@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.5c1a3ff2

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -10,15 +10,15 @@
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
 import { extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, taskIdFromTaskFileName, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
 import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
-import { join, relative, sep } from "node:path";
+import { join, basename, relative, sep } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
-import { getGateResults, getPendingGatesForTurn } from "./gsd-db.js";
+import { getBlockingReworkFindingsForTask, getGateResults, getPendingGatesForTurn } from "./gsd-db.js";
 import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
@@ -62,13 +62,29 @@ function resolvePromptBudgets() {
         const prefs = loadEffectiveGSDPreferences();
         const sessionWindow = prefs?.preferences.context_window_override;
         const windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences, sessionWindow);
-        return computeBudgets(windowTokens);
+        return computeBudgets(windowTokens, resolveExecutionProvider(prefs?.preferences));
     }
     catch (e) {
         logWarning("prompt", `resolvePromptBudgets failed: ${e.message}`);
         return computeBudgets(200_000);
     }
 }
+/**
+ * Best-effort provider for the chars/token ratio: the executor's configured
+ * model profile is the only provider source reachable here (the runtime
+ * `sessionProvider` that reaches `formatExecutorConstraints` isn't threaded to
+ * `capPreamble`/summary callers). Undefined when no explicit provider is set —
+ * `computeBudgets` then uses the 4.0 default, i.e. today's behavior.
+ */
+function resolveExecutionProvider(prefs) {
+    const exec = prefs?.models?.execution;
+    if (exec && typeof exec === "object" && "provider" in exec) {
+        const provider = exec.provider;
+        if (typeof provider === "string" && provider)
+            return provider;
+    }
+    return undefined;
+}
 /**
  * Character budget for dependency/prior slice summaries injected into dispatch
  * prompts. Scales with the executor's configured context window (issue #4435).
@@ -76,6 +92,32 @@ function resolvePromptBudgets() {
 function resolveSummaryBudgetChars() {
     return resolvePromptBudgets().summaryBudgetChars;
 }
+function renderBlockingReworkFindingsBlock(mid, sid, tid) {
+    const findings = getBlockingReworkFindingsForTask(mid, sid, tid)
+        .filter((finding) => finding.status === "pending");
+    if (findings.length === 0)
+        return "";
+    const lines = [
+        "## Blocking Rework Findings (non-optional)",
+        "",
+        "This task has structured blocking rework findings. Address every finding before calling `gsd_task_complete`. Include `reworkResolution` entries with each `findingId`, `status: \"resolved\"`, and concrete evidence. If deferring a finding, use `status: \"deferred-with-override\"` with concrete evidence and `decisionRef`.",
+        "",
+    ];
+    for (const finding of findings) {
+        lines.push(`### ${finding.finding_id} (${finding.severity})`);
+        lines.push(`- Status: ${finding.status}`);
+        lines.push(`- Finding: ${finding.description}`);
+        lines.push(`- Required fix: ${finding.required_fix}`);
+        if (finding.verification_commands.length > 0) {
+            lines.push("- Required verification:");
+            for (const command of finding.verification_commands) {
+                lines.push(`  - \`${command}\``);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
 function formatProjectClassificationForPlanning(classification) {
     const sampleFiles = classification.contentFiles.slice(0, 8);
     const sample = sampleFiles.length > 0 ? sampleFiles.map((file) => `\`${file}\``).join(", ") : "(none)";
@@ -174,7 +216,7 @@ function formatCloseoutReviewInstructions(validationContent, validationRel, curr
         `No passing validation artifact was found at \`${validationRel}\`. Use the full closeout review path before completion.`,
     ].join("\n");
 }
-function capPreamble(preamble) {
+export function capPreamble(preamble) {
     // Cap inlined context at min(static ceiling, scaled inline budget).
     // The ceiling bounds repeated auto prompt payloads; the scaled
     // budget tightens the cap for small-window users whose true safe limit is
@@ -184,6 +226,35 @@ function capPreamble(preamble) {
         return preamble;
     return truncateAtSectionBoundary(preamble, budget).content;
 }
+/**
+ * Cap the execute-task inline blocks against one shared budget in priority
+ * order. Unlike `capPreamble` (single concatenated preamble), execute-task
+ * feeds these blocks into separate, non-contiguous template placeholders, so
+ * they can't be joined and re-split — the budget is spent block-by-block.
+ *
+ * The task plan is the authoritative execution contract: it is never truncated
+ * here (it consumes budget first, whole). Remaining budget flows to the slice
+ * excerpt, then templates, each truncated at section boundaries so the lowest-
+ * priority context drops whole trailing sections first. When the task plan
+ * alone meets or exceeds the budget, the trailing blocks are dropped rather
+ * than the task plan being cut.
+ */
+function capExecuteTaskInlineBlocks(taskPlan, slicePlan, templates, budgetChars) {
+    let remaining = budgetChars - taskPlan.length;
+    if (remaining <= 0) {
+        return { taskPlan, slicePlan: "", templates: "" };
+    }
+    const cappedSlice = slicePlan.length <= remaining
+        ? slicePlan
+        : truncateAtSectionBoundary(slicePlan, remaining).content;
+    remaining -= cappedSlice.length;
+    const cappedTemplates = remaining <= 0
+        ? ""
+        : templates.length <= remaining
+            ? templates
+            : truncateAtSectionBoundary(templates, remaining).content;
+    return { taskPlan, slicePlan: cappedSlice, templates: cappedTemplates };
+}
 function trackPromptContext(entries, key, mode, body, reason) {
     entries.push({
         key,
@@ -227,7 +298,7 @@ function renderContextModeBlockForPrompt(unitType, base, renderMode = "standalon
     return `${contextMode}\n\n## Context Snapshot\nSource: \`.gsd/last-snapshot.md\`\n\n${snapshot.trimEnd()}`;
 }
 function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
-    const toolSurface = composeToolSurfaceInstructions(unitType, { renderMode });
+    const toolSurface = composeToolSurfaceInstructions(unitType, { renderMode, basePath: base });
     const contextMode = renderContextModeBlockForPrompt(unitType, base, renderMode);
     const guidance = [toolSurface, contextMode].filter(Boolean).join("\n\n");
     if (!guidance)
@@ -284,7 +355,7 @@ function formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionP
         // so DEFAULT_CONTEXT_WINDOW stays the single source of truth.
         windowTokens = resolveExecutorContextWindow(undefined, undefined, sessionContextWindow, sessionProvider);
     }
-    const budgets = computeBudgets(windowTokens);
+    const budgets = computeBudgets(windowTokens, sessionProvider);
     const { min, max } = budgets.taskCountRange;
     const execWindowK = Math.round(windowTokens / 1000);
     const perTaskBudgetK = Math.round(budgets.inlineContextBudgetChars / 1000);
@@ -1219,6 +1290,13 @@ function resolveTaskSummariesLocation(base, mid, sid) {
         return { dir: tDir, relPrefix: `${sRel}/tasks` };
     return { dir: slicePath, relPrefix: sRel };
 }
+function summaryFileBelongsToSlice(fileName, base, mid, sid) {
+    const tid = taskIdFromTaskFileName(fileName, "SUMMARY");
+    if (!tid)
+        return false;
+    const resolved = resolveTaskFile(base, mid, sid, tid, "SUMMARY");
+    return resolved !== null && basename(resolved) === fileName;
+}
 export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
     const loc = resolveTaskSummariesLocation(base, mid, sid);
     if (!loc)
@@ -1227,7 +1305,12 @@ export async function getPriorTaskSummaryPaths(mid, sid, currentTid, base) {
     const currentNum = parseInt(currentTid.replace(/^T/, ""), 10);
     return summaryFiles
         .filter(f => {
-        const num = parseInt(f.replace(/^T/, ""), 10);
+        if (!summaryFileBelongsToSlice(f, base, mid, sid))
+            return false;
+        const tid = taskIdFromTaskFileName(f, "SUMMARY");
+        if (!tid)
+            return false;
+        const num = parseInt(tid.replace(/^T/, ""), 10);
         return num < currentNum;
     })
         .map(f => `${loc.relPrefix}/${f}`);
@@ -1254,8 +1337,11 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
     const depSet = new Set(dependsOn.map((d) => d.toUpperCase()));
     return summaryFiles
         .filter((f) => {
-        // Extract task ID from filename: "T02-SUMMARY.md" → "T02"
-        const tid = f.replace(/-SUMMARY\.md$/i, "").toUpperCase();
+        if (!summaryFileBelongsToSlice(f, base, mid, sid))
+            return false;
+        const tid = taskIdFromTaskFileName(f, "SUMMARY");
+        if (!tid)
+            return false;
         return depSet.has(tid);
     })
         .map((f) => `${loc.relPrefix}/${f}`);
@@ -2281,7 +2367,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     // Compute verification budget for the executor's context window (issue #707)
     const prefs = loadEffectiveGSDPreferences();
     const contextWindow = resolveExecutorContextWindow(opts.modelRegistry, prefs?.preferences, opts.sessionContextWindow, opts.sessionProvider);
-    const budgets = computeBudgets(contextWindow);
+    const budgets = computeBudgets(contextWindow, opts.sessionProvider);
     const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
     // Truncate carry-forward section when it exceeds 40% of inline context budget.
     const carryForwardBudget = Math.floor(budgets.inlineContextBudgetChars * 0.4);
@@ -2319,6 +2405,14 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     catch (reopenErr) {
         logWarning("prompt", `reopen reason injection failed: ${reopenErr.message}`);
     }
+    const reworkFindingsBlock = renderBlockingReworkFindingsBlock(mid, sid, tid);
+    if (reworkFindingsBlock) {
+        const block = reworkFindingsBlock + "\n\n---\n\n";
+        phaseAnchorSection = phaseAnchorSection
+            ? `${block}${phaseAnchorSection}`
+            : block;
+        trackPromptContext(contextTelemetry, "rework-findings", "inline", reworkFindingsBlock);
+    }
     // ADR-011 Phase 2: inject any resolved-but-unapplied escalation override
     // into this task's prompt. Claim is atomic via DB UPDATE WHERE IS NULL, so
     // if a parallel build already injected it, we skip. Feature-gated by
@@ -2375,10 +2469,19 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
             }
         },
     });
