@principles/pd-cli 1.145.0 → 1.145.2

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

@@ -0,0 +1,185 @@
+/**
+ * pd pain list command unit tests — PRI-640 (Host Attribution v0.1).
+ *
+ * External contract: listPains reads trajectory.db readonly and filters by
+ * host (openclaw / codex / unknown); handlePainList preserves the strict
+ * --json contract and degraded-failure shapes (cli-1/cli-6).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+import { handlePainList, listPains } from '../../src/commands/pain-list.js';
+import { resolveWorkspaceDir } from '../../src/resolve-workspace.js';
+
+const tempDirs: string[] = [];
+
+function openWorkspaceDb(prefix: string): { workspaceDir: string; db: Database.Database } {
+  const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  tempDirs.push(workspaceDir);
+  const stateDir = path.join(workspaceDir, '.state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  return { workspaceDir, db: new Database(path.join(stateDir, 'trajectory.db')) };
+}
+
+/** Create a temp workspace whose trajectory.db uses the PRI-640 schema (host_kind column). */
+function makeWorkspace(): { workspaceDir: string; db: Database.Database } {
+  const { workspaceDir, db } = openWorkspaceDb('pd-pain-list-');
+  db.prepare('CREATE TABLE sessions (session_id TEXT PRIMARY KEY, started_at TEXT NOT NULL, updated_at TEXT NOT NULL)').run();
+  db.prepare(`CREATE TABLE pain_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL, source TEXT NOT NULL, score REAL NOT NULL, reason TEXT,
+      severity TEXT, origin TEXT, confidence REAL, text TEXT,
+      canonical_pain_id TEXT, runtime_task_id TEXT, host_kind TEXT, created_at TEXT NOT NULL
+    )`).run();
+  db.prepare('CREATE UNIQUE INDEX idx_pain_events_canonical_pain_id ON pain_events(canonical_pain_id) WHERE canonical_pain_id IS NOT NULL').run();
+  return { workspaceDir, db };
+}
+
+/** Create a temp workspace whose trajectory.db predates PRI-640 (no host_kind column). */
+function makePre640Workspace(): { workspaceDir: string; db: Database.Database } {
+  const { workspaceDir, db } = openWorkspaceDb('pd-pain-pre640-');
+  db.prepare('CREATE TABLE sessions (session_id TEXT PRIMARY KEY, started_at TEXT NOT NULL, updated_at TEXT NOT NULL)').run();
+  db.prepare(`CREATE TABLE pain_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL, source TEXT NOT NULL, score REAL NOT NULL, reason TEXT,
+      severity TEXT, origin TEXT, confidence REAL, text TEXT,
+      canonical_pain_id TEXT, runtime_task_id TEXT, created_at TEXT NOT NULL
+    )`).run();
+  db.prepare('CREATE UNIQUE INDEX idx_pain_events_canonical_pain_id ON pain_events(canonical_pain_id) WHERE canonical_pain_id IS NOT NULL').run();
+  return { workspaceDir, db };
+}
+
+function seedPain(db: Database.Database, row: { id: number; source: string; canonical: string; host: string | null; task?: string | null; created: string }): void {
+  db.prepare(`INSERT INTO pain_events (id, session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, host_kind, created_at)
+    VALUES (?, 's1', ?, 80, 'r', 'moderate', 'system_infer', NULL, NULL, ?, ?, ?, ?)`)
+    .run(row.id, row.source, row.canonical, row.task ?? null, row.host, row.created);
+}
+
+function dbPathOf(db: Database.Database): string {
+  return db.name;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 20 });
+  }
+});
+
+describe('listPains (PRI-640 host filter)', () => {
+  it('filters host=openclaw / codex / unknown and reports NULL as unknown', async () => {
+    const { workspaceDir, db } = makeWorkspace();
+    seedPain(db, { id: 1, source: 'user_correction', canonical: 'pain_oc_1', host: 'openclaw', task: 'diagnosis_pain_oc_1', created: '2026-09-01T10:00:00.000Z' });
+    seedPain(db, { id: 2, source: 'tool_failure', canonical: 'pain_cx_1', host: 'codex', created: '2026-09-01T11:00:00.000Z' });
+    seedPain(db, { id: 3, source: 'manual', canonical: 'pain_unknown_1', host: null, created: '2026-09-01T12:00:00.000Z' });
+    const dbPath = dbPathOf(db);
+    db.close();
+
+    const all = await listPains(dbPath, { limit: 10 });
+    expect(all.count).toBe(3);
+    expect(all.pains.map((p) => p.host)).toEqual(['unknown', 'codex', 'openclaw']); // newest first
+    expect(all.pains.find((p) => p.painId === 'pain_oc_1')).toMatchObject({ host: 'openclaw', source: 'user_correction', runtimeTaskId: 'diagnosis_pain_oc_1', createdAt: '2026-09-01T10:00:00.000Z' });
+    expect(all.workspace).toBe(workspaceDir);
+
+    expect((await listPains(dbPath, { limit: 10, host: 'openclaw' })).pains.map((p) => p.painId)).toEqual(['pain_oc_1']);
+    expect((await listPains(dbPath, { limit: 10, host: 'codex' })).pains.map((p) => p.painId)).toEqual(['pain_cx_1']);
+    expect((await listPains(dbPath, { limit: 10, host: 'unknown' })).pains.map((p) => p.painId)).toEqual(['pain_unknown_1']);
+    expect(all.warnings).toEqual([]);
+  });
+
+  it('reports legacy rows without a canonical id as row:<id>', async () => {
+    const { db } = makeWorkspace();
+    db.prepare(`INSERT INTO pain_events (session_id, source, score, created_at) VALUES ('s1', 'correction_rejected', 60, '2026-08-01T00:00:00.000Z')`).run();
+    const dbPath = dbPathOf(db);
+    db.close();
+
+    const result = await listPains(dbPath, { limit: 10 });
+    expect(result.count).toBe(1);
+    expect(result.pains[0]?.painId).toBe('row:1');
+    expect(result.pains[0]?.host).toBe('unknown');
+  });
+
+  it('degrades observably on a pre-PRI-640 database without the host_kind column (rc-9)', async () => {
+    const { db } = makePre640Workspace();
+    db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, created_at)
+      VALUES ('s1', 'tool_failure', 70, 'r', 'moderate', 'system_infer', NULL, NULL, 'pain_legacy', NULL, '2026-08-01T00:00:00.000Z')`).run();
+    const dbPath = dbPathOf(db);
+    db.close();
+
+    const all = await listPains(dbPath, { limit: 10 });
+    expect(all.count).toBe(1);
+    expect(all.pains[0]?.host).toBe('unknown');
+    expect(all.warnings).toContain('host_kind_column_missing');
+
+    // Host filters that cannot match degrade to an explicit empty result.
+    expect(await listPains(dbPath, { limit: 10, host: 'codex' })).toMatchObject({ count: 0, pains: [] });
+    // unknown still returns the legacy rows.
+    expect((await listPains(dbPath, { limit: 10, host: 'unknown' })).count).toBe(1);
+  });
+});
+
+describe('handlePainList (CLI contract)', () => {
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+  let logSpy: ReturnType<typeof vi.spyOn>;
+  let errSpy: ReturnType<typeof vi.spyOn>;
+  let workspaceDir: string;
+
+  beforeEach(() => {
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    const made = makeWorkspace();
+    workspaceDir = made.workspaceDir;
+    seedPain(made.db, { id: 1, source: 'user_correction', canonical: 'pain_cli_oc', host: 'openclaw', task: 't1', created: '2026-09-01T09:00:00.000Z' });
+    seedPain(made.db, { id: 2, source: 'tool_failure', canonical: 'pain_cli_cx', host: 'codex', created: '2026-09-01T09:30:00.000Z' });
+    made.db.close();
+    vi.mocked(resolveWorkspaceDir).mockReturnValue(workspaceDir);
+  });
+
+  afterEach(() => {
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+    errSpy.mockRestore();
+  });
+
+  it('--json emits one valid JSON object with stable host values', async () => {
+    await handlePainList({ json: true });
+    expect(exitSpy).not.toHaveBeenCalled();
+    const raw = logSpy.mock.calls.map((args) => String(args[0])).join('\n');
+    const parsed = JSON.parse(raw) as { count: number; pains: { host: string; painId: string }[]; hostFilter: unknown; warnings: string[] };
+    expect(parsed.count).toBe(2);
+    expect(parsed.pains.map((p) => `${p.painId}:${p.host}`).sort()).toEqual(['pain_cli_cx:codex', 'pain_cli_oc:openclaw']);
+    expect(parsed.hostFilter).toBeNull();
+    expect(parsed.warnings).toEqual([]);
+  });
+
+  it('--host filter is reflected in the JSON result', async () => {
+    await handlePainList({ json: true, host: 'codex' });
+    const parsed = JSON.parse(logSpy.mock.calls.map((args) => String(args[0])).join('\n')) as { count: number; hostFilter: string; pains: unknown[] };
+    expect(parsed).toMatchObject({ count: 1, hostFilter: 'codex' });
+    expect(parsed.pains).toHaveLength(1);
+  });
+
+  it('an invalid --host value fails loudly with a structured reason (cli-6)', async () => {
+    await handlePainList({ json: true, host: 'claude' });
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    const parsed = JSON.parse(logSpy.mock.calls.map((args) => String(args[0])).join('\n')) as { status: string; reason: string; nextAction: string };
+    expect(parsed).toMatchObject({ status: 'failed', reason: 'invalid_host_filter' });
+    expect(parsed.nextAction).toContain('--host openclaw');
+  });
+
+  it('a missing trajectory.db degrades with reason and next action (cli-6)', async () => {
+    fs.rmSync(path.join(workspaceDir, '.state', 'trajectory.db'));
+    await handlePainList({ json: true });
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    const parsed = JSON.parse(logSpy.mock.calls.map((args) => String(args[0])).join('\n')) as { status: string; reason: string; nextAction: string };
+    expect(parsed).toMatchObject({ status: 'failed', reason: 'trajectory_db_not_found' });
+    expect(parsed.nextAction).toContain('pd runtime init');
+  });
+});

package/tests/commands/pain-retry.test.ts

@@ -13,7 +13,7 @@
  * - Wrong taskKind: rejected with reason + nextAction
  * - Missing pi-ai config: rejected with reason + nextAction
  */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Command } from 'commander';
 
 // ── Mocks ──────────────────────────────────────────────────────────────────────
@@ -144,6 +144,8 @@ vi.mock('@principles/core/runtime-v2', () => {
     OpenClawCliRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     PiAiRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     SPLIT_PIPELINE_TOTAL_TIMEOUT_MS: 300000,
+    // PRI-638: capability gate — available by default; disabled cases override this.
+    resolveDiagnosticianCapability: vi.fn((): { available: boolean; reason?: string; message?: string; nextAction?: string } => ({ available: true })),
     PDRuntimeError: class PDRuntimeError extends Error {
       constructor(public category: string, message: string) {
         super(message);
@@ -1048,3 +1050,72 @@ describe('BUG-1 (PRI-442): pain retry — effectiveConfig wiring to split-pipeli
     exitSpy.mockRestore();
   });
 });
+
+// ── PRI-638: unified capability-disabled semantics ───────────────────────────
+//
+// On main, an Owner-disabled Diagnostician surfaced from `pd pain retry` as
+// `missing_runtime` ("no .pd/config.yaml runtime binding found") — telling the
+// Owner their config was broken when they had deliberately switched the agent
+// off. The capability gate now runs BEFORE runtime resolution and reads the
+// same canonical authority the runtime factory uses.
+
+describe('PRI-638: pd pain retry when Diagnostician capability is disabled', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const runtimeV2 = await import('@principles/core/runtime-v2');
+    vi.mocked(runtimeV2.resolveDiagnosticianCapability).mockReturnValue({
+      available: false,
+      reason: 'capability_disabled',
+      message: "Agent 'diagnostician' is disabled",
+      nextAction: "Enable agent 'diagnostician' in .pd/config.yaml internalAgents.agents.diagnostician.enabled",
+    });
+  });
+
+  afterEach(async () => {
+    const runtimeV2 = await import('@principles/core/runtime-v2');
+    vi.mocked(runtimeV2.resolveDiagnosticianCapability).mockReset();
+  });
+
+  it('RETRY-638-01: --json refuses with capability_disabled, not missing_runtime', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handlePainRetry({
+      painId: 'pain-638',
+      workspace: '/tmp/fake-workspace',
+      json: true,
+    });
+
+    const jsonCall = logSpy.mock.calls.find((call) => String(call[0]).trim().startsWith('{'));
+    expect(jsonCall).toBeDefined();
+    const parsed = JSON.parse(String(jsonCall?.[0]));
+    expect(parsed.reason).toBe('capability_disabled');
+    expect(parsed.reason).not.toBe('missing_runtime');
+    expect(parsed.nextAction).toContain('internalAgents.agents.diagnostician.enabled');
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('RETRY-638-02: capability gate fires before the runtime adapter is built', async () => {
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handlePainRetry({
+      painId: 'pain-638',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: false,
+    });
+
+    const out = errSpy.mock.calls.map((c) => String(c[0])).join('\n');
+    expect(out).toContain('capability_disabled');
+    const runtimeV2 = await import('@principles/core/runtime-v2');
+    expect(runtimeV2.TestDoubleRuntimeAdapter).not.toHaveBeenCalled();
+    expect(runtimeV2.SplitDiagnosticianRunner).not.toHaveBeenCalled();
+
+    errSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+});

package/tests/commands/runtime-init.test.ts

@@ -393,6 +393,26 @@ describe('pd runtime init', () => {
       } finally { rmTmpDir(tmp); }
     });
 
+    it('--confirm marks every generated flag entry as system provenance (PRI-637)', async () => {
+      const tmp = mkTmpDir();
+      try {
+        buildRuntimeInitOutput(tmp, true);
+        const configPath = path.join(tmp, '.pd', 'config.yaml');
+        const yaml = (await import('js-yaml')).default;
+        const parsed = yaml.load(fs.readFileSync(configPath, 'utf8'), { schema: yaml.JSON_SCHEMA }) as {
+          features?: Record<string, { source?: unknown }>;
+        };
+        const features = parsed.features ?? {};
+        // Bootstrap snapshot still carries the full registry map.
+        expect(Object.keys(features).length).toBeGreaterThan(0);
+        // PRI-637: `pd runtime init` is PD machinery — entries carry source:
+        // 'system' (NOT owner intent), matching the runtime-init lifecycle label.
+        for (const entry of Object.values(features)) {
+          expect(entry?.source).toBe('system');
+        }
+      } finally { rmTmpDir(tmp); }
+    });
+
     it('--confirm skips when config.yaml already exists (preserves user file)', () => {
       const tmp = mkTmpDir();
       try {