gsd-pi 2.82.0 → 3.0.0-dev.8b8d129d7

package/dist/resources/extensions/gsd/state-reconciliation/drift/roadmap.js

@@ -1,14 +1,15 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 roadmap-divergence drift handler. Detects mismatches
-// between ROADMAP.md (parsed slice sequence + depends declarations) and the
-// DB slice rows for that milestone, then reconciles via the markdown
-// importer plus an explicit junction-table sync.
+// between ROADMAP.md (parsed slice sequence, depends declarations, and
+// checkboxes) and the DB slice rows for that milestone, then re-renders the
+// ROADMAP projection from the authoritative DB rows.
 import { existsSync, readFileSync } from "node:fs";
-import { getMilestone, getMilestoneSlices, isDbAvailable, syncSliceDependencies, } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
+import { getMilestone, getMilestoneSlices, isDbAvailable, } from "../../gsd-db.js";
+import { renderRoadmapFromDb } from "../../markdown-renderer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { parseRoadmap } from "../../parsers-legacy.js";
 import { resolveMilestoneFile } from "../../paths.js";
+import { isClosedStatus } from "../../status-guards.js";
 function arraysEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -30,8 +31,10 @@ function milestoneHasDivergence(basePath, milestoneId) {
     }
     const dbSlices = getMilestoneSlices(milestoneId);
     const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+    const roadmapSliceIds = new Set();
     for (let i = 0; i < roadmap.slices.length; i++) {
         const roadmapSlice = roadmap.slices[i];
+        roadmapSliceIds.add(roadmapSlice.id);
         const expectedSequence = i + 1;
         const dbSlice = dbSliceMap.get(roadmapSlice.id);
         if (!dbSlice)
@@ -40,6 +43,12 @@ function milestoneHasDivergence(basePath, milestoneId) {
             return true;
         if (!arraysEqual(dbSlice.depends, roadmapSlice.depends))
             return true;
+        if (isClosedStatus(dbSlice.status) !== roadmapSlice.done)
+            return true;
+    }
+    for (const dbSlice of dbSlices) {
+        if (!roadmapSliceIds.has(dbSlice.id))
+            return true;
     }
     return false;
 }
@@ -59,26 +68,12 @@ export function detectRoadmapDivergenceDrift(_state, ctx) {
     return drifts;
 }
 /**
- * Repair a milestone's roadmap divergence:
- *   1. migrateHierarchyToDb upserts slice rows (sequence + depends JSON
- *      update via ON CONFLICT DO UPDATE).
- *   2. syncSliceDependencies updates the junction table per slice — the
- *      importer only writes the JSON column, not the relational view.
+ * Repair a milestone's roadmap divergence by regenerating the projection from
+ * DB rows. ROADMAP.md is a projection; runtime reconciliation must not import
+ * slice presence, sequence, dependencies, or checkbox state from markdown.
  */
