@principles/pd-cli 1.152.12 → 1.152.14

package/tests/commands/runtime-activation-governance-audit.test.ts

@@ -1,95 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import * as path from 'node:path';
-
-const { mockClose, mockDeactivate, mockWriteGovernanceAction } = vi.hoisted(() => ({
-  mockClose: vi.fn().mockResolvedValue(undefined),
-  mockDeactivate: vi.fn().mockResolvedValue(true),
-  mockWriteGovernanceAction: vi.fn(),
-}));
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn(() => '/workspace'),
-}));
-
-vi.mock('principles-disciple/governance-audit', () => ({
-  writeGovernanceAction: mockWriteGovernanceAction,
-  authorizeGovernanceAction: vi.fn(async (_stateDir, _data, mutation) => mutation()),
-}));
-
-vi.mock('@principles/core/runtime-v2', async (importOriginal) => {
-  const original = await importOriginal() as Record<string, unknown>;
-  return {
-    ...original,
-    RuntimeStateManager: vi.fn().mockImplementation(function () {
-      return {
-        initialize: vi.fn().mockResolvedValue(undefined),
-        close: mockClose,
-        connection: {},
-      };
-    }),
-    SqliteActivationStateStore: vi.fn().mockImplementation(function () {
-      return { deactivateActivation: mockDeactivate };
-    }),
-  };
-});
-
-import { handleRuntimeActivationDeactivate } from '../../src/commands/runtime-activation.js';
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  mockDeactivate.mockResolvedValue(true);
-  process.exitCode = 0;
-});
-
-afterEach(() => {
-  process.exitCode = 0;
-});
-
-describe('deactivate governance audit ordering (PRI-566)', () => {
-  it('durably authorizes the canonical audit event before mutating activation state', async () => {
-    const callOrder: string[] = [];
-    mockWriteGovernanceAction.mockImplementation(() => { callOrder.push('audit'); });
-    mockDeactivate.mockImplementation(async () => { callOrder.push('mutation'); return true; });
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    await handleRuntimeActivationDeactivate({
-      workspace: '/workspace',
-      activationId: 'act-566',
-      reasonCode: 'owner_requested_rollback',
-      json: true,
-    });
-
-    expect(callOrder).toEqual(['audit', 'mutation']);
-    expect(mockWriteGovernanceAction).toHaveBeenCalledWith(path.join(path.resolve('/workspace'), '.pd'), {
-      action: 'deactivate',
-      activationId: 'act-566',
-      actor: 'cli',
-      reasonCode: 'owner_requested_rollback',
-      outcome: 'authorized',
-    });
-    expect(JSON.parse(String(logSpy.mock.calls[0]?.[0]))).toMatchObject({ ok: true, activationId: 'act-566' });
-    logSpy.mockRestore();
-  });
-
-  it('refuses without mutation when the audit event cannot be persisted', async () => {
-    mockWriteGovernanceAction.mockImplementation(() => { throw new Error('disk full'); });
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    await handleRuntimeActivationDeactivate({
-      workspace: '/workspace',
-      activationId: 'act-566',
-      reasonCode: 'owner_requested_rollback',
-      json: true,
-    });
-
-    expect(mockDeactivate).not.toHaveBeenCalled();
-    expect(process.exitCode).toBe(1);
-    expect(logSpy).toHaveBeenCalledTimes(1);
-    expect(JSON.parse(String(logSpy.mock.calls[0]?.[0]))).toMatchObject({
-      ok: false,
-      reason: 'governance_audit_failed: disk full',
-      nextAction: expect.stringMatching(/retry/i),
-    });
-    logSpy.mockRestore();
-  });
-});

package/tests/commands/runtime-activation-list-flag-wiring.test.ts