-    const taskPlanInline = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "task-plan");
-    const slicePlanExcerpt = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "slice-plan");
+    const rawTaskPlanInline = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "task-plan");
+    const rawSlicePlanExcerpt = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "slice-plan");
     const contractedCarryForward = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "prior-task-summaries");
-    const contractedTemplates = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "templates");
+    const rawContractedTemplates = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "templates");
+    // Cap the static inline blocks against one shared budget so a small-window
+    // executor can't overflow (the sibling builders cap via `capPreamble`;
+    // execute-task's blocks feed separate template slots, so they share a budget
+    // block-by-block). Carry-forward already has its own truncation above.
+    const inlineBudget = Math.min(MAX_PREAMBLE_CHARS, budgets.inlineContextBudgetChars);
+    const { taskPlan: taskPlanInline, slicePlan: slicePlanExcerpt, templates: contractedTemplates } = capExecuteTaskInlineBlocks(rawTaskPlanInline, rawSlicePlanExcerpt, rawContractedTemplates, inlineBudget);
+    const inlineDropped = (rawTaskPlanInline.length + rawSlicePlanExcerpt.length + rawContractedTemplates.length)
+        - (taskPlanInline.length + slicePlanExcerpt.length + contractedTemplates.length);
+    trackPromptContext(contextTelemetry, "inline-cap", inlineDropped > 0 ? "excerpt" : "skipped", null, inlineDropped > 0 ? `dropped ${inlineDropped} chars (budget ${inlineBudget})` : "within budget");
     const onDemandResult = renderExecuteTaskOnDemandContext(base, mid, sid, contractedContext.onDemand);
     const onDemandContext = onDemandResult.text;
     trackPromptContext(contextTelemetry, "slice-research", onDemandContext ? "on-demand" : "skipped", onDemandContext, onDemandContext ? undefined : onDemandResult.skipReason ?? undefined);
