gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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

@@ -15,6 +15,7 @@ import {
   getMilestone,
   getMilestoneSlices,
   getSliceTasks,
+  getLatestAssessmentByScope,
   updateMilestoneStatus,
 } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
@@ -38,9 +39,9 @@ export interface CompleteMilestoneParams {
   definitionOfDoneResults?: string;
   /** @optional — empty/omitted renders as "Not provided." */
   requirementOutcomes?: string;
-  /** @optional — empty/omitted renders as "(none)" */
+  /** @optional — empty/omitted renders as an empty frontmatter list */
   keyDecisions?: string[];
-  /** @optional — empty/omitted renders as "(none)" */
+  /** @optional — empty/omitted renders as an empty frontmatter list */
   keyFiles?: string[];
   /** @optional — empty/omitted renders as "(none)" */
   lessonsLearned?: string[];
@@ -70,12 +71,12 @@ function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams, complet
   const lessonsLearned = params.lessonsLearned ?? [];
 
   const keyDecisionsYaml = keyDecisions.length > 0
-    ? keyDecisions.map(d => `  - ${d}`).join("\n")
-    : "  - (none)";
+    ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+    : " []";
 
   const keyFilesYaml = keyFiles.length > 0
-    ? keyFiles.map(f => `  - ${f}`).join("\n")
-    : "  - (none)";
+    ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+    : " []";
 
   const lessonsYaml = lessonsLearned.length > 0
     ? lessonsLearned.map(l => `  - ${l}`).join("\n")
@@ -86,10 +87,8 @@ id: ${params.milestoneId}
 title: "${displayTitle}"
 status: complete
 completed_at: ${completedAt}
-key_decisions:
-${keyDecisionsYaml}
-key_files:
-${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
+key_files:${keyFilesYaml}
 lessons_learned:
 ${lessonsYaml}
 ---
@@ -158,6 +157,15 @@ export async function handleCompleteMilestone(
       return;
     }
 
+    // Defense-in-depth: only a passing milestone validation permits closeout.
+    const validation = getLatestAssessmentByScope(params.milestoneId, "milestone-validation");
+    if (validation?.status !== "pass") {
+      guardError =
+        `Refusing to complete ${params.milestoneId}: latest milestone-validation verdict is ` +
+        `"${validation?.status ?? "absent"}". Only verdict=pass permits closeout.`;
+      return;
+    }
+
     // Verify all slices are complete
     const slices = getMilestoneSlices(params.milestoneId);
     if (slices.length === 0) {

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

@@ -104,12 +104,12 @@ function renderSliceSummaryMarkdown(params: CompleteSliceParams): string {
     : "  []";
 
   const keyFilesYaml = keyFiles.length > 0
-    ? keyFiles.map(f => `  - ${f}`).join("\n")
-    : "  - (none)";
+    ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+    : " []";
 
   const keyDecisionsYaml = keyDecisions.length > 0
-    ? keyDecisions.map(d => `  - ${d}`).join("\n")
-    : "  - (none)";
+    ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+    : " []";
 
   const patternsYaml = patternsEstablished.length > 0
     ? patternsEstablished.map(p => `  - ${p}`).join("\n")
@@ -155,10 +155,8 @@ requires:
 ${requiresYaml}
 affects:
 ${affectsYaml}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
+key_files:${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
 patterns_established:
 ${patternsYaml}
 observability_surfaces:
@@ -234,6 +232,34 @@ ${params.uatContent}
 `;
 }
 
+function parseRequirementSection(
+  summaryMd: string,
+  heading: "Requirements Advanced" | "Requirements Validated" | "Requirements Invalidated or Re-scoped",
+  field: "how" | "proof" | "what",
+): Array<{ id: string; how?: string; proof?: string; what?: string }> {
+  const headingLine = `## ${heading}\n\n`;
+  const start = summaryMd.indexOf(headingLine);
+  if (start === -1) return [];
+  const contentStart = start + headingLine.length;
+  const nextHeading = summaryMd.indexOf("\n\n## ", contentStart);
+  const content = nextHeading === -1
+    ? summaryMd.slice(contentStart)
+    : summaryMd.slice(contentStart, nextHeading);
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("- "))
+    .map((line) => line.slice(2).trim())
+    .map((line) => {
+      const pair = line.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
+      const id = pair ? pair[1].trim() : line.trim();
+      const detail = pair ? pair[2].trim() : "";
+      if (!id || !detail) return null;
+      return { id, [field]: detail };
+    })
+    .filter((entry): entry is { id: string; how?: string; proof?: string; what?: string } => entry !== null);
+}
+
 /**
  * Handle the complete_slice operation end-to-end.
  *
@@ -279,6 +305,7 @@ export async function handleCompleteSlice(
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
   let guardError: string | null = null;
+  let existingSummaryMd = "";
 
   transaction(() => {
     // State machine preconditions (inside txn for atomicity).
@@ -291,6 +318,7 @@ export async function handleCompleteSlice(
     }
 
     const slice = getSlice(params.milestoneId, params.sliceId);
+    existingSummaryMd = slice?.full_summary_md?.trim() ?? "";
     if (slice && isClosedStatus(slice.status)) {
       if (isStaleWrite("complete-slice")) {
         guardError = "__stale_duplicate__";
@@ -349,8 +377,27 @@ export async function handleCompleteSlice(
     return { error: guardError };
   }
 
+  const effectiveParams: CompleteSliceParams = { ...params };
+  if (existingSummaryMd) {
+    // Keep these heading names in lock-step with renderSliceSummaryMarkdown's
+    // section titles so omitted CompleteSliceParams requirement fields can be
+    // backfilled from previously rendered summary markdown.
+    if (effectiveParams.requirementsAdvanced === undefined) {
+      const parsed = parseRequirementSection(existingSummaryMd, "Requirements Advanced", "how");
+      if (parsed.length > 0) effectiveParams.requirementsAdvanced = parsed as Array<{ id: string; how: string }>;
+    }
+    if (effectiveParams.requirementsValidated === undefined) {
+      const parsed = parseRequirementSection(existingSummaryMd, "Requirements Validated", "proof");
+      if (parsed.length > 0) effectiveParams.requirementsValidated = parsed as Array<{ id: string; proof: string }>;
+    }
+    if (effectiveParams.requirementsInvalidated === undefined) {
+      const parsed = parseRequirementSection(existingSummaryMd, "Requirements Invalidated or Re-scoped", "what");
+      if (parsed.length > 0) effectiveParams.requirementsInvalidated = parsed as Array<{ id: string; what: string }>;
+    }
+  }
+
   // Render summary markdown
-  const summaryMd = renderSliceSummaryMarkdown(params);
+  const summaryMd = renderSliceSummaryMarkdown(effectiveParams);
 
   // Resolve and write summary to disk
   let summaryPath: string;
@@ -365,7 +412,7 @@ export async function handleCompleteSlice(
     summaryPath = join(manualSliceDir, `${params.sliceId}-SUMMARY.md`);
   }
 
-  const uatMd = renderUatMarkdown(params);
+  const uatMd = renderUatMarkdown(effectiveParams);
   const uatPath = summaryPath.replace(/-SUMMARY\.md$/, "-UAT.md");
   setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
   let projectionStale = false;

package/src/resources/extensions/gsd/tools/exec-tool.ts

@@ -1,8 +1,5 @@
-// GSD Exec Tool — executor for the gsd_exec MCP tool.
-//
-// Thin wrapper around exec-sandbox.ts that reads effective options from
-// the project preferences (context_mode block) and formats the result
-// for MCP return.
+// Project/App: GSD-2
+// File Purpose: Executor for the gsd_exec MCP tool.
 
 import {
   EXEC_DEFAULTS,
@@ -11,6 +8,7 @@ import {
   type ExecSandboxRequest,
   type ExecSandboxResult,
 } from "../exec-sandbox.js";
+import path from "node:path";
 import { isContextModeEnabled, type ContextModeConfig } from "../preferences-types.js";
 import { contextModeDisabledResult, type ToolExecutionResult } from "./context-mode-tool-result.js";
 
@@ -81,6 +79,93 @@ function paramError(message: string): ToolExecutionResult {
   };
 }
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function normalizeScanPath(value: string): string {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+
+function parseWorktreeBase(baseDir: string): { originalRoot: string; worktreeRoot: string } | null {
+  const normalizedBase = normalizeScanPath(baseDir);
+  const marker = "/.gsd/worktrees/";
+  const markerIndex = normalizedBase.indexOf(marker);
+  if (markerIndex <= 0) return null;
+  return {
+    originalRoot: normalizedBase.slice(0, markerIndex),
+    worktreeRoot: normalizedBase,
+  };
+}
+
+function pathInside(parent: string, target: string): boolean {
+  const parentWithSep = parent.endsWith("/") ? parent : `${parent}/`;
+  return target === parent || target.startsWith(parentWithSep);
+}
+
+function stripWrappingQuotes(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) return trimmed;
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+  if ((first === "'" || first === '"' || first === "`") && last === first) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+
+function extractPathLikeValues(script: string): string[] {
+  const values: string[] = [];
+  const push = (candidate: string) => {
+    const cleaned = stripWrappingQuotes(candidate).trim();
+    if (!cleaned) return;
+    values.push(cleaned);
+  };
+  const pushQuotedLiterals = (source: string, depth = 0) => {
+    for (const match of source.matchAll(/(["'`])((?:\\.|(?!\1).)*)\1/g)) {
+      push(match[2]);
+      if (depth < 2 && /["'`]/.test(match[2])) {
+        pushQuotedLiterals(match[2], depth + 1);
+      }
+    }
+  };
+
+  for (const match of script.matchAll(/(?:^|[;\n\r]|\&\&|\|\|)\s*cd\s+([^\n\r;|&]+)/g)) {
+    push(match[1]);
+  }
+  for (const match of script.matchAll(/process\.chdir\(\s*([^\n\r;]+?)\s*\)/g)) {
+    push(match[1]);
+    pushQuotedLiterals(match[1]);
+  }
+  pushQuotedLiterals(script);
+  return values;
+}
+
+function resolvesToOriginalRootOutsideWorktree(script: string, baseDir: string): boolean {
+  const parsed = parseWorktreeBase(baseDir);
+  if (!parsed) return false;
+
+  const normalizedWorktree = normalizeScanPath(path.resolve(parsed.worktreeRoot));
+  const normalizedOriginalRoot = normalizeScanPath(path.resolve(parsed.originalRoot));
+  for (const value of extractPathLikeValues(script)) {
+    const resolved = normalizeScanPath(path.resolve(normalizedWorktree, value));
+    if (pathInside(normalizedOriginalRoot, resolved) && !pathInside(normalizedWorktree, resolved)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function scriptReferencesOriginalRootFromWorktree(script: string, baseDir: string): boolean {
+  const parsed = parseWorktreeBase(baseDir);
+  if (!parsed) return false;
+  const normalizedScript = script.replace(/\\/g, "/");
+  const originalRootPattern = new RegExp(
+    `${escapeRegExp(parsed.originalRoot)}(?=$|[\\s'"\\\`;)&|<>]|/(?!\\.gsd/worktrees(?:/|$)))`,
+  );
+  return originalRootPattern.test(normalizedScript);
+}
+
 export async function executeGsdExec(
   params: ExecToolParams,
   deps: ExecToolDeps,
@@ -98,6 +183,14 @@ export async function executeGsdExec(
   if (Buffer.byteLength(script, "utf8") > 200_000) {
     return paramError("script exceeds the 200 KB length limit");
   }
+  if (
+    resolvesToOriginalRootOutsideWorktree(script, deps.baseDir)
+    || scriptReferencesOriginalRootFromWorktree(script, deps.baseDir)
+  ) {
+    return paramError(
+      "script references the original project root while running inside a milestone worktree; use the active worktree path or relative paths",
+    );
+  }
 
   const opts = buildExecOptions(
     deps.baseDir,

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

@@ -1,6 +1,6 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
-import { isNonEmptyString, validateStringArray } from "../validation.js";
+import { isNonEmptyString, validateStringArray, validateTitle } from "../validation.js";
 import {
   transaction,
   getMilestone,
@@ -148,6 +148,8 @@ function validateSlices(value: unknown): PlanMilestoneSliceInput[] {
     if (seen.has(sliceId)) throw new Error(`slices[${index}].sliceId must be unique`);
     seen.add(sliceId);
     if (!isNonEmptyString(title)) throw new Error(`slices[${index}].title must be a non-empty string`);
+    const titleIssue = validateTitle(title);
+    if (titleIssue) throw new Error(`slices[${index}].title is invalid: ${titleIssue}`);
     if (!isNonEmptyString(risk)) throw new Error(`slices[${index}].risk must be a non-empty string`);
     if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item))) {
       throw new Error(`slices[${index}].depends must be an array of non-empty strings`);
@@ -190,6 +192,8 @@ function validateParams(params: PlanMilestoneParams): PlanMilestoneParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
   if (!isNonEmptyString(params?.title)) throw new Error("title is required");
   if (!isNonEmptyString(params?.vision)) throw new Error("vision is required");
+  const milestoneTitleIssue = validateTitle(params.title);
+  if (milestoneTitleIssue) throw new Error(`title is invalid: ${milestoneTitleIssue}`);
 
   return {
     ...params,

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

@@ -1,3 +1,5 @@
+import { existsSync, rmSync } from "node:fs";
+import { join, relative } from "node:path";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
@@ -5,11 +7,15 @@ import {
   transaction,
   getMilestone,
   getSlice,
+  getSliceTasks,
   insertTask,
   upsertSlicePlanning,
   upsertTaskPlanning,
   insertGateRow,
   updateSliceStatus,
+  setSliceSketchFlag,
+  deleteTask,
+  deleteArtifactByPath,
 } from "../gsd-db.js";
 import type { GateId } from "../types.js";
 import { invalidateStateCache } from "../state.js";
@@ -19,6 +25,11 @@ import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { validatePlanningPathScope } from "../planning-path-scope.js";
+import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
+import type { TaskRow } from "../db-task-slice-rows.js";
+import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { createRepositoryRegistryFromPreferences, type RepositoryRegistry } from "../repository-registry.js";
 
 export interface PlanSliceTaskInput {
   taskId: string;
@@ -31,6 +42,7 @@ export interface PlanSliceTaskInput {
   expectedOutput: string[];
   observabilityImpact?: string;
   fullPlanMd?: string;
+  targetRepositories?: string[];
 }
 
 export interface PlanSliceParams {
@@ -46,6 +58,7 @@ export interface PlanSliceParams {
   integrationClosure?: string;
   /** @optional — omitted fields render as conservative defaults */
   observabilityImpact?: string;
+  targetRepositories?: string[];
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
@@ -59,6 +72,18 @@ export interface PlanSliceResult {
   taskPlanPaths: string[];
 }
 
+function validateRepositoryTargetIds(
+  field: string,
+  value: unknown,
+): string[] | null {
+  if (value === undefined) return null;
+  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 validateTasks(value: unknown): PlanSliceTaskInput[] {
   if (!Array.isArray(value) || value.length === 0) {
     throw new Error("tasks must be a non-empty array");
@@ -79,6 +104,7 @@ function validateTasks(value: unknown): PlanSliceTaskInput[] {
     const inputs = obj.inputs;
     const expectedOutput = obj.expectedOutput;
     const observabilityImpact = obj.observabilityImpact;
+    const targetRepositories = obj.targetRepositories;
 
     if (!isNonEmptyString(taskId)) throw new Error(`tasks[${index}].taskId must be a non-empty string`);
     if (seen.has(taskId)) throw new Error(`tasks[${index}].taskId must be unique`);
@@ -86,30 +112,29 @@ function validateTasks(value: unknown): PlanSliceTaskInput[] {
     if (!isNonEmptyString(title)) throw new Error(`tasks[${index}].title must be a non-empty string`);
     if (!isNonEmptyString(description)) throw new Error(`tasks[${index}].description must be a non-empty string`);
     if (!isNonEmptyString(estimate)) throw new Error(`tasks[${index}].estimate must be a non-empty string`);
-    if (!Array.isArray(files) || files.some((item) => !isNonEmptyString(item))) {
-      throw new Error(`tasks[${index}].files must be an array of non-empty strings`);
-    }
+    const validatedFiles = validateStringArray(files, `tasks[${index}].files`);
     if (!isNonEmptyString(verify)) throw new Error(`tasks[${index}].verify must be a non-empty string`);
-    if (!Array.isArray(inputs) || inputs.some((item) => !isNonEmptyString(item))) {
-      throw new Error(`tasks[${index}].inputs must be an array of non-empty strings`);
-    }
-    if (!Array.isArray(expectedOutput) || expectedOutput.some((item) => !isNonEmptyString(item))) {
-      throw new Error(`tasks[${index}].expectedOutput must be an array of non-empty strings`);
-    }
+    const validatedInputs = validateStringArray(inputs, `tasks[${index}].inputs`);
+    const validatedExpectedOutput = validateStringArray(expectedOutput, `tasks[${index}].expectedOutput`);
     if (observabilityImpact !== undefined && !isNonEmptyString(observabilityImpact)) {
       throw new Error(`tasks[${index}].observabilityImpact must be a non-empty string when provided`);
     }
+    const validatedTargetRepositories = validateRepositoryTargetIds(
+      `tasks[${index}].targetRepositories`,
+      targetRepositories,
+    );
 
     return {
       taskId,
       title,
       description,
       estimate,
-      files,
+      files: validatedFiles,
       verify,
-      inputs,
-      expectedOutput,
+      inputs: validatedInputs,
+      expectedOutput: validatedExpectedOutput,
       observabilityImpact: typeof observabilityImpact === "string" ? observabilityImpact : "",
+      targetRepositories: validatedTargetRepositories ?? undefined,
     };
   });
 }
@@ -119,6 +144,11 @@ function validateParams(params: PlanSliceParams): PlanSliceParams {
   if (!isNonEmptyString(params?.sliceId)) throw new Error("sliceId is required");
   if (!isNonEmptyString(params?.goal)) throw new Error("goal is required");
 
+  const validatedTargetRepositories = validateRepositoryTargetIds(
+    "targetRepositories",
+    params.targetRepositories,
+  );
+
   return {
     ...params,
     // Keep optional enrichment fields empty when omitted. The renderer supplies
@@ -127,10 +157,97 @@ function validateParams(params: PlanSliceParams): PlanSliceParams {
     proofLevel: params.proofLevel ?? "",
     integrationClosure: params.integrationClosure ?? "",
     observabilityImpact: params.observabilityImpact ?? "",
+    targetRepositories: validatedTargetRepositories ?? undefined,
     tasks: validateTasks(params.tasks),
   };
 }
 
+function loadRepositoryRegistry(basePath: string): RepositoryRegistry {
+  const loaded = loadEffectiveGSDPreferences(basePath);
+  return createRepositoryRegistryFromPreferences(basePath, loaded?.preferences);
+}
+
+function validateReferencedRepositories(params: PlanSliceParams, registry: RepositoryRegistry): string | null {
+  const known = new Set(registry.repositories.map((repo) => repo.id));
+
+  const missing: string[] = [];
+  const noteMissing = (id: string) => {
+    if (!known.has(id) && !missing.includes(id)) missing.push(id);
+  };
+
+  for (const id of params.targetRepositories ?? []) noteMissing(id);
+  for (const task of params.tasks) {
+    for (const id of task.targetRepositories ?? []) noteMissing(id);
+  }
+
+  if (missing.length === 0) return null;
+  return `unknown targetRepositories: ${missing.join(", ")}. Declared repositories: ${Array.from(known).join(", ")}`;
+}
+
+function resolveAllowedRootsForPathScope(params: PlanSliceParams, registry: RepositoryRegistry): string[] {
+  const requested = new Set<string>();
+  for (const id of params.targetRepositories ?? []) requested.add(id);
+  for (const task of params.tasks) {
+    for (const id of task.targetRepositories ?? []) requested.add(id);
+  }
+  if (requested.size === 0) return [registry.projectRoot];
+  const roots = Array.from(requested)
+    .map((id) => registry.byId.get(id)?.root)
+    .filter((root): root is string => typeof root === "string");
+  return roots.length > 0 ? roots : [registry.projectRoot];
+}
+
+function toTaskRows(params: PlanSliceParams): TaskRow[] {
+  return params.tasks.map((task, index) => ({
+    milestone_id: params.milestoneId,
+    slice_id: params.sliceId,
+    id: task.taskId,
+    title: task.title,
+    status: "pending",
+    one_liner: "",
+    narrative: "",
+    verification_result: "",
+    duration: "",
+    completed_at: null,
+    blocker_discovered: false,
+    deviations: "",
+    known_issues: "",
+    key_files: [],
+    key_decisions: [],
+    full_summary_md: "",
+    description: task.description,
+    estimate: task.estimate,
+    files: task.files,
+    verify: task.verify,
+    inputs: task.inputs,
+    expected_output: task.expectedOutput,
+    observability_impact: task.observabilityImpact ?? "",
+    full_plan_md: task.fullPlanMd ?? "",
+    target_repositories: task.targetRepositories ?? params.targetRepositories ?? ["project"],
+    sequence: index + 1,
+    blocker_source: "",
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
+  }));
+}
+
+function validateTaskPathsBeforePersist(params: PlanSliceParams, basePath: string): string | null {
+  const taskRows = toTaskRows(params);
+  const checks = [
+    ...checkFilePathConsistency(taskRows, basePath),
+    ...checkTaskOrdering(taskRows, basePath),
+  ];
+  const blocking = checks.filter((check) => !check.passed && check.blocking);
+
+  if (blocking.length === 0) return null;
+
+  return blocking
+    .map((check) => `[${check.category}] ${check.target}: ${check.message}`)
+    .join("\n");
+}
+
 export async function handlePlanSlice(
   rawParams: PlanSliceParams,
   basePath: string,
@@ -142,6 +259,14 @@ export async function handlePlanSlice(
     return { error: `validation failed: ${(err as Error).message}` };
   }
 
+  const repositoryRegistry = loadRepositoryRegistry(basePath);
+  const repoValidationError = validateReferencedRepositories(params, repositoryRegistry);
+  if (repoValidationError) {
+    return { error: `validation failed: ${repoValidationError}` };
+  }
+
+  const allowedAbsoluteRoots = resolveAllowedRootsForPathScope(params, repositoryRegistry);
+
   const pathScopeError = validatePlanningPathScope(
     basePath,
     params.tasks.flatMap((task, index) => [
@@ -149,15 +274,22 @@ export async function handlePlanSlice(
       { field: `tasks[${index}].inputs`, values: task.inputs },
       { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
     ]),
+    allowedAbsoluteRoots,
   );
   if (pathScopeError) {
     return { error: `validation failed: ${pathScopeError}` };
   }
 
+  const pathError = validateTaskPathsBeforePersist(params, basePath);
+  if (pathError) {
+    return { error: `pre-execution validation failed:\n${pathError}` };
+  }
+
   // ── 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).
   let guardError: string | null = null;
+  let omittedTaskIds: string[] = [];
 
   try {
     transaction(() => {
@@ -181,9 +313,23 @@ export async function handlePlanSlice(
         return;
       }
 
+      const newTaskIds = new Set(params.tasks.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 (isDeferredStatus(parentSlice.status)) {
         updateSliceStatus(params.milestoneId, params.sliceId, "pending");
       }
+      setSliceSketchFlag(params.milestoneId, params.sliceId, false);
 
       upsertSlicePlanning(params.milestoneId, params.sliceId, {
         goal: params.goal,
@@ -191,8 +337,13 @@ export async function handlePlanSlice(
         proofLevel: params.proofLevel,
         integrationClosure: params.integrationClosure,
         observabilityImpact: params.observabilityImpact,
+        targetRepositories: params.targetRepositories ?? ["project"],
       });
 
+      for (const taskId of omittedTaskIds) {
+        deleteTask(params.milestoneId, params.sliceId, taskId);
+      }
+
       for (const task of params.tasks) {
         insertTask({
           id: task.taskId,
@@ -211,6 +362,7 @@ export async function handlePlanSlice(
           expectedOutput: task.expectedOutput,
           observabilityImpact: task.observabilityImpact ?? "",
           fullPlanMd: task.fullPlanMd,
+          targetRepositories: task.targetRepositories ?? params.targetRepositories ?? ["project"],
         });
       }
 
@@ -237,6 +389,14 @@ export async function handlePlanSlice(
   }
 
   try {
+    const tasksDir = join(gsdProjectionRoot(basePath), "milestones", params.milestoneId, "slices", params.sliceId, "tasks");
+    for (const taskId of omittedTaskIds) {
+      const taskPlanPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
+      if (existsSync(taskPlanPath)) rmSync(taskPlanPath, { force: true });
+      const artifactPath = relative(gsdProjectionRoot(basePath), taskPlanPath).replace(/\\/g, "/");
+      deleteArtifactByPath(artifactPath);
+    }
+
     const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
     invalidateStateCache();
     clearParseCache();