@@ -1,193 +0,0 @@
-/**
- * Parser-level tests for `pd activation list` flags (CLI gate rule 7).
- *
- * Mirrors `runtime-activation-promote-flag-wiring.test.ts`. Exercises the real
- * `registerRuntimeActivationListCommand` helper (single source of truth
- * shared with `index.ts`). Flag typos in production surface here at
- * parseAsync time, not at handler dispatch.
- *
- * Covers:
- *   - --json is registered
- *   - --workspace / -w and --channel / -c shorthand flags are registered
- *   - --include-deactivated is registered
- *   - --dry-run / --confirm / --no-json are NOT registered
- *
- * Handler-level behavior (filtering, JSON output shape) is covered by
- * runtime-activation.test.ts.
- */
-
-import { describe, it, expect } from 'vitest';
-import { Command } from 'commander';
-
-import { registerRuntimeActivationListCommand } from '../../src/commands/runtime-activation.js';
-
-type ActionOptions = Record<string, unknown>;
-
-interface CapturedAction {
-  opts: ActionOptions | null;
-}
-
-function attachCapture(cmd: Command, state: CapturedAction): void {
-  cmd.action(function captureAction(...args: unknown[]): void {
-    let optsArg: unknown = null;
-    for (let i = args.length - 1; i >= 0; i--) {
-      const arg: unknown = args[i];
-      if (arg !== null && typeof arg === 'object' && !(arg instanceof Command)) {
-        optsArg = arg;
-        break;
-      }
-    }
-    if (optsArg !== null && typeof optsArg === 'object') {
-      state.opts = optsArg as ActionOptions;
-    } else {
-      state.opts = {};
-    }
-  });
-}
-
-function freshProgram(): Command {
-  const program = new Command();
-  program.name('pd').exitOverride();
-  return program;
-}
-
-describe('pd activation list — flag wiring (CLI gate rule 7)', () => {
-  // ── Option metadata ──────────────────────────────────────────────────────
-
-  it('registers --json flag', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-
-    const opt = listCmd.options.find((o) => o.long === '--json');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--json');
-  });
-
-  it('registers -w shorthand for --workspace', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-
-    const opt = listCmd.options.find((o) => o.short === '-w');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--workspace');
-  });
-
-  it('registers -c shorthand for --channel', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-
-    const opt = listCmd.options.find((o) => o.short === '-c');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--channel');
-  });
-
-  it('registers --include-deactivated', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-
-    const opt = listCmd.options.find((o) => o.long === '--include-deactivated');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--include-deactivated');
-  });
-
-  it('does NOT register --dry-run', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-
-    const opt = listCmd.options.find((o) => o.long === '--dry-run');
-    expect(opt).toBeUndefined();
-  });
-
-  it('does NOT register --confirm', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-
-    const opt = listCmd.options.find((o) => o.long === '--confirm');
-    expect(opt).toBeUndefined();
-  });
-
-  it('does NOT register --no-json (no accidental negation)', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-
-    const noForm = listCmd.options.find((o) => o.long === '--no-json');
-    expect(noForm).toBeUndefined();
-  });
-
-  // ── Parser-level tests (program.parseAsync) ───────────────────────────────
-
-  it('parses --json as true', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(listCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'list', '--json']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.json).toBe(true);
-  });
-
-  it('parses -w shorthand for --workspace', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(listCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'list', '-w', '/tmp/test']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.workspace).toBe('/tmp/test');
-  });
-
-  it('parses -c shorthand for --channel', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(listCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'list', '-c', 'prompt']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.channel).toBe('prompt');
-  });
-
-  it('parses --include-deactivated as true', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(listCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'list', '--include-deactivated']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.includeDeactivated).toBe(true);
-  });
-
-  it('defaults all flags to undefined when none passed', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const listCmd = registerRuntimeActivationListCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(listCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'list']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.json).toBeUndefined();
-    expect(captured.opts?.workspace).toBeUndefined();
-    expect(captured.opts?.channel).toBeUndefined();
-    expect(captured.opts?.includeDeactivated).toBeUndefined();
-  });
-});

package/tests/commands/runtime-activation-promote-flag-wiring.test.ts

