gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/src/resources/extensions/gsd/tests/ensure-db-open.test.ts

@@ -10,7 +10,10 @@ import assert from 'node:assert/strict';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs';
-import { closeDatabase, isDbAvailable, getDecisionById } from '../gsd-db.ts';
+import { createRequire } from 'node:module';
+import { closeDatabase, isDbAvailable, getDecisionById, _getAdapter } from '../gsd-db.ts';
+
+const _require = createRequire(import.meta.url);
 
 function makeTmpDir(): string {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-ensure-db-'));
@@ -23,6 +26,263 @@ function cleanupDir(dir: string): void {
   } catch { /* swallow */ }
 }
 
+function createLegacyV15Db(dbPath: string): void {
+  const sqlite = _require('node:sqlite');
+  const db = new sqlite.DatabaseSync(dbPath);
+  db.exec('PRAGMA journal_mode=WAL');
+  db.exec(`
+    CREATE TABLE schema_version (
+      version INTEGER NOT NULL,
+      applied_at TEXT NOT NULL
+    );
+    INSERT INTO schema_version (version, applied_at) VALUES (15, '2026-01-01T00:00:00.000Z');
+
+    CREATE TABLE decisions (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT,
+      id TEXT NOT NULL UNIQUE,
+      when_context TEXT NOT NULL DEFAULT '',
+      scope TEXT NOT NULL DEFAULT '',
+      decision TEXT NOT NULL DEFAULT '',
+      choice TEXT NOT NULL DEFAULT '',
+      rationale TEXT NOT NULL DEFAULT '',
+      revisable TEXT NOT NULL DEFAULT '',
+      made_by TEXT NOT NULL DEFAULT 'agent',
+      superseded_by TEXT DEFAULT NULL
+    );
+
+    CREATE TABLE requirements (
+      id TEXT PRIMARY KEY,
+      class TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '',
+      why TEXT NOT NULL DEFAULT '',
+      source TEXT NOT NULL DEFAULT '',
+      primary_owner TEXT NOT NULL DEFAULT '',
+      supporting_slices TEXT NOT NULL DEFAULT '',
+      validation TEXT NOT NULL DEFAULT '',
+      notes TEXT NOT NULL DEFAULT '',
+      full_content TEXT NOT NULL DEFAULT '',
+      superseded_by TEXT DEFAULT NULL
+    );
+
+    CREATE TABLE artifacts (
+      path TEXT PRIMARY KEY,
+      artifact_type TEXT NOT NULL DEFAULT '',
+      milestone_id TEXT DEFAULT NULL,
+      slice_id TEXT DEFAULT NULL,
+      task_id TEXT DEFAULT NULL,
+      full_content TEXT NOT NULL DEFAULT '',
+      imported_at TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE TABLE memories (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT,
+      id TEXT NOT NULL UNIQUE,
+      category TEXT NOT NULL,
+      content TEXT NOT NULL,
+      confidence REAL NOT NULL DEFAULT 0.8,
+      source_unit_type TEXT,
+      source_unit_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      superseded_by TEXT DEFAULT NULL,
+      hit_count INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE TABLE memory_processed_units (
+      unit_key TEXT PRIMARY KEY,
+      activity_file TEXT,
+      processed_at TEXT NOT NULL
+    );
+
+    CREATE TABLE milestones (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'active',
+      depends_on TEXT NOT NULL DEFAULT '[]',
+      created_at TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL,
+      vision TEXT NOT NULL DEFAULT '',
+      success_criteria TEXT NOT NULL DEFAULT '[]',
+      key_risks TEXT NOT NULL DEFAULT '[]',
+      proof_strategy TEXT NOT NULL DEFAULT '[]',
+      verification_contract TEXT NOT NULL DEFAULT '',
+      verification_integration TEXT NOT NULL DEFAULT '',
+      verification_operational TEXT NOT NULL DEFAULT '',
+      verification_uat TEXT NOT NULL DEFAULT '',
+      definition_of_done TEXT NOT NULL DEFAULT '[]',
+      requirement_coverage TEXT NOT NULL DEFAULT '',
+      boundary_map_markdown TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE TABLE slices (
+      milestone_id TEXT NOT NULL,
+      id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending',
+      risk TEXT NOT NULL DEFAULT 'medium',
+      depends TEXT NOT NULL DEFAULT '[]',
+      demo TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL,
+      full_summary_md TEXT NOT NULL DEFAULT '',
+      full_uat_md TEXT NOT NULL DEFAULT '',
+      goal TEXT NOT NULL DEFAULT '',
+      success_criteria TEXT NOT NULL DEFAULT '',
+      proof_level TEXT NOT NULL DEFAULT '',
+      integration_closure TEXT NOT NULL DEFAULT '',
+      observability_impact TEXT NOT NULL DEFAULT '',
+      sequence INTEGER DEFAULT 0,
+      replan_triggered_at TEXT DEFAULT NULL,
+      PRIMARY KEY (milestone_id, id)
+    );
+
+    CREATE TABLE tasks (
+      milestone_id TEXT NOT NULL,
+      slice_id TEXT NOT NULL,
+      id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending',
+      one_liner TEXT NOT NULL DEFAULT '',
+      narrative TEXT NOT NULL DEFAULT '',
+      verification_result TEXT NOT NULL DEFAULT '',
+      duration TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL,
+      blocker_discovered INTEGER DEFAULT 0,
+      deviations TEXT NOT NULL DEFAULT '',
+      known_issues TEXT NOT NULL DEFAULT '',
+      key_files TEXT NOT NULL DEFAULT '[]',
+      key_decisions TEXT NOT NULL DEFAULT '[]',
+      full_summary_md TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '',
+      estimate TEXT NOT NULL DEFAULT '',
+      files TEXT NOT NULL DEFAULT '[]',
+      verify TEXT NOT NULL DEFAULT '',
+      inputs TEXT NOT NULL DEFAULT '[]',
+      expected_output TEXT NOT NULL DEFAULT '[]',
+      observability_impact TEXT NOT NULL DEFAULT '',
+      full_plan_md TEXT NOT NULL DEFAULT '',
+      sequence INTEGER DEFAULT 0,
+      PRIMARY KEY (milestone_id, slice_id, id)
+    );
+
+    CREATE TABLE verification_evidence (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT NOT NULL DEFAULT '',
+      milestone_id TEXT NOT NULL DEFAULT '',
+      command TEXT NOT NULL DEFAULT '',
+      exit_code INTEGER DEFAULT 0,
+      verdict TEXT NOT NULL DEFAULT '',
+      duration_ms INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE TABLE replan_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      milestone_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT DEFAULT NULL,
+      task_id TEXT DEFAULT NULL,
+      summary TEXT NOT NULL DEFAULT '',
+      previous_artifact_path TEXT DEFAULT NULL,
+      replacement_artifact_path TEXT DEFAULT NULL,
+      created_at TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE TABLE assessments (
+      path TEXT PRIMARY KEY,
+      milestone_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT DEFAULT NULL,
+      task_id TEXT DEFAULT NULL,
+      status TEXT NOT NULL DEFAULT '',
+      scope TEXT NOT NULL DEFAULT '',
+      full_content TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE TABLE quality_gates (
+      milestone_id TEXT NOT NULL,
+      slice_id TEXT NOT NULL,
+      gate_id TEXT NOT NULL,
+      scope TEXT NOT NULL DEFAULT 'slice',
+      task_id TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending',
+      verdict TEXT NOT NULL DEFAULT '',
+      rationale TEXT NOT NULL DEFAULT '',
+      findings TEXT NOT NULL DEFAULT '',
+      evaluated_at TEXT DEFAULT NULL,
+      PRIMARY KEY (milestone_id, slice_id, gate_id, task_id)
+    );
+
+    CREATE TABLE slice_dependencies (
+      milestone_id TEXT NOT NULL,
+      slice_id TEXT NOT NULL,
+      depends_on_slice_id TEXT NOT NULL,
+      PRIMARY KEY (milestone_id, slice_id, depends_on_slice_id)
+    );
+
+    CREATE TABLE gate_runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      trace_id TEXT NOT NULL,
+      turn_id TEXT NOT NULL,
+      gate_id TEXT NOT NULL,
+      gate_type TEXT NOT NULL DEFAULT '',
+      unit_type TEXT DEFAULT NULL,
+      unit_id TEXT DEFAULT NULL,
+      milestone_id TEXT DEFAULT NULL,
+      slice_id TEXT DEFAULT NULL,
+      task_id TEXT DEFAULT NULL,
+      outcome TEXT NOT NULL DEFAULT 'pass',
+      failure_class TEXT NOT NULL DEFAULT 'none',
+      rationale TEXT NOT NULL DEFAULT '',
+      findings TEXT NOT NULL DEFAULT '',
+      attempt INTEGER NOT NULL DEFAULT 1,
+      max_attempts INTEGER NOT NULL DEFAULT 1,
+      retryable INTEGER NOT NULL DEFAULT 0,
+      evaluated_at TEXT NOT NULL DEFAULT ''
+    );
+
+    CREATE TABLE turn_git_transactions (
+      trace_id TEXT NOT NULL,
+      turn_id TEXT NOT NULL,
+      unit_type TEXT DEFAULT NULL,
+      unit_id TEXT DEFAULT NULL,
+      stage TEXT NOT NULL DEFAULT 'turn-start',
+      action TEXT NOT NULL DEFAULT 'status-only',
+      push INTEGER NOT NULL DEFAULT 0,
+      status TEXT NOT NULL DEFAULT 'ok',
+      error TEXT DEFAULT NULL,
+      metadata_json TEXT NOT NULL DEFAULT '{}',
+      updated_at TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (trace_id, turn_id, stage)
+    );
+
+    CREATE TABLE audit_events (
+      event_id TEXT PRIMARY KEY,
+      trace_id TEXT NOT NULL,
+      turn_id TEXT DEFAULT NULL,
+      caused_by TEXT DEFAULT NULL,
+      category TEXT NOT NULL,
+      type TEXT NOT NULL,
+      ts TEXT NOT NULL,
+      payload_json TEXT NOT NULL DEFAULT '{}'
+    );
+
+    CREATE TABLE audit_turn_index (
+      trace_id TEXT NOT NULL,
+      turn_id TEXT NOT NULL,
+      first_ts TEXT NOT NULL,
+      last_ts TEXT NOT NULL,
+      event_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (trace_id, turn_id)
+    );
+  `);
+  db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+  db.close();
+  try { fs.unlinkSync(`${dbPath}-wal`); } catch { /* may not exist */ }
+  try { fs.unlinkSync(`${dbPath}-shm`); } catch { /* may not exist */ }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // ensureDbOpen creates DB + migrates when .gsd/ has Markdown
 // ═══════════════════════════════════════════════════════════════════════════
@@ -107,6 +367,51 @@ describe('ensure-db-open', () => {
     }
   });
 
