@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -8,17 +8,21 @@
 
 import {
   gsdRoot,
-  gsdProjectionRoot,
   resolveDir,
   resolveFile,
+  resolveMilestonePath,
+  resolveMilestoneFile,
+  resolveSliceFile,
   relMilestoneFile,
   relSliceFile,
-  buildMilestoneFileName,
-  buildSliceFileName,
   buildTaskFileName,
+  resolveSlicePath,
+  resolveTasksDir,
+  dirIsMetaOnlyLegacyMilestone,
 } from "./paths.js";
+import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 function resolveMilestoneArtifactPath(
   base: string,
@@ -27,8 +31,54 @@ function resolveMilestoneArtifactPath(
 ): string | null {
   const existing = resolveProjectedMilestoneFile(base, mid, suffix) ?? resolveProjectMilestoneFile(base, mid, suffix);
   if (existing) return existing;
-  const dir = resolveProjectedMilestonePath(base, mid) ?? resolveProjectMilestonePath(base, mid);
-  return dir ? join(dir, buildMilestoneFileName(mid, suffix)) : null;
+  // Try projected (worktree) path, then project-root path. Both can return
+  // either a legacy (milestones/<MID>/) or flat-phase (phases/NN-slug/) dir.
+  const dir = resolveProjectedMilestonePath(base, mid) ?? resolveProjectMilestonePath(base, mid) ?? resolveMilestonePath(base, mid);
+  if (dir) {
+    // The filename depends on the LAYOUT of the resolved directory, not on
+    // which resolver found it. A flat-phase dir (phases/NN-slug/) uses the
+    // phase-number prefix (15-CONTEXT.md); a legacy dir (milestones/<MID>/)
+    // uses the milestone-id prefix (M015-CONTEXT.md). Building the wrong
+    // filename for the resolved dir produces existsSync-false paths that trap
+    // the unit in a finalize-retry loop (#852).
+    //
+    // Layout is determined structurally from the resolved directory's parent
+    // segment name, NOT by comparing against a root-anchored legacyMilestonesDir
+    // base path. On a canonical worktree (<project>/.gsd-worktrees/M001/),
+    // legacyMilestonesDir uses gsdProjectionRoot (the worktree .gsd) while
+    // resolveProjectMilestonePath uses gsdRoot (the project .gsd) — two
+    // different roots. A dir returned by resolveProjectMilestonePath would
+    // fail the startsWith check against the worktree root and incorrectly
+    // produce a flat-phase filename for a legacy directory (#bugbot c5ee8eba).
+    const parentDir = dirname(dir);
+    const isLegacy = parentDir.endsWith("/milestones") || parentDir.endsWith("\\milestones");
+    const phaseNum = milestoneIdToPhaseNum(mid);
+    const filename = isLegacy
+      ? `${mid}-${suffix}.md`
+      : `${String(phaseNum).padStart(2, "0")}-${suffix}.md`;
+    return join(dir, filename);
+  }
+  return null;
+}
+
+/**
+ * Build the layout-aware filename for a milestone artifact suffix.
+ * Exported so other callers (e.g. verification diagnostics) use the same
+ * naming policy: flat-phase dirs use the phase-number prefix (15-CONTEXT.md),
+ * legacy dirs use the milestone-id prefix (M015-CONTEXT.md).
+ *
+ * Layout is determined structurally: dirs whose immediate parent is named
+ * "milestones" are legacy; all others are flat-phase. This avoids the
+ * root-path ambiguity between gsdProjectionRoot (worktree .gsd) and gsdRoot
+ * (project .gsd) that caused wrong filenames on canonical worktrees.
+ */
+export function buildMilestoneArtifactFilename(mid: string, suffix: string, dir: string): string {
+  const parentDir = dirname(dir);
+  const isLegacy = parentDir.endsWith("/milestones") || parentDir.endsWith("\\milestones");
+  const phaseNum = milestoneIdToPhaseNum(mid);
+  return isLegacy
+    ? `${mid}-${suffix}.md`
+    : `${String(phaseNum).padStart(2, "0")}-${suffix}.md`;
 }
 
 function resolveSliceArtifactPath(
@@ -39,14 +89,30 @@ function resolveSliceArtifactPath(
 ): string | null {
   const existing = resolveProjectedSliceFile(base, mid, sid, suffix) ?? resolveProjectSliceFile(base, mid, sid, suffix);
   if (existing) return existing;
-  const dir = resolveProjectedSlicePath(base, mid, sid) ?? resolveProjectSlicePath(base, mid, sid);
-  return dir ? join(dir, buildSliceFileName(sid, suffix)) : null;
+  // Flat-phase: plan files live at phases/NN-slug/NN-MM-SUFFIX.md — resolveSliceFile handles both layouts.
+  const flatPhase = resolveSliceFile(base, mid, sid, suffix);
+  if (flatPhase) return flatPhase;
+  // File doesn't exist yet — use relSliceFile for the layout-aware canonical path.
+  // buildSliceFileName(sid) only has sliceId → MM-SUFFIX.md, wrong for both layouts.
+  return join(base, relSliceFile(base, mid, sid, suffix));
 }
 
 function resolveProjectMilestonePath(base: string, mid: string): string | null {
   const milestonesDir = join(gsdRoot(base), "milestones");
   const dir = resolveDir(milestonesDir, mid);
-  return dir ? join(milestonesDir, dir) : null;
+  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).
+  //
+  // We use dirIsMetaOnlyLegacyMilestone rather than !dirIsContentBearingLegacyMilestone
+  // so that an EMPTY dir (a new milestone before any content is written) is NOT
+  // blocked — it is a valid legacy target that write-paths should resolve to.
+  if (dirIsMetaOnlyLegacyMilestone(join(milestonesDir, dir))) return null;
+  return join(milestonesDir, dir);
 }
 
 function resolveProjectMilestoneFile(base: string, mid: string, suffix: string): string | null {
@@ -72,16 +138,11 @@ function resolveProjectSliceFile(base: string, mid: string, sid: string, suffix:
 }
 
 function resolveProjectedMilestonePath(base: string, mid: string): string | null {
-  const milestonesDir = join(gsdProjectionRoot(base), "milestones");
-  const dir = resolveDir(milestonesDir, mid);
-  return dir ? join(milestonesDir, dir) : null;
+  return resolveMilestonePath(base, mid);
 }
 
 function resolveProjectedMilestoneFile(base: string, mid: string, suffix: string): string | null {
-  const dir = resolveProjectedMilestonePath(base, mid);
-  if (!dir) return null;
-  const file = resolveFile(dir, mid, suffix);
-  return file ? join(dir, file) : null;
+  return resolveMilestoneFile(base, mid, suffix);
 }
 
 function resolveProjectedSlicePath(base: string, mid: string, sid: string): string | null {
@@ -155,10 +216,12 @@ export function resolveExpectedArtifactPath(
       return resolveSliceArtifactPath(base, mid, sid!, "ASSESSMENT");
     }
     case "execute-task": {
-      const dir = resolveProjectedSlicePath(base, mid, sid!) ?? resolveProjectSlicePath(base, mid, sid!);
-      return dir && tid
-        ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY"))
-        : null;
+      const slicePath = resolveProjectedSlicePath(base, mid, sid!)
+        ?? resolveProjectSlicePath(base, mid, sid!)
+        ?? resolveSlicePath(base, mid, sid!);
+      if (!slicePath || !tid) return null;
+      const tasksDir = resolveTasksDir(base, mid, sid!) ?? slicePath;
+      return join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
     }
     case "complete-slice": {
       return resolveSliceArtifactPath(base, mid, sid!, "SUMMARY");

package/src/resources/extensions/gsd/auto-closeout-messaging.ts

@@ -0,0 +1,90 @@
+// Project/App: gsd-pi
+// File Purpose: Rewrite premature unit "complete" chat lines before GSD post-unit verification.
+
+/**
+ * Auto-mode owns the authoritative "unit complete" signal (finalize/stopAuto).
+ * Agents may still emit legacy closeout lines after completion tools succeed;
+ * rewrite those for transcript clarity until post-unit verification passes.
+ */
+
+const CLOSEOUT_LINE_REWRITES: Array<{ pattern: RegExp; replacement: string }> = [
+  {
+    pattern: /^Milestone\s+(M\d+[A-Z0-9-]*)\s+complete\.?$/i,
+    replacement: "Milestone $1 closeout submitted.",
+  },
+  {
+    pattern: /^Milestone\s+(M\d+[A-Z0-9-]*)\s+is\s+already\s+complete\.?$/i,
+    replacement: "Milestone $1 closeout already recorded.",
+  },
+  {
+    pattern: /^Slice\s+(S\d+[A-Z0-9-]*)\s+complete\.?$/i,
+    replacement: "Slice $1 closeout submitted.",
+  },
+  {
+    pattern: /^Task\s+(T\d+[A-Z0-9-]*)\s+complete\.?$/i,
+    replacement: "Task $1 closeout submitted.",
+  },
+  {
+    pattern: /^UAT\s+(S\d+[A-Z0-9-]*)\s+complete\.?$/i,
+    replacement: "UAT $1 results submitted.",
+  },
+  {
+    pattern: /^Quick\s+task\s+(\d+)\s+complete\.?$/i,
+    replacement: "Quick task $1 closeout submitted.",
+  },
+  {
+    pattern: /^Triage\s+complete\.?$/i,
+    replacement: "Triage closeout submitted.",
+  },
+];
+
+export function rewritePrematureCloseoutLine(line: string): string {
+  const trimmed = line.trim();
+  if (!trimmed) return line;
+  for (const { pattern, replacement } of CLOSEOUT_LINE_REWRITES) {
+    if (pattern.test(trimmed)) {
+      return trimmed.replace(pattern, replacement);
+    }
+  }
+  return line;
+}
+
+export function rewritePrematureCloseoutText(text: string): string {
+  if (!text) return text;
+  const lines = text.split("\n");
+  let changed = false;
+  const rewritten = lines.map((line) => {
+    const next = rewritePrematureCloseoutLine(line);
+    if (next !== line) changed = true;
+    return next;
+  });
+  return changed ? rewritten.join("\n") : text;
+}
+
+function rewriteAssistantMessageContent(content: unknown): boolean {
+  if (typeof content === "string") {
+    const rewritten = rewritePrematureCloseoutText(content);
+    return rewritten !== content;
+  }
+  if (!Array.isArray(content)) return false;
+
+  let changed = false;
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const part = block as { type?: unknown; text?: unknown };
+    if (part.type !== "text" || typeof part.text !== "string") continue;
+    const rewritten = rewritePrematureCloseoutText(part.text);
+    if (rewritten !== part.text) {
+      part.text = rewritten;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+/** Rewrite assistant closeout lines on message_end during auto-mode. */
+export function sanitizePrematureCloseoutMessageEnd(event: { message?: unknown } | null | undefined): void {
+  const message = event?.message as { role?: unknown; content?: unknown } | undefined;
+  if (!message || message.role !== "assistant") return;
+  rewriteAssistantMessageContent(message.content);
+}