@@ -2463,12 +2566,14 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                     trackPromptContext(contextTelemetry, "prior-task-summaries", "skipped", null, "missing tasks dir");
                     return null;
                 }
-                const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY").sort();
+                const summaryFiles = resolveTaskFiles(loc.dir, "SUMMARY")
+                    .filter((file) => summaryFileBelongsToSlice(file, base, mid, sid))
+                    .sort();
                 const blocks = [];
                 for (const file of summaryFiles) {
                     const absPath = join(loc.dir, file);
                     const relPath = `${loc.relPrefix}/${file}`;
-                    const taskId = file.replace(/-SUMMARY\.md$/i, "");
+                    const taskId = taskIdFromTaskFileName(file, "SUMMARY") ?? file.replace(/-SUMMARY\.md$/i, "");
                     blocks.push(await buildTaskSummaryExcerpt(absPath, relPath, taskId));
                 }
                 const body = blocks.length > 0 ? blocks.join("\n\n---\n\n") : null;
@@ -3038,7 +3143,9 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     let blockerTaskId = "";
     const summaryLoc = resolveTaskSummariesLocation(base, mid, sid);
     if (summaryLoc) {
-        const summaryFiles = resolveTaskFiles(summaryLoc.dir, "SUMMARY").sort();
+        const summaryFiles = resolveTaskFiles(summaryLoc.dir, "SUMMARY")
+            .filter((file) => summaryFileBelongsToSlice(file, base, mid, sid))
+            .sort();
         for (const file of summaryFiles) {
             const absPath = join(summaryLoc.dir, file);
             const content = await loadFile(absPath);
@@ -3047,7 +3154,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
             const summary = parseSummary(content);
             const relPath = `${summaryLoc.relPrefix}/${file}`;
             if (summary.frontmatter.blocker_discovered) {
-                blockerTaskId = summary.frontmatter.id || file.replace(/-SUMMARY\.md$/i, "");
+                blockerTaskId = summary.frontmatter.id || taskIdFromTaskFileName(file, "SUMMARY") || file.replace(/-SUMMARY\.md$/i, "");
                 inlined.push(await buildTaskSummaryExcerpt(absPath, relPath, blockerTaskId, { blocker: true }));
             }
         }

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -17,7 +17,7 @@ import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus, isInactiveStatus } from "./status-guards.js";
-import { resolveSlicePath, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
+import { resolveSlicePath, resolveTaskFile, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { dirname } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
@@ -227,10 +227,15 @@ export function writeReactiveExecuteBlocker(unitId, base, reason) {
     const slicePath = resolveSlicePath(base, mid, sid);
     if (!slicePath)
         return null;
-    const tasksDir = resolveTasksDir(base, mid, sid) ?? slicePath;
-    const existingSummaries = new Set(resolveTaskFiles(tasksDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()));
-    const summaryPresent = batchIds.filter((tid) => existingSummaries.has(tid.toUpperCase()));
-    const summaryMissing = batchIds.filter((tid) => !existingSummaries.has(tid.toUpperCase()));
+    // Resolve each batch task's SUMMARY with slice-qualified paths so flat-phase
+    // slices that reuse a task id (e.g. two T03s in one phase) don't collide: a
+    // sibling slice's summary must never make this slice's task look complete.
+    const hasSummary = (tid) => {
+        const summaryPath = resolveTaskFile(base, mid, sid, tid, "SUMMARY");
+        return summaryPath !== null && existsSync(summaryPath);
+    };
+    const summaryPresent = batchIds.filter((tid) => hasSummary(tid));
+    const summaryMissing = batchIds.filter((tid) => !hasSummary(tid));
     const completedTaskIds = [];
     const skippedTaskIds = [];
     const unchangedTaskIds = [];

package/dist/resources/extensions/gsd/auto-worktree-cleanup.js

@@ -8,6 +8,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, realpathSync, unlinkSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 import { gsdRoot } from "./paths.js";
+import { milestoneMetaPath } from "./git-service.js";
 import { logWarning } from "./workflow-logger.js";
 function isSamePath(a, b) {
     try {
@@ -73,6 +74,9 @@ export function clearProjectRootStateFiles(basePath, milestoneId) {
     // worth removing on teardown.
     const transientFiles = [
         join(gsdDir, "STATE.md"),
+        // Integration-branch META now lives flat at .gsd/<MID>-META.json (ADR-045).
+        milestoneMetaPath(basePath, milestoneId),
+        // Legacy location — still cleaned for pre-migration trees.
         join(gsdDir, "milestones", milestoneId, `${milestoneId}-META.json`),
     ];
     for (const file of transientFiles) {

package/dist/resources/extensions/gsd/auto-worktree-teardown.js

@@ -45,7 +45,7 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
             throw new GSDError(GSD_IO_ERROR, `Failed to chdir back to ${originalBasePath} during teardown: ${err instanceof Error ? err.message : String(err)}`);
         }
         // Mirror cleanup steps from mergeMilestoneToMain abort path:
-        // 1. Remove transient state files (STATE.md, auto.lock, {MID}-META.json).
+        // 1. Remove transient state files (STATE.md, auto.lock, .gsd/{MID}-META.json).
         //    Non-fatal — must not block teardown.
         try {
             clearProjectRootStateFiles(originalBasePath, milestoneId);

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

@@ -11,7 +11,7 @@
  * next unit type, creates a fresh session, and injects a focused prompt
  * telling the LLM which files to read and what to do.
  */
-import { deriveState } from "./state.js";
+import { deriveState, invalidateStateCache } from "./state.js";
 import { buildRequirementsBacklogSummaryLines, countUnmappedActiveRequirements, getUnmappedActiveRequirements, } from "./requirements-backlog.js";
 import { parseUnitId } from "./unit-id.js";
 import { assessInterruptedSession, readPausedSessionMetadata, PAUSED_SESSION_KV_KEY, } from "./interrupted-session.js";
@@ -214,6 +214,9 @@ function captureMilestoneLockEnv(milestoneId) {
     else {
         delete process.env.GSD_MILESTONE_LOCK;
     }
+    // The derive cache is keyed on basePath only; GSD_MILESTONE_LOCK changes
+    // what deriveState computes, so a lock flip must not serve a cached result.
+    invalidateStateCache();
 }
 function restoreMilestoneLockEnv() {
     if (!s.milestoneLockEnvCaptured)
@@ -227,6 +230,7 @@ function restoreMilestoneLockEnv() {
     s.previousMilestoneLockEnv = null;
     s.hadMilestoneLockEnv = false;
     s.milestoneLockEnvCaptured = false;
+    invalidateStateCache();
 }
 /**
  * Rebuild s.scope from the current s.basePath / s.originalBasePath / s.currentMilestoneId.

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -46,6 +46,8 @@ function registerAlias(pi, toolDef, aliasName, canonicalName) {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- toolDef shape matches ToolDefinition but varies by schema
 function registerWorkflowTool(pi, toolDef) {
     pi.registerTool(toolDef);
+    if (process.env.GSD_ADVERTISE_TOOL_ALIASES !== "1")
+        return; // canonical-only model surface (see plan 035)
     for (const alias of aliasesForWorkflowTool(toolDef.name)) {
         registerAlias(pi, toolDef, alias, toolDef.name);
     }
@@ -731,12 +733,12 @@ export function registerDbTools(pi) {
     const planTaskTool = {
         name: "gsd_plan_task",
         label: "Plan Task",
-        description: "Write task planning state to the GSD database, render tasks/T##-PLAN.md from DB, and clear caches after a successful render.",
-        promptSnippet: "Plan a task via DB write + task PLAN render + cache invalidation",
+        description: "Write task planning state to the GSD database, render the slice PLAN from DB, and clear caches after a successful render.",
+        promptSnippet: "Plan a task via DB write + slice PLAN render + cache invalidation",
         promptGuidelines: [
-            "Use gsd_plan_task for task planning instead of writing tasks/T##-PLAN.md directly.",
+            "Use gsd_plan_task for task planning instead of writing task PLAN files directly.",
             "Keep parameters flat and provide the full task planning payload.",
-            "The tool validates input, requires an existing parent slice, writes task planning data, renders the task PLAN file from DB, and clears both state and parse caches after success.",
+            "The tool validates input, requires an existing parent slice, writes task planning data, renders the slice PLAN file from DB, and clears both state and parse caches after success.",
             "Use the canonical name gsd_plan_task; gsd_task_plan is only an alias.",
         ],
         parameters: Type.Object({
@@ -812,6 +814,12 @@ export function registerDbTools(pi) {
                 verdict: Type.String({ description: "Pass/fail verdict (e.g. '✅ pass', '❌ fail')" }),
                 durationMs: Type.Number({ description: "Duration of the command in milliseconds" }),
             }), { description: "Array of verification evidence entries (structured objects only)" })),
+            reworkResolution: Type.Optional(Type.Array(Type.Object({
+                findingId: Type.String({ description: "Rework finding ID being resolved (e.g. F1)" }),
+                status: StringEnum(["resolved", "deferred-with-override"], { description: "Resolution status for this finding" }),
+                evidence: Type.String({ description: "Concrete evidence that the required fix was completed" }),
+                decisionRef: Type.Optional(Type.String({ description: "Decision reference required for deferred-with-override findings" })),
+            }), { description: "Resolution evidence for structured rework findings linked to this task" })),
             // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
             actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
             triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'task verified after retry')" })),
@@ -1084,6 +1092,74 @@ export function registerDbTools(pi) {
         execute: replanSliceExecute,
     };
     registerWorkflowTool(pi, replanSliceTool);
+    // ─── gsd_replan_task ───────────────────────────────────────────────────
+    const replanTaskExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeReplanTask } = await loadWorkflowExecutors();
+        return executeReplanTask(params, resolveWorkflowToolBasePath(_ctx, params));
+    };
+    const replanTaskTool = {
+        name: "gsd_replan_task",
+        label: "Replan Task",
+        description: "Update one pending task's planning contract after rework without touching sibling tasks. " +
+            "Completed tasks are structurally protected. Re-renders the task/slice PLAN projection and records replan history.",
+        promptSnippet: "Replan one pending GSD task after rework",
+        promptGuidelines: [
+            "Use gsd_replan_task when a reopened pending task needs its title, description, files, verify, inputs, or expectedOutput updated for rework.",
+            "The task must already exist and be pending; completed tasks are rejected.",
+            "Set reworkBriefRef when a structured rework brief triggered the task replan.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
+            taskId: Type.String({ description: "Task ID (e.g. T01)" }),
+            title: Type.String({ description: "Updated task title" }),
+            description: Type.String({ description: "Updated task description incorporating rework scope" }),
+            estimate: Type.String({ description: "Updated task estimate string" }),
+            files: Type.Array(Type.String(), { description: "Updated files likely touched" }),
+            verify: Type.String({ description: "Updated verification command or block" }),
+            inputs: Type.Array(Type.String(), { description: "Updated input files or references" }),
+            expectedOutput: Type.Array(Type.String(), { description: "Updated files this task creates or overwrites" }),
+            reworkBriefRef: Type.Optional(Type.String({ description: "Rework brief ID/reference that triggered this task replan" })),
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered" })),
+        }),
+        execute: replanTaskExecute,
+    };
+    registerWorkflowTool(pi, replanTaskTool);
+    // ─── gsd_rework_brief_save ─────────────────────────────────────────────
+    const reworkBriefSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeReworkBriefSave } = await loadWorkflowExecutors();
+        return executeReworkBriefSave(params, resolveWorkflowToolBasePath(_ctx, params));
+    };
+    const reworkBriefSaveTool = {
+        name: "gsd_rework_brief_save",
+        label: "Save Rework Brief",
+        description: "Persist a structured rework brief for a task. Blocking findings are enforced by gsd_task_complete until resolved with evidence.",
+        promptSnippet: "Persist structured task rework findings",
+        promptGuidelines: [
+            "Use gsd_rework_brief_save when post-unit checks produce task rework findings.",
+            "Use severity 'blocking' for findings that must be resolved before gsd_task_complete succeeds.",
+            "Each finding needs a stable findingId, requiredFix, and verificationCommands.",
+        ],
+        parameters: Type.Object({
+            briefId: Type.Optional(Type.String({ description: "Stable brief ID; omitted defaults to RB-<milestone>-<slice>-<task>" })),
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
+            taskId: Type.String({ description: "Task ID (e.g. T01)" }),
+            findings: Type.Array(Type.Object({
+                findingId: Type.String({ description: "Stable finding ID (e.g. F1)" }),
+                severity: StringEnum(["blocking", "advisory"], { description: "Whether this finding blocks task completion" }),
+                description: Type.String({ description: "What was found" }),
+                requiredFix: Type.String({ description: "What must change" }),
+                verificationCommands: Type.Array(Type.String(), { description: "Commands that must pass after the fix" }),
+                status: Type.Optional(StringEnum(["pending", "resolved", "deferred-with-override"], { description: "Finding status; defaults to pending" })),
+                evidence: Type.Optional(Type.String({ description: "Resolution evidence when already resolved" })),
+                decisionRef: Type.Optional(Type.String({ description: "Decision reference for deferred-with-override" })),
+            }), { description: "Structured rework findings for this task" }),
+        }),
+        execute: reworkBriefSaveExecute,
+    };
+    registerWorkflowTool(pi, reworkBriefSaveTool);
     // ─── gsd_reassess_roadmap (gsd_roadmap_reassess alias) ─────────────────
     const reassessRoadmapExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeReassessRoadmap } = await loadWorkflowExecutors();

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -22,13 +22,14 @@ import { saveActivityLog } from "../activity-log.js";
 import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult, saveEvidenceToDisk } from "../safety/evidence-collector.js";
 import { parseUnitId } from "../unit-id.js";
 import { classifyCommand } from "../safety/destructive-guard.js";
-import { confirmDestructiveCommand, consumeDestructiveConfirmation, isDestructiveConfirmGateId, requestDestructiveConfirmation, } from "../safety/destructive-confirmation.js";
+import { confirmDestructiveCommand, consumeDestructiveConfirmation, isDestructiveConfirmGateId, peekPendingDestructiveCommand, requestDestructiveConfirmation, resetDestructiveConfirmation, } from "../safety/destructive-confirmation.js";
 import { logWarning as safetyLogWarning, setStderrLoggingEnabled } from "../workflow-logger.js";
 import { isUnitCloseoutTool, runInteractiveUnitCloseout } from "../unit-closeout.js";
 import { installNotifyInterceptor } from "./notify-interceptor.js";
 import { initNotificationStore } from "../notification-store.js";
 import { initNotificationWidget } from "../notification-widget.js";
 import { notifyPreferenceDiagnostics } from "../preferences-diagnostics.js";
+import { resolveEffectivePlanningToolsPolicy } from "../planning-subagent-policy.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { extractSubagentAgentClasses } from "./subagent-input.js";
 import { approvalGateIdForUnit, evaluateAskUserQuestionsRound, formatUnansweredConsentQuestionMessage, isExplicitApprovalResponse, messageHasPendingAskUserQuestionsTool, shouldPauseForQuestion, } from "../consent-question.js";
@@ -136,6 +137,7 @@ function suppressWelcomeHeader(ctx) {
  * are bounded — cleared on activation, session boundaries, and verification.
  */
 const deferredApprovalGates = new Map();
+const deferredDestructiveConfirmationPauses = new Set();
 export const MINIMAL_GSD_TOOL_NAMES = [
     "gsd_exec",
     "gsd_exec_search",
@@ -456,6 +458,21 @@ function clearDeferredApprovalGate(basePath) {
         deferredApprovalGates.delete(basePath);
     }
 }
+function deferDestructiveConfirmationPause(basePath) {
+    deferredDestructiveConfirmationPauses.add(basePath);
+}
+function clearDeferredDestructiveConfirmationPause(basePath) {
+    if (!basePath) {
+        deferredDestructiveConfirmationPauses.clear();
+    }
+    else {
+        deferredDestructiveConfirmationPauses.delete(basePath);
+    }
+}
+function isDestructiveConfirmationBlocking(basePath) {
+    return deferredDestructiveConfirmationPauses.has(basePath)
+        && Boolean(peekPendingDestructiveCommand(basePath));
+}
 function deferApprovalGate(gateId, basePath) {
     // Verified-on-disk wins (same adapter policy as activation/re-arm): if the
     // workflow MCP child already verified this gate, deferring would block
@@ -798,6 +815,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         await applyToolCallLoopGuardConfig(basePath);
         approvalQuestionAbortInFlight = false;
         clearDeferredApprovalGate();
+        clearDeferredDestructiveConfirmationPause();
         await resetAskUserQuestionsTurnCache();
         await syncServiceTierStatus(ctx);
         await applyDisabledModelProviderPolicy(ctx);
@@ -883,6 +901,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         resetToolCallLoopGuard();
         await applyToolCallLoopGuardConfig(basePath);
         clearDeferredApprovalGate();
+        clearDeferredDestructiveConfirmationPause();
         await resetAskUserQuestionsTurnCache();
         clearDiscussionFlowState(basePath);
         // /clear or /new destroys the conversation holding a discuss interview, so
@@ -933,6 +952,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             }
         }
         clearDeferredApprovalGate(beforeAgentBasePath);
+        clearDeferredDestructiveConfirmationPause(beforeAgentBasePath);
         // session_start can fire before the active provider has settled. By
         // before_agent_start, Claude Code CLI sessions should get the same
         // project MCP config that /gsd mcp init would write.
@@ -1010,7 +1030,10 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         finally {
             activateDeferredApprovalGate(agentEndBasePath);
+            const destructiveConfirmationBlocking = isDestructiveConfirmationBlocking(agentEndBasePath);
+            clearDeferredDestructiveConfirmationPause(agentEndBasePath);
             await maybePauseAutoForApprovalGate(ctx, pi, isApprovalGateBlocking(agentEndBasePath), "Depth confirmation is waiting for your answer — pausing auto-mode.");
+            await maybePauseAutoForApprovalGate(ctx, pi, destructiveConfirmationBlocking, "Destructive-command confirmation is waiting for your answer — pausing auto-mode.");
         }
     });
     pi.on("message_end", async (event) => {
@@ -1276,6 +1299,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         const activeUnitType = dash.currentUnit?.type ?? guidedUnit?.unitType;
         if (activeUnitType) {
             const manifest = resolveManifest(activeUnitType);
+            const planningBasePath = dash.basePath || guidedUnit?.basePath || discussionBasePath;
             let planningInput = "";
             let agentClasses;
             if (isToolCallEventType("write", event)) {
@@ -1291,7 +1315,7 @@ export function registerHooks(pi, ecosystemHandlers) {
                 // Subagent inputs use { agent }, { tasks: [{ agent }] }, or { chain: [{ agent }] }.
                 agentClasses = extractSubagentAgentClasses(event.input);
             }
-            const planningGuard = shouldBlockPlanningUnit(event.toolName, planningInput, dash.basePath || guidedUnit?.basePath || discussionBasePath, activeUnitType, manifest?.tools, agentClasses, event.input, dash.currentUnit?.id);
+            const planningGuard = shouldBlockPlanningUnit(event.toolName, planningInput, planningBasePath, activeUnitType, resolveEffectivePlanningToolsPolicy(activeUnitType, manifest?.tools, planningBasePath), agentClasses, event.input, dash.currentUnit?.id);
             if (planningGuard.block)
                 return planningGuard;
         }
@@ -1373,6 +1397,7 @@ export function registerHooks(pi, ecosystemHandlers) {
                 // Record the command as pending so an affirmative answer to a
                 // destructive_confirm gate (handled in tool_result) can confirm it.
                 requestDestructiveConfirmation(command, guardBasePath);
+                deferDestructiveConfirmationPause(guardBasePath);
                 const reason = [
                     "HARD BLOCK: destructive Bash command requires explicit human confirmation.",
                     `Detected: ${classification.labels.join(", ")}`,
@@ -1383,9 +1408,6 @@ export function registerHooks(pi, ecosystemHandlers) {
                 safetyLogWarning("safety", `destructive command: ${classification.labels.join(", ")}`, {
                     command: String(command).slice(0, 200),
                 });
-                if (ctx) {
-                    await maybePauseAutoForApprovalGate(ctx, pi, isAutoActive(), "Destructive-command confirmation is waiting for your answer — pausing auto-mode.");
-                }
                 return { block: true, reason };
             }
         }
@@ -1541,6 +1563,10 @@ export function registerHooks(pi, ecosystemHandlers) {
                 if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
                     confirmDestructiveCommand(basePath);
                 }
+                else {
+                    resetDestructiveConfirmation(basePath);
+                }
+                clearDeferredDestructiveConfirmationPause(basePath);
                 break;
             }
         }

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -18,6 +18,13 @@ import { formatOverridesSection, formatShortcut, loadActiveOverrides, loadFile,
 import { toPosixPath } from "../../shared/mod.js";
 import { autoEnableCmuxPreferences } from "../commands-cmux.js";
 import { gsdHome } from "../gsd-home.js";
+import { GSD_CONTEXT_MESSAGE_SENTINEL } from "../constants.js";
+// Single source of truth lives in ../constants.js; re-exported here because
+// buildContextMessage() stamps this marker on every context injection and the
+// provider payload policy (filterSupersededContextInjections in
+// context-masker.ts) matches it to dedupe. Adding a new context customType?
+// Ensure buildContextMessage still prepends this sentinel.
+export { GSD_CONTEXT_MESSAGE_SENTINEL };
 const DEFAULT_CONTEXT_MESSAGE_MAX_CHARS = 4_000;
 const DEFAULT_KNOWLEDGE_MAX_CHARS = 12_000;
 const DEFAULT_CODEBASE_MAX_CHARS = 8_000;
@@ -385,17 +392,17 @@ export function buildContextMessage(opts) {
     const contextCharLimit = getContextMessageCharLimit();
     const memoryContent = markMemoryContextSupplied(opts.memoryBlock.trim());
     if (opts.injection) {
-        const content = limitContextMessageContent(memoryContent ? `${memoryContent}\n\n${opts.injection}` : opts.injection, contextCharLimit);
+        const content = limitContextMessageContent(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n${memoryContent ? `${memoryContent}\n\n${opts.injection}` : opts.injection}`, contextCharLimit);
         return { customType: "gsd-guided-context", content, display: false };
     }
     if (opts.forensicsInjection) {
-        const content = limitContextMessageContent(memoryContent ? `${memoryContent}\n\n${opts.forensicsInjection}` : opts.forensicsInjection, contextCharLimit);
+        const content = limitContextMessageContent(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n${memoryContent ? `${memoryContent}\n\n${opts.forensicsInjection}` : opts.forensicsInjection}`, contextCharLimit);
         return { customType: "gsd-forensics", content, display: false };
     }
     if (memoryContent) {
         return {
             customType: "gsd-memory",
-            content: limitContextMessageContent(memoryContent, contextCharLimit),
+            content: limitContextMessageContent(`${GSD_CONTEXT_MESSAGE_SENTINEL}\n${memoryContent}`, contextCharLimit),
             display: false,
         };
     }