@principles/pd-cli 1.147.17 → 1.149.0

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

@@ -105,6 +105,39 @@ describe('listPains (PRI-640 host filter)', () => {
     expect(result.pains[0]?.host).toBe('unknown');
   });
 
+  it('PRI-743: byHost reports the full-table distribution independent of --host/--limit', async () => {
+    const { db } = makeWorkspace();
+    seedPain(db, { id: 1, source: 'user_correction', canonical: 'pain_oc_1', host: 'openclaw', created: '2026-09-01T10:00:00.000Z' });
+    seedPain(db, { id: 2, source: 'user_correction', canonical: 'pain_oc_2', host: 'openclaw', created: '2026-09-01T10:05:00.000Z' });
+    seedPain(db, { id: 3, source: 'tool_failure', canonical: 'pain_cx_1', host: 'codex', created: '2026-09-01T11:00:00.000Z' });
+    seedPain(db, { id: 4, source: 'manual', canonical: 'pain_null_1', host: null, created: '2026-09-01T12:00:00.000Z' });
+    seedPain(db, { id: 5, source: 'manual', canonical: 'pain_null_2', host: null, created: '2026-09-01T12:05:00.000Z' });
+    const dbPath = dbPathOf(db);
+    db.close();
+
+    // --limit narrows the row list but must NOT narrow the distribution.
+    const limited = await listPains(dbPath, { limit: 2 });
+    expect(limited.count).toBe(2);
+    expect(limited.byHost).toEqual({ openclaw: 2, codex: 1, unknown: 2 });
+
+    // --host narrows the row list but must NOT narrow the distribution.
+    const filtered = await listPains(dbPath, { limit: 10, host: 'codex' });
+    expect(filtered.count).toBe(1);
+    expect(filtered.byHost).toEqual({ openclaw: 2, codex: 1, unknown: 2 });
+  });
+
+  it('PRI-743: byHost is null (never guessed) on a pre-PRI-640 database', 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 result = await listPains(dbPath, { limit: 10 });
+    expect(result.byHost).toBeNull();
+    expect(result.warnings).toContain('host_kind_column_missing');
+  });
+
   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)
