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

package/src/resources/extensions/gsd/guided-flow.ts

@@ -26,6 +26,7 @@ import {
   buildPlanMilestonePrompt,
   buildPlanSlicePrompt,
   buildSkillActivationBlock,
+  capPreamble,
 } from "./auto-prompts.js";
 import { deriveState, isGhostMilestone } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
@@ -864,6 +865,13 @@ export function getDiscussableFutureMilestones<T extends { id: string; status: s
   );
 }
 
+function findDiscussTargetMilestone(
+  registry: GSDState["registry"],
+  milestoneId: string,
+): GSDState["registry"][number] | undefined {
+  return registry.find((m) => m.id === milestoneId || m.id.startsWith(`${milestoneId}-`));
+}
+
 function getStructuredQuestionsAvailability(
   pi: ExtensionAPI,
   ctx: ExtensionContext | undefined,
@@ -1192,7 +1200,9 @@ function resolveDiscussSliceBasePath(basePath: string, milestoneId: string): str
  * slice summaries so the agent can ask grounded UX/behaviour questions
  * without wasting a turn reading files.
  */
-async function buildDiscussSlicePrompt(
+// Exported for tests (`prompt-budget-enforcement.test.ts`) — verifies the
+// inlined-context cap. Not part of the public flow surface otherwise.
+export async function buildDiscussSlicePrompt(
   mid: string,
   sid: string,
   sTitle: string,
@@ -1255,8 +1265,12 @@ async function buildDiscussSlicePrompt(
     }
   }
 
+  // Cap the inlined block: it grows unbounded with each completed slice's full
+  // SUMMARY. `capPreamble` truncates at `### ` section boundaries — roadmap and
+  // milestone context come first (survive), completed-slice summaries come last
+  // (dropped first) when the executor's window can't hold everything.
   const inlinedContext = inlined.length > 0
-    ? `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`
+    ? capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`)
     : `## Inlined Context\n\n_(no context files found yet — go in blind and ask broad questions)_`;
 
   const sliceDirPath = `.gsd/milestones/${mid}/slices/${sid}`;
@@ -1268,7 +1282,7 @@ async function buildDiscussSlicePrompt(
     : "";
 
   const inlinedTemplates = inlineTemplate("slice-context", "Slice Context");
-  return loadPrompt("guided-discuss-slice", {
+  return prependLanguageDirective(base, loadPrompt("guided-discuss-slice", {
     milestoneId: mid,
     sliceId: sid,
     sliceTitle: sTitle,
@@ -1279,7 +1293,7 @@ async function buildDiscussSlicePrompt(
     inlinedTemplates,
     structuredQuestionsAvailable: options?.structuredQuestionsAvailable ?? "false",
     commitInstruction: buildDocsCommitInstruction(`docs(${mid}/${sid}): slice context from discuss`),
-  });
+  }));
 }
 
 /**
@@ -1333,12 +1347,23 @@ export async function showDiscuss(
     if (slash > 0) {
       const mid = target.slice(0, slash);
       const sid = target.slice(slash + 1);
-      const targetMilestone = state.registry.find((m) => m.id === mid);
-      if (!targetMilestone || targetMilestone.status === "complete" || targetMilestone.status === "parked") {
-        ctx.ui.notify(`Milestone ${mid} is not discussable.`, "warning");
+      const targetMilestone = findDiscussTargetMilestone(state.registry, mid);
+      if (!targetMilestone) {
+        ctx.ui.notify(
+          `Milestone ${mid} was not found in the roadmap. Use /gsd new-milestone to add it, or /gsd status to see available milestones.`,
+          "warning",
+        );
+        return;
+      }
+      if (targetMilestone.status === "complete") {
+        ctx.ui.notify(`Milestone ${targetMilestone.id} is already complete.`, "info");
+        return;
+      }
+      if (targetMilestone.status === "parked") {
+        ctx.ui.notify(`Milestone ${targetMilestone.id} is parked. Run /gsd unpark ${targetMilestone.id} to reactivate.`, "warning");
         return;
       }
-      const slices = await loadDiscussNormSlices(basePath, mid);
+      const slices = await loadDiscussNormSlices(basePath, targetMilestone.id);
       const chosen = slices.find((s) => s.id.toUpperCase() === sid.toUpperCase());
       if (!chosen) {
         ctx.ui.notify(`Slice ${target} was not found in discussable slices.`, "warning");
@@ -1348,10 +1373,10 @@ export async function showDiscuss(
         ctx.ui.notify(`Slice ${target} is already complete; nothing to discuss.`, "info");
         return;
       }
-      const discussBasePath = resolveDiscussSliceBasePath(basePath, mid);
-      const contextFile = resolveSliceFile(discussBasePath, mid, sid, "CONTEXT");
+      const discussBasePath = resolveDiscussSliceBasePath(basePath, targetMilestone.id);
+      const contextFile = resolveSliceFile(discussBasePath, targetMilestone.id, sid, "CONTEXT");
       const sqAvail = getStructuredQuestionsAvailability(pi, ctx);
-      const prompt = await buildDiscussSlicePrompt(mid, sid, chosen.title, discussBasePath, {
+      const prompt = await buildDiscussSlicePrompt(targetMilestone.id, sid, chosen.title, discussBasePath, {
         rediscuss: !!contextFile,
         structuredQuestionsAvailable: sqAvail,
       });
@@ -1359,9 +1384,20 @@ export async function showDiscuss(
       return;
     }
 
-    const targetMilestone = state.registry.find((m) => m.id === target);
-    if (!targetMilestone || targetMilestone.status === "complete" || targetMilestone.status === "parked") {
-      ctx.ui.notify(`Milestone ${target} is not discussable.`, "warning");
+    const targetMilestone = findDiscussTargetMilestone(state.registry, target);
+    if (!targetMilestone) {
+      ctx.ui.notify(
+        `Milestone ${target} was not found in the roadmap. Use /gsd new-milestone to add it, or /gsd status to see available milestones.`,
+        "warning",
+      );
+      return;
+    }
+    if (targetMilestone.status === "complete") {
+      ctx.ui.notify(`Milestone ${targetMilestone.id} is already complete.`, "info");
+      return;
+    }
+    if (targetMilestone.status === "parked") {
+      ctx.ui.notify(`Milestone ${targetMilestone.id} is parked. Run /gsd unpark ${targetMilestone.id} to reactivate.`, "warning");
       return;
     }
     await dispatchDiscussForMilestone(ctx, pi, basePath, targetMilestone.id, targetMilestone.title, {});

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

@@ -12,7 +12,7 @@
 import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from "node:fs";
 import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
-import { dirname, join, relative } from "node:path";
+import { dirname, join } from "node:path";
 import {
   getAllMilestones,
   getMilestone,
@@ -40,6 +40,7 @@ import {
   resolveTasksDir,
   targetMilestoneFile,
   targetSliceFile,
+  targetTaskFile,
   gsdProjectionRoot,
   gsdRoot,
   buildTaskFileName,
@@ -49,7 +50,7 @@ import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.j
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache, milestonesDir, legacyMilestonesDir, isLegacyMilestonesLayout, resolveMilestonePath, relSliceFile, canonicalPhaseDirName } from "./paths.js";
-import { readCompatMarker, writeCompatMarker, computeProjectionSha } from "./compat/compat-marker.js";
+import { readCompatMarker, writeCompatMarker, computeProjectionSha, deriveCompatProjectionKey } from "./compat/compat-marker.js";
 import type { RiskLevel } from "./types.js";
 import {
   phaseDirName,
@@ -108,13 +109,7 @@ function flushProjectionWritesToMarker(): void {
  */
 function toArtifactPath(absPath: string, basePath: string): string {
   const projectionRoot = gsdProjectionRoot(basePath);
-  const projectionRel = relative(projectionRoot, absPath);
-  const root = projectionRel && !projectionRel.startsWith("..") && !projectionRel.startsWith("/")
-    ? projectionRoot
-    : gsdRoot(basePath);
-  const rel = relative(root, absPath);
-  // Normalize to forward slashes for consistent DB keys
-  return rel.replace(/\\/g, "/");
+  return deriveCompatProjectionKey(absPath, [projectionRoot, gsdRoot(basePath)]);
 }
 
 /**
@@ -756,20 +751,7 @@ export async function renderTaskSummary(
     return false; // No summary to render — skip silently
   }
 
-  // Resolve the tasks directory, creating path if needed
-  const slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
-  if (!slicePath) {
-    process.stderr.write(
-      `markdown-renderer: cannot resolve slice path for ${milestoneId}/${sliceId}\n`,
-    );
-    return false;
-  }
-
-  // Use the tasks/ subdir when it exists (legacy layout), otherwise use the
-  // slice path directly (flat-phase: task summaries live alongside plan files).
-  const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId) ?? slicePath;
-  const fileName = buildTaskFileName(taskId, "SUMMARY");
-  const absPath = join(tasksDir, fileName);
+  const absPath = targetTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY", getMilestone(milestoneId)?.title);
   const artifactPath = toArtifactPath(absPath, basePath);
 
   await writeAndStore(absPath, artifactPath, task.full_summary_md, {
@@ -1208,6 +1190,21 @@ export interface AssessmentData {
   completedSliceId?: string;
 }
 
+function existingLegacySliceAssessmentPath(
+  basePath: string,
+  milestoneId: string,
+  sliceId: string,
+): string | null {
+  if (!isLegacyMilestonesLayout(basePath)) return null;
+  const legacyBase = legacyMilestonesDir(basePath);
+  const milestoneDirName = resolveDir(legacyBase, milestoneId);
+  if (!milestoneDirName) return null;
+  const slicesDir = join(legacyBase, milestoneDirName, "slices");
+  const sliceDirName = resolveDir(slicesDir, sliceId);
+  if (!sliceDirName) return null;
+  return join(slicesDir, sliceDirName, `${sliceId}-ASSESSMENT.md`);
+}
+
 export async function renderReplanFromDb(
   basePath: string,
   milestoneId: string,
@@ -1258,13 +1255,14 @@ export async function renderAssessmentFromDb(
   sliceId: string,
   assessmentData: AssessmentData,
 ): Promise<{ assessmentPath: string; content: string }> {
-  const absPath = targetSliceFile(
-    basePath,
-    milestoneId,
-    sliceId,
-    "ASSESSMENT",
-    getMilestone(milestoneId)?.title,
-  );
+  const absPath = existingLegacySliceAssessmentPath(basePath, milestoneId, sliceId)
+    ?? targetSliceFile(
+      basePath,
+      milestoneId,
+      sliceId,
+      "ASSESSMENT",
+      getMilestone(milestoneId)?.title,
+    );
   mkdirSync(dirname(absPath), { recursive: true });
   const artifactPath = toArtifactPath(absPath, basePath);
 

package/src/resources/extensions/gsd/md-importer.ts

@@ -17,6 +17,8 @@ import {
   transaction,
   updateMilestoneStatus,
   updateSliceStatus,
+  getMilestoneSlices,
+  getSliceTasks,
   _getAdapter,
 } from './gsd-db.js';
 import { openWorkflowDatabasePath } from './db-workspace.js';
@@ -29,6 +31,7 @@ import {
   legacyMilestonesDir,
   gsdRoot,
   resolveTaskFiles,
+  resolveTaskFile,
   resolveMilestonePath,
 } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
@@ -43,6 +46,26 @@ const VALID_MADE_BY = new Set(['human', 'agent', 'collaborative']);
 
 const IMPORT_COMPLETE_STATUSES = new Set(['complete', 'done']);
 
+/**
+ * Derive the set of milestone ids a projection entry's `entities` touch. Marker
+ * entity ids are fully-qualified DB ids (`M001`, `M001/S01`, `M001/S01/T01`), so
+ * the milestone id is always the first `/`-segment — independent of the on-disk
+ * layout (legacy `milestones/<MID>/…` vs flat `phases/NN-slug/…`). The
+ * external-edit drift repairs (#027) feed this into
+ * `migrateHierarchyToDb(..., { statusAuthoritativeMilestones })` to scope status
+ * authority to exactly the milestone(s) a drifted file projects. Empty/blank
+ * entries are dropped, so an entity-less entry yields an empty set (repair then
+ * preserves DB status everywhere — fail toward the DB, not markdown).
+ */
+export function milestoneIdsFromEntities(entities: readonly string[]): Set<string> {
+  const ids = new Set<string>();
+  for (const e of entities) {
+    const milestoneId = e.split('/')[0];
+    if (milestoneId) ids.add(milestoneId);
+  }
+  return ids;
+}
+
 /**
  * Completion timestamp for an entity imported as complete: the SUMMARY.md mtime
  * when one exists (deterministic, matches the completion drift handler), else
@@ -676,15 +699,35 @@ function findFileByPrefixAndSuffix(dir: string, idPrefix: string, suffix: string
  * Uses INSERT OR IGNORE for idempotency. Insert order: milestones → slices → tasks.
  * Ghost milestones (dirs with no CONTEXT, ROADMAP, or SUMMARY) are skipped.
  *
+ * `opts.statusAuthoritativeMilestones` narrows *status* authority. It exists for
+ * the scoped external-edit drift repair: detection knows exactly which
+ * projection file drifted, but this import walks the whole tree. Without scoping,
+ * an unrelated file that is stale from gsd-pi's own miss (a forgotten render)
+ * rides along with markdown authority it was never granted and its stale checked
+ * checkbox silently reverts a reopened slice/milestone in the DB (#027).
+ *
+ * - opts absent → full markdown authority for every milestone (initial migration,
+ *   gsd-core full import, /gsd recover rebuild). Behavior is identical to before.
+ * - opts present → for a milestone NOT in the set whose DB row *already exists*,
+ *   the existing DB status is preserved: the slice upsert is fed the current DB
+ *   status (so a stale `complete` checkbox can't overwrite a reopened `pending`),
+ *   and the complete-status backfills are skipped. Milestone rows are already
+ *   protected by INSERT OR IGNORE. Rows that do not exist yet are inserted with
+ *   the parsed status regardless of scope (new content is new content).
+ *
  * Returns count of inserted hierarchy items.
  */
-export function migrateHierarchyToDb(basePath: string): {
+export function migrateHierarchyToDb(
+  basePath: string,
+  opts?: { statusAuthoritativeMilestones?: ReadonlySet<string> },
+): {
   milestones: number;
   slices: number;
   tasks: number;
 } {
   const counts = { milestones: 0, slices: 0, tasks: 0 };
   const milestoneIds = findMilestoneIds(basePath);
+  const statusScope = opts?.statusAuthoritativeMilestones;
 
   for (const milestoneId of milestoneIds) {
     // Check for ghost milestones — skip dirs with no meaningful content
@@ -745,8 +788,30 @@ export function migrateHierarchyToDb(basePath: string): {
       }
     }
 
-    // Insert milestone (FK parent — must come first)
-    insertMilestone({
+    // #027: when a status scope is supplied, a milestone outside it keeps DB
+    // status authority for rows that already exist — only the drifted file's
+    // milestone(s) may drive status closes from checkboxes. Absent scope, every
+    // milestone is authoritative (unchanged full-import behavior).
+    const milestoneStatusAuthoritative = !statusScope || statusScope.has(milestoneId);
+    // Snapshot existing slice statuses once (only needed when preserving DB
+    // authority for this milestone) so the upsert can echo them back instead of
+    // flipping an open slice closed from a stale checkbox.
+    const existingSliceStatus = new Map<string, string>();
+    const existingTaskStatus = new Map<string, string>();
+    if (!milestoneStatusAuthoritative) {
+      for (const s of getMilestoneSlices(milestoneId)) {
+        existingSliceStatus.set(s.id, s.status);
+        for (const t of getSliceTasks(milestoneId, s.id)) {
+          existingTaskStatus.set(`${s.id}/${t.id}`, t.status);
+        }
+      }
+    }
+
+    // Insert milestone (FK parent — must come first). INSERT OR IGNORE: an
+    // existing milestone row is never overwritten, so DB status is already
+    // preserved for out-of-scope milestones. `inserted` tells us whether this
+    // row is new (parsed status applies) vs pre-existing (backfill gated below).
+    const milestoneInserted = insertMilestone({
       id: milestoneId,
       title: milestoneTitle,
       status: milestoneStatus,
@@ -760,10 +825,14 @@ export function migrateHierarchyToDb(basePath: string): {
     // insertMilestone never sets completed_at; backfill it now for milestones
     // imported as complete so the DB is internally coherent immediately after
     // import (rather than relying on a later reconciliation pass that can't even
-    // see the drift when no SUMMARY file exists).
-    if (IMPORT_COMPLETE_STATUSES.has(milestoneStatus)) {
+    // see the drift when no SUMMARY file exists). #027: skip the backfill for an
+    // out-of-scope milestone that already existed — its DB status is authoritative.
+    if (IMPORT_COMPLETE_STATUSES.has(milestoneStatus) && (milestoneStatusAuthoritative || milestoneInserted)) {
       const summaryPath = resolveMilestoneFile(basePath, milestoneId, 'SUMMARY');
-      updateMilestoneStatus(milestoneId, milestoneStatus, importCompletionTimestamp(summaryPath));
+      // #1291: preserve an existing completion timestamp so a re-import backfills
+      // only rows that lack one, never re-stamping an already-complete milestone
+      // with the current import time. Same guard as the task path below.
+      updateMilestoneStatus(milestoneId, milestoneStatus, importCompletionTimestamp(summaryPath), true);
     }
     counts.milestones++;
 
@@ -783,11 +852,22 @@ export function migrateHierarchyToDb(basePath: string): {
         plan = parsePlan(planContent);
       }
 
+      // #027: for an out-of-scope milestone, echo the existing DB status of a
+      // slice that already exists so the upsert's `ELSE excluded.status` branch
+      // becomes a no-op instead of flipping a reopened `pending` slice back to
+      // `complete` from a stale checkbox. New slices (not yet in the DB) take the
+      // parsed status regardless of scope.
+      const sliceRowExists = existingSliceStatus.has(sliceEntry.id);
+      const sliceStatusAuthoritative = milestoneStatusAuthoritative || !sliceRowExists;
+      const effectiveSliceStatus = sliceStatusAuthoritative
+        ? sliceStatus
+        : existingSliceStatus.get(sliceEntry.id)!;
+
       insertSlice({
         id: sliceEntry.id,
         milestoneId: milestoneId,
         title: sliceEntry.title,
-        status: sliceStatus,
+        status: effectiveSliceStatus,
         risk: sliceEntry.risk,
         depends: (sliceEntry.depends ?? []).map(d => d.replace(/^\[|\]$/g, '')).filter(d => /^[A-Za-z0-9][A-Za-z0-9-]*$/.test(d)),
         demo: sliceEntry.demo,
@@ -798,14 +878,19 @@ export function migrateHierarchyToDb(basePath: string): {
         },
       });
       // insertSlice never sets completed_at; backfill it for slices imported as
-      // complete (same rationale as milestones above).
-      if (IMPORT_COMPLETE_STATUSES.has(sliceStatus)) {
+      // complete (same rationale as milestones above). #027: skip when preserving
+      // an out-of-scope slice's existing DB status.
+      if (IMPORT_COMPLETE_STATUSES.has(sliceStatus) && sliceStatusAuthoritative) {
         const sliceSummary = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'SUMMARY');
+        // #1291: preserve an existing completion timestamp so a re-import backfills
+        // only slices that lack one, never re-stamping an already-complete slice
+        // with the current import time. Same guard as the task path below.
         updateSliceStatus(
           milestoneId,
           sliceEntry.id,
           sliceStatus,
           importCompletionTimestamp(sliceSummary),
+          true,
         );
       }
       counts.slices++;
@@ -841,8 +926,7 @@ export function migrateHierarchyToDb(basePath: string): {
           legacyTasksDir = isLegacySlice
             ? resolveTasksDir(basePath, milestoneId, sliceEntry.id)
             : null;
-          const summaryDir = legacyTasksDir ?? slicePath;
-          taskSummaryFile = join(summaryDir, `${taskEntry.id}-SUMMARY.md`);
+          taskSummaryFile = resolveTaskFile(basePath, milestoneId, sliceEntry.id, taskEntry.id, 'SUMMARY');
         }
         const hasTaskSummary = taskSummaryFile !== null && existsSync(taskSummaryFile);
 
@@ -866,9 +950,9 @@ export function migrateHierarchyToDb(basePath: string): {
         // first execute-task. The surviving SUMMARY wins over a stale checkbox.
         // reopen-task removes the SUMMARY, so this never re-completes an
         // intentionally reopened task.
-        // Flat-phase summaries are phase-scoped (T01-SUMMARY.md); when a milestone
-        // has multiple slices, require the summary parent frontmatter to match so
-        // one slice's completion does not attest a sibling's same-named task.
+        // Flat-phase summaries are phase-scoped; when a milestone has multiple
+        // slices, require the summary parent frontmatter to match so one slice's
+        // completion does not attest a sibling's same-named task.
         let summaryAttestsCompletion = hasTaskSummary;
         if (summaryAttestsCompletion && !isLegacySlice && roadmap.slices.length > 1 && taskSummaryFile) {
           try {
@@ -885,12 +969,20 @@ export function migrateHierarchyToDb(basePath: string): {
           );
         }
 
+        // #027: same scope guard as slices — out-of-scope milestones echo existing
+        // DB task status so stale plan checkboxes cannot re-complete reopened tasks.
+        const taskRowExists = existingTaskStatus.has(`${sliceEntry.id}/${taskEntry.id}`);
+        const taskStatusAuthoritative = milestoneStatusAuthoritative || !taskRowExists;
+        const effectiveTaskStatus = taskStatusAuthoritative
+          ? taskStatus
+          : existingTaskStatus.get(`${sliceEntry.id}/${taskEntry.id}`)!;
+
         insertTask({
           id: taskEntry.id,
           sliceId: sliceEntry.id,
           milestoneId: milestoneId,
           title: taskEntry.title,
-          status: taskStatus,
+          status: effectiveTaskStatus,
           planning: {
             files: taskEntry.files ?? [],
             verify: taskEntry.verify ?? '',
@@ -940,13 +1032,19 @@ export function migrateHierarchyToDb(basePath: string): {
           // checkbox (#1222); flat-phase checkboxes are authoritative without summary.
           return summaryAttestsCompletion || (t.done && !isLegacySliceLayout);
         });
-        if (allTasksDone && hasSliceSummary) {
+        // #027: the same close guard as the backfill above — a stale slice
+        // SUMMARY under an out-of-scope milestone must not upgrade a reopened
+        // slice to complete. New slices stay authoritative.
+        if (allTasksDone && hasSliceSummary && sliceStatusAuthoritative) {
           if (_getAdapter()) {
+            // #1291: preserve an existing completion timestamp — this consistency
+            // upgrade sets a completion time only when the row lacks one.
             updateSliceStatus(
               milestoneId,
               sliceEntry.id,
               'complete',
               importCompletionTimestamp(sliceSummaryPath),
+              true,
             );
             process.stderr.write(
               `gsd-migrate: ${milestoneId}/${sliceEntry.id} all tasks + slice summary complete — upgrading slice to complete\n`,