gsd-pi 2.76.0-dev.b072ebb73 → 2.76.0-dev.fe143342a

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

@@ -0,0 +1,210 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { EXEC_DEFAULTS, runExecSandbox, type ExecSandboxOptions } from '../exec-sandbox.ts';
+import { buildExecOptions, executeGsdExec } from '../tools/exec-tool.ts';
+import { isContextModeEnabled } from '../preferences-types.ts';
+
+function freshBase(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-exec-test-'));
+}
+
+function cleanup(dir: string): void {
+  rmSync(dir, { recursive: true, force: true });
+}
+
+function baseOpts(base: string, overrides: Partial<ExecSandboxOptions> = {}): ExecSandboxOptions {
+  return {
+    baseDir: base,
+    clamp_timeout_ms: EXEC_DEFAULTS.clampTimeoutMs,
+    default_timeout_ms: 10_000,
+    stdout_cap_bytes: 1_024,
+    stderr_cap_bytes: 1_024,
+    digest_chars: 120,
+    env_allowlist: EXEC_DEFAULTS.envAllowlist,
+    ...overrides,
+  };
+}
+
+test('runExecSandbox: captures stdout, persists artifacts, returns digest', async () => {
+  const base = freshBase();
+  try {
+    const result = await runExecSandbox(
+      { runtime: 'bash', script: 'echo hello world' },
+      baseOpts(base),
+    );
+    assert.equal(result.exit_code, 0);
+    assert.equal(result.timed_out, false);
+    assert.ok(result.digest.includes('hello world'), `digest should contain stdout: ${result.digest}`);
+    assert.ok(result.stdout_path.startsWith(join(base, '.gsd', 'exec')), 'stdout path under .gsd/exec');
+    assert.equal(readFileSync(result.stdout_path, 'utf-8').trim(), 'hello world');
+    const meta = JSON.parse(readFileSync(result.meta_path, 'utf-8')) as Record<string, unknown>;
+    assert.equal(meta.runtime, 'bash');
+    assert.equal(meta.exit_code, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('runExecSandbox: enforces stdout cap and marks truncation', async () => {
+  const base = freshBase();
+  try {
+    const result = await runExecSandbox(
+      // Emit far more than the cap so truncation triggers.
+      { runtime: 'bash', script: 'head -c 8000 /dev/urandom | base64' },
+      baseOpts(base, { stdout_cap_bytes: 256 }),
+    );
+    assert.equal(result.stdout_truncated, true, 'should mark stdout truncated');
+    assert.ok(result.stdout_bytes <= 256, `stdout_bytes within cap (got ${result.stdout_bytes})`);
+    const stdout = readFileSync(result.stdout_path, 'utf-8');
+    assert.ok(stdout.endsWith('[truncated: stdout cap reached]\n'), 'truncation marker appended');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('runExecSandbox: enforces timeout and surfaces timed_out', async () => {
+  const base = freshBase();
+  try {
+    const started = Date.now();
+    const result = await runExecSandbox(
+      { runtime: 'bash', script: 'sleep 10' },
+      baseOpts(base, { default_timeout_ms: 150, clamp_timeout_ms: 150 }),
+    );
+    const elapsed = Date.now() - started;
+    assert.equal(result.timed_out, true);
+    assert.ok(elapsed < 5_000, `should return well before 10s (took ${elapsed}ms)`);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('runExecSandbox: forwards only allowlisted env vars', async () => {
+  const base = freshBase();
+  try {
+    const result = await runExecSandbox(
+      { runtime: 'bash', script: 'echo PATH=$PATH SECRET=$GSD_TEST_SECRET' },
+      baseOpts(base, {
+        env_allowlist: [],
+        env: { PATH: '/usr/bin:/bin', HOME: '/tmp', GSD_TEST_SECRET: 'should-be-blocked' },
+      }),
+    );
+    const stdout = readFileSync(result.stdout_path, 'utf-8');
+    assert.ok(stdout.includes('PATH=/usr/bin:/bin'), 'PATH forwarded');
+    assert.ok(!stdout.includes('should-be-blocked'), 'non-allowlisted var blocked');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('runExecSandbox: node runtime executes JS', async () => {
+  const base = freshBase();
+  try {
+    const result = await runExecSandbox(
+      { runtime: 'node', script: 'console.log("node-ok:" + (1+2))' },
+      baseOpts(base),
+    );
+    assert.equal(result.exit_code, 0);
+    assert.ok(result.digest.includes('node-ok:3'));
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ── exec-tool executor ────────────────────────────────────────────────────
+
+test('executeGsdExec: runs by default when context_mode is unset', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      { runtime: 'bash', script: 'echo default-on-run' },
+      { baseDir: base, preferences: {} },
+    );
+    assert.ok(!result.isError, 'should succeed with no preferences');
+    assert.equal(result.details.operation, 'gsd_exec');
+    assert.equal(result.details.exit_code, 0);
+    assert.ok(result.content[0].text.includes('default-on-run'));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: runs when preferences is null (fresh project)', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      { runtime: 'bash', script: 'echo null-prefs-run' },
+      { baseDir: base, preferences: null },
+    );
+    assert.ok(!result.isError, 'null preferences should not disable');
+    assert.ok(result.content[0].text.includes('null-prefs-run'));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: blocked only when context_mode.enabled=false', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      { runtime: 'bash', script: 'echo should-not-run' },
+      { baseDir: base, preferences: { context_mode: { enabled: false } } },
+    );
+    assert.equal(result.isError, true);
+    assert.equal((result.details as { error?: string }).error, 'context_mode_disabled');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: runs when enabled explicitly set to true', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      { runtime: 'bash', script: 'echo explicit-on' },
+      { baseDir: base, preferences: { context_mode: { enabled: true } } },
+    );
+    assert.ok(!result.isError);
+    assert.ok(result.content[0].text.includes('explicit-on'));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: rejects empty script', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      { runtime: 'bash', script: '   ' },
+      { baseDir: base, preferences: { context_mode: { enabled: true } } },
+    );
+    assert.equal(result.isError, true);
+    assert.equal((result.details as { error?: string }).error, 'invalid_params');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('isContextModeEnabled: defaults to true; only explicit false disables', () => {
+  assert.equal(isContextModeEnabled(undefined), true, 'undefined prefs → on');
+  assert.equal(isContextModeEnabled(null), true, 'null prefs → on');
+  assert.equal(isContextModeEnabled({}), true, 'empty prefs → on');
+  assert.equal(isContextModeEnabled({ context_mode: {} }), true, 'empty block → on');
+  assert.equal(isContextModeEnabled({ context_mode: { enabled: true } }), true);
+  assert.equal(isContextModeEnabled({ context_mode: { enabled: false } }), false);
+});
+
+test('buildExecOptions: clamps out-of-range values to safe defaults', () => {
+  const opts = buildExecOptions('/tmp/base', {
+    enabled: true,
+    exec_timeout_ms: 999_999_999,
+    exec_stdout_cap_bytes: 1,
+    exec_digest_chars: -20,
+  });
+  assert.equal(opts.default_timeout_ms, EXEC_DEFAULTS.clampTimeoutMs, 'timeout clamped to upper bound');
+  assert.equal(opts.stdout_cap_bytes, 4_096, 'stdout cap clamped to floor');
+  assert.equal(opts.digest_chars, 0, 'digest chars clamped to floor');
+});

package/src/resources/extensions/gsd/tests/file-change-validator.test.ts

@@ -15,6 +15,26 @@ function git(cwd: string, ...args: string[]): string {
   }).trim();
 }
 
+test("validateFileChanges works on repos with a single commit (no HEAD~1)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-file-change-validator-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  git(base, "init");
+  git(base, "config", "user.email", "test@example.com");
+  git(base, "config", "user.name", "Test User");
+
+  writeFileSync(join(base, "foo.ts"), "export const x = 1;\n");
+  git(base, "add", ".");
+  git(base, "commit", "-m", "initial");
+
+  // With only one commit, HEAD~1 doesn't exist — this must not throw
+  const audit = validateFileChanges(base, ["foo.ts"], []);
+
+  assert.ok(audit, "audit should be produced for single-commit repo");
+  assert.deepEqual(audit.unexpectedFiles, []);
+  assert.deepEqual(audit.missingFiles, []);
+});
+
 test("validateFileChanges ignores inline descriptions in expected output paths", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-file-change-validator-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

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

@@ -3,12 +3,14 @@ import assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { createRequire } from 'node:module';
 import {
   openDatabase,
   closeDatabase,
   isDbAvailable,
   wasDbOpenAttempted,
   getDbProvider,
+  getDbStatus,
   insertDecision,
   getDecisionById,
   insertRequirement,
@@ -26,6 +28,8 @@ import {
   checkpointDatabase,
 } from '../gsd-db.ts';
 
+const _require = createRequire(import.meta.url);
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Helper: create a temp file path for file-backed DB tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -59,6 +63,20 @@ function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
   }
 }
 
+function openRawSqliteForTest(dbPath: string): { exec(sql: string): void; close(): void } {
+  try {
+    const mod = _require('node:sqlite') as { DatabaseSync: new (path: string) => { exec(sql: string): void; close(): void } };
+    return new mod.DatabaseSync(dbPath);
+  } catch {
+    type SqliteCtor = new (path: string) => { exec(sql: string): void; close(): void };
+    const mod = _require('better-sqlite3') as
+      | SqliteCtor
+      | { default: SqliteCtor };
+    const DatabaseCtor: SqliteCtor = typeof mod === 'function' ? mod : mod.default;
+    return new DatabaseCtor(dbPath);
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // gsd-db tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -404,6 +422,53 @@ describe('gsd-db', () => {
     cleanup(dbPath);
   });
 
+  test('gsd-db: legacy DB missing memories.scope opens and bootstraps index columns', () => {
+    const dbPath = tempDbPath();
+    const legacyDb = openRawSqliteForTest(dbPath);
+    legacyDb.exec(`
+      CREATE TABLE schema_version (
+        version INTEGER NOT NULL,
+        applied_at TEXT NOT NULL
+      );
+      INSERT INTO schema_version(version, applied_at) VALUES (17, '2026-04-20T00:00:00.000Z');
+      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
+      );
+      INSERT INTO memories(id, category, content, created_at, updated_at)
+      VALUES ('legacy-memory', 'note', 'legacy row', '2026-04-20T00:00:00.000Z', '2026-04-20T00:00:00.000Z');
+    `);
+    legacyDb.close();
+
+    assert.equal(openDatabase(dbPath), true, 'openDatabase should succeed for legacy DB missing memories.scope');
+
+    const adapter = _getAdapter()!;
+    const columns = adapter.prepare('PRAGMA table_info(memories)').all();
+    const names = columns.map((row) => row['name']);
+    assert.ok(names.includes('scope'), 'memories.scope should be added during bootstrap');
+    assert.ok(names.includes('tags'), 'memories.tags should be added during bootstrap');
+
+    const row = adapter.prepare(`SELECT scope, tags FROM memories WHERE id = 'legacy-memory'`).get();
+    assert.equal(row?.['scope'], 'project', 'legacy rows should receive default scope');
+    assert.equal(row?.['tags'], '[]', 'legacy rows should receive default tags');
+
+    const index = adapter.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_memories_scope'",
+    ).get();
+    assert.equal(index?.['name'], 'idx_memories_scope', 'scope index should be created after bootstrap columns are present');
+
+    cleanup(dbPath);
+  });
+
   test('gsd-db: rowToTask tolerates legacy comma-separated task arrays', () => {
     openDatabase(':memory:');
 
@@ -561,6 +626,92 @@ describe('gsd-db', () => {
     });
   });
 
+  // ─── getDbStatus ───────────────────────────────────────────────────────────
+
+  describe('getDbStatus', () => {
+    test('getDbStatus: initial state before any open', () => {
+      closeDatabase();
+      const status = getDbStatus();
+      assert.strictEqual(status.available, false, 'available false before open');
+      assert.strictEqual(status.attempted, false, 'attempted false before open');
+      assert.strictEqual(status.lastError, null, 'lastError null before open');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase null before open');
+    });
+
+    test('getDbStatus: available after successful open', () => {
+      openDatabase(':memory:');
+      const status = getDbStatus();
+      assert.strictEqual(status.available, true, 'available true after open');
+      assert.strictEqual(status.attempted, true, 'attempted true after open');
+      assert.ok(status.provider !== null, 'provider set after open');
+      assert.strictEqual(status.lastError, null, 'lastError null on success');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase null on success');
+      closeDatabase();
+    });
+
+    test('getDbStatus: resets lastError/lastPhase after closeDatabase', () => {
+      // Simulate a failed open to set error state
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try {
+        openDatabase(corruptPath);
+      } catch {
+        // expected
+      }
+      assert.ok(getDbStatus().lastError !== null, 'lastError set after failed open');
+
+      // closeDatabase should clear it even though no DB was opened
+      closeDatabase();
+      const status = getDbStatus();
+      assert.strictEqual(status.lastError, null, 'lastError cleared by closeDatabase');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase cleared by closeDatabase');
+      assert.strictEqual(status.attempted, false, 'attempted reset by closeDatabase');
+      fs.unlinkSync(corruptPath);
+    });
+
+    test('getDbStatus: captures open-phase error on corrupt file', () => {
+      closeDatabase();
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try {
+        openDatabase(corruptPath);
+      } catch {
+        // expected — both providers should reject a non-SQLite file
+      }
+      const status = getDbStatus();
+      if (!status.available) {
+        // open failed (expected in most environments)
+        assert.strictEqual(status.attempted, true, 'attempted true after failed open');
+        // provider may reject at raw-open level ("open") or at SQL init level ("initSchema")
+        assert.ok(
+          status.lastPhase === 'open' || status.lastPhase === 'initSchema',
+          `lastPhase should be "open" or "initSchema", got: ${status.lastPhase}`,
+        );
+        assert.ok(status.lastError instanceof Error, 'lastError is an Error');
+      }
+      // If somehow it succeeded (unlikely with garbage content), that's also fine
+      closeDatabase();
+      try { fs.unlinkSync(corruptPath); } catch { /* best effort */ }
+    });
+
+    test('getDbStatus: error state resets on next successful open', () => {
+      closeDatabase();
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try { openDatabase(corruptPath); } catch { /* expected */ }
+      assert.ok(!getDbStatus().available, 'DB unavailable after corrupt open');
+
+      // Now open a valid in-memory DB — error state should clear
+      openDatabase(':memory:');
+      const status = getDbStatus();
+      assert.strictEqual(status.available, true, 'available after valid open');
+      assert.strictEqual(status.lastError, null, 'lastError cleared on successful open');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase cleared on successful open');
+      closeDatabase();
+      try { fs.unlinkSync(corruptPath); } catch { /* best effort */ }
+    });
+  });
+
   // ─── Final Report ──────────────────────────────────────────────────────────
 
 });

package/src/resources/extensions/gsd/tests/init-wizard.test.ts

@@ -178,6 +178,33 @@ test("init-wizard: multiple project files detected together", (t) => {
   }
 });
 
+// ─── Git init + initial commit regression (#4530) ───────────────────────────
+
+import { execFileSync } from "node:child_process";
+import { nativeInit, nativeAddAll, nativeCommit } from "../native-git-bridge.ts";
+
+test("init-wizard: nativeInit + nativeAddAll + nativeCommit produces a reachable HEAD (#4530)", (t) => {
+  // Regression: showProjectInit called nativeInit but never committed, leaving
+  // the branch unborn. git log and git worktree add both fail on zero-commit repos.
+  const dir = makeTempDir("git-init-commit");
+  t.after(() => { cleanup(dir); });
+
+  nativeInit(dir, "main");
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: dir });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: dir });
+  writeFileSync(join(dir, ".gitignore"), "*.log\n", "utf-8");
+
+  nativeAddAll(dir);
+  nativeCommit(dir, "chore: init project");
+
+  // git log must succeed (was: fatal: your current branch 'main' does not have any commits yet)
+  const subject = execFileSync("git", ["log", "-1", "--format=%s"], {
+    cwd: dir,
+    encoding: "utf-8",
+  }).trim();
+  assert.equal(subject, "chore: init project");
+});
+
 test("init-wizard: v1 with both .planning/ and .gsd/ prioritizes v2", (t) => {
   const dir = makeTempDir("both-v1-v2");
   try {

package/src/resources/extensions/gsd/tests/isolation-none-branch-guard.test.ts

@@ -42,7 +42,7 @@ describe('isolation:none stale branch guard (#3675)', () => {
   });
 
   test('guard is conditional on isolation mode "none"', () => {
-    assert.match(source, /getIsolationMode\(\)\s*===\s*["']none["']/,
+    assert.match(source, /getIsolationMode\([^)]*\)\s*===\s*["']none["']/,
       'guard should only activate when isolation mode is "none"');
   });
 

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -143,6 +143,13 @@ test("PROVIDER_REGISTRY includes all major LLM providers", () => {
   assert.ok(ids.includes("groq"));
 });
 
+test("PROVIDER_REGISTRY includes claude-code as a first-class LLM provider (#4541)", () => {
+  const entry = PROVIDER_REGISTRY.find((p) => p.id === "claude-code");
+  assert.ok(entry, "claude-code must be in PROVIDER_REGISTRY");
+  assert.equal(entry!.category, "llm");
+  assert.ok(entry!.hasOAuth, "claude-code uses OAuth (CLI auth)");
+});
+
 test("PROVIDER_REGISTRY includes all tool/search providers", () => {
   const ids = PROVIDER_REGISTRY.map((p) => p.id);
   assert.ok(ids.includes("tavily"));

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -30,6 +30,20 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
     assert.equal(normalizeFilePath('``src/foo.ts`` (current state)'), 'src/foo.ts')
   })
 
+  it('strips stray backticks from dash-annotated bare paths (#4550)', () => {
+    assert.equal(
+      normalizeFilePath('.gsd/KNOWLEDGE.md` — append-only S05 lessons section'),
+      '.gsd/KNOWLEDGE.md',
+    )
+  })
+
+  it('prefers a backticked path inside a dash-annotated prefix (#4550)', () => {
+    assert.equal(
+      normalizeFilePath('Input `src/foo.ts` — current state'),
+      'src/foo.ts',
+    )
+  })
+
   it('strips backticks even when mixed with other normalization', () => {
     assert.equal(normalizeFilePath('`./src//bar.ts`'), 'src/bar.ts')
   })

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -140,6 +140,25 @@ import type { Request } from 'express';
     assert.ok(packages.includes("typescript"));
     assert.ok(!packages.includes("-D"));
   });
+
+  // Regression tests for #4388: prose containing `from "..."` must not produce false-positive packages
+  test("does not treat prose 'from \"What's Next\"' as a package name (#4388)", () => {
+    const desc = 'Build the feature described from "What\'s Next" in the roadmap';
+    const packages = extractPackageReferences(desc);
+    assert.deepEqual(packages, [], `prose 'from "What\\'s Next"' must not produce package names, got: ${JSON.stringify(packages)}`);
+  });
+
+  test("does not treat prose \"from 'master'\" as a package name (#4388)", () => {
+    const desc = "Review changes from 'master' branch before merging";
+    const packages = extractPackageReferences(desc);
+    assert.deepEqual(packages, [], `prose "from 'master'" must not produce package names, got: ${JSON.stringify(packages)}`);
+  });
+
+  test("still extracts import statements in code blocks after #4388 fix", () => {
+    const desc = "```typescript\nimport express from 'express';\nimport { Router } from 'express';\n```";
+    const packages = extractPackageReferences(desc);
+    assert.ok(packages.includes("express"), "import...from in code blocks must still be recognized");
+  });
 });
 
 // ─── File Path Consistency Tests ─────────────────────────────────────────────

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

@@ -186,6 +186,45 @@ test("flat_rate_providers is a recognized preference key (no warning)", () => {
   );
 });
 
+test("slice_parallel preferences validate and pass through", () => {
+  const { preferences, errors, warnings } = validatePreferences({
+    slice_parallel: { enabled: true, max_workers: 8 },
+  });
+
+  assert.equal(errors.length, 0);
+  assert.equal(warnings.filter(w => w.includes("slice_parallel")).length, 0);
+  assert.deepEqual(preferences.slice_parallel, { enabled: true, max_workers: 8 });
+});
+
+test("slice_parallel rejects invalid values and warns on unknown keys", () => {
+  const { preferences, errors, warnings } = validatePreferences({
+    slice_parallel: {
+      enabled: "yes",
+      max_workers: 9,
+      future_mode: true,
+    },
+  } as any);
+
+  assert.ok(errors.some(e => e.includes("slice_parallel.enabled")), "should reject non-boolean enabled");
+  assert.ok(errors.some(e => e.includes("slice_parallel.max_workers")), "should reject max_workers outside 1..8");
+  assert.ok(warnings.some(w => w.includes('unknown slice_parallel key "future_mode"')));
+  assert.equal(preferences.slice_parallel, undefined);
+});
+
+test("slice_parallel numeric max_workers is bounded to 1..8", () => {
+  const low = validatePreferences({ slice_parallel: { max_workers: 1 } });
+  const high = validatePreferences({ slice_parallel: { max_workers: 8 } });
+  const tooLow = validatePreferences({ slice_parallel: { max_workers: 0 } });
+  const tooHigh = validatePreferences({ slice_parallel: { max_workers: 9 } });
+
+  assert.equal(low.errors.length, 0);
+  assert.equal(low.preferences.slice_parallel?.max_workers, 1);
+  assert.equal(high.errors.length, 0);
+  assert.equal(high.preferences.slice_parallel?.max_workers, 8);
+  assert.ok(tooLow.errors.some(e => e.includes("slice_parallel.max_workers")));
+  assert.ok(tooHigh.errors.some(e => e.includes("slice_parallel.max_workers")));
+});
+
 test("valid values pass through correctly", () => {
   const { preferences: p1 } = validatePreferences({ budget_enforcement: "halt" });
   assert.equal(p1.budget_enforcement, "halt");
@@ -606,6 +645,44 @@ test("loadEffectiveGSDPreferences preserves experimental prefs across global+pro
   }
 });
 
+test("loadEffectiveGSDPreferences exposes slice_parallel prefs to runtime callers", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-slice-parallel-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-slice-parallel-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "slice_parallel:",
+        "  enabled: true",
+        "  max_workers: 3",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.slice_parallel?.enabled, true);
+    assert.equal(loaded!.preferences.slice_parallel?.max_workers, 3);
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("preferences paths use canonical uppercase filenames", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -632,6 +709,39 @@ test("preferences paths use canonical uppercase filenames", () => {
   }
 });
 
+test("explicit base path preference loading survives a deleted cwd (#4498)", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-base-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-base-home-"));
+  const deletedCwd = mkdtempSync(join(tmpdir(), "gsd-prefs-deleted-cwd-"));
+
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+    rmSync(deletedCwd, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    "---\nversion: 1\nlanguage: Swedish\ngit:\n  isolation: worktree\n---\n",
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(deletedCwd);
+  rmSync(deletedCwd, { recursive: true, force: true });
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.notEqual(loaded, null);
+  assert.equal(loaded!.preferences.language, "Swedish");
+  assert.equal(getIsolationMode(tempProject), "worktree");
+});
+
 test("uppercase PREFERENCES.md wins over legacy lowercase preferences.md", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;