@opengsd/gsd-pi 1.3.0-dev.965d1788 → 1.3.0-dev.cca9c184

package/src/resources/extensions/gsd/tests/workflow-manifest.test.ts

@@ -24,6 +24,7 @@ import {
 } from '../gsd-db.ts';
 import {
   writeManifest,
+  flushManifest,
   readManifest,
   snapshotState,
   bootstrapFromManifest,
@@ -42,6 +43,11 @@ function cleanupDir(dirPath: string): void {
   try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
 }
 
+async function writeManifestAndFlush(base: string): Promise<void> {
+  writeManifest(base);
+  await flushManifest(base);
+}
+
 function insertMemoryBackedDecision(id: string): void {
   const now = '2026-01-01T00:00:00.000Z';
   insertMemoryRow({
@@ -83,12 +89,14 @@ test('workflow-manifest: readManifest returns null when file does not exist', ()
 
 // ─── writeManifest + readManifest round-trip ─────────────────────────────
 
-test('workflow-manifest: writeManifest creates state-manifest.json with version 1', () => {
+test('workflow-manifest: writeManifest creates state-manifest.json with version 1 after flush', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     writeManifest(base);
     const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    assert.equal(fs.existsSync(manifestPath), false, 'writeManifest should not synchronously write state-manifest.json');
+    await flushManifest(base);
     assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist');
     const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
     assert.strictEqual(raw.version, 1);
@@ -98,11 +106,11 @@ test('workflow-manifest: writeManifest creates state-manifest.json with version
   }
 });
 
-test('workflow-manifest: readManifest parses manifest written by writeManifest', () => {
+test('workflow-manifest: readManifest parses manifest written by writeManifest', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     const manifest = readManifest(base);
     assert.ok(manifest !== null);
     assert.strictEqual(manifest!.version, 1);
@@ -124,6 +132,25 @@ test('workflow-manifest: readManifest parses manifest written by writeManifest',
   }
 });
 
+test('workflow-manifest: flushManifest writes the latest queued payload', async () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001', title: 'First Milestone' });
+    writeManifest(base);
+    insertMilestone({ id: 'M002', title: 'Latest Milestone' });
+    writeManifest(base);
+
+    await flushManifest(base);
+
+    const manifest = readManifest(base);
+    assert.ok(manifest?.milestones.some((m) => m.id === 'M002'), 'latest queued write should be durable');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
 // ─── snapshotState: captures DB rows ─────────────────────────────────────
 
 test('workflow-manifest: snapshotState includes inserted milestone', () => {
@@ -181,7 +208,7 @@ test('workflow-manifest: snapshotState captures memory-backed decisions', () =>
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores extended correctness rows', () => {
+test('workflow-manifest: bootstrapFromManifest restores extended correctness rows', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
@@ -256,7 +283,7 @@ test('workflow-manifest: bootstrapFromManifest restores extended correctness row
       createdAt: '2026-06-05T00:00:00.000Z',
     });
 
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -306,7 +333,7 @@ test('workflow-manifest: bootstrapFromManifest returns false when no manifest fi
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-trip)', () => {
+test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-trip)', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
@@ -326,7 +353,7 @@ test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-
       status: 'complete',
       planning: { fullPlanMd: '# Full Task Plan\n\nKeep this body.', targetRepositories: ['project'] },
     });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     // Open a fresh DB and bootstrap from manifest
@@ -356,14 +383,14 @@ test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest preserves target_repositories', () => {
+test('workflow-manifest: bootstrapFromManifest preserves target_repositories', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMilestone({ id: 'M001', title: 'Restored Milestone' });
     insertSlice({ id: 'S01', milestoneId: 'M001', planning: { targetRepositories: ['frontend'] } });
     insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', planning: { targetRepositories: ['backend'] } });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -380,7 +407,7 @@ test('workflow-manifest: bootstrapFromManifest preserves target_repositories', (
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest does not truncate projections when artifact content is empty', () => {
+test('workflow-manifest: bootstrapFromManifest does not truncate projections when artifact content is empty', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
@@ -401,7 +428,7 @@ test('workflow-manifest: bootstrapFromManifest does not truncate projections whe
       task_id: null,
       full_content: '# Manifest Validation',
     });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
 
     const planPath = path.join(base, '.gsd', 'milestones', 'M001', 'M001-PLAN.md');
     const validationPath = path.join(base, '.gsd', 'milestones', 'M001', 'M001-VALIDATION.md');
@@ -434,14 +461,14 @@ test('workflow-manifest: bootstrapFromManifest does not truncate projections whe
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest preserves optional rows from old manifests', () => {
+test('workflow-manifest: bootstrapFromManifest preserves optional rows from old manifests', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMilestone({ id: 'M001', title: 'Old Manifest Milestone' });
     insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Old Manifest Slice' });
     insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Old Manifest Task' });
-    writeManifest(base);
+    await writeManifestAndFlush(base);
 
     const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
     const oldManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as Record<string, unknown>;
@@ -504,12 +531,12 @@ test('workflow-manifest: bootstrapFromManifest preserves optional rows from old
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions', () => {
+test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMemoryBackedDecision('D901');
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');
@@ -526,12 +553,12 @@ test('workflow-manifest: bootstrapFromManifest restores memory-backed decisions'
   }
 });
 
-test('workflow-manifest: bootstrapFromManifest replaces stale memory-backed decisions', () => {
+test('workflow-manifest: bootstrapFromManifest replaces stale memory-backed decisions', async () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));
   try {
     insertMemoryBackedDecision('D902');
-    writeManifest(base);
+    await writeManifestAndFlush(base);
     closeDatabase();
 
     const newDbPath = path.join(base, 'new.db');

package/src/resources/extensions/gsd/tests/workflow-mcp-preflight.test.ts

@@ -29,6 +29,7 @@ test("preflight uses inline workflow MCP config when no project config is persis
         `const { StdioServerTransport } = await import(${JSON.stringify(stdioModuleUrl)});`,
         'const server = new McpServer({ name: "fake", version: "1.0.0" }, { capabilities: { tools: {} } });',
         'server.tool("gsd_plan_slice", "Plan slice", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
+        'server.tool("gsd_plan_task", "Plan task", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
         'server.tool("gsd_reassess_roadmap", "Reassess roadmap", {}, async () => ({ content: [{ type: "text", text: "ok" }] }));',
         'await server.connect(new StdioServerTransport());',
       ].join("\n"),

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -65,14 +65,18 @@ test("auto execute-task requires canonical task completion tool", () => {
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), expected);
 });
 
-test("plan-slice requires planning and roadmap reassessment tools", () => {
-  const expected = ["gsd_plan_slice", "gsd_reassess_roadmap"];
+test("plan-slice requires slice + incremental task planning and roadmap reassessment tools", () => {
+  // Incremental planning (#1027): gsd_plan_slice persists metadata, then
+  // gsd_plan_task adds tasks one at a time, so both must be on the surface.
+  const expected = ["gsd_plan_slice", "gsd_plan_task", "gsd_reassess_roadmap"];
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("plan-slice"), expected);
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("plan-slice"), expected);
 });
 
-test("plan-milestone requires status, roadmap, and single-slice planning tools", () => {
-  const expected = ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice"];
+test("plan-milestone requires status, roadmap, and slice + task planning tools", () => {
+  // gsd_plan_task is required alongside gsd_plan_slice for incremental
+  // milestone planning (#1027).
+  const expected = ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice", "gsd_plan_task"];
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("plan-milestone"), expected);
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("plan-milestone"), expected);
 });

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -781,22 +781,23 @@ test("executePlanSlice writes task planning state and rendered plan artifacts",
   }
 });
 
-test("executePlanSlice marks validation failures with isError", async () => {
+test("executePlanSlice accepts metadata-only incremental planning payloads", async () => {
   const base = makeTmpBase();
   try {
     openTestDb(base);
+    await inProjectDir(base, () => executePlanMilestone(validMilestonePlan(), base));
 
     const result = await inProjectDir(base, () => executePlanSlice({
       milestoneId: "M001",
       sliceId: "S01",
-      goal: "Trigger validation failure for empty tasks.",
+      goal: "Persist slice metadata before tasks.",
       tasks: [],
     }, base));
 
-    assert.equal(result.isError, true);
     assert.equal(result.details.operation, "plan_slice");
-    assert.match(String(result.details.error), /validation failed: tasks must be a non-empty array/);
-    assert.match(result.content[0].text, /Error planning slice:/);
+    assert.equal(result.details.sliceId, "S01");
+    assert.equal(result.isError, undefined);
+    assert.match(result.content[0].text, /Planned slice S01/);
   } finally {
     closeDatabase();
     cleanup(base);

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -51,7 +51,7 @@ export interface PlanSliceParams {
   milestoneId: string;
   sliceId: string;
   goal: string;
-  tasks: PlanSliceTaskInput[];
+  tasks?: PlanSliceTaskInput[];
   /** @optional — omitted fields render as conservative defaults */
   successCriteria?: string;
   /** @optional — omitted fields render as conservative defaults */
@@ -86,10 +86,12 @@ function validateRepositoryTargetIds(
   return deduped;
 }
 
-function validateTasks(value: unknown): PlanSliceTaskInput[] {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error("tasks must be a non-empty array");
+function validateTasks(value: unknown): PlanSliceTaskInput[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value)) {
+    throw new Error("tasks must be an array");
   }
+  if (value.length === 0) return undefined;
 
   const seen = new Set<string>();
   return value.map((entry, index) => {
@@ -200,7 +202,7 @@ function validateReferencedRepositories(
   };
 
   for (const id of params.targetRepositories ?? defaultTargets) noteMissing(id);
-  for (const task of params.tasks) {
+  for (const task of params.tasks ?? []) {
     for (const id of task.targetRepositories ?? params.targetRepositories ?? defaultTargets) noteMissing(id);
   }
 
@@ -211,7 +213,7 @@ function validateReferencedRepositories(
 function resolveAllowedRootsForPathScope(params: PlanSliceParams, registry: RepositoryRegistry, defaultTargets: string[]): string[] {
   const requested = new Set<string>();
   for (const id of params.targetRepositories ?? defaultTargets) requested.add(id);
-  for (const task of params.tasks) {
+  for (const task of params.tasks ?? []) {
     for (const id of task.targetRepositories ?? params.targetRepositories ?? defaultTargets) requested.add(id);
   }
   if (requested.size === 0) return [registry.projectRoot];
@@ -222,7 +224,7 @@ function resolveAllowedRootsForPathScope(params: PlanSliceParams, registry: Repo
 }
 
 function toTaskRows(params: PlanSliceParams, defaultTargets: string[]): TaskRow[] {
-  return params.tasks.map((task, index) => ({
+  return (params.tasks ?? []).map((task, index) => ({
     milestone_id: params.milestoneId,
     slice_id: params.sliceId,
     id: task.taskId,
@@ -309,6 +311,8 @@ export async function handlePlanSlice(
     return { error: `validation failed: ${message}` };
   }
   const defaultTargets = defaultRepositoryTargets(repositoryRegistry);
+  const taskPayload = params.tasks ?? [];
+  const hasTaskPayload = taskPayload.length > 0;
   const repoValidationError = validateReferencedRepositories(params, repositoryRegistry, defaultTargets);
   if (repoValidationError) {
     return { error: `validation failed: ${repoValidationError}` };
@@ -317,7 +321,7 @@ export async function handlePlanSlice(
   const allowedAbsoluteRoots = resolveAllowedRootsForPathScope(params, repositoryRegistry, defaultTargets);
 
   const pathOnlyError = validatePathOnlyPlanningFields(
-    params.tasks.map((task, index) => ({
+    taskPayload.map((task, index) => ({
       field: `tasks[${index}].expectedOutput`,
       values: task.expectedOutput,
     })),
@@ -328,7 +332,7 @@ export async function handlePlanSlice(
 
   const pathScopeError = validatePlanningPathScope(
     basePath,
-    params.tasks.flatMap((task, index) => [
+    taskPayload.flatMap((task, index) => [
       { field: `tasks[${index}].files`, values: task.files },
       { field: `tasks[${index}].inputs`, values: task.inputs },
       { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
@@ -372,16 +376,18 @@ export async function handlePlanSlice(
         return;
       }
 
-      const newTaskIds = new Set(params.tasks.map((task) => task.taskId));
+      const newTaskIds = new Set(taskPayload.map((task) => task.taskId));
       const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
-      omittedTaskIds = existingTasks
-        .filter((task) => !newTaskIds.has(task.id))
-        .map((task) => task.id);
-
-      for (const task of existingTasks) {
-        if (!newTaskIds.has(task.id) && isClosedStatus(task.status)) {
-          guardError = `cannot remove completed task ${task.id}`;
-          return;
+      if (hasTaskPayload) {
+        omittedTaskIds = existingTasks
+          .filter((task) => !newTaskIds.has(task.id))
+          .map((task) => task.id);
+
+        for (const task of existingTasks) {
+          if (!newTaskIds.has(task.id) && isClosedStatus(task.status)) {
+            guardError = `cannot remove completed task ${task.id}`;
+            return;
+          }
         }
       }
 
@@ -398,35 +404,37 @@ export async function handlePlanSlice(
         targetRepositories: params.targetRepositories ?? defaultTargets,
       });
 
-      for (const taskId of omittedTaskIds) {
-        deleteTask(params.milestoneId, params.sliceId, taskId);
-      }
+      if (hasTaskPayload) {
+        for (const taskId of omittedTaskIds) {
+          deleteTask(params.milestoneId, params.sliceId, taskId);
+        }
 
-      const existingTaskById = new Map(existingTasks.map((task) => [task.id, task]));
-      for (const task of params.tasks) {
-        const planning = {
-          title: task.title,
-          description: task.description,
-          estimate: task.estimate,
-          files: task.files,
-          verify: task.verify,
-          inputs: task.inputs,
-          expectedOutput: task.expectedOutput,
-          observabilityImpact: task.observabilityImpact ?? "",
-          fullPlanMd: task.fullPlanMd,
-          targetRepositories: task.targetRepositories ?? params.targetRepositories ?? defaultTargets,
-        };
-        const existingTask = existingTaskById.get(task.taskId);
-        if (!existingTask || !isClosedStatus(existingTask.status)) {
-          insertTask({
-            id: task.taskId,
-            sliceId: params.sliceId,
-            milestoneId: params.milestoneId,
+        const existingTaskById = new Map(existingTasks.map((task) => [task.id, task]));
+        for (const task of taskPayload) {
+          const planning = {
             title: task.title,
-            status: "pending",
-          });
+            description: task.description,
+            estimate: task.estimate,
+            files: task.files,
+            verify: task.verify,
+            inputs: task.inputs,
+            expectedOutput: task.expectedOutput,
+            observabilityImpact: task.observabilityImpact ?? "",
+            fullPlanMd: task.fullPlanMd,
+            targetRepositories: task.targetRepositories ?? params.targetRepositories ?? defaultTargets,
+          };
+          const existingTask = existingTaskById.get(task.taskId);
+          if (!existingTask || !isClosedStatus(existingTask.status)) {
+            insertTask({
+              id: task.taskId,
+              sliceId: params.sliceId,
+              milestoneId: params.milestoneId,
+              title: task.title,
+              status: "pending",
+            });
+          }
+          upsertTaskPlanning(params.milestoneId, params.sliceId, task.taskId, planning);
         }
-        upsertTaskPlanning(params.milestoneId, params.sliceId, task.taskId, planning);
       }
 
       // Seed quality gate rows inside the transaction — all-or-nothing with
@@ -436,7 +444,7 @@ export async function handlePlanSlice(
         insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "slice" });
       }
       const taskGates = resolveTaskGates(gateEvaluation);
-      for (const task of params.tasks) {
+      for (const task of taskPayload) {
         for (const gid of taskGates) {
           insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: task.taskId });
         }
@@ -460,8 +468,13 @@ export async function handlePlanSlice(
       deleteArtifactByPath(artifactPath);
     }
 
-    const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
-    setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+    const sliceTasks = getSliceTasks(params.milestoneId, params.sliceId);
+    const renderResult = sliceTasks.length === 0
+      ? { planPath: "", taskPlanPaths: [] as string[] }
+      : await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+    if (sliceTasks.length > 0) {
+      setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+    }
     invalidateStateCache();
     clearParseCache();
 

package/src/resources/extensions/gsd/tools/plan-task.ts

@@ -1,15 +1,18 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
-import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
+import { getGateIdsForTurn } from "../gate-registry.js";
+import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning, insertGateRow, setSliceSketchFlag } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb, renderPlanFromDb } from "../markdown-renderer.js";
-import { resolveSliceFile, resolveTasksDir } from "../paths.js";
+import { resolveTasksDir } from "../paths.js";
 import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
+import type { GateId } from "../types.js";
 
 export interface PlanTaskParams {
   milestoneId: string;
@@ -57,6 +60,12 @@ function validateParams(params: PlanTaskParams): PlanTaskParams {
   };
 }
 
+function resolveTaskGates(basePath: string): GateId[] {
+  const loaded = loadEffectiveGSDPreferences(basePath);
+  if (loaded?.preferences?.gate_evaluation?.task_gates === false) return [];
+  return [...getGateIdsForTurn("execute-task")];
+}
+
 export async function handlePlanTask(
   rawParams: PlanTaskParams,
   basePath: string,
@@ -84,6 +93,14 @@ export async function handlePlanTask(
     return { error: `validation failed: ${pathScopeError}` };
   }
 
+  let taskGates: GateId[];
+  try {
+    taskGates = resolveTaskGates(basePath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: `validation failed: ${message}` };
+  }
+
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   // Guards must be inside the transaction so the state they check cannot
   // change between the read and the write (#2723).
@@ -127,6 +144,9 @@ export async function handlePlanTask(
         observabilityImpact: params.observabilityImpact ?? "",
         fullPlanMd: params.fullPlanMd,
       });
+      for (const gid of taskGates) {
+        insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: params.taskId });
+      }
     });
   } catch (err) {
     return { error: `db write failed: ${(err as Error).message}` };
@@ -142,17 +162,22 @@ export async function handlePlanTask(
     // Flat-phase: tasks live as checkboxes in the slice plan's <tasks> block,
     // not as standalone TID-PLAN.md files. Re-render the slice plan so the
     // new/updated task appears in the plan file that gsd-core reads.
-    // Guard: resolveTasksDir is null in flat-phase (no tasks/ subdir exists);
-    //        only sync if a slice plan already exists (guards pre-plan-slice calls).
+    // Guard: resolveTasksDir is null in flat-phase (no tasks/ subdir exists).
+    let slicePlanSynced = false;
     try {
       const tDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-      if (!tDir && resolveSliceFile(basePath, params.milestoneId, params.sliceId, "PLAN")) {
+      if (!tDir) {
         await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+        slicePlanSynced = true;
       }
     } catch (syncErr) {
       logWarning("tool", `plan-task: slice-plan sync failed: ${(syncErr as Error).message}`);
     }
 
+    if (slicePlanSynced) {
+      setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+    }
+
     invalidateStateCache();
     clearParseCache();
 

package/src/resources/extensions/gsd/unit-registry.ts

@@ -117,10 +117,11 @@ export const UNIT_REGISTRY = {
         "gsd_milestone_status",
         "gsd_plan_milestone",
         "gsd_plan_slice",
+        "gsd_plan_task",
         "gsd_decision_save",
         "gsd_requirement_update",
       ],
-      requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice"],
+      requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice", "gsd_plan_task"],
     },
   },
   "discuss-milestone": {
@@ -219,13 +220,14 @@ export const UNIT_REGISTRY = {
       allowedGsdTools: [
         "gsd_milestone_status",
         "gsd_plan_slice",
+        "gsd_plan_task",
         "gsd_reassess_roadmap",
         "gsd_decision_save",
         "gsd_exec",
         "gsd_exec_search",
         "gsd_resume",
       ],
-      requiredWorkflowTools: ["gsd_plan_slice", "gsd_reassess_roadmap"],
+      requiredWorkflowTools: ["gsd_plan_slice", "gsd_plan_task", "gsd_reassess_roadmap"],
     },
   },
   "refine-slice": {