+  test('ensureDbOpen: migrates legacy v15 DB before bootstrap indexes touch new columns', async () => {
+    const tmpDir = makeTmpDir();
+    const gsdDir = path.join(tmpDir, '.gsd');
+    fs.mkdirSync(gsdDir, { recursive: true });
+    const dbPath = path.join(gsdDir, 'gsd.db');
+    createLegacyV15Db(dbPath);
+
+    try {
+      closeDatabase();
+    } catch { /* ok */ }
+
+    try {
+      const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
+      const result = await ensureDbOpen(tmpDir);
+
+      assert.equal(result, true, 'legacy v15 DB should open and migrate');
+      assert.ok(isDbAvailable(), 'DB should be available after migrating v15');
+
+      const db = _getAdapter();
+      assert.ok(db, 'adapter should be available after ensureDbOpen');
+      assert.equal(
+        db.prepare('SELECT MAX(version) as version FROM schema_version').get()?.version,
+        22,
+        'legacy DB should migrate to current schema version',
+      );
+
+      const memoryColumns = new Set(db.prepare('PRAGMA table_info(memories)').all().map((row) => row.name));
+      const taskColumns = new Set(db.prepare('PRAGMA table_info(tasks)').all().map((row) => row.name));
+      assert.ok(memoryColumns.has('scope'), 'memory scope column should be present');
+      assert.ok(memoryColumns.has('tags'), 'memory tags column should be present');
+      assert.ok(taskColumns.has('escalation_pending'), 'task escalation_pending column should be present');
+      assert.ok(
+        db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = 'idx_memories_scope'").get(),
+        'memory scope index should be created after migration-safe bootstrap',
+      );
+      assert.ok(
+        db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = 'idx_tasks_escalation_pending'").get(),
+        'task escalation index should be created after migration-safe bootstrap',
+      );
+    } finally {
+      closeDatabase();
+      cleanupDir(tmpDir);
+    }
+  });
+
   // ═══════════════════════════════════════════════════════════════════════════
   // ensureDbOpen returns false when no .gsd/ exists
   // ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/escalation.test.ts

