@principles/pd-cli 1.152.12 → 1.152.14

package/tests/commands/runtime.test.ts

@@ -1,392 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleRuntimeProbe, type RuntimeProbeOptions } from '../../src/commands/runtime.js';
-
-// Mock resolveRuntimeWithOverrides
-const { mockResolveRuntimeWithOverrides } = vi.hoisted(() => {
-  const fn = vi.fn().mockReturnValue({
-    result: {
-      runtimeKind: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      apiKeyEnv: 'TEST_API_KEY',
-      maxRetries: 2,
-      timeoutMs: 180_000,
-    },
-    mergedConfig: {
-      runtimeKind: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      apiKeyEnv: 'TEST_API_KEY',
-      maxRetries: 2,
-      timeoutMs: 180_000,
-    },
-    legacyWarnings: [],
-    configSource: '.pd/config.yaml',
-    configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
-  });
-  return { mockResolveRuntimeWithOverrides: fn };
-});
-
-vi.mock('../../src/services/resolve-runtime-from-pd-config.js', () => ({
-  resolveRuntimeWithOverrides: mockResolveRuntimeWithOverrides,
-}));
-
-vi.mock('@principles/core/runtime-v2', () => ({
-  probeRuntime: vi.fn().mockResolvedValue({
-    runtimeKind: 'openclaw-cli',
-    health: {
-      healthy: true,
-      degraded: false,
-      warnings: [],
-      lastCheckedAt: '2026-04-24T00:00:00.000Z',
-    },
-    capabilities: {
-      supportsStructuredJsonOutput: true,
-      supportsToolUse: false,
-      supportsWorkingDirectory: false,
-      supportsModelSelection: false,
-      supportsLongRunningSessions: false,
-      supportsCancellation: true,
-      supportsArtifactWriteBack: false,
-      supportsConcurrentRuns: false,
-      supportsStreaming: false,
-    },
-  }),
-  resolveRuntimeConfig: vi.fn().mockReturnValue({
-    runtimeKind: 'pi-ai',
-    provider: 'test-provider',
-    model: 'test-model',
-    apiKeyEnv: 'TEST_KEY',
-    timeoutMs: 300000,
-    agentId: 'main',
-  }),
-  isRuntimeConfigError: vi.fn().mockReturnValue(false),
-  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
-  PDRuntimeError: class PDRuntimeError extends Error {
-    constructor(public category: string, message: string) {
-      super(message);
-      this.name = 'PDRuntimeError';
-    }
-  },
-}));
-
-describe('pd runtime probe', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('HG-01: --runtime openclaw-cli --openclaw-local outputs health + capabilities table', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    await handleRuntimeProbe({
-      runtime: 'openclaw-cli',
-      openclawLocal: true,
-      json: false,
-    } as RuntimeProbeOptions);
-
-    // Should output health section
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Runtime:'));
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('healthy:'));
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Capabilities:'));
-    expect(exitSpy).not.toHaveBeenCalledWith(1);
-
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('HG-01: --runtime openclaw-cli --openclaw-gateway outputs health + capabilities table', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    await handleRuntimeProbe({
-      runtime: 'openclaw-cli',
-      openclawGateway: true,
-      json: false,
-    } as RuntimeProbeOptions);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Runtime:'));
-    expect(exitSpy).not.toHaveBeenCalledWith(1);
-
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('CLI-03: --json flag outputs structured JSON with health + capabilities', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    await handleRuntimeProbe({
-      runtime: 'openclaw-cli',
-      openclawLocal: true,
-      json: true,
-    } as RuntimeProbeOptions);
-
-    const jsonOutput = consoleSpy.mock.calls.find(call => {
-      try {
-        JSON.parse(call[0] as string);
-        return true;
-      } catch { return false; }
-    });
-    expect(jsonOutput).toBeDefined();
-    const parsed = JSON.parse((jsonOutput as [string])[0]);
-    expect(parsed.status).toBe('succeeded');
-    expect(parsed.runtimeKind).toBe('openclaw-cli');
-    expect(parsed.health).toBeDefined();
-    expect(parsed.capabilities).toBeDefined();
-    expect(exitSpy).not.toHaveBeenCalledWith(1);
-
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('CLI-03: --json with healthy=false outputs status=failed and exits 1', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    const { probeRuntime } = await import('@principles/core/runtime-v2');
-    vi.mocked(probeRuntime).mockResolvedValueOnce({
-      runtimeKind: 'openclaw-cli',
-      health: {
-        healthy: false,
-        degraded: false,
-        warnings: ['openclaw binary not found'],
-        lastCheckedAt: '2026-04-24T00:00:00.000Z',
-      },
-      capabilities: {
-        supportsStructuredJsonOutput: true,
-        supportsToolUse: false,
-        supportsWorkingDirectory: false,
-        supportsModelSelection: false,
-        supportsLongRunningSessions: false,
-        supportsCancellation: true,
-        supportsArtifactWriteBack: false,
-        supportsConcurrentRuns: false,
-        supportsStreaming: false,
-      },
-    });
-
-    await handleRuntimeProbe({
-      runtime: 'openclaw-cli',
-      openclawLocal: true,
-      json: true,
-    } as RuntimeProbeOptions);
-
-    const jsonOutput = consoleSpy.mock.calls.find(call => {
-      try {
-        const p = JSON.parse(call[0] as string);
-        return p.status !== undefined;
-      } catch { return false; }
-    });
-    expect(jsonOutput).toBeDefined();
-    const parsed = JSON.parse((jsonOutput as [string])[0]);
-    expect(parsed.status).toBe('failed');
-    expect(exitSpy).toHaveBeenCalledWith(1);
-
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('CLI-03: --json with healthy=true degraded=true outputs status=degraded', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    const { probeRuntime } = await import('@principles/core/runtime-v2');
-    vi.mocked(probeRuntime).mockResolvedValueOnce({
-      runtimeKind: 'openclaw-cli',
-      health: {
-        healthy: true,
-        degraded: true,
-        warnings: ['openclaw version is outdated'],
-        lastCheckedAt: '2026-04-24T00:00:00.000Z',
-      },
-      capabilities: {
-        supportsStructuredJsonOutput: true,
-        supportsToolUse: false,
-        supportsWorkingDirectory: false,
-        supportsModelSelection: false,
-        supportsLongRunningSessions: false,
-        supportsCancellation: true,
-        supportsArtifactWriteBack: false,
-        supportsConcurrentRuns: false,
-        supportsStreaming: false,
-      },
-    });
-
-    await handleRuntimeProbe({
-      runtime: 'openclaw-cli',
-      openclawLocal: true,
-      json: true,
-    } as RuntimeProbeOptions);
-
-    const jsonOutput = consoleSpy.mock.calls.find(call => {
-      try {
-        const p = JSON.parse(call[0] as string);
-        return p.status !== undefined;
-      } catch { return false; }
-    });
-    expect(jsonOutput).toBeDefined();
-    const parsed = JSON.parse((jsonOutput as [string])[0]);
-    expect(parsed.status).toBe('degraded');
-    expect(exitSpy).not.toHaveBeenCalledWith(1);
-
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('HG-03: --runtime openclaw-cli without mode flag exits with error', async () => {
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    await handleRuntimeProbe({
-      runtime: 'openclaw-cli',
-      json: false,
-    } as RuntimeProbeOptions);
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      'error: --openclaw-local or --openclaw-gateway is required for --runtime openclaw-cli'
-    );
-    expect(exitSpy).toHaveBeenCalledWith(1);
-
-    consoleErrorSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('HG-03: both --openclaw-local and --openclaw-gateway exits with error', async () => {
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    await handleRuntimeProbe({
-      runtime: 'openclaw-cli',
-      openclawLocal: true,
-      openclawGateway: true,
-      json: false,
-    } as RuntimeProbeOptions);
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      'error: --openclaw-local and --openclaw-gateway are mutually exclusive'
-    );
-    expect(exitSpy).toHaveBeenCalledWith(1);
-
-    consoleErrorSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('HG-01: --runtime other-than-openclaw-cli exits with error', async () => {
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    await handleRuntimeProbe({
-      runtime: 'test-double',
-      json: false,
-    } as RuntimeProbeOptions);
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      expect.stringContaining("unsupported")
-    );
-    expect(exitSpy).toHaveBeenCalledWith(1);
-
-    consoleErrorSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  // ── pi-ai probe: maxRetries backfill from .pd/config.yaml ───────────────
-  it('PRI-393: pi-ai probe reads maxRetries from .pd/config.yaml when --maxRetries not passed', async () => {
-    process.env.TEST_API_KEY = 'test-value';
-    const { probeRuntime } = await import('@principles/core/runtime-v2');
-    vi.mocked(probeRuntime).mockResolvedValue({
-      runtimeKind: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      health: { healthy: true, degraded: false, warnings: [], lastCheckedAt: '2026-06-14T00:00:00.000Z' },
-      capabilities: {},
-    });
-
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    // mockResolveRuntimeWithOverrides returns maxRetries: 2
-    // No --maxRetries CLI flag
-    await handleRuntimeProbe({
-      runtime: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      apiKeyEnv: 'TEST_API_KEY',
-      workspace: '/tmp/ws',
-      json: true,
-    } as RuntimeProbeOptions);
-
-    expect(vi.mocked(probeRuntime)).toHaveBeenCalledWith(
-      expect.objectContaining({ maxRetries: 2 }),
-    );
-
-    delete process.env.TEST_API_KEY;
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('PRI-393: CLI --maxRetries overrides .pd/config.yaml maxRetries', async () => {
-    process.env.TEST_API_KEY = 'test-value';
-    const { probeRuntime } = await import('@principles/core/runtime-v2');
-    vi.mocked(probeRuntime).mockResolvedValue({
-      runtimeKind: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      health: { healthy: true, degraded: false, warnings: [], lastCheckedAt: '2026-06-14T00:00:00.000Z' },
-      capabilities: {},
-    });
-
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    await handleRuntimeProbe({
-      runtime: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      apiKeyEnv: 'TEST_API_KEY',
-      maxRetries: 5,
-      workspace: '/tmp/ws',
-      json: true,
-    } as RuntimeProbeOptions);
-
-    expect(vi.mocked(probeRuntime)).toHaveBeenCalledWith(
-      expect.objectContaining({ maxRetries: 5 }),
-    );
-
-    delete process.env.TEST_API_KEY;
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  it('PRI-393: env var missing → process.exit(1) and does NOT call probeRuntime', async () => {
-    const { probeRuntime } = await import('@principles/core/runtime-v2');
-    vi.mocked(probeRuntime).mockClear();
-
-    // Ensure NONEXISTENT_VAR is NOT set
-    delete process.env.NONEXISTENT_VAR;
-
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-
-    await handleRuntimeProbe({
-      runtime: 'pi-ai',
-      provider: 'test-provider',
-      model: 'test-model',
-      apiKeyEnv: 'NONEXISTENT_VAR',
-      json: true,
-    } as RuntimeProbeOptions);
-
-    const output = consoleSpy.mock.calls.map(([chunk]) => String(chunk)).join('');
-    expect(JSON.parse(output)).toEqual(expect.objectContaining({
-      status: 'failed',
-      reason: 'api_key_not_set',
-      message: expect.stringContaining('NONEXISTENT_VAR'),
-      nextAction: expect.any(String),
-    }));
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(vi.mocked(probeRuntime)).not.toHaveBeenCalled();
-
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-});

package/tests/commands/samples-list.test.ts

@@ -1,43 +0,0 @@
-/**
- * pd samples list command tests — PRI-753 (Trajectory Reader Reality Fix).
- *
- * A missing workspace trajectory database is an operator-visible failure with
- * a next action (cli-6), never a silent "no samples" answer (rc-9).
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/pri753-missing-workspace'),
-}));
-
-import { handleSamplesList } from '../../src/commands/samples-list.js';
-
-describe('handleSamplesList — unavailable database (PRI-753)', () => {
-  let errorSpy: ReturnType<typeof vi.spyOn>;
-  let exitSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code: number) => {
-      throw new Error(`process.exit:${String(code)}`);
-    }) as never);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('fails loud with reason and next action when trajectory.db is missing', async () => {
-    await expect(handleSamplesList({})).rejects.toThrow('process.exit:1');
-
-    const stderrText = errorSpy.mock.calls.map((call) => String(call[0])).join('');
-    expect(stderrText).toContain('Trajectory database unavailable');
-    expect(stderrText).toContain(joinPath('.state', 'trajectory.db'));
-    expect(stderrText).toContain('pd runtime init --confirm');
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-});
-
-function joinPath(a: string, b: string): string {
-  return `${a}${process.platform === 'win32' ? '\\' : '/'}${b}`;
-}

package/tests/commands/samples-review.test.ts

@@ -1,41 +0,0 @@
-/**
- * pd samples review command tests — PRI-753 (Trajectory Reader Reality Fix).
- *
- * A missing workspace trajectory database is an operator-visible failure with
- * a next action (cli-6); failure exits before any mutation (cli-2/cli-5).
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/pri753-missing-workspace'),
-}));
-
-import { handleSamplesReview } from '../../src/commands/samples-review.js';
-
-describe('handleSamplesReview — unavailable database (PRI-753)', () => {
-  let errorSpy: ReturnType<typeof vi.spyOn>;
-  let exitSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code: number) => {
-      throw new Error(`process.exit:${String(code)}`);
-    }) as never);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('fails loud with reason and next action when trajectory.db is missing', async () => {
-    await expect(handleSamplesReview({ sampleId: 'sample-001', decision: 'approve' })).rejects.toThrow(
-      'process.exit:1'
-    );
-
-    const stderrText = errorSpy.mock.calls.map((call) => String(call[0])).join('');
-    expect(stderrText).toContain('Trajectory database unavailable');
-    expect(stderrText).toContain('trajectory.db');
-    expect(stderrText).toContain('pd runtime init --confirm');
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-});

package/tests/commands/task.test.ts

@@ -1,153 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const mockGetTask = vi.hoisted(() => vi.fn());
-const mockGetRunsByTask = vi.hoisted(() => vi.fn());
-const mockInitialize = vi.hoisted(() => vi.fn());
-const mockClose = vi.hoisted(() => vi.fn());
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
-}));
-
-vi.mock('@principles/core', async (importOriginal) => {
-  const original = await importOriginal<typeof import('@principles/core')>();
-  return {
-    ...original,
-    RuntimeStateManager: vi.fn().mockImplementation(function() {
-      return {
-        initialize: mockInitialize,
-        getTask: mockGetTask,
-        getRunsByTask: mockGetRunsByTask,
-        close: mockClose,
-      };
-    }),
-  };
-});
-
-import { handleTaskShow } from '../../src/commands/task.js';
-import { MalformedRunError } from '@principles/core';
-
-describe('pd task show command handler', () => {
-  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
-  let processExitSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockInitialize.mockResolvedValue(undefined);
-    mockGetTask.mockResolvedValue({
-      taskId: 'task-123',
-      taskKind: 'dreamer',
-      status: 'failed',
-      attemptCount: 1,
-      maxAttempts: 3,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    });
-    mockGetRunsByTask.mockResolvedValue([
-      {
-        runId: 'run-1',
-        executionStatus: 'failed',
-        attemptNumber: 1,
-        startedAt: Date.now(),
-      },
-    ]);
-    process.exitCode = 0;
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-  });
-
-  it('happy path JSON mode prints task and runs, exit code 0', async () => {
-    await handleTaskShow({ id: 'task-123', json: true });
-
-    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string);
-    expect(output).toMatchObject({
-      task: { taskId: 'task-123' },
-      runs: [{ runId: 'run-1' }],
-    });
-    expect(process.exitCode).toBe(0);
-    expect(processExitSpy).not.toHaveBeenCalled();
-  });
-
-  it('task not found JSON mode prints ok: false and exits with non-zero code', async () => {
-    mockGetTask.mockResolvedValue(null);
-
-    await handleTaskShow({ id: 'nonexistent-task', json: true });
-
-    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string);
-    expect(output).toMatchObject({
-      ok: false,
-      reason: expect.stringContaining('Task not found'),
-      nextAction: expect.any(String),
-    });
-    expect(processExitSpy).toHaveBeenCalledWith(1);
-  });
-
-  it('degraded JSON mode prints ok: false, lists degraded runs, and sets exitCode to 1', async () => {
-    const malformedError = new MalformedRunError('Malformed schema', [
-      {
-        runId: 'run-valid',
-        executionStatus: 'succeeded',
-        attemptNumber: 1,
-        startedAt: Date.now(),
-      } as any,
-    ], [
-      {
-        runId: 'run-bad',
-        error: 'runtimeKind missing',
-        rawRow: {},
-      },
-    ]);
-
-    mockGetRunsByTask.mockRejectedValue(malformedError);
-
-    await handleTaskShow({ id: 'task-123', json: true });
-
-    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string);
-    expect(output).toMatchObject({
-      ok: false,
-      task: { taskId: 'task-123' },
-      runs: [{ runId: 'run-valid' }],
-      degradedRuns: [{ runId: 'run-bad', error: 'runtimeKind missing' }],
-      reason: expect.stringContaining('Malformed schema'),
-      // Honest nextAction: must NOT promise an auto-repair that doesn't exist,
-      // and must point at the real quarantine command (integrity-repair --confirm).
-      nextAction: expect.stringContaining('not auto-repaired'),
-    });
-    expect(output.nextAction).toContain('integrity-repair --confirm');
-    expect(process.exitCode).toBe(1);
-    expect(processExitSpy).not.toHaveBeenCalled();
-  });
-
-  it('degraded text mode prints warning and sets exitCode to 1', async () => {
-    const malformedError = new MalformedRunError('Malformed schema', [
-      {
-        runId: 'run-valid',
-        executionStatus: 'succeeded',
-        attemptNumber: 1,
-        startedAt: Date.now(),
-      } as any,
-    ], [
-      {
-        runId: 'run-bad',
-        error: 'runtimeKind missing',
-        rawRow: {},
-      },
-    ]);
-
-    mockGetRunsByTask.mockRejectedValue(malformedError);
-
-    await handleTaskShow({ id: 'task-123', json: false });
-
-    expect(consoleErrorSpy).not.toHaveBeenCalled();
-    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Task: task-123'));
-    // The text-mode warning must also carry the honest nextAction.
-    expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('not auto-repaired'));
-    expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('integrity-repair --confirm'));
-    expect(process.exitCode).toBe(1);
-    expect(processExitSpy).not.toHaveBeenCalled();
-  });
-});