npm - @principles/pd-cli - Versions diffs - 1.145.2 → 1.146.1 - Mend

@principles/pd-cli 1.145.2 → 1.146.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/README.md +11 -2
package/dist/commands/build-trajectory-evidence.d.ts +25 -6
package/dist/commands/build-trajectory-evidence.d.ts.map +1 -1
package/dist/commands/build-trajectory-evidence.js +174 -114
package/dist/commands/build-trajectory-evidence.js.map +1 -1
package/dist/commands/console.d.ts +13 -0
package/dist/commands/console.d.ts.map +1 -1
package/dist/commands/console.js +104 -0
package/dist/commands/console.js.map +1 -1
package/dist/commands/pain-record.d.ts.map +1 -1
package/dist/commands/pain-record.js +212 -17
package/dist/commands/pain-record.js.map +1 -1
package/dist/index.js +1 -1
package/dist/index.js.map +1 -1
package/package.json +1 -1
package/src/commands/build-trajectory-evidence.ts +211 -122
package/src/commands/console.ts +105 -0
package/src/commands/pain-record.ts +224 -16
package/src/index.ts +1 -1
package/tests/commands/build-trajectory-evidence.test.ts +226 -161
package/tests/commands/console-open.test.ts +175 -0
package/tests/commands/pain-record-async.test.ts +36 -30
package/tests/commands/pain-record-session-parser.test.ts +127 -0
package/tests/commands/pain-record.test.ts +205 -37

package/tests/commands/console-open.test.ts CHANGED Viewed

