@opengsd/gsd-pi 1.8.1 → 1.9.0

package/dist/resources/extensions/browser-tools/screenshot-constraints.js

@@ -0,0 +1,83 @@
+// sharp is an optional native dependency. Load it lazily so that screenshot
+// emitters still work on platforms where sharp is unavailable (e.g. bunx on
+// Raspberry Pi). constrainScreenshot falls back to returning the raw buffer
+// when sharp is not installed.
+let _sharp;
+async function getSharp() {
+    if (_sharp !== undefined)
+        return _sharp;
+    try {
+        _sharp = (await import("sharp")).default;
+    }
+    catch {
+        _sharp = null;
+    }
+    return _sharp;
+}
+/**
+ * Test-only seam: override the cached sharp module. Pass `null` to simulate
+ * an environment where the sharp native dep is unavailable; pass `undefined`
+ * to clear the cache and let the next getSharp() call re-import. See
+ * tests/capture-sharp-optional.test.cjs.
+ */
+export function __setSharpForTesting(value) {
+    _sharp = value;
+}
+// Anthropic vision: 1568px is the recommended optimal width. Height is capped
+// generously at 8000px so tall full-page screenshots remain readable rather
+// than being squished into a square constraint.
+//
+// Override via environment variables:
+//   SCREENSHOT_MAX_WIDTH=0   -> uncap width (use raw resolution)
+//   SCREENSHOT_MAX_HEIGHT=0  -> uncap height
+export const MAX_SCREENSHOT_WIDTH = parseScreenshotDimension(process.env.SCREENSHOT_MAX_WIDTH, 1568);
+export const MAX_SCREENSHOT_HEIGHT = parseScreenshotDimension(process.env.SCREENSHOT_MAX_HEIGHT, 8000);
+/** Parse a dimension env var: positive int = that value, 0 = Infinity (uncapped), absent/invalid = default. */
+function parseScreenshotDimension(value, fallback) {
+    if (value === undefined || value === "")
+        return fallback;
+    const n = parseInt(value, 10);
+    if (isNaN(n) || n < 0)
+        return fallback;
+    if (n === 0)
+        return Infinity;
+    return n;
+}
+export async function getScreenshotBufferDimensions(buffer) {
+    const sharp = await getSharp();
+    if (!sharp)
+        return null;
+    const meta = await sharp(buffer).metadata();
+    if (meta.width === undefined || meta.height === undefined)
+        return null;
+    return { width: meta.width, height: meta.height };
+}
+/**
+ * Constrain screenshot dimensions for the Anthropic vision API.
+ * Width is capped at 1568px (optimal) and height at 8000px, each
+ * independently, using `fit: "inside"` so aspect ratio is preserved.
+ * Small images are never upscaled.
+ *
+ * `page` parameter is retained for ToolDeps signature stability (D008)
+ * but is no longer used — all processing is server-side via sharp.
+ */
+export async function constrainScreenshot(_page, buffer, mimeType, quality) {
+    const sharp = await getSharp();
+    if (!sharp)
+        return buffer;
+    const dimensions = await getScreenshotBufferDimensions(buffer);
+    const width = dimensions?.width;
+    const height = dimensions?.height;
+    if (width === undefined || height === undefined)
+        return buffer;
+    if (width <= MAX_SCREENSHOT_WIDTH && height <= MAX_SCREENSHOT_HEIGHT)
+        return buffer;
+    const resizer = sharp(buffer).resize(MAX_SCREENSHOT_WIDTH, MAX_SCREENSHOT_HEIGHT, {
+        fit: "inside",
+        withoutEnlargement: true,
+    });
+    if (mimeType === "image/png") {
+        return Buffer.from(await resizer.png().toBuffer());
+    }
+    return Buffer.from(await resizer.jpeg({ quality }).toBuffer());
+}

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -10,6 +10,7 @@
  */
 import { EventStream } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { createRequire } from "node:module";