@@ -348,7 +348,7 @@ test("ADR-011 P2: schema v20 fresh DB has all escalation columns on tasks + sour
   assert.ok(decCols.includes("source"), "decisions table must have source column");
 
   const version = adapter.prepare("SELECT MAX(version) as v FROM schema_version").get();
-  assert.equal(version?.["v"], 20);
+  assert.equal(version?.["v"], 22);
 });
 
 test("ADR-011 P2: findUnappliedEscalationOverride returns null when escalation_pending=1 (still pending)", (t) => {

package/src/resources/extensions/gsd/tests/exec-history.test.ts

@@ -0,0 +1,237 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { listExecHistory, searchExecHistory } from '../exec-history.ts';
+import { executeExecSearch } from '../tools/exec-search-tool.ts';
+
+function freshBase(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-exec-history-'));
+}
+
+function cleanup(dir: string): void {
+  rmSync(dir, { recursive: true, force: true });
+}
+
+function writeRun(base: string, id: string, overrides: Record<string, unknown> = {}): void {
+  const dir = join(base, '.gsd', 'exec');
+  mkdirSync(dir, { recursive: true });
+  const stdoutPath = join(dir, `${id}.stdout`);
+  const stderrPath = join(dir, `${id}.stderr`);
+  const metaPath = join(dir, `${id}.meta.json`);
+  writeFileSync(stdoutPath, (overrides.stdout as string | undefined) ?? `stdout for ${id}\n`);
+  writeFileSync(stderrPath, '');
+  writeFileSync(
+    metaPath,
+    JSON.stringify({
+      id,
+      runtime: 'bash',
+      purpose: `purpose for ${id}`,
+      started_at: '2026-04-20T12:00:00.000Z',
+      finished_at: '2026-04-20T12:00:00.100Z',
+      duration_ms: 100,
+      exit_code: 0,
+      signal: null,
+      timed_out: false,
+      stdout_bytes: 12,
+      stderr_bytes: 0,
+      stdout_truncated: false,
+      stderr_truncated: false,
+      stdout_path: stdoutPath,
+      stderr_path: stderrPath,
+      ...overrides,
+    }),
+  );
+}
+
+test('listExecHistory: returns empty list when .gsd/exec missing', () => {
+  const base = freshBase();
+  try {
+    assert.deepEqual(listExecHistory(base), []);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('listExecHistory: skips malformed meta files', () => {
+  const base = freshBase();
+  try {
+    const dir = join(base, '.gsd', 'exec');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'bad.meta.json'), '{not-json');
+    writeRun(base, 'ok-1');
+    const list = listExecHistory(base);
+    assert.equal(list.length, 1);
+    assert.equal(list[0]!.id, 'ok-1');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('searchExecHistory: filters by query, runtime, and failing_only', () => {
+  const base = freshBase();
+  try {
+    writeRun(base, 'playwright-run', { purpose: 'playwright snapshot' });
+    writeRun(base, 'grep-run', { purpose: 'grep TODOs' });
+    writeRun(base, 'failing-run', { exit_code: 1, purpose: 'boom' });
+    writeRun(base, 'node-run', { runtime: 'node', purpose: 'dedupe' });
+
+    const playwrightHits = searchExecHistory(base, { query: 'playwright' });
+    assert.equal(playwrightHits.length, 1);
+    assert.equal(playwrightHits[0]!.entry.id, 'playwright-run');
+
+    const failingHits = searchExecHistory(base, { failing_only: true });
+    assert.equal(failingHits.length, 1);
+    assert.equal(failingHits[0]!.entry.id, 'failing-run');
+
+    const nodeHits = searchExecHistory(base, { runtime: 'node' });
+    assert.equal(nodeHits.length, 1);
+    assert.equal(nodeHits[0]!.entry.runtime, 'node');
+
+    const unlimited = searchExecHistory(base, {});
+    assert.equal(unlimited.length, 4);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeExecSearch: returns helpful empty-state message when no matches', () => {
+  const base = freshBase();
+  try {
+    const result = executeExecSearch({ query: 'missing' }, { baseDir: base });
+    assert.ok(!result.isError);
+    assert.match(result.content[0].text, /No prior gsd_exec runs/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeExecSearch: includes stdout_path and preview in details', () => {
+  const base = freshBase();
+  try {
+    writeRun(base, 'summary-run', { stdout: 'found 42 TODOs\n' });
+    const result = executeExecSearch({ query: 'summary' }, { baseDir: base });
+    const details = result.details as { results: Array<{ id: string; stdout_path: string }> };
+    assert.equal(details.results.length, 1);
+    assert.equal(details.results[0]!.id, 'summary-run');
+    assert.match(details.results[0]!.stdout_path, /summary-run\.stdout$/);
+    assert.match(result.content[0].text, /found 42 TODOs/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ── Path traversal security tests (issue #4590) ───────────────────────────
+
+test('safeReadMeta: ignores malicious stdout_path in JSON, derives path from meta file location', () => {
+  // Arrange: write a .meta.json whose JSON content has a path-traversal value
+  // in stdout_path / stderr_path. The read-side must silently discard these
+  // and derive sibling paths from the actual .meta.json location instead.
+  const base = freshBase();
+  try {
+    const dir = join(base, '.gsd', 'exec');
+    mkdirSync(dir, { recursive: true });
+    const id = 'traversal-test-run';
+    const metaPath = join(dir, `${id}.meta.json`);
+    const stdoutPath = join(dir, `${id}.stdout`);
+    const stderrPath = join(dir, `${id}.stderr`);
+    // Write real sibling files so digest_preview can succeed.
+    writeFileSync(stdoutPath, 'legitimate stdout content\n');
+    writeFileSync(stderrPath, '');
+    // Write a meta.json that tries to point stdout_path outside the exec dir.
+    writeFileSync(
+      metaPath,
+      JSON.stringify({
+        id,
+        runtime: 'bash',
+        purpose: 'test run',
+        started_at: '2026-04-20T12:00:00.000Z',
+        finished_at: '2026-04-20T12:00:00.100Z',
+        duration_ms: 100,
+        exit_code: 0,
+        signal: null,
+        timed_out: false,
+        stdout_bytes: 24,
+        stderr_bytes: 0,
+        stdout_truncated: false,
+        stderr_truncated: false,
+        // These malicious values must NEVER be used as filesystem paths.
+        stdout_path: '../../etc/passwd',
+        stderr_path: '../../etc/shadow',
+      }),
+    );
+
+    const entries = listExecHistory(base);
+    assert.equal(entries.length, 1);
+    const entry = entries[0]!;
+
+    // stdout_path must be derived from the meta file location, not from JSON.
+    assert.equal(entry.stdout_path, stdoutPath,
+      `stdout_path must be a sibling of the meta file; got: ${entry.stdout_path}`);
+    assert.equal(entry.stderr_path, stderrPath,
+      `stderr_path must be a sibling of the meta file; got: ${entry.stderr_path}`);
+
+    // Verify neither traversal string leaked into the returned entry.
+    assert.ok(!entry.stdout_path.includes('..'),
+      `stdout_path must not contain path traversal sequences: ${entry.stdout_path}`);
+    assert.ok(!entry.stderr_path.includes('..'),
+      `stderr_path must not contain path traversal sequences: ${entry.stderr_path}`);
+    assert.ok(!entry.stdout_path.includes('etc/passwd'),
+      `stdout_path must not point to /etc/passwd: ${entry.stdout_path}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('searchExecHistory: digest_preview is read from derived sibling path, not JSON stdout_path', () => {
+  // Arrange: a .meta.json with a malicious stdout_path pointing to /etc/passwd.
+  // The digest_preview should be read from the real sibling .stdout file,
+  // not from the JSON-supplied path.
+  const base = freshBase();
+  try {
+    const dir = join(base, '.gsd', 'exec');
+    mkdirSync(dir, { recursive: true });
+    const id = 'preview-traversal-run';
+    const metaPath = join(dir, `${id}.meta.json`);
+    const stdoutPath = join(dir, `${id}.stdout`);
+    writeFileSync(stdoutPath, 'safe-sentinel-content\n');
+    writeFileSync(join(dir, `${id}.stderr`), '');
+    writeFileSync(
+      metaPath,
+      JSON.stringify({
+        id,
+        runtime: 'bash',
+        purpose: null,
+        started_at: '2026-04-20T12:00:00.000Z',
+        finished_at: '2026-04-20T12:00:00.100Z',
+        duration_ms: 50,
+        exit_code: 0,
+        signal: null,
+        timed_out: false,
+        stdout_bytes: 21,
+        stderr_bytes: 0,
+        stdout_truncated: false,
+        stderr_truncated: false,
+        // Attacker-controlled path — must be ignored.
+        stdout_path: '/etc/passwd',
+        stderr_path: '/etc/shadow',
+      }),
+    );
+
+    const hits = searchExecHistory(base, {});
+    assert.equal(hits.length, 1);
+    const hit = hits[0]!;
+
+    // The preview must come from the safe sibling, not /etc/passwd.
+    assert.ok(
+      hit.digest_preview?.includes('safe-sentinel-content'),
+      `digest_preview should contain safe-sentinel-content; got: ${hit.digest_preview}`,
+    );
+    // Ensure the entry paths are the derived ones.
+    assert.equal(hit.entry.stdout_path, stdoutPath);
+  } finally {
+    cleanup(base);
+  }
+});