fix(macp): fail-closed typed gate states — no placeholder/empty-command passes (#1275 )

RI-N2 / SDLC-D-035. Every GateResult now carries a typed status discriminator (passed|failed|simulated|waiting|capability_failure); passed:true remains true only for really-executed, really-green gates. - ci-pipeline without a CI provider → capability_failure (MACP_NO_CI_PIPELINE), never the placeholder pass - empty-command gate → capability_failure (MACP_NO_COMMAND / MACP_NO_REVIEWER), and runGates no longer silently skips it - manual gate type waits (MACP_AUTHORITY_REQUIRED) — neither pass nor fail - explicit simulation only (simulate option / --simulate): typed simulated results can never make the aggregate passed (RunGatesResult.state) - CLI stubs (tasks list, submit, events tail) exit nonzero with typed MACP_NOT_IMPLEMENTED; macp gate is now wired to runGates with --simulate - legacy __tests__/gate-runner.test.ts consolidated into src/gate-runner.spec.ts (root eslint project service does not cover packages/macp/__tests__)
Merge pull request 'fix(ci): unwire test-start-agent-session.sh, restore its signed exclusion — unblocks every PR on next' (#1270 ) from fix/1269-ci-chain-unblock into next
2026-08-17 16:40:16 -05:00 · 2026-08-17 20:44:59 +00:00 · 2026-08-16 18:03:02 -05:00 · 2026-08-16 17:58:49 -05:00
14 changed files with 977 additions and 1317 deletions
@@ -1,253 +0,0 @@
-import { mkdirSync, readFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { normalizeGate, countAIFindings, runGate, runGates } from '../src/gate-runner.js';
-
-function makeTmpDir(): string {
-  const dir = join(tmpdir(), `macp-gate-${randomUUID()}`);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-describe('normalizeGate', () => {
-  it('normalizes a string to mechanical gate', () => {
-    expect(normalizeGate('echo test')).toEqual({
-      command: 'echo test',
-      type: 'mechanical',
-      fail_on: 'blocker',
-    });
-  });
-
-  it('normalizes an object gate with defaults', () => {
-    expect(normalizeGate({ command: 'lint' })).toEqual({
-      command: 'lint',
-      type: 'mechanical',
-      fail_on: 'blocker',
-    });
-  });
-
-  it('preserves explicit type and fail_on', () => {
-    expect(normalizeGate({ command: 'review', type: 'ai-review', fail_on: 'any' })).toEqual({
-      command: 'review',
-      type: 'ai-review',
-      fail_on: 'any',
-    });
-  });
-
-  it('handles non-string/non-object input', () => {
-    expect(normalizeGate(42)).toEqual({ command: '', type: 'mechanical', fail_on: 'blocker' });
-    expect(normalizeGate(null)).toEqual({ command: '', type: 'mechanical', fail_on: 'blocker' });
-  });
-});
-
-describe('countAIFindings', () => {
-  it('returns zeros for non-object', () => {
-    expect(countAIFindings(null)).toEqual({ blockers: 0, total: 0 });
-    expect(countAIFindings('string')).toEqual({ blockers: 0, total: 0 });
-    expect(countAIFindings([])).toEqual({ blockers: 0, total: 0 });
-  });
-
-  it('counts from stats block', () => {
-    const output = { stats: { blockers: 2, should_fix: 3, suggestions: 1 } };
-    expect(countAIFindings(output)).toEqual({ blockers: 2, total: 6 });
-  });
-
-  it('counts from findings array when stats has no blockers', () => {
-    const output = {
-      stats: { blockers: 0 },
-      findings: [{ severity: 'blocker' }, { severity: 'warning' }, { severity: 'blocker' }],
-    };
-    expect(countAIFindings(output)).toEqual({ blockers: 2, total: 3 });
-  });
-
-  it('uses stats blockers over findings array when stats has blockers', () => {
-    const output = {
-      stats: { blockers: 5 },
-      findings: [{ severity: 'blocker' }, { severity: 'warning' }],
-    };
-    // stats.blockers = 5, total from stats = 5+0+0 = 5, findings not used for total since stats total is non-zero
-    expect(countAIFindings(output)).toEqual({ blockers: 5, total: 5 });
-  });
-
-  it('counts findings length as total when stats has zero total', () => {
-    const output = {
-      findings: [{ severity: 'warning' }, { severity: 'info' }],
-    };
-    expect(countAIFindings(output)).toEqual({ blockers: 0, total: 2 });
-  });
-});
-
-describe('runGate', () => {
-  let tmp: string;
-  let logPath: string;
-
-  beforeEach(() => {
-    tmp = makeTmpDir();
-    logPath = join(tmp, 'gate.log');
-  });
-
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('passes mechanical gate on exit 0', () => {
-    const result = runGate('echo hello', tmp, logPath, 30);
-    expect(result.passed).toBe(true);
-    expect(result.exit_code).toBe(0);
-    expect(result.type).toBe('mechanical');
-    expect(result.output).toContain('hello');
-  });
-
-  it('fails mechanical gate on non-zero exit', () => {
-    const result = runGate('exit 1', tmp, logPath, 30);
-    expect(result.passed).toBe(false);
-    expect(result.exit_code).toBe(1);
-  });
-
-  it('ci-pipeline always passes', () => {
-    const result = runGate({ command: 'anything', type: 'ci-pipeline' }, tmp, logPath, 30);
-    expect(result.passed).toBe(true);
-    expect(result.type).toBe('ci-pipeline');
-    expect(result.output).toBe('CI pipeline gate placeholder');
-  });
-
-  it('empty command passes', () => {
-    const result = runGate({ command: '' }, tmp, logPath, 30);
-    expect(result.passed).toBe(true);
-  });
-
-  it('ai-review gate parses JSON output', () => {
-    const json = JSON.stringify({ stats: { blockers: 0, should_fix: 1 } });
-    const result = runGate({ command: `echo '${json}'`, type: 'ai-review' }, tmp, logPath, 30);
-    expect(result.passed).toBe(true);
-    expect(result.blockers).toBe(0);
-    expect(result.findings).toBe(1);
-  });
-
-  it('ai-review gate fails on blockers', () => {
-    const json = JSON.stringify({ stats: { blockers: 2 } });
-    const result = runGate({ command: `echo '${json}'`, type: 'ai-review' }, tmp, logPath, 30);
-    expect(result.passed).toBe(false);
-    expect(result.blockers).toBe(2);
-  });
-
-  it('ai-review gate with fail_on=any fails on any findings', () => {
-    const json = JSON.stringify({ stats: { blockers: 0, should_fix: 1 } });
-    const result = runGate(
-      { command: `echo '${json}'`, type: 'ai-review', fail_on: 'any' },
-      tmp,
-      logPath,
-      30,
-    );
-    expect(result.passed).toBe(false);
-    expect(result.fail_on).toBe('any');
-  });
-
-  it('ai-review gate fails on invalid JSON output', () => {
-    const result = runGate({ command: 'echo "not json"', type: 'ai-review' }, tmp, logPath, 30);
-    expect(result.passed).toBe(false);
-    expect(result.parse_error).toBeDefined();
-  });
-
-  it('writes to log file', () => {
-    runGate('echo logged', tmp, logPath, 30);
-    const log = readFileSync(logPath, 'utf-8');
-    expect(log).toContain('COMMAND: echo logged');
-    expect(log).toContain('logged');
-    expect(log).toContain('EXIT:');
-  });
-});
-
-describe('runGates', () => {
-  let tmp: string;
-  let logPath: string;
-  let eventsPath: string;
-
-  beforeEach(() => {
-    tmp = makeTmpDir();
-    logPath = join(tmp, 'gates.log');
-    eventsPath = join(tmp, 'events.ndjson');
-  });
-
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('runs multiple gates and returns results', () => {
-    const { allPassed, gateResults } = runGates(
-      ['echo one', 'echo two'],
-      tmp,
-      logPath,
-      30,
-      eventsPath,
-      'task-1',
-    );
-    expect(allPassed).toBe(true);
-    expect(gateResults).toHaveLength(2);
-  });
-
-  it('reports failure when any gate fails', () => {
-    const { allPassed, gateResults } = runGates(
-      ['echo ok', 'exit 1'],
-      tmp,
-      logPath,
-      30,
-      eventsPath,
-      'task-2',
-    );
-    expect(allPassed).toBe(false);
-    expect(gateResults[0]!.passed).toBe(true);
-    expect(gateResults[1]!.passed).toBe(false);
-  });
-
-  it('emits events for each gate', () => {
-    runGates(['echo test'], tmp, logPath, 30, eventsPath, 'task-3');
-    const events = readFileSync(eventsPath, 'utf-8')
-      .trim()
-      .split('\n')
-      .map((l) => JSON.parse(l));
-    expect(events).toHaveLength(2); // started + passed
-    expect(events[0].event_type).toBe('rail.check.started');
-    expect(events[1].event_type).toBe('rail.check.passed');
-  });
-
-  it('skips gates with empty command (non ci-pipeline)', () => {
-    const { gateResults } = runGates(
-      [{ command: '', type: 'mechanical' }, 'echo real'],
-      tmp,
-      logPath,
-      30,
-      eventsPath,
-      'task-4',
-    );
-    expect(gateResults).toHaveLength(1);
-  });
-
-  it('does not skip ci-pipeline even with empty command', () => {
-    const { gateResults } = runGates(
-      [{ command: '', type: 'ci-pipeline' }],
-      tmp,
-      logPath,
-      30,
-      eventsPath,
-      'task-5',
-    );
-    expect(gateResults).toHaveLength(1);
-    expect(gateResults[0]!.passed).toBe(true);
-  });
-
-  it('emits failed event with correct message', () => {
-    runGates(['exit 42'], tmp, logPath, 30, eventsPath, 'task-6');
-    const events = readFileSync(eventsPath, 'utf-8')
-      .trim()
-      .split('\n')
-      .map((l) => JSON.parse(l));
-    const failEvent = events.find(
-      (e: Record<string, unknown>) => e.event_type === 'rail.check.failed',
-    );
-    expect(failEvent).toBeDefined();
-    expect(failEvent.message).toContain('Gate failed (');
-  });
-});
@@ -1,5 +1,8 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, afterEach, beforeEach, vi } from 'vitest';
 import { Command } from 'commander';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { registerMacpCommand } from './cli.js';

 describe('registerMacpCommand', () => {
@@ -75,3 +78,162 @@ describe('registerMacpCommand', () => {
    expect(topLevel).toContain('events');
  });
 });
+
+/**
+ * RI-N2 fail-closed CLI behavior: an unimplemented capability is a failure,
+ * never a success. Every stub exits nonzero with a typed message, and the
+ * implemented `macp gate` mirrors the typed gate-runner states.
+ */
+describe('registerMacpCommand fail-closed (RI-N2)', () => {
+  let tmpDir: string;
+
+  function buildProgram(): Command {
+    const program = new Command();
+    program.exitOverride();
+    program.configureOutput({ writeErr: () => {} });
+    registerMacpCommand(program);
+    return program;
+  }
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'macp-cli-failclosed-'));
+    process.exitCode = 0;
+  });
+
+  afterEach(() => {
+    process.exitCode = 0;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('macp tasks list exits nonzero (unimplemented capability)', async () => {
+    const program = buildProgram();
+    await program.parseAsync(['macp', 'tasks', 'list'], { from: 'user' });
+    expect(process.exitCode).not.toBe(0);
+  });
+
+  it('macp submit exits nonzero with a typed MACP_NOT_IMPLEMENTED message', async () => {
+    const program = buildProgram();
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      await program.parseAsync(['macp', 'submit', 'spec.json'], { from: 'user' });
+      expect(process.exitCode).not.toBe(0);
+      const errText = errSpy.mock.calls.map((c) => String(c[0])).join('\n');
+      expect(errText).toContain('MACP_NOT_IMPLEMENTED');
+    } finally {
+      errSpy.mockRestore();
+    }
+  });
+
+  it('macp events tail exits nonzero (unimplemented capability)', async () => {
+    const program = buildProgram();
+    await program.parseAsync(['macp', 'events', 'tail'], { from: 'user' });
+    expect(process.exitCode).not.toBe(0);
+  });
+
+  it('macp gate runs a green inline command and exits 0', async () => {
+    const program = buildProgram();
+    await program.parseAsync(
+      [
+        'macp',
+        'gate',
+        'exit 0',
+        '--cwd',
+        tmpDir,
+        '--log',
+        path.join(tmpDir, 'g.log'),
+        '--timeout',
+        '10',
+      ],
+      { from: 'user' },
+    );
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('macp gate exits nonzero on a failing command', async () => {
+    const program = buildProgram();
+    await program.parseAsync(
+      [
+        'macp',
+        'gate',
+        'exit 9',
+        '--cwd',
+        tmpDir,
+        '--log',
+        path.join(tmpDir, 'g.log'),
+        '--timeout',
+        '10',
+      ],
+      { from: 'user' },
+    );
+    expect(process.exitCode).not.toBe(0);
+  });
+
+  it('macp gate with an unimplemented ci-pipeline capability exits nonzero', async () => {
+    const program = buildProgram();
+    const specPath = path.join(tmpDir, 'gates.json');
+    fs.writeFileSync(specPath, JSON.stringify([{ type: 'ci-pipeline' }]));
+    await program.parseAsync(
+      [
+        'macp',
+        'gate',
+        specPath,
+        '--cwd',
+        tmpDir,
+        '--log',
+        path.join(tmpDir, 'g.log'),
+        '--timeout',
+        '10',
+      ],
+      { from: 'user' },
+    );
+    expect(process.exitCode).not.toBe(0);
+  });
+
+  it('macp gate --simulate completes (exit 0) but reports simulated results', async () => {
+    const program = buildProgram();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await program.parseAsync(
+        [
+          'macp',
+          'gate',
+          'exit 0',
+          '--simulate',
+          '--cwd',
+          tmpDir,
+          '--log',
+          path.join(tmpDir, 'g.log'),
+          '--timeout',
+          '10',
+        ],
+        { from: 'user' },
+      );
+      // completes only because the caller explicitly asked to simulate
+      expect(process.exitCode).toBe(0);
+      const outText = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
+      expect(outText).toContain('simulated');
+      expect(outText).toContain('SIMULATED');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('macp gate with an empty spec exits nonzero with a typed error', async () => {
+    const program = buildProgram();
+    await program.parseAsync(
+      [
+        'macp',
+        'gate',
+        '   ',
+        '--cwd',
+        tmpDir,
+        '--log',
+        path.join(tmpDir, 'g.log'),
+        '--timeout',
+        '10',
+      ],
+      { from: 'user' },
+    );
+    expect(process.exitCode).not.toBe(0);
+  });
+});
@@ -1,5 +1,73 @@
+import { existsSync, readFileSync } from 'node:fs';
+
 import type { Command } from 'commander';

+import { runGates } from './gate-runner.js';
+import { MACPCapabilityError, type MacpErrorCode } from './errors.js';
+
+/**
+ * Load gates from a spec: an existing file (JSON gates array, a JSON object
+ * with `quality_gates`, a JSON gate object, or one command per line) or an
+ * inline command string. Fails closed with a typed capability error when the
+ * spec contains no executable gate definition.
+ */
+function loadGateSpec(spec: string): unknown[] {
+  if (existsSync(spec)) {
+    const raw = readFileSync(spec, 'utf-8');
+    try {
+      const parsed = JSON.parse(raw) as unknown;
+      if (Array.isArray(parsed)) {
+        if (parsed.length === 0) {
+          throw new MACPCapabilityError(
+            'MACP_NO_COMMAND',
+            'gate-spec',
+            `gate spec file '${spec}' contains an empty gates array`,
+          );
+        }
+        return parsed;
+      }
+      if (typeof parsed === 'object' && parsed !== null) {
+        const obj = parsed as Record<string, unknown>;
+        if (Array.isArray(obj['quality_gates'])) {
+          return obj['quality_gates'];
+        }
+        return [parsed];
+      }
+      throw new MACPCapabilityError(
+        'MACP_NO_COMMAND',
+        'gate-spec',
+        `gate spec file '${spec}' parsed to ${typeof parsed} — expected a gates array, a task with quality_gates, or a gate object`,
+      );
+    } catch (exc) {
+      if (exc instanceof MACPCapabilityError) throw exc;
+      // Not JSON — treat each non-empty line as a command gate.
+      const lines = raw
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+      if (lines.length > 0) return lines;
+      throw new MACPCapabilityError(
+        'MACP_NO_COMMAND',
+        'gate-spec',
+        `gate spec file '${spec}' contains no gates`,
+      );
+    }
+  }
+  if (spec.trim().length > 0) return [spec];
+  throw new MACPCapabilityError('MACP_NO_COMMAND', 'gate-spec', 'gate spec is empty');
+}
+
+/** Print a typed not-implemented failure and exit nonzero (RI-N2 fail-closed). */
+function notImplemented(subcommand: string, capability: string, hint: string): void {
+  const err = new MACPCapabilityError(
+    'MACP_NOT_IMPLEMENTED',
+    capability,
+    `${subcommand} is not implemented in @mosaicstack/macp yet (${capability} capability absent) — ${hint}`,
+  );
+  console.error(`[macp] ${subcommand}: ${err.message} [${err.code}]`);
+  process.exitCode = 1;
+}
+
 /**
 * Register macp subcommands on an existing Commander program.
 * This avoids cross-package Commander version mismatches by using the
@@ -24,15 +92,14 @@ export function registerMacpCommand(parent: Command): void {
      'Filter by task type (coding|deploy|research|review|documentation|infrastructure)',
    )
    .action((opts: { status?: string; type?: string }) => {
-      // not yet wired — task persistence layer is not present in @mosaicstack/macp
-      console.log('[macp] tasks list: not yet wired — use macp package programmatically');
+      // unimplemented capability — a failure, never a success (RI-N2)
      if (opts.status) {
        console.log(`  status filter: ${opts.status}`);
      }
      if (opts.type) {
        console.log(`  type filter: ${opts.type}`);
      }
-      process.exitCode = 0;
+      notImplemented('tasks list', 'task-persistence', 'use the macp package programmatically');
    });

  // ─── submit ──────────────────────────────────────────────────────────────
@@ -41,12 +108,11 @@ export function registerMacpCommand(parent: Command): void {
    .command('submit <path>')
    .description('Submit a task from a JSON/YAML spec file')
    .action((specPath: string) => {
-      // not yet wired — task submission requires a running MACP server
-      console.log('[macp] submit: not yet wired — use macp package programmatically');
+      // unimplemented capability — a failure, never a success (RI-N2)
      console.log(`  spec path: ${specPath}`);
      console.log('  task id:   (unavailable — no MACP server connected)');
      console.log('  status:    (unavailable — no MACP server connected)');
-      process.exitCode = 0;
+      notImplemented('submit', 'macp-server', 'use the macp package programmatically');
    });

  // ─── gate ────────────────────────────────────────────────────────────────
@@ -58,16 +124,58 @@ export function registerMacpCommand(parent: Command): void {
    .option('--cwd <path>', 'Working directory for gate execution', process.cwd())
    .option('--log <path>', 'Path to write gate log output', '/tmp/macp-gate.log')
    .option('--timeout <seconds>', 'Gate timeout in seconds', '60')
-    .action((spec: string, opts: { failOn: string; cwd: string; log: string; timeout: string }) => {
-      // not yet wired — gate execution requires a task context and event sink
-      console.log('[macp] gate: not yet wired — use macp package programmatically');
-      console.log(`  spec:     ${spec}`);
-      console.log(`  fail-on:  ${opts.failOn}`);
-      console.log(`  cwd:      ${opts.cwd}`);
-      console.log(`  log:      ${opts.log}`);
-      console.log(`  timeout:  ${opts.timeout}s`);
-      process.exitCode = 0;
-    });
+    .option(
+      '--simulate',
+      'Simulate gates instead of executing them; results are typed simulated and never satisfy a check',
+    )
+    .action(
+      (
+        spec: string,
+        opts: { failOn: string; cwd: string; log: string; timeout: string; simulate?: boolean },
+      ) => {
+        let gates: unknown[];
+        try {
+          gates = loadGateSpec(spec);
+        } catch (exc) {
+          if (exc instanceof MACPCapabilityError) {
+            console.error(`[macp] gate: ${exc.message} [${exc.code}]`);
+          } else {
+            console.error(`[macp] gate: ${String(exc)}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const timeoutSec = Number.parseInt(opts.timeout, 10) || 60;
+        const eventsPath = `${opts.log}.events.ndjson`;
+        const { state, gateResults } = runGates(
+          gates,
+          opts.cwd,
+          opts.log,
+          timeoutSec,
+          eventsPath,
+          'macp-cli-gate',
+          {
+            simulate: opts.simulate,
+          },
+        );
+
+        for (const r of gateResults) {
+          const label = r.command || r.type;
+          const reason = r.reason ? ` — ${r.reason}` : '';
+          console.log(`[macp] gate ${r.status}: ${label}${reason}`);
+        }
+        if (opts.simulate) {
+          console.log(
+            '[macp] SIMULATED run — every result is typed simulated and can never satisfy a gate, dependency, or release check',
+          );
+        }
+
+        // Simulated runs may complete (exit 0) only because the caller
+        // explicitly passed --simulate; the typed state stays 'simulated'.
+        process.exitCode = state === 'passed' || state === 'simulated' ? 0 : 1;
+      },
+    );

  // ─── events ──────────────────────────────────────────────────────────────

@@ -79,14 +187,16 @@ export function registerMacpCommand(parent: Command): void {
    .option('--file <path>', 'Path to the MACP events NDJSON file')
    .option('--follow', 'Follow the file for new events (like tail -f)')
    .action((opts: { file?: string; follow?: boolean }) => {
-      // not yet wired — event streaming requires a live event source
-      console.log('[macp] events tail: not yet wired — use macp package programmatically');
+      // unimplemented capability — a failure, never a success (RI-N2)
      if (opts.file) {
        console.log(`  file:   ${opts.file}`);
      }
      if (opts.follow) {
        console.log('  mode:   follow');
      }
-      process.exitCode = 0;
+      notImplemented('events tail', 'event-source', 'use the macp package programmatically');
    });
 }
+
+// Re-export so CLI consumers can surface typed capability codes.
+export type { MacpErrorCode };
@@ -0,0 +1,35 @@
+/** Typed error code from the closed MACP_ERROR_CODES set. */
+export type MacpErrorCode = (typeof MACP_ERROR_CODES)[number];
+/**
+ * Typed fail-closed capability errors (RI-N2, SDLC-D-035).
+ *
+ * MACP must fail closed when a required capability (executor, reviewer,
+ * command, CI provider, human authority) is absent. These typed codes mirror
+ * the Forge failure vocabulary (FORGE_NO_*) so both packages speak the same
+ * language: an unimplemented capability is a failure, never a stub success.
+ */
+
+/** Closed set of typed MACP capability error codes. */
+export const MACP_ERROR_CODES = [
+  'MACP_NOT_IMPLEMENTED',
+  'MACP_NO_COMMAND',
+  'MACP_NO_REVIEWER',
+  'MACP_NO_CI_PIPELINE',
+  'MACP_NO_PROVIDER',
+  'MACP_AUTHORITY_REQUIRED',
+] as const;
+
+/** Raised when a required capability is missing and execution must fail closed. */
+export class MACPCapabilityError extends Error {
+  /** Typed error code from the closed MACP_ERROR_CODES set. */
+  readonly code: MacpErrorCode;
+  /** The missing capability, e.g. `ci-provider`, `task-persistence`, `command`. */
+  readonly capability: string;
+
+  constructor(code: MacpErrorCode, capability: string, message: string) {
+    super(message);
+    this.name = 'MACPCapabilityError';
+    this.code = code;
+    this.capability = capability;
+  }
+}
@@ -0,0 +1,429 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { countAIFindings, normalizeGate, runGate, runGates } from './gate-runner.js';
+
+function makeTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'macp-gate-'));
+}
+
+describe('normalizeGate', () => {
+  it('normalizes a string to mechanical gate', () => {
+    expect(normalizeGate('echo test')).toEqual({
+      command: 'echo test',
+      type: 'mechanical',
+      fail_on: 'blocker',
+    });
+  });
+
+  it('normalizes an object gate with defaults', () => {
+    expect(normalizeGate({ command: 'lint' })).toEqual({
+      command: 'lint',
+      type: 'mechanical',
+      fail_on: 'blocker',
+    });
+  });
+
+  it('preserves explicit type and fail_on', () => {
+    expect(normalizeGate({ command: 'review', type: 'ai-review', fail_on: 'any' })).toEqual({
+      command: 'review',
+      type: 'ai-review',
+      fail_on: 'any',
+    });
+  });
+
+  it('handles non-string/non-object input', () => {
+    expect(normalizeGate(42)).toEqual({ command: '', type: 'mechanical', fail_on: 'blocker' });
+    expect(normalizeGate(null)).toEqual({ command: '', type: 'mechanical', fail_on: 'blocker' });
+  });
+});
+
+describe('countAIFindings', () => {
+  it('returns zeros for non-object', () => {
+    expect(countAIFindings(null)).toEqual({ blockers: 0, total: 0 });
+    expect(countAIFindings('string')).toEqual({ blockers: 0, total: 0 });
+    expect(countAIFindings([])).toEqual({ blockers: 0, total: 0 });
+  });
+
+  it('counts from stats block', () => {
+    const output = { stats: { blockers: 2, should_fix: 3, suggestions: 1 } };
+    expect(countAIFindings(output)).toEqual({ blockers: 2, total: 6 });
+  });
+
+  it('counts from findings array when stats has no blockers', () => {
+    const output = {
+      stats: { blockers: 0 },
+      findings: [{ severity: 'blocker' }, { severity: 'warning' }, { severity: 'blocker' }],
+    };
+    expect(countAIFindings(output)).toEqual({ blockers: 2, total: 3 });
+  });
+
+  it('uses stats blockers over findings array when stats has blockers', () => {
+    const output = {
+      stats: { blockers: 5 },
+      findings: [{ severity: 'blocker' }, { severity: 'warning' }],
+    };
+    // stats.blockers = 5, total from stats = 5+0+0 = 5, findings not used for total since stats total is non-zero
+    expect(countAIFindings(output)).toEqual({ blockers: 5, total: 5 });
+  });
+
+  it('counts findings length as total when stats has zero total', () => {
+    const output = {
+      findings: [{ severity: 'warning' }, { severity: 'info' }],
+    };
+    expect(countAIFindings(output)).toEqual({ blockers: 0, total: 2 });
+  });
+});
+
+describe('runGate', () => {
+  let tmp: string;
+  let logPath: string;
+
+  beforeEach(() => {
+    tmp = makeTmpDir();
+    logPath = path.join(tmp, 'gate.log');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('passes mechanical gate on exit 0', () => {
+    const result = runGate('echo hello', tmp, logPath, 30);
+    expect(result.passed).toBe(true);
+    expect(result.exit_code).toBe(0);
+    expect(result.type).toBe('mechanical');
+    expect(result.output).toContain('hello');
+  });
+
+  it('fails mechanical gate on non-zero exit', () => {
+    const result = runGate('exit 1', tmp, logPath, 30);
+    expect(result.passed).toBe(false);
+    expect(result.exit_code).toBe(1);
+  });
+
+  it('ci-pipeline fails closed without a CI provider (no placeholder pass)', () => {
+    const result = runGate({ command: 'anything', type: 'ci-pipeline' }, tmp, logPath, 30);
+    expect(result.passed).toBe(false);
+    expect(result.status).toBe('capability_failure');
+    expect(result.capability_code).toBe('MACP_NO_CI_PIPELINE');
+    expect(result.type).toBe('ci-pipeline');
+    expect(result.output).not.toBe('CI pipeline gate placeholder');
+  });
+
+  it('empty command is a typed capability failure, never a pass', () => {
+    const result = runGate({ command: '' }, tmp, logPath, 30);
+    expect(result.passed).toBe(false);
+    expect(result.status).toBe('capability_failure');
+    expect(result.capability_code).toBe('MACP_NO_COMMAND');
+  });
+
+  it('ai-review gate parses JSON output', () => {
+    const json = JSON.stringify({ stats: { blockers: 0, should_fix: 1 } });
+    const result = runGate({ command: `echo '${json}'`, type: 'ai-review' }, tmp, logPath, 30);
+    expect(result.passed).toBe(true);
+    expect(result.blockers).toBe(0);
+    expect(result.findings).toBe(1);
+  });
+
+  it('ai-review gate fails on blockers', () => {
+    const json = JSON.stringify({ stats: { blockers: 2 } });
+    const result = runGate({ command: `echo '${json}'`, type: 'ai-review' }, tmp, logPath, 30);
+    expect(result.passed).toBe(false);
+    expect(result.blockers).toBe(2);
+  });
+
+  it('ai-review gate with fail_on=any fails on any findings', () => {
+    const json = JSON.stringify({ stats: { blockers: 0, should_fix: 1 } });
+    const result = runGate(
+      { command: `echo '${json}'`, type: 'ai-review', fail_on: 'any' },
+      tmp,
+      logPath,
+      30,
+    );
+    expect(result.passed).toBe(false);
+    expect(result.fail_on).toBe('any');
+  });
+
+  it('ai-review gate fails on invalid JSON output', () => {
+    const result = runGate({ command: 'echo "not json"', type: 'ai-review' }, tmp, logPath, 30);
+    expect(result.passed).toBe(false);
+    expect(result.parse_error).toBeDefined();
+  });
+
+  it('writes to log file', () => {
+    runGate('echo logged', tmp, logPath, 30);
+    const log = fs.readFileSync(logPath, 'utf-8');
+    expect(log).toContain('COMMAND: echo logged');
+    expect(log).toContain('logged');
+    expect(log).toContain('EXIT:');
+  });
+});
+
+describe('runGates', () => {
+  let tmp: string;
+  let logPath: string;
+  let eventsPath: string;
+
+  beforeEach(() => {
+    tmp = makeTmpDir();
+    logPath = path.join(tmp, 'gates.log');
+    eventsPath = path.join(tmp, 'events.ndjson');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('runs multiple gates and returns results', () => {
+    const { allPassed, gateResults } = runGates(
+      ['echo one', 'echo two'],
+      tmp,
+      logPath,
+      30,
+      eventsPath,
+      'task-1',
+    );
+    expect(allPassed).toBe(true);
+    expect(gateResults).toHaveLength(2);
+  });
+
+  it('reports failure when any gate fails', () => {
+    const { allPassed, gateResults } = runGates(
+      ['echo ok', 'exit 1'],
+      tmp,
+      logPath,
+      30,
+      eventsPath,
+      'task-2',
+    );
+    expect(allPassed).toBe(false);
+    expect(gateResults[0]!.passed).toBe(true);
+    expect(gateResults[1]!.passed).toBe(false);
+  });
+
+  it('emits events for each gate', () => {
+    runGates(['echo test'], tmp, logPath, 30, eventsPath, 'task-3');
+    const events = fs
+      .readFileSync(eventsPath, 'utf-8')
+      .trim()
+      .split('\n')
+      .map((l) => JSON.parse(l));
+    expect(events).toHaveLength(2); // started + passed
+    expect(events[0].event_type).toBe('rail.check.started');
+    expect(events[1].event_type).toBe('rail.check.passed');
+  });
+
+  it('does not silently skip gates with empty command — they become capability failures', () => {
+    const { gateResults, allPassed, state } = runGates(
+      [{ command: '', type: 'mechanical' }, 'echo real'],
+      tmp,
+      logPath,
+      30,
+      eventsPath,
+      'task-4',
+    );
+    expect(gateResults).toHaveLength(2);
+    expect(gateResults[0]!.status).toBe('capability_failure');
+    expect(gateResults[1]!.status).toBe('passed');
+    expect(allPassed).toBe(false);
+    expect(state).toBe('capability_failure');
+  });
+
+  it('does not skip ci-pipeline even with empty command — typed capability failure', () => {
+    const { gateResults, allPassed, state } = runGates(
+      [{ command: '', type: 'ci-pipeline' }],
+      tmp,
+      logPath,
+      30,
+      eventsPath,
+      'task-5',
+    );
+    expect(gateResults).toHaveLength(1);
+    expect(gateResults[0]!.passed).toBe(false);
+    expect(gateResults[0]!.status).toBe('capability_failure');
+    expect(allPassed).toBe(false);
+    expect(state).toBe('capability_failure');
+  });
+
+  it('emits failed event with correct message', () => {
+    runGates(['exit 42'], tmp, logPath, 30, eventsPath, 'task-6');
+    const events = fs
+      .readFileSync(eventsPath, 'utf-8')
+      .trim()
+      .split('\n')
+      .map((l) => JSON.parse(l));
+    const failEvent = events.find(
+      (e: Record<string, unknown>) => e.event_type === 'rail.check.failed',
+    );
+    expect(failEvent).toBeDefined();
+    expect(failEvent.message).toContain('Gate failed (');
+  });
+});
+
+/**
+ * RI-N2 / SDLC-D-035 fail-closed controls for the MACP gate runner.
+ *
+ * Invariant under test: `passed: true` occurs ONLY when a gate really executed
+ * and really exited green (`status === 'passed'`). Absent capabilities,
+ * manual sign-offs, and simulated runs are typed distinctly and can never
+ * make the aggregate `passed`.
+ */
+describe('gate-runner fail-closed (RI-N2)', () => {
+  let tmpDir: string;
+  let logPath: string;
+  let eventsPath: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+    logPath = path.join(tmpDir, 'gate.log');
+    eventsPath = path.join(tmpDir, 'events.ndjson');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function run(gates: unknown[], options?: { simulate?: boolean }) {
+    return runGates(gates, tmpDir, logPath, 10, eventsPath, 'spec-task', options);
+  }
+
+  // ─── positive controls ───────────────────────────────────────────────────
+
+  it('a really-executed green command gate still passes', () => {
+    const result = run([{ command: 'exit 0', type: 'mechanical' }]);
+    expect(result.gateResults[0]!.status).toBe('passed');
+    expect(result.gateResults[0]!.passed).toBe(true);
+    expect(result.allPassed).toBe(true);
+    expect(result.state).toBe('passed');
+  });
+
+  it('explicit simulate completes and types every result simulated', () => {
+    const result = run([{ command: 'exit 0', type: 'mechanical' }, 'echo hello'], {
+      simulate: true,
+    });
+    expect(result.gateResults).toHaveLength(2);
+    for (const gate of result.gateResults) {
+      expect(gate.status).toBe('simulated');
+      expect(gate.passed).toBe(false);
+    }
+    expect(result.state).toBe('simulated');
+  });
+
+  it('a really-executed red command gate fails with typed status failed', () => {
+    const result = run([{ command: 'exit 3', type: 'mechanical' }]);
+    expect(result.gateResults[0]!.status).toBe('failed');
+    expect(result.gateResults[0]!.passed).toBe(false);
+    expect(result.allPassed).toBe(false);
+    expect(result.state).toBe('failed');
+  });
+
+  // ─── negative controls — each asserts typed status AND aggregate not passed ──
+
+  it('an empty-command gate is a capability_failure, not skipped and not passed', () => {
+    const result = run([{ command: '', type: 'mechanical' }]);
+    // runGates must not silently skip it — it produces a typed result
+    expect(result.gateResults).toHaveLength(1);
+    const gate = result.gateResults[0]!;
+    expect(gate.status).toBe('capability_failure');
+    expect(gate.capability_code).toBe('MACP_NO_COMMAND');
+    expect(gate.passed).toBe(false);
+    // aggregate is not passed
+    expect(result.allPassed).toBe(false);
+    expect(result.state).toBe('capability_failure');
+    expect(result.state).not.toBe('passed');
+  });
+
+  it('a commandless ai-review gate is a typed MACP_NO_REVIEWER capability_failure', () => {
+    const result = run([{ command: '', type: 'ai-review' }]);
+    expect(result.gateResults[0]!.status).toBe('capability_failure');
+    expect(result.gateResults[0]!.capability_code).toBe('MACP_NO_REVIEWER');
+    expect(result.allPassed).toBe(false);
+    expect(result.state).not.toBe('passed');
+  });
+
+  it('a ci-pipeline gate without a provider implementation is a capability_failure, never a placeholder pass', () => {
+    const result = run([{ command: '', type: 'ci-pipeline' }]);
+    const gate = result.gateResults[0]!;
+    expect(gate.status).toBe('capability_failure');
+    expect(gate.capability_code).toBe('MACP_NO_CI_PIPELINE');
+    expect(gate.passed).toBe(false);
+    // the old false-success placeholder must be gone
+    expect(gate.output).not.toBe('CI pipeline gate placeholder');
+    expect(result.allPassed).toBe(false);
+    expect(result.state).not.toBe('passed');
+  });
+
+  it('a ci-pipeline gate fails closed even alongside an otherwise green run', () => {
+    const result = run(['exit 0', { type: 'ci-pipeline', command: 'fake-ci' }]);
+    expect(result.gateResults[1]!.status).toBe('capability_failure');
+    expect(result.gateResults[0]!.status).toBe('passed');
+    expect(result.allPassed).toBe(false);
+    expect(result.state).toBe('capability_failure');
+  });
+
+  it('a manual gate with no automation enters typed waiting — neither pass nor fail', () => {
+    const result = run([{ type: 'manual' }]);
+    const gate = result.gateResults[0]!;
+    expect(gate.status).toBe('waiting');
+    expect(gate.passed).toBe(false);
+    expect(gate.exit_code).toBe(0);
+    // aggregate is not passed while any gate is waiting
+    expect(result.allPassed).toBe(false);
+    expect(result.state).toBe('waiting');
+    expect(result.state).not.toBe('passed');
+  });
+
+  it('a simulated result can never make the aggregate passed', () => {
+    const result = run(['exit 0', 'exit 0'], { simulate: true });
+    expect(result.gateResults.every((g) => g.status === 'simulated')).toBe(true);
+    expect(result.allPassed).toBe(false);
+    expect(result.state).toBe('simulated');
+    expect(result.state).not.toBe('passed');
+  });
+
+  it('waiting dominates an otherwise green aggregate', () => {
+    const result = run(['exit 0', { type: 'manual' }]);
+    expect(result.allPassed).toBe(false);
+    expect(result.state).toBe('waiting');
+  });
+});
+
+describe('runGate fail-closed (RI-N2)', () => {
+  let tmpDir: string;
+  let logPath: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+    logPath = path.join(tmpDir, 'gate.log');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('simulate: true returns a typed simulated result without executing', () => {
+    const result = runGate('this-command-does-not-exist-xyz', tmpDir, logPath, 10, {
+      simulate: true,
+    });
+    expect(result.status).toBe('simulated');
+    expect(result.passed).toBe(false);
+    expect(result.exit_code).toBe(0);
+  });
+
+  it('normal mode executes for real and types a green gate passed', () => {
+    const result = runGate('echo ok', tmpDir, logPath, 10);
+    expect(result.status).toBe('passed');
+    expect(result.passed).toBe(true);
+    expect(result.output).toContain('ok');
+  });
+
+  it('a bare string gate normalizes to mechanical and executes', () => {
+    const result = runGate('exit 7', tmpDir, logPath, 10);
+    expect(result.type).toBe('mechanical');
+    expect(result.status).toBe('failed');
+    expect(result.passed).toBe(false);
+  });
+});
@@ -4,7 +4,20 @@ import { dirname } from 'node:path';

 import { emitEvent } from './event-emitter.js';
 import { nowISO } from './event-emitter.js';
-import type { GateResult } from './types.js';
+import type { GateResult, GateStatus, RunGatesResult } from './types.js';
+
+/** Typed reason stamped on every simulated gate result. */
+export const SIMULATED_GATE_REASON =
+  'simulated execution (explicit simulate opt-in): gate was not evaluated by a real implementation';
+
+/** Options for gate execution (RI-N2 fail-closed / explicit simulation). */
+export interface RunGateOptions {
+  /**
+   * Explicit caller opt-in to simulation. Simulated gates are NOT executed;
+   * every result is typed `simulated` and never satisfies anything.
+   */
+  simulate?: boolean;
+}

 export interface NormalizedGate {
  command: string;
@@ -103,36 +116,91 @@ export function countAIFindings(parsedOutput: unknown): { blockers: number; tota
  return { blockers, total };
 }

+function simulatedResult(gateEntry: NormalizedGate): GateResult {
+  return {
+    command: gateEntry.command,
+    exit_code: 0,
+    type: gateEntry.type,
+    output: SIMULATED_GATE_REASON,
+    timed_out: false,
+    passed: false,
+    status: 'simulated',
+    reason: SIMULATED_GATE_REASON,
+  };
+}
+
+function capabilityFailureResult(
+  gateEntry: NormalizedGate,
+  code: GateResult['capability_code'],
+  reason: string,
+): GateResult {
+  return {
+    command: gateEntry.command,
+    exit_code: 1,
+    type: gateEntry.type,
+    output: '',
+    timed_out: false,
+    passed: false,
+    status: 'capability_failure',
+    capability_code: code,
+    reason,
+  };
+}
+
+function waitingResult(gateEntry: NormalizedGate, reason: string): GateResult {
+  return {
+    command: gateEntry.command,
+    exit_code: 0,
+    type: gateEntry.type,
+    output: '',
+    timed_out: false,
+    passed: false,
+    status: 'waiting',
+    capability_code: 'MACP_AUTHORITY_REQUIRED',
+    reason,
+  };
+}
+
 export function runGate(
  gate: unknown,
  cwd: string,
  logPath: string,
  timeoutSec: number,
+  options: RunGateOptions = {},
 ): GateResult {
  const gateEntry = normalizeGate(gate);
  const gateType = gateEntry.type;
  const command = gateEntry.command;

+  // Explicit simulation only: never executes, typed simulated, never satisfying.
+  if (options.simulate) {
+    return simulatedResult(gateEntry);
+  }
+
+  // Fail closed: no CI provider implementation exists in @mosaicstack/macp,
+  // so a ci-pipeline gate is an absent capability — never a placeholder pass.
  if (gateType === 'ci-pipeline') {
-    return {
-      command,
-      exit_code: 0,
-      type: gateType,
-      output: 'CI pipeline gate placeholder',
-      timed_out: false,
-      passed: true,
-    };
+    return capabilityFailureResult(
+      gateEntry,
+      'MACP_NO_CI_PIPELINE',
+      `ci-pipeline gate '${gateEntry.command || gateType}' has no CI provider implementation wired — refusing placeholder pass`,
+    );
  }

  if (!command) {
-    return {
-      command: '',
-      exit_code: 0,
-      type: gateType,
-      output: '',
-      timed_out: false,
-      passed: true,
-    };
+    // A manual gate with no automation waits for human sign-off: not pass, not fail.
+    if (gateType === 'manual') {
+      return waitingResult(
+        gateEntry,
+        `manual gate has no automation — waiting for human sign-off (type: ${gateType})`,
+      );
+    }
+    // Any other commandless gate is an absent capability — never a vacuous pass.
+    return capabilityFailureResult(
+      gateEntry,
+      gateType === 'ai-review' ? 'MACP_NO_REVIEWER' : 'MACP_NO_COMMAND',
+      `gate of type '${gateType}' has no command to execute — refusing empty-command pass`,
+    );
  }

  const { exitCode, output, timedOut } = runShell(command, cwd, logPath, timeoutSec);
@@ -143,10 +211,12 @@ export function runGate(
    output,
    timed_out: timedOut,
    passed: false,
+    status: 'failed',
  };

  if (gateType !== 'ai-review') {
    result.passed = exitCode === 0;
+    result.status = result.passed ? 'passed' : 'failed';
    return result;
  }

@@ -170,6 +240,7 @@ export function runGate(
  } else {
    result.passed = exitCode === 0 && blockers === 0 && !timedOut && parseError === undefined;
  }
+  result.status = result.passed ? 'passed' : 'failed';

  result.fail_on = failOn;
  result.blockers = blockers;
@@ -191,16 +262,19 @@ export function runGates(
  timeoutSec: number,
  eventsPath: string,
  taskId: string,
-): { allPassed: boolean; gateResults: GateResult[] } {
-  let allPassed = true;
+  options: RunGateOptions = {},
+): RunGatesResult {
  const gateResults: GateResult[] = [];
+  let hasCapabilityFailure = false;
+  let hasSimulated = false;
+  let hasFailed = false;
+  let hasWaiting = false;

  for (const gate of gates) {
    const gateEntry = normalizeGate(gate);
    const gateCmd = gateEntry.command;
-    if (!gateCmd && gateEntry.type !== 'ci-pipeline') continue;
-
    const label = gateCmd || gateEntry.type;
+    // NOTE: no silent skip — every gate produces a typed result (RI-N2).
    emitEvent(
      eventsPath,
      'rail.check.started',
@@ -209,10 +283,10 @@ export function runGates(
      'quality-gate',
      `Running gate: ${label}`,
    );
-    const result = runGate(gate, cwd, logPath, timeoutSec);
+    const result = runGate(gate, cwd, logPath, timeoutSec, options);
    gateResults.push(result);

-    if (result.passed) {
+    if (result.status === 'passed') {
      emitEvent(
        eventsPath,
        'rail.check.passed',
@@ -224,7 +298,46 @@ export function runGates(
      continue;
    }

-    allPassed = false;
+    if (result.status === 'waiting') {
+      hasWaiting = true;
+      emitEvent(
+        eventsPath,
+        'rail.check.waiting',
+        taskId,
+        'gated',
+        'quality-gate',
+        `Gate waiting: ${label} — ${result.reason ?? 'manual gate awaits sign-off'}`,
+      );
+      continue;
+    }
+
+    if (result.status === 'simulated') {
+      hasSimulated = true;
+      emitEvent(
+        eventsPath,
+        'rail.check.simulated',
+        taskId,
+        'gated',
+        'quality-gate',
+        `Gate simulated (non-satisfying): ${label}`,
+      );
+      continue;
+    }
+
+    if (result.status === 'capability_failure') {
+      hasCapabilityFailure = true;
+      emitEvent(
+        eventsPath,
+        'rail.check.failed',
+        taskId,
+        'gated',
+        'quality-gate',
+        `Gate capability failure (${result.capability_code ?? 'MACP_NO_PROVIDER'}): ${label} — ${result.reason ?? 'required capability is absent'}`,
+      );
+      continue;
+    }
+
+    hasFailed = true;
    let message: string;
    if (result.timed_out) {
      message = `Gate timed out after ${timeoutSec}s: ${label}`;
@@ -236,5 +349,15 @@ export function runGates(
    emitEvent(eventsPath, 'rail.check.failed', taskId, 'gated', 'quality-gate', message);
  }

-  return { allPassed, gateResults };
+  const state: GateStatus = hasCapabilityFailure
+    ? 'capability_failure'
+    : hasSimulated
+      ? 'simulated'
+      : hasFailed
+        ? 'failed'
+        : hasWaiting
+          ? 'waiting'
+          : 'passed';
+
+  return { allPassed: state === 'passed', gateResults, state };
 }
@@ -6,11 +6,13 @@ export type {
  DependsOnPolicy,
  GateType,
  GateFailOn,
+  GateStatus,
  GateEntry,
  Task,
  EventType,
  MACPEvent,
  GateResult,
+  RunGatesResult,
  TaskResult,
  ProviderMeta,
  ProviderRegistry,
@@ -18,6 +20,11 @@ export type {

 export { CredentialError } from './types.js';

+// Typed fail-closed capability errors (RI-N2, SDLC-D-035)
+export { MACP_ERROR_CODES, MACPCapabilityError } from './errors.js';
+
+export type { MacpErrorCode } from './errors.js';
+
 // Credential resolver
 export {
  DEFAULT_CREDENTIALS_DIR,
@@ -35,9 +42,16 @@ export {
 export type { ResolveCredentialsOptions } from './credential-resolver.js';

 // Gate runner
-export { normalizeGate, runShell, countAIFindings, runGate, runGates } from './gate-runner.js';
+export {
+  normalizeGate,
+  runShell,
+  countAIFindings,
+  runGate,
+  runGates,
+  SIMULATED_GATE_REASON,
+} from './gate-runner.js';

-export type { NormalizedGate } from './gate-runner.js';
+export type { NormalizedGate, RunGateOptions } from './gate-runner.js';

 // Risk-floor (agent reflection loop — diff review classifier)
 export { evaluateRiskFloor, DEFAULT_RISK_THRESHOLD } from './risk-floor.js';
@@ -1,3 +1,5 @@
+import type { MacpErrorCode } from './errors.js';
+
 /** Task status values. */
 export type TaskStatus = 'pending' | 'running' | 'gated' | 'completed' | 'failed' | 'escalated';

@@ -17,7 +19,17 @@ export type DispatchMode = 'yolo' | 'acp' | 'exec';
 export type DependsOnPolicy = 'all' | 'any' | 'all_terminal';

 /** Quality gate type. */
-export type GateType = 'mechanical' | 'ai-review' | 'ci-pipeline';
+export type GateType = 'mechanical' | 'ai-review' | 'ci-pipeline' | 'manual';
+
+/**
+ * Typed execution state of a gate — closed set (RI-N2, SDLC-D-035).
+ *
+ * Only `passed` means "really executed and green". `simulated` is produced
+ * exclusively under an explicit simulate opt-in and never satisfies anything.
+ * `capability_failure` means a required executor/provider/command was absent.
+ * `waiting` means a manual gate awaits human sign-off (neither pass nor fail).
+ */
+export type GateStatus = 'passed' | 'failed' | 'simulated' | 'waiting' | 'capability_failure';

 /** Gate fail_on mode. */
 export type GateFailOn = 'blocker' | 'any';
@@ -67,7 +79,9 @@ export type EventType =
  | 'task.retry.scheduled'
  | 'rail.check.started'
  | 'rail.check.passed'
-  | 'rail.check.failed';
+  | 'rail.check.failed'
+  | 'rail.check.waiting'
+  | 'rail.check.simulated';

 /** Structured event record. */
 export interface MACPEvent {
@@ -88,7 +102,14 @@ export interface GateResult {
  type: string;
  output: string;
  timed_out: boolean;
+  /** Back-compat boolean view — true ONLY when `status === 'passed'`. */
  passed: boolean;
+  /** Typed discriminator — the authoritative gate outcome (RI-N2). */
+  status: GateStatus;
+  /** Typed capability error code, set when `status === 'capability_failure'`. */
+  capability_code?: MacpErrorCode;
+  /** Why a non-executed state (simulated/waiting/capability_failure) was reached. */
+  reason?: string;
  fail_on?: string;
  blockers?: number;
  findings?: number;
@@ -96,6 +117,22 @@ export interface GateResult {
  parse_error?: string;
 }

+/**
+ * Aggregate outcome of `runGates` (RI-N2).
+ *
+ * `state` is the typed aggregate: it is `passed` only when every gate really
+ * executed green. A `simulated` result makes the aggregate `simulated` (never
+ * `passed`); a `waiting` manual gate keeps the aggregate `waiting`; a missing
+ * capability makes it `capability_failure`. `allPassed` is exactly
+ * `state === 'passed'`, so a simulated or waiting result can never satisfy a
+ * dependency, acceptance criterion, gate, merge, or release check.
+ */
+export interface RunGatesResult {
+  allPassed: boolean;
+  gateResults: GateResult[];
+  state: GateStatus;
+}
+
 /** Result from a completed task. */
 export interface TaskResult {
  task_id: string;
@@ -39,3 +39,20 @@ packages/mosaic/framework/tools/tmux/test-send-message-verdict.sh | requires rea
 # recorded judgement. These lines ARE that judgement, signed.)
 packages/mosaic/framework/tools/orchestrator/smoke-test.sh | behavior smoke checks for coord continue/run workflows, run manually by orchestrator seats; unmeasured in CI; #1017 burndown
 packages/mosaic/framework/tools/wake/validate-973/microtest-wake-assert.sh | #973 instrument self-test, run as a precondition of the validate-973 evidence procedure rather than as a standing CI suite; #1017 burndown candidate
+
+# --- tools/fleet: precondition is unsatisfiable in the CI image (#1271) ---
+# Signed by fred (sb-it-1-dt, 2026-08-16) at origin/next 476db12.
+# This suite asserts the launcher's behaviour when `mosaic` and `pi` are MISSING.
+# It shims fakes into $FAKE_BIN, but the constructed PANE_PATH always ends in the
+# real system path, so on a host that installs those binaries the missing-binary
+# cases cannot be measured at all. The suite's own guard (line 103) says so and
+# fails rather than reporting a pass it cannot back. That guard is correct.
+# The error was wiring the suite into CI: #1017 (c56483eb) enumerated it and
+# dropped this exclusion, and the CI image provides `pi` in the system path, so
+# it has failed on every pipeline since. Measured 2026-08-16 across pipelines
+# 2444 (#1256), 2438 (#1240) and 2441 (#1017-quality): exactly one FAIL line in
+# each full log, identical, this assertion; control `zzz-not-present-zzz` -> 0.
+# Burn-down and the full measurement are tracked in #1271; unwired by PR #1270.
+# Because test:framework-shell is one && chain and this sat at position 44 of 48,
+# the four suites after it had not run at all since the merge.
+packages/mosaic/framework/tools/fleet/test-start-agent-session.sh | precondition unsatisfiable in the CI image: asserts missing-binary behaviour, but PANE_PATH always ends in the system path and the image provides `pi` there; guard at line 103 fails by design rather than passing unmeasured. Burn down by controlling the tail of PANE_PATH inside the test. NOT by removing `pi` from the image: the CI image installs @earendil-works/[email protected] deliberately (measured in pipeline 2444's test-step log), and other suites depend on that pin. Burn-down tracked in #1271
@@ -25,7 +25,7 @@
    "lint": "eslint src",
    "typecheck": "tsc --noEmit",
    "test": "vitest run --passWithNoTests && pnpm run test:framework-shell",
-    "test:framework-shell": "bash framework/tools/quality/scripts/check-test-enumeration.sh && bash framework/tools/quality/scripts/test-check-test-enumeration.sh && python3 src/lease-broker/daemon_deadline_unittest.py && python3 src/lease-broker/normative_fragments_unittest.py && python3 src/lease-broker/promotion_binding_unittest.py && python3 src/lease-broker/promotion_trigger_unittest.py && python3 src/lease-broker/receipt_challenge_unittest.py && python3 src/lease-broker/context_recovery_unittest.py && python3 src/lease-broker/recovery_runtime_unittest.py && python3 src/lease-broker/recovery_b1_adversarial_unittest.py && python3 src/lease-broker/receipt_observer_client_unittest.py && python3 src/lease-broker/invariant_r_unittest.py && python3 src/lease-broker/framework_skill_portability_unittest.py && python3 src/mutator-gate/runtime_tools_unittest.py && python3 src/mutator-gate/runtime_launch_guard_unittest.py && python3 src/mutator-gate/version_coupling_unittest.py && python3 framework/tools/lease-broker/check-runtime-launches.py --root ../.. && bash framework/tools/codex/test-pr-diff-context.sh && bash framework/tools/qa/test-deps-preflight.sh && bash framework/tools/git/test-pr-review-gitea-comment.sh && bash framework/tools/git/test-pr-review-repo-host-override.sh && bash framework/tools/git/test-ci-queue-wait-branch-absent.sh && bash framework/tools/git/test-ci-queue-wait-tristate.sh && bash framework/tools/git/test-ci-queue-wait-github-checks.sh && bash framework/tools/git/test-pr-merge-queue-branch.sh && bash framework/tools/git/test-pr-merge-head-pin.sh && bash framework/tools/git/test-pr-merge-message-field.sh && bash framework/tools/git/test-git-credential-mosaic.sh && bash framework/tools/git/test-gitea-token-identity.sh && bash framework/tools/woodpecker/test-terminal-green-contract.sh && bash framework/tools/_scripts/test-install-ordering-guard.sh && bash framework/tools/_scripts/test-mosaic-init-rce.sh && bash framework/tools/tmux/agent-send.test.sh && bash framework/tools/wake/test-wake-store-ack.sh && bash framework/tools/wake/test-wake-store-enqueue-race.sh && bash framework/tools/wake/test-wake-digest-hmac.sh && bash framework/tools/wake/test-wake-digest-quarantine.sh && bash framework/tools/wake/test-wake-detector.sh && bash framework/tools/wake/test-wake-fn-oracle.sh && bash framework/tools/wake/test-wake-reconcile.sh && bash framework/tools/wake/test-wake-beacon.sh && bash framework/tools/wake/test-wake-preimage.sh && bash framework/tools/wake/test-wake-install.sh && bash framework/tools/fleet/test-start-agent-session.sh && bash framework/tools/glpi/test-list-http-status.sh && bash framework/tools/orchestrator/test-board-roll.sh && bash framework/tools/woodpecker/test-ci-wait-exit-matrix.sh && bash framework/tools/_scripts/test-fleet-transport-check.sh"
+    "test:framework-shell": "bash framework/tools/quality/scripts/check-test-enumeration.sh && bash framework/tools/quality/scripts/test-check-test-enumeration.sh && python3 src/lease-broker/daemon_deadline_unittest.py && python3 src/lease-broker/normative_fragments_unittest.py && python3 src/lease-broker/promotion_binding_unittest.py && python3 src/lease-broker/promotion_trigger_unittest.py && python3 src/lease-broker/receipt_challenge_unittest.py && python3 src/lease-broker/context_recovery_unittest.py && python3 src/lease-broker/recovery_runtime_unittest.py && python3 src/lease-broker/recovery_b1_adversarial_unittest.py && python3 src/lease-broker/receipt_observer_client_unittest.py && python3 src/lease-broker/invariant_r_unittest.py && python3 src/lease-broker/framework_skill_portability_unittest.py && python3 src/mutator-gate/runtime_tools_unittest.py && python3 src/mutator-gate/runtime_launch_guard_unittest.py && python3 src/mutator-gate/version_coupling_unittest.py && python3 framework/tools/lease-broker/check-runtime-launches.py --root ../.. && bash framework/tools/codex/test-pr-diff-context.sh && bash framework/tools/qa/test-deps-preflight.sh && bash framework/tools/git/test-pr-review-gitea-comment.sh && bash framework/tools/git/test-pr-review-repo-host-override.sh && bash framework/tools/git/test-ci-queue-wait-branch-absent.sh && bash framework/tools/git/test-ci-queue-wait-tristate.sh && bash framework/tools/git/test-ci-queue-wait-github-checks.sh && bash framework/tools/git/test-pr-merge-queue-branch.sh && bash framework/tools/git/test-pr-merge-head-pin.sh && bash framework/tools/git/test-pr-merge-message-field.sh && bash framework/tools/git/test-git-credential-mosaic.sh && bash framework/tools/git/test-gitea-token-identity.sh && bash framework/tools/woodpecker/test-terminal-green-contract.sh && bash framework/tools/_scripts/test-install-ordering-guard.sh && bash framework/tools/_scripts/test-mosaic-init-rce.sh && bash framework/tools/tmux/agent-send.test.sh && bash framework/tools/wake/test-wake-store-ack.sh && bash framework/tools/wake/test-wake-store-enqueue-race.sh && bash framework/tools/wake/test-wake-digest-hmac.sh && bash framework/tools/wake/test-wake-digest-quarantine.sh && bash framework/tools/wake/test-wake-detector.sh && bash framework/tools/wake/test-wake-fn-oracle.sh && bash framework/tools/wake/test-wake-reconcile.sh && bash framework/tools/wake/test-wake-beacon.sh && bash framework/tools/wake/test-wake-preimage.sh && bash framework/tools/wake/test-wake-install.sh && bash framework/tools/glpi/test-list-http-status.sh && bash framework/tools/orchestrator/test-board-roll.sh && bash framework/tools/woodpecker/test-ci-wait-exit-matrix.sh && bash framework/tools/_scripts/test-fleet-transport-check.sh"
  },
  "dependencies": {
    "@mosaicstack/brain": "workspace:*",
@@ -20,7 +20,6 @@ import { registerMissionCommand } from './commands/mission.js';
 import { registerUninstallCommand } from './commands/uninstall.js';
 import { registerRestoreCommand } from './commands/restore.js';
 import { registerSkillCommand } from './commands/skill.js';
-import { registerStoreCommand } from './commands/store.js';
 // prdy is registered via launch.ts
 import { registerLaunchCommands } from './commands/launch.js';
 import { registerLeaseCapabilityProbe } from './commands/lease-activation-probe.js';
@@ -426,10 +425,6 @@ registerRestoreCommand(program);

 registerSkillCommand(program);

-// ─── store ───────────────────────────────────────────────────────────────────
-
-registerStoreCommand(program);
-
 // ─── telemetry ───────────────────────────────────────────────────────────────

 registerTelemetryCommand(program);
@@ -1,458 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { Command } from 'commander';
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  addStoreEntry,
-  getDefaultStorePaths,
-  listStoreEntries,
-  registerStoreCommand,
-  StoreError,
-  storeKindDir,
-  validateStoreKind,
-  validateStoreName,
-  validateStoreVersion,
-  type StorePaths,
-} from './store.js';
-
-/** Assert a typed StoreError with exactly the expected code. */
-function expectStoreError(run: () => unknown, code: string): void {
-  try {
-    run();
-  } catch (error) {
-    expect(error).toBeInstanceOf(StoreError);
-    expect((error as StoreError).code).toBe(code);
-    return;
-  }
-  throw new Error(`expected StoreError ${code}, but nothing threw`);
-}
-
-describe('vetted user store (W-F4)', () => {
-  let root: string;
-  let paths: StorePaths;
-  let sourceRoot: string;
-
-  beforeEach(() => {
-    root = mkdtempSync(join(tmpdir(), 'mosaic-store-cli-'));
-    paths = { userRoot: join(root, '.mosaic') };
-    sourceRoot = join(root, 'sources');
-    mkdirSync(sourceRoot, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  function createSource(name: string): string {
-    const dir = join(sourceRoot, name);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'SKILL.md'), `# ${name}\n`);
-    return dir;
-  }
-
-  describe('name and version validation (before any filesystem call)', () => {
-    const invalidNames = [
-      '../../etc',
-      '/abs/path',
-      'a/b',
-      String.raw`a\b`,
-      '-rf',
-      '..',
-      'safe.',
-      'space name',
-      'line\nbreak',
-      'escape\u001B[31m',
-    ];
-
-    for (const name of invalidNames) {
-      it(`rejects name ${JSON.stringify(name)}`, () => {
-        expect(() => validateStoreName(name)).toThrow(StoreError);
-      });
-    }
-
-    const invalidVersions = ['', '-1', '1..0', 'a/b', '..', '1.0 beta', '/x'];
-    for (const version of invalidVersions) {
-      it(`rejects version ${JSON.stringify(version)}`, () => {
-        expect(() => validateStoreVersion(version)).toThrow(StoreError);
-      });
-    }
-
-    it('accepts semver-shaped versions including prerelease and build metadata', () => {
-      expect(() => validateStoreVersion('0.1.0-beta.1')).not.toThrow();
-      expect(() => validateStoreVersion('1.2.3+build.7')).not.toThrow();
-    });
-
-    it('rejects plural and unknown kinds', () => {
-      expectStoreError(() => validateStoreKind('plugins'), 'STORE_INVALID_KIND');
-      expectStoreError(() => validateStoreKind('widget'), 'STORE_INVALID_KIND');
-    });
-
-    it('accepts the two spec kinds', () => {
-      expect(() => validateStoreKind('plugin')).not.toThrow();
-      expect(() => validateStoreKind('skill')).not.toThrow();
-    });
-  });
-
-  describe('addStoreEntry', () => {
-    it('copies content into a versioned directory and writes the marker last', () => {
-      const result = addStoreEntry(
-        'skill',
-        'demo',
-        '1.0.0',
-        createSource('demo'),
-        'op',
-        undefined,
-        paths,
-      );
-      expect(result.status).toBe('added');
-      const entryPath = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      expect(result.entryPath).toBe(entryPath);
-      expect(existsSync(join(entryPath, 'SKILL.md'))).toBe(true);
-      expect(existsSync(join(entryPath, 'store-entry.json'))).toBe(true);
-      const meta = JSON.parse(readFileSync(join(entryPath, 'store-entry.json'), 'utf-8'));
-      expect(meta).toMatchObject({
-        schema: 1,
-        kind: 'skill',
-        name: 'demo',
-        version: '1.0.0',
-        vettedBy: 'op',
-      });
-      expect(typeof meta['vettedAt']).toBe('string');
-    });
-
-    it('writes plugins under plugins/ and skills under skills/', () => {
-      addStoreEntry('plugin', 'alpha', '0.1.0', createSource('alpha'), 'op', undefined, paths);
-      addStoreEntry('skill', 'beta', '2.0.0', createSource('beta'), 'op', undefined, paths);
-      expect(existsSync(join(paths.userRoot, 'plugins', 'alpha', '0.1.0'))).toBe(true);
-      expect(existsSync(join(paths.userRoot, 'skills', 'beta', '2.0.0'))).toBe(true);
-    });
-
-    it('is append-only: an existing version with a marker is refused, not overwritten', () => {
-      const sourceA = createSource('demo');
-      const sourceB = join(sourceRoot, 'demo-other');
-      mkdirSync(sourceB, { recursive: true });
-      writeFileSync(join(sourceB, 'SKILL.md'), '# changed\n');
-      addStoreEntry('skill', 'demo', '1.0.0', sourceA, 'op', undefined, paths);
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', sourceB, 'op', undefined, paths),
-        'STORE_ALREADY_PRESENT',
-      );
-      expect(
-        readFileSync(join(paths.userRoot, 'skills', 'demo', '1.0.0', 'SKILL.md'), 'utf-8'),
-      ).toBe('# demo\n');
-    });
-
-    it('allows a second version alongside the first', () => {
-      addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths);
-      const result = addStoreEntry(
-        'skill',
-        'demo',
-        '1.1.0',
-        createSource('demo'),
-        'op',
-        undefined,
-        paths,
-      );
-      expect(result.status).toBe('added');
-      expect(readdirSync(join(paths.userRoot, 'skills', 'demo')).sort()).toEqual([
-        '1.0.0',
-        '1.1.0',
-      ]);
-    });
-
-    it('refuses an unmarked target directory by default and preserves its content', () => {
-      const unmarked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      mkdirSync(unmarked, { recursive: true });
-      writeFileSync(join(unmarked, 'SKILL.md'), '# operator content\n');
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths),
-        'STORE_TARGET_UNMARKED',
-      );
-      // The operator's hand-placed content survives the refusal.
-      expect(readFileSync(join(unmarked, 'SKILL.md'), 'utf-8')).toBe('# operator content\n');
-    });
-
-    it('reclaims an unmarked target only under explicit reclaim opt-in', () => {
-      const unmarked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      mkdirSync(unmarked, { recursive: true });
-      writeFileSync(join(unmarked, 'SKILL.md'), '# torn write\n');
-      const result = addStoreEntry(
-        'skill',
-        'demo',
-        '1.0.0',
-        createSource('demo'),
-        'op',
-        undefined,
-        paths,
-        { reclaim: true },
-      );
-      expect(result.status).toBe('reclaimed-unmarked');
-      expect(readFileSync(join(unmarked, 'SKILL.md'), 'utf-8')).toBe('# demo\n');
-    });
-
-    it('reclaim can never destroy a marked, vetted entry (append-only holds under --reclaim)', () => {
-      addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths);
-      const marked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      const vettedContent = readFileSync(join(marked, 'SKILL.md'), 'utf-8');
-      expectStoreError(
-        () =>
-          addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths, {
-            reclaim: true,
-          }),
-        'STORE_ALREADY_PRESENT',
-      );
-      // Load-bearing half: the throw alone does not prove nothing was deleted
-      // before it. Pins the marker-check-before-reclaim-check ordering against
-      // the guard-clause-migrates-upward refactor (review finding on b2124c6).
-      expect(readFileSync(join(marked, 'SKILL.md'), 'utf-8')).toBe(vettedContent);
-      expect(existsSync(join(marked, 'store-entry.json'))).toBe(true);
-    });
-
-    it('refuses a missing source with a typed error', () => {
-      expectStoreError(
-        () =>
-          addStoreEntry('skill', 'demo', '1.0.0', join(sourceRoot, 'nope'), 'op', undefined, paths),
-        'STORE_SOURCE_MISSING',
-      );
-    });
-
-    it('refuses a file (non-directory) source with a typed error', () => {
-      const filePath = join(sourceRoot, 'file.txt');
-      writeFileSync(filePath, 'x');
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', filePath, 'op', undefined, paths),
-        'STORE_SOURCE_NOT_DIR',
-      );
-    });
-
-    it('refuses a symlinked source with a typed error and writes nothing', () => {
-      const real = createSource('demo');
-      const link = join(sourceRoot, 'demo-link');
-      symlinkSync(real, link);
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', link, 'op', undefined, paths),
-        'STORE_SOURCE_SYMLINK',
-      );
-      expect(existsSync(join(paths.userRoot, 'skills', 'demo'))).toBe(false);
-    });
-
-    it('refuses a source tree containing nested symlinks and writes nothing', () => {
-      const src = createSource('demo');
-      const target = join(sourceRoot, 'elsewhere');
-      mkdirSync(target, { recursive: true });
-      symlinkSync(target, join(src, 'escape'));
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', src, 'op', undefined, paths),
-        'STORE_SOURCE_SYMLINK',
-      );
-      expect(existsSync(join(paths.userRoot, 'skills', 'demo'))).toBe(false);
-    });
-
-    it('refuses adding from inside the store itself', () => {
-      const first = addStoreEntry(
-        'skill',
-        'demo',
-        '1.0.0',
-        createSource('demo'),
-        'op',
-        undefined,
-        paths,
-      );
-      expectStoreError(
-        () => addStoreEntry('skill', 'copy', '1.0.0', first.entryPath, 'op', undefined, paths),
-        'STORE_SOURCE_INSIDE_STORE',
-      );
-    });
-
-    it('refuses a symlinked user root ancestor', () => {
-      const linkedRoot = join(sourceRoot, 'linked-mosaic');
-      symlinkSync(paths.userRoot, linkedRoot);
-      expectStoreError(
-        () =>
-          addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, {
-            userRoot: linkedRoot,
-          }),
-        'STORE_SYMLINK_ROOT',
-      );
-    });
-
-    it('requires a non-empty vetting attribution', () => {
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), '  ', undefined, paths),
-        'STORE_INVALID_VETTER',
-      );
-    });
-  });
-
-  describe('listStoreEntries', () => {
-    it('returns empty for an absent store without creating it', () => {
-      expect(listStoreEntries(paths)).toEqual([]);
-      expect(existsSync(paths.userRoot)).toBe(false);
-    });
-
-    it('lists entries deterministically with vetting metadata', () => {
-      addStoreEntry('plugin', 'alpha', '0.1.0', createSource('alpha'), 'fred', undefined, paths);
-      addStoreEntry('skill', 'beta', '2.0.0', createSource('beta'), 'fargo', 'looked fine', paths);
-      addStoreEntry('skill', 'beta', '2.1.0', createSource('beta'), 'fargo', undefined, paths);
-
-      const entries = listStoreEntries(paths);
-      expect(entries.map((e) => `${e.kind}:${e.name}:${e.version}`)).toEqual([
-        'plugin:alpha:0.1.0',
-        'skill:beta:2.0.0',
-        'skill:beta:2.1.0',
-      ]);
-      expect(entries[0]?.meta?.vettedBy).toBe('fred');
-      expect(entries[1]?.meta?.notes).toBe('looked fine');
-    });
-
-    it('classifies markerless version directories as incomplete', () => {
-      addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths);
-      mkdirSync(join(paths.userRoot, 'skills', 'demo', '2.0.0'), { recursive: true });
-      const entries = listStoreEntries(paths, { kind: 'skill', name: 'demo' });
-      expect(entries.find((e) => e.version === '1.0.0')?.status).toBe('vetted');
-      expect(entries.find((e) => e.version === '2.0.0')?.status).toBe('incomplete');
-    });
-
-    it('classifies malformed marker JSON as invalid-metadata, not vetted', () => {
-      addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths);
-      writeFileSync(
-        join(paths.userRoot, 'skills', 'demo', '1.0.0', 'store-entry.json'),
-        '{not json',
-      );
-      const entries = listStoreEntries(paths);
-      expect(entries[0]?.status).toBe('invalid-metadata');
-    });
-
-    it('surfaces foreign files (never mutates them)', () => {
-      mkdirSync(join(paths.userRoot, 'skills'), { recursive: true });
-      writeFileSync(join(paths.userRoot, 'skills', 'stray.txt'), 'x');
-      const entries = listStoreEntries(paths);
-      expect(entries[0]?.status).toBe('foreign');
-      expect(existsSync(join(paths.userRoot, 'skills', 'stray.txt'))).toBe(true);
-    });
-
-    it('filters by kind and name', () => {
-      addStoreEntry('plugin', 'alpha', '0.1.0', createSource('alpha'), 'op', undefined, paths);
-      addStoreEntry('skill', 'beta', '1.0.0', createSource('beta'), 'op', undefined, paths);
-      expect(listStoreEntries(paths, { kind: 'plugin' }).map((e) => e.name)).toEqual(['alpha']);
-      expect(listStoreEntries(paths, { name: 'beta' }).map((e) => e.name)).toEqual(['beta']);
-      expect(() => listStoreEntries(paths, { name: '../escape' })).toThrow(StoreError);
-    });
-  });
-
-  describe('default paths seam', () => {
-    it('honors MOSAIC_USER_HOME', () => {
-      const previous = process.env['MOSAIC_USER_HOME'];
-      try {
-        process.env['MOSAIC_USER_HOME'] = join(root, 'custom-user-home');
-        expect(getDefaultStorePaths().userRoot).toBe(join(root, 'custom-user-home'));
-        expect(storeKindDir('plugin')).toBe(join(root, 'custom-user-home', 'plugins'));
-      } finally {
-        if (previous === undefined) delete process.env['MOSAIC_USER_HOME'];
-        else process.env['MOSAIC_USER_HOME'] = previous;
-      }
-    });
-  });
-
-  describe('CLI', () => {
-    let previousExitCode: string | number | null | undefined;
-
-    beforeEach(() => {
-      previousExitCode = process.exitCode;
-      process.exitCode = undefined;
-    });
-
-    afterEach(() => {
-      process.exitCode = previousExitCode;
-    });
-
-    const parse = (args: string[]) => {
-      const program = new Command().exitOverride();
-      registerStoreCommand(program, paths);
-      return program.parseAsync(['node', 'mosaic', 'store', ...args]);
-    };
-
-    it('registers on the parent program and renders help', () => {
-      const program = new Command().exitOverride();
-      registerStoreCommand(program, paths);
-      const cmd = program.commands.find((c) => c.name() === 'store');
-      expect(cmd).toBeDefined();
-      expect(() => cmd?.helpInformation()).not.toThrow();
-    });
-
-    it('add exits nonzero with a typed code for an invalid name', async () => {
-      await parse([
-        'add',
-        'skill',
-        '../../etc',
-        '1.0.0',
-        '--from',
-        createSource('x'),
-        '--by',
-        'op',
-      ]);
-      expect(process.exitCode).toBe(1);
-    });
-
-    it('add exits nonzero when the kind is plural', async () => {
-      await parse(['add', 'skills', 'demo', '1.0.0', '--from', createSource('demo'), '--by', 'op']);
-      expect(process.exitCode).toBe(1);
-    });
-
-    it('add succeeds and creates the entry directory', async () => {
-      await parse(['add', 'skill', 'demo', '1.0.0', '--from', createSource('demo'), '--by', 'op']);
-      expect(process.exitCode).toBeUndefined();
-      expect(lstatSync(join(paths.userRoot, 'skills', 'demo', '1.0.0')).isDirectory()).toBe(true);
-    });
-
-    it('add requires --by (commander requiredOption)', async () => {
-      await expect(
-        parse(['add', 'skill', 'demo', '1.0.0', '--from', createSource('demo')]),
-      ).rejects.toThrow(/--by/);
-    });
-
-    it('add exits nonzero on an unmarked target without --reclaim, preserving content', async () => {
-      const unmarked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      mkdirSync(unmarked, { recursive: true });
-      writeFileSync(join(unmarked, 'SKILL.md'), '# operator\n');
-      await parse(['add', 'skill', 'demo', '1.0.0', '--from', createSource('demo'), '--by', 'op']);
-      expect(process.exitCode).toBe(1);
-      expect(readFileSync(join(unmarked, 'SKILL.md'), 'utf-8')).toBe('# operator\n');
-    });
-
-    it('add --reclaim replaces the unmarked target and succeeds', async () => {
-      const unmarked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      mkdirSync(unmarked, { recursive: true });
-      writeFileSync(join(unmarked, 'SKILL.md'), '# torn\n');
-      await parse([
-        'add',
-        'skill',
-        'demo',
-        '1.0.0',
-        '--from',
-        createSource('demo'),
-        '--by',
-        'op',
-        '--reclaim',
-      ]);
-      expect(process.exitCode).toBeUndefined();
-      expect(readFileSync(join(unmarked, 'SKILL.md'), 'utf-8')).toBe('# demo\n');
-    });
-
-    it('list exits 0 on an empty store', async () => {
-      await parse(['list']);
-      expect(process.exitCode).toBeUndefined();
-    });
-  });
-});
@@ -1,544 +0,0 @@
-import {
-  cpSync,
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-  type Dirent,
-  type Stats,
-} from 'node:fs';
-import { isAbsolute, join, parse, relative, resolve, sep } from 'node:path';
-import type { Command } from 'commander';
-import { DEFAULT_MOSAIC_USER_HOME } from '../constants.js';
-
-/**
- * `mosaic store` — the vetted user store under `~/.mosaic/{plugins,skills}` (W-F4).
- *
- * Two roots with distinct ownership (HARNESS-HOMES design, frozen REV3):
- * - `~/.config/mosaic/` is the SYSTEM root: update-owned, replaceable wholesale.
- * - `~/.mosaic/` is the USER root: never touched by installs or updates.
- *
- * This module only ever writes under the USER root. The store is the vetting
- * boundary: content lands here only through an explicit `store add` carrying a
- * named vetting attribution, and every entry is versioned
- * (`store/<kind>s/<name>/<version>/`) with a `store-entry.json` marker written
- * LAST — a version directory without its marker is never a usable entry, and
- * an unmarked target is REFUSED by default: it may be this tool's own debris
- * from an interrupted add, or content the operator placed by hand, and the
- * code cannot tell those apart — so deletion happens only under an explicit
- * `--reclaim` opt-in, and the result status names what was done.
- *
- * Deferred by design (W-F6 and later): activation/symlink-install into agent
- * homes, `current`-pointer pinning, network acquisition. `add` accepts a local
- * source path only — no network, no credentials, ever.
- */
-
-export type StoreKind = 'plugin' | 'skill';
-export const STORE_KINDS: readonly StoreKind[] = ['plugin', 'skill'];
-
-/** On-disk metadata marker; written last so its presence commits an entry. */
-export const STORE_ENTRY_MARKER = 'store-entry.json';
-
-export interface StorePaths {
-  /** User data root, e.g. `~/.mosaic`. */
-  userRoot: string;
-}
-
-export interface StoreEntryMeta {
-  schema: 1;
-  kind: StoreKind;
-  name: string;
-  version: string;
-  /** Absolute source path the content was vetted from, as resolved at add time. */
-  sourcePath: string;
-  /** Operator who vouched for the content — required, non-empty. */
-  vettedBy: string;
-  /** ISO timestamp of the add. */
-  vettedAt: string;
-  /** Free-form vetting notes, if any. */
-  notes?: string;
-}
-
-export type StoreAddStatus = 'added' | 'reclaimed-unmarked';
-
-export interface StoreAddResult {
-  kind: StoreKind;
-  name: string;
-  version: string;
-  status: StoreAddStatus;
-  entryPath: string;
-  sourcePath: string;
-}
-
-export type StoreEntryStatus = 'vetted' | 'incomplete' | 'invalid-metadata' | 'foreign';
-
-export interface StoreListEntry {
-  kind: StoreKind;
-  name: string;
-  /** Undefined for name-level foreign files (not a directory at all). */
-  version?: string;
-  status: StoreEntryStatus;
-  entryPath: string;
-  meta?: StoreEntryMeta;
-}
-
-const SAFE_STORE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const SAFE_STORE_VERSION = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
-
-export class StoreError extends Error {
-  public readonly code: string;
-
-  public constructor(code: string, message: string) {
-    super(message);
-    this.name = 'StoreError';
-    this.code = code;
-  }
-}
-
-/** Resolve the user store root while keeping tests injectable. */
-export function getDefaultStorePaths(): StorePaths {
-  const userRoot = process.env['MOSAIC_USER_HOME'] ?? DEFAULT_MOSAIC_USER_HOME;
-  return { userRoot };
-}
-
-/**
- * Reject a user-supplied name before any filesystem operation.
- * A store name identifies one directory under `store/<kind>s/`.
- */
-export function validateStoreName(name: string): void {
-  if (
-    name.length === 0 ||
-    name.startsWith('-') ||
-    name.endsWith('.') ||
-    name.includes('..') ||
-    name.includes('/') ||
-    name.includes('\\') ||
-    isAbsolute(name) ||
-    !SAFE_STORE_NAME.test(name)
-  ) {
-    throw new StoreError(
-      'STORE_INVALID_NAME',
-      `Invalid store name ${JSON.stringify(name)}: use letters, numbers, dots, underscores, or hyphens; start with a letter or number; and do not use paths, "..", or a leading "-".`,
-    );
-  }
-}
-
-/** Versions share the name discipline plus `+` (semver build metadata). */
-export function validateStoreVersion(version: string): void {
-  if (
-    version.length === 0 ||
-    version.startsWith('-') ||
-    version.endsWith('.') ||
-    version.includes('..') ||
-    version.includes('/') ||
-    version.includes('\\') ||
-    isAbsolute(version) ||
-    !SAFE_STORE_VERSION.test(version)
-  ) {
-    throw new StoreError(
-      'STORE_INVALID_VERSION',
-      `Invalid version ${JSON.stringify(version)}: use letters, numbers, dots, underscores, hyphens, or plus; start with a letter or number; and do not use paths, "..", or a leading "-".`,
-    );
-  }
-}
-
-export function validateStoreKind(kind: string): asserts kind is StoreKind {
-  if (!(STORE_KINDS as readonly string[]).includes(kind)) {
-    throw new StoreError(
-      'STORE_INVALID_KIND',
-      `Invalid store kind ${JSON.stringify(kind)}: expected one of ${STORE_KINDS.map((k) => `"${k}"`).join(', ')}.`,
-    );
-  }
-}
-
-function validateVettedBy(vettedBy: string): void {
-  if (vettedBy.trim().length === 0 || vettedBy.includes('\n') || vettedBy.length > 80) {
-    throw new StoreError(
-      'STORE_INVALID_VETTER',
-      'Invalid --by value: name the operator vouching for this content (single line, at most 80 characters).',
-    );
-  }
-}
-
-function lstatIfPresent(path: string): Stats | undefined {
-  try {
-    return lstatSync(path);
-  } catch (error: unknown) {
-    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return undefined;
-    throw error;
-  }
-}
-
-function assertNoSymlinkAncestors(path: string): void {
-  const absolute = resolve(path);
-  const pathRoot = parse(absolute).root;
-  let current = pathRoot;
-
-  for (const segment of relative(pathRoot, absolute).split(sep)) {
-    if (segment.length === 0) continue;
-    current = join(current, segment);
-    const entry = lstatIfPresent(current);
-    if (!entry) break;
-    if (entry.isSymbolicLink()) {
-      throw new StoreError(
-        'STORE_SYMLINK_ROOT',
-        `Refusing symlink ancestor at ${current}; the user store root must resolve without symlink traversal.`,
-      );
-    }
-  }
-}
-
-/** `plugins` for plugin, `skills` for skill — plural on disk per the layout. */
-function kindDirName(kind: StoreKind): string {
-  return kind === 'plugin' ? 'plugins' : 'skills';
-}
-
-export function storeKindDir(kind: StoreKind, paths: StorePaths = getDefaultStorePaths()): string {
-  return join(paths.userRoot, kindDirName(kind));
-}
-
-function entryDir(kind: StoreKind, name: string, version: string, paths: StorePaths): string {
-  return join(storeKindDir(kind, paths), name, version);
-}
-
-function isInsideRoot(candidate: string, root: string): boolean {
-  const rel = relative(resolve(root), resolve(candidate));
-  return rel.length > 0 && rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
-}
-
-/**
- * Refuse any symlink in the source tree — the vetting boundary copies real
- * content only, so a vetted entry can never carry a link that escapes it.
- *
- * NOTE: known check-then-use window between this walk and the `cpSync` below:
- * a symlink created concurrently with the add could slip through. Accepted
- * for a local, operator-run CLI; revisit before any unattended or networked
- * acquisition path exists.
- */
-function assertSourceTreeHasNoSymlinks(sourcePath: string): void {
-  const stack: string[] = [sourcePath];
-  while (stack.length > 0) {
-    const current = stack.pop()!;
-    for (const dirent of readdirSync(current, { withFileTypes: true })) {
-      const child = join(current, dirent.name);
-      if (dirent.isSymbolicLink()) {
-        throw new StoreError(
-          'STORE_SOURCE_SYMLINK',
-          `Refusing to vet content containing a symlink: ${child}. Resolve or remove symlinks before adding to the store.`,
-        );
-      }
-      if (dirent.isDirectory()) stack.push(child);
-    }
-  }
-}
-
-/**
- * Vet and add one versioned entry to the user store.
- *
- * Copies the source directory (real content, no symlinks) to
- * `<userRoot>/<kind>s/<name>/<version>/` and writes the `store-entry.json`
- * marker LAST: a crash mid-copy leaves at most a recoverable partial, never a
- * half-vetted entry that lists as present.
- */
-export function addStoreEntry(
-  kind: StoreKind,
-  name: string,
-  version: string,
-  sourcePath: string,
-  vettedBy: string,
-  notes: string | undefined,
-  paths: StorePaths = getDefaultStorePaths(),
-  options: { reclaim?: boolean } = {},
-): StoreAddResult {
-  validateStoreKind(kind);
-  validateStoreName(name);
-  validateStoreVersion(version);
-  validateVettedBy(vettedBy);
-  assertNoSymlinkAncestors(paths.userRoot);
-
-  const resolvedSource = resolve(sourcePath);
-  const source = lstatIfPresent(resolvedSource);
-  if (!source) {
-    throw new StoreError('STORE_SOURCE_MISSING', `Source path does not exist: ${resolvedSource}`);
-  }
-  if (source.isSymbolicLink()) {
-    throw new StoreError(
-      'STORE_SOURCE_SYMLINK',
-      `Refusing to vet a symlink as store content: ${resolvedSource} (points at ${resolve(sourcePath)}). Add the real directory.`,
-    );
-  }
-  if (!source.isDirectory()) {
-    throw new StoreError(
-      'STORE_SOURCE_NOT_DIR',
-      `Source path is not a directory: ${resolvedSource}`,
-    );
-  }
-  if (isInsideRoot(resolvedSource, paths.userRoot)) {
-    throw new StoreError(
-      'STORE_SOURCE_INSIDE_STORE',
-      `Refusing to add store content from inside the store itself: ${resolvedSource}`,
-    );
-  }
-  assertSourceTreeHasNoSymlinks(resolvedSource);
-
-  const target = entryDir(kind, name, version, paths);
-  const existing = lstatIfPresent(target);
-  let status: StoreAddStatus = 'added';
-  if (existing) {
-    if (existsSync(join(target, STORE_ENTRY_MARKER))) {
-      throw new StoreError(
-        'STORE_ALREADY_PRESENT',
-        `${kind} "${name}" version "${version}" is already present at ${target}; stores are append-only — add a new version instead.`,
-      );
-    }
-    // Unmarked target: either this tool's own debris from an interrupted add,
-    // or content the operator placed by hand — indistinguishable on disk. The
-    // USER root's contract is that tooling never destroys operator content,
-    // so deletion requires the explicit --reclaim opt-in (review finding on
-    // c23a71d7: silent rmSync under a benign-sounding status).
-    if (!options.reclaim) {
-      throw new StoreError(
-        'STORE_TARGET_UNMARKED',
-        `Target exists without ${STORE_ENTRY_MARKER}: ${target}. Refusing to delete unmarked content — if this is debris from an interrupted add, re-run with --reclaim to replace it.`,
-      );
-    }
-    rmSync(target, { recursive: true, force: true });
-    status = 'reclaimed-unmarked';
-  }
-
-  mkdirSync(target, { recursive: true });
-  cpSync(resolvedSource, target, { recursive: true });
-
-  const meta: StoreEntryMeta = {
-    schema: 1,
-    kind,
-    name,
-    version,
-    sourcePath: resolvedSource,
-    vettedBy: vettedBy.trim(),
-    vettedAt: new Date().toISOString(),
-    ...(notes === undefined ? {} : { notes }),
-  };
-  writeFileSync(join(target, STORE_ENTRY_MARKER), `${JSON.stringify(meta, null, 2)}\n`);
-
-  return { kind, name, version, status, entryPath: target, sourcePath: resolvedSource };
-}
-
-function readEntryMeta(markerPath: string): { meta?: StoreEntryMeta; status: StoreEntryStatus } {
-  let raw: string;
-  try {
-    raw = readFileSync(markerPath, 'utf-8');
-  } catch {
-    return { status: 'invalid-metadata' };
-  }
-  try {
-    const parsed = JSON.parse(raw) as StoreEntryMeta;
-    if (
-      parsed?.schema === 1 &&
-      (STORE_KINDS as readonly string[]).includes(parsed.kind) &&
-      typeof parsed.name === 'string' &&
-      typeof parsed.version === 'string' &&
-      typeof parsed.vettedBy === 'string' &&
-      typeof parsed.vettedAt === 'string'
-    ) {
-      return { meta: parsed, status: 'vetted' };
-    }
-  } catch {
-    // fall through
-  }
-  return { status: 'invalid-metadata' };
-}
-
-/**
- * Enumerate every store entry deterministically (kind, then name, then
- * version). Version directories without a marker list as `incomplete`; files
- * where directories were expected list as `foreign` — surfaced, never mutated.
- */
-export function listStoreEntries(
-  paths: StorePaths = getDefaultStorePaths(),
-  filter: { kind?: StoreKind; name?: string } = {},
-): StoreListEntry[] {
-  if (filter.name !== undefined) validateStoreName(filter.name);
-  assertNoSymlinkAncestors(paths.userRoot);
-
-  const kinds = filter.kind ? [filter.kind] : [...STORE_KINDS];
-  const entries: StoreListEntry[] = [];
-
-  for (const kind of kinds) {
-    const kindRoot = lstatIfPresent(storeKindDir(kind, paths));
-    if (!kindRoot) continue;
-    if (!kindRoot.isDirectory()) {
-      entries.push({
-        kind,
-        name: kindDirName(kind),
-        status: 'foreign',
-        entryPath: storeKindDir(kind, paths),
-      });
-      continue;
-    }
-
-    for (const nameDirent of readdirSync(storeKindDir(kind, paths), {
-      withFileTypes: true,
-    }).sort(byName) as Dirent[]) {
-      if (filter.name !== undefined && nameDirent.name !== filter.name) continue;
-      const namePath = join(storeKindDir(kind, paths), nameDirent.name);
-
-      if (!nameDirent.isDirectory()) {
-        entries.push({ kind, name: nameDirent.name, status: 'foreign', entryPath: namePath });
-        continue;
-      }
-
-      const versionDirents = readdirSync(namePath, { withFileTypes: true }).sort(byName);
-      if (versionDirents.length === 0) {
-        entries.push({ kind, name: nameDirent.name, status: 'incomplete', entryPath: namePath });
-        continue;
-      }
-      for (const versionDirent of versionDirents) {
-        const versionPath = join(namePath, versionDirent.name);
-        if (!versionDirent.isDirectory()) {
-          entries.push({
-            kind,
-            name: nameDirent.name,
-            version: versionDirent.name,
-            status: 'foreign',
-            entryPath: versionPath,
-          });
-          continue;
-        }
-        const markerPath = join(versionPath, STORE_ENTRY_MARKER);
-        if (!existsSync(markerPath)) {
-          entries.push({
-            kind,
-            name: nameDirent.name,
-            version: versionDirent.name,
-            status: 'incomplete',
-            entryPath: versionPath,
-          });
-          continue;
-        }
-        const { meta, status } = readEntryMeta(markerPath);
-        entries.push({
-          kind,
-          name: nameDirent.name,
-          version: versionDirent.name,
-          status,
-          entryPath: versionPath,
-          ...(meta === undefined ? {} : { meta }),
-        });
-      }
-    }
-  }
-
-  return entries;
-}
-
-function byName(a: Dirent, b: Dirent): number {
-  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-}
-
-function reportCommandError(error: unknown): void {
-  if (error instanceof StoreError) {
-    console.error(`store: ${error.code}: ${error.message}`);
-  } else {
-    console.error(error instanceof Error ? error.message : String(error));
-  }
-  process.exitCode = 1;
-}
-
-function displayStoreName(name: string): string {
-  return SAFE_STORE_NAME.test(name) ? name : JSON.stringify(name);
-}
-
-/** Register the `mosaic store` command group (W-F4). */
-export function registerStoreCommand(
-  program: Command,
-  paths: StorePaths = getDefaultStorePaths(),
-): void {
-  const store = program
-    .command('store')
-    .description('Manage the vetted user store under ~/.mosaic (plugins, skills)')
-    .configureHelp({ sortSubcommands: true });
-
-  store
-    .command('add <kind> <name> <version>')
-    .description(
-      'Vet and add a local plugin/skill directory to the user store (versioned, append-only)',
-    )
-    .requiredOption('--from <path>', 'Local source directory to vet (no network acquisition)')
-    .requiredOption('--by <operator>', 'Name of the operator vouching for this content')
-    .option('--notes <notes>', 'Vetting notes recorded in the entry metadata')
-    .option(
-      '--reclaim',
-      'Replace an existing UNMARKED target directory (e.g. debris from an interrupted add); refuses without this flag',
-    )
-    .action(
-      async (
-        kind: string,
-        name: string,
-        version: string,
-        opts: {
-          from: string;
-          by: string;
-          notes?: string;
-          reclaim: boolean;
-        },
-      ) => {
-        try {
-          const result = addStoreEntry(
-            kind as StoreKind,
-            name,
-            version,
-            opts.from,
-            opts.by,
-            opts.notes,
-            paths,
-            { reclaim: opts.reclaim },
-          );
-          const suffix =
-            result.status === 'reclaimed-unmarked' ? ' (replaced unmarked directory)' : '';
-          console.log(
-            `${result.kind} ${displayStoreName(result.name)} ${result.version}: added${suffix}`,
-          );
-          console.log(`  entry: ${result.entryPath}`);
-          console.log(`  vetted by ${opts.by.trim()}`);
-        } catch (error: unknown) {
-          reportCommandError(error);
-        }
-      },
-    );
-
-  store
-    .command('list')
-    .description('List store entries with vetting status')
-    .option('--kind <kind>', 'Filter by kind (plugin | skill)')
-    .option('--name <name>', 'Filter by entry name')
-    .action((opts: { kind?: string; name?: string }) => {
-      try {
-        let kind: StoreKind | undefined;
-        if (opts.kind !== undefined) {
-          validateStoreKind(opts.kind);
-          kind = opts.kind;
-        }
-        const entries = listStoreEntries(paths, {
-          ...(kind === undefined ? {} : { kind }),
-          ...(opts.name === undefined ? {} : { name: opts.name }),
-        });
-        if (entries.length === 0) {
-          console.log('No store entries found.');
-          return;
-        }
-        for (const entry of entries) {
-          const version = entry.version ?? '-';
-          const vetter = entry.meta?.vettedBy ?? '-';
-          console.log(
-            `${entry.status.padEnd(17)}${entry.kind.padEnd(8)}${displayStoreName(entry.name).padEnd(24)}${version.padEnd(16)}${vetter}`,
-          );
-        }
-      } catch (error: unknown) {
-        reportCommandError(error);
-      }
-    });
-}
@@ -5,13 +5,6 @@ export const VERSION = '0.0.2';

 export const DEFAULT_MOSAIC_HOME = join(homedir(), '.config', 'mosaic');

-/**
- * USER data root (HARNESS-HOMES two-root split): everything under here is user
- * content — never replaced or removed by installs, updates, or uninstallers.
- * Distinct from the SYSTEM root above, which is update-owned.
- */
-export const DEFAULT_MOSAIC_USER_HOME = join(homedir(), '.mosaic');
-
 export const DEFAULTS = {
  agentName: 'Assistant',
  roleDescription: 'execution partner and visibility engine',
Author	SHA1	Message	Date
fargo	2097379e25	fix(macp): fail-closed typed gate states — no placeholder/empty-command passes (#1275 ) ci/woodpecker/pr/ci Pipeline was successful Details RI-N2 / SDLC-D-035. Every GateResult now carries a typed status discriminator (passed\|failed\|simulated\|waiting\|capability_failure); passed:true remains true only for really-executed, really-green gates. - ci-pipeline without a CI provider → capability_failure (MACP_NO_CI_PIPELINE), never the placeholder pass - empty-command gate → capability_failure (MACP_NO_COMMAND / MACP_NO_REVIEWER), and runGates no longer silently skips it - manual gate type waits (MACP_AUTHORITY_REQUIRED) — neither pass nor fail - explicit simulation only (simulate option / --simulate): typed simulated results can never make the aggregate passed (RunGatesResult.state) - CLI stubs (tasks list, submit, events tail) exit nonzero with typed MACP_NOT_IMPLEMENTED; macp gate is now wired to runGates with --simulate - legacy __tests__/gate-runner.test.ts consolidated into src/gate-runner.spec.ts (root eslint project service does not cover packages/macp/__tests__)	2026-08-17 16:40:16 -05:00
jason.woltje	8199261caa	Merge pull request 'fix(ci): unwire test-start-agent-session.sh, restore its signed exclusion — unblocks every PR on next' (#1270 ) from fix/1269-ci-chain-unblock into next ci/woodpecker/push/publish Pipeline failed Details Reviewed-on: #1270	2026-08-17 20:44:59 +00:00
fred	57a2f2b40e	docs(ci): point the exclusion at tracking issue #1271 , not the closed first filing ci/woodpecker/pr/ci Pipeline was successful Details The first PR for this change was filed under the retired mos-dt-0 principal (pr-create.sh has no --login flag and find_tea_login_for_host returns the first host match) and was closed and refiled as #1270. That left in-tree references pointing at a closed duplicate PR rather than at the burn-down issue, which is the wrong target for them anyway: the open design question belongs on #1271.	2026-08-16 18:03:02 -05:00
fred	93c1de51e1	fix(ci): unwire test-start-agent-session.sh, restore its signed exclusion (#1269 ) ci/woodpecker/pr/ci Pipeline was canceled Details The `test` step has failed on every `next` pipeline since #1017 on exactly one assertion, and it is the same one on unrelated PRs: FAIL: host provides 'pi' in the system path; missing-binary cases are not measurable here (framework/tools/fleet/test-start-agent-session.sh:103) Measured 2026-08-16 across pipelines 2444 (#1256), 2438 (#1240) and 2441 (#1017-quality): exactly one FAIL line in each full log, identical, this line. Control `zzz-not-present-zzz` -> 0 on all three. Cause. #1241 (`5c35a250`) added the guard: the suite shims fake mosaic/pi/npm into $FAKE_BIN, but the constructed PANE_PATH always ends in the real system path, so on a host that installs those binaries the missing-binary cases cannot be measured and a green run would mean nothing. The guard says so instead of passing. Its own pipeline 2430 was green only because the suite was CI-excluded at the time, so the guard had never run in CI. #1017 (`c56483eb`) then enumerated it and dropped the exclusion. The CI image installs @earendil-works/[email protected].1 on purpose, so the precondition is unsatisfiable there. Both commits are mine. The guard is correct and is not being softened. A check that cannot measure its property and reports success is the failure mode this repo has been cataloguing all week; the error was wiring the suite into an image that violates its precondition, so the wiring is what gets reverted. Second effect, which is the reason this cost a day rather than an hour: test:framework-shell is one && chain and this sat at position 44 of 48, so glpi/test-list-http-status.sh, orchestrator/test-board-roll.sh, woodpecker/test-ci-wait-exit-matrix.sh and _scripts/test-fleet-transport-check.sh have not run at all since the merge. The pipeline reported one failure, never "one failure plus four unrun". All four are green when run directly on sb-it-1-dt, so the mask hid nothing broken -- but that is a local result on one host, not a CI-image result. Verification, with controls: - enumeration guard OK (population 52, enumerated 36, signed-excluded 16). - control A, exclusion line removed while unwired -> FAIL UNENUMERATED. - control B, exclusion line kept while rewired -> FAIL CONTRADICTORY EXCLUSION. The gate discriminates in both directions, so its OK is load-bearing. - the four formerly-masked suites: rc=0 each, run directly. - the full chain cannot be run to completion on sb-it-1-dt: it stops earlier, at the lease-broker Invariant R test, because this host carries the quarantined operator-global pi 0.84.2 against a measured 0.84.1. That is host-specific and out of scope here -- CI pins 0.84.1, and the single FAIL line in those three pipelines proves positions 1-43 passed there. Burn-down is to control the tail of PANE_PATH inside the test, not to remove pi from the image. Recorded in the exclusion reason and in #1269.	2026-08-16 17:58:49 -05:00