@@ -368,6 +369,7 @@ function inferMimeTypeFromDataUri(value) {
 /** Collect all base64 image blocks from user messages in the context for inclusion in the SDK prompt. */
 export function extractImageBlocksFromContext(context) {
     const imageBlocks = [];
+    const seenImageKeys = new Set();
     for (const msg of context.messages) {
         if (msg.role !== "user" || !Array.isArray(msg.content))
             continue;
@@ -382,12 +384,17 @@ export function extractImageBlocksFromContext(context) {
                 : inferMimeTypeFromDataUri(block.data);
             if (!mimeType)
                 continue;
+            const data = stripDataUriPrefix(block.data);
+            const imageKey = `${mimeType}\0${createHash("sha1").update(data).digest("hex")}`;
+            if (seenImageKeys.has(imageKey))
+                continue;
+            seenImageKeys.add(imageKey);
             imageBlocks.push({
                 type: "image",
                 source: {
                     type: "base64",
                     media_type: mimeType,
-                    data: stripDataUriPrefix(block.data),
+                    data,
                 },
             });
         }
@@ -1831,6 +1838,7 @@ function createSdkAttemptMessageState() {
     return {
         builder: null,
         intermediateToolBlocks: [],
+        intermediateTextBlocks: [],
         toolResultsById: new Map(),
         toolCompletionTargetsById: new Map(),
         emittedExternalToolResultIds: new Set(),
@@ -1939,7 +1947,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                 }
             }
             sdkAttemptLoop: for (let readinessAttempt = 0;; readinessAttempt++) {
-                let { builder, intermediateToolBlocks, toolResultsById, toolCompletionTargetsById, emittedExternalToolResultIds, } = createSdkAttemptMessageState();
+                let { builder, intermediateToolBlocks, intermediateTextBlocks, toolResultsById, toolCompletionTargetsById, emittedExternalToolResultIds, } = createSdkAttemptMessageState();
                 const controller = new AbortController();
                 const forwardAbort = () => controller.abort();
                 if (options?.signal) {
@@ -2061,9 +2069,15 @@ async function pumpSdkMessages(model, context, options, stream) {
                                     for (const [contentIndex, block] of builder.message.content.entries()) {
                                         if (block.type === "text" && block.text) {
                                             lastTextContent = block.text;
+                                            // Accumulate completed prose in order — a multi-question
+                                            // turn commits [prose][elicitation] segments across several
+                                            // synthetic-user boundaries, and overwriting a single
+                                            // scalar would drop every explanation but the last.
+                                            intermediateTextBlocks.push({ type: "text", text: block.text });
                                         }
                                         else if (block.type === "thinking" && block.thinking) {
                                             lastThinkingContent = block.thinking;
+                                            intermediateTextBlocks.push({ type: "thinking", thinking: block.thinking });
                                         }
                                         else if (block.type === "toolCall" || block.type === "serverToolUse") {
                                             // Collect tool blocks for externalToolExecution rendering
@@ -2161,6 +2175,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                                 const result = msg;
                                 const finalContent = buildFinalAssistantContent({
                                     intermediateToolBlocks,
+                                    intermediateTextBlocks,
                                     pendingContent: builder?.message.content,
                                     toolResultsById,
                                     lastThinkingContent,

package/dist/resources/extensions/claude-code-cli/turn-assembler.js

@@ -198,6 +198,15 @@ export function buildFinalAssistantContent(params) {
     }
     attachExternalResultsToToolBlocks(mergedToolBlocks, params.toolResultsById);
     const finalContent = mergedToolBlocks.filter((block) => !shouldSuppressDuplicateToolUnavailableBlock(block, mergedToolBlocks));
+    // Emit prose/thinking captured at earlier turn-boundaries (each successive
+    // `ask_user_questions` elicitation completes a turn) before the final
+    // segment. Capturing these in an ordered accumulator — symmetric with
+    // `intermediateToolBlocks` — is what keeps intermediate explanations from
+    // being collapsed to a single overwritten scalar and silently dropped.
+    const intermediateTextBlocks = params.intermediateTextBlocks ?? [];
+    for (const block of intermediateTextBlocks) {
+        finalContent.push(block);
+    }
     if (params.pendingContent && params.pendingContent.length > 0) {
         for (const block of params.pendingContent) {
             if (block.type === "text" || block.type === "thinking") {
@@ -206,11 +215,30 @@ export function buildFinalAssistantContent(params) {
         }
     }
     else {
+        // No builder content survived to this turn boundary, so fall back to the
+        // last scalar thinking/text captured off the stream. When the turn ends
+        // on an elicitation these scalars just mirror the final intermediate
+        // block (they are overwritten at each synthetic-user boundary), so only
+        // emit them when they carry content not already accumulated — otherwise
+        // a non-streaming `assistant` message's prose/thinking is silently lost.
+        const lastBlockOfType = (type) => {
+            for (let i = intermediateTextBlocks.length - 1; i >= 0; i--) {
+                if (intermediateTextBlocks[i].type === type)
+                    return intermediateTextBlocks[i];
+            }
+            return undefined;
+        };
         if (params.lastThinkingContent) {
-            finalContent.push({ type: "thinking", thinking: params.lastThinkingContent });
+            const lastThinking = lastBlockOfType("thinking");
+            if (lastThinking?.thinking !== params.lastThinkingContent) {
+                finalContent.push({ type: "thinking", thinking: params.lastThinkingContent });
+            }
         }
         if (params.lastTextContent) {
-            finalContent.push({ type: "text", text: params.lastTextContent });
+            const lastText = lastBlockOfType("text");
+            if (lastText?.text !== params.lastTextContent) {
+                finalContent.push({ type: "text", text: params.lastTextContent });
+            }
         }
     }
     if (finalContent.length === 0 && params.fallbackResultText) {

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -263,9 +263,9 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
             }
             return `${relSliceFile(base, mid, sid, "RESEARCH")} (slice research)`;
         case "plan-slice":
-            return `${relSliceFile(base, mid, sid, "PLAN")} plus tasks/T##-PLAN.md files (slice plan and task plans)`;
+            return `${relSliceFile(base, mid, sid, "PLAN")} with embedded task plans`;
         case "refine-slice":
-            return `${relSliceFile(base, mid, sid, "PLAN")} plus tasks/T##-PLAN.md files (refined slice plan and task plans)`;
+            return `${relSliceFile(base, mid, sid, "PLAN")} with embedded refined task plans`;
         case "execute-task": {
             return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid, "PLAN")} + summary written`;
         }

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

@@ -209,7 +209,8 @@ export function shouldRunDeepProjectSetup(state, prefs, basePath, options = {})
 }
 function resolveArtifactBasePath(basePath, mid, session) {
     if (session?.basePath &&
-        session.currentMilestoneId === mid &&
+        session.currentMilestoneId &&
+        milestoneIdsDispatchCompatible(session.currentMilestoneId, mid) &&
         existsSync(session.basePath)) {
         return session.basePath;
     }
@@ -231,6 +232,24 @@ function normalizeMilestoneScope(value) {
         return null;
     return trimmed;
 }
+function dispatchMilestoneIdentity(value) {
+    const normalized = normalizeMilestoneScope(value);
+    const match = normalized?.match(/^(M\d{3})(?:-[a-z0-9]{6})?$/);
+    if (!match)
+        return null;
+    return { baseId: match[1], hasSuffix: normalized !== match[1] };
+}
+function isBareSuffixedMilestoneAlias(left, right) {
+    const leftId = dispatchMilestoneIdentity(left);
+    const rightId = dispatchMilestoneIdentity(right);
+    return Boolean(leftId &&
+        rightId &&
+        leftId.baseId === rightId.baseId &&
+        leftId.hasSuffix !== rightId.hasSuffix);
+}
+function milestoneIdsDispatchCompatible(left, right) {
+    return left === right || isBareSuffixedMilestoneAlias(left, right);
+}
 function resolveDispatchMilestoneScope(ctx) {
     const sessionMilestone = normalizeMilestoneScope(ctx.session?.currentMilestoneId);
     if (sessionMilestone)
@@ -243,6 +262,31 @@ function resolveDispatchMilestoneScope(ctx) {
         return { id: baseWorktree, source: "basePath worktree" };
     return null;
 }
+function resolveEffectiveDispatchMilestoneId(ctx, scopedMilestone) {
+    if (scopedMilestone && isBareSuffixedMilestoneAlias(ctx.mid, scopedMilestone.id)) {
+        return dispatchMilestoneIdentity(scopedMilestone.id)?.hasSuffix ? scopedMilestone.id : ctx.mid;
+    }
+    const activeMid = ctx.state.activeMilestone?.id;
+    if (activeMid && isBareSuffixedMilestoneAlias(ctx.mid, activeMid)) {
+        return dispatchMilestoneIdentity(activeMid)?.hasSuffix ? activeMid : ctx.mid;
+    }
+    return ctx.mid;
+}
+function withEffectiveDispatchMilestone(ctx, effectiveMid) {
+    if (effectiveMid === ctx.mid)
+        return ctx;
+    const activeMilestone = ctx.state.activeMilestone;
+    const state = activeMilestone && milestoneIdsDispatchCompatible(activeMilestone.id, effectiveMid)
+        ? {
+            ...ctx.state,
+            activeMilestone: {
+                ...activeMilestone,
+                id: effectiveMid,
+            },
+        }
+        : ctx.state;
+    return { ...ctx, mid: effectiveMid, state };
+}
 function hasMilestonePassedDiscuss(basePath, mid) {
     if (isDbAvailable()) {
         try {
@@ -510,18 +554,25 @@ export const DISPATCH_RULES = [
         // Fire BEFORE the execution-entry phase rules so we redispatch to
         // `discuss-milestone` instead of hitting the plan-v2 gate.
         name: "execution-entry phase (no context) → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
+        match: async ({ state, mid, midTitle, basePath, session, prefs, structuredQuestionsAvailable }) => {
             if (!EXECUTION_ENTRY_PHASES.has(state.phase))
                 return null;
             if (!MILESTONE_ID_RE.test(mid))
                 return null;
             if (isRegistryMilestoneComplete(state, mid))
                 return null;
-            if (hasMilestonePassedDiscuss(basePath, mid))
+            // Resolve discuss/context artifacts against the active session worktree,
+            // mirroring the executing rules below. For a suffixed-worktree milestone
+            // the CONTEXT and slice plans live under the worktree, not the project
+            // root; checking the raw project-root basePath misreads the milestone as
+            // "never discussed" and re-dispatches discuss-milestone after task
+            // closeout instead of continuing execution (#1317).
+            const artifactBasePath = resolveArtifactBasePath(basePath, mid, session);
+            if (hasMilestonePassedDiscuss(artifactBasePath, mid))
                 return null;
             // Align with the plan-v2 gate's lookup semantics: whitespace-only counts
             // as missing, and an auto worktree may fall back to GSD_PROJECT_ROOT.
-            if (hasFinalizedMilestoneContext(basePath, mid))
+            if (hasFinalizedMilestoneContext(artifactBasePath, mid))
                 return null;
             // H6 fix (#4973): non-deep auto-mode has no human to answer the
             // depth-verification question, so pre-marking avoids a write-gate
@@ -854,12 +905,14 @@ export const DISPATCH_RULES = [
     },
     {
         name: "pre-planning (no context) → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, session, structuredQuestionsAvailable }) => {
             if (state.phase !== "pre-planning")
                 return null;
             if (isRegistryMilestoneComplete(state, mid))
                 return null;
-            const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
+            const contextBasePath = resolveWorktreeProjectRoot(basePath, session?.originalBasePath);
+            const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT") ??
+                (contextBasePath !== basePath ? resolveMilestoneFile(contextBasePath, mid, "CONTEXT") : null);
             const hasContext = !!(contextFile && (await loadFile(contextFile)));
             if (hasContext)
                 return null; // fall through to next rule
@@ -1562,31 +1615,33 @@ function applyLanguageDirectiveToDispatch(action, prefs) {
  * resolveDispatch directly without registry initialization).
  */
 export async function resolveDispatch(ctx) {
-    if (ctx.mid && isDbAvailable()) {
-        const milestone = getMilestone(ctx.mid);
+    const scopedMilestone = resolveDispatchMilestoneScope(ctx);
+    const effectiveMid = resolveEffectiveDispatchMilestoneId(ctx, scopedMilestone);
+    const dispatchCtx = withEffectiveDispatchMilestone(ctx, effectiveMid);
+    if (dispatchCtx.mid && isDbAvailable()) {
+        const milestone = getMilestone(dispatchCtx.mid);
         if (milestone && isClosedStatus(milestone.status)) {
             return {
                 action: "stop",
-                reason: `Milestone ${ctx.mid} is closed (status: ${milestone.status}); auto-mode will not reopen or recover it implicitly. ` +
+                reason: `Milestone ${dispatchCtx.mid} is closed (status: ${milestone.status}); auto-mode will not reopen or recover it implicitly. ` +
                     "Use an explicit reopen command before planning or executing more work for this milestone.",
                 level: "warning",
             };
         }
     }
-    const activeMid = ctx.state.activeMilestone?.id;
-    if (activeMid && ctx.mid !== activeMid) {
+    const activeMid = dispatchCtx.state.activeMilestone?.id;
+    if (activeMid && !milestoneIdsDispatchCompatible(dispatchCtx.mid, activeMid)) {
         return {
             action: "stop",
-            reason: `Dispatch milestone mismatch: context mid "${ctx.mid}" does not match active milestone "${activeMid}". ` +
+            reason: `Dispatch milestone mismatch: context mid "${dispatchCtx.mid}" does not match active milestone "${activeMid}". ` +
                 "This usually means a project-level deep setup pseudo-id leaked into milestone dispatch; rerun /gsd auto after setup state is reconciled.",
             level: "warning",
         };
     }
-    const scopedMilestone = resolveDispatchMilestoneScope(ctx);
-    if (scopedMilestone && ctx.mid !== scopedMilestone.id) {
+    if (scopedMilestone && !milestoneIdsDispatchCompatible(dispatchCtx.mid, scopedMilestone.id)) {
         return {
             action: "stop",
-            reason: `Dispatch milestone mismatch: context mid "${ctx.mid}" does not match ${scopedMilestone.source} "${scopedMilestone.id}". ` +
+            reason: `Dispatch milestone mismatch: context mid "${dispatchCtx.mid}" does not match ${scopedMilestone.source} "${scopedMilestone.id}". ` +
                 "The active worktree/session and derived project state disagree; recover, park, or discard the stranded milestone before continuing.",
             level: "warning",
         };
@@ -1594,9 +1649,9 @@ export async function resolveDispatch(ctx) {
     // Delegate to registry when available
     try {
         const registry = getRegistry();
-        const action = annotateBackgroundable(await registry.evaluateDispatch(ctx));
+        const action = annotateBackgroundable(await registry.evaluateDispatch(dispatchCtx));
         if (action.action === "dispatch" &&
-            ctx.session?.exhaustedVerificationUnits?.has(`${action.unitType}:${action.unitId}`)) {
+            dispatchCtx.session?.exhaustedVerificationUnits?.has(`${action.unitType}:${action.unitId}`)) {
             return {
                 action: "stop",
                 reason: `Unit ${action.unitId} exhausted verification retries this session.`,
@@ -1610,13 +1665,13 @@ export async function resolveDispatch(ctx) {
         logWarning("dispatch", `registry dispatch failed, falling back to inline rules: ${err instanceof Error ? err.message : String(err)}`);
     }
     for (const rule of DISPATCH_RULES) {
-        const result = await rule.match(ctx);
+        const result = await rule.match(dispatchCtx);
         if (result) {
             if (result.action !== "skip")
                 result.matchedRule = rule.name;
             const action = annotateBackgroundable(result);
             if (action.action === "dispatch" &&
-                ctx.session?.exhaustedVerificationUnits?.has(`${action.unitType}:${action.unitId}`)) {
+                dispatchCtx.session?.exhaustedVerificationUnits?.has(`${action.unitType}:${action.unitId}`)) {
                 return {
                     action: "stop",
                     reason: `Unit ${action.unitId} exhausted verification retries this session.`,

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -1411,6 +1411,10 @@ export async function postUnitPreVerification(pctx, opts) {
                                 const blockingMismatch = mismatches.find((mismatch) => mismatch.severity === "error");
                                 if (blockingMismatch) {
                                     ctx.ui.notify(`Safety: task ${sTid} claimed passing verification that failed in recorded execution`, "error");
+                                    const gitActionResult = await runCloseoutGitAction(pctx, s.currentUnit);
+                                    if (gitActionResult === "dispatched") {
+                                        return "dispatched";
+                                    }
                                     await pauseAuto(ctx, pi);
                                     return "dispatched";
                                 }

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

@@ -18,7 +18,7 @@ import { parseRoadmap } from "./parsers-legacy.js";
 import { join, 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";
@@ -76,6 +76,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)";
@@ -2319,6 +2345,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

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

@@ -731,12 +731,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 +812,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 +1090,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();