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

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/artifact-verification.js

@@ -9,7 +9,7 @@ import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relSliceFile, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relSliceFile, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { existsSync, readFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { LAYOUT_SEGMENTS } from "./layout-policy.js";
@@ -185,10 +185,9 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         const batchIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
         if (batchIds.length === 0)
             return false;
-        const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
-        const existingSummaries = new Set(resolveTaskFiles(tDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()));
         for (const tid of batchIds) {
-            if (!existingSummaries.has(tid.toUpperCase()))
+            const summaryPath = resolveTaskFile(base, mid, sid, tid, "SUMMARY");
+            if (!summaryPath || !existsSync(summaryPath))
                 return false;
         }
         return true;

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

@@ -5,7 +5,7 @@
 // resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
-import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, normalizeRealPath, } from "./paths.js";
+import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildFlatTaskFileName, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, normalizeRealPath, } from "./paths.js";
 import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
 import { basename, dirname, join, relative } from "node:path";
@@ -79,12 +79,15 @@ function resolveProjectMilestonePath(base, mid) {
     const dir = resolveDir(milestonesDir, mid);
     if (!dir)
         return null;
-    // git-service.ts creates milestones/<MID>/ for integration-branch metadata
-    // (<MID>-META.json) even in flat-phase projects. A dir that holds ONLY
-    // *-META.json files must not be treated as a real legacy milestone dir —
-    // otherwise this early-return resolves CONTEXT/ROADMAP/SUMMARY to the legacy
-    // path (milestones/<MID>/<MID>-<SUFFIX>.md) before the flat-phase fallback
-    // can run, trapping the unit in a finalize-retry loop (#852 follow-up).
+    // Historically git-service.ts wrote integration-branch metadata into
+    // milestones/<MID>/<MID>-META.json, which could create that dir in flat-phase
+    // projects and poison layout detection. As of ADR-045 that META lives flat at
+    // .gsd/<MID>-META.json and no longer poisons detection. A dir that holds ONLY
+    // *-META.json files (a pre-migration on-disk tree) must still not be treated
+    // as a real legacy milestone dir — otherwise this early-return resolves
+    // CONTEXT/ROADMAP/SUMMARY to the legacy path (milestones/<MID>/<MID>-<SUFFIX>.md)
+    // before the flat-phase fallback can run, trapping the unit in a
+    // finalize-retry loop (#852 follow-up).
     //
     // We use dirIsMetaOnlyLegacyMilestone rather than !dirIsContentBearingLegacyMilestone
     // so that an EMPTY dir (a new milestone before any content is written) is NOT
@@ -203,7 +206,10 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             const summaryDir = isLegacySlice
                 ? (resolveTasksDir(base, mid, sid) ?? slicePath)
                 : slicePath;
-            return join(summaryDir, buildTaskFileName(tid, "SUMMARY"));
+            const fileName = isLegacySlice
+                ? buildTaskFileName(tid, "SUMMARY")
+                : buildFlatTaskFileName(sid, tid, "SUMMARY");
+            return join(summaryDir, fileName);
         }
         case "complete-slice": {
             return resolveSliceArtifactPath(base, mid, sid, "SUMMARY");
@@ -263,9 +269,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";
                                 }