@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

package/dist/resources/extensions/gsd/state/derive/from-db.js

@@ -12,6 +12,31 @@ import { countUnmappedActiveRequirements, formatCompletePhaseNextAction } from '
 import { logWarning } from '../../workflow-logger.js';
 import { buildDbUnavailableState, ensureExistingWorkflowDbOpen, getRequestedMilestoneLock, } from './db-open.js';
 const isStatusDone = isClosedStatus;
+function buildProgress(context) {
+    return {
+        milestones: context.milestoneProgress,
+        ...(context.sliceProgress ? { slices: context.sliceProgress } : {}),
+        ...(context.taskProgress ? { tasks: context.taskProgress } : {}),
+    };
+}
+function buildDerivedState(context, phase, nextAction, options = {}) {
+    return {
+        activeMilestone: context.activeMilestone,
+        activeSlice: context.activeSlice ?? null,
+        activeTask: context.activeTask ?? null,
+        phase,
+        recentDecisions: [],
+        blockers: options.blockers ?? [],
+        nextAction,
+        ...(options.lastCompletedMilestone !== undefined
+            ? { lastCompletedMilestone: options.lastCompletedMilestone }
+            : {}),
+        ...(options.includeActiveWorkspace ? { activeWorkspace: undefined } : {}),
+        registry: context.registry,
+        requirements: context.requirements,
+        progress: buildProgress(context),
+    };
+}
 function stripMilestonePrefix(title) {
     return title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '') || title;
 }
