gsd-pi 2.78.0 → 2.78.1-dev.2ff77b0ce

package/src/resources/extensions/gsd/init-wizard.ts

@@ -10,7 +10,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { showNextAction } from "../shared/tui.js";
-import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeDetectMainBranch } from "./native-git-bridge.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -26,6 +26,8 @@ interface InitWizardResult {
   completed: boolean;
   /** Whether .gsd/ was created */
   bootstrapped: boolean;
+  /** Whether git is available or was initialized during setup. */
+  gitEnabled?: boolean;
 }
 
 interface ProjectPreferences {
@@ -75,6 +77,7 @@ export async function showProjectInit(
 
   // ── Step 2: Git setup ──────────────────────────────────────────────────────
   let didInitGit = false;
+  let gitEnabled = signals.isGitRepo;
   if (!signals.isGitRepo) {
     const gitChoice = await showNextAction(ctx, {
       title: "GSD — Project Setup",
@@ -91,6 +94,7 @@ export async function showProjectInit(
     if (gitChoice === "init_git") {
       nativeInit(basePath, prefs.mainBranch);
       didInitGit = true;
+      gitEnabled = true;
     }
   } else {
     // Auto-detect main branch from existing repo
@@ -293,9 +297,12 @@ export async function showProjectInit(
     // Non-fatal — DB creation failure should not block project init
   }
 
-  // Ensure .gitignore
-  ensureGitignore(basePath);
-  untrackRuntimeFiles(basePath);
+  // Ensure .gitignore only when git is active. A user who selected "Skip"
+  // should not have git initialized or git-related files mutated later.
+  if (gitEnabled) {
+    ensureGitignore(basePath);
+    untrackRuntimeFiles(basePath);
+  }
 
   // Create initial commit so git log and git worktree work immediately (#4530).
   // Without this, the branch is "unborn" (zero commits) and downstream operations
@@ -341,7 +348,7 @@ export async function showProjectInit(
 
   ctx.ui.notify("GSD initialized. Starting your first milestone...", "info");
 
-  return { completed: true, bootstrapped: true };
+  return { completed: true, bootstrapped: true, gitEnabled };
 }
 
 // ─── V1 Migration Offer ─────────────────────────────────────────────────────────
@@ -662,22 +669,12 @@ function buildDetectionSummary(signals: ProjectSignals): string[] {
   return lines;
 }
 
-function detectMainBranch(basePath: string): string | null {
+export function detectMainBranch(basePath: string): string | null {
   try {
-    // Check HEAD reference for common branch names
-    const headPath = join(basePath, ".git", "HEAD");
-    if (existsSync(headPath)) {
-      const head = readFileSync(headPath, "utf-8").trim();
-      const match = head.match(/^ref: refs\/heads\/(.+)$/);
-      if (match) return match[1];
-    }
-
-    // Check for common remote branches
-    const refsPath = join(basePath, ".git", "refs", "remotes", "origin");
-    if (existsSync(refsPath)) {
-      if (existsSync(join(refsPath, "main"))) return "main";
-      if (existsSync(join(refsPath, "master"))) return "master";
-    }
+    // Match runtime branch resolution: origin/HEAD -> main -> master -> current.
+    // Reading .git/HEAD first records whichever feature branch happened to be
+    // checked out during init and can redirect future milestone merges.
+    return nativeDetectMainBranch(basePath);
   } catch {
     // Fall through to null
   }

package/src/resources/extensions/gsd/interrupted-session.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 
 import { verifyExpectedArtifact } from "./auto-recovery.js";
@@ -9,6 +9,7 @@ import {
   type LockData,
 } from "./crash-recovery.js";
 import { gsdRoot } from "./paths.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import {
   synthesizeCrashRecovery,
   type RecoveryBriefing,
@@ -50,6 +51,37 @@ export interface InterruptedSessionAssessment {
   isBootstrapCrash: boolean;
 }
 
+const LEGACY_DEEP_SETUP_UNITS = new Set([
+  "workflow-preferences:WORKFLOW-PREFS",
+  "discuss-project:PROJECT",
+  "discuss-requirements:REQUIREMENTS",
+  "research-decision:RESEARCH-DECISION",
+  "research-project:RESEARCH-PROJECT",
+]);
+
+function isStalePseudoMilestonePause(meta: PausedSessionMetadata): boolean {
+  if (meta.activeEngineId && meta.activeEngineId !== "dev") return false;
+  if (
+    meta.unitType === "discuss-milestone"
+    && typeof meta.unitId === "string"
+    && !MILESTONE_ID_RE.test(meta.unitId)
+  ) {
+    return true;
+  }
+  if (
+    typeof meta.unitType === "string"
+    && typeof meta.unitId === "string"
+    && LEGACY_DEEP_SETUP_UNITS.has(`${meta.unitType}:${meta.unitId}`)
+  ) {
+    return true;
+  }
+  return typeof meta.milestoneId === "string"
+    && !MILESTONE_ID_RE.test(meta.milestoneId)
+    && typeof meta.unitType === "string"
+    && typeof meta.unitId === "string"
+    && LEGACY_DEEP_SETUP_UNITS.has(`${meta.unitType}:${meta.unitId}`);
+}
+
 export function readPausedSessionMetadata(
   basePath: string,
 ): PausedSessionMetadata | null {
@@ -57,7 +89,12 @@ export function readPausedSessionMetadata(
   if (!existsSync(pausedPath)) return null;
 
   try {
-    return JSON.parse(readFileSync(pausedPath, "utf-8")) as PausedSessionMetadata;
+    const meta = JSON.parse(readFileSync(pausedPath, "utf-8")) as PausedSessionMetadata;
+    if (isStalePseudoMilestonePause(meta)) {
+      try { unlinkSync(pausedPath); } catch { /* non-fatal */ }
+      return null;
+    }
+    return meta;
   } catch {
     return null;
   }

package/src/resources/extensions/gsd/journal.ts

@@ -60,7 +60,10 @@ export type JournalEventType =
   | "canonical-root-redirect"
   // #4765 — slice-cadence collapse
   | "slice-merged"
-  | "milestone-resquash";
+  | "milestone-resquash"
+  // dispatch telemetry — measure agent/subagent invocation frequency and shape
+  | "subagent-invoked"
+  | "subagent-completed";
 
 /** A single structured event in the journal. */
 export interface JournalEntry {

package/src/resources/extensions/gsd/key-manager.ts

@@ -17,6 +17,7 @@ import { existsSync, statSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { mkdirSync } from "node:fs";
 import { getErrorMessage } from "./error-utils.js";
+import { gsdHome } from "./gsd-home.js";
 
 // ─── Provider Registry ─────────────────────────────────────────────────────────
 
@@ -122,7 +123,7 @@ export function describeCredential(cred: AuthCredential): string {
  * Get the auth.json path.
  */
 export function getAuthPath(): string {
-  return join(process.env.HOME ?? "~", ".gsd", "agent", "auth.json");
+  return join(gsdHome(), "agent", "auth.json");
 }
 
 /**

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -1,9 +1,8 @@
 // GSD Markdown Renderer — DB → Markdown file generation
 //
 // Transforms DB state into correct markdown files on disk.
-// Each render function reads from DB (with disk fallback),
-// patches content to match DB status, writes atomically to disk,
-// stores updated content in the artifacts table, and invalidates caches.
+// Each render function reads from DB, writes a markdown projection to disk,
+// stores generated content in the artifacts table, and invalidates caches.
 //
 // Critical invariant: rendered markdown must round-trip through
 // parseRoadmap(), parsePlan(), parseSummary() in files.ts.
@@ -61,59 +60,43 @@ function invalidateCaches(): void {
   clearParseCache();
 }
 
+function meaningfulSection(value: string | null | undefined): string {
+  const trimmed = (value ?? "").trim();
+  if (!trimmed) return "";
+  if (/^(not provided\.?|none\.?|n\/a)$/i.test(trimmed)) return "";
+  if (/^\{\{[^}]+\}\}$/.test(trimmed)) return "";
+  return trimmed;
+}
+
+function pushIndented(lines: string[], value: string, indent = "  "): void {
+  for (const line of value.split("\n")) {
+    lines.push(`${indent}${line}`);
+  }
+}
+
+function taskSummaryForSlicePlan(description: string): string {
+  const meaningful = meaningfulSection(description);
+  if (!meaningful) return "";
+
+  const beforeHeading = meaningful.split(/\n#{1,6}\s+/)[0]?.trim() ?? "";
+  const firstBlock = beforeHeading.split(/\n\s*\n/)[0]?.trim() ?? "";
+  return firstBlock || beforeHeading;
+}
+
 /**
- * Load artifact content from DB first, falling back to reading from disk.
- * On disk fallback, stores the content in the artifacts table for future use.
- * Returns null if content is unavailable from both sources.
+ * Load artifact content from the DB. Markdown projections are not authoritative
+ * during runtime; when the artifact row is missing, callers regenerate from DB
+ * rows instead of patching disk fallback content and storing it back.
  */
 function loadArtifactContent(
   artifactPath: string,
-  absPath: string | null,
-  opts: {
-    artifact_type: string;
-    milestone_id: string;
-    slice_id?: string;
-    task_id?: string;
-  },
 ): string | null {
-  // Try DB first
   const artifact = getArtifact(artifactPath);
   if (artifact && artifact.full_content) {
     return artifact.full_content;
   }
 
-  // Fall back to disk
-  if (!absPath) {
-    process.stderr.write(
-      `markdown-renderer: artifact not found in DB or on disk: ${artifactPath}\n`,
-    );
-    return null;
-  }
-
-  let content: string;
-  try {
-    content = readFileSync(absPath, "utf-8");
-  } catch {
-    logWarning("renderer", `cannot read file from disk: ${absPath}`);
-    return null;
-  }
-
-  // Store in DB for future use (graceful degradation path)
-  try {
-    insertArtifact({
-      path: artifactPath,
-      artifact_type: opts.artifact_type,
-      milestone_id: opts.milestone_id,
-      slice_id: opts.slice_id ?? null,
-      task_id: opts.task_id ?? null,
-      full_content: content,
-    });
-  } catch {
-    // Non-fatal: we have the content, DB storage is best-effort
-    logWarning("renderer", `failed to store disk fallback in DB: ${artifactPath}`);
-  }
-
-  return content;
+  return null;
 }
 
 /**
@@ -187,7 +170,9 @@ function renderRoadmapMarkdown(milestone: MilestoneRow, slices: SliceRow[]): str
 }
 
 function renderTaskPlanMarkdown(task: TaskRow, taskGates: GateRow[] = []): string {
-  const estimatedSteps = Math.max(1, task.description.trim().split(/\n+/).filter(Boolean).length || 1);
+  const description = meaningfulSection(task.description);
+  const observabilityImpact = meaningfulSection(task.observability_impact);
+  const estimatedSteps = Math.max(1, description.split(/\n+/).filter(Boolean).length || 1);
   const estimatedFiles = task.files.length > 0
     ? task.files.length
     : task.expected_output.length > 0
@@ -206,8 +191,8 @@ function renderTaskPlanMarkdown(task: TaskRow, taskGates: GateRow[] = []): strin
   lines.push(`# ${task.id}: ${task.title || task.id}`);
   lines.push("");
 
-  if (task.description.trim()) {
-    lines.push(task.description.trim());
+  if (description) {
+    lines.push(description);
     lines.push("");
   }
 
@@ -242,10 +227,10 @@ function renderTaskPlanMarkdown(task: TaskRow, taskGates: GateRow[] = []): strin
   lines.push(task.verify.trim() || "- Verify the task outcome with the slice-level checks.");
   lines.push("");
 
-  if (task.observability_impact.trim()) {
+  if (observabilityImpact) {
     lines.push("## Observability Impact");
     lines.push("");
-    lines.push(task.observability_impact.trim());
+    lines.push(observabilityImpact);
     lines.push("");
   }
 
@@ -275,8 +260,9 @@ function renderSlicePlanMarkdown(slice: SliceRow, tasks: TaskRow[], gates: GateR
 
   lines.push("## Must-Haves");
   lines.push("");
-  if (slice.success_criteria.trim()) {
-    for (const line of slice.success_criteria.split(/\n+/).map((entry) => entry.trim()).filter(Boolean)) {
+  const successCriteria = meaningfulSection(slice.success_criteria);
+  if (successCriteria) {
+    for (const line of successCriteria.split(/\n+/).map((entry) => entry.trim()).filter(Boolean)) {
       lines.push(line.startsWith("-") ? line : `- ${line}`);
     }
   } else {
@@ -301,24 +287,27 @@ function renderSlicePlanMarkdown(slice: SliceRow, tasks: TaskRow[], gates: GateR
     lines.push("");
   }
 
-  if (slice.proof_level.trim()) {
+  const proofLevel = meaningfulSection(slice.proof_level);
+  if (proofLevel) {
     lines.push("## Proof Level");
     lines.push("");
-    lines.push(`- This slice proves: ${slice.proof_level.trim()}`);
+    lines.push(`- This slice proves: ${proofLevel}`);
     lines.push("");
   }
 
-  if (slice.integration_closure.trim()) {
+  const integrationClosure = meaningfulSection(slice.integration_closure);
+  if (integrationClosure) {
     lines.push("## Integration Closure");
     lines.push("");
-    lines.push(slice.integration_closure.trim());
+    lines.push(integrationClosure);
     lines.push("");
   }
 
   lines.push("## Verification");
   lines.push("");
-  if (slice.observability_impact.trim()) {
-    const verificationLines = slice.observability_impact
+  const verification = meaningfulSection(slice.observability_impact);
+  if (verification) {
+    const verificationLines = verification
       .split(/\n+/)
       .map((entry) => entry.trim())
       .filter(Boolean);
@@ -336,8 +325,9 @@ function renderSlicePlanMarkdown(slice: SliceRow, tasks: TaskRow[], gates: GateR
     const done = isClosedStatus(task.status) ? "x" : " ";
     const estimate = task.estimate.trim() ? ` \`est:${task.estimate.trim()}\`` : "";
     lines.push(`- [${done}] **${task.id}: ${task.title || task.id}**${estimate}`);
-    if (task.description.trim()) {
-      lines.push(`  ${task.description.trim()}`);
+    const summary = taskSummaryForSlicePlan(task.description);
+    if (summary) {
+      pushIndented(lines, summary);
     }
     if (task.files.length > 0) {
       lines.push(`  - Files: ${task.files.map((file) => `\`${file}\``).join(", ")}`);
@@ -477,20 +467,15 @@ export async function renderRoadmapCheckboxes(
   const absPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
   const artifactPath = absPath ? toArtifactPath(absPath, basePath) : null;
 
-  // Load content from DB (with disk fallback)
+  // Load content from DB; regenerate from DB rows when the artifact is absent.
   let content: string | null = null;
   if (artifactPath) {
-    content = loadArtifactContent(artifactPath, absPath, {
-      artifact_type: "ROADMAP",
-      milestone_id: milestoneId,
-    });
+    content = loadArtifactContent(artifactPath);
   }
 
   if (!content) {
-    process.stderr.write(
-      `markdown-renderer: no roadmap content available for ${milestoneId}\n`,
-    );
-    return false;
+    await renderRoadmapFromDb(basePath, milestoneId);
+    return true;
   }
 
   // Apply checkbox patches for each slice
@@ -552,18 +537,12 @@ export async function renderPlanCheckboxes(
 
   let content: string | null = null;
   if (artifactPath) {
-    content = loadArtifactContent(artifactPath, absPath, {
-      artifact_type: "PLAN",
-      milestone_id: milestoneId,
-      slice_id: sliceId,
-    });
+    content = loadArtifactContent(artifactPath);
   }
 
   if (!content) {
-    process.stderr.write(
-      `markdown-renderer: no plan content available for ${milestoneId}/${sliceId}\n`,
-    );
-    return false;
+    await renderPlanFromDb(basePath, milestoneId, sliceId);
+    return true;
   }
 
   // Apply checkbox patches for each task

package/src/resources/extensions/gsd/memory-store.ts

@@ -7,6 +7,7 @@ import {
   isDbAvailable,
   _getAdapter,
   transaction,
+  isInTransaction,
   insertMemoryRow,
   rewriteMemoryId,
   updateMemoryContentRow,
@@ -19,6 +20,7 @@ import {
   deleteMemoryRelationsFor,
 } from './gsd-db.js';
 import { createMemoryRelation, isValidRelation } from './memory-relations.js';
+import { logWarning } from './workflow-logger.js';
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -487,7 +489,13 @@ export function nextMemoryId(): string {
  * Insert a new memory with a race-safe auto-assigned ID.
  * Uses AUTOINCREMENT seq to derive the ID after insert, avoiding
  * the read-then-write race in concurrent scenarios (e.g. worktrees).
- * Returns the assigned ID, or null on failure.
+ * Returns the assigned ID, or null when the DB is unavailable.
+ *
+ * Throws on genuine SQL errors (corruption, missing tables, constraint
+ * violations) so callers can surface the underlying message instead of
+ * collapsing the failure to a generic "create_failed". See issue #4967 —
+ * the previous bare-catch swallowed "database disk image is malformed"
+ * errors, leaving the memory subsystem broken without any signal.
  */
 export function createMemory(fields: {
   category: string;
@@ -504,34 +512,70 @@ export function createMemory(fields: {
   if (!adapter) return null;
 
   try {
-    const now = new Date().toISOString();
-    // Insert with a temporary placeholder ID — seq is auto-assigned
-    const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    insertMemoryRow({
-      id: placeholder,
-      category: fields.category,
-      content: fields.content,
-      confidence: fields.confidence ?? 0.8,
-      sourceUnitType: fields.source_unit_type ?? null,
-      sourceUnitId: fields.source_unit_id ?? null,
-      createdAt: now,
-      updatedAt: now,
-      scope: fields.scope ?? 'project',
-      tags: fields.tags ?? [],
-      structuredFields: fields.structuredFields ?? null,
-    });
-    // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
-    const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
-    if (!row) return placeholder; // fallback — should not happen
-    const seq = row['seq'] as number;
-    const realId = `MEM${String(seq).padStart(3, '0')}`;
-    rewriteMemoryId(placeholder, realId);
-    return realId;
-  } catch {
-    return null;
+    return transaction(() => doCreateMemory(adapter, fields));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+
+    // Targeted recovery: a malformed memory store can sometimes be rebuilt
+    // by VACUUM. Skip when inside a transaction — SQLite refuses VACUUM
+    // there and a secondary throw would mask the real fault.
+    if (message.toLowerCase().includes('malformed') && !isInTransaction()) {
+      try {
+        adapter.prepare('VACUUM').run();
+        const recoveryMessage = 'recovered malformed memory store via VACUUM';
+        process.stderr.write(`memory-store: ${recoveryMessage}\n`);
+        logWarning('memory-store', recoveryMessage);
+        return transaction(() => doCreateMemory(adapter, fields));
+      } catch (retryErr) {
+        const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+        logWarning('memory-store', `VACUUM recovery for memory store failed: ${retryMsg}`);
+        // Surface the *original* malformed error — it's the actionable signal.
+        throw err;
+      }
+    }
+
+    throw err;
   }
 }
 
+function doCreateMemory(
+  adapter: NonNullable<ReturnType<typeof _getAdapter>>,
+  fields: {
+    category: string;
+    content: string;
+    confidence?: number;
+    source_unit_type?: string;
+    source_unit_id?: string;
+    scope?: string;
+    tags?: string[];
+    structuredFields?: Record<string, unknown> | null;
+  },
+): string {
+  const now = new Date().toISOString();
+  // Insert with a temporary placeholder ID — seq is auto-assigned
+  const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  insertMemoryRow({
+    id: placeholder,
+    category: fields.category,
+    content: fields.content,
+    confidence: fields.confidence ?? 0.8,
+    sourceUnitType: fields.source_unit_type ?? null,
+    sourceUnitId: fields.source_unit_id ?? null,
+    createdAt: now,
+    updatedAt: now,
+    scope: fields.scope ?? 'project',
+    tags: fields.tags ?? [],
+    structuredFields: fields.structuredFields ?? null,
+  });
+  // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
+  const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
+  if (!row) return placeholder; // fallback — should not happen
+  const seq = row['seq'] as number;
+  const realId = `MEM${String(seq).padStart(3, '0')}`;
+  rewriteMemoryId(placeholder, realId);
+  return realId;
+}
+
 /**
  * Update a memory's content and optionally its confidence.
  */
@@ -728,8 +772,17 @@ export function applyMemoryActions(
       }
       enforceMemoryCap();
     });
-  } catch {
-    // non-fatal — transaction will have rolled back
+  } catch (err) {
+    // Non-fatal — the transaction has rolled back. We log a warning so a
+    // degraded memory subsystem (e.g. malformed store, missing tables) is
+    // visible to forensics instead of silently dropping every CREATE — see
+    // issue #4967, where this swallow combined with createMemory's bare
+    // catch hid SQLite corruption from the auto-mode flow entirely.
+    const message = err instanceof Error ? err.message : String(err);
+    logWarning(
+      'memory-store',
+      `applyMemoryActions failed (memory subsystem degraded): ${message}`,
+    );
   }
 }
 

package/src/resources/extensions/gsd/migrate/command.ts

@@ -24,6 +24,7 @@ import {
 } from "./index.js";
 
 import type { MigrationPreview } from "./writer.js";
+import { homedir } from "node:os";
 
 /** Format preview stats for embedding in the review prompt. */
 function formatPreviewStats(preview: MigrationPreview): string {
@@ -85,9 +86,9 @@ export async function handleMigrate(
   // Default to cwd when no args given; expand ~ to HOME
   let rawPath = args.trim() || ".";
   if (rawPath.startsWith("~/")) {
-    rawPath = join(process.env.HOME ?? "~", rawPath.slice(2));
+    rawPath = join(homedir(), rawPath.slice(2));
   } else if (rawPath === "~") {
-    rawPath = process.env.HOME ?? "~";
+    rawPath = homedir();
   }
 
   let sourcePath = resolve(process.cwd(), rawPath);

package/src/resources/extensions/gsd/milestone-id-reservation.ts

@@ -0,0 +1,47 @@
+import { isDbAvailable, getAllMilestones } from "./gsd-db.js";
+import {
+  getReservedMilestoneIds,
+  milestoneIdSort,
+  nextMilestoneId,
+  reserveMilestoneId,
+} from "./milestone-ids.js";
+import { isReusableGhostMilestone } from "./state.js";
+
+function getDatabaseMilestoneIds(): string[] {
+  if (!isDbAvailable()) return [];
+  return getAllMilestones().map((milestone) => milestone.id);
+}
+
+/**
+ * Generate the next milestone ID, accounting for DB rows and in-process
+ * reservations, and reserve it.
+ */
+export function nextMilestoneIdReserved(
+  existingIds: string[],
+  uniqueEnabled: boolean,
+  basePath?: string,
+): string {
+  const reservedIds = getReservedMilestoneIds();
+  const allIds = [
+    ...new Set([
+      ...existingIds,
+      ...reservedIds,
+      ...getDatabaseMilestoneIds(),
+    ]),
+  ];
+
+  if (basePath) {
+    const sorted = [...allIds].sort(milestoneIdSort);
+    for (const candidate of sorted) {
+      if (reservedIds.has(candidate)) continue;
+      if (isReusableGhostMilestone(basePath, candidate)) {
+        reserveMilestoneId(candidate);
+        return candidate;
+      }
+    }
+  }
+
+  const id = nextMilestoneId(allIds, uniqueEnabled);
+  reserveMilestoneId(id);
+  return id;
+}

package/src/resources/extensions/gsd/milestone-scope-classifier.ts

@@ -164,13 +164,19 @@ function mentionsWithoutNegation(text: string, term: string): boolean {
     const start = m.index ?? 0;
     const windowStart = Math.max(0, start - 30);
     const window = lower.slice(windowStart, start);
-    // Negator anywhere in the 30-char lookback window counts as negation —
-    // covers "no backend", "without a server", "not using api", "zero
-    // dependencies on an api". If a sentence break intervenes between the
-    // negator and the term, treat as a different clause (positive mention).
-    const hasNegator = /(^|[^a-z0-9])(no|without|not|zero|skip(s|ping)?|drops?)\b/i.test(window);
-    const hasSentenceBreak = /[.;!?]/.test(window);
-    if (hasNegator && !hasSentenceBreak) continue;
+    // Negator anywhere in the same clause counts as negation — covers "no
+    // backend", "without a server", "not using api", "zero dependencies on
+    // an api". Only inspect text after the most recent sentence break so
+    // "No backend. Add API" still treats API as a positive mention.
+    const lastBreak = Math.max(
+      window.lastIndexOf("."),
+      window.lastIndexOf(";"),
+      window.lastIndexOf("!"),
+      window.lastIndexOf("?"),
+    );
+    const clauseWindow = window.slice(lastBreak + 1);
+    const hasNegator = /(^|[^a-z0-9])(no|without|not|zero|skip(s|ping)?|drops?)\b/i.test(clauseWindow);
+    if (hasNegator) continue;
     return true;
   }
   return false;
@@ -279,7 +285,8 @@ export function classifyMilestoneScope(input: MilestoneScopeInput): ScopeClassif
     input.verificationUat ?? "",
   ].join("\n");
 
-  const overrideHits = containsAnyKeyword(haystack, OVERRIDE_KEYWORDS);
+  const overrideHits = containsAnyKeyword(haystack, OVERRIDE_KEYWORDS)
+    .filter((kw) => mentionsWithoutNegation(haystack, kw));
   const complexHits = containsAnyKeyword(haystack, COMPLEX_KEYWORDS);
   const trivialHits = containsAnyKeyword(haystack, TRIVIAL_KEYWORDS);
   const fileCountHint = extractFileCountHint(haystack);