@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

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

@@ -21,7 +21,6 @@ import {
 import type { GateEvaluationConfig, GateId } from "../types.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.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";
@@ -52,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 */
@@ -87,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) => {
@@ -201,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);
   }
 
@@ -212,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];
@@ -223,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,
@@ -310,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}` };
@@ -318,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,
     })),
@@ -329,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 },
@@ -373,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;
+          }
         }
       }
 
@@ -399,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
@@ -437,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 });
         }
@@ -461,14 +468,18 @@ 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();
 
-    // ── Post-mutation hook: projections, manifest, event log ─────────────
+    // ── Post-mutation hook: manifest, event log ─────────────────────────
     try {
-      await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
       writeManifest(basePath);
       appendEvent(basePath, {
         cmd: "plan-slice",

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

@@ -1,14 +1,19 @@
 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 } from "../markdown-renderer.js";
+import { renderTaskPlanFromDb, renderPlanFromDb } from "../markdown-renderer.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 { createRepositoryRegistryFromPreferences, defaultRepositoryTargets, type RepositoryRegistry } from "../repository-registry.js";
+import type { GateId } from "../types.js";
 
 export interface PlanTaskParams {
   milestoneId: string;
@@ -22,6 +27,8 @@ export interface PlanTaskParams {
   inputs: string[];
   expectedOutput: string[];
   observabilityImpact?: string;
+  /** Repository id(s) this task touches (parent workspace); omitted for single-repo projects. */
+  targetRepositories?: string[];
   fullPlanMd?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
@@ -36,6 +43,63 @@ export interface PlanTaskResult {
   taskPlanPath: string;
 }
 
+function validateRepositoryTargetIds(field: string, value: unknown): string[] {
+  const ids = validateStringArray(value, field);
+  if (ids.length === 0) throw new Error(`${field} must include at least one repository id when provided`);
+  const deduped = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+  if (deduped.length === 0) throw new Error(`${field} must include at least one repository id when provided`);
+  return deduped;
+}
+
+function validateReferencedRepositories(
+  targetRepositories: string[] | undefined,
+  registry: RepositoryRegistry,
+): string | null {
+  if (!targetRepositories) return null;
+  const known = new Set(registry.repositories.map((repo) => repo.id));
+  const missing = targetRepositories.filter((id) => !known.has(id));
+  if (missing.length === 0) return null;
+  return `unknown targetRepositories: ${missing.join(", ")}. Declared repositories: ${Array.from(known).join(", ")}`;
+}
+
+function resolveAllowedRootsForPathScope(
+  targetRepositories: string[],
+  registry: RepositoryRegistry,
+): string[] {
+  if (targetRepositories.length === 0) return [registry.projectRoot];
+  const roots = targetRepositories
+    .map((id) => registry.byId.get(id)?.root)
+    .filter((root): root is string => typeof root === "string");
+  return roots.length > 0 ? roots : [registry.projectRoot];
+}
+
+function validatePathScopeForTargetRepositories(
+  params: PlanTaskParams,
+  basePath: string,
+  registry: RepositoryRegistry,
+  targetRepositories: string[],
+): string | null {
+  return validatePlanningPathScope(
+    basePath,
+    [
+      { field: "files", values: params.files },
+      { field: "inputs", values: params.inputs },
+      { field: "expectedOutput", values: params.expectedOutput },
+    ],
+    resolveAllowedRootsForPathScope(targetRepositories, registry),
+  );
+}
+
+function resolveEffectiveTargetRepositories(
+  taskTargetRepositories: string[] | undefined,
+  sliceTargetRepositories: string[] | undefined,
+  defaultTargets: string[],
+): string[] {
+  if (taskTargetRepositories) return taskTargetRepositories;
+  if (sliceTargetRepositories?.length) return sliceTargetRepositories;
+  return defaultTargets;
+}
+
 function validateParams(params: PlanTaskParams): PlanTaskParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
   if (!isNonEmptyString(params?.sliceId)) throw new Error("sliceId is required");
@@ -53,9 +117,18 @@ function validateParams(params: PlanTaskParams): PlanTaskParams {
     files: validateStringArray(params.files, "files"),
     inputs: validateStringArray(params.inputs, "inputs"),
     expectedOutput: validateStringArray(params.expectedOutput, "expectedOutput"),
+    ...(params.targetRepositories !== undefined
+      ? { targetRepositories: validateRepositoryTargetIds("targetRepositories", params.targetRepositories) }
+      : {}),
   };
 }
 
+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,
@@ -74,15 +147,19 @@ export async function handlePlanTask(
     return { error: `validation failed: ${pathOnlyError}` };
   }
 
-  const pathScopeError = validatePlanningPathScope(basePath, [
-    { field: "files", values: params.files },
-    { field: "inputs", values: params.inputs },
-    { field: "expectedOutput", values: params.expectedOutput },
-  ]);
-  if (pathScopeError) {
-    return { error: `validation failed: ${pathScopeError}` };
+  let taskGates: GateId[];
+  let repositoryRegistry: RepositoryRegistry;
+  try {
+    taskGates = resolveTaskGates(basePath);
+    const loaded = loadEffectiveGSDPreferences(basePath);
+    repositoryRegistry = createRepositoryRegistryFromPreferences(basePath, loaded?.preferences);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: `validation failed: ${message}` };
   }
 
+  const defaultTargets = defaultRepositoryTargets(repositoryRegistry);
+
   // ── 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).
@@ -106,6 +183,44 @@ export async function handlePlanTask(
         return;
       }
 
+      let effectiveTargetRepositories = resolveEffectiveTargetRepositories(
+        params.targetRepositories,
+        parentSlice.target_repositories,
+        defaultTargets,
+      );
+      const repoValidationError = validateReferencedRepositories(effectiveTargetRepositories, repositoryRegistry);
+      if (repoValidationError) {
+        guardError = `validation failed: ${repoValidationError}`;
+        return;
+      }
+
+      let pathScopeError = validatePathScopeForTargetRepositories(
+        params,
+        basePath,
+        repositoryRegistry,
+        effectiveTargetRepositories,
+      );
+      const storedTaskTargets = existingTask?.target_repositories?.length
+        ? existingTask.target_repositories
+        : undefined;
+      // Omitted targetRepositories inherit the current slice default first.
+      // Fall back to the stored task target only when that inherited scope
+      // rejects the replan paths, preserving explicit per-task parent-root work.
+      if (pathScopeError && params.targetRepositories === undefined && storedTaskTargets) {
+        const storedRepoValidationError = validateReferencedRepositories(storedTaskTargets, repositoryRegistry);
+        const storedPathScopeError = storedRepoValidationError
+          ? storedRepoValidationError
+          : validatePathScopeForTargetRepositories(params, basePath, repositoryRegistry, storedTaskTargets);
+        if (!storedPathScopeError) {
+          effectiveTargetRepositories = storedTaskTargets;
+          pathScopeError = null;
+        }
+      }
+      if (pathScopeError) {
+        guardError = `validation failed: ${pathScopeError}`;
+        return;
+      }
+
       if (!existingTask) {
         insertTask({
           id: params.taskId,
@@ -125,7 +240,11 @@ export async function handlePlanTask(
         expectedOutput: params.expectedOutput,
         observabilityImpact: params.observabilityImpact ?? "",
         fullPlanMd: params.fullPlanMd,
+        targetRepositories: effectiveTargetRepositories,
       });
+      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}` };
@@ -137,6 +256,26 @@ export async function handlePlanTask(
 
   try {
     const renderResult = await renderTaskPlanFromDb(basePath, params.milestoneId, params.sliceId, params.taskId);
+
+    // 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).
+    let slicePlanSynced = false;
+    try {
+      const tDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+      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/tools/reassess-roadmap.ts

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import { existsSync, unlinkSync } from "node:fs";
+import { relSliceFile, relMilestoneFile } from "../paths.js";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
@@ -119,12 +120,9 @@ export async function handleReassessRoadmap(
   }
 
   // ── Compute assessment artifact path ──────────────────────────────
-  // Assessment lives in the completed slice's directory
-  const assessmentRelPath = join(
-    ".gsd", "milestones", params.milestoneId,
-    "slices", params.completedSliceId,
-    `${params.completedSliceId}-ASSESSMENT.md`,
-  );
+  // Assessment lives in the completed slice's directory.
+  // Use relSliceFile so the path is layout-aware (flat-phase or legacy).
+  const assessmentRelPath = relSliceFile(basePath, params.milestoneId, params.completedSliceId, "ASSESSMENT");
 
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   // Guards must be inside the transaction so the state they check cannot
@@ -276,6 +274,9 @@ export async function handleReassessRoadmap(
   // ── Render artifacts ──────────────────────────────────────────────
   try {
     const roadmapResult = await renderRoadmapFromDb(basePath, params.milestoneId);
+    if ("skipped" in roadmapResult) {
+      return { error: `roadmap render skipped: milestone ${params.milestoneId} has no planned slices` };
+    }
     const assessmentResult = await renderAssessmentFromDb(basePath, params.milestoneId, params.completedSliceId, {
       verdict: params.verdict,
       assessment: params.assessment,
@@ -289,10 +290,8 @@ export async function handleReassessRoadmap(
       params.sliceChanges.removed.length > 0;
 
     if (hasStructuralChanges) {
-      const validationFile = join(
-        basePath, ".gsd", "milestones", params.milestoneId,
-        `${params.milestoneId}-VALIDATION.md`,
-      );
+      // Layout-aware: flat-phase → phases/NN-slug/NN-VALIDATION.md; legacy → milestones/MID/MID-VALIDATION.md
+      const validationFile = join(basePath, relMilestoneFile(basePath, params.milestoneId, "VALIDATION"));
       try {
         if (existsSync(validationFile)) unlinkSync(validationFile);
       } catch (e) {

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -20,7 +20,7 @@ import {
   getMilestoneSlices,
   getMilestone,
 } from "../gsd-db.js";
-import { gsdProjectionRoot, clearPathCache } from "../paths.js";
+import { gsdProjectionRoot, clearPathCache, relMilestoneFile } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -160,12 +160,11 @@ export async function handleValidateMilestone(
   // worktree exists for this milestone, validation reads/writes the
   // worktree's artifacts instead of stale project-root state.
   const validationMd = renderValidationMarkdown(effectiveParams);
-  const validationPath = join(
-    gsdProjectionRoot(artifactBasePath),
-    "milestones",
-    effectiveParams.milestoneId,
-    `${effectiveParams.milestoneId}-VALIDATION.md`,
-  );
+  // Layout-aware: flat-phase → phases/NN-slug/NN-VALIDATION.md;
+  // legacy → milestones/MID/MID-VALIDATION.md.
+  // join(artifactBasePath, relMilestoneFile) gives the absolute path; relMilestoneFile
+  // returns ".gsd/..."-relative so joining with basePath (project/worktree root) is correct.
+  const validationPath = join(artifactBasePath, relMilestoneFile(artifactBasePath, effectiveParams.milestoneId, "VALIDATION"));
 
   // ── DB write first — matches complete-task/complete-slice pattern ───
   // Write DB before disk so a crash between the two leaves a recoverable
@@ -204,12 +203,8 @@ export async function handleValidateMilestone(
     await saveFile(validationPath, validationMd);
     const projectRoot = resolveWorktreeProjectRoot(basePath);
     if (projectRoot !== artifactBasePath) {
-      const projectValidationPath = join(
-        gsdProjectionRoot(projectRoot),
-        "milestones",
-        effectiveParams.milestoneId,
-        `${effectiveParams.milestoneId}-VALIDATION.md`,
-      );
+      // Mirror to project root using the project root's layout (same logic as above).
+      const projectValidationPath = join(projectRoot, relMilestoneFile(projectRoot, effectiveParams.milestoneId, "VALIDATION"));
       try {
         await saveFile(projectValidationPath, validationMd);
       } catch (mirrorErr) {