@@ -152,11 +185,12 @@ describe('handlePainList (CLI contract)', () => {
     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[] };
+    const parsed = JSON.parse(raw) as { count: number; pains: { host: string; painId: string }[]; hostFilter: unknown; warnings: string[]; byHost: { openclaw: number; codex: number; unknown: number } | null };
     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([]);
+    expect(parsed.byHost).toEqual({ openclaw: 1, codex: 1, unknown: 0 });
   });
 
   it('--host filter is reflected in the JSON result', async () => {

package/tests/commands/pain-record-session-parser.test.ts

@@ -86,6 +86,33 @@ describe('pd pain record --session (real Commander + real trajectory.db)', () =>
     expect(result.stdout).toContain('--session');
   }, 15_000);
 
+  it('PRI-743: --help registers --host with the openclaw|codex contract', async () => {
+    const result = await runBuiltCli(['pain', 'record', '--help']);
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('--host <kind>');
+    // Commander wraps help text; normalize whitespace before asserting content.
+    const normalized = result.stdout.replace(/\s+/g, ' ');
+    expect(normalized).toContain('openclaw | codex');
+    expect(normalized).toContain('codex refuses');
+  }, 15_000);
+
+  it('PRI-743: an invalid --host value exits non-zero with a single structured JSON object', async () => {
+    const result = await runBuiltCli([
+      'pain', 'record',
+      '--reason', 'parser test pain',
+      '--host', 'claude',
+      '--workspace', tmpDir,
+      '--json',
+    ]);
+
+    expect(result.status).not.toBe(0);
+    const trimmed = result.stdout.trim();
+    const parsed = JSON.parse(trimmed) as Record<string, unknown>;
+    expect(parsed.status).toBe('failed');
+    expect(parsed.reason).toBe('invalid_host_kind');
+    expect(typeof parsed.nextAction).toBe('string');
+  }, 15_000);
+
   it('fails with a single JSON object and reason session_not_found for a nonexistent session (SPEC 12.1.4)', async () => {
     const result = await runBuiltCli([
       'pain', 'record',

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

@@ -399,6 +399,83 @@ describe('pd pain record', () => {
     exitSpy.mockRestore();
   });
 
+  // ── PRI-743: explicit --host attribution ──────────────────────────────────
+
+  it('PRI-743: --host openclaw records without the default-assumption disclosure', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'explicit openclaw', session: 'sess-oc', host: 'openclaw', json: true });
+
+    expect(lastRecordPainInput).toBeTruthy();
+    expect(lastRecordPainInput!.sessionId).toBe('sess-oc');
+    expect(lastRecordPainInput!.hostKind).toBe('openclaw');
+    expect(lastRecordPainInput!.provenance).toBe('host_context_bound');
+
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { hostAttribution?: string; warnings?: string[] };
+    expect(jsonOutput.hostAttribution).toBe('openclaw');
+    expect((jsonOutput.warnings ?? []).some((w) => w.includes("defaulted to 'openclaw'"))).toBe(false);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('PRI-743: --host codex refuses loudly — the CLI cannot verify Codex lineage (rc-6)', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'codex mistake', session: 'sess-codex', host: 'codex', json: true });
+
+    // cli-1: exactly one JSON object on stdout
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { status: string; reason: string; nextAction: string };
+    expect(jsonOutput).toMatchObject({ status: 'failed', reason: 'codex_lineage_unverifiable_by_cli' });
+    expect(jsonOutput.nextAction).toContain('Codex ingestion');
+    // cli-2/cli-5: refused before any evidence acquisition or service mutation
+    expect(lastRecordPainInput).toBeNull();
+    expect(acquireTrajectoryEvidenceFromDb).not.toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('PRI-743: omitting --host keeps the openclaw default but discloses the assumption (rc-9)', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'legacy path', session: 'sess-123', json: true });
+
+    expect(lastRecordPainInput).toBeTruthy();
+    expect(lastRecordPainInput!.hostKind).toBe('openclaw');
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { hostAttribution?: string; warnings?: string[] };
+    expect(jsonOutput.hostAttribution).toBe('openclaw');
+    expect((jsonOutput.warnings ?? []).some((w) => w.includes("defaulted to 'openclaw'") && w.includes('--host codex'))).toBe(true);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('PRI-743: an invalid --host value fails loudly before any mutation (cli-5/cli-6)', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'typo host', session: 'sess-123', host: 'claude', json: true });
+
+    // cli-1: exactly one JSON object on stdout
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { status: string; reason: string; nextAction: string };
+    expect(jsonOutput).toMatchObject({ status: 'failed', reason: 'invalid_host_kind' });
+    expect(jsonOutput.nextAction).toContain('--host codex');
+    // cli-2/cli-5: execution stopped before any evidence acquisition or service mutation
+    expect(lastRecordPainInput).toBeNull();
+    expect(acquireTrajectoryEvidenceFromDb).not.toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
   // 用例 C2 (PRI-642 rewrite): without session, no sentinel session, no
   // placeholder evidence — an honest unbound Owner report (SPEC §7.4).
   it('C2: submits an honest unbound report when no --session provided', async () => {

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

@@ -73,10 +73,6 @@ const EXPECTED_TRAJECTORY_TABLES = [
   'exports_audit', 'evolution_tasks', 'evolution_events',
 ];
 
-const EXPECTED_WORKFLOW_TABLES = [
-  'schema_version', 'subagent_workflows', 'subagent_workflow_events',
-];
-
 const EXPECTED_TRAJECTORY_INDEXES = [
   'idx_assistant_turns_session_id',
   'idx_assistant_turns_created_at',
@@ -110,11 +106,11 @@ describe('pd runtime init — empty workspace integration', () => {
   // ── EMPTY-01: initialize empty workspace ───────────────────────────────────
 
   describe('EMPTY-01: initialize empty workspace', () => {
-    it('returns ok=true with 3 initialized databases', () => {
+    it('returns ok=true with 2 initialized databases', () => {
       const output = buildRuntimeInitOutput(tmpDir, true);
       expect(output.ok).toBe(true);
       expect(output.mode).toBe('confirm');
-      expect(output.databases).toHaveLength(3);
+      expect(output.databases).toHaveLength(2);
       for (const db of output.databases) {
         expect(db.status).toBe('initialized');
       }
@@ -150,14 +146,10 @@ describe('pd runtime init — empty workspace integration', () => {
       }
     });
 
-    it('creates subagent_workflows.db with all expected tables', () => {
+    it('no longer creates subagent_workflows.db (legacy workflow store retired in PRI-737)', () => {
       buildRuntimeInitOutput(tmpDir, true);
       const wfDbPath = path.join(tmpDir, '.state', 'subagent_workflows.db');
-      expect(fs.existsSync(wfDbPath)).toBe(true);
-      const tables = getTableNames(wfDbPath);
-      for (const expected of EXPECTED_WORKFLOW_TABLES) {
-        expect(tables).toContain(expected);
-      }
+      expect(fs.existsSync(wfDbPath)).toBe(false);
     });
 
     it('pain_events table has canonical_pain_id and runtime_task_id columns', () => {
@@ -229,7 +221,7 @@ describe('pd runtime init — empty workspace integration', () => {
       // Second initialization (should be idempotent)
       const output2 = buildRuntimeInitOutput(tmpDir, true);
       expect(output2.ok).toBe(true);
-      expect(output2.databases).toHaveLength(3);
+      expect(output2.databases).toHaveLength(2);
       for (const db of output2.databases) {
         expect(db.status).toBe('initialized');
       }

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

@@ -2,8 +2,8 @@
  * runtime-init tests — pd runtime init command (unit tests with mocked DB layer).
  *
  * Covers:
- *   - INIT-01: --dry-run (default) reports 3 DBs as 'skipped', no real writes
- *   - INIT-02: --confirm calls all 3 init functions, output shows 'initialized'
+ *   - INIT-01: --dry-run (default) reports 2 DBs as 'skipped', no real writes
+ *   - INIT-02: --confirm calls all init functions, output shows 'initialized'
  *   - INIT-03: --json outputs single parseable JSON object (cli-1)
  *   - INIT-04: --dry-run + --confirm mutually exclusive (cli-4)
  *   - INIT-05: --confirm failure sets exitCode=1 with reason + nextAction (cli-6)
@@ -24,7 +24,6 @@ import * as fs from 'node:fs';
 const mockState = vi.hoisted(() => {
   return {
     initTrajectorySchema: vi.fn(),
-    initWorkflowSchema: vi.fn(),
     sqliteConnectionCtor: vi.fn(),
     sqliteConnectionGetDb: vi.fn(),
     sqliteConnectionGetWarnings: vi.fn(),
@@ -37,7 +36,6 @@ const mockState = vi.hoisted(() => {
 
 vi.mock('principles-disciple', () => ({
   initTrajectorySchema: mockState.initTrajectorySchema,
-  initWorkflowSchema: mockState.initWorkflowSchema,
 }));
 
 vi.mock('@principles/core/runtime-v2', async () => {
@@ -87,12 +85,6 @@ function setupDefaultConfirmMocks(): void {
     warnings: [],
   });
 
-  // initWorkflowSchema mock
-  mockState.initWorkflowSchema.mockReturnValue({
-    tables: ['schema_version', 'subagent_workflows', 'subagent_workflow_events'],
-    warnings: [],
-  });
-
   // SchemaConformanceReadModel mock
   mockState.schemaConformanceCtor.mockImplementation(function () {
     return {
@@ -113,19 +105,18 @@ describe('pd runtime init', () => {
   // ── INIT-01: dry-run (default) ─────────────────────────────────────────────
 
   describe('INIT-01: dry-run (default)', () => {
-    it('reports 3 DBs as skipped without calling init functions', () => {
+    it('reports 2 DBs as skipped without calling init functions', () => {
       const tmp = mkTmpDir();
       try {
         const output = buildRuntimeInitOutput(tmp, false);
         expect(output.ok).toBe(true);
         expect(output.mode).toBe('dry-run');
-        expect(output.databases).toHaveLength(3);
+        expect(output.databases).toHaveLength(2);
         for (const db of output.databases) {
           expect(db.status).toBe('skipped');
         }
         // No init functions should be called in dry-run mode
         expect(mockState.initTrajectorySchema).not.toHaveBeenCalled();
-        expect(mockState.initWorkflowSchema).not.toHaveBeenCalled();
         expect(mockState.sqliteConnectionCtor).not.toHaveBeenCalled();
       } finally { rmTmpDir(tmp); }
     });
@@ -136,12 +127,10 @@ describe('pd runtime init', () => {
         const output = buildRuntimeInitOutput(tmp, false);
         const stateDb = output.databases.find(d => d.name === 'state.db');
         const trajDb = output.databases.find(d => d.name === 'trajectory.db');
-        const wfDb = output.databases.find(d => d.name === 'subagent_workflows.db');
         expect(stateDb?.tables).toContain('tasks');
         expect(stateDb?.tables).toContain('runs');
         expect(trajDb?.tables).toContain('pain_events');
         expect(trajDb?.tables).toContain('sessions');
-        expect(wfDb?.tables).toContain('subagent_workflows');
       } finally { rmTmpDir(tmp); }
     });
   });
@@ -149,20 +138,19 @@ describe('pd runtime init', () => {
   // ── INIT-02: --confirm ─────────────────────────────────────────────────────
 
   describe('INIT-02: --confirm', () => {
-    it('calls all 3 init functions and reports initialized status', () => {
+    it('calls all init functions and reports initialized status', () => {
       const tmp = mkTmpDir();
       try {
         const output = buildRuntimeInitOutput(tmp, true);
         expect(output.ok).toBe(true);
         expect(output.mode).toBe('confirm');
-        expect(output.databases).toHaveLength(3);
+        expect(output.databases).toHaveLength(2);
         for (const db of output.databases) {
           expect(db.status).toBe('initialized');
         }
         expect(mockState.sqliteConnectionCtor).toHaveBeenCalledTimes(1);
         expect(mockState.sqliteConnectionGetDb).toHaveBeenCalledTimes(1);
         expect(mockState.initTrajectorySchema).toHaveBeenCalledWith(tmp);
-        expect(mockState.initWorkflowSchema).toHaveBeenCalledWith(tmp);
       } finally { rmTmpDir(tmp); }
     });
 
@@ -256,7 +244,6 @@ describe('pd runtime init', () => {
     it('does not call any init functions on flag conflict', async () => {
       await handleRuntimeInit({ dryRun: true, confirm: true, json: true });
       expect(mockState.initTrajectorySchema).not.toHaveBeenCalled();
-      expect(mockState.initWorkflowSchema).not.toHaveBeenCalled();
       expect(mockState.sqliteConnectionCtor).not.toHaveBeenCalled();
     });
   });
@@ -305,19 +292,6 @@ describe('pd runtime init', () => {
       } finally { rmTmpDir(tmp); }
     });
 
-    it('sets exitCode=1 and includes reason when subagent_workflows.db fails', () => {
-      const tmp = mkTmpDir();
-      try {
-        mockState.initWorkflowSchema.mockImplementation(() => {
-          throw new Error('locked');
-        });
-        const output = buildRuntimeInitOutput(tmp, true);
-        expect(output.ok).toBe(false);
-        expect(output.reason).toContain('subagent_workflows.db');
-        expect(output.reason).toContain('locked');
-      } finally { rmTmpDir(tmp); }
-    });
-
     it('handler sets process.exitCode=1 on failure with --json', async () => {
       const tmp = mkTmpDir();
       try {