-export function repairRoadmapDivergence(record, ctx) {
-    migrateHierarchyToDb(ctx.basePath);
-    const roadmapPath = resolveMilestoneFile(ctx.basePath, record.milestoneId, "ROADMAP");
-    if (!roadmapPath || !existsSync(roadmapPath))
-        return;
-    try {
-        const roadmap = parseRoadmap(readFileSync(roadmapPath, "utf-8"));
-        for (const slice of roadmap.slices) {
-            syncSliceDependencies(record.milestoneId, slice.id, slice.depends);
-        }
-    }
-    catch {
-        /* parse failure: detector will fire again next pass */
-    }
+export async function repairRoadmapDivergence(record, ctx) {
+    await renderRoadmapFromDb(ctx.basePath, record.milestoneId);
 }
 export const roadmapDivergenceHandler = {
     kind: "roadmap-divergence",

package/dist/resources/extensions/gsd/state.js

@@ -352,6 +352,12 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
                 continue;
             }
             if (allSlicesDone) {
+                const validation = getLatestAssessmentByScope(m.id, "milestone-validation");
+                const verdict = typeof validation?.status === "string" ? validation.status : undefined;
+                if (verdict === "needs-attention") {
+                    registry.push({ id: m.id, title, status: "parked", ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+                    continue;
+                }
                 activeMilestone = { id: m.id, title };
                 activeMilestoneSlices = slices;
                 activeMilestoneFound = true;
@@ -460,7 +466,7 @@ async function handleAllSlicesDone(basePath, activeMilestone, registry, requirem
             recentDecisions: [],
             blockers: [
                 `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-                    `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+                    `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
             ],
             nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
             registry, requirements,
@@ -892,6 +898,10 @@ export async function _deriveStateImpl(basePath, opts) {
             const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
             const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
             const verdict = validationContent ? extractVerdict(validationContent) : undefined;
+            if (verdict === "needs-attention") {
+                registry.push({ id: mid, title, status: "parked" });
+                continue;
+            }
             // needs-remediation is terminal but requires re-validation (#3596)
             const needsRevalidation = !validationTerminal || verdict === 'needs-remediation';
             if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, cachedLoadFile)) {
@@ -911,7 +921,7 @@ export async function _deriveStateImpl(basePath, opts) {
                 registry.push({ id: mid, title, status: 'pending' });
             }
             else if (!activeMilestoneFound) {
-                // Terminal validation (pass/needs-attention) but no summary → completing-milestone
+                // Terminal passing validation but no summary → completing-milestone
                 activeMilestone = { id: mid, title };
                 activeRoadmap = roadmap;
                 activeMilestoneFound = true;
@@ -1132,7 +1142,7 @@ export async function _deriveStateImpl(basePath, opts) {
                 recentDecisions: [],
                 blockers: [
                     `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-                        `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+                        `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
                 ],
                 nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
                 registry,
@@ -1253,7 +1263,7 @@ export async function _deriveStateImpl(basePath, opts) {
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             t.done = true;
-            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
+            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
         }
     }
     const taskProgress = {

package/dist/resources/extensions/gsd/status-guards.js

@@ -2,14 +2,15 @@
  * Status predicates for GSD state-machine guards.
  *
  * The DB stores status as free-form strings. Three values indicate
- * "closed": "complete" (canonical), "done" (legacy / alias), and
+ * "closed": "complete" (canonical), "done" (legacy / alias),
+ * "closed" (legacy/imported), and
  * "skipped" (user-directed skip via rethink or backtrack).
  * Every inline `status === "complete" || status === "done"` should
  * use isClosedStatus() instead.
  */
 /** Returns true when a milestone, slice, or task status indicates closure. */
 export function isClosedStatus(status) {
-    return status === "complete" || status === "done" || status === "skipped";
+    return status === "complete" || status === "done" || status === "skipped" || status === "closed";
 }
 /** Returns true when a slice status indicates it was deferred by a decision. */
 export function isDeferredStatus(status) {
@@ -22,3 +23,14 @@ export function isDeferredStatus(status) {
 export function isInactiveStatus(status) {
     return isClosedStatus(status) || isDeferredStatus(status);
 }
+/** Returns true when a prior milestone should not block dispatch ordering. */
+export function isSkippedForDispatch(status) {
+    return isClosedStatus(status) || status === "parked" || isDeferredStatus(status);
+}
+/**
+ * Returns true when a milestone is future/backlog work (not currently executing).
+ * Includes legacy/project-specific alias "planned" for compatibility.
+ */
+export function isFutureMilestoneStatus(status) {
+    return status === "pending" || status === "queued" || status === "planned";
+}

package/dist/resources/extensions/gsd/templates/knowledge.md

@@ -1,7 +1,7 @@
 # Project Knowledge
 
-Append-only register of project-specific rules, patterns, and lessons learned.
-Agents read this before every unit. Add entries when you discover something worth remembering.
+Project-specific rules plus projected patterns and lessons learned.
+Rules are maintained in this file. Patterns and lessons are persisted to the memories table and rendered here on the next session-start projection.
 
 ## Rules
 

package/dist/resources/extensions/gsd/templates/plan.md

@@ -99,11 +99,11 @@
   - "Improve UI"
 
   Each task should usually include:
-  - Why: why this task exists / what part of the slice it closes
-  - Files: the main files likely touched
-  - Do: concrete implementation steps and important constraints
-  - Verify: the command, test, or runtime check that proves it worked
-  - Done when: a measurable acceptance condition
+  - description: why this task exists, concrete steps, and done-when acceptance
+  - files: JSON array of likely touched paths
+  - verify: the command, test, or runtime check that proves it worked
+  - inputs: JSON array of existing paths or prior task outputs this task consumes
+  - expectedOutput: JSON array of paths this task creates or overwrites
 
   Keep the checkbox line format exactly:
   - [ ] **T01: Title** `est:30m`
@@ -131,10 +131,14 @@
 
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
+  - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
+  - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
+  - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
+  - GOOD: `python3 -m pytest tests/ -q --tb=short`
   - GOOD: `grep -c "^## " doc.md` returns >= 4 (4+ sections), `! grep -q "TBD\|TODO" doc.md`
 
   Integration closure rule:

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -57,6 +57,12 @@ skills_used:
 - {{howToVerifyThisTaskIsActuallyDone}}
 - {{commandToRun_OR_behaviorToCheck}}
 
+## Verify Rules
+
+- Use a real executable check, not prose.
+- If the check needs file-content assertions, write a `node:test` file and run it with `node --test` or a package test script.
+- Do not use inline `node -e` assertions for verification.
+
 ## Observability Impact
 
 <!-- OMIT THIS SECTION ENTIRELY for simple tasks that don't touch runtime boundaries,
@@ -72,7 +78,8 @@ skills_used:
 <!-- Every input MUST be a backtick-wrapped file path. These paths are machine-parsed to
      derive task dependencies — vague descriptions without paths break dependency detection.
      For the first task in a slice with no prior task outputs, list the existing source files
-     this task reads or modifies. -->
+     this task reads or modifies.
+     Tool field: inputs must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskNeedsFromPriorWork}}
 
@@ -82,6 +89,7 @@ skills_used:
      or modifies. These paths are machine-parsed to derive task dependencies.
      This task should produce a real increment toward making the slice goal/demo true. A full
      slice plan should not be able to mark every task complete while the claimed slice behavior
-     still does not work at the stated proof level. -->
+     still does not work at the stated proof level.
+     Tool field: expectedOutput must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskCreatesOrModifies}}

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -24,11 +24,11 @@ function renderMilestoneSummaryMarkdown(params, completedAt) {
     const keyFiles = params.keyFiles ?? [];
     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")
         : "  - (none)";
@@ -37,10 +37,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}
 ---

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -65,11 +65,11 @@ function renderSliceSummaryMarkdown(params) {
         ? affects.map(a => `  - ${a}`).join("\n")
         : "  []";
     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")
         : "  - (none)";
@@ -106,10 +106,8 @@ requires:
 ${requiresYaml}
 affects:
 ${affectsYaml}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
+key_files:${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
 patterns_established:
 ${patternsYaml}
 observability_surfaces:

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -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, getMilestoneSlices, getSlice, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
@@ -77,6 +77,9 @@ function validateSlices(value) {
         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))) {
@@ -127,6 +130,9 @@ function validateParams(params) {
         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,
         dependsOn: params.dependsOn ? validateStringArray(params.dependsOn, "dependsOn") : [],

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -1,7 +1,9 @@
+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 } from "../validation.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, } from "../gsd-db.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
+import { transaction, getMilestone, getSlice, getSliceTasks, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, setSliceSketchFlag, deleteTask, deleteArtifactByPath, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -9,6 +11,21 @@ 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 { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { createRepositoryRegistryFromPreferences } from "../repository-registry.js";
+function validateRepositoryTargetIds(field, value) {
+    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) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -28,6 +45,7 @@ function validateTasks(value) {
         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))
@@ -39,30 +57,26 @@ function validateTasks(value) {
             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,
         };
     });
 }
@@ -73,6 +87,7 @@ function validateParams(params) {
         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
@@ -81,9 +96,94 @@ function validateParams(params) {
         proofLevel: params.proofLevel ?? "",
         integrationClosure: params.integrationClosure ?? "",
         observabilityImpact: params.observabilityImpact ?? "",
+        targetRepositories: validatedTargetRepositories ?? undefined,
         tasks: validateTasks(params.tasks),
     };
 }
+function loadRepositoryRegistry(basePath) {
+    const loaded = loadEffectiveGSDPreferences(basePath);
+    return createRepositoryRegistryFromPreferences(basePath, loaded?.preferences);
+}
+function validateReferencedRepositories(params, registry) {
+    const known = new Set(registry.repositories.map((repo) => repo.id));
+    const missing = [];
+    const noteMissing = (id) => {
+        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, registry) {
+    const requested = new Set();
+    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) => typeof root === "string");
+    return roots.length > 0 ? roots : [registry.projectRoot];
+}
+function toTaskRows(params) {
+    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, basePath) {
+    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, basePath) {
     let params;
     try {
@@ -92,18 +192,29 @@ export async function handlePlanSlice(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.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) => [
         { field: `tasks[${index}].files`, values: task.files },
         { 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 = null;
+    let omittedTaskIds = [];
     try {
         transaction(() => {
             const parentMilestone = getMilestone(params.milestoneId);
@@ -124,16 +235,32 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first`;
                 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,
                 successCriteria: params.successCriteria,
                 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,
@@ -152,6 +279,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                     expectedOutput: task.expectedOutput,
                     observabilityImpact: task.observabilityImpact ?? "",
                     fullPlanMd: task.fullPlanMd,
+                    targetRepositories: task.targetRepositories ?? params.targetRepositories ?? ["project"],
                 });
             }
             // Seed quality gate rows inside the transaction — all-or-nothing with
@@ -176,6 +304,14 @@ export async function handlePlanSlice(rawParams, basePath) {
         return { error: guardError };
     }
     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();