@@ -569,6 +569,28 @@ describe('CLI command wiring (pd console open)', () => {
     fs.writeFileSync(path.join(consoleDir, 'package.json'), JSON.stringify({ name: 'fake-pd-console', version: '0.0.0', type: 'module' }, null, 2));
     // EP-06 regression guard: dist/web/index.html must exist (PR #1169 fix)
     fs.writeFileSync(path.join(consoleDir, 'dist', 'web', 'index.html'), '<!DOCTYPE html><html></html>');
+    // Runtime dependency integrity check: fake console needs minimal node_modules
+    // slots so the launcher passes the integrity gate and reaches spawn/health logic.
+    const nm = path.join(consoleDir, 'node_modules');
+    // principles-disciple: server imports principles-disciple/governance-audit
+    fs.mkdirSync(path.join(nm, 'principles-disciple', 'dist'), { recursive: true });
+    fs.writeFileSync(path.join(nm, 'principles-disciple', 'package.json'), JSON.stringify({ name: 'x', version: '0.0.0' }, null, 2));
+    fs.writeFileSync(path.join(nm, 'principles-disciple', 'dist', 'governance-audit.js'), 'export {};\n');
+    // @principles/core: server imports TWO subpaths
+    //   @principles/core/principle-tree-ledger → dist/principle-tree-ledger.js
+    //   @principles/core/runtime-v2            → dist/runtime-v2/index.js
+    fs.mkdirSync(path.join(nm, '@principles', 'core', 'dist', 'runtime-v2'), { recursive: true });
+    fs.writeFileSync(path.join(nm, '@principles', 'core', 'package.json'), JSON.stringify({ name: 'x', version: '0.0.0' }, null, 2));
+    fs.writeFileSync(path.join(nm, '@principles', 'core', 'dist', 'principle-tree-ledger.js'), 'export {};\n');
+    fs.writeFileSync(path.join(nm, '@principles', 'core', 'dist', 'runtime-v2', 'index.js'), 'export {};\n');
+    // @principles/host-runtime: uses root entry dist/index.js
+    fs.mkdirSync(path.join(nm, '@principles', 'host-runtime', 'dist'), { recursive: true });
+    fs.writeFileSync(path.join(nm, '@principles', 'host-runtime', 'package.json'), JSON.stringify({ name: 'x', version: '0.0.0' }, null, 2));
+    fs.writeFileSync(path.join(nm, '@principles', 'host-runtime', 'dist', 'index.js'), 'export {};\n');
+    // @principles/install-layout: uses root entry dist/index.js
+    fs.mkdirSync(path.join(nm, '@principles', 'install-layout', 'dist'), { recursive: true });
+    fs.writeFileSync(path.join(nm, '@principles', 'install-layout', 'package.json'), JSON.stringify({ name: 'x', version: '0.0.0' }, null, 2));
+    fs.writeFileSync(path.join(nm, '@principles', 'install-layout', 'dist', 'index.js'), 'export {};\n');
     fs.writeFileSync(path.join(consoleDir, 'dist', 'server.js'), `
       import http from 'node:http';
       const args = process.argv.slice(2);
@@ -710,6 +732,48 @@ describe('CLI command wiring (pd console open)', () => {
     }
   }, 20_000);
+  it('reuses a healthy running Console even when local dependency slots are broken (reuse-before-integrity contract)', async () => {
+    // Regression for the control-flow contract: the integrity gate must only
+    // run on the fresh-spawn branch. If a healthy Console is already running,
+    // broken on-disk node_modules (dangling junction / empty shell left by an
+    // interrupted update) must NOT prevent reusing it — its modules are loaded
+    // in memory. This test breaks the @principles/core slot on disk, then
+    // verifies the CLI still returns status "reused" (never hits the gate).
+    const nm = path.join(
+      process.env.__PD_CONSOLE_TEST_FAKE_HOME ?? '',
+      '.openclaw', 'extensions', 'principles-disciple', 'console', 'node_modules',
+    );
+    // Simulate a broken install: remove the @principles/core dist entry entirely.
+    const coreDist = path.join(nm, '@principles', 'core', 'dist');
+    if (fs.existsSync(coreDist)) fs.rmSync(coreDist, { recursive: true, force: true });
+    const server = http.createServer((req, res) => {
+      if (req.url === '/api/health') {
+        res.statusCode = 200;
+        res.end(JSON.stringify({ success: true, data: { authenticationMode: 'no_auth' } }));
+        return;
+      }
+      res.statusCode = 404;
+      res.end();
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', () => resolve()));
+    const addr = server.address();
+    if (typeof addr !== 'object' || !addr) throw new Error('no addr');
+    let run: CliJsonRun | undefined;
+    try {
+      run = await runPdUntilJson(
+        ['console', 'open', '--workspace', tmp, '--port', String(addr.port), '--json', '--no-browser'],
+        workspaceRoot,
+      );
+      if (!isRecord(run.parsed)) throw new Error('CLI JSON output was not an object');
+      expect(run.parsed.status).toBe('reused');
+      expect(run.parsed.reused).toBe(true);
+    } finally {
+      await teardownCliTree(run);
+      server.close();
+    }
+  }, 20_000);
   it('pd console open --port 99999 --json returns a structured failure (invalid port)', () => {
     const out = runPd(['console', 'open', '--workspace', tmp, '--port', '99999', '--json', '--no-browser'], workspaceRoot);
     const parsed = JSON.parse(out);
@@ -1115,3 +1179,114 @@ function killTreeForce(child: childProcessModule.ChildProcess): void {
     child.kill('SIGKILL');
   } catch { /* already gone */ }
 }
+import { checkConsoleRuntimeDependencies } from '../../src/commands/console.js';
+describe('checkConsoleRuntimeDependencies', () => {
+  it('returns undefined when all deps are intact', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'console-integ-'));
+    try {
+      // @principles/core: entries are dist/principle-tree-ledger.js + dist/runtime-v2/index.js
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'runtime-v2'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'principle-tree-ledger.js'), '');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'runtime-v2', 'index.js'), '');
+      // @principles/host-runtime: entry is dist/index.js
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'host-runtime', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'host-runtime', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'host-runtime', 'dist', 'index.js'), '');
+      // @principles/install-layout: entry is dist/index.js
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'dist', 'index.js'), '');
+      // principles-disciple: entry is dist/governance-audit.js
+      fs.mkdirSync(path.join(tmp, 'node_modules', 'principles-disciple', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', 'principles-disciple', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', 'principles-disciple', 'dist', 'governance-audit.js'), '');
+      expect(checkConsoleRuntimeDependencies(tmp)).toBeUndefined();
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+  it('returns error when a dep is missing package.json', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'console-integ-'));
+    try {
+      // Create all deps intact except host-runtime (no package.json)
+      // core
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'runtime-v2'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'principle-tree-ledger.js'), '');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'runtime-v2', 'index.js'), '');
+      // install-layout
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'dist', 'index.js'), '');
+      // principles-disciple
+      fs.mkdirSync(path.join(tmp, 'node_modules', 'principles-disciple', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', 'principles-disciple', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', 'principles-disciple', 'dist', 'governance-audit.js'), '');
+      // @principles/host-runtime without package.json — the broken-shell case
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'host-runtime', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'host-runtime', 'dist', 'index.js'), '');
+      const err = checkConsoleRuntimeDependencies(tmp);
+      expect(err).toContain('host-runtime');
+      expect(err).toContain('package.json');
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+  it('returns error when a dep has package.json but no dist entry (empty shell)', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'console-integ-'));
+    try {
+      // core intact
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'runtime-v2'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'principle-tree-ledger.js'), '');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'runtime-v2', 'index.js'), '');
+      // install-layout intact
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'dist', 'index.js'), '');
+      // principles-disciple intact
+      fs.mkdirSync(path.join(tmp, 'node_modules', 'principles-disciple', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', 'principles-disciple', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', 'principles-disciple', 'dist', 'governance-audit.js'), '');
+      // host-runtime exists but has no dist/index.js (root entry missing)
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'host-runtime'));
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'host-runtime', 'package.json'), '{}');
+      const err = checkConsoleRuntimeDependencies(tmp);
+      expect(err).toContain('host-runtime');
+      expect(err).toContain('dist/index.js');
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+  it('returns error when a dep junction is dangling (directory missing)', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'console-integ-'));
+    try {
+      // Create core, install-layout, principles-disciple; leave host-runtime missing
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'runtime-v2'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'principle-tree-ledger.js'), '');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'core', 'dist', 'runtime-v2', 'index.js'), '');
+      fs.mkdirSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', '@principles', 'install-layout', 'dist', 'index.js'), '');
+      fs.mkdirSync(path.join(tmp, 'node_modules', 'principles-disciple', 'dist'), { recursive: true });
+      fs.writeFileSync(path.join(tmp, 'node_modules', 'principles-disciple', 'package.json'), '{}');
+      fs.writeFileSync(path.join(tmp, 'node_modules', 'principles-disciple', 'dist', 'governance-audit.js'), '');
+      const err = checkConsoleRuntimeDependencies(tmp);
+      expect(err).toContain('host-runtime');
+      expect(err).toContain('package.json');
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});

package/tests/commands/pain-record-async.test.ts CHANGED Viewed

@@ -31,36 +31,42 @@ vi.mock('../../src/commands/build-trajectory-evidence.js', () => ({
   ]),
 }));
-vi.mock('@principles/core/runtime-v2', () => ({
-  PainToPrincipleService: vi.fn().mockImplementation(function(this: Record<string, unknown>, opts: Record<string, unknown>) {
-    lastServiceOpts = opts;
-    return {
-      recordPain: vi.fn(async () => mockRecordPainResult),
-    };
-  }),
-  PrincipleTreeLedgerAdapter: vi.fn().mockImplementation(function() { return {}; }),
-  computeEffectivePdConfig: vi.fn().mockReturnValue({
-    runtimeKind: 'pi-ai',
-    provider: 'test-provider',
-    model: 'test-model',
-    apiKeyEnv: 'TEST_KEY',
-    timeoutMs: 300000,
-    agentId: 'main',
-    language: 'zh-CN',
-    warnings: [],
-  }),
-  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' }),
-  isFeatureEnabled: vi.fn().mockImplementation(() => mockIsFeatureEnabledReturn),
-}));
+vi.mock('@principles/core/runtime-v2', async (importOriginal) => {
+  // PRI-642 review blocker 1: keep the REAL core evaluatePainIngress (the
+  // shared semantic authority) — only service/IO classes are mocked.
+  const actual = await importOriginal<typeof import('@principles/core/runtime-v2')>();
+  return {
+    ...actual,
+    PainToPrincipleService: vi.fn().mockImplementation(function(this: Record<string, unknown>, opts: Record<string, unknown>) {
+      lastServiceOpts = opts;
+      return {
+        recordPain: vi.fn(async () => mockRecordPainResult),
+      };
+    }),
+    PrincipleTreeLedgerAdapter: vi.fn().mockImplementation(function() { return {}; }),
+    computeEffectivePdConfig: vi.fn().mockReturnValue({
+      runtimeKind: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'TEST_KEY',
+      timeoutMs: 300000,
+      agentId: 'main',
+      language: 'zh-CN',
+      warnings: [],
+    }),
+    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' }),
+    isFeatureEnabled: vi.fn().mockImplementation(() => mockIsFeatureEnabledReturn),
+  };
+});
 vi.mock('../../src/services/pd-config-loader.js', () => ({
   loadPdConfig: vi.fn().mockReturnValue({

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

@@ -0,0 +1,127 @@
+/**
+ * PRI-642 Scope A — real-Commander integration for `pd pain record --session`.
+ *
+ * Spawns the BUILT pd CLI (dist/index.js) against a real temp workspace with a
+ * real trajectory.db, exercising the actual commander registration and the
+ * real typed acquisition path — not the in-process handler with mocks
+ * (cli-7-test-wiring; SPEC §13 "Real Commander parser/registration tests for
+ * --session and --json").
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promisify } from 'node:util';
+import Database from 'better-sqlite3';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+let tmpDir: string;
+function createWorkspace(): void {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pain-record-parser-'));
+  const stateDir = path.join(tmpDir, '.state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  const db = new Database(path.join(stateDir, 'trajectory.db'));
+  db.exec("CREATE TABLE IF NOT EXISTS sessions (session_id TEXT PRIMARY KEY, started_at TEXT, updated_at TEXT)");
+  db.exec("CREATE TABLE IF NOT EXISTS assistant_turns (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, sanitized_text TEXT, stop_reason TEXT, created_at TEXT NOT NULL)");
+  db.exec("CREATE TABLE IF NOT EXISTS user_turns (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, raw_excerpt TEXT, correction_detected INTEGER NOT NULL DEFAULT 0, created_at TEXT NOT NULL)");
+  db.exec("CREATE TABLE IF NOT EXISTS tool_calls (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, tool_name TEXT NOT NULL, outcome TEXT NOT NULL, error_type TEXT, exit_code INTEGER, params_json TEXT NOT NULL DEFAULT '{}', result_preview TEXT, created_at TEXT NOT NULL)");
+  db.prepare('INSERT INTO sessions (session_id, started_at, updated_at) VALUES (?, ?, ?)')
+    .run('real-session-1', '2026-01-01T09:00:00Z', '2026-01-01T09:00:00Z');
+  db.prepare('INSERT INTO user_turns (session_id, raw_excerpt, correction_detected, created_at) VALUES (?, ?, ?, ?)')
+    .run('real-session-1', 'Please fix the output format', 1, '2026-01-01T09:59:00Z');
+  db.close();
+}
+interface CliRunResult {
+  status: number | null;
+  stdout: string;
+  stderr: string;
+}
+/** Resolves and boundary-validates the built pd CLI entry before spawning it. */
+async function resolveBuiltCliEntry(): Promise<string> {
+  const packageRoot = path.resolve(process.cwd());
+  const entry = path.resolve(packageRoot, 'dist', 'index.js');
+  if (!entry.startsWith(`${packageRoot}${path.sep}`) || !fs.statSync(entry).isFile()) {
+    throw new Error(`built pd CLI entry not found or outside the package: ${entry}`);
+  }
+  return entry;
+}
+async function runBuiltCli(literalArgv: readonly string[]): Promise<CliRunResult> {
+  const { execFile } = await import('node:child_process');
+  const execFileAsync = promisify(execFile);
+  const entry = await resolveBuiltCliEntry();
+  try {
+    const { stdout } = await execFileAsync(process.execPath, [entry, ...literalArgv], {
+      cwd: tmpDir,
+      timeout: 30000,
+      encoding: 'utf8',
+      env: { ...process.env, PD_WORKSPACE_DIR: tmpDir },
+    });
+    return { status: 0, stdout, stderr: '' };
+  } catch (err) {
+    const e = err as { code?: number; stdout?: string; stderr?: string };
+    return { status: e.code ?? -1, stdout: e.stdout ?? '', stderr: e.stderr ?? '' };
+  }
+}
+describe('pd pain record --session (real Commander + real trajectory.db)', () => {
+  beforeEach(() => {
+    createWorkspace();
+  });
+  afterEach(() => {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+  });
+  it('--help registers and documents --session', async () => {
+    const result = await runBuiltCli(['pain', 'record', '--help']);
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('--session');
+  }, 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',
+      '--reason', 'parser test pain',
+      '--session', 'no-such-session',
+      '--workspace', tmpDir,
+      '--json',
+    ]);
+    // Failed validation exits non-zero.
+    expect(result.status).not.toBe(0);
+    // cli-1: stdout is exactly one JSON object.
+    const trimmed = result.stdout.trim();
+    expect(trimmed.length).toBeGreaterThan(0);
+    const parsed = JSON.parse(trimmed) as Record<string, unknown>;
+    expect(parsed.status).toBe('failed');
+    expect(parsed.reason).toBe('session_not_found');
+    expect(typeof parsed.nextAction).toBe('string');
+  }, 15_000);
+  it('accepts --session for a session that exists in the trajectory (validation passes, submission proceeds)', async () => {
+    const result = await runBuiltCli([
+      'pain', 'record',
+      '--reason', 'parser test pain with real session',
+      '--session', 'real-session-1',
+      '--workspace', tmpDir,
+      '--json',
+    ]);
+    // The session exists, so session validation must NOT reject it. The run
+    // may still fail later (no LLM runtime configured in this temp
+    // workspace) — the assertion is only about the validation stage.
+    const trimmed = result.stdout.trim();
+    expect(trimmed.length).toBeGreaterThan(0);
+    const parsed = JSON.parse(trimmed) as Record<string, unknown>;
+    expect(parsed.reason).not.toBe('session_not_found');
+    expect(parsed.reason).not.toBe('empty_trajectory');
+  }, 15_000);
+});