@@ -125,103 +150,60 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
 function handleNoActiveMilestone(registry, requirements, milestoneProgress) {
     const pendingEntries = registry.filter(e => e.status === 'pending');
     const parkedEntries = registry.filter(e => e.status === 'parked');
+    const context = {
+        activeMilestone: null,
+        registry,
+        requirements,
+        milestoneProgress,
+    };
     if (pendingEntries.length > 0) {
         const blockerDetails = pendingEntries
             .filter(e => e.dependsOn && e.dependsOn.length > 0)
             .map(e => `${e.id} is waiting on unmet deps: ${e.dependsOn.join(', ')}`);
-        return {
-            activeMilestone: null, activeSlice: null, activeTask: null,
-            phase: 'blocked',
-            recentDecisions: [], blockers: blockerDetails.length > 0
+        return buildDerivedState(context, 'blocked', 'Resolve milestone dependencies before proceeding.', {
+            blockers: blockerDetails.length > 0
                 ? blockerDetails
                 : ['All remaining milestones are dep-blocked but no deps listed — check CONTEXT.md files'],
-            nextAction: 'Resolve milestone dependencies before proceeding.',
-            registry, requirements,
-            progress: { milestones: milestoneProgress },
-        };
+        });
     }
     if (parkedEntries.length > 0) {
         const parkedIds = parkedEntries.map(e => e.id).join(', ');
-        return {
-            activeMilestone: null, activeSlice: null, activeTask: null,
-            phase: 'pre-planning',
-            recentDecisions: [], blockers: [],
-            nextAction: `All remaining milestones are parked (${parkedIds}). Run /gsd unpark <id> or create a new milestone.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress },
-        };
+        return buildDerivedState(context, 'pre-planning', `All remaining milestones are parked (${parkedIds}). Run /gsd unpark <id> or create a new milestone.`);
     }
     if (registry.length === 0) {
-        return {
-            activeMilestone: null, activeSlice: null, activeTask: null,
-            phase: 'pre-planning',
-            recentDecisions: [], blockers: [],
-            nextAction: 'No milestones found. Run /gsd to create one.',
-            registry: [], requirements,
-            progress: { milestones: { done: 0, total: 0 } },
-        };
+        return buildDerivedState({ ...context, registry: [], milestoneProgress: { done: 0, total: 0 } }, 'pre-planning', 'No milestones found. Run /gsd to create one.');
     }
     const lastEntry = registry[registry.length - 1];
     const unmappedActive = countUnmappedActiveRequirements();
     const completionNote = formatCompletePhaseNextAction(unmappedActive);
-    return {
-        activeMilestone: null,
+    return buildDerivedState(context, 'complete', completionNote, {
         lastCompletedMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
-        activeSlice: null, activeTask: null,
-        phase: 'complete',
-        recentDecisions: [], blockers: [],
-        nextAction: completionNote,
-        registry, requirements,
-        progress: { milestones: milestoneProgress },
-    };
+    });
 }
 async function handleAllSlicesDone(basePath, activeMilestone, registry, requirements, milestoneProgress, sliceProgress) {
     const validation = getLatestAssessmentByScope(activeMilestone.id, "milestone-validation");
     const verdict = typeof validation?.status === "string" ? validation.status : undefined;
     const validationTerminal = verdict != null && verdict !== "";
+    const context = {
+        activeMilestone,
+        registry,
+        requirements,
+        milestoneProgress,
+        sliceProgress,
+    };
     if (!validationTerminal) {
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase: 'validating-milestone',
-            recentDecisions: [], blockers: [],
-            nextAction: `Validate milestone ${activeMilestone.id} before completion.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState(context, 'validating-milestone', `Validate milestone ${activeMilestone.id} before completion.`);
     }
     // All roadmap slices are done (enforced by caller) and verdict is
     // needs-remediation — remediation cannot progress without new slices.
     // Return blocked instead of re-dispatching validate-milestone (#4506).
     if (verdict === 'needs-attention') {
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase: 'blocked',
-            recentDecisions: [],
-            blockers: [formatNeedsAttentionBlocker(activeMilestone.id)],
-            nextAction: `Resolve ${activeMilestone.id} validation attention before proceeding.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState(context, 'blocked', `Resolve ${activeMilestone.id} validation attention before proceeding.`, { blockers: [formatNeedsAttentionBlocker(activeMilestone.id)] });
     }
     if (verdict === 'needs-remediation') {
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase: 'blocked',
-            recentDecisions: [],
-            blockers: [formatNeedsRemediationBlocker(activeMilestone.id)],
-            nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState(context, 'blocked', `Resolve ${activeMilestone.id} remediation before proceeding.`, { blockers: [formatNeedsRemediationBlocker(activeMilestone.id)] });
     }
-    return {
-        activeMilestone, activeSlice: null, activeTask: null,
-        phase: 'completing-milestone',
-        recentDecisions: [], blockers: [],
-        nextAction: `All slices complete in ${activeMilestone.id}. Write milestone summary.`,
-        registry, requirements,
-        progress: { milestones: milestoneProgress, slices: sliceProgress },
-    };
+    return buildDerivedState(context, 'completing-milestone', `All slices complete in ${activeMilestone.id}. Write milestone summary.`);
 }
 function resolveSliceDependencies(activeMilestoneSlices) {
     const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
@@ -271,13 +253,12 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
         ? allMilestones.filter(m => m.id === milestoneLock)
         : allMilestones;
     if (milestones.length === 0) {
-        return {
-            activeMilestone: null, activeSlice: null, activeTask: null,
-            phase: 'pre-planning', recentDecisions: [], blockers: [],
-            nextAction: 'No milestones found. Run /gsd to create one.',
-            registry: [], requirements,
-            progress: { milestones: { done: 0, total: 0 } },
-        };
+        return buildDerivedState({
+            activeMilestone: null,
+            registry: [],
+            requirements,
+            milestoneProgress: { done: 0, total: 0 },
+        }, 'pre-planning', 'No milestones found. Run /gsd to create one.');
     }
     const { completeMilestoneIds, parkedMilestoneIds } = buildCompletenessSet(basePath, milestones);
     const registryContext = await buildRegistryAndFindActive(basePath, milestones, completeMilestoneIds, parkedMilestoneIds);
@@ -294,18 +275,20 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
         const nextAction = activeMilestoneHasDraft
             ? `Discuss draft context for milestone ${activeMilestone.id}.`
             : `Plan milestone ${activeMilestone.id}.`;
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase, recentDecisions: [], blockers: [],
-            nextAction, registry, requirements,
-            progress: { milestones: milestoneProgress },
-        };
+        return buildDerivedState({ activeMilestone, registry, requirements, milestoneProgress }, phase, nextAction);
     }
     const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
     const sliceProgress = {
         done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
         total: activeMilestoneSlices.length,
     };
+    const sliceStateContext = {
+        activeMilestone,
+        registry,
+        requirements,
+        milestoneProgress,
+        sliceProgress,
+    };
     if (allSlicesDone) {
         return handleAllSlicesDone(basePath, activeMilestone, registry, requirements, milestoneProgress, sliceProgress);
     }
@@ -314,21 +297,9 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
         // If locked slice wasn't found, it returns null but logs warning, we need to return 'blocked'
         const sliceLock = process.env.GSD_PARALLEL_WORKER ? process.env.GSD_SLICE_LOCK : undefined;
         if (sliceLock) {
-            return {
-                activeMilestone, activeSlice: null, activeTask: null,
-                phase: 'blocked', recentDecisions: [], blockers: [`GSD_SLICE_LOCK=${sliceLock} not found in active milestone slices`],
-                nextAction: 'Slice lock references a non-existent slice — check orchestrator dispatch.',
-                registry, requirements,
-                progress: { milestones: milestoneProgress, slices: sliceProgress },
-            };
+            return buildDerivedState(sliceStateContext, 'blocked', 'Slice lock references a non-existent slice — check orchestrator dispatch.', { blockers: [`GSD_SLICE_LOCK=${sliceLock} not found in active milestone slices`] });
         }
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase: 'blocked', recentDecisions: [], blockers: ['No slice eligible — check dependency ordering'],
-            nextAction: 'Resolve dependency blockers or plan next slice.',
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState(sliceStateContext, 'blocked', 'Resolve dependency blockers or plan next slice.', { blockers: ['No slice eligible — check dependency ordering'] });
     }
     const { activeSlice } = activeSliceContext;
     const activeSliceRow = activeSliceContext.activeSliceRow;
@@ -338,39 +309,30 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
     // PLAN.md and preference flags are projections/configuration and are
     // deliberately not used to infer whether the slice itself is a sketch.
     if (activeSliceRow?.is_sketch === 1) {
-        return {
-            activeMilestone, activeSlice, activeTask: null,
-            phase: 'refining', recentDecisions: [], blockers: [],
-            nextAction: `Refine sketch slice ${activeSlice.id} (${activeSlice.title}) using prior slice context.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState({ ...sliceStateContext, activeSlice }, 'refining', `Refine sketch slice ${activeSlice.id} (${activeSlice.title}) using prior slice context.`);
     }
     const tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     const taskProgress = {
         done: tasks.filter(t => isStatusDone(t.status)).length,
         total: tasks.length,
     };
+    const taskStateContext = {
+        ...sliceStateContext,
+        activeSlice,
+        taskProgress,
+    };
     const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
     if (!activeTaskRow && tasks.length > 0) {
-        return {
-            activeMilestone, activeSlice, activeTask: null,
-            phase: 'summarizing', recentDecisions: [], blockers: [],
-            nextAction: `All tasks done in ${activeSlice.id}. Write slice summary and complete slice.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-        };
+        return buildDerivedState(taskStateContext, 'summarizing', `All tasks done in ${activeSlice.id}. Write slice summary and complete slice.`);
     }
     if (!activeTaskRow) {
-        return {
-            activeMilestone, activeSlice, activeTask: null,
-            phase: 'planning', recentDecisions: [], blockers: [],
-            nextAction: `Slice ${activeSlice.id} has no DB tasks. Plan slice tasks before execution.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-        };
+        return buildDerivedState(taskStateContext, 'planning', `Slice ${activeSlice.id} has no DB tasks. Plan slice tasks before execution.`);
     }
     const activeTask = { id: activeTaskRow.id, title: activeTaskRow.title };
+    const activeTaskStateContext = {
+        ...taskStateContext,
+        activeTask,
+    };
     // ── Quality gate evaluation check ──────────────────────────────────
     // Pause before execution only when gates owned by the `gate-evaluate`
     // turn (Q3/Q4) are still pending. Q8 is also `scope:"slice"` but is
@@ -380,27 +342,16 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
     // Slices with zero gate rows (pre-feature or simple) skip straight through.
     const pendingGateCount = getPendingGateCountForTurn(activeMilestone.id, activeSlice.id, "gate-evaluate");
     if (pendingGateCount > 0) {
-        return {
-            activeMilestone, activeSlice, activeTask: null,
-            phase: 'evaluating-gates', recentDecisions: [], blockers: [],
-            nextAction: `Evaluate ${pendingGateCount} quality gate(s) for ${activeSlice.id} before execution.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-        };
+        return buildDerivedState(taskStateContext, 'evaluating-gates', `Evaluate ${pendingGateCount} quality gate(s) for ${activeSlice.id} before execution.`);
     }
     const blockerTaskId = await detectBlockers(basePath, activeMilestone.id, activeSlice.id, tasks);
     if (blockerTaskId) {
         const replanHistory = getReplanHistory(activeMilestone.id, activeSlice.id);
         if (replanHistory.length === 0) {
-            return {
-                activeMilestone, activeSlice, activeTask,
-                phase: 'replanning-slice', recentDecisions: [],
+            return buildDerivedState(activeTaskStateContext, 'replanning-slice', `Task ${blockerTaskId} reported blocker_discovered. Replan slice ${activeSlice.id} before continuing.`, {
                 blockers: [`Task ${blockerTaskId} discovered a blocker requiring slice replan`],
-                nextAction: `Task ${blockerTaskId} reported blocker_discovered. Replan slice ${activeSlice.id} before continuing.`,
-                activeWorkspace: undefined,
-                registry, requirements,
-                progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-            };
+                includeActiveWorkspace: true,
+            });
         }
     }
     // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
@@ -415,38 +366,22 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
     // and the user's prior resolution never lands.
     const escalatingTaskId = detectPendingEscalation(tasks, basePath);
     if (escalatingTaskId) {
-        return {
-            activeMilestone, activeSlice, activeTask,
-            phase: 'escalating-task', recentDecisions: [],
+        return buildDerivedState(activeTaskStateContext, 'escalating-task', `Run /gsd escalate show ${escalatingTaskId} to review, then /gsd escalate resolve ${escalatingTaskId} <choice> to proceed.`, {
             blockers: [`Task ${escalatingTaskId} requires a user decision before the loop can proceed`],
-            nextAction: `Run /gsd escalate show ${escalatingTaskId} to review, then /gsd escalate resolve ${escalatingTaskId} <choice> to proceed.`,
-            activeWorkspace: undefined,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-        };
+            includeActiveWorkspace: true,
+        });
     }
     if (!blockerTaskId) {
         const isTriggered = checkReplanTrigger(basePath, activeMilestone.id, activeSlice.id);
         if (isTriggered) {
             const replanHistory = getReplanHistory(activeMilestone.id, activeSlice.id);
             if (replanHistory.length === 0) {
-                return {
-                    activeMilestone, activeSlice, activeTask,
-                    phase: 'replanning-slice', recentDecisions: [],
+                return buildDerivedState(activeTaskStateContext, 'replanning-slice', `Triage replan triggered for slice ${activeSlice.id}. Replan before continuing.`, {
                     blockers: ['Triage replan trigger detected — slice replan required'],
-                    nextAction: `Triage replan triggered for slice ${activeSlice.id}. Replan before continuing.`,
-                    activeWorkspace: undefined,
-                    registry, requirements,
-                    progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-                };
+                    includeActiveWorkspace: true,
+                });
             }
         }
     }
-    return {
-        activeMilestone, activeSlice, activeTask,
-        phase: 'executing', recentDecisions: [], blockers: [],
-        nextAction: `Execute ${activeTask.id}: ${activeTask.title} in slice ${activeSlice.id}.`,
-        registry, requirements,
-        progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-    };
+    return buildDerivedState(activeTaskStateContext, 'executing', `Execute ${activeTask.id}: ${activeTask.title} in slice ${activeSlice.id}.`);
 }

package/dist/resources/extensions/gsd/tool-contract.js

@@ -26,6 +26,20 @@ export function getUnitWorkflowDispatchReadinessError(input) {
         activeTools: input.activeTools,
     });
 }
+export function getUnitWorkflowDispatchReadinessErrorForModel(input) {
+    const provider = input.model?.provider ?? input.fallbackModel?.provider;
+    const baseUrl = input.model?.baseUrl ?? input.fallbackModel?.baseUrl;
+    return getUnitWorkflowDispatchReadinessError({
+        provider,
+        unitType: input.unitType,
+        projectRoot: input.projectRoot,
+        env: input.env,
+        surface: input.surface,
+        authMode: provider ? input.getProviderAuthMode?.(provider) : undefined,
+        baseUrl,
+        activeTools: input.activeTools,
+    });
+}
 export function compileUnitToolContract(unitType) {
     const manifest = resolveManifest(unitType);
     const surfaceContract = getUnitToolSurfaceContract(unitType);

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

@@ -12,6 +12,47 @@ 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 } from "../repository-registry.js";
+function validateRepositoryTargetIds(field, value) {
+    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, registry) {
+    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, registry) {
+    if (targetRepositories.length === 0)
+        return [registry.projectRoot];
+    const roots = targetRepositories
+        .map((id) => registry.byId.get(id)?.root)
+        .filter((root) => typeof root === "string");
+    return roots.length > 0 ? roots : [registry.projectRoot];
+}
+function validatePathScopeForTargetRepositories(params, basePath, registry, targetRepositories) {
+    return validatePlanningPathScope(basePath, [
+        { field: "files", values: params.files },
+        { field: "inputs", values: params.inputs },
+        { field: "expectedOutput", values: params.expectedOutput },
+    ], resolveAllowedRootsForPathScope(targetRepositories, registry));
+}
+function resolveEffectiveTargetRepositories(taskTargetRepositories, sliceTargetRepositories, defaultTargets) {
+    if (taskTargetRepositories)
+        return taskTargetRepositories;
+    if (sliceTargetRepositories?.length)
+        return sliceTargetRepositories;
+    return defaultTargets;
+}
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -35,6 +76,9 @@ function validateParams(params) {
         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) {
@@ -57,22 +101,18 @@ export async function handlePlanTask(rawParams, basePath) {
     if (pathOnlyError) {
         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;
+    let 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).
@@ -93,6 +133,33 @@ export async function handlePlanTask(rawParams, basePath) {
                 guardError = `cannot re-plan task ${params.taskId}: it is already complete — use gsd_task_reopen first`;
                 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,
@@ -112,6 +179,7 @@ export async function handlePlanTask(rawParams, basePath) {
                 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 });

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

@@ -5,6 +5,11 @@
  * tasks back to "pending". This is intentional — if you're reopening a
  * slice, you're re-doing the work. Partial resets create ambiguous state.
  *
+ * Also recovers a desynced slice (#1205): when a UAT→planning fallback leaves
+ * the slice open (e.g. "pending") but its tasks still "complete", this clears
+ * that state so the planner can re-plan without hitting "already complete"
+ * rejections.
+ *
  * The parent milestone must still be open (not complete).
  */
 // GSD — reopen-slice tool handler

package/dist/resources/extensions/gsd/tools/reopen-task.js

@@ -16,8 +16,8 @@ import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { existsSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { resolveTasksDir, clearPathCache } from "../paths.js";
+import { join, basename, dirname } from "node:path";
+import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
 export async function handleReopenTask(params, basePath) {
     // ── Validate required fields ────────────────────────────────────────────
     if (!params.taskId || typeof params.taskId !== "string" || params.taskId.trim() === "") {
@@ -69,10 +69,18 @@ export async function handleReopenTask(params, basePath) {
     // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
     // Without this, the DB-filesystem reconciler sees the SUMMARY.md and
     // auto-corrects the task back to "complete", making reopen a no-op (#3161).
+    // Legacy layout keeps the summary under a tasks/ subdir; flat-phase writes
+    // TID-SUMMARY.md directly in the phase dir. A tasks/ subdir may still exist
+    // in flat-phase for auxiliary artifacts — its mere existence must NOT redirect
+    // summary cleanup into tasks/ (#1208).
     try {
-        const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-        if (tasksDir) {
-            const summaryPath = join(tasksDir, `${params.taskId}-SUMMARY.md`);
+        const slicePath = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
+        if (slicePath) {
+            const isLegacySlice = basename(dirname(slicePath)) === "slices";
+            const summaryDir = isLegacySlice
+                ? (resolveTasksDir(basePath, params.milestoneId, params.sliceId) ?? slicePath)
+                : slicePath;
+            const summaryPath = join(summaryDir, `${params.taskId}-SUMMARY.md`);
             if (existsSync(summaryPath))
                 unlinkSync(summaryPath);
         }

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -29,7 +29,9 @@ import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { parseProject } from "../schemas/parsers.js";
 import { autoSession, getAutoRuntimeSnapshot, isAutoActive } from "../auto-runtime-state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
+import { readUnitHarnessAbort } from "../unit-runtime.js";
 import { prepareUatRun, saveUatAttemptArtifact, } from "../uat-run.js";
+import { appendNotification } from "../notification-store.js";
 import { registerAutoWorker, markWorkerStopping, getAutoWorker } from "../db/auto-workers.js";
 import { claimMilestoneLease, releaseMilestoneLease, getMilestoneLease, refreshMilestoneLease, milestoneLeaseTtlSeconds, } from "../db/milestone-leases.js";
 export const SUPPORTED_SUMMARY_ARTIFACT_TYPES = [
@@ -65,6 +67,35 @@ function blockIfWrongAutoUnit(requiredUnitType, operation) {
         isError: true,
     };
 }
+function blockIfHarnessAbortedUnit(operation, basePath) {
+    const snapshot = getAutoRuntimeSnapshot();
+    if (!snapshot.active || !snapshot.currentUnit)
+        return null;
+    const abort = readUnitHarnessAbort(snapshot.basePath || basePath, snapshot.currentUnit.type, snapshot.currentUnit.id, snapshot.currentUnit.startedAt);
+    if (!abort)
+        return null;
+    return harnessAbortResult(operation, snapshot.currentUnit.type, snapshot.currentUnit.id, abort);
+}
+function harnessAbortResult(operation, unitType, unitId, abort) {
+    const toolText = abort.toolName ? ` while calling ${abort.toolName}` : "";
+    const message = `Retryable harness abort: ${unitType} ${unitId} was truncated by ${abort.kind}${toolText}. ` +
+        "This gate result was not saved; leave the gate pending so auto-mode can rerun it.";
+    return {
+        content: [{ type: "text", text: message }],
+        details: {
+            operation,
+            error: "harness_aborted_needs_retry",
+            retryable: true,
+            unitType,
+            unitId,
+            harnessAbortKind: abort.kind,
+            harnessAbortReason: abort.reason,
+            harnessAbortToolName: abort.toolName,
+            harnessAbortCount: abort.count,
+        },
+        isError: true,
+    };
+}
 function milestoneLeaseConflictResult(milestoneId, byWorker, expiresAt) {
     return {
         content: [{ type: "text", text: `Milestone ${milestoneId} is currently leased by ${byWorker}. Retry after ${expiresAt}.` }],
@@ -959,6 +990,9 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
     }
 }
 export async function executeSaveGateResult(params, basePath = process.cwd()) {
+    const harnessAbort = blockIfHarnessAbortedUnit("save_gate_result", basePath);
+    if (harnessAbort)
+        return harnessAbort;
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {
         return {
@@ -1023,6 +1057,9 @@ export async function executeUatResultSave(params, basePath = process.cwd()) {
     const unitGuard = blockIfWrongAutoUnit("run-uat", "save_uat_result");
     if (unitGuard)
         return unitGuard;
+    const harnessAbort = blockIfHarnessAbortedUnit("save_uat_result", basePath);
+    if (harnessAbort)
+        return harnessAbort;
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable)
         return errorResult("save_uat_result", "GSD database is not available.", "db_unavailable");
@@ -1082,6 +1119,9 @@ export async function executeUatResultSave(params, basePath = process.cwd()) {
             evaluatedAt: run.evaluatedAt,
         });
         invalidateStateCache();
+        if (run.hasHuman) {
+            appendNotification(`UAT for ${run.params.milestoneId}/${run.params.sliceId} has NEEDS-HUMAN checks awaiting human validation`, "warning", "notify", { kind: "uat-needs-human", scope: `${run.params.milestoneId}/${run.params.sliceId}` });
+        }
         const savedText = `UAT result saved for ${run.params.milestoneId}/${run.params.sliceId}: ${run.params.verdict}`;
         return {
             content: [{

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -178,9 +178,10 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        // Validation may need to run shell verification commands and apply source
-        // fixes before milestone closeout can proceed.
-        tools: TOOLS_ALL,
+        // Validation must persist its durable output through gsd_validate_milestone;
+        // generic write/bash tools can create filesystem artifacts that bypass DB
+        // state and trigger destructive recovery loops.
+        tools: { mode: "workflow-only", allowedSubagents: ["reviewer", "security", "tester"] },
         artifacts: {
             inline: ["roadmap", "requirements", "templates"],
             excerpt: ["slice-summary", "slice-assessment"],
@@ -531,7 +532,7 @@ export function compileSubagentPermissionContract(policy) {
     if (policy.mode === "all") {
         return { allowed: true, allowedSubagents: ["*"], toolsMode: policy.mode };
     }
-    if ((policy.mode === "planning-dispatch" || policy.mode === "verification") &&
+    if ((policy.mode === "planning-dispatch" || policy.mode === "verification" || policy.mode === "workflow-only") &&
         Array.isArray(policy.allowedSubagents)) {
         return {
             allowed: policy.allowedSubagents.length > 0,