@@ -1,248 +0,0 @@
-/**
- * Parser-level tests for `pd activation promote` flags (CLI gate rule 7).
- *
- * Mirrors `run-rulehost-flag-wiring.test.ts`. Exercises the real
- * `registerRuntimeActivationPromoteCommand` helper (single source of truth
- * shared with `index.ts`). Flag typos in production surface here at
- * parseAsync time, not at handler dispatch.
- *
- * Covers:
- *   - --dry-run and --confirm are registered
- *   - --json is registered
- *   - --activation-id is required (Commander rejects missing required option)
- *   - --workspace / -w shorthand is registered
- *   - --no-dry-run / --no-confirm are NOT registered (no accidental negation)
- *
- * Handler-level behavior (mutual exclusivity enforcement, JSON output shape,
- * refusal reasons) is covered by runtime-activation.test.ts.
- */
-
-import { describe, it, expect } from 'vitest';
-import { Command } from 'commander';
-
-import { registerRuntimeActivationPromoteCommand } from '../../src/commands/runtime-activation.js';
-
-type ActionOptions = Record<string, unknown>;
-
-interface CapturedAction {
-  opts: ActionOptions | null;
-}
-
-function attachCapture(cmd: Command, state: CapturedAction): void {
-  cmd.action(function captureAction(...args: unknown[]): void {
-    let optsArg: unknown = null;
-    for (let i = args.length - 1; i >= 0; i--) {
-      const arg: unknown = args[i];
-      if (arg !== null && typeof arg === 'object' && !(arg instanceof Command)) {
-        optsArg = arg;
-        break;
-      }
-    }
-    if (optsArg !== null && typeof optsArg === 'object') {
-      state.opts = optsArg as ActionOptions;
-    } else {
-      state.opts = {};
-    }
-  });
-}
-
-function freshProgram(): Command {
-  const program = new Command();
-  program.name('pd').exitOverride();
-  return program;
-}
-
-describe('pd activation promote — flag wiring (CLI gate rule 7)', () => {
-  // ── Option metadata ──────────────────────────────────────────────────────
-
-  it('registers --dry-run flag', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-
-    const opt = promoteCmd.options.find((o) => o.long === '--dry-run');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--dry-run');
-  });
-
-  it('registers --confirm flag', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-
-    const opt = promoteCmd.options.find((o) => o.long === '--confirm');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--confirm');
-  });
-
-  it('registers --json flag', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-
-    const opt = promoteCmd.options.find((o) => o.long === '--json');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--json');
-  });
-
-  it.each(['--artifact-id', '--artifact-digest', '--control-version', '--idempotency-key', '--reason', '--note'])(
-    'registers Owner authority binding option %s', (flag) => {
-      const program = freshProgram();
-      const promoteCmd = registerRuntimeActivationPromoteCommand(program.command('activation'));
-      expect(promoteCmd.options.find(option => option.long === flag)).toBeDefined();
-    },
-  );
-
-  it('registers --activation-id as required option', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-
-    const opt = promoteCmd.options.find((o) => o.long === '--activation-id');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--activation-id');
-    expect(opt?.required).toBe(true);
-  });
-
-  it('registers -w shorthand for --workspace', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-
-    const opt = promoteCmd.options.find((o) => o.short === '-w');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--workspace');
-  });
-
-  it('does NOT register --no-dry-run (no accidental negation)', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-
-    const noForm = promoteCmd.options.find((o) => o.long === '--no-dry-run');
-    expect(noForm).toBeUndefined();
-  });
-
-  it('does NOT register --no-confirm (no accidental negation)', () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-
-    const noForm = promoteCmd.options.find((o) => o.long === '--no-confirm');
-    expect(noForm).toBeUndefined();
-  });
-
-  // ── Parser-level tests (program.parseAsync) ───────────────────────────────
-
-  it('parses --dry-run as true', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(promoteCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'promote', '--activation-id', 'act-1', '--dry-run']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.dryRun).toBe(true);
-  });
-
-  it('parses --confirm as true', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(promoteCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'promote', '--activation-id', 'act-1', '--confirm']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.confirm).toBe(true);
-  });
-
-  it('parses both --dry-run and --confirm (handler enforces mutual exclusivity)', async () => {
-    // Commander parses both flags; the handler validates mutual exclusivity.
-    // This test proves the parser accepts both — the handler test in
-    // runtime-activation.test.ts proves the handler rejects the combination.
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(promoteCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'promote', '--activation-id', 'act-1', '--dry-run', '--confirm']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.dryRun).toBe(true);
-    expect(captured.opts?.confirm).toBe(true);
-  });
-
-  it('defaults --dry-run and --confirm to undefined when neither is passed', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(promoteCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'promote', '--activation-id', 'act-1']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.dryRun).toBeUndefined();
-    expect(captured.opts?.confirm).toBeUndefined();
-  });
-
-  it('parses --json as true', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(promoteCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'promote', '--activation-id', 'act-1', '--json']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.json).toBe(true);
-  });
-
-  it('parses -w shorthand for --workspace', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    const promoteCmd = registerRuntimeActivationPromoteCommand(activationCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(promoteCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'activation', 'promote', '--activation-id', 'act-1', '-w', '/tmp/test']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.workspace).toBe('/tmp/test');
-  });
-
-  it('parses all Owner authority binding values through the real command', async () => {
-    const program = freshProgram();
-    const promoteCmd = registerRuntimeActivationPromoteCommand(program.command('activation'));
-    const captured: CapturedAction = { opts: null };
-    attachCapture(promoteCmd, captured);
-
-    await program.parseAsync([
-      'node', 'pd', 'activation', 'promote', '--activation-id', 'act-1',
-      '--artifact-id', 'art-1', '--artifact-digest', 'sha256:one', '--control-version', '7',
-      '--idempotency-key', 'idem-1', '--reason', 'owner_review', '--note', 'reviewed', '--confirm',
-    ]);
-
-    expect(captured.opts).toMatchObject({
-      artifactId: 'art-1', artifactDigest: 'sha256:one', controlVersion: 7,
-      idempotencyKey: 'idem-1', reason: 'owner_review', note: 'reviewed', confirm: true,
-    });
-  });
-
-  it('rejects missing --activation-id (required option)', async () => {
-    const program = freshProgram();
-    const activationCmd = program.command('activation');
-    registerRuntimeActivationPromoteCommand(activationCmd);
-
-    // Commander should throw on missing required option
-    await expect(
-      program.parseAsync(['node', 'pd', 'activation', 'promote', '--dry-run']),
-    ).rejects.toThrow(/activation-id/);
-  });
-});

