@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/tests/plan-slice.test.ts

@@ -8,6 +8,7 @@ import { tmpdir } from 'node:os';
 
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getSlice, getSliceTasks, getTask, getGateResults, updateTaskStatus } from '../gsd-db.ts';
 import { handlePlanSlice } from '../tools/plan-slice.ts';
+import { handlePlanTask } from '../tools/plan-task.ts';
 import { parsePlan } from '../parsers-legacy.ts';
 import { deriveState, invalidateStateCache } from '../state.ts';
 
@@ -511,15 +512,113 @@ test('handlePlanSlice leaves omitted enrichment fields empty instead of renderin
   }
 });
 
-test('handlePlanSlice rejects invalid payloads', async () => {
+test('handlePlanSlice accepts metadata-only payloads without deleting existing tasks', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
 
   try {
     seedParentSlice();
-    const result = await handlePlanSlice({ ...validParams(), tasks: [] }, base);
-    assert.ok('error' in result);
-    assert.match(result.error, /validation failed: tasks must be a non-empty array/);
+    const first = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
+    assert.equal(getSliceTasks('M001', 'S02').length, 2);
+
+    const second = await handlePlanSlice({
+      milestoneId: 'M001',
+      sliceId: 'S02',
+      goal: 'Persist updated slice metadata before incremental tasks.',
+      successCriteria: '- Metadata renders before task planning',
+      proofLevel: 'unit',
+      integrationClosure: 'Task details follow through gsd_plan_task.',
+      observabilityImpact: 'Progress survives between tool calls.',
+    }, base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
+    assert.equal(getSlice('M001', 'S02')?.goal, 'Persist updated slice metadata before incremental tasks.');
+    assert.deepEqual(getSliceTasks('M001', 'S02').map((task) => task.id), ['T01', 'T02']);
+
+    const third = await handlePlanSlice({ ...validParams(), tasks: [] }, base);
+    assert.ok(!('error' in third), `unexpected error: ${'error' in third ? third.error : ''}`);
+    assert.deepEqual(getSliceTasks('M001', 'S02').map((task) => task.id), ['T01', 'T02']);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice metadata-only on a fresh sketch slice keeps is_sketch set and renders no PLAN.md (#1027)', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.', isSketch: true });
+
+    // The incremental flow's first call carries metadata only (no tasks). It
+    // must NOT error (renderPlanFromDb throws on a task-less slice), and it must
+    // NOT clear the sketch flag — clearing it without a PLAN.md would leave the
+    // slice out of refining with no plan artifact, breaking sketch/plan signaling.
+    const result = await handlePlanSlice({
+      milestoneId: 'M001',
+      sliceId: 'S02',
+      goal: 'Persist slice metadata before any tasks exist.',
+    }, base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.equal(getSlice('M001', 'S02')?.goal, 'Persist slice metadata before any tasks exist.');
+    assert.equal(getSliceTasks('M001', 'S02').length, 0);
+    assert.equal(getSlice('M001', 'S02')?.is_sketch, 1, 'sketch flag must stay set until a task-bearing plan renders');
+
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    assert.ok(!existsSync(planPath), 'no PLAN.md should be rendered until the first task is planned');
+
+    invalidateStateCache();
+    const after = await deriveState(base);
+    assert.equal(after.phase, 'refining', 'a task-less sketch slice stays in refining');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask materializes the slice PLAN.md and clears the sketch flag on the incremental path (#1027)', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.', isSketch: true });
+
+    const sliceResult = await handlePlanSlice({
+      milestoneId: 'M001',
+      sliceId: 'S02',
+      goal: 'Incrementally planned slice.',
+      successCriteria: '- The slice plan is built up one task at a time',
+    }, base);
+    assert.ok(!('error' in sliceResult), `unexpected error: ${'error' in sliceResult ? sliceResult.error : ''}`);
+
+    const taskResult = await handlePlanTask({
+      milestoneId: 'M001',
+      sliceId: 'S02',
+      taskId: 'T01',
+      title: 'First incremental task',
+      description: 'Implement the first task added through gsd_plan_task.',
+      estimate: '30m',
+      files: ['src/resources/extensions/gsd/tools/plan-task.ts'],
+      verify: 'node --test src/resources/extensions/gsd/tests/plan-task.test.ts',
+      inputs: ['src/resources/extensions/gsd/tools/plan-milestone.ts'],
+      expectedOutput: ['src/resources/extensions/gsd/tools/plan-task.ts'],
+    }, base);
+    assert.ok(!('error' in taskResult), `unexpected error: ${'error' in taskResult ? taskResult.error : ''}`);
+
+    // The first incremental task materializes the canonical slice PLAN.md with
+    // the task present, and clears the sketch flag now that a plan exists.
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    assert.ok(existsSync(planPath), 'slice PLAN.md should exist after the first task is planned');
+    const parsedPlan = parsePlan(readFileSync(planPath, 'utf-8'));
+    assert.equal(parsedPlan.goal, 'Incrementally planned slice.');
+    assert.equal(parsedPlan.tasks.length, 1);
+    assert.equal(parsedPlan.tasks[0]?.id, 'T01');
+    assert.equal(getSlice('M001', 'S02')?.is_sketch, 0, 'sketch flag must clear once the first task renders a plan');
+
+    invalidateStateCache();
+    const after = await deriveState(base);
+    assert.notEqual(after.phase, 'refining', 'a planned slice leaves refining');
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/plan-task.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getTask } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getSlice, getTask, getSliceTasks, getGateResults } from '../gsd-db.ts';
 import { handlePlanTask } from '../tools/plan-task.ts';
 import { parseTaskPlanFile } from '../files.ts';
 
@@ -24,6 +24,26 @@ function seedParent(): void {
   insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.' });
 }
 
+function writeParentWorkspacePreferences(base: string): void {
+  mkdirSync(join(base, 'frontend', 'src'), { recursive: true });
+  mkdirSync(join(base, 'backend', 'src'), { recursive: true });
+  writeFileSync(
+    join(base, '.gsd', 'PREFERENCES.md'),
+    [
+      '---',
+      'workspace:',
+      '  mode: parent',
+      '  repositories:',
+      '    frontend:',
+      '      path: frontend',
+      '    backend:',
+      '      path: backend',
+      '---',
+    ].join('\n'),
+    'utf-8',
+  );
+}
+
 function validParams() {
   return {
     milestoneId: 'M001',
@@ -65,6 +85,25 @@ test('handlePlanTask writes planning state and renders task plan', async () => {
   }
 });
 
+test('handlePlanTask seeds execute-task gate rows for incremental planning', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const gateIds = getGateResults('M001', 'S02', 'task')
+      .filter((gate) => gate.task_id === 'T02')
+      .map((gate) => gate.gate_id)
+      .sort();
+    assert.deepEqual(gateIds, ['Q5', 'Q6', 'Q7']);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanTask rejects invalid payloads', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -136,6 +175,32 @@ test('handlePlanTask rejects absolute task IO paths outside the active worktree'
   }
 });
 
+test('handlePlanTask rejects parent-checkout task IO paths from an active worktree', async () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), 'gsd-plan-task-project-'));
+  const worktree = join(projectRoot, '.gsd', 'worktrees', 'M001');
+  mkdirSync(join(projectRoot, '.gsd'), { recursive: true });
+  mkdirSync(join(worktree, '.gsd', 'phases', '01-test'), { recursive: true });
+  openDatabase(join(projectRoot, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const parentCheckoutPath = join(projectRoot, 'src', 'index.ts');
+    const result = await handlePlanTask({
+      ...validParams(),
+      files: [parentCheckoutPath],
+      inputs: [parentCheckoutPath],
+      expectedOutput: [parentCheckoutPath],
+    }, worktree);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: files contains path outside allowed repository roots/);
+    assert.match(result.error, new RegExp(worktree.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'parent-checkout paths must not persist worktree task planning');
+  } finally {
+    cleanup(projectRoot);
+  }
+});
+
 test('handlePlanTask rejects missing parent slice', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -170,6 +235,30 @@ test('handlePlanTask surfaces render failures without changing parse-visible tas
   }
 });
 
+test('handlePlanTask keeps the sketch flag set when the flat-phase slice plan sync fails (#1083)', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.', isSketch: true });
+
+    // The per-task render writes T02-PLAN.md and succeeds, but the flat-phase
+    // slice re-render (the canonical PLAN.md that embeds task checkboxes) targets
+    // phases/01-test/01-02-PLAN.md. Pre-creating that path as a directory forces
+    // EISDIR on the slice sync, so the canonical slice plan never reflects the
+    // task. The sketch flag must therefore stay set — the slice keeps refining —
+    // instead of leaving the slice out of refining over a stale plan.
+    mkdirSync(join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md'), { recursive: true });
+
+    const result = await handlePlanTask(validParams(), base);
+    assert.equal(getSlice('M001', 'S02')?.is_sketch, 1, 'sketch flag must stay set when the canonical slice plan could not sync');
+    assert.ok(getTask('M001', 'S02', 'T02'), 'the task itself is still persisted so the slice can re-sync on retry');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanTask reruns idempotently and refreshes parse-visible state', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -200,3 +289,220 @@ test('handlePlanTask reruns idempotently and refreshes parse-visible state', asy
     cleanup(base);
   }
 });
