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

package/src/resources/extensions/gsd/auto/unit-phase.ts

@@ -56,6 +56,26 @@ 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: string): string {
+  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: string): string | null {
+  if (!ZERO_TOOL_PSEUDO_TOOL_CALL_RE.test(message)) return null;
+  return zeroToolMessageSnippet(message);
+}
 
 function classifyZeroToolProviderMessage(message: string): ReturnType<typeof classifyError> | null {
   const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
@@ -68,6 +88,7 @@ function classifyZeroToolProviderMessage(message: string): ReturnType<typeof cla
 }
 
 export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
+export const _zeroToolPseudoToolCallSnippetForTest = zeroToolPseudoToolCallSnippet;
 
 export function resolveDispatchRecoveryAttempts(
   unitRecoveryCount: Map<string, number>,
@@ -767,15 +788,30 @@ export async function runUnitPhase(
       );
       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: () => {
@@ -793,7 +829,7 @@ export async function runUnitPhase(
           });
           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/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -15,6 +15,7 @@ import {
   resolveSliceFile,
   relMilestoneFile,
   relSliceFile,
+  buildFlatTaskFileName,
   buildTaskFileName,
   resolveSlicePath,
   resolveTasksDir,
@@ -103,12 +104,15 @@ function resolveProjectMilestonePath(base: string, mid: string): string | null {
   const milestonesDir = join(gsdRoot(base), "milestones");
   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
@@ -232,7 +236,10 @@ export function resolveExpectedArtifactPath(
       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");
@@ -297,9 +304,9 @@ export function diagnoseExpectedArtifact(
       }
       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/src/resources/extensions/gsd/auto-dispatch.ts

@@ -393,7 +393,8 @@ function resolveArtifactBasePath(
 ): string {
   if (
     session?.basePath &&
-    session.currentMilestoneId === mid &&
+    session.currentMilestoneId &&
+    milestoneIdsDispatchCompatible(session.currentMilestoneId, mid) &&
     existsSync(session.basePath)
   ) {
     return session.basePath;
@@ -422,6 +423,28 @@ function normalizeMilestoneScope(value: string | null | undefined): string | nul
   return trimmed;
 }
 
+function dispatchMilestoneIdentity(value: string | null | undefined): { baseId: string; hasSuffix: boolean } | null {
+  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: string, right: string): boolean {
+  const leftId = dispatchMilestoneIdentity(left);
+  const rightId = dispatchMilestoneIdentity(right);
+  return Boolean(
+    leftId &&
+      rightId &&
+      leftId.baseId === rightId.baseId &&
+      leftId.hasSuffix !== rightId.hasSuffix,
+  );
+}
+
+function milestoneIdsDispatchCompatible(left: string, right: string): boolean {
+  return left === right || isBareSuffixedMilestoneAlias(left, right);
+}
+
 function resolveDispatchMilestoneScope(
   ctx: DispatchContext,
 ): { id: string; source: string } | null {
@@ -439,6 +462,37 @@ function resolveDispatchMilestoneScope(
   return null;
 }
 
+function resolveEffectiveDispatchMilestoneId(
+  ctx: DispatchContext,
+  scopedMilestone: { id: string; source: string } | null,
+): string {
+  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: DispatchContext, effectiveMid: string): DispatchContext {
+  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: string, mid: string): boolean {
   if (isDbAvailable()) {
     try {
@@ -732,14 +786,21 @@ export const DISPATCH_RULES: DispatchRule[] = [
     // 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)) return null;
+      // 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)) return null;
+      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
       // deadlock. Deep planning is still user-driven even inside auto-mode,
@@ -1095,10 +1156,13 @@ export const DISPATCH_RULES: DispatchRule[] = [
   },
   {
     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
       if (prefs?.planning_depth === "deep") return null;
@@ -1892,6 +1956,7 @@ function applyLanguageDirectiveToDispatch(
   if (action.action !== "dispatch" || !action.prompt) return action;
   const directive = renderLanguageDirectiveForPrompt(prefs);
   if (!directive) return action;
+  if (action.prompt.startsWith(directive)) return action;
   return { ...action, prompt: `${directive}\n\n${action.prompt}` };
 }
 
@@ -1908,36 +1973,39 @@ function applyLanguageDirectiveToDispatch(
 export async function resolveDispatch(
   ctx: DispatchContext,
 ): Promise<DispatchAction> {
-  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. ` +
+          `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}". ` +
+        `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}". ` +
+        `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",
     };
@@ -1946,10 +2014,10 @@ export async function resolveDispatch(
   // 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",
@@ -1964,13 +2032,13 @@ export async function resolveDispatch(
   }
 
   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",

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -1698,6 +1698,10 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
                     `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";
                 }