package/tests/commands/runtime-activation-shadow-telemetry.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import {
-  collectRuleCodeEventEntries,
-  readShadowSummaryForActivation,
-} from '../../src/commands/runtime-activation.js';
-
-/**
- * PRI-577 regression tests — RuleCode shadow telemetry directory mismatch.
- *
- * Production writes rulehost_evaluated events to `{workspace}/.state/logs/` via the
- * v1 EventLog component, while the reader used to scan only `{workspace}/.pd/logs/`
- * (a directory no production code ever creates). These tests pin the real-world
- * directory layout so a future refactor cannot silently re-break the channel.
- */
-
-const ACTIVATION_ID = 'act_code_test-rule';
-
-function makeEventLine(eventOverrides: Record<string, unknown> = {}, dataOverrides: Record<string, unknown> = {}): string {
-  return JSON.stringify({
-    ts: '2026-08-21T00:47:00.469Z',
-    type: 'rulehost_evaluated',
-    category: 'evaluated',
-    data: {
-      toolName: 'write_file',
-      filePath: '<redacted>',
-      matched: true,
-      decision: 'block',
-      ruleId: 'rule-1',
-      activationId: ACTIVATION_ID,
-      activationMode: 'shadow',
-      ...dataOverrides,
-    },
-    ...eventOverrides,
-  });
-}
-
-describe('PRI-577 shadow telemetry dual-directory reading', () => {
-  let workspaceDir: string;
-
-  beforeEach(() => {
-    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pri577-ws-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(workspaceDir, { recursive: true, force: true });
-  });
-
-  function writeEventsFile(relLogsDir: string, date: string, lines: string[]): void {
-    const dir = path.join(workspaceDir, ...relLogsDir.split('/'));
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, `events_${date}.jsonl`), lines.join('\n') + '\n', 'utf8');
-  }
-
-  it('reads shadow metrics when events live only in legacy .state/logs (production layout)', () => {
-    writeEventsFile('.state/logs', '2026-08-21', [
-      makeEventLine(),
-      makeEventLine({}, { toolName: 'exec', filePath: 'x', matched: false, decision: 'allow' }),
-    ]);
-
-    const summary = readShadowSummaryForActivation(workspaceDir, ACTIVATION_ID);
-    expect(summary.observed).toBe(2);
-    expect(summary.matched).toBe(1);
-    expect(summary.wouldBlock).toBe(1);
-    expect(summary.firstObservedAt).not.toBeNull();
-  });
-
-  it('merges entries when both .pd/logs and .state/logs exist', () => {
-    writeEventsFile('.state/logs', '2026-08-21', [makeEventLine()]);
-    writeEventsFile('.pd/logs', '2026-08-22', [
-      makeEventLine({ ts: '2026-08-22T10:00:00.000Z' }),
-    ]);
-    const summary = readShadowSummaryForActivation(workspaceDir, ACTIVATION_ID);
-    expect(summary.observed).toBe(2);
-    expect(summary.lastObservedAt).toBe('2026-08-22T10:00:00.000Z');
-  });
-
-  it('keeps distinct events from same-named daily files and deduplicates exact copied lines', () => {
-    const copied = makeEventLine();
-    writeEventsFile('.state/logs', '2026-08-21', [
-      copied,
-      makeEventLine({}, { toolName: 'exec', filePath: 'x', matched: false, decision: 'allow' }),
-    ]);
-    writeEventsFile('.pd/logs', '2026-08-21', [copied]);
-
-    const summary = readShadowSummaryForActivation(workspaceDir, ACTIVATION_ID);
-    expect(summary.observed).toBe(2);
-    expect(summary.wouldAllow).toBe(1);
-  });
-
-  it('reports zero (not unavailable) when a log dir exists but has no matching events', () => {
-    writeEventsFile('.state/logs', '2026-08-21', [
-      JSON.stringify({ ts: '2026-08-21T00:00:00.000Z', type: 'other_event', category: 'x', data: {} }),
-    ]);
-
-    const summary = readShadowSummaryForActivation(workspaceDir, ACTIVATION_ID);
-    // Distinguishes "channel alive, no data" (zeros) from "no channel" (nulls).
-    expect(summary.observed).toBe(0);
-    expect(summary.matched).toBe(0);
-  });
-
-  it('returns unavailable summary only when neither candidate directory exists', () => {
-    const summary = readShadowSummaryForActivation(workspaceDir, ACTIVATION_ID);
-    expect(summary).toEqual({
-      observed: null, matched: null, wouldBlock: null, wouldAllow: null,
-      requireApproval: null, autoCorrect: null, errors: null, neutralControl: null,
-      firstObservedAt: null, lastObservedAt: null,
-    });
-  });
-
-  it('does not report an unreadable candidate path as a healthy zero-event channel', () => {
-    fs.mkdirSync(path.join(workspaceDir, '.state'), { recursive: true });
-    fs.writeFileSync(path.join(workspaceDir, '.state', 'logs'), 'not a directory');
-    const summary = readShadowSummaryForActivation(workspaceDir, ACTIVATION_ID);
-    expect(summary.observed).toBeNull();
-  });
-
-  it('excludes malformed telemetry lines instead of failing the whole scan', () => {
-    writeEventsFile('.state/logs', '2026-08-21', [
-      '{not-valid-json',
-      makeEventLine(),
-    ]);
-
-    const collected = collectRuleCodeEventEntries(workspaceDir);
-    expect(collected.entries.length).toBe(1);
-    expect(collected.sourceDirsFound).toBeGreaterThanOrEqual(1);
-  });
-});