+
+test('handlePlanTask persists targetRepositories for parent-workspace tasks', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: ['project'],
+    }, base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const tasks = getSliceTasks('M001', 'S02');
+    const planned = tasks.find((t) => t.id === 'T02');
+    assert.ok(planned, 'planned task should exist');
+    assert.deepEqual(planned?.target_repositories, ['project']);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask rejects non-array targetRepositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: 'frontend' as unknown as string[],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: targetRepositories/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask rejects empty targetRepositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: [],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: targetRepositories must include at least one repository id when provided/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid target repositories must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask rejects unknown target repositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: ['frontend'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: unknown targetRepositories:/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'unknown target repositories must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask enforces path scope to declared target repositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    mkdirSync(join(base, 'frontend', 'src'), { recursive: true });
+    mkdirSync(join(base, 'backend', 'src'), { recursive: true });
+    writeFileSync(
+      join(base, '.gsd', 'PREFERENCES.md'),
+      [
+        '---',
+        'workspace:',
+        '  mode: parent',
+        '  repositories:',
+        '    frontend:',
+        '      path: frontend',
+        '    backend:',
+        '      path: backend',
+        '---',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: ['frontend'],
+      files: [join(base, 'backend', 'src', 'server.ts')],
+      inputs: ['app.js'],
+      expectedOutput: ['app.js'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: files contains path outside allowed repository roots/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid scoped paths must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask inherits parent slice target repositories for path scope', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    insertSlice({
+      id: 'S02',
+      milestoneId: 'M001',
+      planning: { targetRepositories: ['frontend'] },
+    });
+    writeParentWorkspacePreferences(base);
+
+    const result = await handlePlanTask({
+      ...validParams(),
+      files: [join(base, 'backend', 'src', 'server.ts')],
+      inputs: ['app.js'],
+      expectedOutput: ['app.js'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: files contains path outside allowed repository roots/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'slice-scoped invalid paths must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask preserves stored task target repositories when omitted replan needs them for path scope', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    writeParentWorkspacePreferences(base);
+    insertSlice({
+      id: 'S02',
+      milestoneId: 'M001',
+      planning: { targetRepositories: ['frontend'] },
+    });
+    insertTask({
+      id: 'T02',
+      sliceId: 'S02',
+      milestoneId: 'M001',
+      title: 'Parent root work',
+      status: 'pending',
+      planning: { targetRepositories: ['project'] },
+    });
+
+    const rootFile = join(base, 'root-config.json');
+    const result = await handlePlanTask({
+      ...validParams(),
+      files: [rootFile],
+      inputs: [rootFile],
+      expectedOutput: [rootFile],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.deepEqual(getTask('M001', 'S02', 'T02')?.target_repositories, ['project']);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask follows the current slice target default when omitted replan paths validate there', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    writeParentWorkspacePreferences(base);
+    insertSlice({
+      id: 'S02',
+      milestoneId: 'M001',
+      planning: { targetRepositories: ['frontend'] },
+    });
+    insertTask({
+      id: 'T02',
+      sliceId: 'S02',
+      milestoneId: 'M001',
+      title: 'Child repo work',
+      status: 'pending',
+      planning: { targetRepositories: ['frontend'] },
+    });
+    insertSlice({
+      id: 'S02',
+      milestoneId: 'M001',
+      planning: { targetRepositories: ['backend'] },
+    });
+
+    const backendFile = join(base, 'backend', 'src', 'server.ts');
+    const result = await handlePlanTask({
+      ...validParams(),
+      files: [backendFile],
+      inputs: [backendFile],
+      expectedOutput: [backendFile],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.deepEqual(getTask('M001', 'S02', 'T02')?.target_repositories, ['backend']);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/post-mutation-hook.test.ts

@@ -10,7 +10,7 @@ import * as os from 'node:os';
 import { openDatabase, closeDatabase } from '../gsd-db.ts';
 import { handleCompleteTask } from '../tools/complete-task.ts';
 import { readEvents } from '../workflow-events.ts';
-import { readManifest } from '../workflow-manifest.ts';
+import { flushManifest, readManifest } from '../workflow-manifest.ts';
 
 function tempDir(): string {
   return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-post-hook-'));
@@ -115,8 +115,9 @@ test('post-mutation-hook: state-manifest.json exists after handleCompleteTask',
     const result = await handleCompleteTask(makeCompleteTaskParams(), base);
     assert.ok(!('error' in result), `handler should succeed, got: ${JSON.stringify(result)}`);
 
+    await flushManifest(base);
     const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
-    assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist after handler completes');
+    assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist after manifest flush');
   } finally {
     closeDatabase();
     cleanupDir(base);
@@ -131,6 +132,7 @@ test('post-mutation-hook: manifest has version 1 and includes completed task', a
 
   try {
     await handleCompleteTask(makeCompleteTaskParams(), base);
+    await flushManifest(base);
 
     const manifest = readManifest(base);
     assert.ok(manifest !== null, 'manifest should be readable');

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

@@ -141,6 +141,26 @@ test("invalid value types produce errors and fall back to undefined", () => {
   }
 });
 
+test("remote_questions accepts object config and false disables without error", () => {
+  const disabled = validatePreferences({ remote_questions: false } as any);
+  assert.equal(disabled.errors.length, 0);
+  assert.equal(disabled.preferences.remote_questions, undefined);
+
+  const configured = validatePreferences({
+    remote_questions: { channel: "telegram", channel_id: "12345" },
+  });
+  assert.equal(configured.errors.length, 0);
+  assert.deepEqual(configured.preferences.remote_questions, {
+    channel: "telegram",
+    channel_id: "12345",
+  });
+
+  for (const value of ["telegram", 0]) {
+    const invalid = validatePreferences({ remote_questions: value } as any);
+    assert.ok(invalid.errors.includes("remote_questions must be an object"));
+  }
+});
+
 test("flat_rate_providers: accepts string array", () => {
   const { errors, preferences } = validatePreferences({
     flat_rate_providers: ["my-proxy", "private-cli"],
@@ -327,6 +347,136 @@ test("workspace.repositories duplicate path error includes both repository ids",
   );
 });
 
+test("workspace.mode parent with no repositories is rejected", () => {
+  const { errors } = validatePreferences({
+    workspace: {
+      mode: "parent",
+    },
+  });
+
+  assert.ok(
+    errors.some((e) =>
+      e.includes('workspace.mode "parent" requires at least one repository under workspace.repositories'),
+    ),
+  );
+});
+
+test("workspace.mode parent with empty repositories map is rejected", () => {
+  const { errors } = validatePreferences({
+    workspace: {
+      mode: "parent",
+      repositories: {},
+    },
+  });
+
+  assert.ok(
+    errors.some((e) =>
+      e.includes('workspace.mode "parent" requires at least one repository under workspace.repositories'),
+    ),
+  );
+});
+
+test("workspace.mode parent with declared repositories is valid", () => {
+  const { errors } = validatePreferences({
+    workspace: {
+      mode: "parent",
+      repositories: {
+        frontend: { path: "frontend" },
+      },
+    },
+  });
+
+  assert.equal(errors.length, 0);
+});
+
+test("mode:team + workspace.mode:parent warns about root-only push/PR", () => {
+  const { warnings } = validatePreferences({
+    mode: "team",
+    workspace: {
+      mode: "parent",
+      repositories: {
+        frontend: { path: "frontend" },
+      },
+    },
+  });
+  const crossAxisWarnings = warnings.filter((w) => w.includes("mode:team + workspace.mode:parent"));
+
+  assert.ok(
+    crossAxisWarnings.some((w) =>
+      w.includes("ADR-044"),
+    ),
+    "expected a cross-axis warning naming ADR-044",
+  );
+  assert.equal(crossAxisWarnings.length, 1, "expected exactly one cross-axis warning");
+});
+
+test("mode:team + workspace.mode:parent warns after global/project merge", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-cross-axis-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-cross-axis-home-"));
+
+  t.after(() => {
+    clearGSDPreferencesCache();
+    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 });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(tempProject);
+  clearGSDPreferencesCache();
+
+  writeFileSync(getGlobalGSDPreferencesPath(), "---\nversion: 1\nmode: team\n---\n", "utf-8");
+  writeFileSync(
+    getProjectGSDPreferencesPath(tempProject),
+    [
+      "---",
+      "version: 1",
+      "workspace:",
+      "  mode: parent",
+      "  repositories:",
+      "    frontend:",
+      "      path: frontend",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const rawGlobalWarnings = loadGlobalGSDPreferences()?.warnings ?? [];
+  const rawProjectWarnings = loadProjectGSDPreferences(tempProject)?.warnings ?? [];
+  assert.equal(rawGlobalWarnings.filter((w) => w.includes("workspace.mode:parent")).length, 0);
+  assert.equal(rawProjectWarnings.filter((w) => w.includes("mode:team + workspace.mode:parent")).length, 0);
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.equal(loaded?.preferences.mode, "team");
+  assert.equal(loaded?.preferences.workspace?.mode, "parent");
+  assert.equal(
+    (loaded?.warnings ?? []).filter((w) => w.includes("mode:team + workspace.mode:parent")).length,
+    1,
+  );
+
+  const diagnostics = collectPreferenceDiagnostics(tempProject).filter((diagnostic) =>
+    diagnostic.message.includes("mode:team + workspace.mode:parent"),
+  );
+  assert.equal(diagnostics.length, 1);
+  assert.equal(diagnostics[0]?.scope, "project");
+});
+
+test("mode:team without workspace.mode:parent does not warn about push", () => {
+  const { warnings } = validatePreferences({
+    mode: "team",
+  });
+
+  assert.ok(
+    !warnings.some((w) => w.includes("workspace.mode:parent")),
+    "team mode alone must not trigger the parent-workspace push warning",
+  );
+});
 
 test("workspace is a recognized preference key (no unknown warning)", () => {
   const { warnings } = validatePreferences({