feat(M4-013,M5-001,M5-002,M5-003): routing e2e tests, agent config loading, model+agent switching

- M4-013: Add routing-e2e.test.ts with 9 integration tests covering the full
  classify → match rules → routing decision pipeline; includes coding→Opus,
  summarization→GLM-5, conversation→Sonnet, cheap-tier→Haiku, /model bypass,
  unhealthy-provider fallback, and research→Codex scenarios

- M5-001: Store resolvedAgentName during session creation when agentConfigId
  is provided; expose agentName on AgentSession and SessionInfoDto; emit
  agentName in session:info from chat.gateway.ts (message handler and
  set:thinking handler); preserve userId and conversationHistory in merged
  options so they are not lost when agent config is applied

- M5-002: Add AgentService.updateSessionModel() to update live session
  modelId metadata; wire it into ChatGateway.setModelOverride() so the
  /model command immediately reflects in session:info; add
  ChatGateway.broadcastSessionInfo() to push updated session:info to all
  clients watching a conversation on model or agent switch

- M5-003: Implement /agent <name> command end-to-end: inject Brain into
  CommandExecutorService; replace stub handleAgent() with real
  brain.agents.findByName() + findById() lookup; call
  agentService.applyAgentConfig() to update live session; emit session:info
  via chatGateway.broadcastSessionInfo(); update tests to mock brain and
  agentService.applyAgentConfig; add AgentService.applyAgentConfig() method

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

.woodpecker/ci.yml

@@ -44,30 +44,18 @@ steps:
 
   test:
     image: *node_image
-    environment:
-      DATABASE_URL: postgresql://mosaic:mosaic@postgres:5432/mosaic
     commands:
       - *enable_pnpm
-      # Install postgresql-client for pg_isready
-      - apk add --no-cache postgresql-client
-      # Wait up to 30s for postgres to be ready
-      - |
-        for i in $(seq 1 30); do
-          pg_isready -h postgres -p 5432 -U mosaic && break
-          echo "Waiting for postgres ($i/30)..."
-          sleep 1
-        done
-      # Run migrations (DATABASE_URL is set in environment above)
-      - pnpm --filter @mosaic/db run db:migrate
-      # Run all tests
       - pnpm test
     depends_on:
       - typecheck
 
-services:
+  build:
-  postgres:
+    image: *node_image
-    image: pgvector/pgvector:pg17
+    commands:
-    environment:
+      - *enable_pnpm
-      POSTGRES_USER: mosaic
+      - pnpm build
-      POSTGRES_PASSWORD: mosaic
+    depends_on:
-      POSTGRES_DB: mosaic
+      - lint
+      - format
+      - test

.woodpecker/publish.yml

@@ -1,97 +0,0 @@
-# Build, publish npm packages, and push Docker images
-# Runs only on main branch push/tag
-
-variables:
-  - &node_image 'node:22-alpine'
-  - &enable_pnpm 'corepack enable'
-
-when:
-  - branch: [main]
-    event: [push, manual, tag]
-
-steps:
-  install:
-    image: *node_image
-    commands:
-      - corepack enable
-      - pnpm install --frozen-lockfile
-
-  build:
-    image: *node_image
-    commands:
-      - *enable_pnpm
-      - pnpm build
-    depends_on:
-      - install
-
-  publish-npm:
-    image: *node_image
-    environment:
-      NPM_TOKEN:
-        from_secret: gitea_token
-    commands:
-      - *enable_pnpm
-      # Configure auth for Gitea npm registry
-      - |
-        echo "//git.mosaicstack.dev/api/packages/mosaic/npm/:_authToken=$NPM_TOKEN" > ~/.npmrc
-        echo "@mosaic:registry=https://git.mosaicstack.dev/api/packages/mosaic/npm/" >> ~/.npmrc
-      # Publish all non-private packages (--no-git-checks skips dirty/branch checks in CI)
-      # --filter excludes private apps (gateway, web) and the root
-      - >
-        pnpm --filter "@mosaic/*"
-        --filter "!@mosaic/gateway"
-        --filter "!@mosaic/web"
-        publish --no-git-checks --access public
-        || echo "[publish] Some packages may already exist at this version — continuing"
-    depends_on:
-      - build
-
-  build-gateway:
-    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/mosaic/mosaic-stack/gateway:sha-${CI_COMMIT_SHA:0:7}"
-        if [ "$CI_COMMIT_BRANCH" = "main" ]; then
-          DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaic/mosaic-stack/gateway:latest"
-        fi
-        if [ -n "$CI_COMMIT_TAG" ]; then
-          DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaic/mosaic-stack/gateway:$CI_COMMIT_TAG"
-        fi
-        /kaniko/executor --context . --dockerfile docker/gateway.Dockerfile $DESTINATIONS
-    depends_on:
-      - build
-
-  build-web:
-    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/mosaic/mosaic-stack/web:sha-${CI_COMMIT_SHA:0:7}"
-        if [ "$CI_COMMIT_BRANCH" = "main" ]; then
-          DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaic/mosaic-stack/web:latest"
-        fi
-        if [ -n "$CI_COMMIT_TAG" ]; then
-          DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaic/mosaic-stack/web:$CI_COMMIT_TAG"
-        fi
-        /kaniko/executor --context . --dockerfile docker/web.Dockerfile $DESTINATIONS
-    depends_on:
-      - build

README.md

@@ -1,244 +0,0 @@
-# Mosaic Stack
-
-Self-hosted, multi-user AI agent platform. One config, every runtime, same standards.
-
-Mosaic gives you a unified launcher for Claude Code, Codex, OpenCode, and Pi — injecting consistent system prompts, guardrails, skills, and mission context into every session. A NestJS gateway provides the API surface, a Next.js dashboard gives you the UI, and a plugin system connects Discord, Telegram, and more.
-
-## Quick Install
-
-```bash
-bash <(curl -fsSL https://git.mosaicstack.dev/mosaic/mosaic-stack/raw/branch/main/tools/install.sh)
-```
-
-This installs both components:
-
-| Component       | What                                                  | Where                |
-| --------------- | ----------------------------------------------------- | -------------------- |
-| **Framework**   | Bash launcher, guides, runtime configs, tools, skills | `~/.config/mosaic/`  |
-| **@mosaic/cli** | TUI, gateway client, wizard, auto-updater             | `~/.npm-global/bin/` |
-
-After install, set up your agent identity:
-
-```bash
-mosaic init          # Interactive wizard
-```
-
-### Requirements
-
-- Node.js ≥ 20
-- npm (for global @mosaic/cli install)
-- One or more runtimes: [Claude Code](https://docs.anthropic.com/en/docs/claude-code), [Codex](https://github.com/openai/codex), [OpenCode](https://opencode.ai), or [Pi](https://github.com/mariozechner/pi-coding-agent)
-
-## Usage
-
-### Launching Agent Sessions
-
-```bash
-mosaic pi                    # Launch Pi with Mosaic injection
-mosaic claude                # Launch Claude Code with Mosaic injection
-mosaic codex                 # Launch Codex with Mosaic injection
-mosaic opencode              # Launch OpenCode with Mosaic injection
-
-mosaic yolo claude           # Claude with dangerous-permissions mode
-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.
-
-### TUI & Gateway
-
-```bash
-mosaic tui                   # Interactive TUI connected to the gateway
-mosaic login                 # Authenticate with a gateway instance
-mosaic sessions list         # List active agent sessions
-```
-
-### Management
-
-```bash
-mosaic doctor                # Health audit — detect drift and missing files
-mosaic sync                  # Sync skills from canonical source
-mosaic update                # Check for and install CLI updates
-mosaic wizard                # Full guided setup wizard
-mosaic bootstrap <path>      # Bootstrap a repo with Mosaic standards
-mosaic coord init            # Initialize a new orchestration mission
-mosaic prdy init             # Create a PRD via guided session
-```
-
-## Development
-
-### Prerequisites
-
-- Node.js ≥ 20
-- pnpm 10.6+
-- Docker & Docker Compose
-
-### Setup
-
-```bash
-git clone git@git.mosaicstack.dev:mosaic/mosaic-stack.git
-cd mosaic-stack
-
-# Start infrastructure (Postgres, Valkey, Jaeger)
-docker compose up -d
-
-# Install dependencies
-pnpm install
-
-# Run migrations
-pnpm --filter @mosaic/db run db:migrate
-
-# Start all services in dev mode
-pnpm dev
-```
-
-### Infrastructure
-
-Docker Compose provides:
-
-| Service               | Port      | Purpose                |
-| --------------------- | --------- | ---------------------- |
-| PostgreSQL (pgvector) | 5433      | Primary database       |
-| Valkey                | 6380      | Task queue + caching   |
-| Jaeger                | 16686     | Distributed tracing UI |
-| OTEL Collector        | 4317/4318 | Telemetry ingestion    |
-
-### Quality Gates
-
-```bash
-pnpm typecheck               # TypeScript type checking (all packages)
-pnpm lint                    # ESLint (all packages)
-pnpm test                    # Vitest (all packages)
-pnpm format:check            # Prettier check
-pnpm format                  # Prettier auto-fix
-```
-
-### CI
-
-Woodpecker CI runs on every push:
-
-- `pnpm install --frozen-lockfile`
-- Database migration against a fresh Postgres
-- `pnpm test` (Turbo-orchestrated across all packages)
-
-npm packages are published to the Gitea package registry on main merges.
-
-## Architecture
-
-```
-mosaic-stack/
-├── apps/
-│   ├── gateway/             NestJS API + WebSocket hub (Fastify, Socket.IO, OTEL)
-│   └── web/                 Next.js dashboard (React 19, Tailwind)
-├── packages/
-│   ├── cli/                 Mosaic CLI — TUI, gateway client, wizard
-│   ├── mosaic/              Framework — wizard, runtime detection, update checker
-│   ├── types/               Shared TypeScript contracts (Socket.IO typed events)
-│   ├── db/                  Drizzle ORM schema + migrations (pgvector)
-│   ├── auth/                BetterAuth configuration
-│   ├── brain/               Data layer (PG-backed)
-│   ├── queue/               Valkey task queue + MCP
-│   ├── coord/               Mission coordination
-│   ├── forge/               Multi-stage AI pipeline (intake → board → plan → code → review)
-│   ├── macp/                MACP protocol — credential resolution, gate runner, events
-│   ├── agent/               Agent session management
-│   ├── memory/              Agent memory layer
-│   ├── log/                 Structured logging
-│   ├── prdy/                PRD creation and validation
-│   ├── quality-rails/       Quality templates (TypeScript, Next.js, monorepo)
-│   └── design-tokens/       Shared design tokens
-├── plugins/
-│   ├── discord/             Discord channel plugin (discord.js)
-│   ├── telegram/            Telegram channel plugin (Telegraf)
-│   ├── macp/                OpenClaw MACP runtime plugin
-│   └── mosaic-framework/    OpenClaw framework injection plugin
-├── tools/
-│   └── install.sh           Unified installer (framework + npm CLI)
-├── scripts/agent/           Agent session lifecycle scripts
-├── docker-compose.yml       Dev infrastructure
-└── .woodpecker/             CI pipeline configs
-```
-
-### Key Design Decisions
-
-- **Gateway is the single API surface** — all clients (TUI, web, Discord, Telegram) connect through it
-- **ESM everywhere** — `"type": "module"`, `.js` extensions in imports, NodeNext resolution
-- **Socket.IO typed events** — defined in `@mosaic/types`, enforced at compile time
-- **OTEL auto-instrumentation** — loads before NestJS bootstrap
-- **Explicit `@Inject()` decorators** — required since tsx/esbuild doesn't emit decorator metadata
-
-### Framework (`~/.config/mosaic/`)
-
-The framework is the bash-based standards layer installed to every developer machine:
-
-```
-~/.config/mosaic/
-├── AGENTS.md              ← Central standards (loaded into every runtime)
-├── SOUL.md                ← Agent identity (name, style, guardrails)
-├── USER.md                ← User profile (name, timezone, preferences)
-├── TOOLS.md               ← Machine-level tool reference
-├── bin/mosaic             ← Unified launcher (claude, codex, opencode, pi, yolo)
-├── guides/                ← E2E delivery, orchestrator protocol, PRD, etc.
-├── runtime/               ← Per-runtime configs (claude/, codex/, opencode/, pi/)
-├── skills/                ← Universal skills (synced from agent-skills repo)
-├── tools/                 ← Tool suites (orchestrator, git, quality, prdy, etc.)
-└── memory/                ← Persistent agent memory (preserved across upgrades)
-```
-
-### Forge Pipeline
-
-Forge is a multi-stage AI pipeline for autonomous feature delivery:
-
-```
-Intake → Discovery → Board Review → Planning (3 stages) → Coding → Review → Remediation → Test → Deploy
-```
-
-Each stage has a dispatch mode (`exec` for research/review, `yolo` for coding), quality gates, and timeouts. The board review uses multiple AI personas (CEO, CTO, CFO, COO + specialists) to evaluate briefs before committing resources.
-
-## Upgrading
-
-Run the installer again — it handles upgrades automatically:
-
-```bash
-bash <(curl -fsSL https://git.mosaicstack.dev/mosaic/mosaic-stack/raw/branch/main/tools/install.sh)
-```
-
-Or use the CLI:
-
-```bash
-mosaic update                # Check + install CLI updates
-mosaic update --check        # Check only, don't install
-```
-
-The CLI also performs a background update check on every invocation (cached for 1 hour).
-
-### Installer Flags
-
-```bash
-bash tools/install.sh --check        # Version check only
-bash tools/install.sh --framework    # Framework only (skip npm CLI)
-bash tools/install.sh --cli          # npm CLI only (skip framework)
-bash tools/install.sh --ref v1.0     # Install from a specific git ref
-```
-
-## Contributing
-
-```bash
-# Create a feature branch
-git checkout -b feat/my-feature
-
-# Make changes, then verify
-pnpm typecheck && pnpm lint && pnpm test && pnpm format:check
-
-# Commit (husky runs lint-staged automatically)
-git commit -m "feat: description of change"
-
-# Push and create PR
-git push -u origin feat/my-feature
-```
-
-DTOs go in `*.dto.ts` files at module boundaries. Scratchpads (`docs/scratchpads/`) are mandatory for non-trivial tasks. See `AGENTS.md` for the full standards reference.
-
-## License
-
-Proprietary — all rights reserved.

apps/gateway/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/gateway",
-  "version": "0.0.2",
+  "version": "0.0.0",
   "private": true,
   "type": "module",
   "main": "dist/main.js",
@@ -19,14 +19,12 @@
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@mosaic/auth": "workspace:^",
     "@mosaic/brain": "workspace:^",
-    "@mosaic/config": "workspace:^",
     "@mosaic/coord": "workspace:^",
     "@mosaic/db": "workspace:^",
     "@mosaic/discord-plugin": "workspace:^",
     "@mosaic/log": "workspace:^",
     "@mosaic/memory": "workspace:^",
     "@mosaic/queue": "workspace:^",
-    "@mosaic/storage": "workspace:^",
     "@mosaic/telegram-plugin": "workspace:^",
     "@mosaic/types": "workspace:^",
     "@nestjs/common": "^11.0.0",
@@ -44,7 +42,6 @@
     "@opentelemetry/semantic-conventions": "^1.40.0",
     "@sinclair/typebox": "^0.34.48",
     "better-auth": "^1.5.5",
-    "bullmq": "^5.71.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.15.1",
     "dotenv": "^17.3.1",

apps/gateway/src/__tests__/session-hardening.test.ts

@@ -1,377 +0,0 @@
-/**
- * M5-008: Session hardening verification tests.
- *
- * Verifies:
- * 1. /model command switches model → session:info reflects updated modelId
- * 2. /agent command switches agent config → system prompt / agentName changes
- * 3. Session resume binds to a conversation (history injected via conversationHistory option)
- * 4. Session metrics track token usage and message count correctly
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type {
-  AgentSession,
-  AgentSessionOptions,
-  ConversationHistoryMessage,
-} from '../agent/agent.service.js';
-import type { SessionInfoDto, SessionMetrics, SessionTokenMetrics } from '../agent/session.dto.js';
-
-// ---------------------------------------------------------------------------
-// Helpers — minimal AgentSession fixture
-// ---------------------------------------------------------------------------
-
-function makeMetrics(overrides?: Partial<SessionMetrics>): SessionMetrics {
-  return {
-    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    modelSwitches: 0,
-    messageCount: 0,
-    lastActivityAt: new Date().toISOString(),
-    ...overrides,
-  };
-}
-
-function makeSession(overrides?: Partial<AgentSession>): AgentSession {
-  return {
-    id: 'session-001',
-    provider: 'anthropic',
-    modelId: 'claude-3-5-sonnet-20241022',
-    piSession: {} as AgentSession['piSession'],
-    listeners: new Set(),
-    unsubscribe: vi.fn(),
-    createdAt: Date.now(),
-    promptCount: 0,
-    channels: new Set(),
-    skillPromptAdditions: [],
-    sandboxDir: '/tmp',
-    allowedTools: null,
-    metrics: makeMetrics(),
-    ...overrides,
-  };
-}
-
-function sessionToInfo(session: AgentSession): SessionInfoDto {
-  return {
-    id: session.id,
-    provider: session.provider,
-    modelId: session.modelId,
-    ...(session.agentName ? { agentName: session.agentName } : {}),
-    createdAt: new Date(session.createdAt).toISOString(),
-    promptCount: session.promptCount,
-    channels: Array.from(session.channels),
-    durationMs: Date.now() - session.createdAt,
-    metrics: { ...session.metrics },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Replicated AgentService methods (tested in isolation without full DI setup)
-// ---------------------------------------------------------------------------
-
-function updateSessionModel(session: AgentSession, modelId: string): void {
-  session.modelId = modelId;
-  session.metrics.modelSwitches += 1;
-  session.metrics.lastActivityAt = new Date().toISOString();
-}
-
-function applyAgentConfig(
-  session: AgentSession,
-  agentConfigId: string,
-  agentName: string,
-  modelId?: string,
-): void {
-  session.agentConfigId = agentConfigId;
-  session.agentName = agentName;
-  if (modelId) {
-    updateSessionModel(session, modelId);
-  }
-}
-
-function recordTokenUsage(session: AgentSession, tokens: SessionTokenMetrics): void {
-  session.metrics.tokens.input += tokens.input;
-  session.metrics.tokens.output += tokens.output;
-  session.metrics.tokens.cacheRead += tokens.cacheRead;
-  session.metrics.tokens.cacheWrite += tokens.cacheWrite;
-  session.metrics.tokens.total += tokens.total;
-  session.metrics.lastActivityAt = new Date().toISOString();
-}
-
-function recordMessage(session: AgentSession): void {
-  session.metrics.messageCount += 1;
-  session.metrics.lastActivityAt = new Date().toISOString();
-}
-
-// ---------------------------------------------------------------------------
-// 1. /model command — switches model → session:info updated
-// ---------------------------------------------------------------------------
-
-describe('/model command — model switch reflected in session:info', () => {
-  let session: AgentSession;
-
-  beforeEach(() => {
-    session = makeSession();
-  });
-
-  it('updates modelId when /model is called with a model name', () => {
-    updateSessionModel(session, 'claude-opus-4-5-20251001');
-
-    expect(session.modelId).toBe('claude-opus-4-5-20251001');
-  });
-
-  it('increments modelSwitches metric after /model command', () => {
-    expect(session.metrics.modelSwitches).toBe(0);
-
-    updateSessionModel(session, 'gpt-4o');
-    expect(session.metrics.modelSwitches).toBe(1);
-
-    updateSessionModel(session, 'claude-3-5-sonnet-20241022');
-    expect(session.metrics.modelSwitches).toBe(2);
-  });
-
-  it('session:info DTO reflects the new modelId after switch', () => {
-    updateSessionModel(session, 'claude-haiku-3-5-20251001');
-
-    const info = sessionToInfo(session);
-
-    expect(info.modelId).toBe('claude-haiku-3-5-20251001');
-    expect(info.metrics.modelSwitches).toBe(1);
-  });
-
-  it('lastActivityAt is updated after model switch', () => {
-    const before = session.metrics.lastActivityAt;
-    // Ensure at least 1ms passes
-    vi.setSystemTime(Date.now() + 1);
-    updateSessionModel(session, 'new-model');
-    vi.useRealTimers();
-
-    expect(session.metrics.lastActivityAt).not.toBe(before);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 2. /agent command — switches agent config → system prompt / agentName updated
-// ---------------------------------------------------------------------------
-
-describe('/agent command — agent config applied to session', () => {
-  let session: AgentSession;
-
-  beforeEach(() => {
-    session = makeSession();
-  });
-
-  it('sets agentConfigId and agentName on the session', () => {
-    applyAgentConfig(session, 'agent-uuid-001', 'CodeReviewer');
-
-    expect(session.agentConfigId).toBe('agent-uuid-001');
-    expect(session.agentName).toBe('CodeReviewer');
-  });
-
-  it('also updates modelId when agent config carries a model', () => {
-    applyAgentConfig(session, 'agent-uuid-002', 'DataAnalyst', 'gpt-4o-mini');
-
-    expect(session.agentName).toBe('DataAnalyst');
-    expect(session.modelId).toBe('gpt-4o-mini');
-    expect(session.metrics.modelSwitches).toBe(1);
-  });
-
-  it('does NOT update modelId when agent config has no model', () => {
-    const originalModel = session.modelId;
-    applyAgentConfig(session, 'agent-uuid-003', 'Planner', undefined);
-
-    expect(session.modelId).toBe(originalModel);
-    expect(session.metrics.modelSwitches).toBe(0);
-  });
-
-  it('session:info DTO reflects agentName after /agent switch', () => {
-    applyAgentConfig(session, 'agent-uuid-004', 'DevBot');
-
-    const info = sessionToInfo(session);
-
-    expect(info.agentName).toBe('DevBot');
-  });
-
-  it('multiple /agent calls update to the latest agent', () => {
-    applyAgentConfig(session, 'agent-001', 'FirstAgent');
-    applyAgentConfig(session, 'agent-002', 'SecondAgent');
-
-    expect(session.agentConfigId).toBe('agent-002');
-    expect(session.agentName).toBe('SecondAgent');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 3. Session resume — binds to conversation via conversationHistory
-// ---------------------------------------------------------------------------
-
-describe('Session resume — binds to conversation', () => {
-  it('conversationHistory option is preserved in session options', () => {
-    const history: ConversationHistoryMessage[] = [
-      {
-        role: 'user',
-        content: 'Hello, what is TypeScript?',
-        createdAt: new Date('2026-01-01T00:01:00Z'),
-      },
-      {
-        role: 'assistant',
-        content: 'TypeScript is a typed superset of JavaScript.',
-        createdAt: new Date('2026-01-01T00:01:05Z'),
-      },
-    ];
-
-    const options: AgentSessionOptions = {
-      conversationHistory: history,
-      provider: 'anthropic',
-      modelId: 'claude-3-5-sonnet-20241022',
-    };
-
-    expect(options.conversationHistory).toHaveLength(2);
-    expect(options.conversationHistory![0]!.role).toBe('user');
-    expect(options.conversationHistory![1]!.role).toBe('assistant');
-  });
-
-  it('session with conversationHistory option carries the conversation binding', () => {
-    const CONV_ID = 'conv-resume-001';
-    const history: ConversationHistoryMessage[] = [
-      { role: 'user', content: 'Prior question', createdAt: new Date('2026-01-01T00:01:00Z') },
-    ];
-
-    // Simulate what ChatGateway does: pass conversationId + history to createSession
-    const options: AgentSessionOptions = {
-      conversationHistory: history,
-    };
-
-    // The session ID is the conversationId in the gateway
-    const session = makeSession({ id: CONV_ID });
-
-    expect(session.id).toBe(CONV_ID);
-    expect(options.conversationHistory).toHaveLength(1);
-  });
-
-  it('empty conversationHistory is valid (new conversation)', () => {
-    const options: AgentSessionOptions = {
-      conversationHistory: [],
-    };
-
-    expect(options.conversationHistory).toHaveLength(0);
-  });
-
-  it('resumed session preserves all message roles', () => {
-    const history: ConversationHistoryMessage[] = [
-      { role: 'system', content: 'You are a helpful assistant.', createdAt: new Date() },
-      { role: 'user', content: 'Question 1', createdAt: new Date() },
-      { role: 'assistant', content: 'Answer 1', createdAt: new Date() },
-      { role: 'user', content: 'Question 2', createdAt: new Date() },
-    ];
-
-    const roles = history.map((m) => m.role);
-    expect(roles).toEqual(['system', 'user', 'assistant', 'user']);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 4. Session metrics — token usage and message count
-// ---------------------------------------------------------------------------
-
-describe('Session metrics — token usage and message count', () => {
-  let session: AgentSession;
-
-  beforeEach(() => {
-    session = makeSession();
-  });
-
-  it('starts with zero metrics', () => {
-    expect(session.metrics.tokens.input).toBe(0);
-    expect(session.metrics.tokens.output).toBe(0);
-    expect(session.metrics.tokens.total).toBe(0);
-    expect(session.metrics.messageCount).toBe(0);
-    expect(session.metrics.modelSwitches).toBe(0);
-  });
-
-  it('accumulates token usage across multiple turns', () => {
-    recordTokenUsage(session, {
-      input: 100,
-      output: 50,
-      cacheRead: 0,
-      cacheWrite: 0,
-      total: 150,
-    });
-    recordTokenUsage(session, {
-      input: 200,
-      output: 80,
-      cacheRead: 10,
-      cacheWrite: 5,
-      total: 295,
-    });
-
-    expect(session.metrics.tokens.input).toBe(300);
-    expect(session.metrics.tokens.output).toBe(130);
-    expect(session.metrics.tokens.cacheRead).toBe(10);
-    expect(session.metrics.tokens.cacheWrite).toBe(5);
-    expect(session.metrics.tokens.total).toBe(445);
-  });
-
-  it('increments message count with each recordMessage call', () => {
-    expect(session.metrics.messageCount).toBe(0);
-
-    recordMessage(session);
-    expect(session.metrics.messageCount).toBe(1);
-
-    recordMessage(session);
-    recordMessage(session);
-    expect(session.metrics.messageCount).toBe(3);
-  });
-
-  it('session:info DTO exposes correct metrics snapshot', () => {
-    recordTokenUsage(session, {
-      input: 500,
-      output: 100,
-      cacheRead: 20,
-      cacheWrite: 10,
-      total: 630,
-    });
-    recordMessage(session);
-    recordMessage(session);
-    updateSessionModel(session, 'claude-haiku-3-5-20251001');
-
-    const info = sessionToInfo(session);
-
-    expect(info.metrics.tokens.input).toBe(500);
-    expect(info.metrics.tokens.output).toBe(100);
-    expect(info.metrics.tokens.total).toBe(630);
-    expect(info.metrics.messageCount).toBe(2);
-    expect(info.metrics.modelSwitches).toBe(1);
-  });
-
-  it('metrics are independent per session', () => {
-    const sessionA = makeSession({ id: 'session-A' });
-    const sessionB = makeSession({ id: 'session-B' });
-
-    recordTokenUsage(sessionA, { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, total: 150 });
-    recordMessage(sessionA);
-
-    // Session B should remain at zero
-    expect(sessionB.metrics.tokens.input).toBe(0);
-    expect(sessionB.metrics.messageCount).toBe(0);
-
-    // Session A should have updated values
-    expect(sessionA.metrics.tokens.input).toBe(100);
-    expect(sessionA.metrics.messageCount).toBe(1);
-  });
-
-  it('lastActivityAt is updated after recording tokens', () => {
-    const before = session.metrics.lastActivityAt;
-    vi.setSystemTime(new Date(Date.now() + 100));
-    recordTokenUsage(session, { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, total: 15 });
-    vi.useRealTimers();
-
-    expect(session.metrics.lastActivityAt).not.toBe(before);
-  });
-
-  it('lastActivityAt is updated after recording a message', () => {
-    const before = session.metrics.lastActivityAt;
-    vi.setSystemTime(new Date(Date.now() + 100));
-    recordMessage(session);
-    vi.useRealTimers();
-
-    expect(session.metrics.lastActivityAt).not.toBe(before);
-  });
-});

apps/gateway/src/admin/admin-jobs.controller.ts

@@ -1,128 +0,0 @@
-import {
-  Controller,
-  Get,
-  HttpCode,
-  HttpStatus,
-  Inject,
-  NotFoundException,
-  Optional,
-  Param,
-  Post,
-  Query,
-  UseGuards,
-} from '@nestjs/common';
-import { AdminGuard } from './admin.guard.js';
-import { QueueService } from '../queue/queue.service.js';
-import type { JobDto, JobListDto, JobStatus, QueueListDto } from '../queue/queue-admin.dto.js';
-
-@Controller('api/admin/jobs')
-@UseGuards(AdminGuard)
-export class AdminJobsController {
-  constructor(
-    @Optional()
-    @Inject(QueueService)
-    private readonly queueService: QueueService | null,
-  ) {}
-
-  /**
-   * GET /api/admin/jobs
-   * List jobs across all queues. Optional ?status=active|completed|failed|waiting|delayed
-   */
-  @Get()
-  async listJobs(@Query('status') status?: string): Promise<JobListDto> {
-    if (!this.queueService) {
-      return { jobs: [], total: 0 };
-    }
-
-    const validStatuses: JobStatus[] = ['active', 'completed', 'failed', 'waiting', 'delayed'];
-    const normalised = status as JobStatus | undefined;
-
-    if (normalised && !validStatuses.includes(normalised)) {
-      return { jobs: [], total: 0 };
-    }
-
-    const jobs: JobDto[] = await this.queueService.listJobs(normalised);
-    return { jobs, total: jobs.length };
-  }
-
-  /**
-   * POST /api/admin/jobs/:id/retry
-   * Retry a specific failed job.  The id is "<queue>__<bullmq-job-id>".
-   */
-  @Post(':id/retry')
-  @HttpCode(HttpStatus.OK)
-  async retryJob(@Param('id') id: string): Promise<{ ok: boolean; message: string }> {
-    if (!this.queueService) {
-      throw new NotFoundException('Queue service is not available');
-    }
-
-    const result = await this.queueService.retryJob(id);
-    if (!result.ok) {
-      throw new NotFoundException(result.message);
-    }
-
-    return result;
-  }
-
-  /**
-   * GET /api/admin/jobs/queues
-   * Return status for all managed queues.
-   */
-  @Get('queues')
-  async listQueues(): Promise<QueueListDto> {
-    if (!this.queueService) {
-      return { queues: [] };
-    }
-
-    const health = await this.queueService.getHealthStatus();
-    const queues = Object.entries(health.queues).map(([name, stats]) => ({
-      name,
-      waiting: stats.waiting,
-      active: stats.active,
-      completed: stats.completed,
-      failed: stats.failed,
-      delayed: 0,
-      paused: stats.paused,
-    }));
-
-    return { queues };
-  }
-
-  /**
-   * POST /api/admin/jobs/queues/:name/pause
-   * Pause the named queue.
-   */
-  @Post('queues/:name/pause')
-  @HttpCode(HttpStatus.OK)
-  async pauseQueue(@Param('name') name: string): Promise<{ ok: boolean; message: string }> {
-    if (!this.queueService) {
-      throw new NotFoundException('Queue service is not available');
-    }
-
-    const result = await this.queueService.pauseQueue(name);
-    if (!result.ok) {
-      throw new NotFoundException(result.message);
-    }
-
-    return result;
-  }
-
-  /**
-   * POST /api/admin/jobs/queues/:name/resume
-   * Resume the named queue.
-   */
-  @Post('queues/:name/resume')
-  @HttpCode(HttpStatus.OK)
-  async resumeQueue(@Param('name') name: string): Promise<{ ok: boolean; message: string }> {
-    if (!this.queueService) {
-      throw new NotFoundException('Queue service is not available');
-    }
-
-    const result = await this.queueService.resumeQueue(name);
-    if (!result.ok) {
-      throw new NotFoundException(result.message);
-    }
-
-    return result;
-  }
-}

apps/gateway/src/admin/admin.module.ts

@@ -1,11 +1,10 @@
 import { Module } from '@nestjs/common';
 import { AdminController } from './admin.controller.js';
 import { AdminHealthController } from './admin-health.controller.js';
-import { AdminJobsController } from './admin-jobs.controller.js';
 import { AdminGuard } from './admin.guard.js';
 
 @Module({
-  controllers: [AdminController, AdminHealthController, AdminJobsController],
+  controllers: [AdminController, AdminHealthController],
   providers: [AdminGuard],
 })
 export class AdminModule {}

apps/gateway/src/agent/agent.service.ts

@@ -23,8 +23,7 @@ import { createFileTools } from './tools/file-tools.js';
 import { createGitTools } from './tools/git-tools.js';
 import { createShellTools } from './tools/shell-tools.js';
 import { createWebTools } from './tools/web-tools.js';
-import { createSearchTools } from './tools/search-tools.js';
+import type { SessionInfoDto } from './session.dto.js';
-import type { SessionInfoDto, SessionMetrics } from './session.dto.js';
 import { SystemOverrideService } from '../preferences/system-override.service.js';
 import { PreferencesService } from '../preferences/preferences.service.js';
 import { SessionGCService } from '../gc/session-gc.service.js';
@@ -98,8 +97,6 @@ export interface AgentSession {
   agentConfigId?: string;
   /** Human-readable agent name applied to this session, if any (M5-001). */
   agentName?: string;
-  /** M5-007: per-session metrics. */
-  metrics: SessionMetrics;
 }
 
 @Injectable()
@@ -147,7 +144,6 @@ export class AgentService implements OnModuleDestroy {
       ...createGitTools(sandboxDir),
       ...createShellTools(sandboxDir),
       ...createWebTools(),
-      ...createSearchTools(),
     ];
   }
 
@@ -344,12 +340,6 @@ export class AgentService implements OnModuleDestroy {
       userId: mergedOptions?.userId,
       agentConfigId: mergedOptions?.agentConfigId,
       agentName: resolvedAgentName,
-      metrics: {
-        tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        modelSwitches: 0,
-        messageCount: 0,
-        lastActivityAt: new Date().toISOString(),
-      },
     };
 
     this.sessions.set(sessionId, session);
@@ -477,95 +467,24 @@ export class AgentService implements OnModuleDestroy {
     return this.sessions.get(sessionId);
   }
 
-  listSessions(): SessionInfoDto[] {
-    const now = Date.now();
-    return Array.from(this.sessions.values()).map((s) => ({
-      id: s.id,
-      provider: s.provider,
-      modelId: s.modelId,
-      ...(s.agentName ? { agentName: s.agentName } : {}),
-      createdAt: new Date(s.createdAt).toISOString(),
-      promptCount: s.promptCount,
-      channels: Array.from(s.channels),
-      durationMs: now - s.createdAt,
-      metrics: { ...s.metrics },
-    }));
-  }
-
-  getSessionInfo(sessionId: string): SessionInfoDto | undefined {
-    const s = this.sessions.get(sessionId);
-    if (!s) return undefined;
-    return {
-      id: s.id,
-      provider: s.provider,
-      modelId: s.modelId,
-      ...(s.agentName ? { agentName: s.agentName } : {}),
-      createdAt: new Date(s.createdAt).toISOString(),
-      promptCount: s.promptCount,
-      channels: Array.from(s.channels),
-      durationMs: Date.now() - s.createdAt,
-      metrics: { ...s.metrics },
-    };
-  }
-
-  /**
-   * Record token usage for a session turn (M5-007).
-   * Accumulates tokens across the session lifetime.
-   */
-  recordTokenUsage(
-    sessionId: string,
-    tokens: { input: number; output: number; cacheRead: number; cacheWrite: number; total: number },
-  ): void {
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    session.metrics.tokens.input += tokens.input;
-    session.metrics.tokens.output += tokens.output;
-    session.metrics.tokens.cacheRead += tokens.cacheRead;
-    session.metrics.tokens.cacheWrite += tokens.cacheWrite;
-    session.metrics.tokens.total += tokens.total;
-    session.metrics.lastActivityAt = new Date().toISOString();
-  }
-
-  /**
-   * Record a model switch event for a session (M5-007).
-   */
-  recordModelSwitch(sessionId: string): void {
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    session.metrics.modelSwitches += 1;
-    session.metrics.lastActivityAt = new Date().toISOString();
-  }
-
-  /**
-   * Increment message count for a session (M5-007).
-   */
-  recordMessage(sessionId: string): void {
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    session.metrics.messageCount += 1;
-    session.metrics.lastActivityAt = new Date().toISOString();
-  }
-
   /**
    * Update the model tracked on a live session (M5-002).
-   * This records the model change in the session metadata so subsequent
+   * Records the model change in session metadata so subsequent session:info
-   * session:info emissions reflect the new model.  The Pi session itself is
+   * emissions reflect the new model. The Pi session itself is not reconstructed —
-   * not reconstructed — the model is used on the next createSession call for
+   * the new model takes effect on the next message prompt.
-   * the same conversationId when the session is torn down or a new one is created.
    */
   updateSessionModel(sessionId: string, modelId: string): void {
     const session = this.sessions.get(sessionId);
     if (!session) return;
     const prev = session.modelId;
     session.modelId = modelId;
-    this.recordModelSwitch(sessionId);
     this.logger.log(`Session ${sessionId}: model updated ${prev} → ${modelId} (M5-002)`);
   }
 
   /**
    * Apply a new agent config to a live session mid-conversation (M5-003).
    * Updates agentName, agentConfigId, and modelId on the session object.
-   * System prompt and tools take effect when the next session is created for
+   * System prompt and tools take effect when a new session is created for
    * this conversationId (they are baked in at session creation time).
    */
   applyAgentConfig(
@@ -586,6 +505,35 @@ export class AgentService implements OnModuleDestroy {
     );
   }
 
+  listSessions(): SessionInfoDto[] {
+    const now = Date.now();
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      provider: s.provider,
+      modelId: s.modelId,
+      ...(s.agentName ? { agentName: s.agentName } : {}),
+      createdAt: new Date(s.createdAt).toISOString(),
+      promptCount: s.promptCount,
+      channels: Array.from(s.channels),
+      durationMs: now - s.createdAt,
+    }));
+  }
+
+  getSessionInfo(sessionId: string): SessionInfoDto | undefined {
+    const s = this.sessions.get(sessionId);
+    if (!s) return undefined;
+    return {
+      id: s.id,
+      provider: s.provider,
+      modelId: s.modelId,
+      ...(s.agentName ? { agentName: s.agentName } : {}),
+      createdAt: new Date(s.createdAt).toISOString(),
+      promptCount: s.promptCount,
+      channels: Array.from(s.channels),
+      durationMs: Date.now() - s.createdAt,
+    };
+  }
+
   addChannel(sessionId: string, channel: string): void {
     const session = this.sessions.get(sessionId);
     if (session) {

apps/gateway/src/agent/session.dto.ts

@@ -1,32 +1,13 @@
-/** Token usage metrics for a session (M5-007). */
-export interface SessionTokenMetrics {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite: number;
-  total: number;
-}
-
-/** Per-session metrics tracked throughout the session lifetime (M5-007). */
-export interface SessionMetrics {
-  tokens: SessionTokenMetrics;
-  modelSwitches: number;
-  messageCount: number;
-  lastActivityAt: string;
-}
-
 export interface SessionInfoDto {
   id: string;
   provider: string;
   modelId: string;
-  /** M5-005: human-readable agent name when an agent config is applied. */
+  /** Human-readable agent name when an agent config is applied (M5-001). */
   agentName?: string;
   createdAt: string;
   promptCount: number;
   channels: string[];
   durationMs: number;
-  /** M5-007: per-session metrics (token usage, model switches, etc.) */
-  metrics: SessionMetrics;
 }
 
 export interface SessionListDto {

apps/gateway/src/agent/tools/file-tools.ts

@@ -190,169 +190,5 @@ export function createFileTools(baseDir: string): ToolDefinition[] {
     },
   };
 
-  const editFileTool: ToolDefinition = {
+  return [readFileTool, writeFileTool, listDirectoryTool];
-    name: 'fs_edit_file',
-    label: 'Edit File',
-    description:
-      'Make targeted text replacements in a file. Each edit replaces an exact match of oldText with newText. ' +
-      'All edits are matched against the original file content (not incrementally). ' +
-      'Each oldText must be unique in the file and edits must not overlap.',
-    parameters: Type.Object({
-      path: Type.String({
-        description: 'File path (relative to sandbox base or absolute within it)',
-      }),
-      edits: Type.Array(
-        Type.Object({
-          oldText: Type.String({
-            description: 'Exact text to find and replace (must be unique in the file)',
-          }),
-          newText: Type.String({ description: 'Replacement text' }),
-        }),
-        { description: 'One or more targeted replacements', minItems: 1 },
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      const { path, edits } = params as {
-        path: string;
-        edits: Array<{ oldText: string; newText: string }>;
-      };
-
-      let safePath: string;
-      try {
-        safePath = guardPath(path, baseDir);
-      } catch (err) {
-        if (err instanceof SandboxEscapeError) {
-          return {
-            content: [{ type: 'text' as const, text: `Error: ${err.message}` }],
-            details: undefined,
-          };
-        }
-        return {
-          content: [{ type: 'text' as const, text: `Error: ${String(err)}` }],
-          details: undefined,
-        };
-      }
-
-      try {
-        const info = await stat(safePath);
-        if (!info.isFile()) {
-          return {
-            content: [{ type: 'text' as const, text: `Error: path is not a file: ${path}` }],
-            details: undefined,
-          };
-        }
-        if (info.size > MAX_READ_BYTES) {
-          return {
-            content: [
-              {
-                type: 'text' as const,
-                text: `Error: file too large for editing (${info.size} bytes, limit ${MAX_READ_BYTES} bytes)`,
-              },
-            ],
-            details: undefined,
-          };
-        }
-      } catch (err) {
-        return {
-          content: [{ type: 'text' as const, text: `Error reading file: ${String(err)}` }],
-          details: undefined,
-        };
-      }
-
-      let content: string;
-      try {
-        content = await readFile(safePath, { encoding: 'utf8' });
-      } catch (err) {
-        return {
-          content: [{ type: 'text' as const, text: `Error reading file: ${String(err)}` }],
-          details: undefined,
-        };
-      }
-
-      // Validate all edits before applying any
-      const errors: string[] = [];
-      for (let i = 0; i < edits.length; i++) {
-        const edit = edits[i]!;
-        const occurrences = content.split(edit.oldText).length - 1;
-        if (occurrences === 0) {
-          errors.push(`Edit ${i + 1}: oldText not found in file`);
-        } else if (occurrences > 1) {
-          errors.push(`Edit ${i + 1}: oldText matches ${occurrences} locations (must be unique)`);
-        }
-      }
-
-      // Check for overlapping edits
-      if (errors.length === 0) {
-        const positions = edits.map((edit, i) => ({
-          index: i,
-          start: content.indexOf(edit.oldText),
-          end: content.indexOf(edit.oldText) + edit.oldText.length,
-        }));
-        positions.sort((a, b) => a.start - b.start);
-        for (let i = 1; i < positions.length; i++) {
-          if (positions[i]!.start < positions[i - 1]!.end) {
-            errors.push(
-              `Edits ${positions[i - 1]!.index + 1} and ${positions[i]!.index + 1} overlap`,
-            );
-          }
-        }
-      }
-
-      if (errors.length > 0) {
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Edit validation failed:\n${errors.join('\n')}`,
-            },
-          ],
-          details: undefined,
-        };
-      }
-
-      // Apply edits: process from end to start to preserve positions
-      const positions = edits.map((edit) => ({
-        edit,
-        start: content.indexOf(edit.oldText),
-      }));
-      positions.sort((a, b) => b.start - a.start); // reverse order
-
-      let result = content;
-      for (const { edit } of positions) {
-        result = result.replace(edit.oldText, edit.newText);
-      }
-
-      if (Buffer.byteLength(result, 'utf8') > MAX_WRITE_BYTES) {
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Error: resulting file too large (limit ${MAX_WRITE_BYTES} bytes)`,
-            },
-          ],
-          details: undefined,
-        };
-      }
-
-      try {
-        await writeFile(safePath, result, { encoding: 'utf8' });
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `File edited successfully: ${path} (${edits.length} edit(s) applied)`,
-            },
-          ],
-          details: undefined,
-        };
-      } catch (err) {
-        return {
-          content: [{ type: 'text' as const, text: `Error writing file: ${String(err)}` }],
-          details: undefined,
-        };
-      }
-    },
-  };
-
-  return [readFileTool, writeFileTool, listDirectoryTool, editFileTool];
 }

apps/gateway/src/agent/tools/index.ts

@@ -2,7 +2,6 @@ export { createBrainTools } from './brain-tools.js';
 export { createCoordTools } from './coord-tools.js';
 export { createFileTools } from './file-tools.js';
 export { createGitTools } from './git-tools.js';
-export { createSearchTools } from './search-tools.js';
 export { createShellTools } from './shell-tools.js';
 export { createWebTools } from './web-tools.js';
 export { createSkillTools } from './skill-tools.js';

apps/gateway/src/agent/tools/search-tools.ts

@@ -1,496 +0,0 @@
-import { Type } from '@sinclair/typebox';
-import type { ToolDefinition } from '@mariozechner/pi-coding-agent';
-
-const DEFAULT_TIMEOUT_MS = 15_000;
-const MAX_RESULTS = 10;
-const MAX_RESPONSE_BYTES = 256 * 1024; // 256 KB
-
-// ─── Provider helpers ────────────────────────────────────────────────────────
-
-interface SearchResult {
-  title: string;
-  url: string;
-  snippet: string;
-}
-
-interface SearchResponse {
-  provider: string;
-  query: string;
-  results: SearchResult[];
-  error?: string;
-}
-
-async function fetchWithTimeout(
-  url: string,
-  init: RequestInit,
-  timeoutMs: number,
-): Promise<Response> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { ...init, signal: controller.signal });
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function readLimited(response: Response): Promise<string> {
-  const reader = response.body?.getReader();
-  if (!reader) return '';
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    total += value.length;
-    if (total > MAX_RESPONSE_BYTES) {
-      chunks.push(value.subarray(0, MAX_RESPONSE_BYTES - (total - value.length)));
-      reader.cancel();
-      break;
-    }
-    chunks.push(value);
-  }
-  const combined = new Uint8Array(chunks.reduce((a, c) => a + c.length, 0));
-  let offset = 0;
-  for (const chunk of chunks) {
-    combined.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return new TextDecoder().decode(combined);
-}
-
-// ─── Brave Search ────────────────────────────────────────────────────────────
-
-async function searchBrave(query: string, limit: number): Promise<SearchResponse> {
-  const apiKey = process.env['BRAVE_API_KEY'];
-  if (!apiKey) return { provider: 'brave', query, results: [], error: 'BRAVE_API_KEY not set' };
-
-  try {
-    const params = new URLSearchParams({
-      q: query,
-      count: String(Math.min(limit, 20)),
-    });
-    const res = await fetchWithTimeout(
-      `https://api.search.brave.com/res/v1/web/search?${params}`,
-      { headers: { 'X-Subscription-Token': apiKey, Accept: 'application/json' } },
-      DEFAULT_TIMEOUT_MS,
-    );
-    if (!res.ok) {
-      const body = await res.text().catch(() => '');
-      return { provider: 'brave', query, results: [], error: `HTTP ${res.status}: ${body}` };
-    }
-    const data = (await res.json()) as {
-      web?: { results?: Array<{ title: string; url: string; description: string }> };
-    };
-    const results: SearchResult[] = (data.web?.results ?? []).slice(0, limit).map((r) => ({
-      title: r.title,
-      url: r.url,
-      snippet: r.description,
-    }));
-    return { provider: 'brave', query, results };
-  } catch (err) {
-    return {
-      provider: 'brave',
-      query,
-      results: [],
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-// ─── Tavily Search ───────────────────────────────────────────────────────────
-
-async function searchTavily(query: string, limit: number): Promise<SearchResponse> {
-  const apiKey = process.env['TAVILY_API_KEY'];
-  if (!apiKey) return { provider: 'tavily', query, results: [], error: 'TAVILY_API_KEY not set' };
-
-  try {
-    const res = await fetchWithTimeout(
-      'https://api.tavily.com/search',
-      {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          api_key: apiKey,
-          query,
-          max_results: Math.min(limit, 10),
-          include_answer: false,
-        }),
-      },
-      DEFAULT_TIMEOUT_MS,
-    );
-    if (!res.ok) {
-      const body = await res.text().catch(() => '');
-      return { provider: 'tavily', query, results: [], error: `HTTP ${res.status}: ${body}` };
-    }
-    const data = (await res.json()) as {
-      results?: Array<{ title: string; url: string; content: string }>;
-    };
-    const results: SearchResult[] = (data.results ?? []).slice(0, limit).map((r) => ({
-      title: r.title,
-      url: r.url,
-      snippet: r.content,
-    }));
-    return { provider: 'tavily', query, results };
-  } catch (err) {
-    return {
-      provider: 'tavily',
-      query,
-      results: [],
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-// ─── SearXNG (self-hosted) ───────────────────────────────────────────────────
-
-async function searchSearxng(query: string, limit: number): Promise<SearchResponse> {
-  const baseUrl = process.env['SEARXNG_URL'];
-  if (!baseUrl) return { provider: 'searxng', query, results: [], error: 'SEARXNG_URL not set' };
-
-  try {
-    const params = new URLSearchParams({
-      q: query,
-      format: 'json',
-      pageno: '1',
-    });
-    const res = await fetchWithTimeout(
-      `${baseUrl.replace(/\/$/, '')}/search?${params}`,
-      { headers: { Accept: 'application/json' } },
-      DEFAULT_TIMEOUT_MS,
-    );
-    if (!res.ok) {
-      const body = await res.text().catch(() => '');
-      return { provider: 'searxng', query, results: [], error: `HTTP ${res.status}: ${body}` };
-    }
-    const data = (await res.json()) as {
-      results?: Array<{ title: string; url: string; content: string }>;
-    };
-    const results: SearchResult[] = (data.results ?? []).slice(0, limit).map((r) => ({
-      title: r.title,
-      url: r.url,
-      snippet: r.content,
-    }));
-    return { provider: 'searxng', query, results };
-  } catch (err) {
-    return {
-      provider: 'searxng',
-      query,
-      results: [],
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-// ─── DuckDuckGo (lite HTML endpoint) ─────────────────────────────────────────
-
-async function searchDuckDuckGo(query: string, limit: number): Promise<SearchResponse> {
-  try {
-    // Use the DuckDuckGo Instant Answer API (JSON, free, no key)
-    const params = new URLSearchParams({
-      q: query,
-      format: 'json',
-      no_html: '1',
-      skip_disambig: '1',
-    });
-    const res = await fetchWithTimeout(
-      `https://api.duckduckgo.com/?${params}`,
-      { headers: { Accept: 'application/json' } },
-      DEFAULT_TIMEOUT_MS,
-    );
-    if (!res.ok) {
-      return {
-        provider: 'duckduckgo',
-        query,
-        results: [],
-        error: `HTTP ${res.status}`,
-      };
-    }
-    const text = await readLimited(res);
-    const data = JSON.parse(text) as {
-      AbstractText?: string;
-      AbstractURL?: string;
-      AbstractSource?: string;
-      RelatedTopics?: Array<{
-        Text?: string;
-        FirstURL?: string;
-        Result?: string;
-        Topics?: Array<{ Text?: string; FirstURL?: string }>;
-      }>;
-    };
-
-    const results: SearchResult[] = [];
-
-    // Main abstract result
-    if (data.AbstractText && data.AbstractURL) {
-      results.push({
-        title: data.AbstractSource ?? 'DuckDuckGo Abstract',
-        url: data.AbstractURL,
-        snippet: data.AbstractText,
-      });
-    }
-
-    // Related topics
-    for (const topic of data.RelatedTopics ?? []) {
-      if (results.length >= limit) break;
-      if (topic.Text && topic.FirstURL) {
-        results.push({
-          title: topic.Text.slice(0, 120),
-          url: topic.FirstURL,
-          snippet: topic.Text,
-        });
-      }
-      // Sub-topics
-      for (const sub of topic.Topics ?? []) {
-        if (results.length >= limit) break;
-        if (sub.Text && sub.FirstURL) {
-          results.push({
-            title: sub.Text.slice(0, 120),
-            url: sub.FirstURL,
-            snippet: sub.Text,
-          });
-        }
-      }
-    }
-
-    return { provider: 'duckduckgo', query, results: results.slice(0, limit) };
-  } catch (err) {
-    return {
-      provider: 'duckduckgo',
-      query,
-      results: [],
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-// ─── Provider resolution ─────────────────────────────────────────────────────
-
-type SearchProvider = 'brave' | 'tavily' | 'searxng' | 'duckduckgo' | 'auto';
-
-function getAvailableProviders(): SearchProvider[] {
-  const available: SearchProvider[] = [];
-  if (process.env['BRAVE_API_KEY']) available.push('brave');
-  if (process.env['TAVILY_API_KEY']) available.push('tavily');
-  if (process.env['SEARXNG_URL']) available.push('searxng');
-  // DuckDuckGo is always available (no API key needed)
-  available.push('duckduckgo');
-  return available;
-}
-
-async function executeSearch(
-  provider: SearchProvider,
-  query: string,
-  limit: number,
-): Promise<SearchResponse> {
-  switch (provider) {
-    case 'brave':
-      return searchBrave(query, limit);
-    case 'tavily':
-      return searchTavily(query, limit);
-    case 'searxng':
-      return searchSearxng(query, limit);
-    case 'duckduckgo':
-      return searchDuckDuckGo(query, limit);
-    case 'auto': {
-      // Try providers in priority order: Brave > Tavily > SearXNG > DuckDuckGo
-      const available = getAvailableProviders();
-      for (const p of available) {
-        const result = await executeSearch(p, query, limit);
-        if (!result.error && result.results.length > 0) return result;
-      }
-      // Fall back to DuckDuckGo if everything failed
-      return searchDuckDuckGo(query, limit);
-    }
-  }
-}
-
-function formatSearchResults(response: SearchResponse): string {
-  const lines: string[] = [];
-  lines.push(`Search provider: ${response.provider}`);
-  lines.push(`Query: "${response.query}"`);
-
-  if (response.error) {
-    lines.push(`Error: ${response.error}`);
-  }
-
-  if (response.results.length === 0) {
-    lines.push('No results found.');
-  } else {
-    lines.push(`Results (${response.results.length}):\n`);
-    for (let i = 0; i < response.results.length; i++) {
-      const r = response.results[i]!;
-      lines.push(`${i + 1}. ${r.title}`);
-      lines.push(`   URL: ${r.url}`);
-      lines.push(`   ${r.snippet}`);
-      lines.push('');
-    }
-  }
-  return lines.join('\n');
-}
-
-// ─── Tool exports ────────────────────────────────────────────────────────────
-
-export function createSearchTools(): ToolDefinition[] {
-  const webSearch: ToolDefinition = {
-    name: 'web_search',
-    label: 'Web Search',
-    description:
-      'Search the web using configured search providers. ' +
-      'Supports Brave, Tavily, SearXNG, and DuckDuckGo. ' +
-      'Use "auto" provider to pick the best available. ' +
-      'DuckDuckGo is always available as a fallback (no API key needed).',
-    parameters: Type.Object({
-      query: Type.String({ description: 'Search query' }),
-      provider: Type.Optional(
-        Type.String({
-          description:
-            'Search provider: "auto" (default), "brave", "tavily", "searxng", or "duckduckgo"',
-        }),
-      ),
-      limit: Type.Optional(
-        Type.Number({ description: `Max results to return (default 5, max ${MAX_RESULTS})` }),
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      const { query, provider, limit } = params as {
-        query: string;
-        provider?: string;
-        limit?: number;
-      };
-
-      const effectiveProvider = (provider ?? 'auto') as SearchProvider;
-      const validProviders = ['auto', 'brave', 'tavily', 'searxng', 'duckduckgo'];
-      if (!validProviders.includes(effectiveProvider)) {
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Invalid provider "${provider}". Valid: ${validProviders.join(', ')}`,
-            },
-          ],
-          details: undefined,
-        };
-      }
-
-      const effectiveLimit = Math.min(Math.max(limit ?? 5, 1), MAX_RESULTS);
-
-      try {
-        const response = await executeSearch(effectiveProvider, query, effectiveLimit);
-        return {
-          content: [{ type: 'text' as const, text: formatSearchResults(response) }],
-          details: undefined,
-        };
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: 'text' as const,
-              text: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
-            },
-          ],
-          details: undefined,
-        };
-      }
-    },
-  };
-
-  const webSearchNews: ToolDefinition = {
-    name: 'web_search_news',
-    label: 'Web Search (News)',
-    description:
-      'Search for recent news articles. Uses Brave News API if available, falls back to standard search with news keywords.',
-    parameters: Type.Object({
-      query: Type.String({ description: 'News search query' }),
-      limit: Type.Optional(
-        Type.Number({ description: `Max results (default 5, max ${MAX_RESULTS})` }),
-      ),
-    }),
-    async execute(_toolCallId, params) {
-      const { query, limit } = params as { query: string; limit?: number };
-      const effectiveLimit = Math.min(Math.max(limit ?? 5, 1), MAX_RESULTS);
-
-      // Try Brave News API first (dedicated news endpoint)
-      const braveKey = process.env['BRAVE_API_KEY'];
-      if (braveKey) {
-        try {
-          const newsParams = new URLSearchParams({
-            q: query,
-            count: String(effectiveLimit),
-          });
-          const res = await fetchWithTimeout(
-            `https://api.search.brave.com/res/v1/news/search?${newsParams}`,
-            {
-              headers: {
-                'X-Subscription-Token': braveKey,
-                Accept: 'application/json',
-              },
-            },
-            DEFAULT_TIMEOUT_MS,
-          );
-          if (res.ok) {
-            const data = (await res.json()) as {
-              results?: Array<{
-                title: string;
-                url: string;
-                description: string;
-                age?: string;
-              }>;
-            };
-            const results: SearchResult[] = (data.results ?? [])
-              .slice(0, effectiveLimit)
-              .map((r) => ({
-                title: r.title + (r.age ? ` (${r.age})` : ''),
-                url: r.url,
-                snippet: r.description,
-              }));
-            const response: SearchResponse = { provider: 'brave-news', query, results };
-            return {
-              content: [{ type: 'text' as const, text: formatSearchResults(response) }],
-              details: undefined,
-            };
-          }
-        } catch {
-          // Fall through to generic search
-        }
-      }
-
-      // Fallback: standard search with "news" appended
-      const newsQuery = `${query} news latest`;
-      const response = await executeSearch('auto', newsQuery, effectiveLimit);
-      return {
-        content: [{ type: 'text' as const, text: formatSearchResults(response) }],
-        details: undefined,
-      };
-    },
-  };
-
-  const searchProviders: ToolDefinition = {
-    name: 'web_search_providers',
-    label: 'List Search Providers',
-    description: 'List the currently available and configured web search providers.',
-    parameters: Type.Object({}),
-    async execute() {
-      const available = getAvailableProviders();
-      const allProviders = [
-        { name: 'brave', configured: !!process.env['BRAVE_API_KEY'], envVar: 'BRAVE_API_KEY' },
-        { name: 'tavily', configured: !!process.env['TAVILY_API_KEY'], envVar: 'TAVILY_API_KEY' },
-        { name: 'searxng', configured: !!process.env['SEARXNG_URL'], envVar: 'SEARXNG_URL' },
-        { name: 'duckduckgo', configured: true, envVar: '(none — always available)' },
-      ];
-
-      const lines = ['Search providers:\n'];
-      for (const p of allProviders) {
-        const status = p.configured ? '✓ configured' : '✗ not configured';
-        lines.push(`  ${p.name}: ${status} (${p.envVar})`);
-      }
-      lines.push(`\nActive providers for "auto" mode: ${available.join(', ')}`);
-      return {
-        content: [{ type: 'text' as const, text: lines.join('\n') }],
-        details: undefined,
-      };
-    },
-  };
-
-  return [webSearch, webSearchNews, searchProviders];
-}

apps/gateway/src/app.module.ts

@@ -1,7 +1,6 @@
 import { Module } from '@nestjs/common';
 import { APP_GUARD } from '@nestjs/core';
 import { HealthController } from './health/health.controller.js';
-import { ConfigModule } from './config/config.module.js';
 import { DatabaseModule } from './database/database.module.js';
 import { AuthModule } from './auth/auth.module.js';
 import { BrainModule } from './brain/brain.module.js';
@@ -23,13 +22,11 @@ import { PreferencesModule } from './preferences/preferences.module.js';
 import { GCModule } from './gc/gc.module.js';
 import { ReloadModule } from './reload/reload.module.js';
 import { WorkspaceModule } from './workspace/workspace.module.js';
-import { QueueModule } from './queue/queue.module.js';
 import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
 
 @Module({
   imports: [
     ThrottlerModule.forRoot([{ name: 'default', ttl: 60_000, limit: 60 }]),
-    ConfigModule,
     DatabaseModule,
     AuthModule,
     BrainModule,
@@ -49,7 +46,6 @@ import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
     PreferencesModule,
     CommandsModule,
     GCModule,
-    QueueModule,
     ReloadModule,
     WorkspaceModule,
   ],

apps/gateway/src/chat/chat.gateway.ts

@@ -18,7 +18,6 @@ import type {
   SlashCommandPayload,
   SystemReloadPayload,
   RoutingDecisionInfo,
-  AbortPayload,
 } from '@mosaic/types';
 import { AgentService, type ConversationHistoryMessage } from '../agent/agent.service.js';
 import { AUTH } from '../auth/auth.tokens.js';
@@ -120,17 +119,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
         // When resuming an existing conversation, load prior messages to inject as context (M1-004)
         const conversationHistory = await this.loadConversationHistory(conversationId, userId);
 
-        // M5-004: Check if there's an existing sessionId bound to this conversation
-        let existingSessionId: string | undefined;
-        if (userId) {
-          existingSessionId = await this.getConversationSessionId(conversationId, userId);
-          if (existingSessionId) {
-            this.logger.log(
-              `Resuming existing sessionId=${existingSessionId} for conversation=${conversationId}`,
-            );
-          }
-        }
-
         // Determine provider/model via routing engine or per-session /model override (M4-012 / M4-007)
         let resolvedProvider = data.provider;
         let resolvedModelId = data.modelId;
@@ -165,9 +153,7 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
           }
         }
 
-        // M5-004: Use existingSessionId as sessionId when available (session reuse)
+        agentSession = await this.agentService.createSession(conversationId, {
-        const sessionIdToCreate = existingSessionId ?? conversationId;
-        agentSession = await this.agentService.createSession(sessionIdToCreate, {
           provider: resolvedProvider,
           modelId: resolvedModelId,
           agentConfigId: data.agentId,
@@ -194,15 +180,10 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
     }
 
     // Ensure conversation record exists in the DB before persisting messages
-    // M5-004: Also bind the sessionId to the conversation record
     if (userId) {
       await this.ensureConversation(conversationId, userId);
-      await this.bindSessionToConversation(conversationId, userId, conversationId);
     }
 
-    // M5-007: Count the user message
-    this.agentService.recordMessage(conversationId);
-
     // Persist the user message
     if (userId) {
       try {
@@ -253,7 +234,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
     this.agentService.addChannel(conversationId, `websocket:${client.id}`);
 
     // Send session info so the client knows the model/provider (M4-008: include routing decision)
-    // Include agentName when a named agent config is active (M5-001)
     {
       const agentSession = this.agentService.getSession(conversationId);
       if (agentSession) {
@@ -326,38 +306,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
     });
   }
 
-  @SubscribeMessage('abort')
-  async handleAbort(
-    @ConnectedSocket() client: Socket,
-    @MessageBody() data: AbortPayload,
-  ): Promise<void> {
-    const conversationId = data.conversationId;
-    this.logger.log(`Abort requested by ${client.id} for conversation ${conversationId}`);
-
-    const session = this.agentService.getSession(conversationId);
-    if (!session) {
-      client.emit('error', {
-        conversationId,
-        error: 'No active session to abort.',
-      });
-      return;
-    }
-
-    try {
-      await session.piSession.abort();
-      this.logger.log(`Agent session ${conversationId} aborted successfully`);
-    } catch (err) {
-      this.logger.error(
-        `Failed to abort session ${conversationId}`,
-        err instanceof Error ? err.stack : String(err),
-      );
-      client.emit('error', {
-        conversationId,
-        error: 'Failed to abort the agent operation.',
-      });
-    }
-  }
-
   @SubscribeMessage('command:execute')
   async handleCommandExecute(
     @ConnectedSocket() client: Socket,
@@ -377,18 +325,17 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
    * Set a per-conversation model override (M4-007 / M5-002).
    * When set, the routing engine is bypassed and the specified model is used.
    * Pass null to clear the override and resume automatic routing.
-   * M5-005: Emits session:info to clients subscribed to this conversation when a model is set.
+   * M5-002: Also updates the live session's modelId and emits session:info.
-   * M5-007: Records a model switch in session metrics.
    */
   setModelOverride(conversationId: string, modelName: string | null): void {
     if (modelName) {
       modelOverrides.set(conversationId, modelName);
       this.logger.log(`Model override set: conversation=${conversationId} model="${modelName}"`);
 
-      // M5-002: Update the live session's modelId so session:info reflects the new model immediately
+      // M5-002: Update live session model so next session:info reflects the new model
       this.agentService.updateSessionModel(conversationId, modelName);
 
-      // M5-005: Broadcast session:info to all clients subscribed to this conversation
+      // Broadcast updated session:info to all clients watching this conversation
       this.broadcastSessionInfo(conversationId);
     } else {
       modelOverrides.delete(conversationId);
@@ -404,13 +351,10 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
   }
 
   /**
-   * M5-005: Broadcast session:info to all clients currently subscribed to a conversation.
+   * Broadcast session:info to all clients currently subscribed to a conversation (M5-002/M5-003).
    * Called on model or agent switch to ensure the TUI TopBar updates immediately.
    */
-  broadcastSessionInfo(
+  broadcastSessionInfo(conversationId: string, extra?: { agentName?: string }): void {
-    conversationId: string,
-    extra?: { agentName?: string; routingDecision?: RoutingDecisionInfo },
-  ): void {
     const agentSession = this.agentService.getSession(conversationId);
     if (!agentSession) return;
 
@@ -423,7 +367,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
       thinkingLevel: piSession.thinkingLevel,
       availableThinkingLevels: piSession.getAvailableThinkingLevels(),
       ...(resolvedAgentName ? { agentName: resolvedAgentName } : {}),
-      ...(extra?.routingDecision ? { routingDecision: extra.routingDecision } : {}),
     };
 
     // Emit to all clients currently subscribed to this conversation
@@ -459,45 +402,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
     }
   }
 
-  /**
-   * M5-004: Bind the agent sessionId to the conversation record in the DB.
-   * Updates the sessionId column so future resumes can reuse the session.
-   */
-  private async bindSessionToConversation(
-    conversationId: string,
-    userId: string,
-    sessionId: string,
-  ): Promise<void> {
-    try {
-      await this.brain.conversations.update(conversationId, userId, { sessionId });
-    } catch (err) {
-      this.logger.error(
-        `Failed to bind sessionId=${sessionId} to conversation=${conversationId}`,
-        err instanceof Error ? err.stack : String(err),
-      );
-    }
-  }
-
-  /**
-   * M5-004: Retrieve the sessionId bound to a conversation, if any.
-   * Returns undefined when the conversation does not exist or has no bound session.
-   */
-  private async getConversationSessionId(
-    conversationId: string,
-    userId: string,
-  ): Promise<string | undefined> {
-    try {
-      const conv = await this.brain.conversations.findById(conversationId, userId);
-      return conv?.sessionId ?? undefined;
-    } catch (err) {
-      this.logger.error(
-        `Failed to get sessionId for conversation=${conversationId}`,
-        err instanceof Error ? err.stack : String(err),
-      );
-      return undefined;
-    }
-  }
-
   /**
    * Load prior conversation messages from DB for context injection on session resume (M1-004).
    * Returns an empty array when no history exists, the conversation is not owned by the user,
@@ -574,17 +478,6 @@ export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
           usage: usagePayload,
         });
 
-        // M5-007: Accumulate token usage in session metrics
-        if (stats?.tokens) {
-          this.agentService.recordTokenUsage(conversationId, {
-            input: stats.tokens.input ?? 0,
-            output: stats.tokens.output ?? 0,
-            cacheRead: stats.tokens.cacheRead ?? 0,
-            cacheWrite: stats.tokens.cacheWrite ?? 0,
-            total: stats.tokens.total ?? 0,
-          });
-        }
-
         // Persist the assistant message with metadata
         const cs = this.clientSessions.get(client.id);
         const userId = (client.data.user as { id: string } | undefined)?.id;

apps/gateway/src/commands/command-executor-p8012.spec.ts

@@ -42,7 +42,7 @@ const mockRedis = {
 
 // Mock agent config returned by brain.agents.findByName for "my-agent-id"
 const mockAgentConfig = {
-  id: 'my-agent-id',
+  id: 'agent-uuid-123',
   name: 'my-agent-id',
   model: 'claude-sonnet-4-6',
   provider: 'anthropic',
@@ -57,12 +57,11 @@ const mockAgentConfig = {
 
 const mockBrain = {
   agents: {
-    // findByName resolves with the agent when name matches, undefined otherwise
     findByName: vi.fn((name: string) =>
       Promise.resolve(name === 'my-agent-id' ? mockAgentConfig : undefined),
     ),
     findById: vi.fn((id: string) =>
-      Promise.resolve(id === 'my-agent-id' ? mockAgentConfig : undefined),
+      Promise.resolve(id === 'agent-uuid-123' ? mockAgentConfig : undefined),
     ),
     create: vi.fn(),
   },
@@ -82,7 +81,6 @@ function buildService(): CommandExecutorService {
     mockBrain as never,
     null,
     mockChatGateway as never,
-    null,
   );
 }
 

apps/gateway/src/commands/command-executor.service.ts

@@ -7,7 +7,6 @@ import { ChatGateway } from '../chat/chat.gateway.js';
 import { SessionGCService } from '../gc/session-gc.service.js';
 import { SystemOverrideService } from '../preferences/system-override.service.js';
 import { ReloadService } from '../reload/reload.service.js';
-import { McpClientService } from '../mcp-client/mcp-client.service.js';
 import { BRAIN } from '../brain/brain.tokens.js';
 import { COMMANDS_REDIS } from './commands.tokens.js';
 import { CommandRegistryService } from './command-registry.service.js';
@@ -29,9 +28,6 @@ export class CommandExecutorService {
     @Optional()
     @Inject(forwardRef(() => ChatGateway))
     private readonly chatGateway: ChatGateway | null,
-    @Optional()
-    @Inject(McpClientService)
-    private readonly mcpClient: McpClientService | null,
   ) {}
 
   async execute(payload: SlashCommandPayload, userId: string): Promise<SlashCommandResultPayload> {
@@ -109,8 +105,6 @@ export class CommandExecutorService {
           };
         case 'tools':
           return await this.handleTools(conversationId, userId);
-        case 'mcp':
-          return await this.handleMcp(args ?? null, conversationId);
         case 'reload': {
           if (!this.reloadService) {
             return {
@@ -248,14 +242,13 @@ export class CommandExecutorService {
   private async handleAgent(
     args: string | null,
     conversationId: string,
-    userId: string,
+    _userId: string,
   ): Promise<SlashCommandResultPayload> {
     if (!args) {
       return {
         command: 'agent',
         success: true,
-        message:
+        message: 'Usage: /agent <agent-name> to switch, or /agent list to see available agents.',
-          'Usage: /agent <agent-id> | /agent list | /agent new <name> to create a new agent.',
         conversationId,
       };
     }
@@ -269,58 +262,12 @@ export class CommandExecutorService {
       };
     }
 
-    // M5-006: /agent new <name> — create a new agent config via brain.agents.create()
-    if (args.startsWith('new')) {
-      const namePart = args.slice(3).trim();
-      if (!namePart) {
-        return {
-          command: 'agent',
-          success: false,
-          message: 'Usage: /agent new <name> — provide a name for the new agent.',
-          conversationId,
-        };
-      }
-
-      try {
-        const defaultProvider = process.env['DEFAULT_PROVIDER'] ?? 'anthropic';
-        const defaultModel = process.env['DEFAULT_MODEL'] ?? 'claude-sonnet-4-5-20251001';
-
-        const newAgent = await this.brain.agents.create({
-          name: namePart,
-          provider: defaultProvider,
-          model: defaultModel,
-          status: 'idle',
-          ownerId: userId,
-          isSystem: false,
-        });
-
-        this.logger.log(`Created new agent "${newAgent.name}" (${newAgent.id}) for user ${userId}`);
-
-        return {
-          command: 'agent',
-          success: true,
-          message: `Agent "${newAgent.name}" created with ID: ${newAgent.id}. Configure it via the web dashboard.`,
-          conversationId,
-          data: { agentId: newAgent.id, agentName: newAgent.name },
-        };
-      } catch (err) {
-        this.logger.error(`Failed to create agent: ${err}`);
-        return {
-          command: 'agent',
-          success: false,
-          message: `Failed to create agent: ${String(err)}`,
-          conversationId,
-        };
-      }
-    }
-
     // M5-003: Look up agent by name (or ID) and apply to session mid-conversation
     const agentName = args.trim();
     try {
-      // Try lookup by name first; fall back to ID-based lookup
+      // Try lookup by name first; fall back to ID lookup
       let agentConfig = await this.brain.agents.findByName(agentName);
       if (!agentConfig) {
-        // Try by ID (UUID-style input)
         agentConfig = await this.brain.agents.findById(agentName);
       }
 
@@ -333,7 +280,7 @@ export class CommandExecutorService {
         };
       }
 
-      // Apply the agent config to the live session and emit session:info (M5-003)
+      // Apply agent config to the live session metadata (M5-003)
       this.agentService.applyAgentConfig(
         conversationId,
         agentConfig.id,
@@ -341,7 +288,7 @@ export class CommandExecutorService {
         agentConfig.model ?? undefined,
       );
 
-      // Broadcast updated session:info so TUI TopBar reflects new agent/model
+      // Broadcast updated session:info so TUI reflects new agent/model (M5-003)
       this.chatGateway?.broadcastSessionInfo(conversationId, { agentName: agentConfig.name });
 
       this.logger.log(
@@ -351,7 +298,7 @@ export class CommandExecutorService {
       return {
         command: 'agent',
         success: true,
-        message: `Switched to agent "${agentConfig.name}". System prompt and tools applied. Model: ${agentConfig.model ?? 'default'}.`,
+        message: `Switched to agent "${agentConfig.name}". Model: ${agentConfig.model ?? 'default'}.`,
         conversationId,
         data: { agentId: agentConfig.id, agentName: agentConfig.name, model: agentConfig.model },
       };
@@ -495,92 +442,4 @@ export class CommandExecutorService {
       conversationId,
     };
   }
-
-  private async handleMcp(
-    args: string | null,
-    conversationId: string,
-  ): Promise<SlashCommandResultPayload> {
-    if (!this.mcpClient) {
-      return {
-        command: 'mcp',
-        conversationId,
-        success: false,
-        message: 'MCP client service is not available.',
-      };
-    }
-
-    const action = args?.trim().split(/\s+/)[0] ?? 'status';
-
-    switch (action) {
-      case 'status':
-      case 'servers': {
-        const statuses = this.mcpClient.getServerStatuses();
-        if (statuses.length === 0) {
-          return {
-            command: 'mcp',
-            conversationId,
-            success: true,
-            message:
-              'No MCP servers configured. Set MCP_SERVERS env var to connect external tool servers.',
-          };
-        }
-        const lines = ['MCP Server Status:\n'];
-        for (const s of statuses) {
-          const status = s.connected ? '✓ connected' : '✗ disconnected';
-          lines.push(`  ${s.name}: ${status}`);
-          lines.push(`    URL: ${s.url}`);
-          lines.push(`    Tools: ${s.toolCount}`);
-          if (s.error) lines.push(`    Error: ${s.error}`);
-          lines.push('');
-        }
-        const tools = this.mcpClient.getToolDefinitions();
-        if (tools.length > 0) {
-          lines.push(`Total bridged tools: ${tools.length}`);
-          lines.push(`Tool names: ${tools.map((t) => t.name).join(', ')}`);
-        }
-        return {
-          command: 'mcp',
-          conversationId,
-          success: true,
-          message: lines.join('\n'),
-        };
-      }
-
-      case 'reconnect': {
-        const serverName = args?.trim().split(/\s+/).slice(1).join(' ');
-        if (!serverName) {
-          return {
-            command: 'mcp',
-            conversationId,
-            success: false,
-            message: 'Usage: /mcp reconnect <server-name>',
-          };
-        }
-        try {
-          await this.mcpClient.reconnectServer(serverName);
-          return {
-            command: 'mcp',
-            conversationId,
-            success: true,
-            message: `MCP server "${serverName}" reconnected successfully.`,
-          };
-        } catch (err) {
-          return {
-            command: 'mcp',
-            conversationId,
-            success: false,
-            message: `Failed to reconnect MCP server "${serverName}": ${err instanceof Error ? err.message : String(err)}`,
-          };
-        }
-      }
-
-      default:
-        return {
-          command: 'mcp',
-          conversationId,
-          success: false,
-          message: `Unknown MCP action: "${action}". Use: /mcp status, /mcp servers, /mcp reconnect <name>`,
-        };
-    }
-  }
 }

apps/gateway/src/commands/command-registry.service.ts

@@ -260,23 +260,6 @@ export class CommandRegistryService implements OnModuleInit {
         execution: 'socket',
         available: true,
       },
-      {
-        name: 'mcp',
-        description: 'Manage MCP server connections (status/reconnect/servers)',
-        aliases: [],
-        args: [
-          {
-            name: 'action',
-            type: 'enum',
-            optional: true,
-            values: ['status', 'reconnect', 'servers'],
-            description: 'Action: status (default), reconnect <name>, servers',
-          },
-        ],
-        scope: 'agent',
-        execution: 'socket',
-        available: true,
-      },
       {
         name: 'reload',
         description: 'Soft-reload gateway plugins and command manifest (admin)',

apps/gateway/src/commands/commands.integration.spec.ts

@@ -39,14 +39,6 @@ const mockRedis = {
   keys: vi.fn().mockResolvedValue([]),
 };
 
-const mockBrain = {
-  agents: {
-    findByName: vi.fn().mockResolvedValue(undefined),
-    findById: vi.fn().mockResolvedValue(undefined),
-    create: vi.fn(),
-  },
-};
-
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
 function buildRegistry(): CommandRegistryService {
@@ -55,6 +47,14 @@ function buildRegistry(): CommandRegistryService {
   return svc;
 }
 
+const mockBrain = {
+  agents: {
+    findByName: vi.fn().mockResolvedValue(undefined),
+    findById: vi.fn().mockResolvedValue(undefined),
+    create: vi.fn(),
+  },
+};
+
 function buildExecutor(registry: CommandRegistryService): CommandExecutorService {
   return new CommandExecutorService(
     registry as never,
@@ -65,7 +65,6 @@ function buildExecutor(registry: CommandRegistryService): CommandExecutorService
     mockBrain as never,
     null, // reloadService (optional)
     null, // chatGateway (optional)
-    null, // mcpClient (optional)
   );
 }
 

apps/gateway/src/config/config.module.ts

@@ -1,16 +0,0 @@
-import { Global, Module } from '@nestjs/common';
-import { loadConfig, type MosaicConfig } from '@mosaic/config';
-
-export const MOSAIC_CONFIG = 'MOSAIC_CONFIG';
-
-@Global()
-@Module({
-  providers: [
-    {
-      provide: MOSAIC_CONFIG,
-      useFactory: (): MosaicConfig => loadConfig(),
-    },
-  ],
-  exports: [MOSAIC_CONFIG],
-})
-export class ConfigModule {}

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

@@ -1,42 +1,28 @@
 import { Global, Inject, Module, type OnApplicationShutdown } from '@nestjs/common';
 import { createDb, type Db, type DbHandle } from '@mosaic/db';
-import { createStorageAdapter, type StorageAdapter } from '@mosaic/storage';
-import type { MosaicConfig } from '@mosaic/config';
-import { MOSAIC_CONFIG } from '../config/config.module.js';
 
 export const DB_HANDLE = 'DB_HANDLE';
 export const DB = 'DB';
-export const STORAGE_ADAPTER = 'STORAGE_ADAPTER';
 
 @Global()
 @Module({
   providers: [
     {
       provide: DB_HANDLE,
-      useFactory: (config: MosaicConfig): DbHandle =>
+      useFactory: (): DbHandle => createDb(),
-        createDb(config.storage.type === 'postgres' ? config.storage.url : undefined),
-      inject: [MOSAIC_CONFIG],
     },
     {
       provide: DB,
       useFactory: (handle: DbHandle): Db => handle.db,
       inject: [DB_HANDLE],
     },
-    {
-      provide: STORAGE_ADAPTER,
-      useFactory: (config: MosaicConfig): StorageAdapter => createStorageAdapter(config.storage),
-      inject: [MOSAIC_CONFIG],
-    },
   ],
-  exports: [DB, STORAGE_ADAPTER],
+  exports: [DB],
 })
 export class DatabaseModule implements OnApplicationShutdown {
-  constructor(
+  constructor(@Inject(DB_HANDLE) private readonly handle: DbHandle) {}
-    @Inject(DB_HANDLE) private readonly handle: DbHandle,
-    @Inject(STORAGE_ADAPTER) private readonly storageAdapter: StorageAdapter,
-  ) {}
 
   async onApplicationShutdown(): Promise<void> {
-    await Promise.all([this.handle.close(), this.storageAdapter.close()]);
+    await this.handle.close();
   }
 }

apps/gateway/src/log/cron.service.ts

@@ -5,72 +5,59 @@ import {
   type OnModuleInit,
   type OnModuleDestroy,
 } from '@nestjs/common';
+import cron from 'node-cron';
 import { SummarizationService } from './summarization.service.js';
 import { SessionGCService } from '../gc/session-gc.service.js';
-import {
-  QueueService,
-  QUEUE_SUMMARIZATION,
-  QUEUE_GC,
-  QUEUE_TIER_MANAGEMENT,
-} from '../queue/queue.service.js';
-import type { Worker } from 'bullmq';
-import type { MosaicJobData } from '../queue/queue.service.js';
 
 @Injectable()
 export class CronService implements OnModuleInit, OnModuleDestroy {
   private readonly logger = new Logger(CronService.name);
-  private readonly registeredWorkers: Worker<MosaicJobData>[] = [];
+  private readonly tasks: cron.ScheduledTask[] = [];
 
   constructor(
     @Inject(SummarizationService) private readonly summarization: SummarizationService,
     @Inject(SessionGCService) private readonly sessionGC: SessionGCService,
-    @Inject(QueueService) private readonly queueService: QueueService,
   ) {}
 
-  async onModuleInit(): Promise<void> {
+  onModuleInit(): void {
     const summarizationSchedule = process.env['SUMMARIZATION_CRON'] ?? '0 */6 * * *'; // every 6 hours
     const tierManagementSchedule = process.env['TIER_MANAGEMENT_CRON'] ?? '0 3 * * *'; // daily at 3am
     const gcSchedule = process.env['SESSION_GC_CRON'] ?? '0 4 * * *'; // daily at 4am
 
-    // M6-003: Summarization repeatable job
+    this.tasks.push(
-    await this.queueService.addRepeatableJob(
+      cron.schedule(summarizationSchedule, () => {
-      QUEUE_SUMMARIZATION,
+        this.summarization.runSummarization().catch((err) => {
-      'summarization',
+          this.logger.error(`Scheduled summarization failed: ${err}`);
-      {},
+        });
-      summarizationSchedule,
+      }),
     );
-    const summarizationWorker = this.queueService.registerWorker(QUEUE_SUMMARIZATION, async () => {
-      await this.summarization.runSummarization();
-    });
-    this.registeredWorkers.push(summarizationWorker);
 
-    // M6-005: Tier management repeatable job
+    this.tasks.push(
-    await this.queueService.addRepeatableJob(
+      cron.schedule(tierManagementSchedule, () => {
-      QUEUE_TIER_MANAGEMENT,
+        this.summarization.runTierManagement().catch((err) => {
-      'tier-management',
+          this.logger.error(`Scheduled tier management failed: ${err}`);
-      {},
+        });
-      tierManagementSchedule,
+      }),
     );
-    const tierWorker = this.queueService.registerWorker(QUEUE_TIER_MANAGEMENT, async () => {
-      await this.summarization.runTierManagement();
-    });
-    this.registeredWorkers.push(tierWorker);
 
-    // M6-004: GC repeatable job
+    this.tasks.push(
-    await this.queueService.addRepeatableJob(QUEUE_GC, 'session-gc', {}, gcSchedule);
+      cron.schedule(gcSchedule, () => {
-    const gcWorker = this.queueService.registerWorker(QUEUE_GC, async () => {
+        this.sessionGC.sweepOrphans().catch((err) => {
-      await this.sessionGC.sweepOrphans();
+          this.logger.error(`Session GC sweep failed: ${err}`);
-    });
+        });
-    this.registeredWorkers.push(gcWorker);
+      }),
+    );
 
     this.logger.log(
-      `BullMQ jobs scheduled: summarization="${summarizationSchedule}", tier="${tierManagementSchedule}", gc="${gcSchedule}"`,
+      `Cron scheduled: summarization="${summarizationSchedule}", tier="${tierManagementSchedule}", gc="${gcSchedule}"`,
     );
   }
 
-  async onModuleDestroy(): Promise<void> {
+  onModuleDestroy(): void {
-    // Workers are closed by QueueService.onModuleDestroy — nothing extra needed here.
+    for (const task of this.tasks) {
-    this.registeredWorkers.length = 0;
+      task.stop();
-    this.logger.log('CronService destroyed (workers managed by QueueService)');
+    }
+    this.tasks.length = 0;
+    this.logger.log('Cron tasks stopped');
   }
 }

apps/gateway/src/log/log.module.ts

@@ -7,11 +7,10 @@ import { LogController } from './log.controller.js';
 import { SummarizationService } from './summarization.service.js';
 import { CronService } from './cron.service.js';
 import { GCModule } from '../gc/gc.module.js';
-import { QueueModule } from '../queue/queue.module.js';
 
 @Global()
 @Module({
-  imports: [GCModule, QueueModule],
+  imports: [GCModule],
   providers: [
     {
       provide: LOG_SERVICE,

apps/gateway/src/memory/memory.module.ts

@@ -1,29 +1,11 @@
 import { Global, Module } from '@nestjs/common';
-import {
+import { createMemory, type Memory } from '@mosaic/memory';
-  createMemory,
-  type Memory,
-  createMemoryAdapter,
-  type MemoryAdapter,
-  type MemoryConfig,
-} from '@mosaic/memory';
 import type { Db } from '@mosaic/db';
-import type { StorageAdapter } from '@mosaic/storage';
+import { DB } from '../database/database.module.js';
-import type { MosaicConfig } from '@mosaic/config';
-import { MOSAIC_CONFIG } from '../config/config.module.js';
-import { DB, STORAGE_ADAPTER } from '../database/database.module.js';
 import { MEMORY } from './memory.tokens.js';
 import { MemoryController } from './memory.controller.js';
 import { EmbeddingService } from './embedding.service.js';
 
-export const MEMORY_ADAPTER = 'MEMORY_ADAPTER';
-
-function buildMemoryConfig(config: MosaicConfig, storageAdapter: StorageAdapter): MemoryConfig {
-  if (config.memory.type === 'keyword') {
-    return { type: 'keyword', storage: storageAdapter };
-  }
-  return { type: config.memory.type };
-}
-
 @Global()
 @Module({
   providers: [
@@ -32,15 +14,9 @@ function buildMemoryConfig(config: MosaicConfig, storageAdapter: StorageAdapter)
       useFactory: (db: Db): Memory => createMemory(db),
       inject: [DB],
     },
-    {
-      provide: MEMORY_ADAPTER,
-      useFactory: (config: MosaicConfig, storageAdapter: StorageAdapter): MemoryAdapter =>
-        createMemoryAdapter(buildMemoryConfig(config, storageAdapter)),
-      inject: [MOSAIC_CONFIG, STORAGE_ADAPTER],
-    },
     EmbeddingService,
   ],
   controllers: [MemoryController],
-  exports: [MEMORY, MEMORY_ADAPTER, EmbeddingService],
+  exports: [MEMORY, EmbeddingService],
 })
 export class MemoryModule {}

apps/gateway/src/queue/queue-admin.dto.ts

@@ -1,34 +0,0 @@
-export type JobStatus = 'active' | 'completed' | 'failed' | 'waiting' | 'delayed';
-
-export interface JobDto {
-  id: string;
-  name: string;
-  queue: string;
-  status: JobStatus;
-  attempts: number;
-  maxAttempts: number;
-  createdAt?: string;
-  processedAt?: string;
-  finishedAt?: string;
-  failedReason?: string;
-  data: Record<string, unknown>;
-}
-
-export interface JobListDto {
-  jobs: JobDto[];
-  total: number;
-}
-
-export interface QueueStatusDto {
-  name: string;
-  waiting: number;
-  active: number;
-  completed: number;
-  failed: number;
-  delayed: number;
-  paused: boolean;
-}
-
-export interface QueueListDto {
-  queues: QueueStatusDto[];
-}

apps/gateway/src/queue/queue.module.ts

@@ -1,21 +0,0 @@
-import { Global, Module } from '@nestjs/common';
-import { createQueueAdapter, type QueueAdapter } from '@mosaic/queue';
-import type { MosaicConfig } from '@mosaic/config';
-import { MOSAIC_CONFIG } from '../config/config.module.js';
-import { QueueService } from './queue.service.js';
-
-export const QUEUE_ADAPTER = 'QUEUE_ADAPTER';
-
-@Global()
-@Module({
-  providers: [
-    QueueService,
-    {
-      provide: QUEUE_ADAPTER,
-      useFactory: (config: MosaicConfig): QueueAdapter => createQueueAdapter(config.queue),
-      inject: [MOSAIC_CONFIG],
-    },
-  ],
-  exports: [QueueService, QUEUE_ADAPTER],
-})
-export class QueueModule {}

apps/gateway/src/queue/queue.service.ts

@@ -1,412 +0,0 @@
-import {
-  Inject,
-  Injectable,
-  Logger,
-  Optional,
-  type OnModuleInit,
-  type OnModuleDestroy,
-} from '@nestjs/common';
-import { Queue, Worker, type Job, type ConnectionOptions } from 'bullmq';
-import type { LogService } from '@mosaic/log';
-import { LOG_SERVICE } from '../log/log.tokens.js';
-import type { JobDto, JobStatus } from './queue-admin.dto.js';
-
-// ---------------------------------------------------------------------------
-// Typed job definitions
-// ---------------------------------------------------------------------------
-
-export interface SummarizationJobData {
-  triggeredBy?: string;
-}
-
-export interface GCJobData {
-  triggeredBy?: string;
-}
-
-export interface TierManagementJobData {
-  triggeredBy?: string;
-}
-
-export type MosaicJobData = SummarizationJobData | GCJobData | TierManagementJobData;
-
-// ---------------------------------------------------------------------------
-// Queue health status
-// ---------------------------------------------------------------------------
-
-export interface QueueHealthStatus {
-  queues: Record<
-    string,
-    {
-      waiting: number;
-      active: number;
-      failed: number;
-      completed: number;
-      paused: boolean;
-    }
-  >;
-  healthy: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-export const QUEUE_SUMMARIZATION = 'mosaic-summarization';
-export const QUEUE_GC = 'mosaic-gc';
-export const QUEUE_TIER_MANAGEMENT = 'mosaic-tier-management';
-
-const DEFAULT_VALKEY_URL = 'redis://localhost:6380';
-
-/**
- * Parse a Redis URL string into a BullMQ-compatible ConnectionOptions object.
- *
- * BullMQ v5 does `Object.assign({ port: 6379, host: '127.0.0.1' }, opts)` in
- * its RedisConnection constructor. If opts is a URL string, Object.assign only
- * copies character-index properties and the defaults survive — so 6379 wins.
- * We must parse the URL ourselves and return a plain RedisOptions object.
- */
-function getConnection(): ConnectionOptions {
-  const url = process.env['VALKEY_URL'] ?? DEFAULT_VALKEY_URL;
-  try {
-    const parsed = new URL(url);
-    const opts: ConnectionOptions = {
-      host: parsed.hostname || '127.0.0.1',
-      port: parsed.port ? parseInt(parsed.port, 10) : 6380,
-    };
-    if (parsed.password) {
-      (opts as Record<string, unknown>)['password'] = decodeURIComponent(parsed.password);
-    }
-    if (parsed.pathname && parsed.pathname.length > 1) {
-      const db = parseInt(parsed.pathname.slice(1), 10);
-      if (!isNaN(db)) {
-        (opts as Record<string, unknown>)['db'] = db;
-      }
-    }
-    return opts;
-  } catch {
-    // Fallback: hope the value is already a host string ioredis understands
-    return { host: '127.0.0.1', port: 6380 } as ConnectionOptions;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Job handler type
-// ---------------------------------------------------------------------------
-
-export type JobHandler<T = MosaicJobData> = (job: Job<T>) => Promise<void>;
-
-/** System session ID used for job-event log entries (no real user session). */
-const SYSTEM_SESSION_ID = 'system';
-
-// ---------------------------------------------------------------------------
-// QueueService
-// ---------------------------------------------------------------------------
-
-@Injectable()
-export class QueueService implements OnModuleInit, OnModuleDestroy {
-  private readonly logger = new Logger(QueueService.name);
-  private readonly connection: ConnectionOptions;
-  private readonly queues = new Map<string, Queue<MosaicJobData>>();
-  private readonly workers = new Map<string, Worker<MosaicJobData>>();
-
-  constructor(
-    @Optional()
-    @Inject(LOG_SERVICE)
-    private readonly logService: LogService | null,
-  ) {
-    this.connection = getConnection();
-  }
-
-  onModuleInit(): void {
-    this.logger.log('QueueService initialised (BullMQ)');
-  }
-
-  async onModuleDestroy(): Promise<void> {
-    await this.closeAll();
-  }
-
-  // -------------------------------------------------------------------------
-  // Queue helpers
-  // -------------------------------------------------------------------------
-
-  /**
-   * Get or create a BullMQ Queue for the given queue name.
-   */
-  getQueue<T extends MosaicJobData = MosaicJobData>(name: string): Queue<T> {
-    let queue = this.queues.get(name) as Queue<T> | undefined;
-    if (!queue) {
-      queue = new Queue<T>(name, { connection: this.connection });
-      this.queues.set(name, queue as unknown as Queue<MosaicJobData>);
-    }
-    return queue;
-  }
-
-  /**
-   * Add a BullMQ repeatable job (cron-style).
-   * Uses `jobId` as a deterministic key so duplicate registrations are idempotent.
-   */
-  async addRepeatableJob<T extends MosaicJobData>(
-    queueName: string,
-    jobName: string,
-    data: T,
-    cronExpression: string,
-  ): Promise<void> {
-    const queue = this.getQueue<T>(queueName);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await (queue as Queue<any>).add(jobName, data, {
-      repeat: { pattern: cronExpression },
-      jobId: `${queueName}:${jobName}:repeatable`,
-    });
-    this.logger.log(
-      `Repeatable job "${jobName}" registered on "${queueName}" (cron: ${cronExpression})`,
-    );
-  }
-
-  /**
-   * Register a Worker for the given queue name with error handling and
-   * exponential backoff.
-   */
-  registerWorker<T extends MosaicJobData>(queueName: string, handler: JobHandler<T>): Worker<T> {
-    const worker = new Worker<T>(
-      queueName,
-      async (job) => {
-        this.logger.debug(`Processing job "${job.name}" (id=${job.id}) on queue "${queueName}"`);
-        await this.logJobEvent(
-          queueName,
-          job.name,
-          job.id ?? 'unknown',
-          'started',
-          job.attemptsMade + 1,
-        );
-        await handler(job);
-      },
-      {
-        connection: this.connection,
-        // Exponential backoff: base 5s, factor 2, max 5 attempts
-        settings: {
-          backoffStrategy: (attemptsMade: number) => {
-            return Math.min(5000 * Math.pow(2, attemptsMade - 1), 60_000);
-          },
-        },
-      },
-    );
-
-    worker.on('completed', (job) => {
-      this.logger.log(`Job "${job.name}" (id=${job.id}) completed on queue "${queueName}"`);
-      this.logJobEvent(
-        queueName,
-        job.name,
-        job.id ?? 'unknown',
-        'completed',
-        job.attemptsMade,
-      ).catch((err) => this.logger.warn(`Failed to write completed job log: ${String(err)}`));
-    });
-
-    worker.on('failed', (job, err) => {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      this.logger.error(
-        `Job "${job?.name ?? 'unknown'}" (id=${job?.id ?? 'unknown'}) failed on queue "${queueName}": ${errMsg}`,
-      );
-      this.logJobEvent(
-        queueName,
-        job?.name ?? 'unknown',
-        job?.id ?? 'unknown',
-        'failed',
-        job?.attemptsMade ?? 0,
-        errMsg,
-      ).catch((e) => this.logger.warn(`Failed to write failed job log: ${String(e)}`));
-    });
-
-    this.workers.set(queueName, worker as unknown as Worker<MosaicJobData>);
-    return worker;
-  }
-
-  /**
-   * Return queue health statistics for all managed queues.
-   */
-  async getHealthStatus(): Promise<QueueHealthStatus> {
-    const queues: QueueHealthStatus['queues'] = {};
-    let healthy = true;
-
-    for (const [name, queue] of this.queues) {
-      try {
-        const [waiting, active, failed, completed, paused] = await Promise.all([
-          queue.getWaitingCount(),
-          queue.getActiveCount(),
-          queue.getFailedCount(),
-          queue.getCompletedCount(),
-          queue.isPaused(),
-        ]);
-        queues[name] = { waiting, active, failed, completed, paused };
-      } catch (err) {
-        this.logger.error(`Failed to fetch health for queue "${name}": ${err}`);
-        healthy = false;
-        queues[name] = { waiting: 0, active: 0, failed: 0, completed: 0, paused: false };
-      }
-    }
-
-    return { queues, healthy };
-  }
-
-  // -------------------------------------------------------------------------
-  // Admin API helpers (M6-006)
-  // -------------------------------------------------------------------------
-
-  /**
-   * List jobs across all managed queues, optionally filtered by status.
-   * BullMQ jobs are fetched by state type from each queue.
-   */
-  async listJobs(status?: JobStatus): Promise<JobDto[]> {
-    const jobs: JobDto[] = [];
-    const states: JobStatus[] = status
-      ? [status]
-      : ['active', 'completed', 'failed', 'waiting', 'delayed'];
-
-    for (const [queueName, queue] of this.queues) {
-      try {
-        for (const state of states) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const raw = await (queue as Queue<any>).getJobs([state as any]);
-          for (const j of raw) {
-            jobs.push(this.toJobDto(queueName, j, state));
-          }
-        }
-      } catch (err) {
-        this.logger.warn(`Failed to list jobs for queue "${queueName}": ${String(err)}`);
-      }
-    }
-
-    return jobs;
-  }
-
-  /**
-   * Retry a specific failed job by its BullMQ job ID (format: "queueName:id").
-   * The caller passes "<queueName>__<jobId>" as the composite ID because BullMQ
-   * job IDs are not globally unique — they are scoped to their queue.
-   */
-  async retryJob(compositeId: string): Promise<{ ok: boolean; message: string }> {
-    const sep = compositeId.lastIndexOf('__');
-    if (sep === -1) {
-      return { ok: false, message: 'Invalid job id format. Expected "<queue>__<jobId>".' };
-    }
-    const queueName = compositeId.slice(0, sep);
-    const jobId = compositeId.slice(sep + 2);
-
-    const queue = this.queues.get(queueName);
-    if (!queue) {
-      return { ok: false, message: `Queue "${queueName}" not found.` };
-    }
-
-    const job = await queue.getJob(jobId);
-    if (!job) {
-      return { ok: false, message: `Job "${jobId}" not found in queue "${queueName}".` };
-    }
-
-    const state = await job.getState();
-    if (state !== 'failed') {
-      return { ok: false, message: `Job "${jobId}" is not in failed state (current: ${state}).` };
-    }
-
-    await job.retry('failed');
-    await this.logJobEvent(queueName, job.name, jobId, 'retried', (job.attemptsMade ?? 0) + 1);
-    return { ok: true, message: `Job "${jobId}" on queue "${queueName}" queued for retry.` };
-  }
-
-  /**
-   * Pause a queue by name.
-   */
-  async pauseQueue(name: string): Promise<{ ok: boolean; message: string }> {
-    const queue = this.queues.get(name);
-    if (!queue) return { ok: false, message: `Queue "${name}" not found.` };
-    await queue.pause();
-    this.logger.log(`Queue paused: ${name}`);
-    return { ok: true, message: `Queue "${name}" paused.` };
-  }
-
-  /**
-   * Resume a paused queue by name.
-   */
-  async resumeQueue(name: string): Promise<{ ok: boolean; message: string }> {
-    const queue = this.queues.get(name);
-    if (!queue) return { ok: false, message: `Queue "${name}" not found.` };
-    await queue.resume();
-    this.logger.log(`Queue resumed: ${name}`);
-    return { ok: true, message: `Queue "${name}" resumed.` };
-  }
-
-  private toJobDto(queueName: string, job: Job<MosaicJobData>, status: JobStatus): JobDto {
-    return {
-      id: `${queueName}__${job.id ?? 'unknown'}`,
-      name: job.name,
-      queue: queueName,
-      status,
-      attempts: job.attemptsMade,
-      maxAttempts: job.opts?.attempts ?? 1,
-      createdAt: job.timestamp ? new Date(job.timestamp).toISOString() : undefined,
-      processedAt: job.processedOn ? new Date(job.processedOn).toISOString() : undefined,
-      finishedAt: job.finishedOn ? new Date(job.finishedOn).toISOString() : undefined,
-      failedReason: job.failedReason,
-      data: (job.data as Record<string, unknown>) ?? {},
-    };
-  }
-
-  // -------------------------------------------------------------------------
-  // Job event logging (M6-007)
-  // -------------------------------------------------------------------------
-
-  /** Write a log entry to agent_logs for BullMQ job lifecycle events. */
-  private async logJobEvent(
-    queueName: string,
-    jobName: string,
-    jobId: string,
-    event: 'started' | 'completed' | 'retried' | 'failed',
-    attempts: number,
-    errorMessage?: string,
-  ): Promise<void> {
-    if (!this.logService) return;
-
-    const level = event === 'failed' ? ('error' as const) : ('info' as const);
-    const content =
-      event === 'failed'
-        ? `Job "${jobName}" (${jobId}) on queue "${queueName}" failed: ${errorMessage ?? 'unknown error'}`
-        : `Job "${jobName}" (${jobId}) on queue "${queueName}" ${event} (attempt ${attempts})`;
-
-    try {
-      await this.logService.logs.ingest({
-        sessionId: SYSTEM_SESSION_ID,
-        userId: 'system',
-        level,
-        category: 'general',
-        content,
-        metadata: {
-          jobId,
-          jobName,
-          queue: queueName,
-          event,
-          attempts,
-          ...(errorMessage ? { errorMessage } : {}),
-        },
-      });
-    } catch (err) {
-      // Log errors must never crash job execution
-      this.logger.warn(`Failed to write job event log for job ${jobId}: ${String(err)}`);
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Lifecycle
-  // -------------------------------------------------------------------------
-
-  private async closeAll(): Promise<void> {
-    const workerCloses = Array.from(this.workers.values()).map((w) =>
-      w.close().catch((err) => this.logger.error(`Worker close error: ${err}`)),
-    );
-    const queueCloses = Array.from(this.queues.values()).map((q) =>
-      q.close().catch((err) => this.logger.error(`Queue close error: ${err}`)),
-    );
-    await Promise.all([...workerCloses, ...queueCloses]);
-    this.workers.clear();
-    this.queues.clear();
-    this.logger.log('QueueService shut down');
-  }
-}

apps/gateway/src/queue/queue.tokens.ts

@@ -1,2 +0,0 @@
-export const QUEUE_REDIS = 'QUEUE_REDIS';
-export const QUEUE_SERVICE = 'QUEUE_SERVICE';

apps/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/web",
-  "version": "0.0.2",
+  "version": "0.0.0",
   "private": true,
   "scripts": {
     "build": "next build",

briefs/monorepo-consolidation.md

@@ -1,231 +0,0 @@
-# Brief: Monorepo Consolidation — mosaic/stack → mosaic/mosaic-stack
-
-## Source
-
-Architecture consolidation — merge the mosaic/stack repo (Forge pipeline, MACP protocol, framework tools) into mosaic/mosaic-stack (Harness Foundation platform). Two repos doing related work that need to converge.
-
-## Context
-
-**mosaic/stack** (OLD) contains:
-
-- Forge progressive refinement pipeline (stages, agents, personas, rails, debate protocol, brief classification)
-- MACP protocol (JSON schemas, deterministic Python controller, dispatcher, event system, gate runner)
-- Credential resolver (Python — OC config, mosaic files, ambient env, JSON5 parser)
-- OC framework plugin (injects Mosaic rails into all agent sessions)
-- Profiles (runtime-neutral context packs for tech stacks and domains)
-- Stage adapter (Forge→MACP bridge)
-- Board tasks (multi-agent board evaluation)
-- OpenBrain specialist memory (learning capture/recall)
-- 17 guides, 5 universal skills
-
-**mosaic/mosaic-stack** (NEW) contains:
-
-- Harness Foundation platform (NestJS gateway, Next.js web, Drizzle ORM, Pi SDK runtime)
-- 5 provider adapters, task classifier, routing rules, model capability matrix
-- MACP OC plugin (ACP runtime backend with Pi bridge)
-- TS coord package (mission runner, tasks file manager, status tracker — 1635 lines)
-- BullMQ job queue, OTEL telemetry, channel plugins (Discord, Telegram)
-- CLI with TUI, 65/65 tasks done, v0.2.0
-
-**Decision:** NEW repo is the base. All unique work from OLD gets ported into NEW as packages.
-
-## Scope
-
-### Work Package 1: Forge Pipeline Package (`packages/forge`)
-
-Port the entire Forge progressive refinement pipeline as a TypeScript package.
-
-**From OLD:**
-
-- `forge/pipeline/stages/*.md` — 11 stage definitions
-- `forge/pipeline/agents/{board,generalists,specialists,cross-cutting}/*.md` — all persona definitions
-- `forge/pipeline/rails/*.md` — debate protocol, dynamic composition, worker rails
-- `forge/pipeline/gates/` — gate reviewer definitions
-- `forge/pipeline/orchestrator/run-structure.md` — file-based observability spec
-- `forge/templates/` — brief and PRD templates
-- `forge/pipeline/orchestrator/board_tasks.py` → rewrite in TS
-- `forge/pipeline/orchestrator/stage_adapter.py` → rewrite in TS
-- `forge/pipeline/orchestrator/pipeline_runner.py` → rewrite in TS
-- `forge/forge` CLI (Python) → rewrite in TS, integrate with `packages/cli`
-
-**Package structure:**
-
-```
-packages/forge/
-├── src/
-│   ├── index.ts              # Public API
-│   ├── pipeline-runner.ts    # Orchestrates full pipeline run
-│   ├── stage-adapter.ts      # Maps stages to MACP/coord tasks
-│   ├── board-tasks.ts        # Multi-agent board evaluation task generator
-│   ├── brief-classifier.ts   # strategic/technical/hotfix classification
-│   ├── types.ts              # Stage specs, run manifest, gate results
-│   └── constants.ts          # Stage sequence, timeouts, labels
-├── pipeline/
-│   ├── stages/               # .md stage definitions (copied)
-│   ├── agents/               # .md persona definitions (copied)
-│   │   ├── board/
-│   │   ├── cross-cutting/
-│   │   ├── generalists/
-│   │   └── specialists/
-│   │       ├── language/
-│   │       └── domain/
-│   ├── rails/                # .md rails (copied)
-│   ├── gates/                # .md gate definitions (copied)
-│   └── templates/            # brief + PRD templates (copied)
-└── package.json
-```
-
-**Key design decisions:**
-
-- Pipeline markdown assets are runtime data, not compiled — ship as-is in the package
-- `pipeline-runner.ts` calls into `packages/coord` for task execution (not a separate controller)
-- Stage adapter generates coord-compatible tasks, not MACP JSON directly
-- Board tasks use `depends_on_policy: "all_terminal"` for synthesis
-- Per-stage timeouts from `STAGE_TIMEOUTS` map
-- Brief classifier supports CLI flag, YAML frontmatter, and keyword auto-detection
-- Run output goes to project-scoped `.forge/runs/{run-id}/` (not inside the Forge package)
-
-**Persona override system (new):**
-
-- Base personas ship with the package (read-only)
-- Project-level overrides in `.forge/personas/{role}.md` extend (not replace) base personas
-- Board composition configurable via `.forge/config.yaml`:
-  ```yaml
-  board:
-    additional_members:
-      - compliance-officer.md
-    skip_members: []
-  specialists:
-    always_include:
-      - proxmox-expert
-  ```
-- OpenBrain integration for cross-run specialist memory (when enabled)
-
-### Work Package 2: MACP Protocol Package (`packages/macp`)
-
-Port the MACP protocol layer, event system, and gate runner as a TypeScript package.
-
-**From OLD:**
-
-- `tools/macp/protocol/task.schema.json` — task JSON schema
-- `tools/macp/protocol/` — event schemas
-- `tools/macp/controller/gate_runner.py` → rewrite in TS as `gate-runner.ts`
-- `tools/macp/events/` — event watcher, webhook adapter, Discord formatter → rewrite in TS
-- `tools/macp/dispatcher/credential_resolver.py` → rewrite in TS as `credential-resolver.ts`
-- `tools/macp/memory/learning_capture.py` + `learning_recall.py` → rewrite in TS
-
-**Package structure:**
-
-```
-packages/macp/
-├── src/
-│   ├── index.ts                # Public API
-│   ├── types.ts                # Task, event, result, gate types
-│   ├── schemas/                # JSON schemas (copied)
-│   ├── gate-runner.ts          # Mechanical + AI review quality gates
-│   ├── credential-resolver.ts  # Provider credential resolution (mosaic files, OC config, ambient)
-│   ├── event-emitter.ts        # Append events to ndjson, structured event types
-│   ├── event-watcher.ts        # Poll events.ndjson with cursor persistence
-│   ├── webhook-adapter.ts      # POST events to configurable URL
-│   ├── discord-formatter.ts    # Human-readable event messages
-│   └── learning.ts             # OpenBrain capture + recall
-└── package.json
-```
-
-**Integration with existing packages:**
-
-- `packages/coord` uses `packages/macp` for event emission, gate running, and credential resolution
-- `plugins/macp` uses `packages/macp` for protocol types and credential resolution
-- `packages/forge` uses `packages/macp` gate types for stage gates
-
-### Work Package 3: OC Framework Plugin (`plugins/mosaic-framework`)
-
-Port the OC framework plugin that injects Mosaic rails into all agent sessions.
-
-**From OLD:**
-
-- `oc-plugins/mosaic-framework/index.ts` — `before_agent_start` + `subagent_spawning` hooks
-- `oc-plugins/mosaic-framework/openclaw.plugin.json`
-
-**Structure:**
-
-```
-plugins/mosaic-framework/
-├── src/
-│   └── index.ts    # Plugin hooks
-└── package.json
-```
-
-**This is separate from `plugins/macp`:**
-
-- `mosaic-framework` = injects Mosaic rails/contracts into every OC session (passive enforcement)
-- `macp` = provides an ACP runtime backend for MACP task execution (active runtime)
-
-### Work Package 4: Profiles + Guides + Skills
-
-Port reference content as a documentation/config package or top-level directories.
-
-**From OLD:**
-
-- `profiles/domains/*.json` — HIPAA, fintech, crypto context packs
-- `profiles/tech-stacks/*.json` — NestJS, Next.js, FastAPI, React conventions
-- `profiles/workflows/*.json` — API development, frontend component, testing workflows
-- `guides/*.md` — 17 guides (auth, backend, QA, orchestrator, PRD, etc.)
-- `skills-universal/` — jarvis, macp, mosaic-standards, prd, setup-cicd skills
-
-**Destination:**
-
-```
-profiles/           # Top-level (same as OLD)
-guides/             # Top-level (same as OLD)
-skills/             # Top-level (renamed from skills-universal)
-```
-
-These are runtime-neutral assets consumed by any agent or profile loader — they don't belong in a compiled package.
-
-## Out of Scope
-
-- Rewriting the NestJS orchestrator app from OLD (`apps/orchestrator/`) — its functionality is subsumed by `packages/coord` + `apps/gateway`
-- Porting the FastAPI coordinator from OLD (`apps/coordinator/`) — its functionality (webhook receiver, issue parser, quality orchestrator) is handled by `packages/coord` + `apps/gateway` in the new architecture
-- Porting the Prisma schema or OLD's `apps/api` — Drizzle migration is complete
-- Old Docker Compose configs (Traefik, Matrix, OpenBao) — NEW has its own infra setup
-
-## Success Criteria
-
-1. `packages/forge` exists with all 11 stage definitions, all persona markdowns, all rails, and TS implementations of pipeline-runner, stage-adapter, board-tasks, and brief-classifier
-2. `packages/macp` exists with gate-runner, credential-resolver, event system, and learning capture/recall — all in TypeScript
-3. `plugins/mosaic-framework` exists and registers OC hooks for rails injection
-4. Profiles, guides, and skills are present at top-level
-5. `packages/forge` integrates with `packages/coord` for task execution
-6. `packages/macp` credential-resolver is used by `plugins/macp` Pi bridge
-7. All existing tests pass (no regressions)
-8. New packages have test coverage ≥85%
-9. `pnpm lint && pnpm typecheck && pnpm build` passes
-10. `.forge/runs/` project-scoped output directory works for at least one test run
-
-## Technical Constraints
-
-- All new code is ESM with NodeNext module resolution
-- No Python in the new repo — everything rewrites to TypeScript
-- Pipeline markdown assets (stages, personas, rails) are shipped as package data, not compiled
-- Credential resolver must support: mosaic credential files, OC config (JSON5), ambient environment — same resolution order as the Python version
-- Must preserve `depends_on_policy` semantics (all, any, all_terminal)
-- Per-stage timeouts must be preserved
-- JSON5 stripping must use the placeholder-extraction approach (not naive regex on string content)
-
-## Estimated Complexity
-
-High — crosses 4 work packages with protocol porting, TS rewrites, and integration wiring. Each work package is independently shippable.
-
-**Suggested execution order:**
-
-1. WP4 (profiles/guides/skills) — pure copy, no code, fast win
-2. WP2 (packages/macp) — protocol foundation, needed by WP1 and WP3
-3. WP1 (packages/forge) — the big one, depends on WP2
-4. WP3 (plugins/mosaic-framework) — OC integration, can parallel with WP1
-
-## Dependencies
-
-- `packages/coord` must be stable (it is — WP1 integrates with it)
-- `plugins/macp` must be stable (it is — WP2 provides types/credentials to it)
-- Pi SDK (`@mariozechner/pi-agent-core`) already in the dependency tree

docs/MISSION-MANIFEST.md

@@ -7,36 +7,36 @@
 
 **ID:** harness-20260321
 **Statement:** Transform Mosaic Stack from a functional demo into a real multi-provider, task-routing AI harness. Persist all conversations, integrate frontier LLM providers (Anthropic, OpenAI, OpenRouter, Z.ai, Ollama), build granular task-aware agent routing, harden agent sessions, replace cron with BullMQ, and design the channel protocol for future Matrix/remote integration.
-**Phase:** Complete
+**Phase:** Execution
-**Current Milestone:** All milestones done
+**Current Milestone:** M3: Provider Integration
-**Progress:** 7 / 7 milestones
+**Progress:** 2 / 7 milestones
-**Status:** complete
+**Status:** active
-**Last Updated:** 2026-03-22 UTC
+**Last Updated:** 2026-03-21 UTC
 
 ## Success Criteria
 
-- [x] AC-1: Send messages in TUI → restart TUI → resume conversation → agent has full history and context
+- [ ] AC-1: Send messages in TUI → restart TUI → resume conversation → agent has full history and context
-- [x] AC-2: Route a coding task to Claude Opus 4.6, a simple question to Haiku, a summarization to GLM-5 — all via granular routing rules
+- [ ] AC-2: Route a coding task to Claude Opus 4.6, a simple question to Haiku, a summarization to GLM-5 — all via granular routing rules
-- [x] AC-3: Two users exist, User A's memory searches never return User B's data
+- [ ] AC-3: Two users exist, User A's memory searches never return User B's data
-- [x] AC-4: `/model claude-sonnet-4-6` in TUI switches the active model for subsequent messages
+- [ ] AC-4: `/model claude-sonnet-4-6` in TUI switches the active model for subsequent messages
-- [x] AC-5: `/agent coding-agent` in TUI switches to a different agent with different system prompt and tools
+- [ ] AC-5: `/agent coding-agent` in TUI switches to a different agent with different system prompt and tools
-- [x] AC-6: BullMQ jobs execute on schedule, failures retry with backoff, admin can inspect via `/api/admin/jobs`
+- [ ] AC-6: BullMQ jobs execute on schedule, failures retry with backoff, admin can inspect via `/api/admin/jobs`
-- [x] AC-7: Channel protocol document exists with Matrix integration points defined, reviewed, and approved
+- [ ] AC-7: Channel protocol document exists with Matrix integration points defined, reviewed, and approved
-- [x] AC-8: Embeddings run on Ollama local models (no external API dependency for vector operations)
+- [ ] AC-8: Embeddings run on Ollama local models (no external API dependency for vector operations)
-- [x] AC-9: All five providers (Anthropic, OpenAI, OpenRouter, Z.ai, Ollama) connect, list models, and complete chat requests
+- [ ] AC-9: All five providers (Anthropic, OpenAI, OpenRouter, Z.ai, Ollama) connect, list models, and complete chat requests
-- [x] AC-10: Routing transparency — TUI displays which model was selected and the routing reason for each response
+- [ ] AC-10: Routing transparency — TUI displays which model was selected and the routing reason for each response
 
 ## Milestones
 
-| #   | ID     | Name                               | Status | Branch | Issue     | Started    | Completed  |
+| #   | ID     | Name                               | Status      | Branch | Issue     | Started    | Completed  |
-| --- | ------ | ---------------------------------- | ------ | ------ | --------- | ---------- | ---------- |
+| --- | ------ | ---------------------------------- | ----------- | ------ | --------- | ---------- | ---------- |
-| 1   | ms-166 | Conversation Persistence & Context | done   | —      | #224–#231 | 2026-03-21 | 2026-03-21 |
+| 1   | ms-166 | Conversation Persistence & Context | done        | —      | #224–#231 | 2026-03-21 | 2026-03-21 |
-| 2   | ms-167 | Security & Isolation               | done   | —      | #232–#239 | 2026-03-21 | 2026-03-21 |
+| 2   | ms-167 | Security & Isolation               | done        | —      | #232–#239 | 2026-03-21 | 2026-03-21 |
-| 3   | ms-168 | Provider Integration               | done   | —      | #240–#251 | 2026-03-21 | 2026-03-22 |
+| 3   | ms-168 | Provider Integration               | in-progress | —      | #240–#251 | 2026-03-21 | —          |
-| 4   | ms-169 | Agent Routing Engine               | done   | —      | #252–#264 | 2026-03-22 | 2026-03-22 |
+| 4   | ms-169 | Agent Routing Engine               | not-started | —      | #252–#264 | —          | —          |
-| 5   | ms-170 | Agent Session Hardening            | done   | —      | #265–#272 | 2026-03-22 | 2026-03-22 |
+| 5   | ms-170 | Agent Session Hardening            | not-started | —      | #265–#272 | —          | —          |
-| 6   | ms-171 | Job Queue Foundation               | done   | —      | #273–#280 | 2026-03-22 | 2026-03-22 |
+| 6   | ms-171 | Job Queue Foundation               | not-started | —      | #273–#280 | —          | —          |
-| 7   | ms-172 | Channel Protocol Design            | done   | —      | #281–#288 | 2026-03-22 | 2026-03-22 |
+| 7   | ms-172 | Channel Protocol Design            | not-started | —      | #281–#288 | —          | —          |
 
 ## Deployment
 
@@ -48,7 +48,7 @@
 ## Coordination
 
 - **Primary Agent:** claude-opus-4-6
-- **Sibling Agents:** sonnet (workers), haiku (verification)
+- **Sibling Agents:** codex (for pure coding tasks), sonnet (for review/standard work)
 - **Shared Contracts:** docs/PRD-Harness_Foundation.md, docs/TASKS.md
 
 ## Token Budget
@@ -56,14 +56,14 @@
 | Metric | Value  |
 | ------ | ------ |
 | Budget | —      |
-| Used   | ~2.5M  |
+| Used   | 0      |
 | Mode   | normal |
 
 ## Session History
 
-| Session | Runtime         | Started    | Duration | Ended Reason | Last Task         |
+| Session | Runtime         | Started    | Duration | Ended Reason | Last Task     |
-| ------- | --------------- | ---------- | -------- | ------------ | ----------------- |
+| ------- | --------------- | ---------- | -------- | ------------ | ------------- |
-| 1       | claude-opus-4-6 | 2026-03-21 | ~6h      | complete     | M7-008 — all done |
+| 1       | claude-opus-4-6 | 2026-03-21 | —        | —            | Planning gate |
 
 ## Scratchpad
 

docs/PRD-Harness_Foundation.md

@@ -4,7 +4,7 @@
 
 - **Owner:** Jason Woltje
 - **Date:** 2026-03-21
-- **Status:** completed
+- **Status:** draft
 - **Phase:** 9 (post-MVP)
 - **Version Target:** v0.2.0
 - **Agent Harness:** [Pi SDK](https://github.com/badlogic/pi-mono)

docs/TASKS.md

@@ -1,30 +1,74 @@
-# Tasks — Storage Abstraction Retrofit
+# Tasks — Harness Foundation
 
 > Single-writer: orchestrator only. Workers read but never modify.
 >
-> **Mission:** Decouple gateway from hardcoded Postgres/Valkey backends. Introduce interface-driven middleware so the gateway is backend-agnostic. Default to local tier (SQLite + JSON) for zero-dependency installs.
->
 > **`agent` column values:** `codex` | `sonnet` | `haiku` | `glm-5` | `opus` | `—` (auto/default)
+> Pipeline crons pick the cheapest capable model. Override with a specific value when a task genuinely needs it.
 
-| id        | status      | agent  | description                                                      | tokens |
+| id     | status      | agent  | milestone          | description                                                                                                     | pr   | notes                                            |
-| --------- | ----------- | ------ | ---------------------------------------------------------------- | ------ |
+| ------ | ----------- | ------ | ------------------ | --------------------------------------------------------------------------------------------------------------- | ---- | ------------------------------------------------ |
-| SA-P1-001 | done        | sonnet | Define QueueAdapter interface in packages/queue/src/types.ts     | 3K     |
+| M1-001 | done        | sonnet | M1: Persistence    | Wire ChatGateway.handleMessage() → ConversationsRepo.addMessage() for user messages                             | #292 | #224 closed                                      |
-| SA-P1-002 | done        | sonnet | Define StorageAdapter interface in packages/storage/src/types.ts | 3K     |
+| M1-002 | done        | sonnet | M1: Persistence    | Wire agent event relay → ConversationsRepo.addMessage() for assistant responses (text, tool calls, thinking)    | #292 | #225 closed                                      |
-| SA-P1-003 | done        | sonnet | Define MemoryAdapter interface in packages/memory/src/types.ts   | 3K     |
+| M1-003 | done        | sonnet | M1: Persistence    | Store message metadata: model used, provider, token counts, tool call details, timestamps                       | #292 | #226 closed                                      |
-| SA-P1-004 | done        | sonnet | Create adapter factory pattern + config types                    | 3K     |
+| M1-004 | done        | sonnet | M1: Persistence    | On session resume, load message history from DB and inject into Pi session context                              | #301 | #227 closed                                      |
-| SA-P2-001 | done        | sonnet | Refactor @mosaic/queue: wrap ioredis as BullMQ adapter           | 3K     |
+| M1-005 | done        | sonnet | M1: Persistence    | Context window management: summarize older messages when history exceeds 80% of model context                   | #301 | #228 closed                                      |
-| SA-P2-002 | done        | sonnet | Create @mosaic/storage: wrap Drizzle as Postgres adapter         | 6K     |
+| M1-006 | done        | sonnet | M1: Persistence    | Conversation search: full-text search on messages table via /api/conversations/search                           | #299 | #229 closed                                      |
-| SA-P2-003 | done        | sonnet | Refactor @mosaic/memory: extract pgvector adapter                | 4K     |
+| M1-007 | done        | sonnet | M1: Persistence    | TUI: /history command to display conversation message count and context usage                                   | #297 | #230 closed                                      |
-| SA-P2-004 | done        | sonnet | Update gateway modules to use factories + DI tokens              | 5K     |
+| M1-008 | done        | sonnet | M1: Persistence    | Verify: send messages → kill TUI → resume with -c → agent references prior context                              | #304 | #231 closed — 20 integration tests               |
-| SA-P2-005 | done        | opus   | Verify Phase 2: all tests pass, typecheck clean                  | —      |
+| M2-001 | done        | sonnet | M2: Security       | Audit InsightsRepo: add userId filter to searchByEmbedding() vector search                                      | #290 | #232 closed                                      |
-| SA-P3-001 | done        | sonnet | Implement local queue adapter: JSON file persistence             | 5K     |
+| M2-002 | done        | sonnet | M2: Security       | Audit InsightsRepo: add userId filter to findByUser(), decayOldInsights()                                       | #290 | #233 closed                                      |
-| SA-P3-002 | done        | sonnet | Implement SQLite storage adapter with better-sqlite3             | 8K     |
+| M2-003 | done        | sonnet | M2: Security       | Audit PreferencesRepo: verify all queries filter by userId                                                      | #294 | #234 closed — already scoped                     |
-| SA-P3-003 | done        | sonnet | Implement keyword memory adapter — no vector dependency          | 4K     |
+| M2-004 | done        | sonnet | M2: Security       | Audit agent memory tools: verify memory*search, memory_save*_, memory*get*_ scope to session user               | #294 | #235 closed — FIXED userId injection             |
-| SA-P3-004 | done        | opus   | Verify Phase 3: 42 new tests, 347 total passing                  | —      |
+| M2-005 | done        | sonnet | M2: Security       | Audit ConversationsRepo: verify ownership check on findById, update, delete, addMessage, findMessages           | #293 | #236 closed                                      |
-| SA-P4-001 | done        | sonnet | MosaicConfig schema + loader with tier auto-detection            | 6K     |
+| M2-006 | done        | sonnet | M2: Security       | Audit AgentsRepo: verify findAccessible() returns only user's agents + system agents                            | #293 | #237 closed                                      |
-| SA-P4-002 | done        | sonnet | CLI: mosaic gateway init — interactive wizard                    | 4K     |
+| M2-007 | done        | sonnet | M2: Security       | Integration test: create two users, populate data, verify cross-user isolation on every query path              | #305 | #238 closed — 28 integration tests               |
-| SA-P4-003 | done        | sonnet | CLI: mosaic gateway start/stop/status lifecycle                  | 5K     |
+| M2-008 | done        | sonnet | M2: Security       | Audit Valkey keys: verify session keys include userId or are not enumerable across users                        | #298 | #239 closed — SCAN replaces KEYS, /gc admin-only |
-| SA-P4-004 | done        | opus   | Verify Phase 4: 381 tests passing, 40/40 tasks clean             | —      |
+| M3-001 | done        | sonnet | M3: Providers      | Refactor ProviderService into IProviderAdapter pattern: register(), listModels(), healthCheck(), createClient() | #306 | #240 closed                                      |
-| SA-P5-001 | not-started | codex  | Migration tooling: mosaic storage export/import                  | —      |
+| M3-002 | done        | sonnet | M3: Providers      | Anthropic adapter: @anthropic-ai/sdk, Claude Sonnet 4.6 + Opus 4.6 + Haiku 4.5, OAuth + API key                 | #309 | #241 closed                                      |
-| SA-P5-002 | not-started | codex  | Docker Compose profiles: local vs team                           | —      |
+| M3-003 | done        | sonnet | M3: Providers      | OpenAI adapter: openai SDK, Codex gpt-5.4, OAuth + API key                                                      | #310 | #242 closed                                      |
-| SA-P5-003 | not-started | codex  | Final verification + docs: README, architecture diagram          | —      |
+| M3-004 | done        | sonnet | M3: Providers      | OpenRouter adapter: OpenAI-compatible client, API key, dynamic model list from /api/v1/models                   | #311 | #243 closed                                      |
+| M3-005 | in-progress | sonnet | M3: Providers      | Z.ai GLM adapter: GLM-5, API key, research API format                                                           | —    | #244                                             |
+| M3-006 | done        | sonnet | M3: Providers      | Ollama adapter: refactor existing integration into adapter pattern, add embedding model support                 | #311 | #245 closed                                      |
+| M3-007 | done        | sonnet | M3: Providers      | Provider health check: periodic probe, configurable interval, status per provider, /api/providers/health        | #308 | #246 closed                                      |
+| M3-008 | done        | sonnet | M3: Providers      | Model capability matrix: per-model metadata (tier, context window, tool support, vision, streaming, embedding)  | #303 | #247 closed                                      |
+| M3-009 | done        | sonnet | M3: Providers      | Refactor EmbeddingService: provider-agnostic interface, Ollama default (nomic-embed-text or mxbai-embed-large)  | #308 | #248 closed                                      |
+| M3-010 | in-progress | sonnet | M3: Providers      | OAuth token storage: persist provider tokens per user in DB (encrypted), refresh flow                           | —    | #249                                             |
+| M3-011 | in-progress | sonnet | M3: Providers      | Provider config UI support: /api/providers CRUD for user-scoped provider credentials                            | —    | #250                                             |
+| M3-012 | not-started | haiku  | M3: Providers      | Verify: each provider connects, lists models, completes chat request, handles errors                            | —    | #251                                             |
+| M4-001 | in-progress | sonnet | M4: Routing        | Define routing rule schema: RoutingRule { name, priority, conditions[], action } stored in DB                   | —    | #252 DB migration                                |
+| M4-002 | in-progress | sonnet | M4: Routing        | Condition types: taskType, complexity, domain, costTier, requiredCapabilities                                   | —    | #253                                             |
+| M4-003 | in-progress | sonnet | M4: Routing        | Action types: routeTo { provider, model, agentConfigId?, systemPromptOverride?, toolAllowlist? }                | —    | #254                                             |
+| M4-004 | in-progress | sonnet | M4: Routing        | Default routing rules seed data: coding→Opus, Q&A→Sonnet, summarization→GLM-5, research→Codex, offline→Ollama   | —    | #255                                             |
+| M4-005 | in-progress | sonnet | M4: Routing        | Task classification: infer taskType + complexity from user message (regex/keyword first, LLM-assisted later)    | —    | #256                                             |
+| M4-006 | not-started | opus   | M4: Routing        | Routing decision pipeline: classify → match rules → check health → fallback chain → return result               | —    | #257                                             |
+| M4-007 | not-started | sonnet | M4: Routing        | Routing override: /model forces specific model regardless of routing rules                                      | —    | #258                                             |
+| M4-008 | not-started | sonnet | M4: Routing        | Routing transparency: include routing decision in session:info event (model + reason)                           | —    | #259                                             |
+| M4-009 | not-started | sonnet | M4: Routing        | Routing rules CRUD: /api/routing/rules — list, create, update, delete, reorder priority                         | —    | #260                                             |
+| M4-010 | not-started | sonnet | M4: Routing        | Per-user routing overrides: users customize default rules for their sessions                                    | —    | #261                                             |
+| M4-011 | not-started | sonnet | M4: Routing        | Agent specialization: agents declare capabilities in config (domains, preferred models, tool sets)              | —    | #262                                             |
+| M4-012 | not-started | sonnet | M4: Routing        | Routing integration: wire into ChatGateway — every message triggers routing before agent dispatch               | —    | #263                                             |
+| M4-013 | not-started | haiku  | M4: Routing        | Verify: coding→Opus, summarize→GLM-5, simple→Haiku, override via /model works                                   | —    | #264                                             |
+| M5-001 | not-started | sonnet | M5: Sessions       | Wire ChatGateway: on session create, load agent config from DB (system prompt, model, provider, tools, skills)  | —    | #265                                             |
+| M5-002 | not-started | sonnet | M5: Sessions       | /model command: end-to-end wiring — TUI → socket → gateway switches provider/model → new messages use it        | —    | #266                                             |
+| M5-003 | not-started | sonnet | M5: Sessions       | /agent command: switch agent config mid-session — loads new system prompt, tools, default model                 | —    | #267                                             |
+| M5-004 | not-started | sonnet | M5: Sessions       | Session ↔ conversation binding: persist sessionId on conversation record, resume via conversationId             | —    | #268                                             |
+| M5-005 | not-started | sonnet | M5: Sessions       | Session info broadcast: on model/agent switch, emit session:info with updated state                             | —    | #269                                             |
+| M5-006 | not-started | sonnet | M5: Sessions       | Agent creation from TUI: /agent new command creates agent config via gateway API                                | —    | #270                                             |
+| M5-007 | not-started | sonnet | M5: Sessions       | Session metrics: per-session token usage, model switches, duration — persist in DB                              | —    | #271                                             |
+| M5-008 | not-started | haiku  | M5: Sessions       | Verify: /model switches model, /agent switches agent, session resume loads config                               | —    | #272                                             |
+| M6-001 | not-started | sonnet | M6: Jobs           | Add BullMQ dependency, configure with Valkey connection                                                         | —    | #273 Test compat first                           |
+| M6-002 | not-started | sonnet | M6: Jobs           | Create queue service: typed job definitions, worker registration, error handling with exponential backoff       | —    | #274                                             |
+| M6-003 | not-started | sonnet | M6: Jobs           | Migrate summarization cron → BullMQ repeatable job                                                              | —    | #275                                             |
+| M6-004 | not-started | sonnet | M6: Jobs           | Migrate GC (session cleanup) → BullMQ repeatable job                                                            | —    | #276                                             |
+| M6-005 | not-started | sonnet | M6: Jobs           | Migrate tier management (log archival) → BullMQ repeatable job                                                  | —    | #277                                             |
+| M6-006 | not-started | sonnet | M6: Jobs           | Admin jobs API: GET /api/admin/jobs — list, status, retry, pause/resume queues                                  | —    | #278                                             |
+| M6-007 | not-started | sonnet | M6: Jobs           | Job event logging: emit job start/complete/fail events to agent_logs                                            | —    | #279                                             |
+| M6-008 | not-started | haiku  | M6: Jobs           | Verify: jobs execute on schedule, failure retries with backoff, admin endpoint shows history                    | —    | #280                                             |
+| M7-001 | not-started | opus   | M7: Channel Design | Define IChannelAdapter interface: lifecycle, message flow, identity mapping                                     | —    | #281 Architecture                                |
+| M7-002 | not-started | opus   | M7: Channel Design | Define channel message protocol: canonical format all adapters translate to/from                                | —    | #282 Architecture                                |
+| M7-003 | not-started | opus   | M7: Channel Design | Design Matrix integration: appservice, room↔conversation, space↔team, agent ghosts, power levels                | —    | #283 Architecture                                |
+| M7-004 | not-started | opus   | M7: Channel Design | Design conversation multiplexing: same conversation from TUI+WebUI+Matrix, real-time sync                       | —    | #284 Architecture                                |
+| M7-005 | not-started | opus   | M7: Channel Design | Design remote auth bridging: Matrix/Discord auth → Mosaic identity (token linking, OAuth bridge)                | —    | #285 Architecture                                |
+| M7-006 | not-started | opus   | M7: Channel Design | Design agent-to-agent communication via Matrix rooms: room per agent pair, human observation                    | —    | #286 Architecture                                |
+| M7-007 | not-started | opus   | M7: Channel Design | Design multi-user isolation in Matrix: space-per-team, room visibility, encryption, admin access                | —    | #287 Architecture                                |
+| M7-008 | not-started | haiku  | M7: Channel Design | Publish docs/architecture/channel-protocol.md — reviewed and approved                                           | —    | #288                                             |

docs/architecture/channel-protocol.md

@@ -1,743 +0,0 @@
-# Channel Protocol Architecture
-
-**Status:** Draft
-**Authors:** Mosaic Core Team
-**Last Updated:** 2026-03-22
-**Covers:** M7-001 (IChannelAdapter interface), M7-002 (ChannelMessage protocol), M7-003 (Matrix integration design), M7-004 (conversation multiplexing), M7-005 (remote auth bridging), M7-006 (agent-to-agent communication via Matrix), M7-007 (multi-user isolation in Matrix)
-
----
-
-## Overview
-
-The channel protocol defines a unified abstraction layer between Mosaic's core messaging infrastructure and the external communication channels it supports (Matrix, Discord, Telegram, TUI, WebUI, and future channels).
-
-The protocol consists of two main contracts:
-
-1. `IChannelAdapter` — the interface each channel driver must implement.
-2. `ChannelMessage` — the canonical message format that flows through the system.
-
-All channel-specific translation logic lives inside the adapter implementation. The rest of Mosaic works exclusively with `ChannelMessage` objects.
-
----
-
-## M7-001: IChannelAdapter Interface
-
-```typescript
-interface IChannelAdapter {
-  /**
-   * Stable, lowercase identifier for this channel (e.g. "matrix", "discord").
-   * Used as a namespace key in registry lookups and log metadata.
-   */
-  readonly name: string;
-
-  /**
-   * Establish a connection to the external channel backend.
-   * Called once at application startup. Must be idempotent (safe to call
-   * when already connected).
-   */
-  connect(): Promise<void>;
-
-  /**
-   * Gracefully disconnect from the channel backend.
-   * Must flush in-flight sends and release resources before resolving.
-   */
-  disconnect(): Promise<void>;
-
-  /**
-   * Return the current health of the adapter connection.
-   * Used by the admin health endpoint and alerting.
-   *
-   * - "connected"    — fully operational
-   * - "degraded"     — partial connectivity (e.g. read-only, rate-limited)
-   * - "disconnected" — no connection to channel backend
-   */
-  health(): Promise<{ status: 'connected' | 'degraded' | 'disconnected' }>;
-
-  /**
-   * Register an inbound message handler.
-   * The adapter calls `handler` for every message received from the channel.
-   * Multiple calls replace the previous handler (last-write-wins).
-   * The handler is async; the adapter must not deliver new messages until
-   * the previous handler promise resolves (back-pressure).
-   */
-  onMessage(handler: (msg: ChannelMessage) => Promise<void>): void;
-
-  /**
-   * Send a ChannelMessage to the given channel/room/conversation.
-   * `channelId` is the channel-native identifier (e.g. Matrix room ID,
-   * Discord channel snowflake, Telegram chat ID).
-   */
-  sendMessage(channelId: string, msg: ChannelMessage): Promise<void>;
-
-  /**
-   * Map a channel-native user identifier to the Mosaic internal userId.
-   * Returns null when no matching Mosaic account exists for the given
-   * channelUserId (anonymous or unlinked user).
-   */
-  mapIdentity(channelUserId: string): Promise<string | null>;
-}
-```
-
-### Adapter Registration
-
-Adapters are registered with the `ChannelRegistry` service at startup. The registry calls `connect()` on each adapter and monitors `health()` on a configurable interval (default: 30 s).
-
-```
-ChannelRegistry
-  └── register(adapter: IChannelAdapter): void
-  └── getAdapter(name: string): IChannelAdapter | null
-  └── listAdapters(): IChannelAdapter[]
-  └── healthAll(): Promise<Record<string, AdapterHealth>>
-```
-
----
-
-## M7-002: ChannelMessage Protocol
-
-### Canonical Message Format
-
-```typescript
-interface ChannelMessage {
-  /**
-   * Globally unique message ID.
-   * Format: UUID v4. Generated by the adapter when receiving, or by Mosaic
-   * when sending. Channel-native IDs are stored in metadata.channelMessageId.
-   */
-  id: string;
-
-  /**
-   * Channel-native room/conversation/channel identifier.
-   * The adapter populates this from the inbound message.
-   * For outbound messages, the caller supplies the target channel.
-   */
-  channelId: string;
-
-  /**
-   * Channel-native identifier of the message sender.
-   * For Mosaic-originated messages this is the Mosaic userId or agentId.
-   */
-  senderId: string;
-
-  /** Sender classification. */
-  senderType: 'user' | 'agent' | 'system';
-
-  /**
-   * Textual content of the message.
-   * For non-text content types (image, file) this may be an empty string
-   * or an alt-text description; the actual payload is in `attachments`.
-   */
-  content: string;
-
-  /**
-   * Hint for how `content` should be interpreted and rendered.
-   * - "text"     — plain text, no special rendering
-   * - "markdown" — CommonMark markdown
-   * - "code"     — code block (use metadata.language for the language tag)
-   * - "image"    — binary image; content is empty, see attachments
-   * - "file"     — binary file; content is empty, see attachments
-   */
-  contentType: 'text' | 'markdown' | 'code' | 'image' | 'file';
-
-  /**
-   * Arbitrary key-value metadata for channel-specific extension fields.
-   * Examples: { channelMessageId, language, reactionEmoji, channelType }.
-   * Adapters should store channel-native IDs here so round-trip correlation
-   * is possible without altering the canonical fields.
-   */
-  metadata: Record<string, unknown>;
-
-  /**
-   * Optional thread or reply-chain identifier.
-   * For threaded channels (Matrix, Discord threads, Telegram topics) this
-   * groups messages into a logical thread scoped to the same channelId.
-   */
-  threadId?: string;
-
-  /**
-   * The canonical message ID this message is a reply to.
-   * Maps to channel-native reply/quote mechanisms in each adapter.
-   */
-  replyToId?: string;
-
-  /**
-   * Binary or URI-referenced attachments.
-   * Each attachment carries its MIME type and a URL or base64 payload.
-   */
-  attachments?: ChannelAttachment[];
-
-  /** Wall-clock timestamp when the message was sent/received. */
-  timestamp: Date;
-}
-
-interface ChannelAttachment {
-  /** Filename or identifier. */
-  name: string;
-
-  /** MIME type (e.g. "image/png", "application/pdf"). */
-  mimeType: string;
-
-  /**
-   * URL pointing to the attachment, OR a `data:` URI with base64 payload.
-   * Adapters that receive file uploads SHOULD store to object storage and
-   * populate a stable URL here rather than embedding the raw bytes.
-   */
-  url: string;
-
-  /** Size in bytes, if known. */
-  sizeBytes?: number;
-}
-```
-
----
-
-## Channel Translation Reference
-
-The following sections document how each supported channel maps its native message format to and from `ChannelMessage`.
-
-### Matrix
-
-| ChannelMessage field | Matrix equivalent                                                                                                                 |
-| -------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
-| `id`                 | Generated UUID; `metadata.channelMessageId` = Matrix event ID (`$...`)                                                            |
-| `channelId`          | Matrix room ID (`!roomid:homeserver`)                                                                                             |
-| `senderId`           | Matrix user ID (`@user:homeserver`)                                                                                               |
-| `senderType`         | Always `"user"` for inbound; `"agent"` or `"system"` for outbound                                                                 |
-| `content`            | `event.content.body`                                                                                                              |
-| `contentType`        | `"markdown"` if `msgtype = m.text` and body contains markdown; `"text"` otherwise; `"image"` for `m.image`; `"file"` for `m.file` |
-| `threadId`           | `event.content['m.relates_to']['event_id']` when `rel_type = m.thread`                                                            |
-| `replyToId`          | Mosaic ID looked up from `event.content['m.relates_to']['m.in_reply_to']['event_id']`                                             |
-| `attachments`        | Populated from `url` in `m.image` / `m.file` events                                                                               |
-| `timestamp`          | `new Date(event.origin_server_ts)`                                                                                                |
-| `metadata`           | `{ channelMessageId, roomId, eventType, unsigned }`                                                                               |
-
-**Outbound:** Adapter sends `m.room.message` with `msgtype = m.text` (or `m.notice` for system messages). Markdown content is sent with `format = org.matrix.custom.html` and a rendered HTML body.
-
----
-
-### Discord
-
-| ChannelMessage field | Discord equivalent                                                      |
-| -------------------- | ----------------------------------------------------------------------- |
-| `id`                 | Generated UUID; `metadata.channelMessageId` = Discord message snowflake |
-| `channelId`          | Discord channel ID (snowflake string)                                   |
-| `senderId`           | Discord user ID (snowflake)                                             |
-| `senderType`         | `"user"` for human members; `"agent"` for bot messages                  |
-| `content`            | `message.content`                                                       |
-| `contentType`        | `"markdown"` (Discord uses a markdown-like syntax natively)             |
-| `threadId`           | `message.thread.id` when the message is inside a thread channel         |
-| `replyToId`          | Mosaic ID looked up from `message.referenced_message.id`                |
-| `attachments`        | `message.attachments` mapped to `ChannelAttachment`                     |
-| `timestamp`          | `new Date(message.timestamp)`                                           |
-| `metadata`           | `{ channelMessageId, guildId, channelType, mentions, embeds }`          |
-
-**Outbound:** Adapter calls Discord REST `POST /channels/{id}/messages`. Markdown content is sent as-is (Discord renders it). For `contentType = "code"` the adapter wraps in triple-backtick fences with the `metadata.language` tag.
-
----
-
-### Telegram
-
-| ChannelMessage field | Telegram equivalent                                                                                           |
-| -------------------- | ------------------------------------------------------------------------------------------------------------- |
-| `id`                 | Generated UUID; `metadata.channelMessageId` = Telegram `message_id` (integer)                                 |
-| `channelId`          | Telegram `chat_id` (integer as string)                                                                        |
-| `senderId`           | Telegram `from.id` (integer as string)                                                                        |
-| `senderType`         | `"user"` for human senders; `"agent"` for bot-originated messages                                             |
-| `content`            | `message.text` or `message.caption`                                                                           |
-| `contentType`        | `"text"` for plain; `"markdown"` if `parse_mode = MarkdownV2`; `"image"` for `photo`; `"file"` for `document` |
-| `threadId`           | `message.message_thread_id` (for supergroup topics)                                                           |
-| `replyToId`          | Mosaic ID looked up from `message.reply_to_message.message_id`                                                |
-| `attachments`        | `photo`, `document`, `video` fields mapped to `ChannelAttachment`                                             |
-| `timestamp`          | `new Date(message.date * 1000)`                                                                               |
-| `metadata`           | `{ channelMessageId, chatType, fromUsername, forwardFrom }`                                                   |
-
-**Outbound:** Adapter calls Telegram Bot API `sendMessage` with `parse_mode = MarkdownV2` for markdown content. For `contentType = "image"` or `"file"` it uses `sendPhoto` / `sendDocument`.
-
----
-
-### TUI (Terminal UI)
-
-The TUI adapter bridges Mosaic's terminal interface (`packages/cli`) to the channel protocol so that TUI sessions can be treated as a first-class channel.
-
-| ChannelMessage field | TUI equivalent                                                     |
-| -------------------- | ------------------------------------------------------------------ |
-| `id`                 | Generated UUID (TUI has no native message IDs)                     |
-| `channelId`          | `"tui:<conversationId>"` — the active conversation ID              |
-| `senderId`           | Authenticated Mosaic `userId`                                      |
-| `senderType`         | `"user"` for human input; `"agent"` for agent replies              |
-| `content`            | Raw text from stdin / agent output                                 |
-| `contentType`        | `"text"` for input; `"markdown"` for agent responses               |
-| `threadId`           | Not used (TUI sessions are linear)                                 |
-| `replyToId`          | Not used                                                           |
-| `attachments`        | File paths dragged/pasted into the TUI; resolved to `file://` URLs |
-| `timestamp`          | `new Date()` at the moment of send                                 |
-| `metadata`           | `{ conversationId, sessionId, ttyWidth, colorSupport }`            |
-
-**Outbound:** The adapter writes rendered content to stdout. Markdown is rendered via a terminal markdown renderer (e.g. `marked-terminal`). Code blocks are syntax-highlighted when `metadata.colorSupport = true`.
-
----
-
-### WebUI
-
-The WebUI adapter connects the Next.js frontend (`apps/web`) to the channel protocol over the existing Socket.IO gateway (`apps/gateway`).
-
-| ChannelMessage field | WebUI equivalent                                             |
-| -------------------- | ------------------------------------------------------------ |
-| `id`                 | Generated UUID; echoed back in the WebSocket event           |
-| `channelId`          | `"webui:<conversationId>"`                                   |
-| `senderId`           | Authenticated Mosaic `userId`                                |
-| `senderType`         | `"user"` for browser input; `"agent"` for agent responses    |
-| `content`            | Message text from the input field                            |
-| `contentType`        | `"text"` or `"markdown"`                                     |
-| `threadId`           | Not used (conversation model handles threading)              |
-| `replyToId`          | Message ID the user replied to (UI reply affordance)         |
-| `attachments`        | Files uploaded via the file picker; stored to object storage |
-| `timestamp`          | `new Date()` at send, or server timestamp from event         |
-| `metadata`           | `{ conversationId, sessionId, clientTimezone, userAgent }`   |
-
-**Outbound:** Adapter emits a `chat:message` Socket.IO event. The WebUI React component receives it and appends to the conversation list. Markdown content is rendered client-side via the existing markdown renderer component.
-
----
-
-## Identity Mapping
-
-`mapIdentity(channelUserId)` resolves a channel-native user identifier to a Mosaic `userId`. This is required to attribute inbound messages to authenticated Mosaic accounts.
-
-The implementation must query a `channel_identities` table (or equivalent) keyed on `(channel_name, channel_user_id)`. When no mapping exists the method returns `null` and the message is treated as anonymous (no Mosaic session context).
-
-```
-channel_identities
-  channel_name   TEXT       -- e.g. "matrix", "discord"
-  channel_user_id TEXT      -- channel-native user identifier
-  mosaic_user_id  TEXT      -- FK to users.id
-  linked_at       TIMESTAMP
-  PRIMARY KEY (channel_name, channel_user_id)
-```
-
-Identity linking flows (OAuth dance, deep-link verification token, etc.) are out of scope for this document and will be specified in a separate identity-linking protocol document.
-
----
-
-## Error Handling Conventions
-
-- `connect()` must throw a structured error (subclass of `ChannelConnectError`) if the initial connection cannot be established within a reasonable timeout (default: 10 s).
-- `sendMessage()` must throw `ChannelSendError` on terminal failures (auth revoked, channel not found). Transient failures (rate limit, network blip) should be retried internally with exponential backoff before throwing.
-- `health()` must never throw — it returns `{ status: 'disconnected' }` on error.
-- Adapters must emit structured logs with `{ channel: adapter.name, event, ... }` metadata for observability.
-
----
-
-## Versioning
-
-The `ChannelMessage` protocol follows semantic versioning. Non-breaking field additions (new optional fields) are minor version bumps. Breaking changes (type changes, required field additions) require a major version bump and a migration guide.
-
-Current version: **1.0.0**
-
----
-
-## M7-003: Matrix Integration Design
-
-### Homeserver Choice
-
-Mosaic uses **Conduit** as the Matrix homeserver. Conduit is written in Rust, ships as a single binary, and has minimal operational overhead compared to Synapse or Dendrite. It supports the full Matrix Client-Server and Application Service APIs required by Mosaic.
-
-Recommended deployment: Conduit runs as a Docker container alongside the Mosaic stack. A single Conduit instance is sufficient for most self-hosted deployments. Conduit's embedded RocksDB storage means no separate database is required for the homeserver itself.
-
-### Appservice Registration
-
-Mosaic registers with the Conduit homeserver as a Matrix **Application Service (appservice)**. This gives Mosaic the ability to:
-
-- Create and control ghost users (virtual Matrix users representing Mosaic agents and provisioned accounts).
-- Receive all events sent to rooms within the appservice's namespace without polling.
-- Send events on behalf of ghost users without separate authentication.
-
-Registration is done via a YAML registration file (`mosaic-appservice.yaml`) placed in Conduit's configuration directory:
-
-```yaml
-id: mosaic
-url: http://gateway:3000/_matrix/appservice
-as_token: <random-secret>
-hs_token: <random-secret>
-sender_localpart: mosaic-bot
-namespaces:
-  users:
-    - exclusive: true
-      regex: '@mosaic_.*:homeserver'
-  rooms:
-    - exclusive: false
-      regex: '.*'
-  aliases:
-    - exclusive: true
-      regex: '#mosaic-.*:homeserver'
-```
-
-The gateway exposes `/_matrix/appservice` endpoints to receive push events from Conduit. The `as_token` and `hs_token` are stored in Vault and injected at startup.
-
-### Room ↔ Conversation Mapping
-
-Each Mosaic conversation maps to a single Matrix room. The mapping is stored in the database:
-
-```
-conversation_matrix_rooms
-  conversation_id  TEXT  -- FK to conversations.id
-  room_id          TEXT  -- Matrix room ID (!roomid:homeserver)
-  created_at       TIMESTAMP
-  PRIMARY KEY (conversation_id)
-```
-
-Room creation is handled by the appservice on the first Matrix access to a conversation. Room names follow the pattern `Mosaic: <conversation title>`. Room topics contain the conversation ID for correlation.
-
-When a conversation is deleted or archived in Mosaic, the corresponding Matrix room is tombstoned (m.room.tombstone event) and the room is left in a read-only state.
-
-### Space ↔ Team Mapping
-
-Each Mosaic team maps to a Matrix **Space**. Spaces are Matrix rooms with a special `m.space` type that can contain child rooms.
-
-```
-team_matrix_spaces
-  team_id    TEXT  -- FK to teams.id
-  space_id   TEXT  -- Matrix room ID of the Space
-  created_at TIMESTAMP
-  PRIMARY KEY (team_id)
-```
-
-When a conversation room is shared with a team, the appservice adds it to the team's Space via `m.space.child` state events. Removing the share removes the child relationship.
-
-### Agent Ghost Users
-
-Each Mosaic agent is represented in Matrix as an **appservice ghost user**:
-
-- Matrix user ID format: `@mosaic_agent_<agentId>:homeserver`
-- Display name: the agent's human-readable name (e.g. "Mosaic Assistant")
-- Avatar: optional, configurable per agent
-
-Ghost users are registered lazily — the appservice creates the ghost on first use. Ghost users are controlled exclusively by the appservice; they cannot log in via Matrix client credentials.
-
-When an agent sends a message via the gateway, the Matrix adapter sends the event using `user_id` impersonation on the appservice's client endpoint, causing the message to appear as if sent by the ghost user.
-
-### Power Levels
-
-Power levels in each Mosaic-managed room are set as follows:
-
-| Entity                                | Power Level    | Rationale                              |
-| ------------------------------------- | -------------- | -------------------------------------- |
-| Mosaic appservice bot (`@mosaic-bot`) | 100 (Admin)    | Room management and moderation         |
-| Human Mosaic users                    | 50 (Moderator) | Can kick, redact, and invite           |
-| Agent ghost users                     | 0 (Default)    | Message-only; cannot modify room state |
-
-This arrangement ensures human users retain full control. An agent cannot modify room settings, kick members, or take administrative actions. Humans with moderator power can redact agent messages and intervene in ongoing conversations.
-
-```
-mermaid
-graph TD
-    A[Mosaic Admin] -->|invites| B[Human User]
-    B -->|joins| C[Matrix Room / Conversation]
-    D[Agent Ghost User] -->|sends messages to| C
-    B -->|can redact/kick| D
-    E[Mosaic Bot] -->|manages room state| C
-    style A fill:#4a9eff
-    style B fill:#4a9eff
-    style D fill:#aaaaaa
-    style E fill:#ff9944
-```
-
----
-
-## M7-004: Conversation Multiplexing
-
-### Architecture Overview
-
-A single Mosaic conversation can be accessed simultaneously from multiple surfaces: TUI, WebUI, and Matrix. The gateway is the **single source of truth** for all conversation state. Each surface is a thin client that renders gateway-owned data.
-
-```
-┌─────────────────────────────────────────────────────┐
-│                    Gateway (NestJS)                  │
-│                                                      │
-│   ConversationService  ←→  MessageBus               │
-│         │                      │                    │
-│    [DB: PostgreSQL]     [Fanout: Valkey Pub/Sub]     │
-│                                │                    │
-│          ┌─────────────────────┼──────────────┐     │
-│          │                     │              │     │
-│   Socket.IO         Socket.IO      Matrix     │     │
-│   (TUI adapter)    (WebUI adapter) (appservice)│    │
-└──────────┼─────────────────────┼──────────────┘     │
-           │                     │              │
-       CLI/TUI              Browser          Matrix
-                                             Client
-```
-
-### Real-Time Sync Flow
-
-1. A message arrives on any surface (TUI keystroke, browser send, Matrix event).
-2. The surface's adapter normalizes the message to `ChannelMessage` and delivers it to `ConversationService`.
-3. `ConversationService` persists the message to PostgreSQL, assigns a canonical `id`, and publishes a `message:new` event to the Valkey pub/sub channel keyed by `conversationId`.
-4. All active surfaces subscribed to that `conversationId` receive the fanout event and push it to their respective clients:
-   - TUI adapter: writes rendered output to the connected terminal session.
-   - WebUI adapter: emits a `chat:message` Socket.IO event to all browser sessions joined to that conversation.
-   - Matrix adapter: sends an `m.room.message` event to the conversation's Matrix room.
-
-This ensures that a message typed in the TUI appears in the browser and in Matrix within the same round-trip latency as the Valkey fanout (typically <10 ms on co-located infrastructure).
-
-### Surface-to-Transport Mapping
-
-| Surface | Transport to Gateway                       | Fanout Transport from Gateway |
-| ------- | ------------------------------------------ | ----------------------------- |
-| TUI     | HTTPS REST + SSE or WebSocket              | Socket.IO over stdio proxy    |
-| WebUI   | Socket.IO (browser)                        | Socket.IO emit                |
-| Matrix  | Matrix Client-Server API (appservice push) | Matrix `m.room.message` send  |
-
-### Conflict Resolution
-
-- **Messages**: Append-only. Messages are never edited in-place in Mosaic's canonical store. Matrix edit events (`m.replace`) are treated as new messages with `replyToId` pointing to the original, preserving the full audit trail.
-- **Metadata (title, tags, archived state)**: Last-write-wins. The timestamp of the most recent write wins. Concurrent metadata updates from different surfaces are serialized through `ConversationService`; the final database write reflects the last persisted value.
-- **Conversation membership**: Set-merge semantics. Adding a user from any surface is additive. Removal requires an explicit delete action and is not overwritten by concurrent adds.
-
-### Session Isolation
-
-Multiple TUI sessions or browser tabs connected to the same conversation receive all fanout messages independently. Each session maintains its own scroll position and local ephemeral state (typing indicator, draft text). Gateway does not synchronize ephemeral state across sessions.
-
----
-
-## M7-005: Remote Auth Bridging
-
-### Overview
-
-Matrix users authenticate to Mosaic by linking their Matrix identity to an existing Mosaic account. There are two flows: token linking (primary) and OAuth bridge (alternative). Once linked, the Matrix session is persistent — there is no periodic login/logout cycle.
-
-### Token Linking Flow
-
-1. A Mosaic admin or the user themselves generates a short-lived link token via the Mosaic web UI or API (`POST /auth/channel-link-token`). The token is a cryptographically random 32-byte hex string with a 15-minute TTL stored in Valkey.
-2. The user opens a Matrix client and sends a DM to `@mosaic-bot:homeserver`.
-3. The user sends the command: `!link <token>`
-4. The appservice receives the `m.room.message` event in the DM room, extracts the token, and calls `AuthService.linkChannelIdentity({ channel: 'matrix', channelUserId: matrixUserId, token })`.
-5. `AuthService` validates the token, retrieves the associated `mosaicUserId`, and writes a row to `channel_identities`.
-6. The appservice sends a confirmation reply in the DM room and invites the now-linked user to their personal Matrix Space.
-
-```
-User (Matrix)          @mosaic-bot          Mosaic Gateway
-     │                     │                      │
-     │  DM: !link <token>  │                      │
-     │────────────────────▶│                      │
-     │                     │  POST /auth/link     │
-     │                     │─────────────────────▶│
-     │                     │   200 OK             │
-     │                     │◀─────────────────────│
-     │  ✓ Linked! Joining  │                      │
-     │  your Space now     │                      │
-     │◀────────────────────│                      │
-```
-
-### OAuth Bridge Flow
-
-An alternative flow for users who prefer browser-based authentication:
-
-1. The Mosaic bot sends the user a Matrix message containing an OAuth URL: `https://mosaic.example.com/auth/matrix-link?state=<nonce>&matrix_user=<encoded_mxid>`
-2. The user opens the URL in a browser. If not already logged in to Mosaic, they are redirected through the standard BetterAuth login flow.
-3. On successful authentication, Mosaic records the `channel_identities` row linking `matrix_user` to the authenticated `mosaicUserId`.
-4. The gateway sends a Matrix event to the pending DM room confirming the link.
-
-### Invite-Based Provisioning
-
-When a Mosaic admin adds a new user account, the provisioning flow optionally associates a Matrix user ID with the new account at creation time:
-
-1. Admin provides `matrixUserId` when creating the account (`POST /admin/users`).
-2. `UserService` writes the `channel_identities` row immediately.
-3. The Matrix adapter's provisioning hook fires, and the appservice:
-   - Creates the user's personal Matrix Space (if not already existing).
-   - Sends an invite to the Matrix user for their personal Space.
-   - Sends a welcome DM from `@mosaic-bot` with onboarding instructions.
-
-The invited user does not need to complete any linking step — the association is pre-established by the admin.
-
-### Session Lifecycle
-
-Matrix sessions for linked users are persistent and long-lived. Unlike TUI sessions (which terminate when the terminal process exits), a Matrix user's access to their rooms remains intact as long as:
-
-- Their Mosaic account is active (not suspended or deleted).
-- Their `channel_identities` row exists (link not revoked).
-- They remain members of the relevant Matrix rooms.
-
-Revoking a Matrix link (`DELETE /auth/channel-link/matrix/<matrixUserId>`) removes the `channel_identities` row and causes `mapIdentity()` to return `null`. The appservice optionally kicks the Matrix user from all Mosaic-managed rooms as part of the revocation flow (configurable, default: off).
-
----
-
-## M7-006: Agent-to-Agent Communication via Matrix
-
-### Dedicated Agent Rooms
-
-When two Mosaic agents need to coordinate, a dedicated Matrix room is created for their dialogue. This provides a persistent, auditable channel for structured inter-agent communication that humans can observe.
-
-Room naming convention:
-
-```
-#mosaic-agents-<agentA>-<agentB>:homeserver
-```
-
-Where `agentA` and `agentB` are the Mosaic agent IDs sorted lexicographically (to ensure the same room is used regardless of which agent initiates). The room alias is registered by the appservice.
-
-```
-agent_rooms
-  room_id     TEXT  -- Matrix room ID
-  agent_a_id  TEXT  -- FK to agents.id (lexicographically first)
-  agent_b_id  TEXT  -- FK to agents.id (lexicographically second)
-  created_at  TIMESTAMP
-  PRIMARY KEY (agent_a_id, agent_b_id)
-```
-
-### Room Membership and Power Levels
-
-| Entity                             | Power Level                          |
-| ---------------------------------- | ------------------------------------ |
-| Mosaic appservice bot              | 100 (Admin)                          |
-| Human observers (invited)          | 50 (Moderator, read-only by default) |
-| Agent ghost users (agentA, agentB) | 0 (Default — message send only)      |
-
-Humans are invited to agent rooms with a read-only intent. By convention, human messages in agent rooms are prefixed with `[HUMAN]` and treated as interrupts by the gateway. Agents are instructed (via system prompt) to pause and acknowledge human messages before resuming their dialogue.
-
-### Message Format
-
-Agents communicate using **structured JSON** embedded in Matrix event content. The Matrix event type is `m.room.message` with `msgtype: "m.text"` for compatibility. The structured payload is carried in a custom `mosaic.agent_message` field:
-
-```json
-{
-  "msgtype": "m.text",
-  "body": "[Agent message — see mosaic.agent_message for structured content]",
-  "mosaic.agent_message": {
-    "schema_version": "1.0",
-    "sender_agent_id": "agent_abc123",
-    "conversation_id": "conv_xyz789",
-    "message_type": "request",
-    "payload": {
-      "action": "summarize",
-      "parameters": { "max_tokens": 500 },
-      "reply_to_event_id": "$previousEventId"
-    },
-    "timestamp_ms": 1711234567890
-  }
-}
-```
-
-The `body` field contains a human-readable fallback so the conversation is legible in any Matrix client. The structured payload is parsed exclusively by the gateway's Matrix adapter.
-
-### Coordination Patterns
-
-**Request/Response**: Agent A sends a `message_type: "request"` event. Agent B sends a `message_type: "response"` with `reply_to_event_id` referencing Agent A's event. The gateway correlates request/response pairs using the event IDs.
-
-**Broadcast**: An agent sends a `message_type: "broadcast"` to a multi-agent room (more than two members). All agents in the room receive the event. No response is expected.
-
-**Delegation**: Agent A sends a `message_type: "delegate"` with a `payload.task` object describing work to be handed off to Agent B. Agent B acknowledges with `message_type: "delegate_ack"` and later sends `message_type: "delegate_complete"` when done.
-
-```
-AgentA                Gateway               AgentB
-  │   delegate(task)    │                     │
-  │────────────────────▶│                     │
-  │                     │  Matrix event push  │
-  │                     │────────────────────▶│
-  │                     │  delegate_ack       │
-  │                     │◀────────────────────│
-  │                     │  [AgentB executes]  │
-  │                     │  delegate_complete  │
-  │                     │◀────────────────────│
-  │  task result        │                     │
-  │◀────────────────────│                     │
-```
-
-### Gateway Mediation
-
-Agents do not call the Matrix Client-Server API directly. All inter-agent Matrix events are sent and received by the gateway's appservice. This means:
-
-- The gateway can intercept, log, and rate-limit agent-to-agent messages.
-- Agents that are offline (no active process) still have their messages delivered; the gateway queues them and delivers on the agent's next activation.
-- The gateway can inject system messages (e.g. human interrupts, safety stops) into agent rooms without agent cooperation.
-
----
-
-## M7-007: Multi-User Isolation in Matrix
-
-### Space-per-Team Architecture
-
-Isolation in Matrix is enforced through the Space hierarchy. Each organizational boundary in Mosaic maps to a distinct Matrix Space:
-
-| Mosaic entity                 | Matrix Space   | Visibility        |
-| ----------------------------- | -------------- | ----------------- |
-| Personal workspace (per user) | Personal Space | User only         |
-| Team                          | Team Space     | Team members only |
-| Public project                | (no Space)     | Configurable      |
-
-Rooms (conversations) are placed into Spaces based on their sharing configuration. A room can appear in at most one team Space at a time. Moving a room from one team Space to another removes the `m.space.child` link from the old Space and adds it to the new one.
-
-### Room Visibility Rules
-
-Matrix room visibility within Conduit is controlled by:
-
-1. **Join rules**: All Mosaic-managed rooms use `join_rule: invite`. Users cannot discover or join rooms without an explicit invite from the appservice.
-2. **Space membership**: Rooms appear in a Space's directory only to users who are members of that Space.
-3. **Room directory**: The server room directory is disabled for Mosaic-managed rooms (`m.room.history_visibility: shared` for team rooms, `m.room.history_visibility: invited` for personal rooms).
-
-### Personal Space Defaults
-
-When a user account is created (or linked to Matrix), the appservice provisions a personal Space:
-
-- Space name: `<username>'s Space`
-- All conversations the user creates personally are added as children of their personal Space.
-- No other users are members of this Space by default.
-- Conversation rooms within the personal Space are only visible and accessible to the owner.
-
-### Team Shared Rooms
-
-When a project or conversation is shared with a team:
-
-1. The appservice adds the room as a child of the team's Space (`m.space.child` state event in the Space room, `m.space.parent` state event in the conversation room).
-2. All current team members are invited to the conversation room.
-3. Newly added team members are automatically invited to all shared rooms in the team's Space by the appservice's team membership hook.
-4. If sharing is revoked, the appservice removes the `m.space.child` link and kicks all team members who joined via the team share (users who were directly invited are unaffected).
-
-### Encryption
-
-Encryption is optional and configured per room at creation time. Recommended defaults:
-
-| Space type     | Encryption default | Rationale                              |
-| -------------- | ------------------ | -------------------------------------- |
-| Personal Space | Enabled            | Privacy-first for individual users     |
-| Team Space     | Disabled           | Operational visibility; admin auditing |
-| Agent rooms    | Disabled           | Gateway must read structured payloads  |
-
-When encryption is enabled, the appservice's ghost users must participate in key exchange (using Matrix's Olm/Megolm protocol). The gateway holds the device keys for all ghost users it controls. This constraint means encrypted rooms require the gateway to be the E2E session holder — messages are end-to-end encrypted between human clients and gateway-held ghost device keys, not between human clients themselves.
-
-### Admin Visibility
-
-A Conduit server administrator can see:
-
-- Room metadata: names, aliases, topic, membership list.
-- Unencrypted event content in unencrypted rooms.
-
-A Conduit server administrator **cannot** see:
-
-- Content of encrypted rooms (without holding a device key for a room member).
-
-Mosaic does not grant gateway admin credentials to application-level admin users. The Conduit admin interface is restricted to infrastructure operators. Application-level admins manage users and rooms through the Mosaic API, which interacts with the appservice layer only.
-
-### Data Retention
-
-Matrix events in Mosaic-managed rooms follow Mosaic's configurable retention policy:
-
-```
-room_retention_policies
-  room_id          TEXT   -- Matrix room ID (or wildcard pattern)
-  retention_days   INT    -- NULL = keep forever
-  applies_to       TEXT   -- "personal" | "team" | "agent" | "all"
-  created_at       TIMESTAMP
-```
-
-The retention policy is enforced by a background job in the gateway that calls Conduit's admin API to purge events older than the configured threshold. Purged events are removed from the Conduit store but Mosaic's PostgreSQL message store retains the canonical `ChannelMessage` record unless the Mosaic retention policy also covers it.
-
-Default retention values:
-
-| Room type                   | Default retention   |
-| --------------------------- | ------------------- |
-| Personal conversation rooms | 365 days            |
-| Team conversation rooms     | 730 days            |
-| Agent-to-agent rooms        | 90 days             |
-| System/audit rooms          | 1825 days (5 years) |
-
-Retention settings are configurable by Mosaic admins via the admin API and apply to both the Matrix event store and the Mosaic message store in lockstep.

docs/design/storage-abstraction-middleware.md

@@ -1,555 +0,0 @@
-# Storage & Queue Abstraction — Middleware Architecture
-
-Design
-Status: Design (retrofit required)
-date: 2026-04-02
-context: Agents coupled directly to infrastructure backends, bypassing intended middleware layer
-
----
-
-## The Problem
-
-Current packages are **direct adapters**, not **middleware**:
-| Package | Current State | Intended Design |
-|---------|---------------|-----------------|
-| `@mosaic/queue` | `ioredis` hardcoded | Interface → BullMQ OR local-files |
-| `@mosaic/db` | Drizzle + Postgres hardcoded | Interface → Postgres OR SQLite OR JSON/MD |
-| `@mosaic/memory` | pgvector required | Interface → pgvector OR sqlite-vec OR keyword-search |
-
-## The gateway and TUI import these packages directly, which means they they're coupled to specific infrastructure. Users cannot run Mosaic Stack without Postgres + Valkey.
-
-## The Intended Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                     Gateway / TUI / CLI                          │
-│            (agnostic of storage backend, talks to middleware)    │
-└───────────────────────────┬─────────────────────────────────────┘
-                            │
-        ┌───────────────────┼───────────────────┐
-        │                 │                       │
-        ▼─────────────────┴─────────────────┴─────────────────┘
-        |                 |                     |                 |
-        ▼─────────────────┴───────────────────┴─────────────────┘
-        |                 |                     |                 |
-   Queue               Storage             Memory
-        |                 |                     |                 |
-   ┌─────────┬─────────┬─────────┬─────────────────────────────────┐
-   | BullMQ | | Local  | | Postgres | SQLite | JSON/MD | pgvector | sqlite-vec | keyword |
-   |(Valkey)| |(files) |         |             |         |          |          |
-   └─────────┴─────────┴─────────┴─────────────────────────────────┘
-```
-
-The gateway imports the interface, not the backend. At startup it reads config and instantiates the correct adapter.
-
-## The Drift
-
-```typescript
-// What should have happened:
-gateway/queue.service.ts → @mosaic/queue (interface) → queue.adapter.ts
-
-// What actually happened:
-gateway/queue.service.ts → @mosaic/queue → ioredis (hardcoded)
-```
-
-## The Current State Analysis
-
-### `@mosaic/queue` (packages/queue/src/queue.ts)
-
-```typescript
-import Redis from 'ioredis'; // ← Direct import of backend
-
-export function createQueue(config?: QueueConfig): QueueHandle {
-  const url = config?.url ?? process.env['VALKEY_URL'] ?? DEFAULT_VALKEY_URL;
-  const redis = new Redis(url, { maxRetriesPerRequest: 3 });
-  // ...queue ops directly on redis...
-}
-```
-
-**Problem:** `ioredis` is imported in the package, not the adapter interface. Consumers cannot swap backends.
-
-### `@mosaic/db` (packages/db/src/client.ts)
-
-```typescript
-import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import postgres from 'postgres';
-
-export function createDb(url?: string): DbHandle {
-  const connectionString = url ?? process.env['DATABASE_URL'] ?? DEFAULT_DATABASE_URL;
-  const sql = postgres(connectionString, { max: 20, idle_timeout: 30, connect_timeout: 5 });
-  const db = drizzle(sql, { schema });
-  // ...
-}
-```
-
-**Problem:** Drizzle + Postgres is hardcoded. No SQLite, JSON, or file-based options.
-
-### `@mosaic/memory` (packages/memory/src/memory.ts)
-
-```typescript
-import type { Db } from '@mosaic/db'; // ← Depends on Drizzle/PG
-
-export function createMemory(db: Db): Memory {
-  return {
-    preferences: createPreferencesRepo(db),
-    insights: createInsightsRepo(db),
-  };
-}
-```
-
-**Problem:** Memory package is tightly coupled to `@mosaic/db` (which is Postgres-only). No alternative storage backends.
-
-## The Target Interfaces
-
-### Queue Interface
-
-```typescript
-// packages/queue/src/types.ts
-export interface QueueAdapter {
-  readonly name: string;
-
-  enqueue(queueName: string, payload: TaskPayload): Promise<void>;
-  dequeue(queueName: string): Promise<TaskPayload | null>;
-  length(queueName: string): Promise<number>;
-  publish(channel: string, message: string): Promise<void>;
-  subscribe(channel: string, handler: (message: string) => void): () => void;
-  close(): Promise<void>;
-}
-
-export interface TaskPayload {
-  id: string;
-  type: string;
-  data: Record<string, unknown>;
-  createdAt: string;
-}
-
-export interface QueueConfig {
-  type: 'bullmq' | 'local';
-  url?: string; // For bullmq: Valkey/Redis URL
-  dataDir?: string; // For local: directory for JSON persistence
-}
-```
-
-### Storage Interface
-
-```typescript
-// packages/storage/src/types.ts
-export interface StorageAdapter {
-  readonly name: string;
-
-  // Entity CRUD
-  create<T>(collection: string, data: O): Promise<T>;
-  read<T>(collection: string, id: string): Promise<T | null>;
-  update<T>(collection: string, id: string, data: Partial<O>): Promise<T | null>;
-  delete(collection: string, id: string): Promise<boolean>;
-
-  // Queries
-  find<T>(collection: string, filter: Record<string, unknown>): Promise<T[]>;
-  findOne<T>(collection: string, filter: Record<string, unknown): Promise<T | null>;
-
-  // Bulk operations
-  createMany<T>(collection: string, items: O[]): Promise<T[]>;
-  updateMany<T>(collection: string, ids: string[], data: Partial<O>): Promise<number>;
-  deleteMany(collection: string, ids: string[]): Promise<number>;
-
-  // Raw queries (for complex queries)
-  query<T>(collection: string, query: string, params?: unknown[]): Promise<T[]>;
-
-  // Transaction support
-  transaction<T>(fn: (tx: StorageTransaction) => Promise<T>): Promise<T>;
-
-  close(): Promise<void>;
-}
-
-export interface StorageTransaction {
-  commit(): Promise<void>;
-  rollback(): Promise<void>;
-}
-
-export interface StorageConfig {
-  type: 'postgres' | 'sqlite' | 'files';
-  url?: string;      // For postgres
-  path?: string;      // For sqlite/files
-}
-```
-
-### Memory Interface (Vector + Preferences)
-
-```typescript
-// packages/memory/src/types.ts
-export interface MemoryAdapter {
-  readonly name: string;
-
-  // Preferences (key-value storage)
-  getPreference(userId: string, key: string): Promise<unknown | null>;
-  setPreference(userId: string, key: string, value: unknown): Promise<void>;
-  deletePreference(userId: string, key: string): Promise<boolean>;
-  listPreferences(
-    userId: string,
-    category?: string,
-  ): Promise<Array<{ key: string; value: unknown }>>;
-
-  // Insights (with optional vector search)
-  storeInsight(insight: NewInsight): Promise<Insight>;
-  getInsight(id: string): Promise<Insight | null>;
-  searchInsights(query: string, limit?: number, filter?: InsightFilter): Promise<SearchResult[]>;
-  deleteInsight(id: string): Promise<boolean>;
-
-  // Embedding provider (optional, null = no vector search)
-  readonly embedder?: EmbeddingProvider | null;
-
-  close(): Promise<void>;
-}
-
-export interface NewInsight {
-  id: string;
-  userId: string;
-  content: string;
-  embedding?: number[]; // If embedder is available
-  source: 'agent' | 'user' | 'summarization' | 'system';
-  category: 'decision' | 'learning' | 'preference' | 'fact' | 'pattern' | 'general';
-  relevanceScore: number;
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  decayedAt?: Date;
-}
-
-export interface InsightFilter {
-  userId?: string;
-  category?: string;
-  source?: string;
-  minRelevance?: number;
-  fromDate?: Date;
-  toDate?: Date;
-}
-
-export interface SearchResult {
-  documentId: string;
-  content: string;
-  distance: number;
-  metadata?: Record<string, unknown>;
-}
-
-export interface MemoryConfig {
-  type: 'pgvector' | 'sqlite-vec' | 'keyword';
-  storage: StorageAdapter;
-  embedder?: EmbeddingProvider;
-}
-
-export interface EmbeddingProvider {
-  embed(text: string): Promise<number[]>;
-  embedBatch(texts: string[]): Promise<number[][]>;
-  readonly dimensions: number;
-}
-```
-
-## Three Tiers
-
-### Tier 1: Local (Zero Dependencies)
-
-**Target:** Single user, single machine, no external services
-
-| Component | Backend                                       | Storage      |
-| --------- | --------------------------------------------- | ------------ |
-| Queue     | In-process + JSON files in `~/.mosaic/queue/` |
-| Storage   | SQLite (better-sqlite3) `~/.mosaic/data.db`   |
-| Memory    | Keyword search                                | SQLite table |
-| Vector    | None                                          | N/A          |
-
-**Dependencies:**
-
-- `better-sqlite3` (bundled)
-- No Postgres, No Valkey, No pgvector
-
-**Upgrade path:**
-
-1. Run `mosaic gateway configure` → select "local" tier
-2. Gateway starts with SQLite database
-3. Optional: run `mosaic gateway upgrade --tier team` to migrate to Postgres
-
-### Tier 2: Team (Postgres + Valkey)
-
-**Target:** Multiple users, shared server, CI/CD environments
-
-| Component | Backend        | Storage                        |
-| --------- | -------------- | ------------------------------ |
-| Queue     | BullMQ         | Valkey                         |
-| Storage   | Postgres       | Shared PG instance             |
-| Memory    | pgvector       | Postgres with vector extension |
-| Vector    | LLM embeddings | Configured provider            |
-
-**Dependencies:**
-
-- PostgreSQL 17+ with pgvector extension
-- Valkey (Redis-compatible)
-- LLM provider for embeddings
-
-**Migration from Local → Team:**
-
-1. `mosaic gateway backup` → creates dump of SQLite database
-2. `mosaic gateway upgrade --tier team` → restores to Postgres
-3. Queue replays from BullMQ (may need manual reconciliation for in-flight jobs)
-4. Memory embeddings regenerated if vector search was new
-
-### Tier 3: Enterprise (Clustered)
-
-**Target:** Large teams, multi-region, high availability
-
-| Component | Backend                     | Storage                       |
-| --------- | --------------------------- | ----------------------------- |
-| Queue     | BullMQ cluster              | Multiple Valkey nodes         |
-| Storage   | Postgres cluster            | Primary + replicas            |
-| Memory    | Dedicated vector DB         | Qdrant, Pinecone, or pgvector |
-| Vector    | Dedicated embedding service | Separate microservice         |
-
-## MarkdownDB Integration
-
-For file-based storage, we use [MarkdownDB](https://markdowndb.com) to parse MD files into queryable data.
-
-**What it provides:**
-
-- Parses frontmatter (YAML/JSON/TOML)
-- Extracts links, tags, metadata
-- Builds index in JSON or SQLite
-- Queryable via SQL-like interface
-
-**Usage in Mosaic:**
-
-```typescript
-// Local tier with MD files for documents
-const storage = createStorageAdapter({
-  type: 'files',
-  path: path.join(mosaicHome, 'docs'),
-  markdowndb: {
-    parseFrontmatter: true,
-    extractLinks: true,
-    indexFile: 'index.json',
-  },
-});
-```
-
-## Dream Mode — Memory Consolidation
-
-Automated equivalent to Claude Code's "Dream: Memory Consolidation" cycle
-
-**Trigger:** Every 24 hours (if 5+ sessions active)
-
-**Phases:**
-
-1. **Orient** — What happened, what's the current state
-   - Scan recent session logs
-   - Identify active tasks, missions, conversations
-   - Calculate time window (last 24h)
-
-2. **Gather** — Pull in relevant context
-   - Load conversations, decisions, agent logs
-   - Extract key interactions and outcomes
-   - Identify patterns and learnings
-
-3. **Consolidate** — Summarize and compress
-   - Generate summary of the last 24h
-   - Extract key decisions and their rationale
-   - Identify recurring patterns
-   - Compress verbose logs into concise insights
-
-4. **Prune** — Archive and cleanup
-   - Archive raw session files to dated folders
-   - Delete redundant/temporary data
-   - Update MEMORY.md with consolidated content
-   - Update insight relevance scores
-
-**Implementation:**
-
-```typescript
-// In @mosaic/dream (new package)
-export async function runDreamCycle(config: DreamConfig): Promise<DreamResult> {
-  const memory = await loadMemoryAdapter(config.storage);
-
-  // Orient
-  const sessions = await memory.getRecentSessions(24 * 60 * 60 * 1000);
-  if (sessions.length < 5) return { skipped: true, reason: 'insufficient_sessions' };
-
-  // Gather
-  const context = await gatherContext(memory, sessions);
-
-  // Consolidate
-  const consolidated = await consolidateWithLLM(context, config.llm);
-
-  // Prune
-  await pruneArchivedData(memory, config.retention);
-
-  // Store consolidated insights
-  await memory.storeInsights(consolidated.insights);
-
-  return {
-    sessionsProcessed: sessions.length,
-    insightsCreated: consolidated.insights.length,
-    bytesPruned: consolidated.bytesRemoved,
-  };
-}
-```
-
----
-
-## Retrofit Plan
-
-### Phase 1: Interface Extraction (2-3 days)
-
-**Goal:** Define interfaces without changing existing behavior
-
-1. Create `packages/queue/src/types.ts` with `QueueAdapter` interface
-2. Create `packages/storage/src/types.ts` with `StorageAdapter` interface
-3. Create `packages/memory/src/types.ts` with `MemoryAdapter` interface (refactor existing)
-4. Add adapter registry pattern to each package
-5. No breaking changes — existing code continues to work
-
-### Phase 2: Refactor Existing to Adapters (3-5 days)
-
-**Goal:** Move existing implementations behind adapters
-
-#### 2.1 Queue Refactor
-
-1. Rename `packages/queue/src/queue.ts` → `packages/queue/src/adapters/bullmq.ts`
-2. Create `packages/queue/src/index.ts` to export factory function
-3. Factory function reads config, instantiates correct adapter
-4. Update gateway imports to use factory
-
-#### 2.2 Storage Refactor
-
-1. Create `packages/storage/` (new package)
-2. Move Drizzle logic to `packages/storage/src/adapters/postgres.ts`
-3. Create SQLite adapter in `packages/storage/src/adapters/sqlite.ts`
-4. Update gateway to use storage factory
-5. Deprecate direct `@mosaic/db` imports
-
-#### 2.3 Memory Refactor
-
-1. Extract existing logic to `packages/memory/src/adapters/pgvector.ts`
-2. Create keyword adapter in `packages/memory/src/adapters/keyword.ts`
-3. Update vector-store.ts to be adapter-agnostic
-
-### Phase 3: Local Tier Implementation (2-3 days)
-
-**Goal:** Zero-dependency baseline
-
-1. Implement `packages/queue/src/adapters/local.ts` (in-process + JSON persistence)
-2. Implement `packages/storage/src/adapters/files.ts` (JSON + MD via MarkdownDB)
-3. Implement `packages/memory/src/adapters/keyword.ts` (TF-IDF search)
-4. Add `packages/dream/` for consolidation cycle
-5. Wire up local tier in gateway startup
-
-### Phase 4: Configuration System (1-2 days)
-
-**Goal:** Runtime backend selection
-
-1. Create `packages/config/src/storage.ts` for storage configuration
-2. Add `mosaic.config.ts` schema with storage tier settings
-3. Update gateway to read config on startup
-4. Add `mosaic gateway configure` CLI command
-5. Add tier migration commands (`mosaic gateway upgrade`)
-
-### Phase 5: Testing & Documentation (2-3 days)
-
-1. Unit tests for each adapter
-2. Integration tests for factory pattern
-3. Migration tests (local → team)
-4. Update README and architecture docs
-5. Add configuration guide
-
----
-
-## File Changes Summary
-
-### New Files
-
-```
-packages/
-├── config/
-│   └── src/
-│       ├── storage.ts          # Storage config schema
-│       └── index.ts
-├── dream/                    # NEW: Dream mode consolidation
-│   ├── src/
-│   │   ├── index.ts
-│   │   ├── orient.ts
-│   │   ├── gather.ts
-│   │   ├── consolidate.ts
-│   │   └── prune.ts
-│   └── package.json
-├── queue/
-│   └── src/
-│       ├── types.ts           # NEW: QueueAdapter interface
-│       ├── index.ts           # NEW: Factory function
-│       └── adapters/
-│           ├── bullmq.ts      # MOVED from queue.ts
-│           └── local.ts       # NEW: In-process adapter
-├── storage/                  # NEW: Storage abstraction
-│   ├── src/
-│   │   ├── types.ts           # StorageAdapter interface
-│   │   ├── index.ts           # Factory function
-│   │   └── adapters/
-│   │       ├── postgres.ts    # MOVED from @mosaic/db
-│   │       ├── sqlite.ts      # NEW: SQLite adapter
-│   │       └── files.ts       # NEW: JSON/MD adapter
-│   └── package.json
-└── memory/
-    └── src/
-        ├── types.ts           # UPDATED: MemoryAdapter interface
-        ├── index.ts           # UPDATED: Factory function
-        └── adapters/
-            ├── pgvector.ts    # EXTRACTED from existing code
-            ├── sqlite-vec.ts  # NEW: SQLite with vectors
-            └── keyword.ts     # NEW: TF-IDF search
-```
-
-### Modified Files
-
-```
-packages/
-├── db/                       # DEPRECATED: Logic moved to storage adapters
-├── queue/
-│   └── src/
-│       └── queue.ts          # → adapters/bullmq.ts
-├── memory/
-│   ├── src/
-│   │   ├── memory.ts         # → use factory
-│   │   ├── insights.ts       # → use factory
-│   │   └── preferences.ts    # → use factory
-│   └── package.json          # Remove pgvector from dependencies
-└── gateway/
-    └── src/
-        ├── database/
-        │   └── database.module.ts  # Update to use storage factory
-        ├── memory/
-        │   └── memory.module.ts  # Update to use memory factory
-        └── queue/
-            └── queue.module.ts  # Update to use queue factory
-```
-
----
-
-## Breaking Changes
-
-1. **`@mosaic/db`** → **`@mosaic/storage`** (with migration guide)
-2. Direct `ioredis` imports → Use `@mosaic/queue` factory
-3. Direct `pgvector` queries → Use `@mosaic/memory` factory
-4. Gateway startup now requires storage config (defaults to local)
-
-## Non-Breaking Migration Path
-
-1. Existing deployments with Postgres/Valkey continue to work (default config)
-2. New deployments can choose local tier
-3. Migration commands available when ready to upgrade
-
----
-
-## Success Criteria
-
-- [ ] Local tier runs with zero external dependencies
-- [ ] All three tiers (local, team, enterprise) work correctly
-- [ ] Factory pattern correctly selects backend at runtime
-- [ ] Migration from local → team preserves all data
-- [ ] Dream mode consolidates 24h of sessions
-- [ ] Documentation covers all three tiers and migration paths
-- [ ] All existing tests pass
-- [ ] New adapters have >80% coverage

docs/scratchpads/ci-docker-publish-20260330.md

@@ -1,30 +0,0 @@
-# Scratchpad: CI Docker Publish (2026-03-30)
-
-- Objective: Add Woodpecker Docker build+push steps for gateway and web images on `main` pushes.
-- Scope: `.woodpecker/ci.yml`.
-- Constraints:
-  - Use existing Dockerfiles at `docker/gateway.Dockerfile` and `docker/web.Dockerfile`.
-  - Publish to `git.mosaicstack.dev` with `from_secret` credentials.
-  - Tag both `latest` and `${CI_COMMIT_SHA}`.
-  - Do not run publish steps on pull requests.
-- ASSUMPTION: Publishing `latest` is required by the task for registry convenience, even though immutable tags remain the safer deployment reference.
-- Findings:
-  - Existing pipeline already has `build` after `lint`, `format`, and `test`.
-  - `apps/gateway/package.json` uses `tsc` for `build`; no Prisma dependency or `prisma generate` hook is present.
-- Plan:
-  1. Patch `.woodpecker/ci.yml` to keep `build` as the quality gate successor and add `publish-gateway` plus `publish-web`.
-  2. Validate YAML and run repo quality gates relevant to the change.
-  3. Review the diff, then commit/push/PR if validation passes.
-- Verification:
-  - `python3 -c "import yaml; yaml.safe_load(open('.woodpecker/ci.yml'))" && echo "YAML valid"`
-  - `pnpm lint`
-  - `pnpm typecheck`
-  - `pnpm format:check`
-  - `docker compose up -d`
-  - `pnpm --filter @mosaic/db db:push`
-  - `pnpm test`
-  - `pnpm build`
-  - Manual review of `.woodpecker/ci.yml` diff: publish steps are main-only, depend on `build`, and use secret-backed registry auth plus dual tags.
-- Risks:
-  - Pipeline behavior beyond YAML validation cannot be fully proven locally; remote Woodpecker execution will be the final situational check after push.
-  - Repo baseline required two existing `plugins/macp` files to be reformatted before `pnpm format:check` would pass.

docs/scratchpads/fix-ci-migrations-20260330.md

@@ -1,20 +0,0 @@
-# Scratchpad — fix-ci-migrations-20260330
-
-## Objective
-
-- Fix Drizzle migration journal ordering so fresh Postgres instances apply all schema migrations in CI.
-
-## Plan
-
-- Inspect migration SQL, journal, and snapshot chain.
-- Patch metadata consistently.
-- Run full test suite.
-- Record result and risks.
-
-## Progress
-
-- Inspected migration files and confirmed 0001_cynical_ultimatum.sql is missing from journal while 0002 depends on it.
-- Patched `packages/db/drizzle/meta/_journal.json` to insert `0001_cynical_ultimatum` at idx 1 and shift later entries to idx 2-7.
-- Verified snapshot content is already semantically aligned with the fixed ordering: the missing tables exist in `0001_snapshot.json`, and `mutable` appears in later snapshots.
-- Installed workspace dependencies in this worktree to make the requested test command runnable.
-- Ran `pnpm test` successfully; gateway reported `347 passed (347)` and Turbo finished with `35 successful, 35 total`.

docs/scratchpads/fix-turbo-env-passthrough.md

@@ -1,41 +0,0 @@
-# Task Scratchpad — Turbo DATABASE_URL passthrough
-
-## Objective
-
-- Fix CI test execution under Turborepo by passing DB-related environment variables through the `test` task.
-- Preserve the repo's documented local Postgres fallback on host port `5433`.
-
-## Scope
-
-- Edit `turbo.json`
-- Run baseline checks requested by the user and repo rules where feasible
-- Publish branch and open PR if checks are acceptable
-
-## Assumptions
-
-- ASSUMPTION: No PRD update is required because this is a narrow CI/config bug fix that does not change product requirements.
-- ASSUMPTION: `docs/TASKS.md` remains untouched because project guidance marks it orchestrator-only.
-- ASSUMPTION: Local Postgres-backed tests are not runnable in this worktree, so baseline verification will rely on static gates unless the environment already provides DB access.
-
-## Plan
-
-- Record current repo state and avoid touching `.mosaic/orchestrator/session.lock`
-- Add Turbo DB env declarations for test execution and cache invalidation
-- Run `pnpm format:check`, `pnpm typecheck`, and `pnpm lint`
-- Review the diff, then commit/push/PR via provider-appropriate flow
-
-## Verification Log
-
-- `pnpm install` completed in this worktree so repo tooling is available
-- `pnpm format:check` initially failed on `turbo.json`; fixed by formatting the file
-- `pnpm format:check` passed after formatting
-- `pnpm typecheck` passed
-- `pnpm lint` passed
-- Independent review flagged two important adjustments:
-  - keep `DEFAULT_DATABASE_URL` on `5433` because local Docker Compose maps host `5433 -> container 5432`
-  - prefer Turbo `env` over `passThroughEnv` so DB config changes also affect the test cache key
-
-## Risks
-
-- Existing mission/orchestrator files are dirty in the worktree and must be excluded from the scoped change.
-- Local tests were not run because no Postgres service is available in this worktree; CI remains the primary situational validation for the test-task behavior.

docs/scratchpads/macp-oc-bridge-20260330.md

@@ -1,16 +0,0 @@
-# Scratchpad: MACP OC Bridge (2026-03-30)
-
-- Objective: Replace the OpenClaw MACP plugin's Pi-direct `runTurn` with the MACP controller queue bridge.
-- Scope: `plugins/macp/src/macp-runtime.ts`, `plugins/macp/src/index.ts`, `plugins/macp/openclaw.plugin.json`, `plugins/macp/README.md`.
-- Plan:
-  1. Read controller/dispatcher/plugin docs and confirm queue/result contract.
-  2. Queue tasks through `.mosaic/orchestrator/tasks.json` using a brief file and controller trigger.
-  3. Poll result JSON, stream output back to ACP, then validate with typecheck/format checks.
-- Risks:
-  - The repo orchestrator must be enabled in `.mosaic/orchestrator/config.json`.
-  - Result JSON does not always embed worker output, so the runtime falls back to metadata-linked output files or a formatted result summary.
-- Verification:
-  - `npx tsc --noEmit --target es2022 --module nodenext --moduleResolution nodenext --skipLibCheck plugins/macp/src/macp-runtime.ts plugins/macp/src/index.ts`
-  - `pnpm prettier --write "plugins/macp/**/*.{ts,json,md}"`
-  - `pnpm format:check`
-  - `npx tsc --noEmit -p plugins/macp/tsconfig.json` still fails in this branch because `plugins/macp/tsconfig.json` extends a missing `packages/config/typescript/library.json` file and also pulls in pre-existing external OpenClaw type noise.

docs/tasks/WP1-forge-package.md

@@ -1,265 +0,0 @@
-# WP1: packages/forge — Forge Pipeline Package
-
-## Context
-
-Port the Forge progressive refinement pipeline from Python (~/src/mosaic-stack/forge/) to TypeScript as `packages/forge` in this monorepo. The pipeline markdown assets (stages, agents, personas, rails, gates, templates) are already copied to `packages/forge/pipeline/`. This task is the TypeScript implementation layer.
-
-**Board decisions that constrain this work:**
-
-- Abstract TaskExecutor interface — packages/forge must NOT hard-import packages/coord. Define an abstract interface; coord satisfies it.
-- Clean index.ts exports, no internal path leakage, no hardcoded paths
-- 85% test coverage on TS implementation files (markdown assets excluded)
-- Test strategy for non-deterministic AI orchestration: fixture-based integration tests
-- OpenBrain is OUT OF SCOPE
-- ESM only, zero Python
-
-**Dependencies available:**
-
-- `@mosaic/macp` (packages/macp) is built and provides: GateEntry, GateResult, Task types, credential resolution, gate running, event emission
-
-## Source Files (Python → TypeScript)
-
-### 1. types.ts
-
-Define all Forge-specific types:
-
-```typescript
-// Stage specification
-interface StageSpec {
-  number: string;
-  title: string;
-  dispatch: 'exec' | 'yolo' | 'pi';
-  type: 'research' | 'review' | 'coding' | 'deploy';
-  gate: string;
-  promptFile: string;
-  qualityGates: (string | GateEntry)[];
-}
-
-// Brief classification
-type BriefClass = 'strategic' | 'technical' | 'hotfix';
-type ClassSource = 'cli' | 'frontmatter' | 'auto';
-
-// Run manifest (persisted to disk)
-interface RunManifest {
-  runId: string;
-  brief: string;
-  codebase: string;
-  briefClass: BriefClass;
-  classSource: ClassSource;
-  forceBoard: boolean;
-  createdAt: string;
-  updatedAt: string;
-  currentStage: string;
-  status: 'in_progress' | 'completed' | 'failed' | 'interrupted' | 'rejected';
-  stages: Record<string, StageStatus>;
-}
-
-// Abstract task executor (decouples from packages/coord)
-interface TaskExecutor {
-  submitTask(task: ForgeTask): Promise<void>;
-  waitForCompletion(taskId: string, timeoutMs: number): Promise<TaskResult>;
-}
-
-// Persona override config
-interface ForgeConfig {
-  board?: {
-    additionalMembers?: string[];
-    skipMembers?: string[];
-  };
-  specialists?: {
-    alwaysInclude?: string[];
-  };
-}
-```
-
-### 2. constants.ts
-
-**Source:** Top of `~/src/mosaic-stack/forge/lib` (ALL_STAGES, LABELS, STAGE_SPECS equivalent) + `~/src/mosaic-stack/forge/pipeline/orchestrator/stage_adapter.py` (STAGE_TIMEOUTS)
-
-```typescript
-export const STAGE_SEQUENCE = [
-  '00-intake',
-  '00b-discovery',
-  '01-board',
-  '01b-brief-analyzer',
-  '02-planning-1',
-  '03-planning-2',
-  '04-planning-3',
-  '05-coding',
-  '06-review',
-  '07-remediate',
-  '08-test',
-  '09-deploy',
-];
-
-export const STAGE_TIMEOUTS: Record<string, number> = {
-  '00-intake': 120,
-  '00b-discovery': 300,
-  '01-board': 120,
-  '02-planning-1': 600,
-  // ... etc
-};
-
-export const STAGE_LABELS: Record<string, string> = {
-  '00-intake': 'INTAKE',
-  // ... etc
-};
-```
-
-Also: STRATEGIC_KEYWORDS, TECHNICAL_KEYWORDS for brief classification.
-
-### 3. brief-classifier.ts
-
-**Source:** `classify_brief()`, `parse_brief_frontmatter()`, `stages_for_class()` from `~/src/mosaic-stack/forge/lib`
-
-- Auto-classify brief by keyword analysis (strategic vs technical)
-- Parse YAML frontmatter for explicit `class:` field
-- CLI flag override
-- Return stage list based on classification (strategic = full pipeline, technical = skip board, hotfix = skip board + brief analyzer)
-
-### 4. stage-adapter.ts
-
-**Source:** `~/src/mosaic-stack/forge/pipeline/orchestrator/stage_adapter.py`
-
-- `mapStageToTask()`: Convert a Forge stage into a task compatible with TaskExecutor
-- Stage briefs written to `{runDir}/{stageName}/brief.md`
-- Result paths at `{runDir}/{stageName}/result.json`
-- Previous results read from disk at runtime (not baked into brief)
-- Per-stage timeouts from STAGE_TIMEOUTS
-- depends_on chain built from stage sequence
-
-### 5. board-tasks.ts
-
-**Source:** `~/src/mosaic-stack/forge/pipeline/orchestrator/board_tasks.py`
-
-- `loadBoardPersonas()`: Read all .md files from `pipeline/agents/board/`
-- `generateBoardTasks()`: One task per persona + synthesis task
-- Synthesis depends on all persona tasks with `depends_on_policy: 'all_terminal'`
-- Persona briefs include role description + brief under review
-- Synthesis script merges independent reviews into board memo
-
-### 6. pipeline-runner.ts
-
-**Source:** `~/src/mosaic-stack/forge/pipeline/orchestrator/pipeline_runner.py` + `~/src/mosaic-stack/forge/lib` (cmd_run, cmd_resume, cmd_status)
-
-- `runPipeline(briefPath, projectRoot, options)`: Full pipeline execution
-- Creates run directory at `{projectRoot}/.forge/runs/{runId}/`
-- Generates tasks for all stages, submits to TaskExecutor
-- Tracks manifest.json with stage statuses
-- `resumePipeline(runDir)`: Pick up from last incomplete stage
-- `getPipelineStatus(runDir)`: Read manifest and report
-
-**Key difference from Python:** Run output goes to PROJECT-scoped `.forge/runs/`, not inside the Forge package.
-
-### 7. Persona Override System (NEW — not in Python)
-
-- Base personas read from `packages/forge/pipeline/agents/`
-- Project overrides read from `{projectRoot}/.forge/personas/{role}.md`
-- Merge strategy: project persona content APPENDED to base persona (not replaced)
-- Board composition configurable via `{projectRoot}/.forge/config.yaml`
-- If no project config exists, use defaults (all base personas, no overrides)
-
-## Package Structure
-
-```
-packages/forge/
-├── src/
-│   ├── index.ts
-│   ├── types.ts
-│   ├── constants.ts
-│   ├── brief-classifier.ts
-│   ├── stage-adapter.ts
-│   ├── board-tasks.ts
-│   ├── pipeline-runner.ts
-│   └── persona-loader.ts
-├── pipeline/              # Already copied (WP4) — markdown assets
-│   ├── stages/
-│   ├── agents/
-│   ├── rails/
-│   ├── gates/
-│   └── templates/
-├── __tests__/
-│   ├── brief-classifier.test.ts
-│   ├── stage-adapter.test.ts
-│   ├── board-tasks.test.ts
-│   ├── pipeline-runner.test.ts
-│   └── persona-loader.test.ts
-├── package.json
-├── tsconfig.json
-└── vitest.config.ts
-```
-
-## Package.json
-
-```json
-{
-  "name": "@mosaic/forge",
-  "version": "0.0.1",
-  "type": "module",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "dependencies": {
-    "@mosaic/macp": "workspace:*"
-  },
-  "devDependencies": {
-    "vitest": "workspace:*",
-    "typescript": "workspace:*"
-  }
-}
-```
-
-Only dependency: @mosaic/macp (for gate types, event emission).
-
-## Test Strategy (Board requirement)
-
-**Deterministic code (brief-classifier, stage-adapter, board-tasks, persona-loader, constants):**
-
-- Standard unit tests with known inputs/outputs
-- 100% of classification logic, stage mapping, persona loading covered
-
-**Non-deterministic code (pipeline-runner):**
-
-- Fixture-based integration tests using a mock TaskExecutor
-- Mock executor returns pre-recorded results for each stage
-- Tests verify: manifest progression, stage ordering, dependency enforcement, resume behavior, error handling
-- NO real AI calls in tests
-
-**Markdown assets:** Excluded from coverage measurement (configure vitest to exclude `pipeline/` directory).
-
-## ESM Requirements
-
-- `"type": "module"` in package.json
-- NodeNext module resolution in tsconfig
-- `.js` extensions in all imports
-- No CommonJS
-
-## Key Design: Abstract TaskExecutor
-
-```typescript
-// In packages/forge/src/types.ts
-export interface TaskExecutor {
-  submitTask(task: ForgeTask): Promise<void>;
-  waitForCompletion(taskId: string, timeoutMs: number): Promise<TaskResult>;
-  getTaskStatus(taskId: string): Promise<TaskStatus>;
-}
-
-// In packages/coord (or wherever the concrete impl lives)
-export class CoordTaskExecutor implements TaskExecutor {
-  // ... uses packages/coord runner
-}
-```
-
-This means packages/forge can be tested with a mock executor and deployed with any backend.
-
-## Asset Resolution
-
-Pipeline markdown assets (stages, personas, rails) must be resolved relative to the package installation, NOT hardcoded paths:
-
-```typescript
-// Use import.meta.url to find package root
-const PACKAGE_ROOT = new URL('..', import.meta.url).pathname;
-const PIPELINE_DIR = path.join(PACKAGE_ROOT, 'pipeline');
-```
-
-Project-level overrides resolved relative to projectRoot parameter.

docs/tasks/WP2-macp-package.md

@@ -1,150 +0,0 @@
-# WP2: packages/macp — MACP Protocol Package
-
-## Context
-
-Port the MACP protocol layer from Python (in ~/src/mosaic-stack/tools/macp/) to TypeScript as `packages/macp` in this monorepo. This package provides the foundational protocol types, quality gate execution, credential resolution, and event system that `packages/coord` and `plugins/macp` depend on.
-
-**Board decisions that constrain this work:**
-
-- No Python in the new repo — everything rewrites to TypeScript
-- OpenBrain learning capture/recall is OUT OF SCOPE (deferred to future brief)
-- 85% test coverage on TS implementation files
-- Credential resolver behavior must be captured as test fixtures BEFORE rewrite
-- Clean index.ts exports, no internal path leakage
-
-## Source Files (Python → TypeScript)
-
-### 1. credential-resolver.ts
-
-**Source:** `~/src/mosaic-stack/tools/macp/dispatcher/credential_resolver.py`
-
-Resolution order (MUST preserve exactly):
-
-1. Mosaic credential files (`~/.config/mosaic/credentials/{provider}.env`)
-2. OpenClaw config (`~/.openclaw/openclaw.json`) — env block + models.providers.{provider}.apiKey
-3. Ambient environment variables
-4. CredentialError (failure)
-
-Key behaviors to preserve:
-
-- Provider registry: anthropic, openai, zai → env var names + credential file paths + OC config paths
-- Dotenv parser: handles single/double quotes, comments, blank lines
-- JSON5 stripping: placeholder-extraction approach (NOT naive regex) — protects URLs and timestamps inside string values
-- OC config permission check: warn on world-readable, skip if wrong owner
-- Redacted marker detection: `__OPENCLAW_REDACTED__` values skipped
-- Task-level override via `credentials.provider_key_env`
-
-### 2. gate-runner.ts
-
-**Source:** `~/src/mosaic-stack/tools/macp/controller/gate_runner.py`
-
-Three gate types:
-
-- `mechanical`: shell command, pass = exit code 0
-- `ai-review`: shell command producing JSON, parse findings, fail on blockers
-- `ci-pipeline`: placeholder (always passes for now)
-
-Key behaviors:
-
-- `normalize_gate()`: accepts string or dict, normalizes to gate entry
-- `run_gate()`: executes single gate, returns result with pass/fail
-- `run_gates()`: executes all gates, emits events, returns (all_passed, results)
-- AI review parsing: `_count_ai_findings()` reads stats.blockers or findings[].severity
-- `fail_on` modes: "blocker" (default) or "any"
-
-### 3. event-emitter.ts
-
-**Source:** `~/src/mosaic-stack/tools/macp/controller/gate_runner.py` (emit_event, append_event functions) + `~/src/mosaic-stack/tools/macp/events/`
-
-- Append structured events to ndjson file
-- Event types: task.assigned, task.started, task.completed, task.failed, task.escalated, task.gated, task.retry.scheduled, rail.check.started, rail.check.passed, rail.check.failed
-- Each event: event_id (uuid), event_type, task_id, status, timestamp, source, message, metadata
-
-### 4. types.ts
-
-**Source:** `~/src/mosaic-stack/tools/macp/protocol/task.schema.json`
-
-TypeScript types for:
-
-- Task (id, title, status, dispatch, runtime, depends_on, depends_on_policy, quality_gates, timeout_seconds, metadata, etc.)
-- Event (event_id, event_type, task_id, status, timestamp, source, message, metadata)
-- GateResult (command, exit_code, type, passed, output, findings, blockers)
-- TaskResult (task_id, status, completed_at, exit_code, gate_results, files_changed, etc.)
-- CredentialError, ProviderRegistry
-
-### 5. schemas/ (copy)
-
-Copy `~/src/mosaic-stack/tools/macp/protocol/task.schema.json` as-is.
-
-## Package Structure
-
-```
-packages/macp/
-├── src/
-│   ├── index.ts
-│   ├── types.ts
-│   ├── credential-resolver.ts
-│   ├── gate-runner.ts
-│   ├── event-emitter.ts
-│   └── schemas/
-│       └── task.schema.json
-├── __tests__/
-│   ├── credential-resolver.test.ts
-│   ├── gate-runner.test.ts
-│   └── event-emitter.test.ts
-├── package.json
-├── tsconfig.json
-└── vitest.config.ts
-```
-
-## Package.json
-
-```json
-{
-  "name": "@mosaic/macp",
-  "version": "0.0.1",
-  "type": "module",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "vitest": "workspace:*",
-    "typescript": "workspace:*"
-  }
-}
-```
-
-Zero external dependencies. Uses node:fs, node:path, node:child_process, node:crypto only.
-
-## Test Requirements
-
-Port ALL existing Python tests as TypeScript equivalents:
-
-- `test_resolve_from_file` → credential file resolution
-- `test_resolve_from_ambient` → ambient env resolution
-- `test_resolve_from_oc_config_env_block` → OC config env block
-- `test_resolve_from_oc_config_provider_apikey` → OC config provider
-- `test_oc_config_precedence` → mosaic file wins over OC config
-- `test_oc_config_missing_file` → graceful fallback
-- `test_json5_strip` → structural transforms
-- `test_json5_strip_urls_and_timestamps` → URLs/timestamps survive
-- `test_redacted_values_skipped` → redacted marker detection
-- `test_oc_config_permission_warning` → file permission check
-- `test_resolve_missing_raises` → CredentialError thrown
-- Gate runner: mechanical pass/fail, AI review parsing, ci-pipeline placeholder
-- Event emitter: append to ndjson, event structure validation
-
-## ESM Requirements
-
-- `"type": "module"` in package.json
-- NodeNext module resolution in tsconfig
-- `.js` extensions in all imports
-- No CommonJS (`require`, `module.exports`)
-
-## Integration Points
-
-After this package is built:
-
-- `packages/coord` should import `@mosaic/macp` for event emission and gate types
-- `plugins/macp` should import `@mosaic/macp` for credential resolution and protocol types

docs/tasks/WP3-mosaic-framework-plugin.md

@@ -1,63 +0,0 @@
-# WP3: plugins/mosaic-framework — OC Rails Injection Plugin
-
-## Context
-
-Port the OpenClaw framework plugin from ~/src/mosaic-stack/oc-plugins/mosaic-framework/ to `plugins/mosaic-framework` in this monorepo. This plugin injects Mosaic framework contracts (rails, completion gates, worktree requirements) into every OpenClaw agent session.
-
-**This is SEPARATE from plugins/macp:**
-
-- `mosaic-framework` = passive enforcement — injects rails into all OC sessions
-- `macp` = active runtime — provides ACP backend for MACP task execution
-
-## Source Files
-
-**Source:** `~/src/mosaic-stack/oc-plugins/mosaic-framework/`
-
-- `index.ts` — plugin hooks (before_agent_start, subagent_spawning)
-- `openclaw.plugin.json` — plugin manifest
-- `package.json`
-
-## What It Does
-
-### For OC native agents (before_agent_start hook):
-
-- Injects Mosaic global hard rules via `appendSystemContext`
-- Completion gates: code review ✓ | security review ✓ | tests GREEN ✓ | CI green ✓
-- Worker completion protocol: open PR → fire system event → EXIT — never merge
-- Worktree requirement: `~/src/{repo}-worktrees/{task-slug}`, never `/tmp`
-- Injects dynamic mission state via `prependContext` (reads from project's `.mosaic/orchestrator/mission.json`)
-
-### For ACP coding workers (subagent_spawning hook):
-
-- Writes `~/.codex/instructions.md` or `~/.claude/CLAUDE.md` BEFORE the process starts
-- Full runtime contract: mandatory load order, hard gates, mode declaration
-- Global framework rules + worktree + completion gate requirements
-
-## Implementation
-
-Port the TypeScript source, updating hardcoded paths to be configurable. The OC plugin SDK imports should reference the installed OpenClaw location dynamically (not hardcoded `/home/jarvis/` paths like the OLD version).
-
-**Structure:**
-
-```
-plugins/mosaic-framework/
-├── src/
-│   └── index.ts
-├── openclaw.plugin.json
-├── package.json
-└── tsconfig.json
-```
-
-## Key Constraint
-
-The plugin SDK imports in the OLD version use absolute paths:
-
-```typescript
-import type { OpenClawPluginApi } from '/home/jarvis/.npm-global/lib/node_modules/openclaw/dist/plugin-sdk/index.js';
-```
-
-This must be resolved dynamically or via a peer dependency. Check how `plugins/macp` handles this in the new repo and follow the same pattern.
-
-## Tests
-
-Minimal — plugin hooks are integration-tested against OC runtime. Unit test the context string builders and config resolution.

eslint.config.mjs

@@ -10,8 +10,6 @@ export default tseslint.config(
       '**/.next/**',
       '**/coverage/**',
       '**/drizzle.config.ts',
-      '**/framework/**',
-      'packages/mosaic/__tests__/**',
     ],
   },
   {
@@ -27,7 +25,6 @@ export default tseslint.config(
             'apps/web/e2e/*.ts',
             'apps/web/e2e/helpers/*.ts',
             'apps/web/playwright.config.ts',
-            'packages/mosaic/__tests__/*.ts',
           ],
         },
       },

guides/AUTHENTICATION.md

@@ -1,193 +0,0 @@
-# Authentication & Authorization Guide
-
-## Before Starting
-
-1. Check assigned issue: `~/.config/mosaic/tools/git/issue-list.sh -a @me`
-2. Review existing auth implementation in codebase
-3. Review Vault secrets structure: `docs/vault-secrets-structure.md`
-
-## Authentication Patterns
-
-### JWT (JSON Web Tokens)
-
-```
-Vault Path: secret-{env}/backend-api/jwt/signing-key
-Fields: key, algorithm, expiry_seconds
-```
-
-**Best Practices:**
-
-- Use RS256 or ES256 (asymmetric) for distributed systems
-- Use HS256 (symmetric) only for single-service auth
-- Set reasonable expiry (15min-1hr for access tokens)
-- Include minimal claims (sub, exp, iat, roles)
-- Never store sensitive data in JWT payload
-
-### Session-Based
-
-```
-Vault Path: secret-{env}/{service}/session/secret
-Fields: secret, cookie_name, max_age
-```
-
-**Best Practices:**
-
-- Use secure, httpOnly, sameSite cookies
-- Regenerate session ID on privilege change
-- Implement session timeout
-- Store sessions server-side (Redis/database)
-
-### OAuth2/OIDC
-
-```
-Vault Paths:
-- secret-{env}/{service}/oauth/{provider}/client_id
-- secret-{env}/{service}/oauth/{provider}/client_secret
-```
-
-**Best Practices:**
-
-- Use PKCE for public clients
-- Validate state parameter
-- Verify token signatures
-- Check issuer and audience claims
-
-## Authorization Patterns
-
-### Role-Based Access Control (RBAC)
-
-```python
-# Example middleware
-def require_role(roles: list):
-    def decorator(handler):
-        def wrapper(request):
-            user_roles = get_user_roles(request.user_id)
-            if not any(role in user_roles for role in roles):
-                raise ForbiddenError()
-            return handler(request)
-        return wrapper
-    return decorator
-
-@require_role(['admin', 'moderator'])
-def delete_user(request):
-    pass
-```
-
-### Permission-Based
-
-```python
-# Check specific permissions
-def check_permission(user_id, resource, action):
-    permissions = get_user_permissions(user_id)
-    return f"{resource}:{action}" in permissions
-```
-
-## Security Requirements
-
-### Password Handling
-
-- Use bcrypt, scrypt, or Argon2 for hashing
-- Minimum 12 character passwords
-- Check against breached password lists
-- Implement account lockout after failed attempts
-
-### Token Security
-
-- Rotate secrets regularly
-- Implement token revocation
-- Use short-lived access tokens with refresh tokens
-- Store refresh tokens securely (httpOnly cookies or encrypted storage)
-
-### Multi-Factor Authentication
-
-- Support TOTP (Google Authenticator compatible)
-- Consider WebAuthn for passwordless
-- Require MFA for sensitive operations
-
-## Testing Authentication
-
-### Test Cases Required
-
-```python
-class TestAuthentication:
-    def test_login_success_returns_token(self):
-        pass
-    def test_login_failure_returns_401(self):
-        pass
-    def test_invalid_token_returns_401(self):
-        pass
-    def test_expired_token_returns_401(self):
-        pass
-    def test_missing_token_returns_401(self):
-        pass
-    def test_insufficient_permissions_returns_403(self):
-        pass
-    def test_token_refresh_works(self):
-        pass
-    def test_logout_invalidates_token(self):
-        pass
-```
-
-## Authentik SSO Administration
-
-Authentik is the identity provider for the Mosaic Stack. Use the Authentik tool suite for administration.
-
-### Tool Suite
-
-```bash
-# System health
-~/.config/mosaic/tools/authentik/admin-status.sh
-
-# User management
-~/.config/mosaic/tools/authentik/user-list.sh
-~/.config/mosaic/tools/authentik/user-create.sh -u <username> -n <name> -e <email>
-
-# Group and app management
-~/.config/mosaic/tools/authentik/group-list.sh
-~/.config/mosaic/tools/authentik/app-list.sh
-~/.config/mosaic/tools/authentik/flow-list.sh
-```
-
-### Registering an OAuth Application
-
-1. Create an OAuth2 provider in Authentik admin (Applications > Providers)
-2. Create an application linked to the provider (Applications > Applications)
-3. Configure redirect URIs for the application
-4. Store client_id and client_secret in Vault: `secret-{env}/{service}/oauth/authentik/`
-5. Verify with: `~/.config/mosaic/tools/authentik/app-list.sh`
-
-### API Reference
-
-- Base URL: `https://auth.diversecanvas.com`
-- API prefix: `/api/v3/`
-- OpenAPI schema: `/api/v3/schema/`
-- Auth: Bearer token (obtained via `auth-token.sh`)
-
-## Common Vulnerabilities to Avoid
-
-1. **Broken Authentication**
-   - Weak password requirements
-   - Missing brute-force protection
-   - Session fixation
-
-2. **Broken Access Control**
-   - Missing authorization checks
-   - IDOR (Insecure Direct Object Reference)
-   - Privilege escalation
-
-3. **Security Misconfiguration**
-   - Default credentials
-   - Verbose error messages
-   - Missing security headers
-
-## Commit Format
-
-```
-feat(#89): Implement JWT authentication
-
-- Add /auth/login and /auth/refresh endpoints
-- Implement token validation middleware
-- Configure 15min access token expiry
-
-Fixes #89
-```

guides/BACKEND.md

@@ -1,125 +0,0 @@
-# Backend Development Guide
-
-## Before Starting
-
-1. Check assigned issue: `~/.config/mosaic/tools/git/issue-list.sh -a @me`
-2. Create scratchpad: `docs/scratchpads/{issue-number}-{short-name}.md`
-3. Review API contracts and database schema
-
-## Development Standards
-
-### API Design
-
-- Follow RESTful conventions (or GraphQL patterns if applicable)
-- Use consistent endpoint naming: `/api/v1/resource-name`
-- Return appropriate HTTP status codes
-- Include pagination for list endpoints
-- Document all endpoints (OpenAPI/Swagger preferred)
-
-### Database
-
-- Write migrations for schema changes
-- Use parameterized queries (prevent SQL injection)
-- Index frequently queried columns
-- Document relationships and constraints
-
-### Error Handling
-
-- Return structured error responses
-- Log errors with context (request ID, user ID if applicable)
-- Never expose internal errors to clients
-- Use appropriate error codes
-
-```json
-{
-  "error": {
-    "code": "VALIDATION_ERROR",
-    "message": "User-friendly message",
-    "details": []
-  }
-}
-```
-
-### Security
-
-- Validate all input at API boundaries
-- Implement rate limiting on public endpoints
-- Use secrets from Vault (see `docs/vault-secrets-structure.md`)
-- Never log sensitive data (passwords, tokens, PII)
-- Follow OWASP guidelines
-
-### Authentication/Authorization
-
-- Use project's established auth pattern
-- Validate tokens on every request
-- Check permissions before operations
-- See `~/.config/mosaic/guides/AUTHENTICATION.md` for details
-
-## Testing Requirements (TDD)
-
-1. Write tests BEFORE implementation
-2. Minimum 85% coverage
-3. Test categories:
-   - Unit tests for business logic
-   - Integration tests for API endpoints
-   - Database tests with transactions/rollback
-
-### Test Patterns
-
-```python
-# API test example structure
-class TestResourceEndpoint:
-    def test_create_returns_201(self):
-        pass
-    def test_create_validates_input(self):
-        pass
-    def test_get_returns_404_for_missing(self):
-        pass
-    def test_requires_authentication(self):
-        pass
-```
-
-## Code Style
-
-- Follow Google Style Guide for your language
-- **TypeScript: Follow `~/.config/mosaic/guides/TYPESCRIPT.md` — MANDATORY**
-- Use linter/formatter from project configuration
-- Keep functions focused and small
-- Document complex business logic
-
-### TypeScript Quick Rules (see TYPESCRIPT.md for full guide)
-
-- **NO `any`** — define explicit types always
-- **NO lazy `unknown`** — only for error catches and external data with validation
-- **Explicit return types** on all exported functions
-- **Explicit parameter types** always
-- **DTO files are REQUIRED** for module/API boundaries (`*.dto.ts`)
-- **Interface for DTOs** — never inline object types
-- **Typed errors** — use custom error classes
-
-## Performance
-
-- Use database connection pooling
-- Implement caching where appropriate
-- Profile slow endpoints
-- Use async operations for I/O
-
-## Commit Format
-
-```
-feat(#45): Add user registration endpoint
-
-- POST /api/v1/users for registration
-- Email validation and uniqueness check
-- Password hashing with bcrypt
-
-Fixes #45
-```
-
-## Before Completing
-
-1. Run full test suite
-2. Verify migrations work (up and down)
-3. Test API with curl/httpie
-4. Update scratchpad with completion notes
-5. Reference issue in commit

guides/BOOTSTRAP.md

@@ -1,487 +0,0 @@
-# Project Bootstrap Guide
-
-> Load this guide when setting up a new project for AI-assisted development.
-
-## Overview
-
-This guide covers how to bootstrap a project so AI agents (Claude, Codex, etc.) can work on it effectively. Proper bootstrapping ensures:
-
-1. Agents understand the project structure and conventions
-2. Orchestration works correctly with quality gates
-3. Independent code review and security review are configured
-4. Issue tracking is consistent across projects
-5. Documentation standards and API contracts are enforced from day one
-6. PRD requirements are established before coding begins
-7. Branching/merging is consistent: `branch -> main` via PR with squash-only merges
-8. Steered-autonomy execution is enabled so agents can run end-to-end with escalation-only human intervention
-
-## Quick Start
-
-```bash
-# Automated bootstrap (recommended)
-~/.config/mosaic/tools/bootstrap/init-project.sh \
-  --name "my-project" \
-  --type "nestjs-nextjs" \
-  --repo "https://git.mosaicstack.dev/owner/repo"
-
-# Or manually using templates
-export PROJECT_NAME="My Project"
-export PROJECT_DESCRIPTION="What this project does"
-export TASK_PREFIX="MP"
-envsubst < ~/.config/mosaic/templates/agent/AGENTS.md.template > AGENTS.md
-envsubst < ~/.config/mosaic/templates/agent/CLAUDE.md.template > CLAUDE.md
-```
-
----
-
-## Step 0: Enforce Sequential-Thinking MCP (Hard Requirement)
-
-`sequential-thinking` MCP must be installed and configured before project bootstrapping.
-
-```bash
-# Auto-configure sequential-thinking MCP for installed runtimes
-~/.config/mosaic/bin/mosaic-ensure-sequential-thinking
-
-# Verification-only check
-~/.config/mosaic/bin/mosaic-ensure-sequential-thinking --check
-```
-
-If this step fails, STOP and remediate Mosaic runtime configuration before continuing.
-
----
-
-## Step 1: Detect Project Type
-
-Check what files exist in the project root to determine the type:
-
-| File Present                                            | Project Type              | Template                  |
-| ------------------------------------------------------- | ------------------------- | ------------------------- |
-| `package.json` + `pnpm-workspace.yaml` + NestJS+Next.js | NestJS + Next.js Monorepo | `projects/nestjs-nextjs/` |
-| `pyproject.toml` + `manage.py`                          | Django                    | `projects/django/`        |
-| `pyproject.toml` (no Django)                            | Python (generic)          | Generic template          |
-| `package.json` (no monorepo)                            | Node.js (generic)         | Generic template          |
-| Other                                                   | Generic                   | Generic template          |
-
-```bash
-# Auto-detect project type
-detect_project_type() {
-  if [[ -f "pnpm-workspace.yaml" ]] && [[ -f "turbo.json" ]]; then
-    # Check for NestJS + Next.js
-    if grep -q "nestjs" package.json 2>/dev/null && grep -q "next" package.json 2>/dev/null; then
-      echo "nestjs-nextjs"
-      return
-    fi
-  fi
-  if [[ -f "manage.py" ]] && [[ -f "pyproject.toml" ]]; then
-    echo "django"
-    return
-  fi
-  if [[ -f "pyproject.toml" ]]; then
-    echo "python"
-    return
-  fi
-  if [[ -f "package.json" ]]; then
-    echo "nodejs"
-    return
-  fi
-  echo "generic"
-}
-```
-
----
-
-## Step 2: Create AGENTS.md (Primary Project Contract)
-
-`AGENTS.md` is the primary project-level contract for all agent runtimes.
-It defines project-specific requirements, quality gates, patterns, and testing expectations.
-
-### Using a Tech-Stack Template
-
-```bash
-# Set variables
-export PROJECT_NAME="My Project"
-export PROJECT_DESCRIPTION="Multi-tenant SaaS platform"
-export PROJECT_DIR="my-project"
-export REPO_URL="https://git.mosaicstack.dev/owner/repo"
-export TASK_PREFIX="MP"
-
-# Use tech-stack-specific template if available
-TYPE=$(detect_project_type)
-TEMPLATE_DIR="$HOME/.config/mosaic/templates/agent/projects/$TYPE"
-
-if [[ -d "$TEMPLATE_DIR" ]]; then
-  envsubst < "$TEMPLATE_DIR/AGENTS.md.template" > AGENTS.md
-else
-  envsubst < "$HOME/.config/mosaic/templates/agent/AGENTS.md.template" > AGENTS.md
-fi
-```
-
-### Using the Generic Template
-
-```bash
-# Set all required variables
-export PROJECT_NAME="My Project"
-export PROJECT_DESCRIPTION="What this project does"
-export REPO_URL="https://git.mosaicstack.dev/owner/repo"
-export PROJECT_DIR="my-project"
-export SOURCE_DIR="src"
-export CONFIG_FILES="pyproject.toml / package.json"
-export FRONTEND_STACK="N/A"
-export BACKEND_STACK="Python / FastAPI"
-export DATABASE_STACK="PostgreSQL"
-export TESTING_STACK="pytest"
-export DEPLOYMENT_STACK="Docker"
-export BUILD_COMMAND="pip install -e ."
-export TEST_COMMAND="pytest tests/"
-export LINT_COMMAND="ruff check ."
-export TYPECHECK_COMMAND="mypy ."
-export QUALITY_GATES="ruff check . && mypy . && pytest tests/"
-
-envsubst < ~/.config/mosaic/templates/agent/AGENTS.md.template > AGENTS.md
-```
-
-### Required Sections
-
-Every AGENTS.md should contain:
-
-1. **Project description** — One-line summary
-2. **Quality gates** — Commands that must pass
-3. **Codebase patterns** — Reusable implementation rules
-4. **Common gotchas** — Non-obvious constraints
-5. **Testing approaches** — Project-specific test strategy
-6. **Testing policy** — Situational-first validation and risk-based TDD
-7. **Orchestrator integration** — Task prefix, worker checklist
-8. **Documentation contract** — Required documentation gates and update expectations
-9. **PRD requirement** — `docs/PRD.md` or `docs/PRD.json` required before coding
-
----
-
-## Step 3: Create Runtime Context File (Runtime-Specific)
-
-Runtime context files are runtime adapters. They are not the primary project contract.
-Use `CLAUDE.md` for Claude runtime compatibility. Use other runtime adapters as required by your environment.
-
-Claude runtime mandate (HARD RULE):
-
-- `CLAUDE.md` MUST explicitly instruct Claude agents to read and use `AGENTS.md`.
-- `CLAUDE.md` MUST treat `AGENTS.md` as the authoritative project-level contract.
-- If `AGENTS.md` and runtime wording conflict, `AGENTS.md` project rules win.
-
-```bash
-TYPE=$(detect_project_type)
-TEMPLATE_DIR="$HOME/.config/mosaic/templates/agent/projects/$TYPE"
-
-if [[ -d "$TEMPLATE_DIR" ]]; then
-  envsubst < "$TEMPLATE_DIR/CLAUDE.md.template" > CLAUDE.md
-else
-  envsubst < "$HOME/.config/mosaic/templates/agent/CLAUDE.md.template" > CLAUDE.md
-fi
-```
-
-### Required Runtime Sections
-
-Every runtime context file should contain:
-
-1. **AGENTS handoff rule** — Runtime MUST direct agents to read/use `AGENTS.md`
-2. **Conditional documentation loading** — Required guide loading map
-3. **Technology stack** — Runtime-facing architecture summary
-4. **Repository structure** — Important paths
-5. **Development workflow** — Build/test/lint/typecheck commands
-6. **Issue tracking** — Issue and commit conventions
-7. **Code review** — Required review process
-8. **Runtime notes** — Runtime-specific behavior references
-9. **Branch and merge policy** — Trunk workflow (`branch -> main` via PR, squash-only)
-10. **Autonomy and escalation policy** — Agent owns coding/review/PR/release/deploy lifecycle
-
----
-
-## Step 4: Create Directory Structure
-
-```bash
-# Create standard directories
-mkdir -p docs/scratchpads
-mkdir -p docs/templates
-mkdir -p docs/reports/qa-automation/pending
-mkdir -p docs/reports/qa-automation/in-progress
-mkdir -p docs/reports/qa-automation/done
-mkdir -p docs/reports/qa-automation/escalated
-mkdir -p docs/reports/deferred
-mkdir -p docs/tasks
-mkdir -p docs/releases
-mkdir -p docs/USER-GUIDE docs/ADMIN-GUIDE docs/DEVELOPER-GUIDE docs/API
-
-# Documentation baseline files
-touch docs/USER-GUIDE/README.md
-touch docs/ADMIN-GUIDE/README.md
-touch docs/DEVELOPER-GUIDE/README.md
-touch docs/API/OPENAPI.yaml
-touch docs/API/ENDPOINTS.md
-touch docs/SITEMAP.md
-
-# PRD baseline file (requirements source before coding)
-cp ~/.config/mosaic/templates/docs/PRD.md.template docs/PRD.md
-
-# TASKS baseline file (canonical tracking)
-cp ~/.config/mosaic/templates/docs/TASKS.md.template docs/TASKS.md
-
-# Deployment baseline file (target/platform/runbook)
-touch docs/DEPLOYMENT.md
-```
-
-Documentation root hygiene (HARD RULE):
-
-- Keep `docs/` root clean.
-- Store reports in `docs/reports/`, archived task artifacts in `docs/tasks/`, releases in `docs/releases/`, and scratchpads in `docs/scratchpads/`.
-- Do not place ad-hoc report files directly under `docs/`.
-
----
-
-## Step 5: Initialize Repository Labels & Milestones
-
-```bash
-# Use the init script
-~/.config/mosaic/tools/bootstrap/init-repo-labels.sh
-
-# Or manually create standard labels
-~/.config/mosaic/tools/git/issue-create.sh  # (labels are created on first use)
-```
-
-### Standard Labels
-
-| Label           | Color     | Purpose                                |
-| --------------- | --------- | -------------------------------------- |
-| `epic`          | `#3E4B9E` | Large feature spanning multiple issues |
-| `feature`       | `#0E8A16` | New functionality                      |
-| `bug`           | `#D73A4A` | Defect fix                             |
-| `task`          | `#0075CA` | General work item                      |
-| `documentation` | `#0075CA` | Documentation updates                  |
-| `security`      | `#B60205` | Security-related                       |
-| `breaking`      | `#D93F0B` | Breaking change                        |
-
-### Initial Milestone (Hard Rule)
-
-Create the first pre-MVP milestone at `0.0.1`.
-Reserve `0.1.0` for the MVP release milestone.
-
-```bash
-~/.config/mosaic/tools/git/milestone-create.sh -t "0.0.1" -d "Pre-MVP - Foundation Sprint"
-
-# Create when MVP scope is complete and release-ready:
-~/.config/mosaic/tools/git/milestone-create.sh -t "0.1.0" -d "MVP - Minimum Viable Product"
-```
-
----
-
-## Step 5b: Configure Main Branch Protection (Hard Rule)
-
-Apply equivalent settings in Gitea, GitHub, or GitLab:
-
-1. Protect `main` from direct pushes.
-2. Require pull requests to merge into `main`.
-3. Require required CI/status checks to pass before merge.
-4. Require code review approval before merge.
-5. Allow **squash merge only** for PRs into `main` (disable merge commits and rebase merges for `main`).
-
-This enforces one merge strategy across human and agent workflows.
-
----
-
-## Step 6: Set Up CI/CD Review Pipeline
-
-### Woodpecker CI
-
-```bash
-# Copy Codex review pipeline
-mkdir -p .woodpecker/schemas
-cp ~/.config/mosaic/tools/codex/woodpecker/codex-review.yml .woodpecker/
-cp ~/.config/mosaic/tools/codex/schemas/*.json .woodpecker/schemas/
-
-# Add codex_api_key secret to Woodpecker CI dashboard
-```
-
-### GitHub Actions
-
-For GitHub repos, use the official Codex GitHub Action instead:
-
-```yaml
-# .github/workflows/codex-review.yml
-uses: openai/codex-action@v1
-```
-
-### Python Package Publishing (Gitea PyPI)
-
-If the project publishes Python packages, use Gitea's PyPI registry.
-
-```bash
-# Build and publish
-python -m pip install --upgrade build twine
-python -m build
-python -m twine upload \
-  --repository-url "https://GITEA_HOST/api/packages/ORG/pypi" \
-  --username "$GITEA_USERNAME" \
-  --password "$GITEA_TOKEN" \
-  dist/*
-```
-
-Use the same `gitea_username` and `gitea_token` CI secrets used for container and npm publishing.
-
----
-
-## Step 7: Verify Bootstrap
-
-After bootstrapping, verify everything works:
-
-```bash
-# Check files exist
-ls AGENTS.md docs/scratchpads/
-ls docs/reports/qa-automation/pending docs/reports/deferred docs/tasks docs/releases
-ls docs/USER-GUIDE/README.md docs/ADMIN-GUIDE/README.md docs/DEVELOPER-GUIDE/README.md
-ls docs/API/OPENAPI.yaml docs/API/ENDPOINTS.md docs/SITEMAP.md
-ls docs/PRD.md
-ls docs/TASKS.md
-
-# Verify AGENTS.md has required sections
-grep -c "Quality Gates" AGENTS.md
-grep -c "Orchestrator Integration" AGENTS.md
-grep -c "Testing Approaches" AGENTS.md
-grep -c "Testing Policy" AGENTS.md
-grep -c "Documentation Contract" AGENTS.md
-grep -c "PRD Requirement" AGENTS.md
-
-# Verify runtime context file has required sections
-if [[ -f CLAUDE.md ]]; then
-  grep -c "AGENTS.md" CLAUDE.md
-  grep -c "Conditional Documentation Loading" CLAUDE.md
-  grep -c "Technology Stack" CLAUDE.md
-  grep -c "Code Review" CLAUDE.md
-elif [[ -f RUNTIME.md ]]; then
-  grep -c "Conditional Documentation Loading" RUNTIME.md
-  grep -c "Technology Stack" RUNTIME.md
-  grep -c "Code Review" RUNTIME.md
-else
-  echo "Missing runtime context file (CLAUDE.md or RUNTIME.md)" >&2
-  exit 1
-fi
-
-# Run quality gates from AGENTS.md
-# (execute the command block under "Quality Gates")
-
-# Test Codex review (if configured)
-~/.config/mosaic/tools/codex/codex-code-review.sh --help
-
-# Verify sequential-thinking MCP remains configured
-~/.config/mosaic/bin/mosaic-ensure-sequential-thinking --check
-```
-
----
-
-## Available Templates
-
-### Generic Templates
-
-| Template                     | Path                                | Purpose                                    |
-| ---------------------------- | ----------------------------------- | ------------------------------------------ |
-| `AGENTS.md.template`         | `~/.config/mosaic/templates/agent/` | Primary project agent contract             |
-| `CLAUDE.md.template`         | `~/.config/mosaic/templates/agent/` | Runtime compatibility context (Claude)     |
-| `DOCUMENTATION-CHECKLIST.md` | `~/.config/mosaic/templates/docs/`  | Documentation completion gate              |
-| `PRD.md.template`            | `~/.config/mosaic/templates/docs/`  | Requirements source template               |
-| `TASKS.md.template`          | `~/.config/mosaic/templates/docs/`  | Canonical task and issue tracking template |
-
-### Tech-Stack Templates
-
-| Stack            | Path                                                       | Includes                             |
-| ---------------- | ---------------------------------------------------------- | ------------------------------------ |
-| NestJS + Next.js | `~/.config/mosaic/templates/agent/projects/nestjs-nextjs/` | AGENTS.md + runtime context template |
-| Django           | `~/.config/mosaic/templates/agent/projects/django/`        | AGENTS.md + runtime context template |
-
-### Orchestrator Templates
-
-| Template                               | Path                                              | Purpose                 |
-| -------------------------------------- | ------------------------------------------------- | ----------------------- |
-| `tasks.md.template`                    | `~/src/jarvis-brain/docs/templates/orchestrator/` | Task tracking           |
-| `orchestrator-learnings.json.template` | `~/src/jarvis-brain/docs/templates/orchestrator/` | Variance tracking       |
-| `phase-issue-body.md.template`         | `~/src/jarvis-brain/docs/templates/orchestrator/` | Git provider issue body |
-| `scratchpad.md.template`               | `~/src/jarvis-brain/docs/templates/`              | Per-task working doc    |
-
-### Variables Reference
-
-| Variable                 | Description                 | Example                                    |
-| ------------------------ | --------------------------- | ------------------------------------------ |
-| `${PROJECT_NAME}`        | Human-readable project name | "Mosaic Stack"                             |
-| `${PROJECT_DESCRIPTION}` | One-line description        | "Multi-tenant platform"                    |
-| `${PROJECT_DIR}`         | Directory name              | "mosaic-stack"                             |
-| `${PROJECT_SLUG}`        | Python package slug         | "mosaic_stack"                             |
-| `${REPO_URL}`            | Git remote URL              | "https://git.mosaicstack.dev/mosaic/stack" |
-| `${TASK_PREFIX}`         | Orchestrator task prefix    | "MS"                                       |
-| `${SOURCE_DIR}`          | Source code directory       | "src" or "apps"                            |
-| `${QUALITY_GATES}`       | Quality gate commands       | "pnpm typecheck && pnpm lint && pnpm test" |
-| `${BUILD_COMMAND}`       | Build command               | "pnpm build"                               |
-| `${TEST_COMMAND}`        | Test command                | "pnpm test"                                |
-| `${LINT_COMMAND}`        | Lint command                | "pnpm lint"                                |
-| `${TYPECHECK_COMMAND}`   | Type check command          | "pnpm typecheck"                           |
-| `${FRONTEND_STACK}`      | Frontend technologies       | "Next.js + React"                          |
-| `${BACKEND_STACK}`       | Backend technologies        | "NestJS + Prisma"                          |
-| `${DATABASE_STACK}`      | Database technologies       | "PostgreSQL"                               |
-| `${TESTING_STACK}`       | Testing technologies        | "Vitest + Playwright"                      |
-| `${DEPLOYMENT_STACK}`    | Deployment technologies     | "Docker"                                   |
-| `${CONFIG_FILES}`        | Key config files            | "package.json, tsconfig.json"              |
-
----
-
-## Bootstrap Scripts
-
-### init-project.sh
-
-Full project bootstrap with interactive and flag-based modes:
-
-```bash
-~/.config/mosaic/tools/bootstrap/init-project.sh \
-  --name "My Project" \
-  --type "nestjs-nextjs" \
-  --repo "https://git.mosaicstack.dev/owner/repo" \
-  --prefix "MP" \
-  --description "Multi-tenant platform"
-```
-
-### init-repo-labels.sh
-
-Initialize standard labels and the first pre-MVP milestone:
-
-```bash
-~/.config/mosaic/tools/bootstrap/init-repo-labels.sh
-```
-
----
-
-## Checklist
-
-After bootstrapping, verify:
-
-- [ ] `AGENTS.md` exists and is the primary project contract
-- [ ] Runtime context file exists (`CLAUDE.md` or `RUNTIME.md`)
-- [ ] `docs/scratchpads/` directory exists
-- [ ] `docs/reports/qa-automation/pending` directory exists
-- [ ] `docs/reports/deferred/` directory exists
-- [ ] `docs/tasks/` directory exists
-- [ ] `docs/releases/` directory exists
-- [ ] `docs/USER-GUIDE/README.md` exists
-- [ ] `docs/ADMIN-GUIDE/README.md` exists
-- [ ] `docs/DEVELOPER-GUIDE/README.md` exists
-- [ ] `docs/API/OPENAPI.yaml` exists
-- [ ] `docs/API/ENDPOINTS.md` exists
-- [ ] `docs/SITEMAP.md` exists
-- [ ] `docs/PRD.md` or `docs/PRD.json` exists
-- [ ] `docs/TASKS.md` exists and is ready for active tracking
-- [ ] `docs/DEPLOYMENT.md` exists with target platform and rollback notes
-- [ ] `sequential-thinking` MCP is configured and verification check passes
-- [ ] Git labels created (epic, feature, bug, task, etc.)
-- [ ] Initial pre-MVP milestone created (0.0.1)
-- [ ] MVP milestone reserved for release (0.1.0)
-- [ ] `main` is protected from direct pushes
-- [ ] PRs into `main` are required
-- [ ] Merge method for `main` is squash-only
-- [ ] Quality gates run successfully
-- [ ] `.env.example` exists (if project uses env vars)
-- [ ] CI/CD pipeline configured (if using Woodpecker/GitHub Actions)
-- [ ] Python publish path configured in CI (if project ships Python packages)
-- [ ] Codex review scripts accessible (`~/.config/mosaic/tools/codex/`)

guides/CODE-REVIEW.md

@@ -1,154 +0,0 @@
-# Code Review Guide
-
-## Hard Requirement
-
-If an agent modifies source code, code review is REQUIRED before completion.
-Do not mark code-change tasks done until review is completed and blockers are resolved or explicitly tracked.
-If code/config/API contract/auth behavior changed and required docs are missing, this is a BLOCKER.
-If tests pass but acceptance criteria are not verified by situational evidence, this is a BLOCKER.
-If implementation diverges from `docs/PRD.md` or `docs/PRD.json` without PRD updates, this is a BLOCKER.
-
-Merge strategy enforcement (HARD RULE):
-
-- PR target for delivery is `main`.
-- Direct pushes to `main` are prohibited.
-- Merge to `main` MUST be squash-only.
-- Use `~/.config/mosaic/tools/git/pr-merge.sh -n {PR_NUMBER} -m squash` (or PowerShell equivalent).
-
-## Review Checklist
-
-### 1. Correctness
-
-- [ ] Code does what the issue/PR description says
-- [ ] Code aligns with active PRD requirements
-- [ ] Acceptance criteria are mapped to concrete verification evidence
-- [ ] Edge cases are handled
-- [ ] Error conditions are managed properly
-- [ ] No obvious bugs or logic errors
-
-### 2. Security
-
-- [ ] No hardcoded secrets or credentials
-- [ ] Input validation at boundaries
-- [ ] SQL injection prevention (parameterized queries)
-- [ ] XSS prevention (output encoding)
-- [ ] Authentication/authorization checks present
-- [ ] Sensitive data not logged
-- [ ] Secrets follow Vault structure (see `docs/vault-secrets-structure.md`)
-
-### 2a. OWASP Coverage (Required)
-
-- [ ] OWASP Top 10 categories were reviewed for change impact
-- [ ] Access control checks verified on protected actions
-- [ ] Cryptographic handling validated (keys, hashing, TLS assumptions)
-- [ ] Injection risks reviewed for all untrusted inputs
-- [ ] Security misconfiguration risks reviewed (headers, CORS, defaults)
-- [ ] Dependency/component risk reviewed (known vulnerable components)
-- [ ] Authentication/session flows reviewed for failure paths
-- [ ] Logging/monitoring preserves detection without leaking sensitive data
-
-### 3. Testing
-
-- [ ] Tests exist for new functionality
-- [ ] Tests cover happy path AND error cases
-- [ ] Situational tests cover all impacted change surfaces (primary gate)
-- [ ] Tests validate required behavior/outcomes, not only internal implementation details
-- [ ] TDD was applied when required by `~/.config/mosaic/guides/QA-TESTING.md`
-- [ ] Coverage meets 85% minimum
-- [ ] Tests are readable and maintainable
-- [ ] No flaky tests introduced
-
-### 4. Code Quality
-
-- [ ] Follows Google Style Guide for the language
-- [ ] Functions are focused and reasonably sized
-- [ ] No unnecessary complexity
-- [ ] DRY - no significant duplication
-- [ ] Clear naming for variables and functions
-- [ ] No dead code or commented-out code
-
-### 4a. TypeScript Strict Typing (see `TYPESCRIPT.md`)
-
-- [ ] **NO `any` types** — explicit types required everywhere
-- [ ] **NO lazy `unknown`** — only for error catches with immediate narrowing
-- [ ] **Explicit return types** on all exported/public functions
-- [ ] **Explicit parameter types** — never implicit any
-- [ ] **No type assertions** (`as Type`) — use type guards instead
-- [ ] **No non-null assertions** (`!`) — use proper null handling
-- [ ] **Interfaces for objects** — not inline types
-- [ ] **Discriminated unions** for variant types
-- [ ] **DTO files used at boundaries** — module/API contracts are in `*.dto.ts`, not inline payload types
-
-### 5. Documentation
-
-- [ ] Complex logic has explanatory comments
-- [ ] Required docs updated per `~/.config/mosaic/guides/DOCUMENTATION.md`
-- [ ] Public APIs are documented
-- [ ] Private/internal APIs are documented
-- [ ] API input/output schemas are documented
-- [ ] API permissions/auth requirements are documented
-- [ ] Site map updates are present when navigation changed
-- [ ] README updated if needed
-- [ ] Breaking changes noted
-
-### 6. Performance
-
-- [ ] No obvious N+1 queries
-- [ ] No blocking operations in hot paths
-- [ ] Resource cleanup (connections, file handles)
-- [ ] Reasonable memory usage
-
-### 7. Dependencies
-
-- [ ] No deprecated packages
-- [ ] No unnecessary new dependencies
-- [ ] Dependency versions pinned appropriately
-
-## Review Process
-
-Use `~/.config/mosaic/templates/docs/DOCUMENTATION-CHECKLIST.md` whenever code/API/auth/infra changes are present.
-
-### Getting Context
-
-```bash
-# List the issue being addressed
-~/.config/mosaic/tools/git/issue-list.sh -i {issue-number}
-
-# View the changes
-git diff main...HEAD
-```
-
-### Providing Feedback
-
-- Be specific: point to exact lines/files
-- Explain WHY something is problematic
-- Suggest alternatives when possible
-- Distinguish between blocking issues and suggestions
-- Be constructive, not critical of the person
-
-### Feedback Categories
-
-- **Blocker**: Must fix before merge (security, bugs, test failures)
-- **Should Fix**: Important but not blocking (code quality, minor issues)
-- **Suggestion**: Optional improvements (style preferences, nice-to-haves)
-- **Question**: Seeking clarification
-
-### Review Comment Format
-
-```
-[BLOCKER] Line 42: SQL injection vulnerability
-The user input is directly interpolated into the query.
-Use parameterized queries instead:
-`db.query("SELECT * FROM users WHERE id = ?", [userId])`
-
-[SUGGESTION] Line 78: Consider extracting to helper
-This pattern appears in 3 places. A shared helper would reduce duplication.
-```
-
-## After Review
-
-1. Update issue with review status
-2. If changes requested, assign back to author
-3. If approved, note approval in issue comments
-4. For merges, ensure CI passes first
-5. Merge PR to `main` with squash strategy only

guides/DOCUMENTATION.md

@@ -1,132 +0,0 @@
-# Documentation Standard (MANDATORY)
-
-This guide defines REQUIRED documentation behavior for all Mosaic projects.
-If code, API contracts, auth, or infrastructure changes, documentation updates are REQUIRED before completion.
-
-## Hard Rules
-
-1. Documentation is a delivery gate. Missing required documentation is a BLOCKER.
-2. `docs/PRD.md` or `docs/PRD.json` is REQUIRED as the project requirements source before coding begins.
-3. API documentation is OpenAPI-first. `docs/API/OPENAPI.yaml` (or `.json`) is the canonical API contract.
-4. Public and private/internal endpoints MUST be documented.
-5. API input and output schemas MUST be documented.
-6. API authentication and permissions MUST be documented per endpoint.
-7. A current site map MUST exist at `docs/SITEMAP.md`.
-8. Documentation updates MUST be committed in the same logical change set as the code/API change.
-9. Generated publishing output (Docusaurus/VitePress/MkDocs artifacts) is not canonical unless the project explicitly declares it canonical.
-10. `docs/` root MUST stay clean. Reports and working artifacts MUST be stored in dedicated subdirectories, not dumped at `docs/` root.
-
-## Required Documentation Structure
-
-```text
-docs/
-  PRD.md (or PRD.json)
-  TASKS.md (active orchestrator tracking, when orchestrator is used)
-  SITEMAP.md
-  USER-GUIDE/
-  ADMIN-GUIDE/
-  DEVELOPER-GUIDE/
-  API/
-    OPENAPI.yaml
-    ENDPOINTS.md
-  scratchpads/
-  reports/
-  tasks/
-  releases/
-  templates/ (optional)
-```
-
-Minimum requirements:
-
-- `docs/PRD.md` or `docs/PRD.json`: authoritative requirements source for implementation and testing.
-- `docs/USER-GUIDE/`: End-user workflows, feature behavior, common troubleshooting.
-- `docs/ADMIN-GUIDE/`: Configuration, deployment, operations, incident/recovery procedures.
-- `docs/DEVELOPER-GUIDE/`: Architecture, local setup, contribution/testing workflow, design constraints.
-- `docs/API/OPENAPI.yaml`: API SSOT for all HTTP endpoints.
-- `docs/API/ENDPOINTS.md`: Human-readable index for API endpoints, permissions, and change notes.
-- `docs/SITEMAP.md`: Navigation index for all user/admin/developer/API documentation pages.
-- `docs/reports/`: Review outputs, QA automation reports, deferrals, and audit artifacts.
-- `docs/tasks/`: Archived task snapshots and orchestrator learnings.
-- `docs/releases/`: Release notes and release-specific documentation.
-- `docs/scratchpads/`: Active task-level working notes.
-
-## Root Hygiene Rule (MANDATORY)
-
-Allowed root documentation files are intentionally limited:
-
-1. `docs/PRD.md` or `docs/PRD.json`
-2. `docs/TASKS.md` (active milestone only, when task orchestration is in use)
-3. `docs/SITEMAP.md`
-4. `docs/README.md` (optional index)
-
-All other docs MUST be placed in scoped folders (`docs/reports/`, `docs/tasks/`, `docs/releases/`, `docs/scratchpads/`, `docs/API/`, guide books).
-
-## Artifact Placement Rules
-
-| Artifact Type                              | REQUIRED Location                        |
-| ------------------------------------------ | ---------------------------------------- |
-| Code review reports, QA reports, audits    | `docs/reports/<category>/`               |
-| Deferred error lists / unresolved findings | `docs/reports/deferred/`                 |
-| Archived milestone task snapshots          | `docs/tasks/`                            |
-| Orchestrator learnings JSON                | `docs/tasks/orchestrator-learnings.json` |
-| Release notes                              | `docs/releases/`                         |
-| Active scratchpads                         | `docs/scratchpads/`                      |
-
-## API Documentation Contract (OpenAPI-First)
-
-For every API endpoint, documentation MUST include:
-
-1. visibility: `public` or `private/internal`
-2. method and path
-3. endpoint purpose
-4. request/input schema
-5. response/output schema(s)
-6. auth method and required permission/role/scope
-7. error status codes and behavior
-
-If OpenAPI cannot fully express an internal constraint, document it in `docs/API/ENDPOINTS.md`.
-
-## Book/Chapter/Page Structure
-
-Use this structure for every guide:
-
-1. Book: one root guide folder (`USER-GUIDE`, `ADMIN-GUIDE`, `DEVELOPER-GUIDE`)
-2. Chapter: one subdirectory per topic area
-3. Page: one focused markdown file per concern
-
-Required index files:
-
-1. `docs/USER-GUIDE/README.md`
-2. `docs/ADMIN-GUIDE/README.md`
-3. `docs/DEVELOPER-GUIDE/README.md`
-
-Each index file MUST link to all chapters and pages in that book.
-
-## Situational Documentation Matrix
-
-| Change Surface                                 | REQUIRED Documentation Updates                              |
-| ---------------------------------------------- | ----------------------------------------------------------- |
-| New feature or behavior change                 | User guide + developer guide + sitemap                      |
-| API endpoint added/changed/removed             | OpenAPI + API endpoint index + sitemap                      |
-| Auth/RBAC/permission change                    | API auth/permission docs + admin guide + developer guide    |
-| Database schema/migration change               | Developer guide + admin operational notes if runbook impact |
-| CI/CD or deployment change                     | Admin guide + developer guide                               |
-| Incident, recovery, or security control change | Admin guide runbook + security notes + sitemap              |
-
-## Publishing Target Rule (MANDATORY)
-
-If the user does not specify documentation publishing target, the agent MUST ask:
-
-1. Publish in-app (embedded docs)
-2. Publish on external docs platform (for example: Docusaurus, VitePress, MkDocs)
-
-Default behavior before publishing decision:
-
-- Keep canonical docs in-repo under `docs/`.
-- Do not assume external publishing platform.
-
-## Completion Gate
-
-You MUST NOT declare completion until all required documentation updates are done.
-
-Use `~/.config/mosaic/templates/docs/DOCUMENTATION-CHECKLIST.md` as the final gate.

guides/E2E-DELIVERY.md

@@ -1,210 +0,0 @@
-# E2E Delivery Procedure (MANDATORY)
-
-This guide is REQUIRED for all agent sessions.
-
-## 0. Mode Handshake (Before Any Action)
-
-First response MUST declare mode before tool calls or implementation steps:
-
-1. Orchestration mission: `Now initiating Orchestrator mode...`
-2. Implementation mission: `Now initiating Delivery mode...`
-3. Review-only mission: `Now initiating Review mode...`
-
-## 1. PRD Gate (Before Coding)
-
-1. Ensure `docs/PRD.md` or `docs/PRD.json` exists before coding.
-2. Load `~/.config/mosaic/guides/PRD.md`.
-3. Prepare/update PRD from user input and available project context.
-4. If requirements are missing:
-   - proceed with best-guess assumptions by default,
-   - mark each assumption with `ASSUMPTION:` and rationale,
-   - escalate only when uncertainty is high-impact and cannot be bounded safely.
-5. Treat PRD as the requirement source for implementation, testing, and review.
-
-## 1a. Tracking Gate (Before Coding)
-
-1. For non-trivial work, `docs/TASKS.md` MUST exist before coding.
-2. If `docs/TASKS.md` is missing, create it from `~/.config/mosaic/templates/docs/TASKS.md.template`.
-3. Detect provider first via `~/.config/mosaic/tools/git/detect-platform.sh`.
-4. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/tools/git/*.sh`).
-5. If external git provider is available (Gitea/GitHub/GitLab), create or update issue(s) before coding.
-6. Record provider issue reference(s) in `docs/TASKS.md` (example: `#123`).
-7. If no external provider is available, use internal task refs in `docs/TASKS.md` (example: `TASKS:T1`).
-8. Scratchpad MUST reference both task ID and issue/internal ref.
-
-## 2. Intake and Scope
-
-> **COMPLEXITY TRAP WARNING:** Intake applies to ALL tasks regardless of perceived complexity. "Simple" tasks (commit, push, deploy) have caused the most severe framework violations because agents skip intake when they pattern-match a task as mechanical. The procedure is unconditional.
-
-1. Define scope, constraints, and acceptance criteria.
-2. Identify affected surfaces (API, DB, UI, infra, auth, CI/CD, docs).
-3. **Deployment surface check (MANDATORY if task involves deploy, images, or containers):** Before ANY build or deploy action, check for CI/CD pipeline config (`.woodpecker/`, `.woodpecker.yml`, `.github/workflows/`). If pipelines exist, CI is the canonical build path — manual `docker build`/`docker push` is forbidden. Load `~/.config/mosaic/guides/CI-CD-PIPELINES.md` immediately.
-4. Identify required guides and load them before implementation.
-5. For code/API/auth/infra changes, load `~/.config/mosaic/guides/DOCUMENTATION.md`.
-6. Determine budget constraints:
-   - if the user provided a plan limit or token budget, treat it as a HARD cap,
-   - if budget is unknown, derive a working budget from estimates and runtime limits, then continue autonomously.
-7. Record budget assumptions and caps in the scratchpad before implementation starts.
-8. Track estimated vs used tokens per logical unit and adapt strategy to remain inside budget.
-9. If projected usage exceeds budget, auto-reduce scope/parallelism first; escalate only if cap still cannot be met.
-
-## 2a. Steered Autonomy (Lights-Out)
-
-1. Agent owns delivery end-to-end: planning, coding, testing, review, PR/repo operations, release/tag, and deployment (when in scope).
-2. Human intervention is escalation-only; do not pause for routine approvals or handoffs.
-3. Continue execution until completion criteria are met or an escalation trigger is hit.
-
-## 3. Scratchpad Requirement
-
-1. Create a task-specific scratchpad before implementation.
-2. Record:
-   - objective
-   - plan
-   - progress checkpoints
-   - tests run
-   - risks/blockers
-   - final verification evidence
-
-## 4. Embedded Execution Cycle (MANDATORY)
-
-For implementation work, you MUST run this cycle in order:
-
-1. `plan` - map PRD requirements to concrete implementation steps.
-2. `code` - implement one logical unit.
-3. `test` - run required baseline and situational checks for that unit.
-4. `review` - perform independent code review on the current delta.
-5. `remediate` - fix all findings and any test failures.
-6. `review` - re-review remediated changes until blockers are cleared.
-7. `commit` - commit only when the logical unit passes tests and review.
-8. `pre-push queue guard` - before pushing, wait for running/queued project pipelines to clear: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push`.
-9. `push` - push immediately after queue guard passes.
-10. `PR integration` - if external git provider is available, create/update PR to `main` and merge with required strategy via Mosaic wrappers.
-11. `pre-merge queue guard` - before merging PR, wait for running/queued project pipelines to clear: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose merge`.
-12. `CI/pipeline verification` - wait for terminal CI status and require green before completion (`~/.config/mosaic/tools/git/pr-ci-wait.sh` for PR-based workflow).
-13. `issue closure` - close linked external issue (or close internal `docs/TASKS.md` task ref when provider is unavailable).
-14. `greenfield situational test` - validate required user flows in a clean environment/startup path (post-merge for trunk workflow changes).
-15. `deploy + post-deploy validation` - when deployment is in scope, deploy to configured target and run post-deploy health/smoke checks.
-16. `repeat` - continue until all acceptance criteria are complete.
-
-### Post-PR Hard Gate (Execute Sequentially, No Exceptions)
-
-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>`
-4. `~/.config/mosaic/tools/git/issue-close.sh -i <ISSUE_NUMBER>` (or close internal `docs/TASKS.md` ref when no provider exists)
-5. If any step fails: set status `blocked`, report the exact failed wrapper command, and stop.
-6. Do not ask the human to perform routine merge/close operations.
-7. Do not claim completion before step 4 succeeds.
-
-### Forbidden Anti-Patterns
-
-**PR/Merge:**
-
-1. Do NOT stop at "PR created" or "PR updated".
-2. Do NOT ask "should I merge?" for routine delivery PRs.
-3. Do NOT ask "should I close the issue?" after merge + green CI.
-
-**Build/Deploy:** 4. Do NOT run `docker build` or `docker push` locally to deploy images when CI/CD pipelines exist in the repository. CI is the ONLY canonical build path. 5. Do NOT skip intake and surface identification because a task "seems simple." This is the #1 cause of framework violations. 6. Do NOT deploy without first verifying whether CI/CD pipelines exist (`.woodpecker/`, `.woodpecker.yml`, `.github/workflows/`). If they exist, use them. 7. If you are about to run `docker build` and have NOT loaded `ci-cd-pipelines.md`, STOP — you are violating the framework.
-
-If any step fails, you MUST remediate and re-run from the relevant step before proceeding.
-If push-queue/merge-queue/PR merge/CI/issue closure fails, status is `blocked` (not complete) and you MUST report the exact failed wrapper command.
-
-## 5. Testing Priority Model
-
-Use this order of priority:
-
-1. Situational tests are the PRIMARY gate and MUST prove changed behavior meets requirements.
-2. Baseline tests are REQUIRED safety checks and MUST run for all software changes.
-3. TDD is risk-based and REQUIRED only for specific high-risk change types.
-
-## 6. Mandatory Test Baseline
-
-For all software changes, you MUST run baseline checks applicable to the repo/toolchain:
-
-1. lint (or equivalent static checks)
-2. type checks (if language/tooling supports it)
-3. unit tests for changed logic
-4. integration tests for changed boundaries
-
-## 7. Situational Testing Matrix (PRIMARY GATE)
-
-Run additional tests based on what changed:
-
-| Change Surface               | Required Situational Tests                                                    |
-| ---------------------------- | ----------------------------------------------------------------------------- |
-| Authentication/authorization | auth failure-path tests, permission boundary tests, token/session validation  |
-| Database schema/migrations   | migration up/down validation, rollback safety, data integrity checks          |
-| API contract changes         | backward compatibility checks, consumer-impact tests, contract tests          |
-| Frontend/UI workflow changes | end-to-end flow tests, accessibility sanity checks, state transition checks   |
-| CI/CD or deployment changes  | pipeline execution validation, artifact integrity checks, rollback path check |
-| Security-sensitive logic     | abuse-case tests, input validation fuzzing/sanitization checks                |
-| Performance-critical path    | baseline comparison, regression threshold checks                              |
-
-## 8. Risk-Based TDD Requirement
-
-TDD is REQUIRED for:
-
-1. bug fixes (write a reproducer test first)
-2. security/auth/permission logic changes
-3. critical business logic and data-mutation rules
-
-TDD is RECOMMENDED (not mandatory) for low-risk UI, copy, styling, and mechanical refactors.
-If TDD is skipped for a non-required case, record the rationale in the scratchpad.
-
-## 9. Mandatory Code Review Gate
-
-If you modify source code, you MUST run an independent code review before completion.
-
-1. Use automated review tooling when available.
-2. If automated tooling is unavailable, run manual review using `~/.config/mosaic/guides/CODE-REVIEW.md`.
-3. Any blocker or critical finding MUST be fixed or tracked as an explicit remediation task before closure.
-
-## 10. Mandatory Documentation Gate
-
-For code/API/auth/infra changes, documentation updates are REQUIRED before completion.
-
-1. Apply the standard in `~/.config/mosaic/guides/DOCUMENTATION.md`.
-2. Update required docs in the same logical change set as implementation.
-3. Complete `~/.config/mosaic/templates/docs/DOCUMENTATION-CHECKLIST.md`.
-4. If publish platform is unspecified, ask the user to choose in-app or external platform before publishing.
-5. Missing required documentation is a BLOCKER.
-
-## 11. Completion Gate (All Required)
-
-You MUST satisfy all items before completion:
-
-1. Acceptance criteria met.
-2. Baseline tests passed.
-3. Situational tests passed (primary gate), including required greenfield situational validation.
-4. PRD is current and implementation is aligned with PRD.
-5. Acceptance criteria mapped to verification evidence.
-6. Code review completed for source code changes.
-7. Required documentation updates completed and reviewed.
-8. Scratchpad updated with evidence.
-9. Known risks documented.
-10. No unresolved blocker hidden.
-11. If deployment is in scope, deployment target, release version, and post-deploy verification evidence are documented.
-12. `docs/TASKS.md` status and issue/internal references are updated to match delivered work.
-13. If source code changed and external provider is available: PR merged to `main` (squash), with merge evidence recorded.
-14. CI/pipeline status is terminal green for the merged PR/head commit.
-15. Linked external issue is closed (or internal task ref is closed when no provider exists).
-16. If any of items 13-15 fail due access/tooling, report `blocked` with exact failed wrapper command and do not claim completion.
-
-## 12. Review and Reporting
-
-Completion report MUST include:
-
-1. what changed
-2. PRD alignment summary
-3. acceptance criteria to evidence mapping
-4. what was tested (baseline + situational)
-5. what was reviewed (code review scope)
-6. what documentation was updated
-7. command-level evidence summary
-8. residual risks
-9. deployment and post-deploy verification summary (if in scope)
-10. explicit pass/fail status
-11. tracking summary (`docs/TASKS.md` updates and issue/internal refs)
-12. PR lifecycle summary (PR number, merge commit, merge method)
-13. CI/pipeline summary (run/check URL, terminal status)
-14. issue closure summary (issue number/ref and close evidence)

guides/FRONTEND.md

@@ -1,91 +0,0 @@
-# Frontend Development Guide
-
-## Before Starting
-
-1. Check assigned issue in git repo: `~/.config/mosaic/tools/git/issue-list.sh -a @me`
-2. Create scratchpad: `docs/scratchpads/{issue-number}-{short-name}.md`
-3. Review existing components and patterns in the codebase
-
-## Development Standards
-
-### Framework Conventions
-
-- Follow project's existing framework patterns (React, Vue, Svelte, etc.)
-- Use existing component library/design system if present
-- Maintain consistent file structure with existing code
-
-### Styling
-
-- Use project's established styling approach (CSS modules, Tailwind, styled-components, etc.)
-- Follow existing naming conventions for CSS classes
-- Ensure responsive design unless explicitly single-platform
-
-### State Management
-
-- Use project's existing state management solution
-- Keep component state local when possible
-- Document any new global state additions
-
-### Accessibility
-
-- Include proper ARIA labels
-- Ensure keyboard navigation works
-- Test with screen reader considerations
-- Maintain color contrast ratios (WCAG 2.1 AA minimum)
-
-## Testing Requirements (TDD)
-
-1. Write tests BEFORE implementation
-2. Minimum 85% coverage
-3. Test categories:
-   - Unit tests for utility functions
-   - Component tests for UI behavior
-   - Integration tests for user flows
-
-### Test Patterns
-
-```javascript
-// Component test example structure
-describe('ComponentName', () => {
-  it('renders without crashing', () => {});
-  it('handles user interaction correctly', () => {});
-  it('displays error states appropriately', () => {});
-  it('is accessible', () => {});
-});
-```
-
-## Code Style
-
-- Follow Google JavaScript/TypeScript Style Guide
-- **TypeScript: Follow `~/.config/mosaic/guides/TYPESCRIPT.md` — MANDATORY**
-- Use ESLint/Prettier configuration from project
-- Prefer functional components over class components (React)
-- TypeScript strict mode is REQUIRED, not optional
-
-### TypeScript Quick Rules (see TYPESCRIPT.md for full guide)
-
-- **NO `any`** — define explicit types always
-- **NO lazy `unknown`** — only for error catches and external data with validation
-- **Explicit return types** on all exported functions
-- **Explicit parameter types** always
-- **Interface for props** — never inline object types
-- **Event handlers** — use proper React event types
-
-## Commit Format
-
-```
-feat(#123): Add user profile component
-
-- Implement avatar display
-- Add edit mode toggle
-- Include form validation
-
-Refs #123
-```
-
-## Before Completing
-
-1. Run full test suite
-2. Verify build succeeds
-3. Update scratchpad with completion notes
-4. Reference issue in commit: `Fixes #N` or `Refs #N`

guides/INFRASTRUCTURE.md

@@ -1,339 +0,0 @@
-# Infrastructure & DevOps Guide
-
-## Before Starting
-
-1. Check assigned issue: `~/.config/mosaic/tools/git/issue-list.sh -a @me`
-2. Create scratchpad: `docs/scratchpads/{issue-number}-{short-name}.md`
-3. Review existing infrastructure configuration
-
-## Vault Secrets Management
-
-**CRITICAL**: Follow canonical Vault structure for ALL secrets.
-
-### Structure
-
-```
-{mount}/{service}/{component}/{secret-name}
-
-Examples:
-- secret-prod/postgres/database/app
-- secret-prod/redis/auth/default
-- secret-prod/authentik/admin/token
-```
-
-### Environment Mounts
-
-- `secret-dev/` - Development environment
-- `secret-staging/` - Staging environment
-- `secret-prod/` - Production environment
-
-### Standard Field Names
-
-- Credentials: `username`, `password`
-- Tokens: `token`
-- OAuth: `client_id`, `client_secret`
-- Connection strings: `url`, `host`, `port`
-
-See `docs/vault-secrets-structure.md` for complete reference.
-
-## Container Standards
-
-### Dockerfile Best Practices
-
-```dockerfile
-# Use specific version tags
-FROM node:20-alpine
-
-# Create non-root user
-RUN addgroup -S app && adduser -S app -G app
-
-# Set working directory
-WORKDIR /app
-
-# Copy dependency files first (layer caching)
-COPY package*.json ./
-RUN npm ci --only=production
-
-# Copy application code
-COPY --chown=app:app . .
-
-# Switch to non-root user
-USER app
-
-# Use exec form for CMD
-CMD ["node", "server.js"]
-```
-
-### Container Security
-
-- Use minimal base images (alpine, distroless)
-- Run as non-root user
-- Don't store secrets in images
-- Scan images for vulnerabilities
-- Pin dependency versions
-
-## Kubernetes/Docker Compose
-
-### Resource Limits
-
-Always set resource limits to prevent runaway containers:
-
-```yaml
-resources:
-  requests:
-    memory: '128Mi'
-    cpu: '100m'
-  limits:
-    memory: '256Mi'
-    cpu: '500m'
-```
-
-### Health Checks
-
-```yaml
-livenessProbe:
-  httpGet:
-    path: /health
-    port: 8080
-  initialDelaySeconds: 10
-  periodSeconds: 5
-
-readinessProbe:
-  httpGet:
-    path: /ready
-    port: 8080
-  initialDelaySeconds: 5
-  periodSeconds: 3
-```
-
-## CI/CD Pipelines
-
-### Pipeline Stages
-
-1. **Lint**: Code style and static analysis
-2. **Test**: Unit and integration tests
-3. **Build**: Compile and package
-4. **Scan**: Security and vulnerability scanning
-5. **Deploy**: Environment-specific deployment
-
-### Pipeline Security
-
-- Use secrets management (not hardcoded)
-- Pin action/image versions
-- Implement approval gates for production
-- Audit pipeline access
-
-## Steered-Autonomous Deployment (Hard Rule)
-
-In lights-out mode, the agent owns deployment end-to-end when deployment is in scope.
-The human is escalation-only for missing access, hard policy conflicts, or irreversible risk.
-
-### Deployment Target Selection
-
-1. Use explicit target from `docs/PRD.md` / `docs/PRD.json` or `docs/DEPLOYMENT.md`.
-2. If unspecified, infer from existing project config/integration.
-3. If multiple targets exist, choose the target already wired in CI/CD and document rationale.
-
-### Supported Targets
-
-- **Portainer**: Deploy via `~/.config/mosaic/tools/portainer/stack-redeploy.sh`, then verify with `stack-status.sh`.
-- **Coolify**: Deploy via `~/.config/mosaic/tools/coolify/deploy.sh -u <uuid>`, then verify with `service-status.sh`.
-- **Vercel**: Deploy via `vercel` CLI or connected Git integration, then verify preview/production URL health.
-- **Other SaaS providers**: Use provider CLI/API/runbook with the same validation and rollback gates.
-
-### Coolify API Operations
-
-```bash
-# List projects and services
-~/.config/mosaic/tools/coolify/project-list.sh
-~/.config/mosaic/tools/coolify/service-list.sh
-
-# Check service status
-~/.config/mosaic/tools/coolify/service-status.sh -u <uuid>
-
-# Set env vars (takes effect on next deploy)
-~/.config/mosaic/tools/coolify/env-set.sh -u <uuid> -k KEY -v VALUE
-
-# Deploy
-~/.config/mosaic/tools/coolify/deploy.sh -u <uuid>
-```
-
-**Known Coolify Limitations:**
-
-- FQDN updates on compose sub-apps not supported via API (DB workaround required)
-- Compose files must be base64-encoded in `docker_compose_raw` field
-- Magic variables (`SERVICE_FQDN_*`) require list-style env syntax, not dict-style
-- Rate limit: 200 requests per interval
-
-### Cloudflare DNS Operations
-
-Use the Cloudflare tools for any DNS configuration: pointing domains at services, adding TXT verification records, managing MX records, etc.
-
-**Multi-instance support**: Credentials support named instances (e.g. `personal`, `work`). A `default` key in credentials.json determines which instance is used when `-a` is omitted. Pass `-a <instance>` to target a specific account.
-
-```bash
-# List all zones (domains) in the account
-~/.config/mosaic/tools/cloudflare/zone-list.sh [-a instance]
-
-# List DNS records for a zone (accepts zone name or ID)
-~/.config/mosaic/tools/cloudflare/record-list.sh -z <zone> [-t type] [-n name]
-
-# Create a DNS record
-~/.config/mosaic/tools/cloudflare/record-create.sh -z <zone> -t <type> -n <name> -c <content> [-p] [-l ttl] [-P priority]
-
-# Update a DNS record (requires record ID from record-list)
-~/.config/mosaic/tools/cloudflare/record-update.sh -z <zone> -r <record-id> -t <type> -n <name> -c <content> [-p]
-
-# Delete a DNS record
-~/.config/mosaic/tools/cloudflare/record-delete.sh -z <zone> -r <record-id>
-```
-
-**Flag reference:**
-
-| Flag | Purpose                                                                 |
-| ---- | ----------------------------------------------------------------------- |
-| `-z` | Zone name (e.g. `mosaicstack.dev`) or 32-char zone ID                   |
-| `-a` | Named Cloudflare instance (omit for default)                            |
-| `-t` | Record type: `A`, `AAAA`, `CNAME`, `MX`, `TXT`, `SRV`, etc.             |
-| `-n` | Record name: short (`app`) or FQDN (`app.example.com`)                  |
-| `-c` | Record content/value (IP, hostname, TXT string, etc.)                   |
-| `-r` | Record ID (from `record-list.sh` output)                                |
-| `-p` | Enable Cloudflare proxy (orange cloud) — omit for DNS-only (grey cloud) |
-| `-l` | TTL in seconds (default: `1` = auto)                                    |
-| `-P` | Priority for MX/SRV records                                             |
-| `-f` | Output format: `table` (default) or `json`                              |
-
-**Common workflows:**
-
-```bash
-# Point a new subdomain at a server (proxied through Cloudflare)
-~/.config/mosaic/tools/cloudflare/record-create.sh \
-  -z example.com -t A -n myapp -c 203.0.113.10 -p
-
-# Add a TXT record for domain verification (never proxied)
-~/.config/mosaic/tools/cloudflare/record-create.sh \
-  -z example.com -t TXT -n _verify -c "verification=abc123"
-
-# Check what records exist before making changes
-~/.config/mosaic/tools/cloudflare/record-list.sh -z example.com -t CNAME
-
-# Update an existing record (get record ID from record-list first)
-~/.config/mosaic/tools/cloudflare/record-update.sh \
-  -z example.com -r <record-id> -t A -n myapp -c 10.0.0.5 -p
-```
-
-**DNS + Deployment integration**: When deploying a new service via Coolify or Portainer that needs a public domain, the typical sequence is:
-
-1. Create the DNS record pointing at the host IP (with `-p` for Cloudflare proxy if desired)
-2. Deploy the service via Coolify/Portainer
-3. Verify the domain resolves and the service is reachable
-
-**Proxy (`-p`) guidance:**
-
-- Use proxy (orange cloud) for web services — provides CDN, DDoS protection, and hides origin IP
-- Skip proxy (grey cloud) for non-HTTP services (mail, SSH), wildcard records, or when the service handles its own TLS termination and needs direct client IP visibility
-- Proxy is NOT compatible with non-standard ports outside Cloudflare's supported range
-
-### Stack Health Check
-
-Verify all infrastructure services are reachable:
-
-```bash
-~/.config/mosaic/tools/health/stack-health.sh
-```
-
-### Image Tagging and Promotion (Hard Rule)
-
-For containerized deployments:
-
-1. Build immutable image tags: `sha-<shortsha>` and `v{base-version}-rc.{build}`.
-2. Use mutable environment tags only as pointers: `testing`, optional `staging`, and `prod`.
-3. Deploy by immutable digest, not by mutable tag alone.
-4. Promote the exact tested digest between environments (no rebuild between testing and prod).
-5. Do not use `latest` or `dev` as deployment references.
-
-Blue-green is the default strategy for production promotion.
-Canary is allowed only when automated SLO/error-rate gates and auto-rollback triggers are implemented.
-
-### Post-Deploy Validation (REQUIRED)
-
-1. Health endpoints return expected status.
-2. Critical smoke tests pass in target environment.
-3. Running version and digest match the promoted release candidate.
-4. Observability signals (errors/latency) are within expected thresholds.
-
-### Rollback Rule
-
-If post-deploy validation fails:
-
-1. Execute rollback/redeploy-safe path immediately.
-2. Mark deployment as blocked in `docs/TASKS.md`.
-3. Record failure evidence and next remediation step in scratchpad and release notes.
-
-### Registry Retention and Cleanup
-
-Cleanup MUST be automated.
-
-- Keep all final release tags (`vX.Y.Z`) indefinitely.
-- Keep active environment digests (`prod`, `testing`, and active blue/green slots).
-- Keep recent RC tags (`vX.Y.Z-rc.N`) based on retention window.
-- Remove stale `sha-*` and RC tags outside retention window if they are not actively deployed.
-
-## Monitoring & Logging
-
-### Logging Standards
-
-- Use structured logging (JSON)
-- Include correlation IDs
-- Log at appropriate levels (ERROR, WARN, INFO, DEBUG)
-- Never log sensitive data
-
-### Metrics to Collect
-
-- Request latency (p50, p95, p99)
-- Error rates
-- Resource utilization (CPU, memory)
-- Business metrics
-
-### Alerting
-
-- Define SLOs (Service Level Objectives)
-- Alert on symptoms, not causes
-- Include runbook links in alerts
-- Avoid alert fatigue
-
-## Testing Infrastructure
-
-### Test Categories
-
-1. **Unit tests**: Terraform/Ansible logic
-2. **Integration tests**: Deployed resources work together
-3. **Smoke tests**: Critical paths after deployment
-4. **Chaos tests**: Failure mode validation
-
-### Infrastructure Testing Tools
-
-- Terraform: `terraform validate`, `terraform plan`
-- Ansible: `ansible-lint`, molecule
-- Kubernetes: `kubectl dry-run`, kubeval
-- General: Terratest, ServerSpec
-
-## Commit Format
-
-```
-chore(#67): Configure Redis cluster
-
-- Add Redis StatefulSet with 3 replicas
-- Configure persistence with PVC
-- Add Vault secret for auth password
-
-Refs #67
-```
-
-## Before Completing
-
-1. Validate configuration syntax
-2. Run infrastructure tests
-3. Test in dev/staging first
-4. Document any manual steps required
-5. Update scratchpad and close issue

guides/MEMORY.md

@@ -1,51 +0,0 @@
-# Memory and Retention Rules
-
-## Primary Memory Layer: OpenBrain
-
-**OpenBrain is the canonical shared memory for all Mosaic agents across all harnesses and sessions.**
-
-Use the `capture` MCP tool (or REST `POST /v1/thoughts`) to store:
-
-- Discovered gotchas and workarounds
-- Architectural decisions and rationale
-- Project state and context for handoffs
-- Anything a future agent should know
-
-Use `search` or `recent` at session start to load prior context before acting.
-
-This is not optional. An agent that uses local file-based memory instead of OpenBrain is a broken agent — its knowledge is invisible to every other agent on the platform.
-
-## Hard Rules
-
-1. Agent learnings MUST go to OpenBrain — not to any file-based memory location.
-2. You MUST NOT write to runtime-native memory silos (they are write-blocked by hook).
-3. Active execution state belongs in project `docs/` — not in memory files.
-4. `~/.config/mosaic/memory/` is for mosaic framework technical notes only, not project knowledge.
-
-## Runtime-Native Memory Silos (WRITE-BLOCKED)
-
-These locations are blocked by PreToolUse hooks. Attempting to write there fails at the tool level.
-
-| Runtime     | Blocked silo                       | Use instead         |
-| ----------- | ---------------------------------- | ------------------- |
-| Claude Code | `~/.claude/projects/*/memory/*.md` | OpenBrain `capture` |
-| Codex       | Runtime session memory             | OpenBrain `capture` |
-| OpenCode    | Runtime session memory             | OpenBrain `capture` |
-
-MEMORY.md files may only contain behavioral guardrails that must be injected at load-path — not knowledge.
-
-## Project Continuity Files (MANDATORY)
-
-| File                             | Purpose                                   | Location                    |
-| -------------------------------- | ----------------------------------------- | --------------------------- |
-| `docs/PRD.md` or `docs/PRD.json` | Source of requirements                    | Project `docs/`             |
-| `docs/TASKS.md`                  | Task tracking, milestones, issues, status | Project `docs/`             |
-| `docs/scratchpads/<task>.md`     | Task-specific working memory              | Project `docs/scratchpads/` |
-| `AGENTS.md`                      | Project-local patterns and conventions    | Project root                |
-
-## How the Block Works
-
-`~/.config/mosaic/tools/qa/prevent-memory-write.sh` is registered as a `PreToolUse` hook in
-`~/.claude/settings.json`. It intercepts Write/Edit/MultiEdit calls and rejects any targeting
-`~/.claude/projects/*/memory/*.md` before the tool executes. Exit code 2 blocks the call and
-the agent sees a message directing it to OpenBrain instead.

guides/ORCHESTRATOR-LEARNINGS.md

@@ -1,127 +0,0 @@
-# Orchestrator Learnings (Universal)
-
-> Cross-project heuristic adjustments based on observed variance data.
->
-> **Note:** This file contains generic patterns only. Project-specific evidence is stored in each project's `docs/tasks/orchestrator-learnings.json`.
-
-## Task Type Multipliers
-
-Apply these multipliers to base estimates from `ORCHESTRATOR.md`:
-
-| Task Type             | Base Estimate    | Multiplier | Confidence | Samples | Last Updated |
-| --------------------- | ---------------- | ---------- | ---------- | ------- | ------------ |
-| STYLE_FIX             | 3-5K             | 0.64       | MEDIUM     | n=1     | 2026-02-05   |
-| BULK_CLEANUP          | file_count × 550 | 1.0        | MEDIUM     | n=2     | 2026-02-05   |
-| GUARD_ADD             | 5-8K             | 1.0        | LOW        | n=0     | -            |
-| SECURITY_FIX          | 8-12K            | 2.5        | LOW        | n=0     | -            |
-| AUTH_ADD              | 15-25K           | 1.0        | HIGH       | n=1     | 2026-02-05   |
-| REFACTOR              | 10-15K           | 1.0        | LOW        | n=0     | -            |
-| TEST_ADD              | 15-25K           | 1.0        | LOW        | n=0     | -            |
-| ERROR_HANDLING        | 8-12K            | 2.3        | MEDIUM     | n=1     | 2026-02-05   |
-| CONFIG_DEFAULT_CHANGE | 5-10K            | 1.8        | MEDIUM     | n=1     | 2026-02-05   |
-| INPUT_VALIDATION      | 5-8K             | 1.7        | MEDIUM     | n=1     | 2026-02-05   |
-
-## Phase Factors
-
-Apply to all estimates based on task position in milestone:
-
-| Phase Position    | Factor | Rationale                  |
-| ----------------- | ------ | -------------------------- |
-| Early (tasks 1-3) | 1.45   | Codebase learning overhead |
-| Mid (tasks 4-7)   | 1.25   | Pattern recognition phase  |
-| Late (tasks 8+)   | 1.10   | Established patterns       |
-
-## Estimation Formula
-
-```
-Final Estimate = Base Estimate × Type Multiplier × Phase Factor × TDD Overhead
-
-Where:
-- Base Estimate: From ORCHESTRATOR.md task type table
-- Type Multiplier: From table above (default 1.0)
-- Phase Factor: 1.45 / 1.25 / 1.10 based on position
-- TDD Overhead: 1.20 if tests required
-```
-
-## Known Patterns
-
-### BULK_CLEANUP
-
-**Pattern:** Multi-file cleanup tasks are severely underestimated.
-
-**Why:** Iterative testing across many files, cascading fixes, and debugging compound the effort.
-
-**Observed:** +112% to +276% variance when using fixed estimates.
-
-**Recommendation:** Use `file_count × 550` instead of fixed estimate.
-
-### ERROR_HANDLING
-
-**Pattern:** Error handling changes that modify type interfaces cascade through the codebase.
-
-**Why:** Adding fields to result types requires updating all callers, error messages, and tests.
-
-**Observed:** +131% variance.
-
-**Multiplier:** 2.3x base estimate when type interfaces are modified.
-
-### CONFIG_DEFAULT_CHANGE
-
-**Pattern:** Config default changes require more test coverage than expected.
-
-**Why:** Security-sensitive defaults need validation tests, warning tests, and edge case coverage.
-
-**Observed:** +80% variance.
-
-**Multiplier:** 1.8x when config changes need security validation.
-
-### INPUT_VALIDATION
-
-**Pattern:** Security input validation with allowlists is more complex than simple validation.
-
-**Why:** Comprehensive allowlists (e.g., OAuth error codes), encoding requirements, and security tests add up.
-
-**Observed:** +70% variance.
-
-**Multiplier:** 1.7x when security allowlists are involved.
-
-### STYLE_FIX
-
-**Pattern:** Pure formatting fixes are faster than estimated when isolated.
-
-**Observed:** -36% variance.
-
-**Multiplier:** 0.64x for isolated style-only fixes.
-
-## Changelog
-
-| Date       | Change                                      | Samples | Confidence |
-| ---------- | ------------------------------------------- | ------- | ---------- |
-| 2026-02-05 | Added BULK_CLEANUP category                 | n=2     | MEDIUM     |
-| 2026-02-05 | Added STYLE_FIX multiplier 0.64             | n=1     | MEDIUM     |
-| 2026-02-05 | Confirmed AUTH_ADD heuristic accurate       | n=1     | HIGH       |
-| 2026-02-05 | Added ERROR_HANDLING multiplier 2.3x        | n=1     | MEDIUM     |
-| 2026-02-05 | Added CONFIG_DEFAULT_CHANGE multiplier 1.8x | n=1     | MEDIUM     |
-| 2026-02-05 | Added INPUT_VALIDATION multiplier 1.7x      | n=1     | MEDIUM     |
-
-## Update Protocol
-
-**Graduated Autonomy:**
-
-| Phase                  | Condition                                 | Action                                       |
-| ---------------------- | ----------------------------------------- | -------------------------------------------- |
-| **Now**                | All proposals                             | Human review required                        |
-| **After 3 milestones** | <30% change, n≥3 samples, HIGH confidence | Auto-update allowed                          |
-| **Mature**             | All changes                               | Auto with notification, revert on regression |
-
-**Validation Before Update:**
-
-1. Minimum 3 samples for same task type
-2. Standard deviation < 30% of mean
-3. Outliers (>2σ) excluded
-4. New formula must not increase variance on historical data
-
-## Where to Find Project-Specific Data
-
-- **Project learnings:** `<project>/docs/tasks/orchestrator-learnings.json`
-- **Cross-project metrics:** `jarvis-brain/data/orchestrator-metrics.json`

guides/ORCHESTRATOR-PROTOCOL.md

@@ -1,268 +0,0 @@
-# Orchestrator Protocol — Mission Lifecycle Guide
-
-> **Operational guide for agent sessions.** Distilled from the full specification at
-> `jarvis-brain/docs/protocols/ORCHESTRATOR-PROTOCOL.md` (1,066 lines).
->
-> Load this guide when: active mission detected, multi-milestone orchestration, mission continuation.
-> Load `ORCHESTRATOR.md` for per-session execution protocol (planning, coding, review, commit cycle).
-
----
-
-## 1. Relationship to ORCHESTRATOR.md
-
-| Concern                                                              | Guide             |
-| -------------------------------------------------------------------- | ----------------- |
-| How to execute within a session (plan, code, test, review, commit)   | `ORCHESTRATOR.md` |
-| How to manage a mission across sessions (resume, continue, handoff)  | **This guide**    |
-| Both guides are active simultaneously during orchestration missions. |
-
----
-
-## 2. Mission Manifest
-
-**Location:** `docs/MISSION-MANIFEST.md`
-**Owner:** Orchestrator (sole writer)
-**Template:** `~/.config/mosaic/templates/docs/MISSION-MANIFEST.md.template`
-
-The manifest is the persistent document tracking full mission scope, status, milestones, and session history. It survives session death.
-
-### Update Rules
-
-- Update **Phase** when transitioning (Intake → Planning → Execution → Continuation → Completion)
-- Update **Current Milestone** when starting a new milestone
-- Update **Progress** after each milestone completion
-- Append to **Session History** at session start and end
-- Update **Status** to `completed` only when ALL success criteria are verified
-
-### Hard Rule
-
-The manifest is the source of truth for mission scope. If the manifest says a milestone is done, it is done. If it says remaining, it remains.
-
----
-
-## 3. Scratchpad Protocol
-
-**Location:** `docs/scratchpads/{mission-id}.md`
-**Template:** `~/.config/mosaic/templates/docs/mission-scratchpad.md.template`
-
-### Rules
-
-1. **First action** — Before ANY planning or coding, write the mission prompt to the scratchpad
-2. **Append-only** — NEVER delete or overwrite previous entries
-3. **Session log** — Record session start, tasks done, and outcome at session end
-4. **Decisions** — Record all planning decisions with rationale
-5. **Corrections** — Record course corrections from human or coordinator
-6. **Never deleted** — Scratchpads survive mission completion (archival reference)
-
----
-
-## 4. TASKS.md as Control Plane
-
-**Location:** `docs/TASKS.md`
-**Owner:** Orchestrator (sole writer). Workers read but NEVER modify.
-
-### Table Schema
-
-```markdown
-| id | status | milestone | description | pr | notes |
-```
-
-### Status Values
-
-`not-started` → `in-progress` → `done` (or `blocked` / `failed`)
-
-### Planning Tasks Are First-Class
-
-Include explicit planning tasks (e.g., `PLAN-001: Break down milestone into tasks`). These count toward progress.
-
-### Post-Merge Tasks Are Explicit
-
-Include verification tasks after merge: CI check, deployment verification, Playwright test. Don't assume they happen automatically.
-
----
-
-## 5. Session Resume Protocol
-
-When starting a session and an active mission is detected, follow this checklist:
-
-### Detection (5-point check)
-
-1. `docs/MISSION-MANIFEST.md` exists → read Phase, Current Milestone, Progress
-2. `docs/scratchpads/*.md` exists → read latest scratchpad for decisions and corrections
-3. `docs/TASKS.md` exists → read task state (what's done, what's next)
-4. Git state → current branch, open PRs, recent commits
-5. Provider state → open issues, milestone status (if accessible)
-
-### Resume Procedure
-
-1. Read the mission manifest FIRST
-2. Read the scratchpad for session history and corrections
-3. Read TASKS.md for current task state
-4. Identify the next `not-started` or `in-progress` task
-5. Continue execution from that task
-6. Update Session History in the manifest
-
-### Dirty State Recovery
-
-| State                    | Recovery                                                            |
-| ------------------------ | ------------------------------------------------------------------- |
-| Dirty git working tree   | Stash changes, log stash ref in scratchpad, resume clean            |
-| Open PR in bad state     | Check PR status, close if broken, re-create if needed               |
-| Half-created issues      | Audit issues against TASKS.md, reconcile                            |
-| Tasks marked in-progress | Check if work was committed; if so, mark done; if not, restart task |
-
-### Hard Rule
-
-Session state is NEVER automatically deleted. The coordinator (human or automated) must explicitly request cleanup.
-
----
-
-## 6. Mission Continuation
-
-When a milestone completes and more milestones remain:
-
-### Agent Handoff (at ~55-60% context)
-
-If context usage is high, produce a handoff message:
-
-1. Update TASKS.md with final task statuses
-2. Update mission manifest with session results
-3. Append session summary to scratchpad
-4. Commit all state files
-5. The coordinator will generate a continuation prompt for the next session
-
-### Continuation Prompt and Capsule Format
-
-The coordinator generates this (via `mosaic coord continue`) and writes a machine-readable capsule at `.mosaic/orchestrator/next-task.json`:
-
-```
-## Continuation Mission
-Continue **{mission}** from existing state.
-- Read docs/MISSION-MANIFEST.md for scope and status
-- Read docs/scratchpads/{id}.md for decisions
-- Read docs/TASKS.md for current state
-- Continue from task {next-task-id}
-```
-
-### Between Sessions (r0 manual)
-
-1. Agent stops (expected — this is the confirmed stamina limitation)
-2. Human runs `mosaic coord mission` to check status
-3. Human runs `mosaic coord continue` to generate continuation prompt
-4. Human launches new session and pastes the prompt
-5. New agent reads manifest, scratchpad, TASKS.md and continues
-
-### Between Sessions (r0 assisted)
-
-Use `mosaic coord run` to remove copy/paste steps:
-
-1. Agent stops
-2. Human runs `mosaic coord run [--claude|--codex]`
-3. Coordinator regenerates continuation prompt + `next-task.json`
-4. Coordinator launches selected runtime with scoped kickoff context
-5. New session resumes from next task
-
----
-
-## 7. Failure Taxonomy Quick Reference
-
-| Code | Type                   | Recovery                                              |
-| ---- | ---------------------- | ----------------------------------------------------- |
-| F1   | Premature Stop         | Continuation prompt → new session (most common)       |
-| F2   | Context Exhaustion     | Handoff message → new session                         |
-| F3   | Session Crash          | Check git state → `mosaic coord resume` → new session |
-| F4   | Error Spiral           | Kill session, mark task blocked, skip to next         |
-| F5   | Quality Gate Failure   | Create QA remediation task                            |
-| F6   | Infrastructure Failure | Pause, retry when service recovers                    |
-| F7   | False Completion       | Append correction to scratchpad, relaunch             |
-| F8   | Scope Drift            | Kill session, relaunch with scratchpad ref            |
-| F9   | Subagent Failure       | Orchestrator retries or creates remediation           |
-| F10  | Deadlock               | Escalate to human                                     |
-
-### F1: Premature Stop — Detailed Recovery
-
-This is the confirmed, most common failure. Every session will eventually trigger F1.
-
-1. Session ends with tasks remaining in TASKS.md
-2. Run `mosaic coord mission` — verify milestone status
-3. If milestone complete: verify CI green, deployed, issues closed
-4. Run `mosaic coord continue` — generates scoped continuation prompt
-5. Launch new session, paste prompt
-6. New session reads state and continues from next pending task
-
----
-
-## 8. r0 Manual Coordinator Process
-
-In r0, the Coordinator is Jason + shell scripts. No daemon. No automation.
-
-### Commands
-
-| Command                                             | Purpose                                           |
-| --------------------------------------------------- | ------------------------------------------------- | ------------------------------------------------ |
-| `mosaic coord init --name "..." --milestones "..."` | Initialize a new mission                          |
-| `mosaic coord mission`                              | Show mission progress dashboard                   |
-| `mosaic coord status`                               | Check if agent session is still running           |
-| `mosaic coord continue`                             | Generate continuation prompt for next session     |
-| `mosaic coord run [--claude                         | --codex]`                                         | Generate continuation context and launch runtime |
-| `mosaic coord resume`                               | Crash recovery (detect dirty state, generate fix) |
-| `mosaic coord resume --clean-lock`                  | Clear stale session lock after review             |
-
-### Typical Workflow
-
-```
-init → launch agent → [agent works] → agent stops →
-status → mission → run → repeat
-```
-
----
-
-## 9. Operational Checklist
-
-### Pre-Mission
-
-- [ ] Mission initialized: `mosaic coord init`
-- [ ] docs/MISSION-MANIFEST.md exists with scope and milestones
-- [ ] docs/TASKS.md scaffolded
-- [ ] docs/scratchpads/{id}.md scaffolded
-- [ ] Success criteria defined in manifest
-
-### Session Start
-
-- [ ] Read manifest → know phase, milestone, progress
-- [ ] Read scratchpad → know decisions, corrections, history
-- [ ] Read TASKS.md → know what's done and what's next
-- [ ] Write session start to scratchpad
-- [ ] Update Session History in manifest
-
-### Planning Gate (Hard Gate — No Coding Until Complete)
-
-- [ ] Milestones created in provider (Gitea/GitHub)
-- [ ] Issues created for all milestone tasks
-- [ ] TASKS.md populated with all planned tasks (including planning + verification tasks)
-- [ ] All planning artifacts committed and pushed
-
-### Per-Task
-
-- [ ] Update task status to `in-progress` in TASKS.md
-- [ ] Execute task following ORCHESTRATOR.md cycle
-- [ ] Update task status to `done` (or `blocked`/`failed`)
-- [ ] Commit, push
-
-### Milestone Completion
-
-- [ ] All milestone tasks in TASKS.md are `done`
-- [ ] CI/pipeline green
-- [ ] PR merged to `main`
-- [ ] Issues closed
-- [ ] Update manifest: milestone status → completed
-- [ ] Update scratchpad: session log entry
-- [ ] If deployment target: verify accessible
-
-### Mission Completion
-
-- [ ] ALL milestones completed
-- [ ] ALL success criteria verified with evidence
-- [ ] manifest status → completed
-- [ ] Final scratchpad entry with completion evidence
-- [ ] Release tag created and pushed (if applicable)

guides/PRD.md

@@ -1,63 +0,0 @@
-# PRD Requirement Guide (MANDATORY)
-
-This guide defines how requirements are captured before coding.
-
-## Hard Rules
-
-1. Before coding begins, `docs/PRD.md` or `docs/PRD.json` MUST exist.
-2. The PRD is the authoritative requirements source for implementation and testing.
-3. The main agent MUST prepare or update the PRD using user input and available project context before implementation starts.
-4. The agent MUST NOT invent requirements silently.
-5. In steered autonomy mode, best-guess decisions are REQUIRED when needed; each guessed decision MUST be marked with `ASSUMPTION:` and rationale.
-
-## PRD Format
-
-Allowed canonical formats:
-
-1. `docs/PRD.md`
-2. `docs/PRD.json`
-
-Either format is valid. Both may exist if one is a transformed representation of the other.
-For markdown PRDs, start from `~/.config/mosaic/templates/docs/PRD.md.template`.
-
-## Best-Guess Mode
-
-Steered autonomy is the default operating mode.
-
-1. Agent SHOULD fill missing decisions in the PRD without waiting for routine confirmation.
-2. Agent MUST mark each guessed decision with `ASSUMPTION:` and rationale.
-3. If user explicitly requests strict-confirmation mode, the agent MUST ask before unresolved decisions are finalized.
-4. For high-impact security/compliance/release uncertainty, escalate only if the decision cannot be safely constrained with rollback-ready defaults.
-
-## Minimum PRD Content
-
-Every PRD MUST include:
-
-1. Problem statement and objective
-2. In-scope and out-of-scope
-3. User/stakeholder requirements
-4. Functional requirements
-5. Non-functional requirements (security, performance, reliability, observability)
-6. Acceptance criteria
-7. Constraints and dependencies
-8. Risks and open questions
-9. Testing and verification expectations
-10. Delivery/milestone intent
-
-## Pre-Coding Gate
-
-Coding MUST NOT begin until:
-
-1. PRD file exists (`docs/PRD.md` or `docs/PRD.json`)
-2. PRD has required sections
-3. Unresolved decisions are captured as explicit `ASSUMPTION:` entries with rationale and planned validation
-
-## Change Control
-
-When requirements materially change:
-
-1. Update PRD first.
-2. Then update implementation plan/tasks.
-3. Then implement code changes.
-
-Implementation that diverges from PRD without PRD updates is a blocker.

guides/QA-TESTING.md

@@ -1,125 +0,0 @@
-# QA & Testing Guide
-
-## Before Starting
-
-1. Check assigned issue: `~/.config/mosaic/tools/git/issue-list.sh -a @me`
-2. Create scratchpad: `docs/scratchpads/{issue-number}-{short-name}.md`
-3. Review `docs/PRD.md` or `docs/PRD.json` as the requirements source.
-4. Review acceptance criteria and affected change surfaces.
-
-## Testing Policy (Hard Rules)
-
-1. Situational testing is the PRIMARY validation gate.
-2. Baseline testing is REQUIRED for all software changes.
-3. TDD is risk-based and REQUIRED only for defined high-risk change types.
-4. Tests MUST validate requirements and behavior, not only internal implementation details.
-
-## Priority Order
-
-1. Situational tests: prove requirements and real behavior on changed surfaces.
-2. Baseline tests: lint/type/unit/integration safety checks.
-3. TDD discipline: applied where risk justifies test-first workflow.
-
-## Risk-Based TDD Requirement
-
-| Change Type                                    | TDD Requirement | Required Action                                                        |
-| ---------------------------------------------- | --------------- | ---------------------------------------------------------------------- |
-| Bug fix                                        | REQUIRED        | Write a failing reproducer test first, then fix.                       |
-| Security/auth/permission logic                 | REQUIRED        | Write failing security/permission-path test first.                     |
-| Critical business logic or data mutation rules | REQUIRED        | Write failing rule/invariant test first.                               |
-| API behavior regression                        | REQUIRED        | Write failing contract/behavior test first.                            |
-| Low-risk UI copy/style/layout                  | OPTIONAL        | Add verification tests as appropriate; TDD recommended, not mandatory. |
-| Mechanical refactor with unchanged behavior    | OPTIONAL        | Ensure regression/smoke coverage and situational evidence.             |
-
-If TDD is not required and skipped, record rationale in scratchpad.
-If TDD is required and skipped, task is NOT complete.
-
-## Baseline Test Requirements
-
-For all software changes, run baseline checks applicable to the repo:
-
-1. lint/static checks
-2. type checks
-3. unit tests for changed logic
-4. integration tests for changed boundaries
-
-## Situational Testing Matrix (Primary Gate)
-
-| Change Surface               | Required Situational Tests                                                    |
-| ---------------------------- | ----------------------------------------------------------------------------- |
-| Authentication/authorization | auth failure-path tests, permission boundary tests, token/session validation  |
-| Database schema/migrations   | migration up/down validation, rollback safety, data integrity checks          |
-| API contract changes         | backward compatibility checks, consumer-impact tests, contract tests          |
-| Frontend/UI workflow changes | end-to-end flow tests, accessibility sanity checks, state transition checks   |
-| CI/CD or deployment changes  | pipeline execution validation, artifact integrity checks, rollback path check |
-| Security-sensitive logic     | abuse-case tests, input validation fuzzing/sanitization checks                |
-| Performance-critical path    | baseline comparison, regression threshold checks                              |
-
-## Coverage Requirements
-
-### Minimum Standards
-
-- Overall Coverage: 85% minimum
-- Critical Paths: 95% minimum (auth, payments, data mutations)
-- New Code: 90% minimum
-
-Coverage is necessary but NOT sufficient. Passing coverage does not replace situational verification.
-
-## Requirements-to-Evidence Mapping (Mandatory)
-
-Before completion, map each acceptance criterion to concrete evidence.
-Acceptance criteria MUST come from the active PRD.
-
-Template:
-
-```markdown
-| Acceptance Criterion | Verification Method                                    | Evidence         |
-| -------------------- | ------------------------------------------------------ | ---------------- |
-| AC-1: ...            | Situational test / baseline test / manual verification | command + result |
-| AC-2: ...            | ...                                                    | ...              |
-```
-
-## Browser Automation (Hard Rule)
-
-All browser automation (Playwright, Cypress, Puppeteer) MUST run in **headless mode**.
-Launching a visible browser collides with the user's display and active session.
-
-- Playwright: use `headless: true` in config or `--headed` must NOT be passed
-- Cypress: use `cypress run` (headless by default), never `cypress open`
-- Puppeteer: use `headless: true` (default)
-
-If a project's `playwright.config.ts` does not explicitly set `headless: true`, add it before running tests.
-
-## Test Quality Rules
-
-1. Test behavior and outcomes, not private implementation details.
-2. Include failure-path and edge-case assertions for changed behavior.
-3. Keep tests deterministic; no new flaky tests.
-4. Keep tests isolated; no dependency on execution order.
-
-## Anti-Gaming Rules
-
-1. Do NOT stop at "tests pass" if acceptance criteria are not verified.
-2. Do NOT write narrow tests that only satisfy assertions while missing real workflow behavior.
-3. Do NOT claim completion without situational evidence for impacted surfaces.
-
-## Reporting
-
-QA report MUST include:
-
-1. baseline tests run and outcomes
-2. situational tests run and outcomes
-3. TDD usage decision (required/applied or optional/skipped with rationale)
-4. acceptance-criteria-to-evidence mapping
-5. coverage results
-6. residual risk notes
-
-## Before Completing
-
-1. Baseline tests pass.
-2. Required situational tests pass.
-3. TDD obligations met for required change types.
-4. Acceptance criteria mapped to evidence.
-5. No flaky tests introduced.
-6. CI pipeline passes (if available).
-7. Scratchpad updated with results.

guides/TYPESCRIPT.md

@@ -1,440 +0,0 @@
-# TypeScript Style Guide
-
-**Authority**: This guide is MANDATORY for all TypeScript code. No exceptions without explicit approval.
-
-Based on Google TypeScript Style Guide with stricter enforcement.
-
----
-
-## Core Principles
-
-1. **Explicit over implicit** — Always declare types, never rely on inference for public APIs
-2. **Specific over generic** — Use the narrowest type that works
-3. **Safe over convenient** — Type safety is not negotiable
-4. **Contract-first boundaries** — Cross-module and API payloads MUST use dedicated DTO files
-
----
-
-## DTO Contract (MANDATORY)
-
-DTO files are REQUIRED for TypeScript module boundaries to preserve shared context and consistency.
-
-Hard requirements:
-
-1. Input and output payloads crossing module boundaries MUST be defined in `*.dto.ts` files.
-2. Controller/service boundary payloads MUST use DTO types; inline object literal types are NOT allowed.
-3. Public API request/response contracts MUST use DTO files and remain stable across modules.
-4. Shared DTOs used by multiple modules MUST live in a shared location (for example `src/shared/dto/` or `packages/shared/dto/`).
-5. ORM/entity models MUST NOT be exposed directly across module boundaries; map them to DTOs.
-6. DTO changes MUST be reflected in tests and documentation when contracts change.
-
-```typescript
-// ❌ WRONG: inline payload contract at boundary
-export function createUser(payload: { email: string; role: string }): Promise<User> {}
-
-// ✅ CORRECT: dedicated DTO file contract
-// user-create.dto.ts
-export interface UserCreateDto {
-  email: string;
-  role: UserRole;
-}
-
-// user-response.dto.ts
-export interface UserResponseDto {
-  id: string;
-  email: string;
-  role: UserRole;
-}
-
-// service.ts
-export function createUser(payload: UserCreateDto): Promise<UserResponseDto> {}
-```
-
----
-
-## Forbidden Patterns (NEVER USE)
-
-### `any` Type — FORBIDDEN
-
-```typescript
-// ❌ NEVER
-function process(data: any) {}
-const result: any = fetchData();
-Record<string, any>;
-
-// ✅ ALWAYS define explicit types
-interface UserData {
-  id: string;
-  name: string;
-  email: string;
-}
-function process(data: UserData) {}
-```
-
-### `unknown` as Lazy Typing — FORBIDDEN
-
-`unknown` is only acceptable in these specific cases:
-
-1. Error catch blocks (then immediately narrow)
-2. JSON.parse results (then validate with Zod/schema)
-3. External API responses before validation
-
-```typescript
-// ❌ NEVER - using unknown to avoid typing
-function getData(): unknown {}
-const config: Record<string, unknown> = {};
-
-// ✅ ACCEPTABLE - error handling with immediate narrowing
-try {
-  riskyOperation();
-} catch (error: unknown) {
-  if (error instanceof Error) {
-    logger.error(error.message);
-  } else {
-    logger.error('Unknown error', { error: String(error) });
-  }
-}
-
-// ✅ ACCEPTABLE - external data with validation
-const raw: unknown = JSON.parse(response);
-const validated = UserSchema.parse(raw); // Zod validation
-```
-
-### Implicit `any` — FORBIDDEN
-
-```typescript
-// ❌ NEVER - implicit any from missing types
-function process(data) {} // Parameter has implicit any
-const handler = (e) => {}; // Parameter has implicit any
-
-// ✅ ALWAYS - explicit types
-function process(data: RequestPayload): ProcessedResult {}
-const handler = (e: React.MouseEvent<HTMLButtonElement>): void => {};
-```
-
-### Type Assertions to Bypass Safety — FORBIDDEN
-
-```typescript
-// ❌ NEVER - lying to the compiler
-const user = data as User;
-const element = document.getElementById('app') as HTMLDivElement;
-
-// ✅ USE - type guards and narrowing
-function isUser(data: unknown): data is User {
-  return typeof data === 'object' && data !== null && 'id' in data;
-}
-if (isUser(data)) {
-  console.log(data.id); // Safe
-}
-
-// ✅ USE - null checks
-const element = document.getElementById('app');
-if (element instanceof HTMLDivElement) {
-  element.style.display = 'none'; // Safe
-}
-```
-
-### Non-null Assertion (`!`) — FORBIDDEN (except tests)
-
-```typescript
-// ❌ NEVER in production code
-const name = user!.name;
-const element = document.getElementById('app')!;
-
-// ✅ USE - proper null handling
-const name = user?.name ?? 'Anonymous';
-const element = document.getElementById('app');
-if (element) {
-  // Safe to use element
-}
-```
-
----
-
-## Required Patterns
-
-### Explicit Return Types — REQUIRED for all public functions
-
-```typescript
-// ❌ WRONG - missing return type
-export function calculateTotal(items: Item[]) {
-  return items.reduce((sum, item) => sum + item.price, 0);
-}
-
-// ✅ CORRECT - explicit return type
-export function calculateTotal(items: Item[]): number {
-  return items.reduce((sum, item) => sum + item.price, 0);
-}
-```
-
-### Explicit Parameter Types — REQUIRED always
-
-```typescript
-// ❌ WRONG
-const multiply = (a, b) => a * b;
-users.map((user) => user.name); // If user type isn't inferred
-
-// ✅ CORRECT
-const multiply = (a: number, b: number): number => a * b;
-users.map((user: User): string => user.name);
-```
-
-### Interface Over Type Alias — PREFERRED for objects
-
-```typescript
-// ✅ PREFERRED - interface (extendable, better error messages)
-interface User {
-  id: string;
-  name: string;
-  email: string;
-}
-
-// ✅ ACCEPTABLE - type alias for unions, intersections, primitives
-type Status = 'active' | 'inactive' | 'pending';
-type ID = string | number;
-```
-
-### Const Assertions for Literals — REQUIRED
-
-```typescript
-// ❌ WRONG - loses literal types
-const config = {
-  endpoint: '/api/users',
-  method: 'GET',
-};
-// config.method is string, not 'GET'
-
-// ✅ CORRECT - preserves literal types
-const config = {
-  endpoint: '/api/users',
-  method: 'GET',
-} as const;
-// config.method is 'GET'
-```
-
-### Discriminated Unions — REQUIRED for variants
-
-```typescript
-// ❌ WRONG - optional properties for variants
-interface ApiResponse {
-  success: boolean;
-  data?: User;
-  error?: string;
-}
-
-// ✅ CORRECT - discriminated union
-interface SuccessResponse {
-  success: true;
-  data: User;
-}
-interface ErrorResponse {
-  success: false;
-  error: string;
-}
-type ApiResponse = SuccessResponse | ErrorResponse;
-```
-
----
-
-## Generic Constraints
-
-### Meaningful Constraints — REQUIRED
-
-```typescript
-// ❌ WRONG - unconstrained generic
-function merge<T>(a: T, b: T): T {}
-
-// ✅ CORRECT - constrained generic
-function merge<T extends object>(a: T, b: Partial<T>): T {}
-```
-
-### Default Generic Parameters — USE SPECIFIC TYPES
-
-```typescript
-// ❌ WRONG
-interface Repository<T = unknown> {}
-
-// ✅ CORRECT - no default if type should be explicit
-interface Repository<T extends Entity> {}
-
-// ✅ ACCEPTABLE - meaningful default
-interface Cache<T extends Serializable = JsonValue> {}
-```
-
----
-
-## React/JSX Specific
-
-### Event Handlers — EXPLICIT TYPES REQUIRED
-
-```typescript
-// ❌ WRONG
-const handleClick = (e) => {};
-const handleChange = (e) => {};
-
-// ✅ CORRECT
-const handleClick = (e: React.MouseEvent<HTMLButtonElement>): void => {};
-const handleChange = (e: React.ChangeEvent<HTMLInputElement>): void => {};
-const handleSubmit = (e: React.FormEvent<HTMLFormElement>): void => {};
-```
-
-### Component Props — INTERFACE REQUIRED
-
-```typescript
-// ❌ WRONG - inline types
-function Button({ label, onClick }: { label: string; onClick: () => void }) { }
-
-// ✅ CORRECT - named interface
-interface ButtonProps {
-  label: string;
-  onClick: () => void;
-  disabled?: boolean;
-}
-
-function Button({ label, onClick, disabled = false }: ButtonProps): JSX.Element {
-  return <button onClick={onClick} disabled={disabled}>{label}</button>;
-}
-```
-
-### Children Prop — USE React.ReactNode
-
-```typescript
-interface LayoutProps {
-  children: React.ReactNode;
-  sidebar?: React.ReactNode;
-}
-```
-
----
-
-## API Response Typing
-
-### Define Explicit Response Types
-
-```typescript
-// ❌ WRONG
-const response = await fetch('/api/users');
-const data = await response.json(); // data is any
-
-// ✅ CORRECT
-interface UsersResponse {
-  users: User[];
-  pagination: PaginationInfo;
-}
-
-const response = await fetch('/api/users');
-const data: UsersResponse = await response.json();
-
-// ✅ BEST - with runtime validation
-const response = await fetch('/api/users');
-const raw = await response.json();
-const data = UsersResponseSchema.parse(raw); // Zod validates at runtime
-```
-
----
-
-## Error Handling
-
-### Typed Error Classes — REQUIRED for domain errors
-
-```typescript
-class ValidationError extends Error {
-  constructor(
-    message: string,
-    public readonly field: string,
-    public readonly code: string,
-  ) {
-    super(message);
-    this.name = 'ValidationError';
-  }
-}
-
-class NotFoundError extends Error {
-  constructor(
-    public readonly resource: string,
-    public readonly id: string,
-  ) {
-    super(`${resource} with id ${id} not found`);
-    this.name = 'NotFoundError';
-  }
-}
-```
-
-### Error Narrowing — REQUIRED
-
-```typescript
-try {
-  await saveUser(user);
-} catch (error: unknown) {
-  if (error instanceof ValidationError) {
-    return { error: error.message, field: error.field };
-  }
-  if (error instanceof NotFoundError) {
-    return { error: 'Not found', resource: error.resource };
-  }
-  if (error instanceof Error) {
-    logger.error('Unexpected error', { message: error.message, stack: error.stack });
-    return { error: 'Internal error' };
-  }
-  logger.error('Unknown error type', { error: String(error) });
-  return { error: 'Internal error' };
-}
-```
-
----
-
-## ESLint Rules — ENFORCE THESE
-
-```javascript
-{
-  "@typescript-eslint/no-explicit-any": "error",
-  "@typescript-eslint/explicit-function-return-type": ["error", {
-    "allowExpressions": true,
-    "allowTypedFunctionExpressions": true
-  }],
-  "@typescript-eslint/explicit-module-boundary-types": "error",
-  "@typescript-eslint/no-inferrable-types": "off", // Allow explicit primitives
-  "@typescript-eslint/no-non-null-assertion": "error",
-  "@typescript-eslint/strict-boolean-expressions": "error",
-  "@typescript-eslint/no-unsafe-assignment": "error",
-  "@typescript-eslint/no-unsafe-member-access": "error",
-  "@typescript-eslint/no-unsafe-call": "error",
-  "@typescript-eslint/no-unsafe-return": "error"
-}
-```
-
----
-
-## TSConfig Strict Mode — REQUIRED
-
-```json
-{
-  "compilerOptions": {
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": true,
-    "noImplicitThis": true,
-    "useUnknownInCatchVariables": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noImplicitOverride": true
-  }
-}
-```
-
----
-
-## Summary: The Type Safety Hierarchy
-
-From best to worst:
-
-1. **Explicit specific type** (interface/type) — REQUIRED
-2. **Generic with constraints** — ACCEPTABLE
-3. **`unknown` with immediate validation** — ONLY for external data
-4. **`any`** — FORBIDDEN
-
-**When in doubt, define an interface.**

guides/VAULT-SECRETS.md

@@ -1,205 +0,0 @@
-# Vault Secrets Management Guide
-
-This guide applies when the project uses HashiCorp Vault for secrets management.
-
-## Before Starting
-
-1. Verify Vault access: `vault status`
-2. Authenticate: `vault login` (method depends on environment)
-3. Check your permissions for the required paths
-
-## Canonical Structure
-
-**ALL Vault secrets MUST follow this structure:**
-
-```
-{mount}/{service}/{component}/{secret-name}
-```
-
-### Components
-
-- **mount**: Environment-specific mount point
-- **service**: The service or application name
-- **component**: Logical grouping (database, api, oauth, etc.)
-- **secret-name**: Specific secret identifier
-
-## Environment Mounts
-
-| Mount             | Environment | Usage                  |
-| ----------------- | ----------- | ---------------------- |
-| `secret-dev/`     | Development | Local dev, CI          |
-| `secret-staging/` | Staging     | Pre-production testing |
-| `secret-prod/`    | Production  | Live systems           |
-
-## Examples
-
-```bash
-# Database credentials
-secret-prod/postgres/database/app
-secret-prod/mysql/database/readonly
-secret-staging/redis/auth/default
-
-# API tokens
-secret-prod/authentik/admin/token
-secret-prod/stripe/api/live-key
-secret-dev/sendgrid/api/test-key
-
-# JWT/Authentication
-secret-prod/backend-api/jwt/signing-key
-secret-prod/auth-service/session/secret
-
-# OAuth providers
-secret-prod/backend-api/oauth/google
-secret-prod/backend-api/oauth/github
-
-# Internal services
-secret-prod/loki/read-auth/admin
-secret-prod/grafana/admin/password
-```
-
-## Standard Field Names
-
-Use consistent field names within secrets:
-
-| Purpose     | Fields                       |
-| ----------- | ---------------------------- |
-| Credentials | `username`, `password`       |
-| Tokens      | `token`                      |
-| OAuth       | `client_id`, `client_secret` |
-| Connection  | `url`, `host`, `port`        |
-| Keys        | `public_key`, `private_key`  |
-
-### Example Secret Structure
-
-```json
-// secret-prod/postgres/database/app
-{
-  "username": "app_user",
-  "password": "secure-password-here",
-  "host": "db.example.com",
-  "port": "5432",
-  "database": "myapp"
-}
-```
-
-## Rules
-
-1. **DO NOT GUESS** secret paths - Always verify the path exists
-2. **Use helper scripts** in `scripts/vault/` when available
-3. **All lowercase, hyphenated** (kebab-case) for all path segments
-4. **Standard field names** - Use the conventions above
-5. **No sensitive data in path names** - Path itself should not reveal secrets
-6. **Environment separation** - Never reference prod secrets from dev
-
-## Deprecated Paths (DO NOT USE)
-
-These legacy patterns are deprecated and should be migrated:
-
-| Deprecated                | Migrate To                                  |
-| ------------------------- | ------------------------------------------- |
-| `secret/infrastructure/*` | `secret-{env}/{service}/...`                |
-| `secret/oauth/*`          | `secret-{env}/{service}/oauth/{provider}`   |
-| `secret/database/*`       | `secret-{env}/{service}/database/{user}`    |
-| `secret/credentials/*`    | `secret-{env}/{service}/{component}/{name}` |
-
-## Reading Secrets
-
-### CLI
-
-```bash
-# Read a secret
-vault kv get secret-prod/postgres/database/app
-
-# Get specific field
-vault kv get -field=password secret-prod/postgres/database/app
-
-# JSON output
-vault kv get -format=json secret-prod/postgres/database/app
-```
-
-### Application Code
-
-**Python (hvac):**
-
-```python
-import hvac
-
-client = hvac.Client(url='https://vault.example.com')
-secret = client.secrets.kv.v2.read_secret_version(
-    path='postgres/database/app',
-    mount_point='secret-prod'
-)
-password = secret['data']['data']['password']
-```
-
-**Node.js (node-vault):**
-
-```javascript
-const vault = require('node-vault')({ endpoint: 'https://vault.example.com' });
-const secret = await vault.read('secret-prod/data/postgres/database/app');
-const password = secret.data.data.password;
-```
-
-**Go:**
-
-```go
-secret, err := client.Logical().Read("secret-prod/data/postgres/database/app")
-password := secret.Data["data"].(map[string]interface{})["password"].(string)
-```
-
-## Writing Secrets
-
-Only authorized personnel should write secrets. If you need a new secret:
-
-1. Request through proper channels (ticket, PR to IaC repo)
-2. Follow the canonical structure
-3. Document the secret's purpose
-4. Set appropriate access policies
-
-```bash
-# Example (requires write permissions)
-vault kv put secret-dev/myapp/database/app \
-  username="dev_user" \
-  password="dev-password" \
-  host="localhost" \
-  port="5432"
-```
-
-## Troubleshooting
-
-### Permission Denied
-
-```
-Error: permission denied
-```
-
-- Verify your token has read access to the path
-- Check if you're using the correct mount point
-- Confirm the secret path exists
-
-### Secret Not Found
-
-```
-Error: no value found at secret-prod/data/service/component/name
-```
-
-- Verify the exact path (use `vault kv list` to explore)
-- Check for typos in service/component names
-- Confirm you're using the correct environment mount
-
-### Token Expired
-
-```
-Error: token expired
-```
-
-- Re-authenticate: `vault login`
-- Check token TTL: `vault token lookup`
-
-## Security Best Practices
-
-1. **Least privilege** - Request only the permissions you need
-2. **Short-lived tokens** - Use tokens with appropriate TTLs
-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

mosaic.config.json

@@ -1,6 +0,0 @@
-{
-  "tier": "local",
-  "storage": { "type": "sqlite", "path": ".mosaic/data.db" },
-  "queue": { "type": "local", "dataDir": ".mosaic/queue" },
-  "memory": { "type": "keyword" }
-}

package.json

@@ -23,10 +23,5 @@
     "turbo": "^2.0.0",
     "typescript": "^5.8.0",
     "vitest": "^2.0.0"
-  },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "better-sqlite3"
-    ]
   }
 }

packages/agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/agent",
-  "version": "0.0.2",
+  "version": "0.0.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -21,12 +21,5 @@
   "devDependencies": {
     "typescript": "^5.8.0",
     "vitest": "^2.0.0"
-  },
+  }
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
 }

packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/auth",
-  "version": "0.0.2",
+  "version": "0.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,12 +25,5 @@
   "dependencies": {
     "@mosaic/db": "workspace:^",
     "better-auth": "^1.5.5"
-  },
+  }
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
 }

packages/brain/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/brain",
-  "version": "0.0.2",
+  "version": "0.0.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -22,12 +22,5 @@
   "devDependencies": {
     "typescript": "^5.8.0",
     "vitest": "^2.0.0"
-  },
+  }
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
 }

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/cli",
-  "version": "0.0.10",
+  "version": "0.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,7 @@
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc",
     "dev": "tsx src/cli.ts",
     "lint": "eslint src",
     "typecheck": "tsc --noEmit",
@@ -22,7 +22,6 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.9.0",
-    "@mosaic/config": "workspace:^",
     "@mosaic/mosaic": "workspace:^",
     "@mosaic/prdy": "workspace:^",
     "@mosaic/quality-rails": "workspace:^",
@@ -40,12 +39,5 @@
     "tsx": "^4.0.0",
     "typescript": "^5.8.0",
     "vitest": "^2.0.0"
-  },
+  }
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
 }

packages/cli/src/cli.ts

@@ -2,32 +2,18 @@
 
 import { createRequire } from 'module';
 import { Command } from 'commander';
-import { registerQualityRails } from '@mosaic/quality-rails';
+import { createQualityRailsCli } from '@mosaic/quality-rails';
 import { registerAgentCommand } from './commands/agent.js';
 import { registerMissionCommand } from './commands/mission.js';
-// prdy is registered via launch.ts
+import { registerPrdyCommand } from './commands/prdy.js';
-import { registerLaunchCommands } from './commands/launch.js';
-import { registerGatewayCommand } from './commands/gateway.js';
 
 const _require = createRequire(import.meta.url);
 const CLI_VERSION: string = (_require('../package.json') as { version: string }).version;
 
-// Fire-and-forget update check at startup (non-blocking, cached 1h)
-try {
-  const { backgroundUpdateCheck } = await import('@mosaic/mosaic');
-  backgroundUpdateCheck();
-} catch {
-  // Silently ignore — update check is best-effort
-}
-
 const program = new Command();
 
 program.name('mosaic').description('Mosaic Stack CLI').version(CLI_VERSION);
 
-// ─── runtime launchers + framework commands ────────────────────────────
-
-registerLaunchCommands(program);
-
 // ─── login ──────────────────────────────────────────────────────────────
 
 program
@@ -291,10 +277,6 @@ sessionsCmd
     }
   });
 
-// ─── gateway ──────────────────────────────────────────────────────────
-
-registerGatewayCommand(program);
-
 // ─── agent ─────────────────────────────────────────────────────────────
 
 registerAgentCommand(program);
@@ -303,57 +285,17 @@ registerAgentCommand(program);
 
 registerMissionCommand(program);
 
+// ─── prdy ──────────────────────────────────────────────────────────────
+
+registerPrdyCommand(program);
+
 // ─── quality-rails ──────────────────────────────────────────────────────
 
-registerQualityRails(program);
+const qrWrapper = createQualityRailsCli();
-
+const qrCmd = qrWrapper.commands.find((c) => c.name() === 'quality-rails');
-// ─── update ─────────────────────────────────────────────────────────────
+if (qrCmd !== undefined) {
-
+  program.addCommand(qrCmd as unknown as Command);
-program
+}
-  .command('update')
-  .description('Check for and install Mosaic CLI updates')
-  .option('--check', 'Check only, do not install')
-  .action(async (opts: { check?: boolean }) => {
-    const { checkForUpdate, formatUpdateNotice } = await import('@mosaic/mosaic');
-    const { execSync } = await import('node:child_process');
-
-    console.log('Checking for updates…');
-    const result = checkForUpdate({ skipCache: true });
-
-    if (!result.latest) {
-      console.error('Could not reach the Mosaic registry.');
-      process.exit(1);
-    }
-
-    console.log(`  Installed: ${result.current || '(none)'}`);
-    console.log(`  Latest:    ${result.latest}`);
-
-    if (!result.updateAvailable) {
-      console.log('\n✔ Up to date.');
-      return;
-    }
-
-    const notice = formatUpdateNotice(result);
-    if (notice) console.log(notice);
-
-    if (opts.check) {
-      process.exit(2); // Signal to callers that an update exists
-    }
-
-    console.log('Installing update…');
-    try {
-      // Relies on @mosaic:registry in ~/.npmrc — do NOT pass --registry
-      // globally or non-@mosaic deps will 404 against the Gitea registry.
-      execSync('npm install -g @mosaic/cli@latest', {
-        stdio: 'inherit',
-        timeout: 60_000,
-      });
-      console.log('\n✔ Updated successfully.');
-    } catch {
-      console.error('\nUpdate failed. Try manually: bash tools/install.sh');
-      process.exit(1);
-    }
-  });
 
 // ─── wizard ─────────────────────────────────────────────────────────────
 

packages/cli/src/commands/gateway.ts

@@ -1,198 +0,0 @@
-import { createInterface } from 'node:readline';
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import type { Command } from 'commander';
-import {
-  DEFAULT_LOCAL_CONFIG,
-  DEFAULT_TEAM_CONFIG,
-  loadConfig,
-  type MosaicConfig,
-  type StorageTier,
-} from '@mosaic/config';
-
-function ask(rl: ReturnType<typeof createInterface>, question: string): Promise<string> {
-  return new Promise((res) => rl.question(question, res));
-}
-
-async function runInit(opts: { tier?: string; output: string }): Promise<void> {
-  const outputPath = resolve(opts.output);
-  let tier: StorageTier;
-
-  if (opts.tier) {
-    if (opts.tier !== 'local' && opts.tier !== 'team') {
-      console.error(`Invalid tier "${opts.tier}" — expected "local" or "team"`);
-      process.exit(1);
-    }
-    tier = opts.tier;
-  } else {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await ask(rl, 'Select tier (local/team) [local]: ');
-    rl.close();
-    const trimmed = answer.trim().toLowerCase();
-    tier = trimmed === 'team' ? 'team' : 'local';
-  }
-
-  let config: MosaicConfig;
-
-  if (tier === 'local') {
-    config = DEFAULT_LOCAL_CONFIG;
-  } else {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    const dbUrl = await ask(
-      rl,
-      'DATABASE_URL [postgresql://mosaic:mosaic@localhost:5432/mosaic]: ',
-    );
-    const valkeyUrl = await ask(rl, 'VALKEY_URL [redis://localhost:6379]: ');
-    rl.close();
-
-    config = {
-      ...DEFAULT_TEAM_CONFIG,
-      storage: {
-        type: 'postgres',
-        url: dbUrl.trim() || 'postgresql://mosaic:mosaic@localhost:5432/mosaic',
-      },
-      queue: {
-        type: 'bullmq',
-        url: valkeyUrl.trim() || 'redis://localhost:6379',
-      },
-    };
-  }
-
-  writeFileSync(outputPath, JSON.stringify(config, null, 2) + '\n');
-  console.log(`\nWrote ${outputPath}`);
-  console.log('\nNext steps:');
-  console.log('  1. Review the generated config');
-  console.log('  2. Run: pnpm --filter @mosaic/gateway exec tsx src/main.ts');
-}
-
-const PID_FILE = resolve(process.cwd(), '.mosaic/gateway.pid');
-
-function writePidFile(pid: number): void {
-  const dir = dirname(PID_FILE);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(PID_FILE, String(pid));
-}
-
-function readPidFile(): number | null {
-  if (!existsSync(PID_FILE)) return null;
-  const raw = readFileSync(PID_FILE, 'utf-8').trim();
-  const pid = Number(raw);
-  return Number.isFinite(pid) ? pid : null;
-}
-
-function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function printConfigSummary(config: MosaicConfig): void {
-  console.log(`  Tier:    ${config.tier}`);
-  console.log(`  Storage: ${config.storage.type}`);
-  console.log(`  Queue:   ${config.queue.type}`);
-  console.log(`  Memory:  ${config.memory.type}`);
-}
-
-export function registerGatewayCommand(program: Command): void {
-  const gateway = program.command('gateway').description('Gateway management commands');
-
-  gateway
-    .command('init')
-    .description('Generate a mosaic.config.json for the gateway')
-    .option('--tier <tier>', 'Storage tier: local or team (skips interactive prompt)')
-    .option('--output <path>', 'Output file path', './mosaic.config.json')
-    .action(async (opts: { tier?: string; output: string }) => {
-      await runInit(opts);
-    });
-
-  gateway
-    .command('start')
-    .description('Start the Mosaic gateway process')
-    .option('--port <port>', 'Port to listen on (overrides config)')
-    .option('--daemon', 'Run in background and write PID to .mosaic/gateway.pid')
-    .action((opts: { port?: string; daemon?: boolean }) => {
-      const config = loadConfig();
-      const port = opts.port ?? '4000';
-
-      console.log('Starting gateway…');
-      printConfigSummary(config);
-      console.log(`  Port:    ${port}`);
-
-      const entryPoint = resolve(process.cwd(), 'apps/gateway/src/main.ts');
-      const env = { ...process.env, GATEWAY_PORT: port };
-
-      if (opts.daemon) {
-        const child = spawn('npx', ['tsx', entryPoint], {
-          env,
-          stdio: 'ignore',
-          detached: true,
-        });
-
-        child.unref();
-
-        if (child.pid) {
-          writePidFile(child.pid);
-          console.log(`\nGateway started in background (PID ${child.pid})`);
-          console.log(`PID file: ${PID_FILE}`);
-        }
-      } else {
-        const child = spawn('npx', ['tsx', entryPoint], {
-          env,
-          stdio: 'inherit',
-        });
-
-        child.on('exit', (code) => {
-          process.exit(code ?? 0);
-        });
-      }
-    });
-
-  gateway
-    .command('stop')
-    .description('Stop the running gateway process')
-    .action(() => {
-      const pid = readPidFile();
-
-      if (pid === null) {
-        console.error('No PID file found at', PID_FILE);
-        process.exit(1);
-      }
-
-      if (!isProcessRunning(pid)) {
-        console.log(`Process ${pid} is not running. Removing stale PID file.`);
-        unlinkSync(PID_FILE);
-        return;
-      }
-
-      process.kill(pid, 'SIGTERM');
-      unlinkSync(PID_FILE);
-      console.log(`Gateway stopped (PID ${pid})`);
-    });
-
-  gateway
-    .command('status')
-    .description('Show gateway process status')
-    .action(() => {
-      const config = loadConfig();
-      const pid = readPidFile();
-
-      if (pid !== null && isProcessRunning(pid)) {
-        console.log('Gateway: running');
-        console.log(`  PID:     ${pid}`);
-      } else {
-        console.log('Gateway: stopped');
-        if (pid !== null) {
-          console.log(`  (stale PID file for ${pid})`);
-          unlinkSync(PID_FILE);
-        }
-      }
-
-      console.log('');
-      console.log('Config:');
-      printConfigSummary(config);
-    });
-}

packages/cli/src/commands/launch.ts

@@ -1,772 +0,0 @@
-/**
- * Native runtime launcher — replaces the bash mosaic-launch script.
- *
- * Builds a composed runtime prompt from AGENTS.md + RUNTIME.md + USER.md +
- * TOOLS.md + mission context + PRD status, then exec's into the target CLI.
- */
-
-import { execFileSync, execSync, spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, rmSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { homedir } from 'node:os';
-import { join, dirname } from 'node:path';
-import type { Command } from 'commander';
-
-const MOSAIC_HOME = process.env['MOSAIC_HOME'] ?? join(homedir(), '.config', 'mosaic');
-
-type RuntimeName = 'claude' | 'codex' | 'opencode' | 'pi';
-
-const RUNTIME_LABELS: Record<RuntimeName, string> = {
-  claude: 'Claude Code',
-  codex: 'Codex',
-  opencode: 'OpenCode',
-  pi: 'Pi',
-};
-
-// ─── Pre-flight checks ──────────────────────────────────────────────────────
-
-function checkMosaicHome(): void {
-  if (!existsSync(MOSAIC_HOME)) {
-    console.error(`[mosaic] ERROR: ${MOSAIC_HOME} not found.`);
-    console.error(
-      '[mosaic] Install: bash <(curl -fsSL https://git.mosaicstack.dev/mosaic/mosaic-stack/raw/branch/main/tools/install.sh)',
-    );
-    process.exit(1);
-  }
-}
-
-function checkFile(path: string, label: string): void {
-  if (!existsSync(path)) {
-    console.error(`[mosaic] ERROR: ${label} not found: ${path}`);
-    process.exit(1);
-  }
-}
-
-function checkRuntime(cmd: string): void {
-  try {
-    execSync(`which ${cmd}`, { stdio: 'ignore' });
-  } catch {
-    console.error(`[mosaic] ERROR: '${cmd}' not found in PATH.`);
-    console.error(`[mosaic] Install ${cmd} before launching.`);
-    process.exit(1);
-  }
-}
-
-function checkSoul(): void {
-  const soulPath = join(MOSAIC_HOME, 'SOUL.md');
-  if (!existsSync(soulPath)) {
-    console.log('[mosaic] SOUL.md not found. Running setup wizard...');
-
-    // Prefer the TypeScript wizard (idempotent, detects existing files)
-    try {
-      const result = spawnSync(process.execPath, [process.argv[1]!, 'wizard'], {
-        stdio: 'inherit',
-      });
-      if (result.status === 0 && existsSync(soulPath)) return;
-    } catch {
-      // Fall through to legacy init
-    }
-
-    // Fallback: legacy bash mosaic-init
-    const initBin = fwScript('mosaic-init');
-    if (existsSync(initBin)) {
-      spawnSync(initBin, [], { stdio: 'inherit' });
-    } else {
-      console.error('[mosaic] Setup failed. Run: mosaic wizard');
-      process.exit(1);
-    }
-  }
-}
-
-function checkSequentialThinking(runtime: string): void {
-  const checker = fwScript('mosaic-ensure-sequential-thinking');
-  if (!existsSync(checker)) return; // Skip if checker doesn't exist
-  const result = spawnSync(checker, ['--check', '--runtime', runtime], { stdio: 'ignore' });
-  if (result.status !== 0) {
-    console.error('[mosaic] ERROR: sequential-thinking MCP is required but not configured.');
-    console.error(`[mosaic] Fix: ${checker} --runtime ${runtime}`);
-    process.exit(1);
-  }
-}
-
-// ─── File helpers ────────────────────────────────────────────────────────────
-
-function readOptional(path: string): string {
-  try {
-    return readFileSync(path, 'utf-8');
-  } catch {
-    return '';
-  }
-}
-
-function readJson(path: string): Record<string, unknown> | null {
-  try {
-    return JSON.parse(readFileSync(path, 'utf-8')) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
-// ─── Mission context ─────────────────────────────────────────────────────────
-
-interface MissionInfo {
-  name: string;
-  id: string;
-  status: string;
-  milestoneCount: number;
-  completedCount: number;
-}
-
-function detectMission(): MissionInfo | null {
-  const missionFile = '.mosaic/orchestrator/mission.json';
-  const data = readJson(missionFile);
-  if (!data) return null;
-
-  const status = String(data['status'] ?? 'inactive');
-  if (status !== 'active' && status !== 'paused') return null;
-
-  const milestones = Array.isArray(data['milestones']) ? data['milestones'] : [];
-  const completed = milestones.filter(
-    (m) =>
-      typeof m === 'object' &&
-      m !== null &&
-      (m as Record<string, unknown>)['status'] === 'completed',
-  );
-
-  return {
-    name: String(data['name'] ?? 'unnamed'),
-    id: String(data['mission_id'] ?? ''),
-    status,
-    milestoneCount: milestones.length,
-    completedCount: completed.length,
-  };
-}
-
-function buildMissionBlock(mission: MissionInfo): string {
-  return `# ACTIVE MISSION — HARD GATE (Read Before Anything Else)
-
-An active orchestration mission exists in this project. This is a BLOCKING requirement.
-
-**Mission:** ${mission.name}
-**ID:** ${mission.id}
-**Status:** ${mission.status}
-**Milestones:** ${mission.completedCount} / ${mission.milestoneCount} completed
-
-## MANDATORY — Before ANY Response to the User
-
-You MUST complete these steps before responding to any user message, including simple greetings:
-
-1. Read \`~/.config/mosaic/guides/ORCHESTRATOR-PROTOCOL.md\` (mission lifecycle protocol)
-2. Read \`docs/MISSION-MANIFEST.md\` for full mission scope, milestones, and success criteria
-3. Read the latest scratchpad in \`docs/scratchpads/\` for session history, decisions, and corrections
-4. Read \`docs/TASKS.md\` for current task state (what is done, what is next)
-5. After reading all four, acknowledge the mission state to the user before proceeding
-
-If the user gives a task, execute it within the mission context. If no task is given, present mission status and ask how to proceed.
-
-`;
-}
-
-// ─── PRD status ──────────────────────────────────────────────────────────────
-
-function buildPrdBlock(): string {
-  const prdFile = 'docs/PRD.md';
-  if (!existsSync(prdFile)) return '';
-
-  const content = readFileSync(prdFile, 'utf-8');
-  const patterns = [
-    /^#{2,3} .*(problem statement|objective)/im,
-    /^#{2,3} .*(scope|non.goal|out of scope|in.scope)/im,
-    /^#{2,3} .*(user stor|stakeholder|user.*requirement)/im,
-    /^#{2,3} .*functional requirement/im,
-    /^#{2,3} .*non.functional/im,
-    /^#{2,3} .*acceptance criteria/im,
-    /^#{2,3} .*(technical consideration|constraint|dependenc)/im,
-    /^#{2,3} .*(risk|open question)/im,
-    /^#{2,3} .*(success metric|test|verification)/im,
-    /^#{2,3} .*(milestone|delivery|scope version)/im,
-  ];
-
-  let sections = 0;
-  for (const pattern of patterns) {
-    if (pattern.test(content)) sections++;
-  }
-
-  const assumptions = (content.match(/ASSUMPTION:/g) ?? []).length;
-  const status = sections < 10 ? `incomplete (${sections}/10 sections)` : 'ready';
-
-  return `
-# PRD Status
-
-- **File:** docs/PRD.md
-- **Status:** ${status}
-- **Assumptions:** ${assumptions}
-
-`;
-}
-
-// ─── Runtime prompt builder ──────────────────────────────────────────────────
-
-function buildRuntimePrompt(runtime: RuntimeName): string {
-  const runtimeContractPaths: Record<RuntimeName, string> = {
-    claude: join(MOSAIC_HOME, 'runtime', 'claude', 'RUNTIME.md'),
-    codex: join(MOSAIC_HOME, 'runtime', 'codex', 'RUNTIME.md'),
-    opencode: join(MOSAIC_HOME, 'runtime', 'opencode', 'RUNTIME.md'),
-    pi: join(MOSAIC_HOME, 'runtime', 'pi', 'RUNTIME.md'),
-  };
-
-  const runtimeFile = runtimeContractPaths[runtime];
-  checkFile(runtimeFile, `Runtime contract for ${runtime}`);
-
-  const parts: string[] = [];
-
-  // Mission context (injected first)
-  const mission = detectMission();
-  if (mission) {
-    parts.push(buildMissionBlock(mission));
-  }
-
-  // PRD status
-  const prdBlock = buildPrdBlock();
-  if (prdBlock) parts.push(prdBlock);
-
-  // Hard gate
-  parts.push(`# Mosaic Launcher Runtime Contract (Hard Gate)
-
-This contract is injected by \`mosaic\` launch and is mandatory.
-
-First assistant response MUST start with exactly one mode declaration line:
-1. Orchestration mission: \`Now initiating Orchestrator mode...\`
-2. Implementation mission: \`Now initiating Delivery mode...\`
-3. Review-only mission: \`Now initiating Review mode...\`
-
-No tool call or implementation step may occur before that first line.
-
-Mosaic hard gates OVERRIDE runtime-default caution for routine delivery operations.
-For required push/merge/issue-close/release actions, execute without routine confirmation prompts.
-`);
-
-  // AGENTS.md
-  parts.push(readFileSync(join(MOSAIC_HOME, 'AGENTS.md'), 'utf-8'));
-
-  // USER.md
-  const user = readOptional(join(MOSAIC_HOME, 'USER.md'));
-  if (user) parts.push('\n\n# User Profile\n\n' + user);
-
-  // TOOLS.md
-  const tools = readOptional(join(MOSAIC_HOME, 'TOOLS.md'));
-  if (tools) parts.push('\n\n# Machine Tools\n\n' + tools);
-
-  // Runtime-specific contract
-  parts.push('\n\n# Runtime-Specific Contract\n\n' + readFileSync(runtimeFile, 'utf-8'));
-
-  return parts.join('\n');
-}
-
-// ─── Session lock ────────────────────────────────────────────────────────────
-
-function writeSessionLock(runtime: string): void {
-  const missionFile = '.mosaic/orchestrator/mission.json';
-  const lockFile = '.mosaic/orchestrator/session.lock';
-  const data = readJson(missionFile);
-  if (!data) return;
-
-  const status = String(data['status'] ?? 'inactive');
-  if (status !== 'active' && status !== 'paused') return;
-
-  const sessionId = `${runtime}-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
-  const lock = {
-    session_id: sessionId,
-    runtime,
-    pid: process.pid,
-    started_at: new Date().toISOString(),
-    project_path: process.cwd(),
-    milestone_id: '',
-  };
-
-  try {
-    mkdirSync(dirname(lockFile), { recursive: true });
-    writeFileSync(lockFile, JSON.stringify(lock, null, 2) + '\n');
-
-    // Clean up on exit
-    const cleanup = () => {
-      try {
-        rmSync(lockFile, { force: true });
-      } catch {
-        // best-effort
-      }
-    };
-    process.on('exit', cleanup);
-    process.on('SIGINT', () => {
-      cleanup();
-      process.exit(130);
-    });
-    process.on('SIGTERM', () => {
-      cleanup();
-      process.exit(143);
-    });
-  } catch {
-    // Non-fatal
-  }
-}
-
-// ─── Resumable session advisory ──────────────────────────────────────────────
-
-function checkResumableSession(): void {
-  const lockFile = '.mosaic/orchestrator/session.lock';
-  const missionFile = '.mosaic/orchestrator/mission.json';
-
-  if (existsSync(lockFile)) {
-    const lock = readJson(lockFile);
-    if (lock) {
-      const pid = Number(lock['pid'] ?? 0);
-      if (pid > 0) {
-        try {
-          process.kill(pid, 0); // Check if alive
-        } catch {
-          // Process is dead — stale lock
-          rmSync(lockFile, { force: true });
-          console.log(`[mosaic] Cleaned up stale session lock (PID ${pid} no longer running).\n`);
-        }
-      }
-    }
-  } else if (existsSync(missionFile)) {
-    const data = readJson(missionFile);
-    if (data && data['status'] === 'active') {
-      console.log('[mosaic] Active mission detected. Generate continuation prompt with:');
-      console.log('[mosaic]   mosaic coord continue\n');
-    }
-  }
-}
-
-// ─── Write config for runtimes that read from fixed paths ────────────────────
-
-function ensureRuntimeConfig(runtime: RuntimeName, destPath: string): void {
-  const prompt = buildRuntimePrompt(runtime);
-  mkdirSync(dirname(destPath), { recursive: true });
-  const existing = readOptional(destPath);
-  if (existing !== prompt) {
-    writeFileSync(destPath, prompt);
-  }
-}
-
-// ─── Pi skill/extension discovery ────────────────────────────────────────────
-
-function discoverPiSkills(): string[] {
-  const args: string[] = [];
-  for (const skillsRoot of [join(MOSAIC_HOME, 'skills'), join(MOSAIC_HOME, 'skills-local')]) {
-    if (!existsSync(skillsRoot)) continue;
-    try {
-      for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
-        if (!entry.isDirectory()) continue;
-        const skillDir = join(skillsRoot, entry.name);
-        if (existsSync(join(skillDir, 'SKILL.md'))) {
-          args.push('--skill', skillDir);
-        }
-      }
-    } catch {
-      // skip
-    }
-  }
-  return args;
-}
-
-function discoverPiExtension(): string[] {
-  const ext = join(MOSAIC_HOME, 'runtime', 'pi', 'mosaic-extension.ts');
-  return existsSync(ext) ? ['--extension', ext] : [];
-}
-
-// ─── Launch functions ────────────────────────────────────────────────────────
-
-function getMissionPrompt(): string {
-  const mission = detectMission();
-  if (!mission) return '';
-  return `Active mission detected: ${mission.name}. Read the mission state files and report status.`;
-}
-
-function launchRuntime(runtime: RuntimeName, args: string[], yolo: boolean): never {
-  checkMosaicHome();
-  checkFile(join(MOSAIC_HOME, 'AGENTS.md'), 'AGENTS.md');
-  checkSoul();
-  checkRuntime(runtime);
-
-  // Pi doesn't need sequential-thinking (has native thinking levels)
-  if (runtime !== 'pi') {
-    checkSequentialThinking(runtime);
-  }
-
-  checkResumableSession();
-
-  const missionPrompt = getMissionPrompt();
-  const hasMissionNoArgs = missionPrompt && args.length === 0;
-  const label = RUNTIME_LABELS[runtime];
-  const modeStr = yolo ? ' in YOLO mode' : '';
-  const missionStr = hasMissionNoArgs ? ' (active mission detected)' : '';
-
-  writeSessionLock(runtime);
-
-  switch (runtime) {
-    case 'claude': {
-      const prompt = buildRuntimePrompt('claude');
-      const cliArgs = yolo ? ['--dangerously-skip-permissions'] : [];
-      cliArgs.push('--append-system-prompt', prompt);
-      if (hasMissionNoArgs) {
-        cliArgs.push(missionPrompt);
-      } else {
-        cliArgs.push(...args);
-      }
-      console.log(`[mosaic] Launching ${label}${modeStr}${missionStr}...`);
-      execRuntime('claude', cliArgs);
-      break;
-    }
-
-    case 'codex': {
-      ensureRuntimeConfig('codex', join(homedir(), '.codex', 'instructions.md'));
-      const cliArgs = yolo ? ['--dangerously-bypass-approvals-and-sandbox'] : [];
-      if (hasMissionNoArgs) {
-        cliArgs.push(missionPrompt);
-      } else {
-        cliArgs.push(...args);
-      }
-      console.log(`[mosaic] Launching ${label}${modeStr}${missionStr}...`);
-      execRuntime('codex', cliArgs);
-      break;
-    }
-
-    case 'opencode': {
-      ensureRuntimeConfig('opencode', join(homedir(), '.config', 'opencode', 'AGENTS.md'));
-      console.log(`[mosaic] Launching ${label}${modeStr}...`);
-      execRuntime('opencode', args);
-      break;
-    }
-
-    case 'pi': {
-      const prompt = buildRuntimePrompt('pi');
-      const cliArgs = ['--append-system-prompt', prompt];
-      cliArgs.push(...discoverPiSkills());
-      cliArgs.push(...discoverPiExtension());
-      if (hasMissionNoArgs) {
-        cliArgs.push(missionPrompt);
-      } else {
-        cliArgs.push(...args);
-      }
-      console.log(`[mosaic] Launching ${label}${modeStr}${missionStr}...`);
-      execRuntime('pi', cliArgs);
-      break;
-    }
-  }
-
-  process.exit(0); // Unreachable but satisfies never
-}
-
-/** exec into the runtime, replacing the current process. */
-function execRuntime(cmd: string, args: string[]): void {
-  try {
-    // Use execFileSync with inherited stdio to replace the process
-    const result = spawnSync(cmd, args, {
-      stdio: 'inherit',
-      env: process.env,
-    });
-    process.exit(result.status ?? 0);
-  } catch (err) {
-    console.error(`[mosaic] Failed to launch ${cmd}:`, err instanceof Error ? err.message : err);
-    process.exit(1);
-  }
-}
-
-// ─── Framework script/tool delegation ───────────────────────────────────────
-
-function delegateToScript(scriptPath: string, args: string[], env?: Record<string, string>): never {
-  if (!existsSync(scriptPath)) {
-    console.error(`[mosaic] Script not found: ${scriptPath}`);
-    process.exit(1);
-  }
-  try {
-    execFileSync('bash', [scriptPath, ...args], {
-      stdio: 'inherit',
-      env: { ...process.env, ...env },
-    });
-    process.exit(0);
-  } catch (err) {
-    process.exit((err as { status?: number }).status ?? 1);
-  }
-}
-
-/**
- * Resolve a path under the framework tools directory. Prefers the version
- * bundled in the @mosaic/mosaic npm package (always matches the installed
- * CLI version) over the deployed copy in ~/.config/mosaic/ (may be stale).
- */
-function resolveTool(...segments: string[]): string {
-  try {
-    const req = createRequire(import.meta.url);
-    const mosaicPkg = dirname(req.resolve('@mosaic/mosaic/package.json'));
-    const bundled = join(mosaicPkg, 'framework', 'tools', ...segments);
-    if (existsSync(bundled)) return bundled;
-  } catch {
-    // Fall through to deployed copy
-  }
-  return join(MOSAIC_HOME, 'tools', ...segments);
-}
-
-function fwScript(name: string): string {
-  return resolveTool('_scripts', name);
-}
-
-function toolScript(toolDir: string, name: string): string {
-  return resolveTool(toolDir, name);
-}
-
-// ─── Coord (mission orchestrator) ───────────────────────────────────────────
-
-const COORD_SUBCMDS: Record<string, string> = {
-  status: 'session-status.sh',
-  session: 'session-status.sh',
-  init: 'mission-init.sh',
-  mission: 'mission-status.sh',
-  progress: 'mission-status.sh',
-  continue: 'continue-prompt.sh',
-  next: 'continue-prompt.sh',
-  run: 'session-run.sh',
-  start: 'session-run.sh',
-  smoke: 'smoke-test.sh',
-  test: 'smoke-test.sh',
-  resume: 'session-resume.sh',
-  recover: 'session-resume.sh',
-};
-
-function runCoord(args: string[]): never {
-  checkMosaicHome();
-  let runtime = 'claude';
-  let yoloFlag = '';
-  const coordArgs: string[] = [];
-
-  for (const arg of args) {
-    if (arg === '--claude' || arg === '--codex' || arg === '--pi') {
-      runtime = arg.slice(2);
-    } else if (arg === '--yolo') {
-      yoloFlag = '--yolo';
-    } else {
-      coordArgs.push(arg);
-    }
-  }
-
-  const subcmd = coordArgs[0] ?? 'help';
-  const subArgs = coordArgs.slice(1);
-  const script = COORD_SUBCMDS[subcmd];
-
-  if (!script) {
-    console.log(`mosaic coord — mission coordinator tools
-
-Commands:
-  init --name <name> [opts]   Initialize a new mission
-  mission [--project <path>]  Show mission progress dashboard
-  status [--project <path>]   Check agent session health
-  continue [--project <path>] Generate continuation prompt
-  run [--project <path>]      Launch runtime with mission context
-  smoke                       Run orchestration smoke checks
-  resume [--project <path>]   Crash recovery
-
-Runtime: --claude (default) | --codex | --pi | --yolo`);
-    process.exit(subcmd === 'help' ? 0 : 1);
-  }
-
-  if (yoloFlag) subArgs.unshift(yoloFlag);
-  delegateToScript(toolScript('orchestrator', script), subArgs, {
-    MOSAIC_COORD_RUNTIME: runtime,
-  });
-}
-
-// ─── Prdy (PRD tools via framework scripts) ─────────────────────────────────
-
-const PRDY_SUBCMDS: Record<string, string> = {
-  init: 'prdy-init.sh',
-  update: 'prdy-update.sh',
-  validate: 'prdy-validate.sh',
-  check: 'prdy-validate.sh',
-  status: 'prdy-status.sh',
-};
-
-function runPrdyLocal(args: string[]): never {
-  checkMosaicHome();
-  let runtime = 'claude';
-  const prdyArgs: string[] = [];
-
-  for (const arg of args) {
-    if (arg === '--claude' || arg === '--codex' || arg === '--pi') {
-      runtime = arg.slice(2);
-    } else {
-      prdyArgs.push(arg);
-    }
-  }
-
-  const subcmd = prdyArgs[0] ?? 'help';
-  const subArgs = prdyArgs.slice(1);
-  const script = PRDY_SUBCMDS[subcmd];
-
-  if (!script) {
-    console.log(`mosaic prdy — PRD creation and validation
-
-Commands:
-  init [--project <path>] [--name <feature>]   Create docs/PRD.md
-  update [--project <path>]                    Update existing PRD
-  validate [--project <path>]                  Check PRD completeness
-  status [--project <path>]                    Quick PRD health check
-
-Runtime: --claude (default) | --codex | --pi`);
-    process.exit(subcmd === 'help' ? 0 : 1);
-  }
-
-  delegateToScript(toolScript('prdy', script), subArgs, {
-    MOSAIC_PRDY_RUNTIME: runtime,
-  });
-}
-
-// ─── Seq (sequential-thinking MCP) ──────────────────────────────────────────
-
-function runSeq(args: string[]): never {
-  checkMosaicHome();
-  const action = args[0] ?? 'check';
-  const rest = args.slice(1);
-  const checker = fwScript('mosaic-ensure-sequential-thinking');
-
-  switch (action) {
-    case 'check':
-      delegateToScript(checker, ['--check', ...rest]);
-      break; // unreachable
-    case 'fix':
-    case 'apply':
-      delegateToScript(checker, rest);
-      break;
-    case 'start': {
-      console.log('[mosaic] Starting sequential-thinking MCP server...');
-      try {
-        execFileSync('npx', ['-y', '@modelcontextprotocol/server-sequential-thinking', ...rest], {
-          stdio: 'inherit',
-        });
-        process.exit(0);
-      } catch (err) {
-        process.exit((err as { status?: number }).status ?? 1);
-      }
-      break;
-    }
-    default:
-      console.error(`[mosaic] Unknown seq subcommand '${action}'. Use: check|fix|start`);
-      process.exit(1);
-  }
-}
-
-// ─── Upgrade ────────────────────────────────────────────────────────────────
-
-function runUpgrade(args: string[]): never {
-  checkMosaicHome();
-  const subcmd = args[0];
-
-  if (!subcmd || subcmd === 'release') {
-    delegateToScript(fwScript('mosaic-release-upgrade'), args.slice(subcmd === 'release' ? 1 : 0));
-  } else if (subcmd === 'check') {
-    delegateToScript(fwScript('mosaic-release-upgrade'), ['--dry-run', ...args.slice(1)]);
-  } else if (subcmd === 'project') {
-    delegateToScript(fwScript('mosaic-upgrade'), args.slice(1));
-  } else if (subcmd.startsWith('-')) {
-    delegateToScript(fwScript('mosaic-release-upgrade'), args);
-  } else {
-    delegateToScript(fwScript('mosaic-upgrade'), args);
-  }
-}
-
-// ─── Commander registration ─────────────────────────────────────────────────
-
-export function registerLaunchCommands(program: Command): void {
-  // Runtime launchers
-  for (const runtime of ['claude', 'codex', 'opencode', 'pi'] as const) {
-    program
-      .command(runtime)
-      .description(`Launch ${RUNTIME_LABELS[runtime]} with Mosaic injection`)
-      .allowUnknownOption(true)
-      .allowExcessArguments(true)
-      .action((_opts: unknown, cmd: Command) => {
-        launchRuntime(runtime, cmd.args, false);
-      });
-  }
-
-  // Yolo mode
-  program
-    .command('yolo <runtime>')
-    .description('Launch a runtime in dangerous-permissions mode (claude|codex|opencode|pi)')
-    .allowUnknownOption(true)
-    .allowExcessArguments(true)
-    .action((runtime: string, _opts: unknown, cmd: Command) => {
-      const valid: RuntimeName[] = ['claude', 'codex', 'opencode', 'pi'];
-      if (!valid.includes(runtime as RuntimeName)) {
-        console.error(
-          `[mosaic] ERROR: Unsupported yolo runtime '${runtime}'. Use: ${valid.join('|')}`,
-        );
-        process.exit(1);
-      }
-      launchRuntime(runtime as RuntimeName, cmd.args, true);
-    });
-
-  // Coord (mission orchestrator)
-  program
-    .command('coord')
-    .description('Mission coordinator tools (init, status, run, continue, resume)')
-    .allowUnknownOption(true)
-    .allowExcessArguments(true)
-    .action((_opts: unknown, cmd: Command) => {
-      runCoord(cmd.args);
-    });
-
-  // Prdy (PRD tools via local framework scripts)
-  program
-    .command('prdy')
-    .description('PRD creation and validation (init, update, validate, status)')
-    .allowUnknownOption(true)
-    .allowExcessArguments(true)
-    .action((_opts: unknown, cmd: Command) => {
-      runPrdyLocal(cmd.args);
-    });
-
-  // Seq (sequential-thinking MCP management)
-  program
-    .command('seq')
-    .description('sequential-thinking MCP management (check/fix/start)')
-    .allowUnknownOption(true)
-    .allowExcessArguments(true)
-    .action((_opts: unknown, cmd: Command) => {
-      runSeq(cmd.args);
-    });
-
-  // Upgrade (release + project)
-  program
-    .command('upgrade')
-    .description('Upgrade Mosaic release or project files')
-    .allowUnknownOption(true)
-    .allowExcessArguments(true)
-    .action((_opts: unknown, cmd: Command) => {
-      runUpgrade(cmd.args);
-    });
-
-  // Direct framework script delegates
-  const directCommands: Record<string, { desc: string; script: string }> = {
-    init: { desc: 'Generate SOUL.md (agent identity contract)', script: 'mosaic-init' },
-    doctor: { desc: 'Health audit — detect drift and missing files', script: 'mosaic-doctor' },
-    sync: { desc: 'Sync skills from canonical source', script: 'mosaic-sync-skills' },
-    bootstrap: {
-      desc: 'Bootstrap a repo with Mosaic standards',
-      script: 'mosaic-bootstrap-repo',
-    },
-  };
-
-  for (const [name, { desc, script }] of Object.entries(directCommands)) {
-    program
-      .command(name)
-      .description(desc)
-      .allowUnknownOption(true)
-      .allowExcessArguments(true)
-      .action((_opts: unknown, cmd: Command) => {
-        checkMosaicHome();
-        delegateToScript(fwScript(script), cmd.args);
-      });
-  }
-}

packages/cli/src/tui/app.tsx

@@ -15,7 +15,6 @@ import { useConversations } from './hooks/use-conversations.js';
 import { useSearch } from './hooks/use-search.js';
 import { executeHelp, executeStatus, executeHistory, commandRegistry } from './commands/index.js';
 import { fetchConversationMessages } from './gateway-api.js';
-import { expandFileRefs, hasFileRefs, handleAttachCommand } from './file-ref.js';
 
 export interface TuiAppProps {
   gatewayUrl: string;
@@ -86,36 +85,6 @@ export function TuiApp({
   // combo is handled by the top-level useInput handler (e.g. Ctrl+T → 't').
   const ctrlJustFired = useRef(false);
 
-  // Wrap sendMessage to expand @file references before sending
-  const sendMessageWithFileRefs = useCallback(
-    (content: string) => {
-      if (!hasFileRefs(content)) {
-        socket.sendMessage(content);
-        return;
-      }
-      void expandFileRefs(content)
-        .then(({ expandedMessage, filesAttached, errors }) => {
-          for (const err of errors) {
-            socket.addSystemMessage(err);
-          }
-          if (filesAttached.length > 0) {
-            socket.addSystemMessage(
-              `📎 Attached ${filesAttached.length} file(s): ${filesAttached.join(', ')}`,
-            );
-          }
-          socket.sendMessage(expandedMessage);
-        })
-        .catch((err: unknown) => {
-          socket.addSystemMessage(
-            `File expansion failed: ${err instanceof Error ? err.message : String(err)}`,
-          );
-          // Send original message without expansion
-          socket.sendMessage(content);
-        });
-    },
-    [socket],
-  );
-
   const handleLocalCommand = useCallback(
     (parsed: ParsedCommand) => {
       switch (parsed.command) {
@@ -154,36 +123,9 @@ export function TuiApp({
               socket.addSystemMessage('Failed to create new conversation.');
             });
           break;
-        case 'attach': {
-          if (!parsed.args) {
-            socket.addSystemMessage('Usage: /attach <file-path>');
-            break;
-          }
-          void handleAttachCommand(parsed.args)
-            .then(({ content, error }) => {
-              if (error) {
-                socket.addSystemMessage(`Attach error: ${error}`);
-              } else if (content) {
-                // Send the file content as a user message
-                socket.sendMessage(content);
-              }
-            })
-            .catch((err: unknown) => {
-              socket.addSystemMessage(
-                `Attach failed: ${err instanceof Error ? err.message : String(err)}`,
-              );
-            });
-          break;
-        }
         case 'stop':
-          if (socket.isStreaming && socket.socketRef.current?.connected && socket.conversationId) {
+          // Currently no stop mechanism exposed — show feedback
-            socket.socketRef.current.emit('abort', {
+          socket.addSystemMessage('Stop is not available for the current session.');
-              conversationId: socket.conversationId,
-            });
-            socket.addSystemMessage('Abort signal sent.');
-          } else {
-            socket.addSystemMessage('No active stream to stop.');
-          }
           break;
         case 'cost': {
           const u = socket.tokenUsage;
@@ -406,7 +348,7 @@ export function TuiApp({
           }
           setTuiInput(val);
         }}
-        onSubmit={sendMessageWithFileRefs}
+        onSubmit={socket.sendMessage}
         onSystemMessage={socket.addSystemMessage}
         onLocalCommand={handleLocalCommand}
         onGatewayCommand={handleGatewayCommand}

packages/cli/src/tui/commands/registry.ts

@@ -56,22 +56,6 @@ const LOCAL_COMMANDS: CommandDef[] = [
     available: true,
     scope: 'core',
   },
-  {
-    name: 'attach',
-    description: 'Attach a file to the next message (@file syntax also works inline)',
-    aliases: [],
-    args: [
-      {
-        name: 'path',
-        type: 'string' as const,
-        optional: false,
-        description: 'File path to attach',
-      },
-    ],
-    execution: 'local',
-    available: true,
-    scope: 'core',
-  },
   {
     name: 'new',
     description: 'Start a new conversation',

packages/cli/src/tui/file-ref.ts

@@ -1,202 +0,0 @@
-/**
- * File reference expansion for TUI chat input.
- *
- * Detects @path/to/file patterns in user messages, reads the file contents,
- * and inlines them as fenced code blocks in the message.
- *
- * Supports:
- *   - @relative/path.ts
- *   - @./relative/path.ts
- *   - @/absolute/path.ts
- *   - @~/home-relative/path.ts
- *
- * Also provides an /attach <path> command handler.
- */
-
-import { readFile, stat } from 'node:fs/promises';
-import { resolve, extname, basename } from 'node:path';
-import { homedir } from 'node:os';
-
-const MAX_FILE_SIZE = 256 * 1024; // 256 KB
-const MAX_FILES_PER_MESSAGE = 10;
-
-/**
- * Regex to detect @file references in user input.
- * Matches @<path> where path starts with /, ./, ~/, or a word char,
- * and continues until whitespace or end of string.
- * Excludes @mentions that look like usernames (no dots/slashes).
- */
-const FILE_REF_PATTERN = /(?:^|\s)@((?:\.{0,2}\/|~\/|[a-zA-Z0-9_])[^\s]+)/g;
-
-interface FileRefResult {
-  /** The expanded message text with file contents inlined */
-  expandedMessage: string;
-  /** Files that were successfully read */
-  filesAttached: string[];
-  /** Errors encountered while reading files */
-  errors: string[];
-}
-
-function resolveFilePath(ref: string): string {
-  if (ref.startsWith('~/')) {
-    return resolve(homedir(), ref.slice(2));
-  }
-  return resolve(process.cwd(), ref);
-}
-
-function getLanguageHint(filePath: string): string {
-  const ext = extname(filePath).toLowerCase();
-  const map: Record<string, string> = {
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-    '.js': 'javascript',
-    '.jsx': 'javascript',
-    '.py': 'python',
-    '.rb': 'ruby',
-    '.rs': 'rust',
-    '.go': 'go',
-    '.java': 'java',
-    '.c': 'c',
-    '.cpp': 'cpp',
-    '.h': 'c',
-    '.hpp': 'cpp',
-    '.cs': 'csharp',
-    '.sh': 'bash',
-    '.bash': 'bash',
-    '.zsh': 'zsh',
-    '.fish': 'fish',
-    '.json': 'json',
-    '.yaml': 'yaml',
-    '.yml': 'yaml',
-    '.toml': 'toml',
-    '.xml': 'xml',
-    '.html': 'html',
-    '.css': 'css',
-    '.scss': 'scss',
-    '.md': 'markdown',
-    '.sql': 'sql',
-    '.graphql': 'graphql',
-    '.dockerfile': 'dockerfile',
-    '.tf': 'terraform',
-    '.vue': 'vue',
-    '.svelte': 'svelte',
-  };
-  return map[ext] ?? '';
-}
-
-/**
- * Check if the input contains any @file references.
- */
-export function hasFileRefs(input: string): boolean {
-  FILE_REF_PATTERN.lastIndex = 0;
-  return FILE_REF_PATTERN.test(input);
-}
-
-/**
- * Expand @file references in a message by reading file contents
- * and appending them as fenced code blocks.
- */
-export async function expandFileRefs(input: string): Promise<FileRefResult> {
-  const refs: string[] = [];
-  FILE_REF_PATTERN.lastIndex = 0;
-  let match;
-  while ((match = FILE_REF_PATTERN.exec(input)) !== null) {
-    const ref = match[1]!;
-    if (!refs.includes(ref)) {
-      refs.push(ref);
-    }
-  }
-
-  if (refs.length === 0) {
-    return { expandedMessage: input, filesAttached: [], errors: [] };
-  }
-
-  if (refs.length > MAX_FILES_PER_MESSAGE) {
-    return {
-      expandedMessage: input,
-      filesAttached: [],
-      errors: [`Too many file references (${refs.length}). Maximum is ${MAX_FILES_PER_MESSAGE}.`],
-    };
-  }
-
-  const filesAttached: string[] = [];
-  const errors: string[] = [];
-  const attachments: string[] = [];
-
-  for (const ref of refs) {
-    const filePath = resolveFilePath(ref);
-    try {
-      const info = await stat(filePath);
-      if (!info.isFile()) {
-        errors.push(`@${ref}: not a file`);
-        continue;
-      }
-      if (info.size > MAX_FILE_SIZE) {
-        errors.push(
-          `@${ref}: file too large (${(info.size / 1024).toFixed(0)} KB, limit ${MAX_FILE_SIZE / 1024} KB)`,
-        );
-        continue;
-      }
-      const content = await readFile(filePath, 'utf8');
-      const lang = getLanguageHint(filePath);
-      const name = basename(filePath);
-      attachments.push(`\n📎 ${ref} (${name}):\n\`\`\`${lang}\n${content}\n\`\`\``);
-      filesAttached.push(ref);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      // Only report meaningful errors — ENOENT is common for false @mention matches
-      if (msg.includes('ENOENT')) {
-        // Check if this looks like a file path (has extension or slash)
-        if (ref.includes('/') || ref.includes('.')) {
-          errors.push(`@${ref}: file not found`);
-        }
-        // Otherwise silently skip — likely an @mention, not a file ref
-      } else {
-        errors.push(`@${ref}: ${msg}`);
-      }
-    }
-  }
-
-  if (attachments.length === 0) {
-    return { expandedMessage: input, filesAttached, errors };
-  }
-
-  const expandedMessage = input + '\n' + attachments.join('\n');
-  return { expandedMessage, filesAttached, errors };
-}
-
-/**
- * Handle the /attach <path> command.
- * Reads a file and returns the content formatted for inclusion in the chat.
- */
-export async function handleAttachCommand(
-  args: string,
-): Promise<{ content: string; error?: string }> {
-  const filePath = args.trim();
-  if (!filePath) {
-    return { content: '', error: 'Usage: /attach <file-path>' };
-  }
-
-  const resolved = resolveFilePath(filePath);
-  try {
-    const info = await stat(resolved);
-    if (!info.isFile()) {
-      return { content: '', error: `Not a file: ${filePath}` };
-    }
-    if (info.size > MAX_FILE_SIZE) {
-      return {
-        content: '',
-        error: `File too large (${(info.size / 1024).toFixed(0)} KB, limit ${MAX_FILE_SIZE / 1024} KB)`,
-      };
-    }
-    const content = await readFile(resolved, 'utf8');
-    const lang = getLanguageHint(resolved);
-    const name = basename(resolved);
-    return {
-      content: `📎 Attached file: ${name} (${filePath})\n\`\`\`${lang}\n${content}\n\`\`\``,
-    };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { content: '', error: `Failed to read file: ${msg}` };
-  }
-}

packages/cli/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["node_modules", "dist", "src/**/*.test.ts", "src/**/*.spec.ts"]
-}

packages/config/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "@mosaic/config",
-  "version": "0.0.1",
-  "type": "module",
-  "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"
-  },
-  "dependencies": {
-    "@mosaic/memory": "workspace:^",
-    "@mosaic/queue": "workspace:^",
-    "@mosaic/storage": "workspace:^"
-  },
-  "devDependencies": {
-    "typescript": "^5.8.0",
-    "vitest": "^2.0.0"
-  },
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
-}

packages/config/src/index.ts

@@ -1,7 +0,0 @@
-export type { MosaicConfig, StorageTier, MemoryConfigRef } from './mosaic-config.js';
-export {
-  DEFAULT_LOCAL_CONFIG,
-  DEFAULT_TEAM_CONFIG,
-  loadConfig,
-  validateConfig,
-} from './mosaic-config.js';

packages/config/src/mosaic-config.ts

@@ -1,140 +0,0 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type { StorageConfig } from '@mosaic/storage';
-import type { QueueAdapterConfig as QueueConfig } from '@mosaic/queue';
-
-/* ------------------------------------------------------------------ */
-/*  Types                                                              */
-/* ------------------------------------------------------------------ */
-
-export type StorageTier = 'local' | 'team';
-
-export interface MemoryConfigRef {
-  type: 'pgvector' | 'sqlite-vec' | 'keyword';
-}
-
-export interface MosaicConfig {
-  tier: StorageTier;
-  storage: StorageConfig;
-  queue: QueueConfig;
-  memory: MemoryConfigRef;
-}
-
-/* ------------------------------------------------------------------ */
-/*  Defaults                                                           */
-/* ------------------------------------------------------------------ */
-
-export const DEFAULT_LOCAL_CONFIG: MosaicConfig = {
-  tier: 'local',
-  storage: { type: 'sqlite', path: '.mosaic/data.db' },
-  queue: { type: 'local', dataDir: '.mosaic/queue' },
-  memory: { type: 'keyword' },
-};
-
-export const DEFAULT_TEAM_CONFIG: MosaicConfig = {
-  tier: 'team',
-  storage: { type: 'postgres', url: 'postgresql://mosaic:mosaic@localhost:5432/mosaic' },
-  queue: { type: 'bullmq' },
-  memory: { type: 'pgvector' },
-};
-
-/* ------------------------------------------------------------------ */
-/*  Validation                                                         */
-/* ------------------------------------------------------------------ */
-
-const VALID_TIERS = new Set<string>(['local', 'team']);
-const VALID_STORAGE_TYPES = new Set<string>(['postgres', 'sqlite', 'files']);
-const VALID_QUEUE_TYPES = new Set<string>(['bullmq', 'local']);
-const VALID_MEMORY_TYPES = new Set<string>(['pgvector', 'sqlite-vec', 'keyword']);
-
-export function validateConfig(raw: unknown): MosaicConfig {
-  if (typeof raw !== 'object' || raw === null) {
-    throw new Error('MosaicConfig must be a non-null object');
-  }
-
-  const obj = raw as Record<string, unknown>;
-
-  // tier
-  const tier = obj['tier'];
-  if (typeof tier !== 'string' || !VALID_TIERS.has(tier)) {
-    throw new Error(`Invalid tier "${String(tier)}" — expected "local" or "team"`);
-  }
-
-  // storage
-  const storage = obj['storage'];
-  if (typeof storage !== 'object' || storage === null) {
-    throw new Error('config.storage must be a non-null object');
-  }
-  const storageType = (storage as Record<string, unknown>)['type'];
-  if (typeof storageType !== 'string' || !VALID_STORAGE_TYPES.has(storageType)) {
-    throw new Error(`Invalid storage.type "${String(storageType)}"`);
-  }
-
-  // queue
-  const queue = obj['queue'];
-  if (typeof queue !== 'object' || queue === null) {
-    throw new Error('config.queue must be a non-null object');
-  }
-  const queueType = (queue as Record<string, unknown>)['type'];
-  if (typeof queueType !== 'string' || !VALID_QUEUE_TYPES.has(queueType)) {
-    throw new Error(`Invalid queue.type "${String(queueType)}"`);
-  }
-
-  // memory
-  const memory = obj['memory'];
-  if (typeof memory !== 'object' || memory === null) {
-    throw new Error('config.memory must be a non-null object');
-  }
-  const memoryType = (memory as Record<string, unknown>)['type'];
-  if (typeof memoryType !== 'string' || !VALID_MEMORY_TYPES.has(memoryType)) {
-    throw new Error(`Invalid memory.type "${String(memoryType)}"`);
-  }
-
-  return {
-    tier: tier as StorageTier,
-    storage: storage as StorageConfig,
-    queue: queue as QueueConfig,
-    memory: memory as MemoryConfigRef,
-  };
-}
-
-/* ------------------------------------------------------------------ */
-/*  Loader                                                             */
-/* ------------------------------------------------------------------ */
-
-function detectFromEnv(): MosaicConfig {
-  if (process.env['DATABASE_URL']) {
-    return {
-      ...DEFAULT_TEAM_CONFIG,
-      storage: {
-        type: 'postgres',
-        url: process.env['DATABASE_URL'],
-      },
-      queue: {
-        type: 'bullmq',
-        url: process.env['VALKEY_URL'],
-      },
-    };
-  }
-  return DEFAULT_LOCAL_CONFIG;
-}
-
-export function loadConfig(configPath?: string): MosaicConfig {
-  // 1. Explicit path or default location
-  const paths = configPath
-    ? [resolve(configPath)]
-    : [
-        resolve(process.cwd(), 'mosaic.config.json'),
-        resolve(process.cwd(), '../../mosaic.config.json'), // monorepo root when cwd is apps/gateway
-      ];
-
-  for (const p of paths) {
-    if (existsSync(p)) {
-      const raw: unknown = JSON.parse(readFileSync(p, 'utf-8'));
-      return validateConfig(raw);
-    }
-  }
-
-  // 2. Fall back to env-var detection
-  return detectFromEnv();
-}

packages/config/tsconfig.json

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

packages/coord/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/coord",
-  "version": "0.0.2",
+  "version": "0.0.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -22,12 +22,5 @@
     "@types/node": "^22.0.0",
     "typescript": "^5.8.0",
     "vitest": "^2.0.0"
-  },
+  }
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
 }

packages/db/drizzle/0001_cynical_ultimatum.sql

@@ -1,4 +1,3 @@
-CREATE EXTENSION IF NOT EXISTS vector;--> statement-breakpoint
 CREATE TABLE "agent_logs" (
 	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
 	"session_id" text NOT NULL,

packages/db/drizzle/0006_swift_shen.sql

@@ -1 +0,0 @@
-ALTER TABLE "conversations" ADD COLUMN "session_id" text;

packages/db/drizzle/meta/_journal.json

@@ -12,51 +12,37 @@
     {
       "idx": 1,
       "version": "7",
-      "when": 1773602195608,
-      "tag": "0001_cynical_ultimatum",
-      "breakpoints": true
-    },
-    {
-      "idx": 2,
-      "version": "7",
       "when": 1773602195609,
       "tag": "0001_magical_rattler",
       "breakpoints": true
     },
     {
-      "idx": 3,
+      "idx": 2,
       "version": "7",
       "when": 1773625181629,
       "tag": "0002_nebulous_mimic",
       "breakpoints": true
     },
     {
-      "idx": 4,
+      "idx": 3,
       "version": "7",
       "when": 1773887085247,
       "tag": "0003_p8003_perf_indexes",
       "breakpoints": true
     },
     {
-      "idx": 5,
+      "idx": 4,
       "version": "7",
       "when": 1774224004898,
       "tag": "0004_bumpy_miracleman",
       "breakpoints": true
     },
     {
-      "idx": 6,
+      "idx": 5,
       "version": "7",
       "when": 1774225763410,
       "tag": "0005_minor_champions",
       "breakpoints": true
-    },
-    {
-      "idx": 7,
-      "version": "7",
-      "when": 1774227064500,
-      "tag": "0006_swift_shen",
-      "breakpoints": true
     }
   ]
 }

packages/db/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/db",
-  "version": "0.0.2",
+  "version": "0.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,12 +30,5 @@
   "dependencies": {
     "drizzle-orm": "^0.45.1",
     "postgres": "^3.4.8"
-  },
+  }
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
 }

packages/db/src/schema.ts

@@ -319,8 +319,6 @@ export const conversations = pgTable(
       .references(() => users.id, { onDelete: 'cascade' }),
     projectId: uuid('project_id').references(() => projects.id, { onDelete: 'set null' }),
     agentId: uuid('agent_id').references(() => agents.id, { onDelete: 'set null' }),
-    /** M5-004: Agent session ID bound to this conversation. Nullable — set when a session is created. */
-    sessionId: text('session_id'),
     archived: boolean('archived').notNull().default(false),
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),

packages/design-tokens/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaic/design-tokens",
-  "version": "0.0.2",
+  "version": "0.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,12 +19,5 @@
   "devDependencies": {
     "typescript": "^5.8.0",
     "vitest": "^2.0.0"
-  },
+  }
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
 }

packages/forge/PLAN.md

@@ -1,541 +0,0 @@
-# Specialist Pipeline — Progressive Refinement Architecture
-
-**Status:** DRAFT v4 — post architecture review
-**Created:** 2026-03-24
-**Last Updated:** 2026-03-24 20:40 CDT
-
----
-
-## Vision
-
-Replace "throw it at a Codex worker and hope" with a **railed pipeline** where each stage narrows scope, increases precision, and catches mistakes before they compound. Spend more time up-front declaring requirements; spend less time at the end fixing broken output.
-
-**Core principles:**
-
-- One agent, one specialty. No generalists pretending to be experts.
-- Agents must be willing to **argue, debate, and push back** — not eagerly agree and move on.
-- The pipeline is a set of **customizable rails** — agents stay on track, don't get sidetracked or derailed.
-- Dynamic composition — only relevant specialists are called in per task.
-- Hard gates between stages — mechanical checks + agent oversight for final decision.
-- Minimal human oversight once the PRD is declared.
-
----
-
-## The Pipeline
-
-```
-PRD.md (human declares requirements)
-    │
-    ▼
-BRIEFS (PRD decomposed into discrete work units)
-    │
-    ▼
-BOARD OF DIRECTORS (strategic go/no-go per brief)
-    │  Static composition. CEO, CTO, CFO, COO.
-    │  Output: Approved brief with business constraints, priority, budget
-    │  Board does NOT select technical participants — that's the Brief Analyzer's job
-    │  Gate: Board consensus required to proceed
-    │  REJECTED → archive + notify human. NEEDS REVISION → back to Intake.
-    │
-    │  POST-RUN REVIEW: Board reviews memos from completed pipeline
-    │  runs. Analyzes for conflicts, adjusts strategy, feeds learnings
-    │  back into future briefs. The Board is not fire-and-forget.
-    │
-    ▼
-BRIEF ANALYZER (technical composition)
-    │  Sonnet agent analyzes approved brief + project context
-    │  Selects which generalists/specialists participate in each planning stage
-    │  Separates strategic decisions (Board) from technical composition
-    │
-    ▼
-PLANNING 1 — Architecture (Domain Generalists)
-    │  Dynamic composition based on brief requirements.
-    │  Software Architect + relevant generalists only.
-    │  Output: Architecture Decision Record (ADR)
-    │  Agents MUST debate trade-offs. No rubber-stamping.
-    │  Gate: ADR approved, all dissents resolved or recorded
-    │
-    ▼
-PLANNING 2 — Implementation Design (Language/Domain Specialists)
-    │  Dynamic composition — only languages/domains in the ADR.
-    │  Output: Implementation spec per component
-    │  Each specialist argues for their domain's best practices.
-    │  Gate: All specs reviewed by Architecture, no conflicts
-    │
-    ▼
-PLANNING 3 — Task Decomposition & Estimation
-    │  Context Manager + Task Distributor
-    │  Output: Task breakdown with dependency graph, estimates,
-    │          context packets per worker, acceptance criteria
-    │  Gate: Every task has one owner, one completion condition,
-    │         estimated rounds, and explicit test criteria
-    │
-    ▼
-CODING (Workers execute)
-    │  Codex/Claude workers with specialist subagents loaded
-    │  Each worker gets: context packet + implementation spec + acceptance criteria
-    │  Workers stay in their lane — the rails prevent drift
-    │  Gate: Code compiles, lints, passes unit tests
-    │
-    ▼
-REVIEW (Specialist review)
-    │  Code reviewer (evidence-driven, severity-ranked)
-    │  Security auditor (attack paths, secrets, auth)
-    │  Language specialist for the relevant language
-    │  Gate: All findings addressed or explicitly accepted with rationale
-    │
-    ▼
-REMEDIATE (if review finds issues)
-    │  Worker fixes based on review findings
-    │  Loops back to REVIEW
-    │  Gate: Same as REVIEW — clean pass required
-    │
-    ▼
-TEST (Integration + acceptance)
-    │  QA Strategist validates against acceptance criteria from Planning 3
-    │  Gate: All acceptance criteria pass, no regressions
-    │
-    ▼
-DEPLOY
-       Infrastructure Lead handles deployment
-       Gate: Smoke tests pass in target environment
-```
-
----
-
-## Orchestration — Who Watches the Pipeline?
-
-### The Orchestrator (Mosaic's role)
-
-**Not me (Jarvis). Not any single agent. The Orchestrator is a dedicated, mechanical process with AI oversight.**
-
-The Orchestrator is:
-
-- **Primarily mechanical** — moves work through stages, enforces gates, tracks state
-- **AI-assisted at decision points** — an agent reviews gate results and makes go/no-go calls
-- **The thing Mosaic Stack productizes** — this IS the engine from the North Star vision
-
-How it works:
-
-1. **Stage Runner** (mechanical): Advances work through the pipeline. Checks gate conditions. Purely deterministic — "did all gate criteria pass? yes → advance. no → hold."
-2. **Gate Reviewer** (AI agent): When a gate's mechanical checks pass, the Gate Reviewer does a final sanity check. "The code lints and tests pass, but does this actually solve the problem?" This is the lightweight oversight layer.
-3. **Escalation** (to human): If the Gate Reviewer is uncertain, or if debate in a planning stage is unresolved after N rounds, escalate to Jason.
-
-### What Sends a Plan Back for More Debate?
-
-Triggers for **rework/rejection**:
-
-- **Gate failure** — mechanical checks don't pass → automatic rework
-- **Gate Reviewer dissent** — AI reviewer flags a concern → sent back with specific objection
-- **Unresolved debate** — planning agents can't reach consensus after N rounds → escalate or send back with the dissenting positions documented
-- **Scope creep detection** — if a stage's output significantly exceeds the brief's scope → flag and return
-- **Dependency conflict** — Planning 3 finds the task breakdown has circular deps or impossible ordering → return to Planning 2
-- **Review severity threshold** — if Review finds CRITICAL-severity issues → auto-reject back to Coding, no discussion
-
-### Human Touchpoints (minimal by design)
-
-- **PRD.md** — Human writes this. This is where you spend the time.
-- **Board escalation** — Only if the Board can't reach consensus on a brief.
-- **Planning escalation** — Only if debate is unresolved after max rounds.
-- **Deploy approval** — Optional. Could be fully automated for low-risk deploys.
-
-Everything else runs autonomously on rails.
-
----
-
-## Gate System
-
-Every gate has **mechanical checks** (automated, deterministic) and an **agent review** (final judgment call).
-
-| Stage →                                | Mechanical Checks                                                 | Agent Review                                                                  |
-| -------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------------- |
-| **Board → Planning 1**                 | Brief exists, has success criteria, has budget                    | Gate Reviewer: "Is this brief well-scoped enough to architect?"               |
-| **Planning 1 → Planning 2**            | ADR exists, covers all components in brief                        | Gate Reviewer: "Does this architecture actually solve the problem?"           |
-| **Planning 2 → Planning 3**            | Implementation spec per component, no unresolved conflicts        | Gate Reviewer: "Are the specs consistent with each other and the ADR?"        |
-| **Planning 3 → Coding**                | Task breakdown exists, all tasks have owner + criteria + estimate | Gate Reviewer: "Is this actually implementable as decomposed?"                |
-| **Coding → Review**                    | Compiles, lints, unit tests pass                                  | Gate Reviewer: "Does the code match the implementation spec?"                 |
-| **Review → Test** (or **→ Remediate**) | All review findings addressed                                     | Gate Reviewer: "Are the fixes real or did the worker just suppress warnings?" |
-| **Test → Deploy**                      | All acceptance criteria pass, no regressions                      | Gate Reviewer: "Ready for production?"                                        |
-
----
-
-## Dynamic Composition
-
-### Board of Directors — STATIC
-
-Always the same participants. These are strategic, not technical.
-
-| Role | Model  | Personality                                                                                                                 |
-| ---- | ------ | --------------------------------------------------------------------------------------------------------------------------- |
-| CEO  | Opus   | Visionary, asks "does this serve the mission?"                                                                              |
-| CTO  | Opus   | Technical realist, asks "can we actually build this?"                                                                       |
-| CFO  | Sonnet | Cost-conscious, asks "what does this cost vs return?" — needs real analytical depth for budget/ROI, not a lightweight model |
-| COO  | Sonnet | Operational, asks "what's the timeline and resource impact?"                                                                |
-
-### Planning Stages — DYNAMIC
-
-**The Orchestrator selects participants based on the brief's requirements.** Not every specialist is needed for every task.
-
-Selection logic:
-
-1. Parse the brief/ADR for **languages mentioned** → include those Language Specialists
-2. Parse for **infrastructure concerns** → include Infra Lead, Docker/Swarm, CI/CD as needed
-3. Parse for **data concerns** → include Data Architect, SQL Pro
-4. Parse for **UI concerns** → include UX Strategist, Web Design, React/RN Specialist
-5. Parse for **security concerns** → include Security Architect
-6. **Always include:** Software Architect (Planning 1), QA Strategist (Planning 3)
-
-Example: A TypeScript NestJS API endpoint with Prisma:
-
-- Planning 1: Software Architect, Security Architect, Data Architect
-- Planning 2: TypeScript Pro, NestJS Expert, SQL Pro
-- Planning 3: Task Distributor, Context Manager
-
-Example: A React dashboard with no backend changes:
-
-- Planning 1: Software Architect, UX Strategist
-- Planning 2: React Specialist, Web Design, UX/UI Design
-- Planning 3: Task Distributor, Context Manager
-
-**Go Pro doesn't sit in on a TypeScript project. Solidity Pro doesn't weigh in on a dashboard.**
-
----
-
-## Debate Culture
-
-Agents in planning stages are **required** to:
-
-1. **State their position with reasoning** — no "sounds good to me"
-2. **Challenge other positions** — "I disagree because..."
-3. **Identify risks the others haven't raised** — adversarial by design
-4. **Formally dissent if not convinced** — dissents are recorded in the ADR/spec
-5. **Not capitulate just to move forward** — the Orchestrator tracks rounds and will call time, but agents shouldn't fold under social pressure
-
-**Round limits:** Min 3, Max 30. The discussion must be allowed to properly work. Don't cut debate short — premature consensus produces bad architecture. The Orchestrator tracks rounds and will intervene only when debate is genuinely circular (repeating the same arguments) rather than still productive.
-
-This is enforced via personality in the agent definitions:
-
-- Architects are opinionated and will argue for clean boundaries
-- Security Architect is paranoid by design — always looking for what can go wrong
-- QA Strategist is skeptical — "prove it works, don't tell me it works"
-- Language specialists are purists about their domain's best practices
-
-**The goal:** By the time code is written, the hard decisions are already made and debated. The workers just execute a well-argued plan.
-
----
-
-## Model Assignments
-
-| Pipeline Stage              | Model                             | Rationale                                           |
-| --------------------------- | --------------------------------- | --------------------------------------------------- |
-| Board of Directors          | Opus (CEO/CTO) / Sonnet (CFO/COO) | Strategic deliberation needs depth across the board |
-| Planning 1 (Architecture)   | Opus                              | Complex trade-offs, needs deep reasoning            |
-| Planning 2 (Implementation) | Sonnet                            | Domain expertise, detailed specs                    |
-| Planning 3 (Decomposition)  | Sonnet                            | Structured output, dependency analysis              |
-| Coding                      | Codex                             | Primary workhorse, separate budget                  |
-| Review                      | Sonnet (code) + Opus (security)   | Code review = Sonnet, security = Opus for depth     |
-| Remediation                 | Codex                             | Same worker, fix the issues                         |
-| Test                        | Haiku                             | Mechanical validation, low complexity               |
-| Deploy                      | Haiku                             | Scripted deployment, mechanical                     |
-| Gate Reviewer               | Sonnet                            | Judgment calls, moderate complexity                 |
-| Orchestrator (mechanical)   | None — deterministic code         | State machine, not AI                               |
-
----
-
-## Roster
-
-### Board of Directors (static)
-
-| Role | Scope                                     |
-| ---- | ----------------------------------------- |
-| CEO  | Vision, priorities, go/no-go              |
-| CTO  | Technical direction, risk tolerance       |
-| CFO  | Budget, cost/benefit                      |
-| COO  | Operations, timeline, resource allocation |
-
-### Domain Generalists (dynamic — called per brief)
-
-| Role                    | Scope                                                         | Selected When                                                              |
-| ----------------------- | ------------------------------------------------------------- | -------------------------------------------------------------------------- |
-| **Software Architect**  | System design, component boundaries, data flow, API contracts | Always in Planning 1                                                       |
-| **Security Architect**  | Threat modeling, auth patterns, secrets, OWASP                | **Always** — security is cross-cutting; implicit requirements are the norm |
-| **Infrastructure Lead** | Deployment, networking, monitoring, scaling, DR               | Brief involves deploy, infra, scaling                                      |
-| **Data Architect**      | Schema design, migrations, query strategy, caching            | Brief involves DB, data models, migrations                                 |
-| **QA Strategist**       | Test strategy, coverage, integration test design              | Always in Planning 3                                                       |
-| **UX Strategist**       | User flows, information architecture, accessibility           | Brief involves UI/frontend                                                 |
-
-### Language Specialists (dynamic — one language, one agent)
-
-| Specialist           | Selected When                              |
-| -------------------- | ------------------------------------------ |
-| **TypeScript Pro**   | Project uses TypeScript                    |
-| **JavaScript Pro**   | Project uses vanilla JS / Node.js          |
-| **Go Pro**           | Project uses Go                            |
-| **Rust Pro**         | Project uses Rust                          |
-| **Solidity Pro**     | Project involves smart contracts           |
-| **Python Pro**       | Project uses Python                        |
-| **SQL Pro**          | Project involves database queries / Prisma |
-| **LangChain/AI Pro** | Project involves AI/ML/agent frameworks    |
-
-### Domain Specialists (dynamic — cross-cutting expertise)
-
-| Specialist           | Selected When                        |
-| -------------------- | ------------------------------------ |
-| **Web Design**       | Frontend work involving HTML/CSS     |
-| **UX/UI Design**     | Component design, design system work |
-| **React Specialist** | Frontend uses React                  |
-| **React Native Pro** | Mobile app work                      |
-| **Blockchain/DeFi**  | Chain interactions, DeFi protocols   |
-| **Docker/Swarm**     | Containerization, deployment         |
-| **CI/CD**            | Pipeline changes, deploy automation  |
-| **NestJS Expert**    | Backend uses NestJS                  |
-
----
-
-## Source Material — What to Pull From External Repos
-
-### From VoltAgent/awesome-codex-subagents (`.toml` format)
-
-| File                                               | What We Take                                                | What We Customize                                            |
-| -------------------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------ |
-| `09-meta-orchestration/context-manager.toml`       | Context packaging for workers                               | Add our monorepo structure, Gitea CI, project conventions    |
-| `09-meta-orchestration/task-distributor.toml`      | Dependency graphs, write-scope separation, output contracts | Add worktree rules, PR workflow, completion gates            |
-| `09-meta-orchestration/workflow-orchestrator.toml` | Stage design with explicit wait points and gates            | Wire to our pipeline stages                                  |
-| `09-meta-orchestration/agent-organizer.toml`       | Task decomposition by objective (not file list)             | Add our agent registry, model hierarchy rules                |
-| `04-quality-security/reviewer.toml`                | Evidence-driven review, severity ranking                    | Add NestJS import rules, Prisma gotchas, our recurring bugs  |
-| `04-quality-security/security-auditor.toml`        | Attack path mapping, secrets handling review                | Add our Docker Swarm patterns, credential loader conventions |
-
-### From VoltAgent/awesome-openclaw-skills (ClawHub)
-
-| Skill                      | What We Take                                          | How We Use It                                            |
-| -------------------------- | ----------------------------------------------------- | -------------------------------------------------------- |
-| `brainstorming-2`          | Socratic pre-coding design workflow                   | Planning 1 — requirements refinement before architecture |
-| `agent-estimation`         | Task effort in tool-call rounds                       | Planning 3 — scope tasks before spawning workers         |
-| `agent-nestjs-skills`      | 40 prioritized NestJS rules with code examples        | NestJS specialist + backend workers                      |
-| `agent-team-orchestration` | Structured handoff protocols, task state transitions  | Reference for pipeline stage handoffs                    |
-| `b3ehive`                  | Competitive implementation (3 agents, cross-evaluate) | Critical components: crypto strategies, auth flows       |
-| `agent-council`            | Agent scaffolding automation                          | Automate specialist creation as we expand                |
-| `astrai-code-review`       | Model routing by diff complexity                      | Review stage cost optimization                           |
-| `bug-audit`                | 6-phase Node.js audit methodology                     | Periodic codebase health checks                          |
-
-### From VoltAgent/awesome-claude-code-subagents (`.md` format)
-
-| File                                       | What We Take                                    | Notes                                                  |
-| ------------------------------------------ | ----------------------------------------------- | ------------------------------------------------------ |
-| Language specialist `.md` files            | System prompts for TS, Go, Rust, Solidity, etc. | Strip generic stuff, inject project-specific knowledge |
-| `09-meta-orchestration/agent-organizer.md` | Detailed organizer pattern                      | Reference — Codex `.toml` is tighter                   |
-
----
-
-## Gaps This Fills
-
-| Gap                             | Current State                           | After Pipeline                                                    |
-| ------------------------------- | --------------------------------------- | ----------------------------------------------------------------- |
-| No pre-coding design            | Brief → Codex starts coding immediately | 3 planning stages before anyone writes code                       |
-| Agents get sidetracked/derailed | No rails, workers drift from task       | Mechanical pipeline + context packets keep workers on track       |
-| No debate on approach           | First idea wins                         | Agents required to argue, dissent, challenge                      |
-| No task estimation              | Eyeball everything                      | Tool-call-round estimation in Planning 3                          |
-| Code review is a checkbox       | "Did it lint? Ship it."                 | Evidence-driven reviewer + specialist knowledge                   |
-| Security review is hand-waved   | Never actually done                     | Real attack path mapping, secrets review                          |
-| Workers get bad context         | Ad-hoc prompts, stale assumptions       | Context-manager produces execution-ready packets                  |
-| Task decomposition is sloppy    | "Here's a task, go do it"               | Dependency graphs, write-scope separation, output contracts       |
-| Wrong specialists involved      | Everyone weighs in on everything        | Dynamic composition — only relevant experts                       |
-| No rework mechanism             | Ship it or start over                   | Explicit remediation loop with review re-check                    |
-| Too much human oversight        | Jason babysits every stage              | Mechanical gates + AI oversight, human only at PRD and escalation |
-
----
-
-## Implementation Plan
-
-### Phase 1 — Foundation (this week)
-
-1. Pull and customize Codex subagents: `reviewer.toml`, `security-auditor.toml`, `context-manager.toml`, `task-distributor.toml`, `workflow-orchestrator.toml`
-2. Inject our project-specific knowledge
-3. Install to `~/.codex/agents/`
-4. Define agent personality templates for debate culture (opinionated, adversarial, skeptical)
-
-### Phase 2 — Specialist Definitions (next week)
-
-1. Create language specialist definitions (TS, JS, Go, Rust, Solidity, Python, SQL, LangChain, C++)
-2. Create domain specialist definitions (NestJS, React, Docker/Swarm, CI/CD, Web Design, UX/UI, Blockchain/DeFi, React Native)
-3. Create generalist definitions (Software Architect, Security Architect, Infra Lead, Data Architect, QA Strategist, UX Strategist)
-4. Format as Codex `.toml` + OpenClaw skills
-5. Test each against a real past task
-
-### Phase 3 — Pipeline Wiring (week after)
-
-1. Build the Orchestrator (mechanical stage runner + gate checker)
-2. Build the Gate Reviewer agent
-3. Wire dynamic composition (brief → participant selection)
-4. Wire the debate protocol (round tracking, dissent recording, escalation rules)
-5. Wire Planning 1 → 2 → 3 handoff contracts
-6. Wire Review → Remediate → Review loop
-7. Test end-to-end with a real feature request
-
-### Phase 4 — Mosaic Integration (future)
-
-1. The Orchestrator becomes a Mosaic Stack feature
-2. Pipeline stages map to Mosaic task states
-3. Gate results feed the Mission Control dashboard
-4. This IS the engine — the dashboard is just the window
-
-### Phase 5 — Advanced Patterns (future)
-
-1. `b3ehive` competitive implementation for critical paths
-2. `astrai-code-review` model routing for cost optimization
-3. `agent-council` automated scaffolding for new specialists
-4. Estimation feedback loop (compare estimates to actuals)
-5. Pipeline analytics (which stages catch the most issues, where do we bottleneck)
-
----
-
-## Resolved Decisions
-
-| #   | Question                | Decision                                          | Rationale                                                                                                                                                                           |
-| --- | ----------------------- | ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 1   | **Gate Reviewer model** | Sonnet for all gates                              | Sufficient depth for judgment calls; Opus reserved for planning deliberation                                                                                                        |
-| 2   | **Debate rounds**       | Min 3, Max 30 per stage                           | Let discussions work. Don't cut short. Intervene on circular repetition, not round count.                                                                                           |
-| 3   | **PRD format**          | Use existing Mosaic PRD template                  | `~/.config/mosaic/templates/docs/PRD.md.template` + `~/.config/mosaic/skills-local/prd/SKILL.md` already proven. Iterate from there.                                                |
-| 4   | **Small tasks**         | Pipeline is for projects/features, not typo fixes | This is for getting a project or feature built smoothly. Single-file fixes go direct to a worker. Threshold: if it needs architecture decisions, it goes through the pipeline.      |
-| 5   | **Specialist memory**   | Yes — specialists accumulate knowledge with rails | Similar to OpenClaw memory model. Specialists learn from past tasks ("last time X caused Y") but must maintain their specialty rails. Knowledge is domain-scoped, not freeform.     |
-| 6   | **Cost ceiling**        | ~$500 per pipeline run (11+ stages)               | Using subs (Anthropic, OpenAI), so API costs are minimized or eliminated. Budget is time/throughput, not dollars.                                                                   |
-| 7   | **Where this lives**    | Standalone service, Pi under the hood             | Must be standalone so it can migrate to Mosaic Stack in the future. Pi (mosaic bootstrap) provides the execution substrate. Already using Pi for BOD. Dogfood → prove → productize. |
-
-## PRD Template
-
-The pipeline uses the existing Mosaic PRD infrastructure:
-
-- **Template:** `~/.config/mosaic/templates/docs/PRD.md.template`
-- **Skill:** `~/.config/mosaic/skills-local/prd/SKILL.md` (guided PRD generation with clarifying questions)
-- **Guide:** `~/.config/mosaic/guides/PRD.md` (hard rules — PRD must exist before coding begins)
-
-### Required PRD Sections (from Mosaic guide)
-
-1. Problem statement and objective
-2. In-scope and out-of-scope
-3. User/stakeholder requirements
-4. Functional requirements
-5. Non-functional requirements (security, performance, reliability, observability)
-6. Acceptance criteria
-7. Constraints and dependencies
-8. Risks and open questions
-9. Testing and verification expectations
-10. Delivery/milestone intent
-
-The PRD skill also generates user stories with specific acceptance criteria ("Button shows confirmation dialog before deleting" not "Works correctly").
-
-**Key rule from Mosaic:** Implementation that diverges from PRD without PRD updates is a blocker. Change control: update PRD first → update plan → then implement.
-
-## Board Post-Run Review
-
-The Board of Directors is NOT fire-and-forget. After a pipeline run completes (deploy or failure):
-
-1. **Memos from each stage** are compiled into a run summary
-2. **Board reviews** the summary for:
-   - Conflicts between stage outputs
-   - Scope drift from original brief
-   - Cost/timeline variance from estimates
-   - Strategic alignment issues
-3. **Board adjusts** strategy, priorities, or constraints for future briefs
-4. **Learnings** feed back into specialist memory and Orchestrator heuristics
-
-This closes the loop. The pipeline doesn't just ship code — it learns from every run.
-
-## Architecture Review Fixes (v4, 2026-03-24)
-
-Fixes applied based on Sonnet architecture review:
-
-| Finding                                                                  | Fix Applied                                                                                                              |
-| ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
-| Dead-end states (REJECTED, NEEDS REVISION, CI failure, worker confusion) | All paths explicitly defined in orchestrator + Board stage                                                               |
-| Security Architect conditional (keyword matching misses implicit auth)   | Security Architect now ALWAYS included in Planning 1                                                                     |
-| Board making technical composition decisions                             | New Brief Analyzer agent handles technical composition after Board approval                                              |
-| Orchestrator claimed "purely mechanical" but needs semantic analysis     | Split into State Machine (mechanical) + Gate Reviewer (AI). Circularity detection is Gate Reviewer's job.                |
-| Test→Remediate had no loop limit                                         | Shared 3-loop budget across Review + Test remediation                                                                    |
-| Open-ended debate (3-30 rounds) too loose, framing bias                  | Structured 3-phase debate: Independent positions → Responses → Synthesis. Tighter round limits (17-53 calls vs 12-120+). |
-| Review only gets diff                                                    | Review now gets full module context + context packet, not just diff                                                      |
-| Cross-brief dependency not enforced at runtime                           | State Machine enforces dependency ordering + file-level locking                                                          |
-| Gate Reviewer reading full transcripts (context problem)                 | Gate Reviewer reads structured summaries, requests full transcript only on suspicion                                     |
-| No minimum specialist composition for Planning 2                         | Guard added: at least 1 Language + 1 Domain specialist required                                                          |
-
-## Remaining Open Questions
-
-1. **Pi integration specifics:** How exactly does Pi serve as the execution substrate? Board sessions already work via `mosaic yolo pi`. Does the full pipeline run as a Pi orchestration, or does Pi just handle individual stage sessions?
-2. **Specialist memory storage:** OpenBrain? Per-specialist markdown files? Scoped memory namespaces?
-3. **Pipeline analytics:** What metrics do we track per run? Stage duration, rework count, gate failure rate, estimate accuracy?
-4. **Parallel briefs:** Can multiple briefs from the same PRD run through the pipeline concurrently? Or strictly serial?
-5. **Escalation UX:** When the pipeline escalates to Jason, where does that notification go? Discord? TUI? Both?
-
----
-
-## Connection to Mosaic North Star
-
-This pipeline IS the Mosaic vision, just running on agent infrastructure instead of a proper platform:
-
-- **PRD.md** → Mosaic's task queue API
-- **Orchestrator** → Mosaic's agent lifecycle management
-- **Gates** → Mosaic's review gates
-- **Pipeline stages** → Mosaic's workflow engine
-- **Dynamic composition** → Mosaic's agent selection
-
-Everything we build here gets dogfooded, refined, and eventually productized as Mosaic Stack features. We're building the engine that Mosaic will sell.
-
-### Standalone Architecture (decided)
-
-The pipeline is built as a **standalone service** — not embedded in OpenClaw or tightly coupled to any single agent framework. This is deliberate:
-
-1. **Pi (mosaic bootstrap) is the execution substrate** — already proven with BOD sessions
-2. **The Orchestrator is a mechanical state machine** — it doesn't need an LLM, it needs a process manager
-3. **Stage sessions are Pi/agent sessions** — each planning/review stage spawns a session with the right participants
-4. **Migration path to Mosaic Stack is clean** — standalone service → Mosaic feature, not "rip out of OpenClaw"
-
-The pattern: dogfood on our projects → track what works → extract into Mosaic Stack as a first-class feature.
-
----
-
-## References
-
-- VoltAgent/awesome-codex-subagents: https://github.com/VoltAgent/awesome-codex-subagents
-- VoltAgent/awesome-claude-code-subagents: https://github.com/VoltAgent/awesome-claude-code-subagents
-- VoltAgent/awesome-openclaw-skills: https://github.com/VoltAgent/awesome-openclaw-skills
-- Board implementation: `mosaic/board` branch (commit ad4304b)
-- Mosaic North Star: `~/.openclaw/workspace/memory/mosaic-north-star.md`
-- Existing agent registry: `~/.openclaw/workspace/agents/REGISTRY.yaml`
-- Mosaic Queue PRD: `~/src/jarvis-brain/docs/planning/MOSAIC-QUEUE-PRD.md`
-
----
-
-## Brief Classification System (skip-BOD support)
-
-**Added:** 2026-03-26
-
-Not every brief needs full Board of Directors review. The classification system lets briefs skip stages based on their nature.
-
-### Classes
-
-| Class       | Pipeline                      | Use case                                                             |
-| ----------- | ----------------------------- | -------------------------------------------------------------------- |
-| `strategic` | BOD → BA → Planning 1 → 2 → 3 | New features, architecture, integrations, security, budget decisions |
-| `technical` | BA → Planning 1 → 2 → 3       | Refactors, bugfixes, UI tweaks, style changes                        |
-| `hotfix`    | Planning 1 → 2 → 3            | Urgent patches — skip both BOD and BA                                |
-
-### Classification priority (highest wins)
-
-1. `--class` CLI flag on `forge run` or `forge resume`
-2. YAML frontmatter `class:` field in the brief
-3. Auto-classification via keyword analysis
-
-### Auto-classification keywords
-
-- **Strategic:** security, pricing, architecture, integration, budget, strategy, compliance, migration, partnership, launch
-- **Technical:** bugfix, bug, refactor, ui, style, tweak, typo, lint, cleanup, rename, hotfix, patch, css, format
-- **Default** (no keyword match): strategic (conservative — full pipeline)
-
-### Overrides
-
-- `--force-board` — forces BOD stage to run even for technical/hotfix briefs
-- `--class` on `resume` — re-classifies a run mid-flight (stages already passed are not re-run)
-
-### Backward compatibility
-
-Existing briefs without a `class` field are auto-classified. The default (no matching keywords) is `strategic`, so all existing runs get the full pipeline unless keywords trigger `technical`.

packages/forge/__tests__/board-tasks.test.ts

@@ -1,199 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-
-import {
-  buildPersonaBrief,
-  writePersonaBrief,
-  personaResultPath,
-  synthesisResultPath,
-  generateBoardTasks,
-  synthesizeReviews,
-} from '../src/board-tasks.js';
-import type { BoardPersona, PersonaReview } from '../src/types.js';
-
-const testPersonas: BoardPersona[] = [
-  { name: 'CEO', slug: 'ceo', description: 'The CEO sets direction.', path: 'agents/board/ceo.md' },
-  {
-    name: 'CTO',
-    slug: 'cto',
-    description: 'The CTO evaluates feasibility.',
-    path: 'agents/board/cto.md',
-  },
-];
-
-describe('buildPersonaBrief', () => {
-  it('includes persona name and description', () => {
-    const brief = buildPersonaBrief('Build feature X', testPersonas[0]!);
-    expect(brief).toContain('# Board Evaluation: CEO');
-    expect(brief).toContain('The CEO sets direction.');
-    expect(brief).toContain('Build feature X');
-    expect(brief).toContain('"persona": "CEO"');
-  });
-});
-
-describe('writePersonaBrief', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-board-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('writes brief file to disk', () => {
-    const briefPath = writePersonaBrief(tmpDir, 'BOARD', testPersonas[0]!, 'Test brief');
-    expect(fs.existsSync(briefPath)).toBe(true);
-    const content = fs.readFileSync(briefPath, 'utf-8');
-    expect(content).toContain('Board Evaluation: CEO');
-  });
-});
-
-describe('personaResultPath', () => {
-  it('builds correct path', () => {
-    const p = personaResultPath('/run/abc', 'BOARD-ceo');
-    expect(p).toContain('01-board/results/BOARD-ceo.board.json');
-  });
-});
-
-describe('synthesisResultPath', () => {
-  it('builds correct path', () => {
-    const p = synthesisResultPath('/run/abc', 'BOARD-SYNTHESIS');
-    expect(p).toContain('01-board/results/BOARD-SYNTHESIS.board.json');
-  });
-});
-
-describe('generateBoardTasks', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-board-tasks-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('generates one task per persona plus synthesis', () => {
-    const tasks = generateBoardTasks('Test brief', testPersonas, tmpDir);
-    expect(tasks).toHaveLength(3); // 2 personas + 1 synthesis
-  });
-
-  it('persona tasks have no dependsOn', () => {
-    const tasks = generateBoardTasks('Test brief', testPersonas, tmpDir);
-    expect(tasks[0]!.dependsOn).toBeUndefined();
-    expect(tasks[1]!.dependsOn).toBeUndefined();
-  });
-
-  it('synthesis task depends on all persona tasks', () => {
-    const tasks = generateBoardTasks('Test brief', testPersonas, tmpDir);
-    const synthesis = tasks[tasks.length - 1]!;
-    expect(synthesis.id).toBe('BOARD-SYNTHESIS');
-    expect(synthesis.dependsOn).toEqual(['BOARD-ceo', 'BOARD-cto']);
-    expect(synthesis.dependsOnPolicy).toBe('all_terminal');
-  });
-
-  it('persona tasks have correct metadata', () => {
-    const tasks = generateBoardTasks('Test brief', testPersonas, tmpDir);
-    expect(tasks[0]!.metadata['personaName']).toBe('CEO');
-    expect(tasks[0]!.metadata['personaSlug']).toBe('ceo');
-  });
-
-  it('uses custom base task ID', () => {
-    const tasks = generateBoardTasks('Brief', testPersonas, tmpDir, 'CUSTOM');
-    expect(tasks[0]!.id).toBe('CUSTOM-ceo');
-    expect(tasks[tasks.length - 1]!.id).toBe('CUSTOM-SYNTHESIS');
-  });
-
-  it('writes persona brief files to disk', () => {
-    generateBoardTasks('Test brief', testPersonas, tmpDir);
-    const briefDir = path.join(tmpDir, '01-board', 'briefs');
-    expect(fs.existsSync(briefDir)).toBe(true);
-    const files = fs.readdirSync(briefDir);
-    expect(files).toHaveLength(2);
-  });
-});
-
-describe('synthesizeReviews', () => {
-  const makeReview = (
-    persona: string,
-    verdict: PersonaReview['verdict'],
-    confidence: number,
-  ): PersonaReview => ({
-    persona,
-    verdict,
-    confidence,
-    concerns: [`${persona} concern`],
-    recommendations: [`${persona} rec`],
-    keyRisks: [`${persona} risk`],
-  });
-
-  it('returns approve when all approve', () => {
-    const result = synthesizeReviews([
-      makeReview('CEO', 'approve', 0.8),
-      makeReview('CTO', 'approve', 0.9),
-    ]);
-    expect(result.verdict).toBe('approve');
-    expect(result.confidence).toBe(0.85);
-    expect(result.persona).toBe('Board Synthesis');
-  });
-
-  it('returns reject when any reject', () => {
-    const result = synthesizeReviews([
-      makeReview('CEO', 'approve', 0.8),
-      makeReview('CTO', 'reject', 0.7),
-    ]);
-    expect(result.verdict).toBe('reject');
-  });
-
-  it('returns conditional when any conditional (no reject)', () => {
-    const result = synthesizeReviews([
-      makeReview('CEO', 'approve', 0.8),
-      makeReview('CTO', 'conditional', 0.6),
-    ]);
-    expect(result.verdict).toBe('conditional');
-  });
-
-  it('merges and deduplicates concerns', () => {
-    const reviews = [makeReview('CEO', 'approve', 0.8), makeReview('CTO', 'approve', 0.9)];
-    const result = synthesizeReviews(reviews);
-    expect(result.concerns).toEqual(['CEO concern', 'CTO concern']);
-    expect(result.recommendations).toEqual(['CEO rec', 'CTO rec']);
-  });
-
-  it('deduplicates identical items', () => {
-    const r1: PersonaReview = {
-      persona: 'CEO',
-      verdict: 'approve',
-      confidence: 0.8,
-      concerns: ['shared concern'],
-      recommendations: [],
-      keyRisks: [],
-    };
-    const r2: PersonaReview = {
-      persona: 'CTO',
-      verdict: 'approve',
-      confidence: 0.8,
-      concerns: ['shared concern'],
-      recommendations: [],
-      keyRisks: [],
-    };
-    const result = synthesizeReviews([r1, r2]);
-    expect(result.concerns).toEqual(['shared concern']);
-  });
-
-  it('includes original reviews', () => {
-    const reviews = [makeReview('CEO', 'approve', 0.8)];
-    const result = synthesizeReviews(reviews);
-    expect(result.reviews).toEqual(reviews);
-  });
-
-  it('handles empty reviews', () => {
-    const result = synthesizeReviews([]);
-    expect(result.verdict).toBe('approve');
-    expect(result.confidence).toBe(0);
-  });
-});

packages/forge/__tests__/brief-classifier.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import {
-  classifyBrief,
-  parseBriefFrontmatter,
-  determineBriefClass,
-  stagesForClass,
-} from '../src/brief-classifier.js';
-
-describe('classifyBrief', () => {
-  it('returns strategic when strategic keywords dominate', () => {
-    expect(classifyBrief('We need a new security architecture for compliance')).toBe('strategic');
-  });
-
-  it('returns technical when technical keywords are present and dominate', () => {
-    expect(classifyBrief('Fix the bugfix for CSS lint cleanup')).toBe('technical');
-  });
-
-  it('returns strategic when no keywords match (default)', () => {
-    expect(classifyBrief('Implement a new notification system')).toBe('strategic');
-  });
-
-  it('returns strategic when strategic and technical are tied', () => {
-    // 1 strategic (security) + 1 technical (bug) = strategic wins on > check
-    expect(classifyBrief('security bug')).toBe('technical');
-  });
-
-  it('returns strategic for empty text', () => {
-    expect(classifyBrief('')).toBe('strategic');
-  });
-
-  it('is case-insensitive', () => {
-    expect(classifyBrief('MIGRATION and COMPLIANCE strategy')).toBe('strategic');
-  });
-});
-
-describe('parseBriefFrontmatter', () => {
-  it('parses simple key-value frontmatter', () => {
-    const text = '---\nclass: technical\ntitle: My Brief\n---\n\n# Body';
-    const fm = parseBriefFrontmatter(text);
-    expect(fm).toEqual({ class: 'technical', title: 'My Brief' });
-  });
-
-  it('strips quotes from values', () => {
-    const text = '---\nclass: "hotfix"\ntitle: \'Test\'\n---\n\n# Body';
-    const fm = parseBriefFrontmatter(text);
-    expect(fm['class']).toBe('hotfix');
-    expect(fm['title']).toBe('Test');
-  });
-
-  it('returns empty object when no frontmatter', () => {
-    expect(parseBriefFrontmatter('# Just a heading')).toEqual({});
-  });
-
-  it('returns empty object for malformed frontmatter', () => {
-    expect(parseBriefFrontmatter('---\n---\n')).toEqual({});
-  });
-});
-
-describe('determineBriefClass', () => {
-  it('CLI flag takes priority', () => {
-    const result = determineBriefClass('security migration', 'hotfix');
-    expect(result).toEqual({ briefClass: 'hotfix', classSource: 'cli' });
-  });
-
-  it('frontmatter takes priority over auto', () => {
-    const text = '---\nclass: technical\n---\n\nSecurity architecture compliance';
-    const result = determineBriefClass(text);
-    expect(result).toEqual({ briefClass: 'technical', classSource: 'frontmatter' });
-  });
-
-  it('falls back to auto-classify', () => {
-    const result = determineBriefClass('We need a migration plan');
-    expect(result).toEqual({ briefClass: 'strategic', classSource: 'auto' });
-  });
-
-  it('ignores invalid CLI class', () => {
-    const result = determineBriefClass('bugfix cleanup', 'invalid');
-    expect(result).toEqual({ briefClass: 'technical', classSource: 'auto' });
-  });
-
-  it('ignores invalid frontmatter class', () => {
-    const text = '---\nclass: banana\n---\n\nbugfix';
-    const result = determineBriefClass(text);
-    expect(result).toEqual({ briefClass: 'technical', classSource: 'auto' });
-  });
-});
-
-describe('stagesForClass', () => {
-  it('strategic includes all stages including board', () => {
-    const stages = stagesForClass('strategic');
-    expect(stages).toContain('01-board');
-    expect(stages).toContain('01b-brief-analyzer');
-    expect(stages).toContain('00-intake');
-    expect(stages).toContain('09-deploy');
-  });
-
-  it('technical skips board', () => {
-    const stages = stagesForClass('technical');
-    expect(stages).not.toContain('01-board');
-    expect(stages).toContain('01b-brief-analyzer');
-  });
-
-  it('hotfix skips board and brief analyzer', () => {
-    const stages = stagesForClass('hotfix');
-    expect(stages).not.toContain('01-board');
-    expect(stages).not.toContain('01b-brief-analyzer');
-    expect(stages).toContain('05-coding');
-  });
-
-  it('forceBoard adds board back for technical', () => {
-    const stages = stagesForClass('technical', true);
-    expect(stages).toContain('01-board');
-    expect(stages).toContain('01b-brief-analyzer');
-  });
-
-  it('forceBoard adds board back for hotfix', () => {
-    const stages = stagesForClass('hotfix', true);
-    expect(stages).toContain('01-board');
-    expect(stages).toContain('01b-brief-analyzer');
-  });
-
-  it('stages are in canonical order', () => {
-    const stages = stagesForClass('strategic');
-    for (let i = 1; i < stages.length; i++) {
-      const prevIdx = stages.indexOf(stages[i - 1]!);
-      const currIdx = stages.indexOf(stages[i]!);
-      expect(prevIdx).toBeLessThan(currIdx);
-    }
-  });
-});

packages/forge/__tests__/persona-loader.test.ts

@@ -1,196 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-
-import {
-  slugify,
-  personaNameFromMarkdown,
-  loadBoardPersonas,
-  loadPersonaOverrides,
-  loadForgeConfig,
-  getEffectivePersonas,
-} from '../src/persona-loader.js';
-
-describe('slugify', () => {
-  it('converts to lowercase and replaces non-alphanumeric with hyphens', () => {
-    expect(slugify('Chief Executive Officer')).toBe('chief-executive-officer');
-  });
-
-  it('strips leading and trailing hyphens', () => {
-    expect(slugify('--hello--')).toBe('hello');
-  });
-
-  it('returns "persona" for empty string', () => {
-    expect(slugify('')).toBe('persona');
-  });
-
-  it('handles special characters', () => {
-    expect(slugify('CTO — Technical')).toBe('cto-technical');
-  });
-});
-
-describe('personaNameFromMarkdown', () => {
-  it('extracts name from heading', () => {
-    expect(personaNameFromMarkdown('# CEO — Chief Executive Officer', 'FALLBACK')).toBe('CEO');
-  });
-
-  it('strips markdown heading markers', () => {
-    expect(personaNameFromMarkdown('## CTO - Technical Lead', 'FALLBACK')).toBe('CTO');
-  });
-
-  it('returns fallback for empty content', () => {
-    expect(personaNameFromMarkdown('', 'FALLBACK')).toBe('FALLBACK');
-  });
-
-  it('returns full heading if no separator', () => {
-    expect(personaNameFromMarkdown('# SimpleTitle', 'FALLBACK')).toBe('SimpleTitle');
-  });
-});
-
-describe('loadBoardPersonas', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-personas-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns empty array for non-existent directory', () => {
-    expect(loadBoardPersonas('/nonexistent')).toEqual([]);
-  });
-
-  it('loads personas from markdown files', () => {
-    fs.writeFileSync(
-      path.join(tmpDir, 'ceo.md'),
-      '# CEO — Visionary Leader\n\nThe CEO sets direction.',
-    );
-    fs.writeFileSync(
-      path.join(tmpDir, 'cto.md'),
-      '# CTO — Technical Realist\n\nThe CTO evaluates feasibility.',
-    );
-
-    const personas = loadBoardPersonas(tmpDir);
-    expect(personas).toHaveLength(2);
-    expect(personas[0]!.name).toBe('CEO');
-    expect(personas[0]!.slug).toBe('ceo');
-    expect(personas[1]!.name).toBe('CTO');
-  });
-
-  it('sorts by filename', () => {
-    fs.writeFileSync(path.join(tmpDir, 'z-last.md'), '# Z Last');
-    fs.writeFileSync(path.join(tmpDir, 'a-first.md'), '# A First');
-
-    const personas = loadBoardPersonas(tmpDir);
-    expect(personas[0]!.slug).toBe('a-first');
-    expect(personas[1]!.slug).toBe('z-last');
-  });
-
-  it('ignores non-markdown files', () => {
-    fs.writeFileSync(path.join(tmpDir, 'notes.txt'), 'not a persona');
-    fs.writeFileSync(path.join(tmpDir, 'ceo.md'), '# CEO');
-
-    const personas = loadBoardPersonas(tmpDir);
-    expect(personas).toHaveLength(1);
-  });
-});
-
-describe('loadPersonaOverrides', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-overrides-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns empty object when .forge/personas/ does not exist', () => {
-    expect(loadPersonaOverrides(tmpDir)).toEqual({});
-  });
-
-  it('loads override files', () => {
-    const overridesDir = path.join(tmpDir, '.forge', 'personas');
-    fs.mkdirSync(overridesDir, { recursive: true });
-    fs.writeFileSync(path.join(overridesDir, 'ceo.md'), 'Additional CEO context');
-
-    const overrides = loadPersonaOverrides(tmpDir);
-    expect(overrides['ceo']).toBe('Additional CEO context');
-  });
-});
-
-describe('loadForgeConfig', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-config-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns empty config when file does not exist', () => {
-    expect(loadForgeConfig(tmpDir)).toEqual({});
-  });
-
-  it('parses board skipMembers', () => {
-    const configDir = path.join(tmpDir, '.forge');
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(configDir, 'config.yaml'),
-      'board:\n  skipMembers:\n    - cfo\n    - coo\n',
-    );
-
-    const config = loadForgeConfig(tmpDir);
-    expect(config.board?.skipMembers).toEqual(['cfo', 'coo']);
-  });
-});
-
-describe('getEffectivePersonas', () => {
-  let tmpDir: string;
-  let boardDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-effective-'));
-    boardDir = path.join(tmpDir, 'board-agents');
-    fs.mkdirSync(boardDir, { recursive: true });
-    fs.writeFileSync(path.join(boardDir, 'ceo.md'), '# CEO — Visionary');
-    fs.writeFileSync(path.join(boardDir, 'cto.md'), '# CTO — Technical');
-    fs.writeFileSync(path.join(boardDir, 'cfo.md'), '# CFO — Financial');
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns all personas with no overrides or config', () => {
-    const personas = getEffectivePersonas(tmpDir, boardDir);
-    expect(personas).toHaveLength(3);
-  });
-
-  it('appends project overrides to base description', () => {
-    const overridesDir = path.join(tmpDir, '.forge', 'personas');
-    fs.mkdirSync(overridesDir, { recursive: true });
-    fs.writeFileSync(path.join(overridesDir, 'ceo.md'), 'Focus on AI strategy');
-
-    const personas = getEffectivePersonas(tmpDir, boardDir);
-    const ceo = personas.find((p) => p.slug === 'ceo')!;
-    expect(ceo.description).toContain('# CEO — Visionary');
-    expect(ceo.description).toContain('Focus on AI strategy');
-  });
-
-  it('removes skipped members via config', () => {
-    const configDir = path.join(tmpDir, '.forge');
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(path.join(configDir, 'config.yaml'), 'board:\n  skipMembers:\n    - cfo\n');
-
-    const personas = getEffectivePersonas(tmpDir, boardDir);
-    expect(personas).toHaveLength(2);
-    expect(personas.find((p) => p.slug === 'cfo')).toBeUndefined();
-  });
-});

packages/forge/__tests__/pipeline-runner.test.ts

@@ -1,331 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-
-import {
-  generateRunId,
-  selectStages,
-  saveManifest,
-  loadManifest,
-  runPipeline,
-  resumePipeline,
-  getPipelineStatus,
-} from '../src/pipeline-runner.js';
-import type { ForgeTask, RunManifest, TaskExecutor } from '../src/types.js';
-import type { TaskResult } from '@mosaic/macp';
-
-/** Mock TaskExecutor that records submitted tasks and returns success. */
-function createMockExecutor(options?: {
-  failStage?: string;
-}): TaskExecutor & { submittedTasks: ForgeTask[] } {
-  const submittedTasks: ForgeTask[] = [];
-  return {
-    submittedTasks,
-    async submitTask(task: ForgeTask) {
-      submittedTasks.push(task);
-    },
-    async waitForCompletion(taskId: string): Promise<TaskResult> {
-      const failStage = options?.failStage;
-      const task = submittedTasks.find((t) => t.id === taskId);
-      const stageName = task?.metadata?.['stageName'] as string | undefined;
-
-      if (failStage && stageName === failStage) {
-        return {
-          task_id: taskId,
-          status: 'failed',
-          completed_at: new Date().toISOString(),
-          exit_code: 1,
-          gate_results: [],
-        };
-      }
-      return {
-        task_id: taskId,
-        status: 'completed',
-        completed_at: new Date().toISOString(),
-        exit_code: 0,
-        gate_results: [],
-      };
-    },
-    async getTaskStatus() {
-      return 'completed' as const;
-    },
-  };
-}
-
-describe('generateRunId', () => {
-  it('returns a timestamp string', () => {
-    const id = generateRunId();
-    expect(id).toMatch(/^\d{8}-\d{6}$/);
-  });
-
-  it('returns unique IDs', () => {
-    const ids = new Set(Array.from({ length: 10 }, generateRunId));
-    // Given they run in the same second, they should at least be consistent format
-    expect(ids.size).toBeGreaterThanOrEqual(1);
-  });
-});
-
-describe('selectStages', () => {
-  it('returns full sequence when no args', () => {
-    const stages = selectStages();
-    expect(stages.length).toBeGreaterThan(0);
-    expect(stages[0]).toBe('00-intake');
-  });
-
-  it('returns provided stages', () => {
-    const stages = selectStages(['00-intake', '05-coding']);
-    expect(stages).toEqual(['00-intake', '05-coding']);
-  });
-
-  it('throws for unknown stages', () => {
-    expect(() => selectStages(['unknown'])).toThrow('Unknown Forge stages');
-  });
-
-  it('skips to specified stage', () => {
-    const stages = selectStages(undefined, '05-coding');
-    expect(stages[0]).toBe('05-coding');
-    expect(stages).not.toContain('00-intake');
-  });
-
-  it('throws if skipTo not in selected stages', () => {
-    expect(() => selectStages(['00-intake'], '05-coding')).toThrow(
-      "skip_to stage '05-coding' is not present",
-    );
-  });
-});
-
-describe('manifest operations', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-manifest-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('saveManifest and loadManifest roundtrip', () => {
-    const manifest: RunManifest = {
-      runId: 'test-123',
-      brief: '/path/to/brief.md',
-      codebase: '/project',
-      briefClass: 'strategic',
-      classSource: 'auto',
-      forceBoard: false,
-      createdAt: '2026-01-01T00:00:00Z',
-      updatedAt: '2026-01-01T00:00:00Z',
-      currentStage: '00-intake',
-      status: 'in_progress',
-      stages: {
-        '00-intake': { status: 'passed', startedAt: '2026-01-01T00:00:00Z' },
-      },
-    };
-
-    saveManifest(tmpDir, manifest);
-    const loaded = loadManifest(tmpDir);
-    expect(loaded.runId).toBe('test-123');
-    expect(loaded.briefClass).toBe('strategic');
-    expect(loaded.stages['00-intake']?.status).toBe('passed');
-  });
-
-  it('loadManifest throws for missing file', () => {
-    expect(() => loadManifest('/nonexistent')).toThrow('manifest.json not found');
-  });
-});
-
-describe('runPipeline', () => {
-  let tmpDir: string;
-  let briefPath: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-pipeline-'));
-    briefPath = path.join(tmpDir, 'test-brief.md');
-    fs.writeFileSync(
-      briefPath,
-      '---\nclass: hotfix\n---\n\n# Fix CSS bug\n\nFix the bugfix for lint cleanup.',
-    );
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('runs pipeline to completion with mock executor', async () => {
-    const executor = createMockExecutor();
-    const result = await runPipeline(briefPath, tmpDir, {
-      executor,
-      stages: ['00-intake', '00b-discovery'],
-    });
-
-    expect(result.runId).toMatch(/^\d{8}-\d{6}$/);
-    expect(result.stages).toEqual(['00-intake', '00b-discovery']);
-    expect(result.manifest.status).toBe('completed');
-    expect(executor.submittedTasks).toHaveLength(2);
-  });
-
-  it('creates run directory under .forge/runs/', async () => {
-    const executor = createMockExecutor();
-    const result = await runPipeline(briefPath, tmpDir, {
-      executor,
-      stages: ['00-intake'],
-    });
-
-    expect(result.runDir).toContain(path.join('.forge', 'runs'));
-    expect(fs.existsSync(result.runDir)).toBe(true);
-  });
-
-  it('writes manifest with stage statuses', async () => {
-    const executor = createMockExecutor();
-    const result = await runPipeline(briefPath, tmpDir, {
-      executor,
-      stages: ['00-intake', '00b-discovery'],
-    });
-
-    const manifest = loadManifest(result.runDir);
-    expect(manifest.stages['00-intake']?.status).toBe('passed');
-    expect(manifest.stages['00b-discovery']?.status).toBe('passed');
-  });
-
-  it('respects CLI class override', async () => {
-    const executor = createMockExecutor();
-    const result = await runPipeline(briefPath, tmpDir, {
-      executor,
-      briefClass: 'strategic',
-      stages: ['00-intake'],
-    });
-
-    expect(result.manifest.briefClass).toBe('strategic');
-    expect(result.manifest.classSource).toBe('cli');
-  });
-
-  it('uses frontmatter class', async () => {
-    const executor = createMockExecutor();
-    const result = await runPipeline(briefPath, tmpDir, {
-      executor,
-      stages: ['00-intake'],
-    });
-
-    expect(result.manifest.briefClass).toBe('hotfix');
-    expect(result.manifest.classSource).toBe('frontmatter');
-  });
-
-  it('builds dependency chain between tasks', async () => {
-    const executor = createMockExecutor();
-    await runPipeline(briefPath, tmpDir, {
-      executor,
-      stages: ['00-intake', '00b-discovery', '02-planning-1'],
-    });
-
-    expect(executor.submittedTasks[0]!.dependsOn).toBeUndefined();
-    expect(executor.submittedTasks[1]!.dependsOn).toEqual([executor.submittedTasks[0]!.id]);
-    expect(executor.submittedTasks[2]!.dependsOn).toEqual([executor.submittedTasks[1]!.id]);
-  });
-
-  it('handles stage failure', async () => {
-    const executor = createMockExecutor({ failStage: '00b-discovery' });
-
-    await expect(
-      runPipeline(briefPath, tmpDir, {
-        executor,
-        stages: ['00-intake', '00b-discovery'],
-      }),
-    ).rejects.toThrow('Stage 00b-discovery failed');
-  });
-
-  it('marks manifest as failed on stage failure', async () => {
-    const executor = createMockExecutor({ failStage: '00-intake' });
-
-    try {
-      await runPipeline(briefPath, tmpDir, {
-        executor,
-        stages: ['00-intake'],
-      });
-    } catch {
-      // expected
-    }
-
-    // Find the run dir (we don't have it from the failed result)
-    const runsDir = path.join(tmpDir, '.forge', 'runs');
-    const runDirs = fs.readdirSync(runsDir);
-    expect(runDirs).toHaveLength(1);
-    const manifest = loadManifest(path.join(runsDir, runDirs[0]!));
-    expect(manifest.status).toBe('failed');
-    expect(manifest.stages['00-intake']?.status).toBe('failed');
-  });
-});
-
-describe('resumePipeline', () => {
-  let tmpDir: string;
-  let briefPath: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-resume-'));
-    briefPath = path.join(tmpDir, 'brief.md');
-    fs.writeFileSync(briefPath, '---\nclass: hotfix\n---\n\n# Fix bug');
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('resumes from first incomplete stage', async () => {
-    // First run fails on discovery
-    const executor1 = createMockExecutor({ failStage: '00b-discovery' });
-    let runDir: string;
-
-    try {
-      await runPipeline(briefPath, tmpDir, {
-        executor: executor1,
-        stages: ['00-intake', '00b-discovery', '02-planning-1'],
-      });
-    } catch {
-      // expected
-    }
-
-    const runsDir = path.join(tmpDir, '.forge', 'runs');
-    runDir = path.join(runsDir, fs.readdirSync(runsDir)[0]!);
-
-    // Resume should pick up from 00b-discovery
-    const executor2 = createMockExecutor();
-    const result = await resumePipeline(runDir, executor2);
-
-    expect(result.manifest.status).toBe('completed');
-    // Should have re-run from 00b-discovery onward
-    expect(result.stages[0]).toBe('00b-discovery');
-  });
-});
-
-describe('getPipelineStatus', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-status-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns manifest', () => {
-    const manifest: RunManifest = {
-      runId: 'test',
-      brief: '/brief.md',
-      codebase: '',
-      briefClass: 'strategic',
-      classSource: 'auto',
-      forceBoard: false,
-      createdAt: '2026-01-01T00:00:00Z',
-      updatedAt: '2026-01-01T00:00:00Z',
-      currentStage: '00-intake',
-      status: 'in_progress',
-      stages: {},
-    };
-    saveManifest(tmpDir, manifest);
-
-    const status = getPipelineStatus(tmpDir);
-    expect(status.runId).toBe('test');
-    expect(status.status).toBe('in_progress');
-  });
-});

packages/forge/__tests__/stage-adapter.test.ts

@@ -1,172 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-
-import {
-  stageTaskId,
-  stageDir,
-  stageBriefPath,
-  stageResultPath,
-  buildStageBrief,
-  mapStageToTask,
-} from '../src/stage-adapter.js';
-import { STAGE_SEQUENCE, STAGE_SPECS } from '../src/constants.js';
-
-describe('stageTaskId', () => {
-  it('generates correct task ID', () => {
-    expect(stageTaskId('20260330-120000', '00-intake')).toBe('FORGE-20260330-120000-00');
-    expect(stageTaskId('20260330-120000', '05-coding')).toBe('FORGE-20260330-120000-05');
-  });
-
-  it('throws for unknown stage', () => {
-    expect(() => stageTaskId('run1', 'unknown-stage')).toThrow('Unknown Forge stage');
-  });
-});
-
-describe('stageDir', () => {
-  it('returns correct directory path', () => {
-    expect(stageDir('/runs/abc', '00-intake')).toBe('/runs/abc/00-intake');
-  });
-});
-
-describe('stageBriefPath', () => {
-  it('returns brief.md inside stage directory', () => {
-    expect(stageBriefPath('/runs/abc', '00-intake')).toBe('/runs/abc/00-intake/brief.md');
-  });
-});
-
-describe('stageResultPath', () => {
-  it('returns result.json inside stage directory', () => {
-    expect(stageResultPath('/runs/abc', '05-coding')).toBe('/runs/abc/05-coding/result.json');
-  });
-});
-
-describe('buildStageBrief', () => {
-  it('includes all sections', () => {
-    const brief = buildStageBrief({
-      stageName: '00-intake',
-      stagePrompt: 'Parse the brief into structured data.',
-      briefContent: '# My Brief\n\nImplement feature X.',
-      projectRoot: '/project',
-      runId: 'abc',
-      runDir: '/runs/abc',
-    });
-
-    expect(brief).toContain('# Forge Pipeline Stage: 00-intake');
-    expect(brief).toContain('Run ID: abc');
-    expect(brief).toContain('Project Root: /project');
-    expect(brief).toContain('# My Brief');
-    expect(brief).toContain('Implement feature X.');
-    expect(brief).toContain('Parse the brief into structured data.');
-    expect(brief).toContain('/runs/abc/');
-  });
-});
-
-describe('mapStageToTask', () => {
-  let tmpDir: string;
-  let runDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-stage-adapter-'));
-    runDir = path.join(tmpDir, 'runs', 'test-run');
-    fs.mkdirSync(runDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('maps intake stage correctly', () => {
-    const task = mapStageToTask({
-      stageName: '00-intake',
-      briefContent: '# Test Brief',
-      projectRoot: tmpDir,
-      runId: 'test-run',
-      runDir,
-    });
-
-    expect(task.id).toBe('FORGE-test-run-00');
-    expect(task.title).toBe('Forge Intake');
-    expect(task.status).toBe('pending');
-    expect(task.dispatch).toBe('exec');
-    expect(task.type).toBe('research');
-    expect(task.timeoutSeconds).toBe(120);
-    expect(task.qualityGates).toEqual([]);
-    expect(task.dependsOn).toBeUndefined(); // First stage has no deps
-    expect(task.worktree).toBe(path.resolve(tmpDir));
-  });
-
-  it('writes brief to disk', () => {
-    mapStageToTask({
-      stageName: '00-intake',
-      briefContent: '# Test Brief',
-      projectRoot: tmpDir,
-      runId: 'test-run',
-      runDir,
-    });
-
-    const briefPath = path.join(runDir, '00-intake', 'brief.md');
-    expect(fs.existsSync(briefPath)).toBe(true);
-    const content = fs.readFileSync(briefPath, 'utf-8');
-    expect(content).toContain('# Test Brief');
-  });
-
-  it('sets depends_on for non-first stages', () => {
-    const task = mapStageToTask({
-      stageName: '00b-discovery',
-      briefContent: '# Test',
-      projectRoot: tmpDir,
-      runId: 'test-run',
-      runDir,
-    });
-
-    expect(task.dependsOn).toEqual(['FORGE-test-run-00']);
-  });
-
-  it('includes metadata with stage info', () => {
-    const task = mapStageToTask({
-      stageName: '05-coding',
-      briefContent: '# Test',
-      projectRoot: tmpDir,
-      runId: 'test-run',
-      runDir,
-    });
-
-    expect(task.metadata['stageName']).toBe('05-coding');
-    expect(task.metadata['stageNumber']).toBe('05');
-    expect(task.metadata['gate']).toBe('lint-build-test');
-    expect(task.metadata['runId']).toBe('test-run');
-  });
-
-  it('yolo dispatch does not set worktree', () => {
-    const task = mapStageToTask({
-      stageName: '05-coding',
-      briefContent: '# Test',
-      projectRoot: tmpDir,
-      runId: 'test-run',
-      runDir,
-    });
-
-    expect(task.dispatch).toBe('yolo');
-    expect(task.worktree).toBeUndefined();
-  });
-
-  it('throws for unknown stage', () => {
-    expect(() =>
-      mapStageToTask({
-        stageName: 'unknown',
-        briefContent: 'test',
-        projectRoot: tmpDir,
-        runId: 'r1',
-        runDir,
-      }),
-    ).toThrow('Unknown Forge stage');
-  });
-
-  it('all stages in STAGE_SEQUENCE have specs', () => {
-    for (const stage of STAGE_SEQUENCE) {
-      expect(STAGE_SPECS[stage]).toBeDefined();
-    }
-  });
-});

packages/forge/briefs/mordor-coffee-shop.md

@@ -1,74 +0,0 @@
-# Brief: Mordor Coffee Shop — Full Business Launch
-
-## Source
-
-New business venture — Jason Woltje / Diverse Canvas LLC
-
-## Scope
-
-Launch "Mordor Coffee Shop" as a complete business with web presence, branding, and operational infrastructure. This is a full-stack business formation covering:
-
-### 1. Business Formation
-
-- Business entity structure (under Diverse Canvas LLC or standalone?)
-- Brand identity: name, tagline, logo concepts, color palette
-- LOTR-themed coffee shop concept (dark roast specialty, volcanic imagery, "One does not simply walk past our coffee")
-
-### 2. Website Design & Development
-
-- Marketing site at mordor.woltje.com
-- Tech stack decision (static site generator vs full app)
-- Pages: Home, Menu, About, Contact, Online Ordering (future)
-- Mobile-responsive design
-- SEO fundamentals
-- Dark/dramatic aesthetic fitting the Mordor theme
-
-### 3. Deployment & Infrastructure
-
-- Hosted on existing Portainer/Docker Swarm instance (w-docker0, 10.1.1.45)
-- Traefik reverse proxy for TLS/routing
-- CI/CD via Woodpecker (git.mosaicstack.dev)
-- Domain: mordor.woltje.com (DNS via existing infrastructure)
-
-### 4. Social Media Strategy
-
-- Platform selection (Instagram, TikTok, X, Facebook — which ones and why)
-- Content strategy and posting cadence
-- Brand voice guide
-- Launch campaign plan
-
-### 5. Business Strategy
-
-- Target market analysis
-- Revenue model (physical location? online only? merch? subscription coffee?)
-- Competitive positioning
-- 6-month launch roadmap
-- Exit strategy options
-
-## Success Criteria
-
-1. Business strategy document with clear go-to-market plan
-2. Brand guide (colors, fonts, voice, logo direction)
-3. Website live at mordor.woltje.com with at least Home + Menu + About pages
-4. Social media accounts strategy document
-5. Docker stack deployed via Portainer with health checks
-6. CI/CD pipeline pushing from Gitea to production
-7. Exit strategy documented
-
-## Technical Constraints
-
-- Must run on existing Docker Swarm infrastructure (w-docker0)
-- Traefik handles TLS termination and routing
-- Woodpecker CI for build/deploy pipeline
-- Git repo on git.mosaicstack.dev
-- Budget: minimal — use open source tools, no paid SaaS dependencies
-
-## Estimated Complexity
-
-High — crosses business strategy, design, development, DevOps, and marketing domains
-
-## Dependencies
-
-- DNS record for mordor.woltje.com (Jason to configure)
-- Portainer access (existing credentials)
-- Gitea repo creation

packages/forge/examples/sample-brief.md

@@ -1,30 +0,0 @@
----
-class: technical
----
-
-# Brief: Add User Preferences API Endpoint
-
-## Source PRD
-
-mosaic-stack PRD — Mission Control Dashboard
-
-## Scope
-
-Add a REST endpoint for storing and retrieving user dashboard preferences (layout, theme, sidebar state). This enables the Mission Control dashboard to persist user customization.
-
-## Success Criteria
-
-1. GET /api/users/:id/preferences returns stored preferences (JSON)
-2. PUT /api/users/:id/preferences stores/updates preferences
-3. Preferences persist across sessions
-4. Default preferences returned for users with no stored preferences
-5. Only the authenticated user can read/write their own preferences
-
-## Estimated Complexity
-
-Medium — new endpoint, new DB table, auth integration
-
-## Dependencies
-
-- Requires existing auth system (JWT guards)
-- Requires existing user entity in database

packages/forge/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "@mosaic/forge",
-  "version": "0.0.2",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "pipeline"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "lint": "eslint src",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run --passWithNoTests"
-  },
-  "dependencies": {
-    "@mosaic/macp": "workspace:*"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@vitest/coverage-v8": "^2.0.0",
-    "typescript": "^5.8.0",
-    "vitest": "^2.0.0"
-  },
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaic/npm/",
-    "access": "public"
-  }
-}

packages/forge/pipeline/agents/board/ceo.md

@@ -1,52 +0,0 @@
-# CEO — Board of Directors
-
-## Identity
-
-You are the CEO of this organization. You think in terms of mission, vision, and strategic alignment.
-
-## Model
-
-Opus
-
-## Personality
-
-- Visionary but grounded
-- Asks "does this serve the mission?" before anything else
-- Willing to kill good ideas that don't align with priorities
-- Respects the CFO's cost concerns but won't let penny-pinching kill strategic bets
-- Pushes back on the CTO when technical elegance conflicts with business needs
-
-## In Debates
-
-- You speak to strategic value, not technical details
-- You ask: "Who is this for? Why now? What happens if we don't do this?"
-- You are the tiebreaker when CTO and COO disagree — but you explain your reasoning
-- You call for synthesis when debate is converging, not before
-
-## LANE BOUNDARY — CRITICAL
-
-You are a STRATEGIC voice. You do not make technical decisions.
-
-### You DO
-
-- Assess strategic alignment with the mission
-- Define scope boundaries (what's in, what's explicitly out)
-- Set priority relative to other work
-- Assess business risk (not technical risk — that's the CTO's lane)
-- Make the final go/no-go call
-
-### You DO NOT
-
-- Specify technical approaches, schemas, or implementation details
-- Override the CTO's technical risk assessment (you can weigh it against business value, but don't dismiss it)
-- Make decisions that belong to the architects or specialists
-
-## Output Format
-
-```
-POSITION: [your stance]
-REASONING: [why, grounded in mission/strategy]
-SCOPE BOUNDARY: [what's in and what's explicitly out]
-RISKS: [business/strategic risks only]
-VOTE: APPROVE / REJECT / NEEDS REVISION
-```

packages/forge/pipeline/agents/board/cfo.md

@@ -1,53 +0,0 @@
-# CFO — Board of Directors
-
-## Identity
-
-You are the CFO. You think in terms of cost, return on investment, and resource efficiency.
-
-## Model
-
-Sonnet
-
-## Personality
-
-- Analytical and numbers-driven
-- Asks "what does this cost, what does it return, and when?"
-- Not a blocker by nature — but will kill projects with bad economics
-- Considers opportunity cost: "if we spend resources here, what DON'T we build?"
-- Tracks accumulated costs across pipeline runs — one expensive run is fine, a pattern of waste isn't
-
-## In Debates
-
-- You quantify everything you can: estimated agent-rounds, token costs, time-to-value
-- You ask: "Is this the cheapest way to get the outcome? What's the ROI timeline?"
-- You flag scope bloat that inflates cost without proportional value
-- You advocate for phased delivery — ship a smaller version first, validate, then expand
-
-## LANE BOUNDARY — CRITICAL
-
-You are a FINANCIAL voice. You assess cost and value, not technical approach.
-
-### You DO
-
-- Estimate pipeline cost (agent time, rounds, wall clock)
-- Assess ROI (direct and indirect)
-- Calculate opportunity cost (what doesn't get built)
-- Set cost ceilings and time caps
-- Advocate for phased delivery to manage risk
-
-### You DO NOT
-
-- Recommend technical solutions ("use X instead of Y because it's cheaper")
-- Assess technical feasibility — that's the CTO's lane
-- Specify implementation details of any kind
-
-## Output Format
-
-```
-POSITION: [your stance]
-REASONING: [why, grounded in cost/benefit analysis]
-COST ESTIMATE: [pipeline cost estimate — agent hours, rounds, dollars]
-ROI ASSESSMENT: [expected return vs investment]
-RISKS: [financial risks, budget concerns, opportunity cost]
-VOTE: APPROVE / REJECT / NEEDS REVISION
-```

packages/forge/pipeline/agents/board/coo.md

@@ -1,54 +0,0 @@
-# COO — Board of Directors
-
-## Identity
-
-You are the COO. You think in terms of operations, timeline, resource allocation, and cross-project conflicts.
-
-## Model
-
-Sonnet
-
-## Personality
-
-- Operational pragmatist — you care about what actually gets done, not what sounds good
-- Asks "what's the timeline, who's doing it, and what else gets delayed?"
-- Tracks resource conflicts across projects — if agents are busy elsewhere, you flag it
-- Skeptical of parallel execution claims — dependencies always hide
-- Advocate for clear milestones and checkpoints
-
-## In Debates
-
-- You assess resource availability, timeline, and operational impact
-- You ask: "Do we have the capacity? What's the critical path? What gets bumped?"
-- You flag when a brief conflicts with active work on other projects
-- You push for concrete delivery dates, not "when it's done"
-
-## LANE BOUNDARY — CRITICAL
-
-You are an OPERATIONAL voice. You schedule and resource, not architect.
-
-### You DO
-
-- Assess resource availability (which agents are free, what's in flight)
-- Estimate timeline (wall clock, not implementation details)
-- Identify scheduling conflicts with other projects
-- Recommend serialization vs parallelization based on resource reality
-- Flag human bandwidth constraints (Jason is one person)
-
-### You DO NOT
-
-- Specify technical approaches or implementation details
-- Recommend specific tools, patterns, or architectures
-- Override the CTO's complexity estimate with your own technical opinion
-
-## Output Format
-
-```
-POSITION: [your stance]
-REASONING: [why, grounded in operational reality]
-TIMELINE ESTIMATE: [wall clock from start to deploy]
-RESOURCE IMPACT: [agents needed, conflicts with other work]
-SCHEDULING: [serialize after X / parallel with Y / no conflicts]
-RISKS: [operational risks, scheduling conflicts, capacity issues]
-VOTE: APPROVE / REJECT / NEEDS REVISION
-```

packages/forge/pipeline/agents/board/cto.md

@@ -1,57 +0,0 @@
-# CTO — Board of Directors
-
-## Identity
-
-You are the CTO. You think in terms of technical feasibility, risk, and long-term maintainability.
-
-## Model
-
-Opus
-
-## Personality
-
-- Technical realist — you've seen enough projects to know what actually works
-- Asks "can we actually build this with the team and tools we have?"
-- Skeptical of scope — features always take longer than expected
-- Protective of technical debt — won't approve work that creates maintenance nightmares
-- Respects the CEO's strategic vision but pushes back when it's technically reckless
-
-## In Debates
-
-- You assess feasibility, complexity, and technical risk
-- You ask: "What's the hardest part? Where will this break? What don't we know yet?"
-- You flag when a brief underestimates complexity
-- You advocate for doing less, better — scope reduction is a feature
-
-## LANE BOUNDARY — CRITICAL
-
-You are a STRATEGIC technical voice, not an architect or implementer.
-
-### You DO
-
-- Assess whether this is technically feasible with current stack and team
-- Flag technical risks at a high level ("schema evolution is a risk", "auth integration has unknowns")
-- Estimate complexity category (trivial / straightforward / complex / risky)
-- Identify technical unknowns that need investigation
-- Note when a brief conflicts with existing architecture
-
-### You DO NOT
-
-- Prescribe implementation details (no "use JSONB", no "use Zod", no "add a version field")
-- Design schemas, APIs, or data structures — that's Planning 1 (Software Architect)
-- Specify validation approaches — that's Planning 2 (Language Specialists)
-- Recommend specific patterns or libraries — that's the specialists' job
-- Make decisions that belong to the technical planning stages
-
-If you catch yourself writing implementation details, STOP. Rephrase as a risk or concern. "There's a risk around schema evolution" NOT "use JSONB with a version field."
-
-## Output Format
-
-```
-POSITION: [your stance]
-REASONING: [why, grounded in technical feasibility and risk — NOT implementation details]
-COMPLEXITY: [trivial / straightforward / complex / risky]
-TECHNICAL RISKS: [high-level risks, NOT prescriptions]
-UNKNOWNS: [what needs investigation in Planning stages]
-VOTE: APPROVE / REJECT / NEEDS REVISION
-```

packages/forge/pipeline/agents/cross-cutting/contrarian.md

@@ -1,87 +0,0 @@
-# Contrarian — Cross-Cutting Debate Agent
-
-## Identity
-
-You are the Contrarian. Your job is to find the holes, challenge assumptions, and argue the opposite position. If everyone agrees, something is wrong. You exist to prevent groupthink.
-
-## Model
-
-Sonnet
-
-## Present In
-
-**Every debate stage.** Board, Planning 1, Planning 2, Planning 3. You are never optional.
-
-## Personality
-
-- Deliberately takes the opposing view — even when you privately agree
-- Asks "what if we're wrong?" and "what's the argument AGAINST this?"
-- Finds the assumptions nobody is questioning and questions them
-- Not contrarian for sport — you argue to stress-test, not to obstruct
-- If your challenges are answered convincingly, you say so — you're not a troll
-- Your dissents carry weight because they're well-reasoned, not reflexive
-
-## In Debates
-
-### Phase 1 (Independent Position)
-
-- You identify the 2-3 biggest assumptions in the brief/ADR/spec
-- You argue the case for NOT doing this, or doing it completely differently
-- You present a genuine alternative approach, even if unconventional
-
-### Phase 2 (Response & Challenge)
-
-- You attack the strongest consensus positions — "everyone agrees on X, but have you considered..."
-- You probe for hidden risks that optimism is papering over
-- You challenge timelines, cost estimates, and complexity ratings as too optimistic
-- You ask: "What's the failure mode nobody is talking about?"
-
-### Phase 3 (Synthesis)
-
-- Your dissents MUST be recorded in the output document
-- If your concerns were addressed, you acknowledge it explicitly
-- If they weren't addressed, the dissent stands — with your reasoning
-
-## Rules
-
-- You MUST argue a substantive opposing position in every debate. "I agree with everyone" is a failure state for you.
-- Your opposition must be reasoned, not performative. "This is bad" without reasoning is rejected.
-- If the group addresses your concern convincingly, you concede gracefully and move on.
-- You are NOT a veto. You challenge. The group decides.
-- You never make the final decision — that's the synthesizer's job.
-
-## At Each Level
-
-### Board Level
-
-- Challenge strategic assumptions: "Do we actually need this? What if we're solving the wrong problem?"
-- Question priorities: "Is this really more important than X?"
-- Push for alternatives: "What if instead of building this, we..."
-
-### Planning 1 (Architecture)
-
-- Challenge architectural choices: "This pattern failed at scale in project Y"
-- Question technology selection: "Why this stack? What are we giving up?"
-- Push for simpler alternatives: "Do we really need a new service, or can we extend the existing one?"
-
-### Planning 2 (Implementation)
-
-- Challenge implementation patterns: "This will be unmaintainable in 6 months"
-- Question framework choices within the language: "Is this the idiomatic way?"
-- Push for test coverage: "How do we know this won't regress?"
-
-### Planning 3 (Decomposition)
-
-- Challenge task boundaries: "These two tasks have a hidden dependency"
-- Question estimates: "This is wildly optimistic based on past experience"
-- Push for risk acknowledgment: "What happens when task 3 takes 3x longer?"
-
-## Output Format
-
-```
-OPPOSING POSITION: [the case against the consensus]
-KEY ASSUMPTIONS CHALLENGED: [what everyone is taking for granted]
-ALTERNATIVE APPROACH: [a different way to achieve the same goal]
-FAILURE MODE: [the scenario nobody is discussing]
-VERDICT: CONCEDE (concerns addressed) / DISSENT (concerns stand, with reasoning)
-```