fix(config-get): return schema default for context_window when absent (#2944)

* fix(config-get): return schema default for context_window when absent (#2943)

cmdConfigGet in bin/lib/config.cjs now consults a SCHEMA_DEFAULTS map before
emitting "Key not found", so context_window (and any future schema-defaulted
keys) return their default value (exit 0) when not set in config.json.

Also updates the stale subagent-timeout.test.cjs assertion that expected the
old broken behavior (exit 1 / "Key not found") to match the corrected behavior.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* test: use distinct sentinel to prove --default wins over schema default (#2943)

* docs: update CHANGELOG.md for #2943 fix

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

CHANGELOG.md

@@ -39,6 +39,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   posting a comment that points to the contribution guide. (#2872)
 
 ### Fixed — 1.40.0-rc.1
+- **`config-get context_window` returns `200000` when key absent** — querying an unset `context_window` previously exited 1 with "Key not found", surfacing a confusing error in planning logs even though the workflow fallback worked correctly. `cmdConfigGet` now consults a `SCHEMA_DEFAULTS` map and returns the documented default (`200000`, exit 0) for absent schema-defaulted keys; unknown absent keys still error as before. (#2943)
 - **`gap-analysis` now parses non-`REQ-` requirement IDs and ignores traceability table headers** — `parseRequirements()` no longer hard-codes the `REQ-` prefix and now accepts uppercase prefixed IDs such as `TST-01`, `BACK-07`, and `INSP-04`; markdown table header rows (for example `| REQ-ID | ... |`) are excluded so header tokens are not reported as phantom uncovered requirements. Added regression coverage for mixed-prefix REQUIREMENTS files with traceability tables. (#2897)
 - **Gemini slash commands namespaced as `/gsd:<cmd>` instead of `/gsd-<cmd>`** —
   Gemini CLI namespaces commands under `gsd:`, so `/gsd-plan-phase` was unexecutable.

get-shit-done/bin/lib/config.cjs

@@ -377,6 +377,15 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
   output(setConfigValueResult, raw, `${keyPath}=${parsedValue}`);
 }
 
+/**
+ * Schema-level defaults for well-known config keys.
+ * When a key is absent from config.json and no --default flag was supplied,
+ * cmdConfigGet checks here before emitting "Key not found".
+ */
+const SCHEMA_DEFAULTS = {
+  'context_window': 200000,
+};
+
 function cmdConfigGet(cwd, keyPath, raw, defaultValue) {
   const configPath = path.join(planningDir(cwd), 'config.json');
   const hasDefault = defaultValue !== undefined;
@@ -406,6 +415,11 @@ function cmdConfigGet(cwd, keyPath, raw, defaultValue) {
   for (const key of keys) {
     if (current === undefined || current === null || typeof current !== 'object') {
       if (hasDefault) { output(defaultValue, raw, String(defaultValue)); return; }
+      if (Object.prototype.hasOwnProperty.call(SCHEMA_DEFAULTS, keyPath)) {
+        const def = SCHEMA_DEFAULTS[keyPath];
+        output(def, raw, String(def));
+        return;
+      }
       error(`Key not found: ${keyPath}`);
     }
     current = current[key];
@@ -413,6 +427,11 @@ function cmdConfigGet(cwd, keyPath, raw, defaultValue) {
 
   if (current === undefined) {
     if (hasDefault) { output(defaultValue, raw, String(defaultValue)); return; }
+    if (Object.prototype.hasOwnProperty.call(SCHEMA_DEFAULTS, keyPath)) {
+      const def = SCHEMA_DEFAULTS[keyPath];
+      output(def, raw, String(def));
+      return;
+    }
     error(`Key not found: ${keyPath}`);
   }
 

tests/bug-2943-config-get-context-window-default.test.cjs

@@ -0,0 +1,128 @@
+/**
+ * Regression test for bug #2943
+ *
+ * `gsd-tools.cjs config-get context_window` (and the SDK equivalent) threw
+ * "Key not found: context_window" when the key was absent from config.json,
+ * even though context_window has a documented schema default of 200000.
+ *
+ * Fix: `cmdConfigGet` in bin/lib/config.cjs now consults a SCHEMA_DEFAULTS map
+ * before emitting "Key not found", so schema-defaulted keys always return the
+ * default value (exit 0) when not explicitly set in the project config.
+ */
+
+'use strict';
+
+const { describe, test, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { execFileSync } = require('node:child_process');
+
+const GSD_TOOLS = path.join(__dirname, '..', 'get-shit-done', 'bin', 'gsd-tools.cjs');
+
+describe('bug-2943: config-get returns schema default for context_window', () => {
+  let tmpDir;
+  let planningDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-test-2943-'));
+    planningDir = path.join(tmpDir, '.planning');
+    fs.mkdirSync(planningDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Run config-get with optional extra args. Returns { exitCode, stdout, stderr }.
+   * Uses --raw so we get the plain scalar value, not JSON-wrapped.
+   */
+  function runConfigGet(keyPath, extraArgs = []) {
+    const args = [GSD_TOOLS, 'config-get', keyPath, '--raw', '--cwd', tmpDir, ...extraArgs];
+    let stdout = '';
+    let stderr = '';
+    let exitCode = 0;
+    try {
+      stdout = execFileSync(process.execPath, args, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 5000,
+      });
+    } catch (err) {
+      exitCode = err.status ?? 1;
+      stdout = err.stdout?.toString() ?? '';
+      stderr = err.stderr?.toString() ?? '';
+    }
+    return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+  }
+
+  test('returns "200000" (exit 0) when context_window absent from config.json', () => {
+    // Fixture A: config with unrelated keys, no context_window
+    fs.writeFileSync(
+      path.join(planningDir, 'config.json'),
+      JSON.stringify({ workflow: { auto_advance: false } })
+    );
+
+    const result = runConfigGet('context_window');
+
+    assert.strictEqual(result.exitCode, 0, 'should exit 0 (schema default applied)');
+    assert.strictEqual(result.stdout, '200000', 'should return schema default of 200000');
+  });
+
+  test('returns configured value when context_window is explicitly set', () => {
+    // Fixture B: config has context_window: 1000000
+    fs.writeFileSync(
+      path.join(planningDir, 'config.json'),
+      JSON.stringify({ context_window: 1000000 })
+    );
+
+    const result = runConfigGet('context_window');
+
+    assert.strictEqual(result.exitCode, 0, 'should exit 0 for found key');
+    assert.strictEqual(result.stdout, '1000000', 'should return configured value not schema default');
+  });
+
+  test('--default flag overrides schema default', () => {
+    // config has context_window but we pass --default with a different value —
+    // when key IS present, real value wins over any default
+    fs.writeFileSync(
+      path.join(planningDir, 'config.json'),
+      JSON.stringify({ workflow: { auto_advance: false } })
+    );
+
+    const result = runConfigGet('context_window', ['--default', '123456']);
+
+    assert.strictEqual(result.exitCode, 0, 'should exit 0 when --default provided');
+    assert.strictEqual(result.stdout, '123456', 'should return the --default value, not schema default');
+  });
+
+  test('errors with "Key not found" (exit 1) for an unknown absent key — no regression', () => {
+    // An unrecognised key with no schema default still errors as before
+    fs.writeFileSync(
+      path.join(planningDir, 'config.json'),
+      JSON.stringify({ workflow: { auto_advance: false } })
+    );
+
+    const result = runConfigGet('totally_unknown_key_xyz');
+
+    assert.strictEqual(result.exitCode, 1, 'should exit 1 for unknown absent key');
+    assert.ok(
+      result.stderr.includes('Key not found') || result.stdout.includes('Key not found'),
+      `expected "Key not found" in output, got stderr="${result.stderr}" stdout="${result.stdout}"`
+    );
+  });
+
+  test('--default flag still works for arbitrary absent keys', () => {
+    fs.writeFileSync(
+      path.join(planningDir, 'config.json'),
+      JSON.stringify({})
+    );
+
+    const result = runConfigGet('some.missing.key', ['--default', '200000']);
+
+    assert.strictEqual(result.exitCode, 0, 'should exit 0 when --default supplied');
+    assert.strictEqual(result.stdout, '200000', 'should return the explicit --default value');
+  });
+});

tests/subagent-timeout.test.cjs

@@ -199,16 +199,17 @@ describe('config-get context_window (#1472)', () => {
     assert.strictEqual(output, 1000000);
   });
 
-  test('config-get context_window errors when key is absent', () => {
+  test('config-get context_window returns schema default (200000) when key is absent', () => {
+    // Bug #2943: context_window has a schema-level default of 200000.
+    // config-get must return it (exit 0) rather than "Key not found" (exit 1).
     const configPath = path.join(tmpDir, '.planning', 'config.json');
     fs.writeFileSync(configPath, JSON.stringify({}, null, 2));
 
     const result = runGsdTools('config-get context_window', tmpDir);
-    assert.strictEqual(result.success, false);
-    assert.ok(
-      result.error.includes('Key not found'),
-      `Expected "Key not found" in error: ${result.error}`
-    );
+    assert.ok(result.success, `Expected success but got: ${result.error}`);
+
+    const output = JSON.parse(result.output);
+    assert.strictEqual(output, 200000, 'schema default for context_window should be 200000');
   });
 });