gsd-pi 2.26.1-next.1 → 2.28.0-dev.346ee62

package/dist/resources/extensions/gsd/state.ts

@@ -26,6 +26,7 @@ import {
   resolveSlicePath,
   resolveSliceFile,
   resolveTaskFile,
+  resolveTasksDir,
   resolveGsdRootFile,
   gsdRoot,
 } from './paths.js';
@@ -34,6 +35,7 @@ import { milestoneIdSort, findMilestoneIds } from './guided-flow.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
 
 import { join, resolve } from 'path';
+import { existsSync, readdirSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 
 // ─── Query Functions ───────────────────────────────────────────────────────
@@ -101,9 +103,17 @@ export async function getActiveMilestoneId(basePath: string): Promise<string | n
   // Parallel worker isolation
   const milestoneLock = process.env.GSD_MILESTONE_LOCK;
   if (milestoneLock) {
-    return milestoneIds.includes(milestoneLock) ? milestoneLock : null;
+    if (!milestoneIds.includes(milestoneLock)) return null;
+    // Locked milestone that is parked should not be active
+    const lockedParked = resolveMilestoneFile(basePath, milestoneLock, "PARKED");
+    if (lockedParked) return null;
+    return milestoneLock;
   }
   for (const mid of milestoneIds) {
+    // Skip parked milestones — they are not eligible for active status
+    const parkedFile = resolveMilestoneFile(basePath, mid, "PARKED");
+    if (parkedFile) continue;
+
     const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
     const content = roadmapFile ? await loadFile(roadmapFile) : null;
     if (!content) {
@@ -222,7 +232,22 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
   const roadmapCache = new Map<string, Roadmap>();
   const completeMilestoneIds = new Set<string>();
 
+  // Track parked milestone IDs so Phase 2 can check without re-reading disk
+  const parkedMilestoneIds = new Set<string>();
+
   for (const mid of milestoneIds) {
+    // Skip parked milestones — they do NOT count as complete (don't satisfy depends_on)
+    // But still parse their roadmap for title extraction in Phase 2.
+    const parkedFile = resolveMilestoneFile(basePath, mid, "PARKED");
+    if (parkedFile) {
+      parkedMilestoneIds.add(mid);
+      // Cache roadmap for title extraction (but don't add to completeMilestoneIds)
+      const prf = resolveMilestoneFile(basePath, mid, "ROADMAP");
+      const prc = prf ? await cachedLoadFile(prf) : null;
+      if (prc) roadmapCache.set(mid, parseRoadmap(prc));
+      continue;
+    }
+
     const rf = resolveMilestoneFile(basePath, mid, "ROADMAP");
     const rc = rf ? await cachedLoadFile(rf) : null;
     if (!rc) {
@@ -245,6 +270,16 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
   let activeMilestoneHasDraft = false;
 
   for (const mid of milestoneIds) {
+    // Skip parked milestones — register them as 'parked' and move on
+    if (parkedMilestoneIds.has(mid)) {
+      const roadmap = roadmapCache.get(mid) ?? null;
+      const title = roadmap
+        ? roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '')
+        : mid;
+      registry.push({ id: mid, title, status: 'parked' });
+      continue;
+    }
+
     const roadmap = roadmapCache.get(mid) ?? null;
 
     if (!roadmap) {
@@ -350,8 +385,9 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
   };
 
   if (!activeMilestone) {
-    // Check whether any milestones are pending (dep-blocked) vs all complete
+    // Check whether any milestones are pending (dep-blocked) or parked
     const pendingEntries = registry.filter(entry => entry.status === 'pending');
+    const parkedEntries = registry.filter(entry => entry.status === 'parked');
     if (pendingEntries.length > 0) {
       // All incomplete milestones are dep-blocked — no progress possible
       const blockerDetails = pendingEntries
@@ -374,6 +410,24 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
         },
       };
     }
+    if (parkedEntries.length > 0) {
+      // All non-complete milestones are parked — nothing active, but not "all complete"
+      const parkedIds = parkedEntries.map(e => e.id).join(', ');
+      return {
+        activeMilestone: null,
+        activeSlice: null,
+        activeTask: null,
+        phase: 'pre-planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: `All remaining milestones are parked (${parkedIds}). Run /gsd unpark <id> or create a new milestone.`,
+        registry,
+        requirements,
+        progress: {
+          milestones: milestoneProgress,
+        },
+      };
+    }
     // All milestones complete
     const lastEntry = registry[registry.length - 1];
     return {
@@ -573,6 +627,34 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
     title: activeTaskEntry.title,
   };
 
+  // ── Task plan file check (#909) ──────────────────────────────────────
+  // The slice plan may reference tasks but per-task plan files may be
+  // missing — e.g. when the slice plan was pre-created during roadmapping.
+  // If the tasks dir exists but has literally zero files (empty dir from
+  // mkdir), fall back to planning so plan-slice generates task plans.
+  const tasksDir = resolveTasksDir(basePath, activeMilestone.id, activeSlice.id);
+  if (tasksDir && existsSync(tasksDir) && slicePlan.tasks.length > 0) {
+    const allFiles = readdirSync(tasksDir).filter(f => f.endsWith(".md"));
+    if (allFiles.length === 0) {
+      return {
+        activeMilestone,
+        activeSlice,
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: `Task plan files missing for ${activeSlice.id}. Run plan-slice to generate task plans.`,
+        registry,
+        requirements,
+        progress: {
+          milestones: milestoneProgress,
+          slices: sliceProgress,
+          tasks: taskProgress,
+        },
+      };
+    }
+  }
+
   // ── Blocker detection: scan completed task summaries ──────────────────
   // If any completed task has blocker_discovered: true and no REPLAN.md
   // exists yet, transition to replanning-slice instead of executing.

package/dist/resources/extensions/gsd/structured-data-formatter.ts

@@ -0,0 +1,144 @@
+/**
+ * Structured Data Formatter — compact notation for prompt injection.
+ *
+ * Converts GSD data structures into a token-efficient format that removes
+ * markdown table overhead, redundant labels, and formatting while remaining
+ * perfectly readable by LLMs.
+ *
+ * Format rules:
+ * - No table pipes, dashes, or header rows
+ * - Use indentation (2 spaces) for structure instead of delimiters
+ * - Omit field names when the pattern is clear from a header
+ * - Use single-line entries for simple records
+ * - Use multi-line with indentation for complex records
+ */
+
+// ---------------------------------------------------------------------------
+// Types (inline — no imports from other GSD modules)
+// ---------------------------------------------------------------------------
+
+interface DecisionInput {
+  id: string;
+  when_context: string;
+  scope: string;
+  decision: string;
+  choice: string;
+  rationale: string;
+  revisable: string;
+}
+
+interface RequirementInput {
+  id: string;
+  class: string;
+  status: string;
+  description: string;
+  why: string;
+  primary_owner: string;
+  validation: string;
+}
+
+interface TaskPlanInput {
+  id: string;
+  title: string;
+  description: string;
+  done: boolean;
+  estimate: string;
+  files?: string[];
+  verify?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Decisions
+// ---------------------------------------------------------------------------
+
+/** Compact format for a single decision record (pipe-separated, no padding). */
+export function formatDecisionCompact(decision: DecisionInput): string {
+  return [
+    decision.id,
+    decision.when_context,
+    decision.scope,
+    decision.decision,
+    decision.choice,
+    decision.rationale,
+    decision.revisable,
+  ].join(" | ");
+}
+
+/** Format multiple decisions in compact notation with a Fields header. */
+export function formatDecisionsCompact(decisions: DecisionInput[]): string {
+  if (decisions.length === 0) {
+    return "# Decisions (compact)\n(none)";
+  }
+
+  const header = "# Decisions (compact)\nFields: id | when | scope | decision | choice | rationale | revisable";
+  const lines = decisions.map(formatDecisionCompact);
+  return `${header}\n\n${lines.join("\n")}`;
+}
+
+// ---------------------------------------------------------------------------
+// Requirements
+// ---------------------------------------------------------------------------
+
+/** Compact format for a single requirement record (multi-line). */
+export function formatRequirementCompact(req: RequirementInput): string {
+  const lines: string[] = [];
+  lines.push(`${req.id} [${req.class}] (${req.status}) owner:${req.primary_owner}`);
+  lines.push(`  ${req.description}`);
+  lines.push(`  why: ${req.why}`);
+  lines.push(`  validate: ${req.validation}`);
+  return lines.join("\n");
+}
+
+/** Format multiple requirements in compact notation. */
+export function formatRequirementsCompact(requirements: RequirementInput[]): string {
+  if (requirements.length === 0) {
+    return "# Requirements (compact)\n(none)";
+  }
+
+  const header = "# Requirements (compact)";
+  const blocks = requirements.map(formatRequirementCompact);
+  return `${header}\n\n${blocks.join("\n\n")}`;
+}
+
+// ---------------------------------------------------------------------------
+// Task Plans
+// ---------------------------------------------------------------------------
+
+/** Compact format for task plan entries. */
+export function formatTaskPlanCompact(tasks: TaskPlanInput[]): string {
+  if (tasks.length === 0) {
+    return "# Tasks (compact)\n(none)";
+  }
+
+  const header = "# Tasks (compact)";
+  const blocks = tasks.map((t) => {
+    const check = t.done ? "x" : " ";
+    const lines: string[] = [];
+    lines.push(`${t.id} [${check}] ${t.title} (${t.estimate})`);
+    if (t.files && t.files.length > 0) {
+      lines.push(`  files: ${t.files.join(", ")}`);
+    }
+    if (t.verify) {
+      lines.push(`  verify: ${t.verify}`);
+    }
+    lines.push(`  ${t.description}`);
+    return lines.join("\n");
+  });
+
+  return `${header}\n\n${blocks.join("\n\n")}`;
+}
+
+// ---------------------------------------------------------------------------
+// Savings measurement
+// ---------------------------------------------------------------------------
+
+/**
+ * Measure the token savings of compact format vs markdown format.
+ * Returns savings as a percentage (0-100).
+ * A positive number means compact is smaller (saves tokens).
+ */
+export function measureSavings(compactContent: string, markdownContent: string): number {
+  if (markdownContent.length === 0) return 0;
+  const saved = markdownContent.length - compactContent.length;
+  return (saved / markdownContent.length) * 100;
+}

package/dist/resources/extensions/gsd/summary-distiller.ts

@@ -0,0 +1,258 @@
+/**
+ * Summary distiller — extracts essential structured data from SUMMARY.md files,
+ * dropping verbose prose to save context budget.
+ */
+
+export interface DistillationResult {
+  content: string;
+  summaryCount: number;
+  savingsPercent: number;
+  originalChars: number;
+  distilledChars: number;
+}
+
+interface ParsedFrontmatter {
+  id: string;
+  provides: string[];
+  requires: string[];
+  key_files: string[];
+  key_decisions: string[];
+  patterns_established: string[];
+}
+
+interface DistilledEntry {
+  id: string;
+  oneLiner: string;
+  provides: string[];
+  requires: string[];
+  key_files: string[];
+  key_decisions: string[];
+  patterns: string[];
+}
+
+// ─── Frontmatter parsing ─────────────────────────────────────────────────────
+
+function parseFrontmatter(raw: string): ParsedFrontmatter {
+  const result: ParsedFrontmatter = {
+    id: "",
+    provides: [],
+    requires: [],
+    key_files: [],
+    key_decisions: [],
+    patterns_established: [],
+  };
+
+  // Extract frontmatter block between --- markers
+  const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fmMatch) return result;
+
+  const fmBlock = fmMatch[1];
+  const lines = fmBlock.split(/\r?\n/);
+
+  let currentKey: string | null = null;
+
+  for (const line of lines) {
+    // Scalar value: key: value
+    const scalarMatch = line.match(/^(\w[\w_]*):\s*(.+)$/);
+    if (scalarMatch) {
+      const [, key, value] = scalarMatch;
+      currentKey = key;
+      setScalar(result, key, value.trim());
+      continue;
+    }
+
+    // Array-start key with empty value: key:\n  or key: []\n
+    const arrayStartMatch = line.match(/^(\w[\w_]*):\s*(\[\])?\s*$/);
+    if (arrayStartMatch) {
+      currentKey = arrayStartMatch[1];
+      continue;
+    }
+
+    // Array item:   - value
+    const itemMatch = line.match(/^\s+-\s+(.+)$/);
+    if (itemMatch && currentKey) {
+      pushItem(result, currentKey, itemMatch[1].trim());
+      continue;
+    }
+  }
+
+  return result;
+}
+
+function setScalar(fm: ParsedFrontmatter, key: string, value: string): void {
+  if (key === "id") fm.id = value;
+}
+
+function pushItem(fm: ParsedFrontmatter, key: string, value: string): void {
+  switch (key) {
+    case "provides": fm.provides.push(value); break;
+    case "requires": fm.requires.push(value); break;
+    case "key_files": fm.key_files.push(value); break;
+    case "key_decisions": fm.key_decisions.push(value); break;
+    case "patterns_established": fm.patterns_established.push(value); break;
+  }
+}
+
+// ─── Body parsing ────────────────────────────────────────────────────────────
+
+function extractTitleAndOneLiner(body: string): { id: string; oneLiner: string } {
+  const lines = body.split(/\r?\n/);
+  let titleId = "";
+  let oneLiner = "";
+  let foundTitle = false;
+
+  for (const line of lines) {
+    const titleMatch = line.match(/^#\s+(\S+):\s*(.*)$/);
+    if (titleMatch && !foundTitle) {
+      titleId = titleMatch[1];
+      // If the title line itself has text after "S01: ", use that as a fallback
+      if (titleMatch[2].trim()) {
+        oneLiner = titleMatch[2].trim();
+      }
+      foundTitle = true;
+      continue;
+    }
+
+    // First non-empty line after the title is the one-liner
+    if (foundTitle && !oneLiner && line.trim() && !line.startsWith("#")) {
+      oneLiner = line.trim();
+      break;
+    }
+  }
+
+  return { id: titleId, oneLiner };
+}
+
+function getBodyAfterFrontmatter(raw: string): string {
+  const fmMatch = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  if (fmMatch) {
+    return raw.slice(fmMatch[0].length);
+  }
+  return raw;
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Distill a single SUMMARY.md content string into a compact structured block.
+ */
+export function distillSingle(summary: string): string {
+  const fm = parseFrontmatter(summary);
+  const body = getBodyAfterFrontmatter(summary);
+  const { id: titleId, oneLiner } = extractTitleAndOneLiner(body);
+
+  const id = fm.id || titleId || "???";
+
+  return formatEntry({
+    id,
+    oneLiner,
+    provides: fm.provides,
+    requires: fm.requires,
+    key_files: fm.key_files,
+    key_decisions: fm.key_decisions,
+    patterns: fm.patterns_established,
+  });
+}
+
+function formatEntry(entry: DistilledEntry): string {
+  return formatEntryWithDropLevel(entry, 0);
+}
+
+/**
+ * Format an entry, progressively dropping fields based on dropLevel:
+ *   0 = full output
+ *   1 = drop patterns
+ *   2 = drop patterns + key_decisions
+ *   3 = drop patterns + key_decisions + key_files
+ */
+function formatEntryWithDropLevel(entry: DistilledEntry, dropLevel: number): string {
+  const lines: string[] = [];
+  lines.push(`## ${entry.id}: ${entry.oneLiner}`);
+
+  if (entry.provides.length > 0) {
+    lines.push(`provides: ${entry.provides.join(", ")}`);
+  }
+  if (entry.requires.length > 0) {
+    lines.push(`requires: ${entry.requires.join(", ")}`);
+  }
+  if (dropLevel < 3 && entry.key_files.length > 0) {
+    lines.push(`key_files: ${entry.key_files.join(", ")}`);
+  }
+  if (dropLevel < 2 && entry.key_decisions.length > 0) {
+    lines.push(`key_decisions: ${entry.key_decisions.join(", ")}`);
+  }
+  if (dropLevel < 1 && entry.patterns.length > 0) {
+    lines.push(`patterns: ${entry.patterns.join(", ")}`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Distill multiple SUMMARY.md contents into a budget-constrained output.
+ */
+export function distillSummaries(summaries: string[], budgetChars: number): DistillationResult {
+  const originalChars = summaries.reduce((sum, s) => sum + s.length, 0);
+
+  if (summaries.length === 0) {
+    return {
+      content: "",
+      summaryCount: 0,
+      savingsPercent: 0,
+      originalChars: 0,
+      distilledChars: 0,
+    };
+  }
+
+  // Parse all entries up front
+  const entries: DistilledEntry[] = summaries.map((summary) => {
+    const fm = parseFrontmatter(summary);
+    const body = getBodyAfterFrontmatter(summary);
+    const { id: titleId, oneLiner } = extractTitleAndOneLiner(body);
+    return {
+      id: fm.id || titleId || "???",
+      oneLiner,
+      provides: fm.provides,
+      requires: fm.requires,
+      key_files: fm.key_files,
+      key_decisions: fm.key_decisions,
+      patterns: fm.patterns_established,
+    };
+  });
+
+  // Try progressively more aggressive dropping until it fits
+  for (let dropLevel = 0; dropLevel <= 3; dropLevel++) {
+    const blocks = entries.map((e) => formatEntryWithDropLevel(e, dropLevel));
+    const content = blocks.join("\n\n");
+    if (content.length <= budgetChars) {
+      const distilledChars = content.length;
+      return {
+        content,
+        summaryCount: summaries.length,
+        savingsPercent: originalChars > 0
+          ? Math.round((1 - distilledChars / originalChars) * 100)
+          : 0,
+        originalChars,
+        distilledChars,
+      };
+    }
+  }
+
+  // Even at max drop level it doesn't fit — truncate
+  const blocks = entries.map((e) => formatEntryWithDropLevel(e, 3));
+  let content = blocks.join("\n\n");
+  if (content.length > budgetChars) {
+    content = content.slice(0, Math.max(0, budgetChars - 15)) + "\n[...truncated]";
+  }
+
+  const distilledChars = content.length;
+  return {
+    content,
+    summaryCount: summaries.length,
+    savingsPercent: originalChars > 0
+      ? Math.round((1 - distilledChars / originalChars) * 100)
+      : 0,
+    originalChars,
+    distilledChars,
+  };
+}

package/dist/resources/extensions/gsd/templates/preferences.md

@@ -8,6 +8,7 @@ skill_rules: []
 custom_instructions: []
 models: {}
 skill_discovery:
+skill_staleness_days:
 auto_supervisor: {}
 git:
   auto_push:
@@ -19,10 +20,36 @@ git:
   main_branch:
   merge_strategy:
   isolation:
+  commit_docs:
+  manage_gitignore:
+  worktree_post_create:
 unique_milestone_ids:
 budget_ceiling:
 budget_enforcement:
 context_pause_threshold:
+token_profile:
+phases:
+  skip_research:
+  skip_reassess:
+  skip_slice_research:
+dynamic_routing:
+  enabled:
+  tier_models: {}
+  escalate_on_failure:
+  budget_pressure:
+  cross_provider:
+  hooks:
+auto_visualize:
+auto_report:
+parallel:
+  enabled:
+  max_workers:
+  budget_ceiling:
+  merge_strategy:
+  auto_merge:
+verification_commands: []
+verification_auto_fix:
+verification_max_retries:
 notifications:
   enabled:
   on_complete:
@@ -30,7 +57,14 @@ notifications:
   on_budget:
   on_milestone:
   on_attention:
+remote_questions:
+  channel:
+  channel_id:
+  timeout_minutes:
+  poll_interval_seconds:
 uat_dispatch:
+post_unit_hooks: []
+pre_dispatch_hooks: []
 ---
 
 # GSD Skill Preferences