@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

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/loop.js

@@ -261,7 +261,22 @@ async function enforceMinRequestInterval(s, prefs) {
         await new Promise(r => setTimeout(r, decision.waitMs));
     }
 }
-function closeOutCrashedUnit(s, iterData, err) {
+async function snapshotCrashedUnitWork(ctx, s, deps, iterData) {
+    try {
+        const commitMsg = await deps.autoCommitUnit?.(s.basePath, iterData.unitType, iterData.unitId, ctx);
+        if (commitMsg) {
+            debugLog("autoLoop", {
+                phase: "crash-snapshot-commit",
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
+        }
+    }
+    catch (snapshotErr) {
+        logWarning("dispatch", `unit crash snapshot failed: ${snapshotErr instanceof Error ? snapshotErr.message : String(snapshotErr)}`);
+    }
+}
+async function closeOutCrashedUnit(ctx, s, deps, iterData, err) {
     const summary = formatDispatchExceptionSummary({ error: err });
     try {
         emitOpenUnitEndForUnit(s.basePath, iterData.unitType, iterData.unitId, "cancelled", {
@@ -278,6 +293,7 @@ function closeOutCrashedUnit(s, iterData, err) {
     catch (closeoutErr) {
         logWarning("dispatch", `unit crash closeout failed: ${closeoutErr instanceof Error ? closeoutErr.message : String(closeoutErr)}`);
     }
+    await snapshotCrashedUnitWork(ctx, s, deps, iterData);
 }
 /**
  * Main auto-mode execution loop. Iterates: orchestration.advance → guards →
@@ -400,11 +416,15 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             active: s.active,
             iteration,
             maxIterations: MAX_LOOP_ITERATIONS,
-            hasCommandContext: Boolean(s.cmdCtx),
+            hasCommandContext: typeof s.cmdCtx?.newSession === "function",
             sessionLockValid: true,
         });
         if (commandContextDecision.action === "stop" && commandContextDecision.reason === "missing-command-context") {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
+            if (s.currentUnit) {
+                await deps.autoCommitUnit?.(s.basePath, s.currentUnit.type, s.currentUnit.id, ctx);
+            }
+            await deps.stopAuto(ctx, pi, commandContextDecision.message, { preserveWorktree: true });
             finishTurn("stopped", "manual-attention", commandContextDecision.reason);
             break;
         }
@@ -586,7 +606,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     if (err instanceof ModelPolicyDispatchBlockedError) {
                         throw err;
                     }
-                    closeOutCrashedUnit(s, iterData, err);
+                    await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                     throw err;
                 }
                 if (unitPhaseResult.action === "next") {
@@ -1109,7 +1129,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 if (err instanceof ModelPolicyDispatchBlockedError) {
                     throw err;
                 }
-                closeOutCrashedUnit(s, iterData, err);
+                await closeOutCrashedUnit(ctx, s, deps, iterData, err);
                 dispatchSettled = settleDispatchFailed(dispatchId, formatDispatchExceptionSummary({ error: err }), {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,

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

@@ -58,6 +58,24 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
+    const cmdCtx = s.cmdCtx;
+    if (typeof cmdCtx?.newSession !== "function") {
+        const msg = "command context is missing newSession";
+        debugLog("runUnit", {
+            phase: "session-error",
+            unitType,
+            unitId,
+            error: msg,
+        });
+        return {
+            status: "cancelled",
+            errorContext: {
+                message: `Session creation failed: ${msg}`,
+                category: "session-failed",
+                isTransient: false,
+            },
+        };
+    }
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
@@ -67,7 +85,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession({
+        const sessionPromise = cmdCtx.newSession({
             abortSignal: sessionAbortController.signal,
             workspaceRoot: s.basePath,
         }).finally(() => {

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

@@ -30,6 +30,25 @@ import { isIsolatedWorktreeSession, _resolveCurrentUnitStartedAtForTest, emitCan
 import { MAX_RECOVERY_CHARS } from "./types.js";
 const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE = /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) (?:hit|reached) your (?:\w+ )?limit\b|.*\b(?:usage|session|weekly|daily|monthly|quota) limit\b|limit\b.{0,40}\bresets?\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
 const ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE = /(?:\b(?:http|status(?: code)?|code|error:)\s*(?:429|500|502|503)\b|\b(?:api|provider) error\s*[:(]?\s*(?:429|500|502|503)\b|\b(?:typeerror|error):\s*(?:fetch failed\b|socket hang up\b|terminated(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|(?:network|connection|server) error(?::|$)|stream idle timeout\b|partial response received\b|unexpected eof\b)|\b(?:server_error|api_error|stream_exhausted(?:_without_result)?)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|context (?:window|length) exceed|context window exceed)/i;
+const ZERO_TOOL_PSEUDO_TOOL_CALL_RE = /<arg_key>[\s\S]*?<\/arg_key>\s*<arg_value>[\s\S]*?<\/arg_value>[\s\S]*?<\/tool_call>/i;
+const ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS = 200;
+function zeroToolMessageSnippet(message) {
+    const compact = message.trim().replace(/\s+/g, " ");
+    if (compact.length <= ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS)
+        return compact;
+    return `${compact.slice(0, ZERO_TOOL_PSEUDO_TOOL_CALL_SNIPPET_CHARS - 3)}...`;
+}
+// Provider serialization drift: the model emitted a tool call as plain assistant
+// text (`toolName<arg_key>…</arg_key><arg_value>…</arg_value></tool_call>`)
+// instead of a structured tool call. Returns an operator-visible snippet when
+// detected. Kept separate from error classification so a drift snippet is never
+// conflated with an ErrorClass (which would force a fragile union whose
+// narrowing the root and extensions tsconfigs disagree on).
+function zeroToolPseudoToolCallSnippet(message) {
+    if (!ZERO_TOOL_PSEUDO_TOOL_CALL_RE.test(message))
+        return null;
+    return zeroToolMessageSnippet(message);
+}
 function classifyZeroToolProviderMessage(message) {
     const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
     if (!firstLine ||
@@ -39,6 +58,7 @@ function classifyZeroToolProviderMessage(message) {
     return classifyError(firstLine);
 }
 export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
+export const _zeroToolPseudoToolCallSnippetForTest = zeroToolPseudoToolCallSnippet;
 export function resolveDispatchRecoveryAttempts(unitRecoveryCount, unitType, unitId) {
     return (unitRecoveryCount.get(`${unitType}/${unitId}`) ?? 0) > 0
         ? 0
@@ -572,11 +592,23 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             const lastUnit = [...currentLedger.units].reverse().find((u) => u.type === unitType && u.id === unitId && u.startedAt === _resolveCurrentUnitStartedAtForTest(s.currentUnit));
             if (lastUnit && lastUnit.toolCalls === 0) {
                 const lastAssistantMessage = lastAssistantText(s.lastUnitAgentEndMessages);
-                const providerMessageClass = classifyZeroToolProviderMessage(lastAssistantMessage);
-                if (providerMessageClass && isTransient(providerMessageClass)) {
-                    const retryAfterMs = "retryAfterMs" in providerMessageClass ? providerMessageClass.retryAfterMs : 15_000;
+                const pseudoToolCallSnippet = zeroToolPseudoToolCallSnippet(lastAssistantMessage);
+                if (pseudoToolCallSnippet) {
+                    debugLog("runUnitPhase", {
+                        phase: "zero-tool-serialization-drift",
+                        unitType,
+                        unitId,
+                        snippet: pseudoToolCallSnippet,
+                    });
+                    ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls - provider serialization drift: model emitted pseudo-tool-call text. Snippet: ${pseudoToolCallSnippet}`, "error");
+                    await deps.pauseAuto(ctx, pi);
+                    return { action: "break", reason: "zero-tool-serialization-drift" };
+                }
+                const providerErrorClass = classifyZeroToolProviderMessage(lastAssistantMessage);
+                if (providerErrorClass && isTransient(providerErrorClass)) {
+                    const retryAfterMs = "retryAfterMs" in providerErrorClass ? providerErrorClass.retryAfterMs : 15_000;
                     await pauseAutoForProviderError(ctx.ui, ` for ${unitType} ${unitId}`, () => deps.pauseAuto(ctx, pi), {
-                        isRateLimit: providerMessageClass.kind === "rate-limit",
+                        isRateLimit: providerErrorClass.kind === "rate-limit",
                         isTransient: true,
                         retryAfterMs,
                         resume: () => {
@@ -593,7 +625,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                     });
                     return {
                         action: "break",
-                        reason: providerMessageClass.kind === "rate-limit" ? "rate-limit" : "api-timeout",
+                        reason: providerErrorClass.kind === "rate-limit" ? "rate-limit" : "api-timeout",
                     };
                 }
                 if (USER_DRIVEN_DEEP_UNITS.has(unitType) && isAwaitingUserInput(s.lastUnitAgentEndMessages ?? undefined)) {

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`;
         }