gsd-pi 0.2.9 → 0.3.0

package/README.md

@@ -46,6 +46,28 @@ GSD v2 solves all of these because it's not a prompt framework anymore — it's
 | Roadmap reassessment | Manual | Automatic after each slice completes |
 | Skill discovery | None | Auto-detect and install relevant skills during research |
 
+### Migrating from v1
+
+If you have projects with `.planning` directories from the original Get Shit Done, you can migrate them to GSD-2's `.gsd` format:
+
+```bash
+# From within the project directory
+/gsd migrate
+
+# Or specify a path
+/gsd migrate ~/projects/my-old-project
+```
+
+The migration tool:
+- Parses your old `PROJECT.md`, `ROADMAP.md`, `REQUIREMENTS.md`, phase directories, plans, summaries, and research
+- Maps phases → slices, plans → tasks, milestones → milestones
+- Preserves completion state (`[x]` phases stay done, summaries carry over)
+- Consolidates research files into the new structure
+- Shows a preview before writing anything
+- Optionally runs an agent-driven review of the output for quality assurance
+
+Supports format variations including milestone-sectioned roadmaps with `<details>` blocks, bold phase entries, bullet-format requirements, decimal phase numbering, and duplicate phase numbers across milestones.
+
 ---
 
 ## How It Works
@@ -187,6 +209,7 @@ On first run, GSD prompts for optional API keys (Brave Search, Context7, Jina) f
 | `/gsd status` | Progress dashboard |
 | `/gsd queue` | Queue future milestones (safe during auto mode) |
 | `/gsd prefs` | Model selection, timeouts, budget ceiling |
+| `/gsd migrate` | Migrate a v1 `.planning` directory to `.gsd` format |
 | `/gsd doctor` | Validate `.gsd/` integrity, find and fix issues |
 | `Ctrl+Alt+G` | Toggle dashboard overlay |
 

package/dist/cli.js

@@ -7,18 +7,19 @@ loadStoredEnvKeys(authStorage);
 await runWizardIfNeeded(authStorage);
 const modelRegistry = new ModelRegistry(authStorage);
 const settingsManager = SettingsManager.create(agentDir);
-// Always ensure defaults: anthropic/claude-sonnet-4-6, thinking off.
-// Validates on every startup — catches stale settings from prior installs
+// Validate configured model on startup — catches stale settings from prior installs
 // (e.g. grok-2 which no longer exists) and fresh installs with no settings.
+// Only resets the default when the configured model no longer exists in the registry;
+// never overwrites a valid user choice.
 const configuredProvider = settingsManager.getDefaultProvider();
 const configuredModel = settingsManager.getDefaultModel();
 const allModels = modelRegistry.getAll();
 const configuredExists = configuredProvider && configuredModel &&
     allModels.some((m) => m.provider === configuredProvider && m.id === configuredModel);
 if (!configuredModel || !configuredExists) {
-    // Preferred default: anthropic/claude-sonnet-4-6
-    const preferred = allModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-sonnet-4-6') ||
-        allModels.find((m) => m.provider === 'anthropic' && m.id.includes('sonnet')) ||
+    // Fallback: pick the best available Anthropic model
+    const preferred = allModels.find((m) => m.provider === 'anthropic' && m.id === 'claude-opus-4-6') ||
+        allModels.find((m) => m.provider === 'anthropic' && m.id.includes('opus')) ||
         allModels.find((m) => m.provider === 'anthropic');
     if (preferred) {
         settingsManager.setDefaultModelAndProvider(preferred.provider, preferred.id);
@@ -52,5 +53,46 @@ if (extensionsResult.errors.length > 0) {
         process.stderr.write(`[gsd] Extension load error: ${err.error}\n`);
     }
 }
+// Restore scoped models from settings on startup.
+// The upstream InteractiveMode reads enabledModels from settings when /scoped-models is opened,
+// but doesn't apply them to the session at startup — so Ctrl+P cycles all models instead of
+// just the saved selection until the user re-runs /scoped-models.
+const enabledModelPatterns = settingsManager.getEnabledModels();
+if (enabledModelPatterns && enabledModelPatterns.length > 0) {
+    const availableModels = modelRegistry.getAvailable();
+    const scopedModels = [];
+    const seen = new Set();
+    for (const pattern of enabledModelPatterns) {
+        // Patterns are "provider/modelId" exact strings saved by /scoped-models
+        const slashIdx = pattern.indexOf('/');
+        if (slashIdx !== -1) {
+            const provider = pattern.substring(0, slashIdx);
+            const modelId = pattern.substring(slashIdx + 1);
+            const model = availableModels.find((m) => m.provider === provider && m.id === modelId);
+            if (model) {
+                const key = `${model.provider}/${model.id}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    scopedModels.push({ model });
+                }
+            }
+        }
+        else {
+            // Fallback: match by model id alone
+            const model = availableModels.find((m) => m.id === pattern);
+            if (model) {
+                const key = `${model.provider}/${model.id}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    scopedModels.push({ model });
+                }
+            }
+        }
+    }
+    // Only apply if we resolved some models and it's a genuine subset
+    if (scopedModels.length > 0 && scopedModels.length < availableModels.length) {
+        session.setScopedModels(scopedModels);
+    }
+}
 const interactiveMode = new InteractiveMode(session);
 await interactiveMode.run();

package/dist/wizard.js

@@ -75,7 +75,7 @@ export function loadStoredEnvKeys(authStorage) {
     for (const [provider, envVar] of providers) {
         if (!process.env[envVar]) {
             const cred = authStorage.get(provider);
-            if (cred?.type === 'api_key') {
+            if (cred?.type === 'api_key' && cred.key) {
                 process.env[envVar] = cred.key;
             }
         }
@@ -143,6 +143,7 @@ export async function runWizardIfNeeded(authStorage) {
             savedCount++;
         }
         else {
+            authStorage.set(key.provider, { type: 'api_key', key: '' });
             process.stdout.write(`  ${dim}↷  ${key.label} skipped${reset}\n\n`);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "GSD — Get Stuff Done coding agent",
   "license": "MIT",
   "repository": {

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

@@ -30,6 +30,7 @@ import {
   filterDoctorIssues,
 } from "./doctor.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { handleMigrate } from "./migrate/command.js";
 
 function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportText: string, structuredIssues: string): void {
   const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
@@ -51,10 +52,10 @@ function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportT
 
 export function registerGSDCommand(pi: ExtensionAPI): void {
   pi.registerCommand("gsd", {
-    description: "GSD — Get Stuff Done: /gsd auto|stop|status|queue|prefs|doctor",
+    description: "GSD — Get Stuff Done: /gsd auto|stop|status|queue|prefs|doctor|migrate",
 
     getArgumentCompletions: (prefix: string) => {
-      const subcommands = ["auto", "stop", "status", "queue", "discuss", "prefs", "doctor"];
+      const subcommands = ["auto", "stop", "status", "queue", "discuss", "prefs", "doctor", "migrate"];
       const parts = prefix.trim().split(/\s+/);
 
       if (parts.length <= 1) {
@@ -136,13 +137,18 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
         return;
       }
 
+      if (trimmed === "migrate" || trimmed.startsWith("migrate ")) {
+        await handleMigrate(trimmed.replace(/^migrate\s*/, "").trim(), ctx, pi);
+        return;
+      }
+
       if (trimmed === "") {
         await showSmartEntry(ctx, pi, process.cwd());
         return;
       }
 
       ctx.ui.notify(
-        `Unknown: /gsd ${trimmed}. Use /gsd, /gsd auto, /gsd stop, /gsd status, /gsd queue, /gsd discuss, /gsd prefs [global|project|status], or /gsd doctor [audit|fix|heal] [M###/S##].`,
+        `Unknown: /gsd ${trimmed}. Use /gsd, /gsd auto, /gsd stop, /gsd status, /gsd queue, /gsd discuss, /gsd prefs [global|project|status], /gsd doctor [audit|fix|heal] [M###/S##], or /gsd migrate <path>.`,
         "warning",
       );
     },

package/src/resources/extensions/gsd/dashboard-overlay.ts

@@ -17,6 +17,7 @@ import {
   aggregateByModel, formatCost, formatTokenCount, formatCostProjection,
 } from "./metrics.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { getActiveWorktreeName } from "./worktree-command.js";
 
 function formatDuration(ms: number): string {
   const s = Math.floor(ms / 1000);
@@ -273,8 +274,12 @@ export class GSDDashboardOverlay {
       : this.dashData.paused
         ? th.fg("warning", "⏸ PAUSED")
         : th.fg("dim", "idle");
+    const worktreeName = getActiveWorktreeName();
+    const worktreeTag = worktreeName
+      ? `  ${th.fg("warning", `⎇ ${worktreeName}`)}`
+      : "";
     const elapsed = th.fg("dim", formatDuration(this.dashData.elapsed));
-    lines.push(row(joinColumns(`${title}  ${status}`, elapsed, contentWidth)));
+    lines.push(row(joinColumns(`${title}  ${status}${worktreeTag}`, elapsed, contentWidth)));
     lines.push(blank());
 
     if (this.dashData.currentUnit) {

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

@@ -21,7 +21,7 @@ import type {
  * Split markdown content into frontmatter (YAML-like) and body.
  * Returns [frontmatterLines, body] where frontmatterLines is null if no frontmatter.
  */
-function splitFrontmatter(content: string): [string[] | null, string] {
+export function splitFrontmatter(content: string): [string[] | null, string] {
   const trimmed = content.trimStart();
   if (!trimmed.startsWith('---')) return [null, content];
 
@@ -42,7 +42,7 @@ function splitFrontmatter(content: string): [string[] | null, string] {
  * Handles simple scalars and arrays (lines starting with "  - ").
  * Handles nested objects like requires (lines with "    key: value").
  */
-function parseFrontmatterMap(lines: string[]): Record<string, unknown> {
+export function parseFrontmatterMap(lines: string[]): Record<string, unknown> {
   const result: Record<string, unknown> = {};
   let currentKey: string | null = null;
   let currentArray: unknown[] | null = null;
@@ -124,7 +124,7 @@ function parseFrontmatterMap(lines: string[]): Record<string, unknown> {
 }
 
 /** Extract the text after a heading at a given level, up to the next heading of same or higher level. */
-function extractSection(body: string, heading: string, level: number = 2): string | null {
+export function extractSection(body: string, heading: string, level: number = 2): string | null {
   const prefix = '#'.repeat(level) + ' ';
   const regex = new RegExp(`^${prefix}${escapeRegex(heading)}\\s*$`, 'm');
   const match = regex.exec(body);
@@ -140,7 +140,7 @@ function extractSection(body: string, heading: string, level: number = 2): strin
 }
 
 /** Extract all sections at a given level, returning heading → content map. */
-function extractAllSections(body: string, level: number = 2): Map<string, string> {
+export function extractAllSections(body: string, level: number = 2): Map<string, string> {
   const prefix = '#'.repeat(level) + ' ';
   const regex = new RegExp(`^${prefix}(.+)$`, 'gm');
   const sections = new Map<string, string>();
@@ -161,14 +161,14 @@ function escapeRegex(s: string): string {
 }
 
 /** Parse bullet list items from a text block. */
-function parseBullets(text: string): string[] {
+export function parseBullets(text: string): string[] {
   return text.split('\n')
     .map(l => l.replace(/^\s*[-*]\s+/, '').trim())
     .filter(l => l.length > 0 && !l.startsWith('#'));
 }
 
 /** Extract key: value from bold-prefixed lines like "**Key:** Value" */
-function extractBoldField(text: string, key: string): string | null {
+export function extractBoldField(text: string, key: string): string | null {
   const regex = new RegExp(`^\\*\\*${escapeRegex(key)}:\\*\\*\\s*(.+)$`, 'm');
   const match = regex.exec(text);
   return match ? match[1].trim() : null;
@@ -548,7 +548,7 @@ export function parseRequirementCounts(content: string | null): RequirementCount
   for (const section of sections) {
     const text = extractSection(content, section.heading, 2);
     if (!text) continue;
-    const matches = text.match(/^###\s+R\d+\s+—/gm);
+    const matches = text.match(/^###\s+[A-Z][\w-]*\d+\s+—/gm);
     counts[section.key] = matches ? matches.length : 0;
   }
 

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

@@ -17,6 +17,7 @@ const BASELINE_PATTERNS = [
   // ── GSD runtime (not source artifacts) ──
   ".gsd/activity/",
   ".gsd/runtime/",
+  ".gsd/worktrees/",
   ".gsd/auto.lock",
   ".gsd/metrics.json",
   ".gsd/STATE.md",

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

@@ -22,8 +22,10 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
+import { createBashTool } from "@mariozechner/pi-coding-agent";
 
 import { registerGSDCommand } from "./commands.js";
+import { registerWorktreeCommand, getWorktreeOriginalCwd, getActiveWorktreeName } from "./worktree-command.js";
 import { saveFile, formatContinue, loadFile, parseContinue, parseSummary } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { deriveState } from "./state.js";
@@ -59,6 +61,16 @@ const GSD_LOGO_LINES = [
 
 export default function (pi: ExtensionAPI) {
   registerGSDCommand(pi);
+  registerWorktreeCommand(pi);
+
+  // ── Dynamic-cwd bash tool ──────────────────────────────────────────────
+  // The built-in bash tool captures cwd at startup. This replacement uses
+  // a spawnHook to read process.cwd() dynamically so that process.chdir()
+  // (used by /worktree switch) propagates to shell commands.
+  const dynamicBash = createBashTool(process.cwd(), {
+    spawnHook: (ctx) => ({ ...ctx, cwd: process.cwd() }),
+  });
+  pi.registerTool(dynamicBash as any);
 
   // ── session_start: render branded GSD header ───────────────────────────
   pi.on("session_start", async (_event, ctx) => {
@@ -131,8 +143,31 @@ export default function (pi: ExtensionAPI) {
 
     const injection = await buildGuidedExecuteContextInjection(event.prompt, process.cwd());
 
+    // Worktree context — override the static CWD in the system prompt
+    let worktreeBlock = "";
+    const worktreeName = getActiveWorktreeName();
+    const worktreeMainCwd = getWorktreeOriginalCwd();
+    if (worktreeName && worktreeMainCwd) {
+      worktreeBlock = [
+        "",
+        "",
+        "[WORKTREE CONTEXT — OVERRIDES CURRENT WORKING DIRECTORY ABOVE]",
+        `IMPORTANT: Ignore the "Current working directory" shown earlier in this prompt.`,
+        `The actual current working directory is: ${process.cwd()}`,
+        "",
+        `You are working inside a GSD worktree.`,
+        `- Worktree name: ${worktreeName}`,
+        `- Worktree path (this is the real cwd): ${process.cwd()}`,
+        `- Main project: ${worktreeMainCwd}`,
+        `- Branch: worktree/${worktreeName}`,
+        "",
+        "All file operations, bash commands, and GSD state resolve against the worktree path above.",
+        "Use /worktree merge to merge changes back. Use /worktree return to switch back to the main tree.",
+      ].join("\n");
+    }
+
     return {
-      systemPrompt: `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${newSkillsBlock}`,
+      systemPrompt: `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${newSkillsBlock}${worktreeBlock}`,
       ...(injection
         ? {
           message: {

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

@@ -0,0 +1,215 @@
+/**
+ * /gsd migrate — one-shot migration from .planning to .gsd
+ *
+ * Thin UX orchestrator: resolves paths, runs the validate → parse → transform →
+ * preview → write pipeline, and shows confirmation UI via showNextAction.
+ * All business logic lives in the pipeline modules (S01–S03).
+ *
+ * After a successful write, offers an agent-driven review that audits the
+ * output for GSD-2 standards compliance.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { showNextAction } from "../../shared/next-action-ui.js";
+import {
+  validatePlanningDirectory,
+  parsePlanningDirectory,
+  transformToGSD,
+  generatePreview,
+  writeGSDDirectory,
+} from "./index.js";
+
+import type { MigrationPreview } from "./writer.js";
+
+/** Format preview stats for embedding in the review prompt. */
+function formatPreviewStats(preview: MigrationPreview): string {
+  const lines = [
+    `- Milestones: ${preview.milestoneCount}`,
+    `- Slices: ${preview.totalSlices} (${preview.doneSlices} done — ${preview.sliceCompletionPct}%)`,
+    `- Tasks: ${preview.totalTasks} (${preview.doneTasks} done — ${preview.taskCompletionPct}%)`,
+  ];
+  if (preview.requirements.total > 0) {
+    lines.push(
+      `- Requirements: ${preview.requirements.total} (${preview.requirements.validated} validated, ${preview.requirements.active} active, ${preview.requirements.deferred} deferred)`,
+    );
+  }
+  return lines.join("\n");
+}
+
+/** Load and interpolate the review-migration prompt template. */
+function buildReviewPrompt(
+  sourcePath: string,
+  gsdPath: string,
+  preview: MigrationPreview,
+): string {
+  const promptsDir = join(dirname(fileURLToPath(import.meta.url)), "..", "prompts");
+  const templatePath = join(promptsDir, "review-migration.md");
+  let content = readFileSync(templatePath, "utf-8");
+
+  content = content.replaceAll("{{sourcePath}}", sourcePath);
+  content = content.replaceAll("{{gsdPath}}", gsdPath);
+  content = content.replaceAll("{{previewStats}}", formatPreviewStats(preview));
+
+  return content.trim();
+}
+
+/** Dispatch the review prompt to the agent. */
+function dispatchReview(
+  pi: ExtensionAPI,
+  sourcePath: string,
+  gsdPath: string,
+  preview: MigrationPreview,
+): void {
+  const prompt = buildReviewPrompt(sourcePath, gsdPath, preview);
+
+  pi.sendMessage(
+    {
+      customType: "gsd-migrate-review",
+      content: prompt,
+      display: false,
+    },
+    { triggerTurn: true },
+  );
+}
+
+export async function handleMigrate(
+  args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  // ── Resolve source path ────────────────────────────────────────────────────
+  // 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));
+  } else if (rawPath === "~") {
+    rawPath = process.env.HOME ?? "~";
+  }
+
+  let sourcePath = resolve(process.cwd(), rawPath);
+  if (!sourcePath.endsWith(".planning")) {
+    sourcePath = join(sourcePath, ".planning");
+  }
+
+  if (!existsSync(sourcePath)) {
+    ctx.ui.notify(
+      `Directory not found: ${sourcePath}\n\nMake sure the path points to a project root with a .planning directory.`,
+      "error",
+    );
+    return;
+  }
+
+  // ── Validate ───────────────────────────────────────────────────────────────
+  const validation = await validatePlanningDirectory(sourcePath);
+
+  const warnings = validation.issues.filter((i) => i.severity === "warning");
+  const fatals = validation.issues.filter((i) => i.severity === "fatal");
+
+  for (const w of warnings) {
+    ctx.ui.notify(`⚠ ${w.message} (${w.file})`, "warning");
+  }
+  for (const f of fatals) {
+    ctx.ui.notify(`✖ ${f.message} (${f.file})`, "error");
+  }
+
+  if (!validation.valid) {
+    ctx.ui.notify(
+      "Migration blocked — fix the fatal issues above before retrying.",
+      "error",
+    );
+    return;
+  }
+
+  // ── Parse → Transform → Preview ───────────────────────────────────────────
+  const parsed = await parsePlanningDirectory(sourcePath);
+  const project = transformToGSD(parsed);
+  const preview = generatePreview(project);
+
+  // ── Build preview text ─────────────────────────────────────────────────────
+  const lines: string[] = [
+    `Milestones: ${preview.milestoneCount}`,
+    `Slices: ${preview.totalSlices} (${preview.doneSlices} done — ${preview.sliceCompletionPct}%)`,
+    `Tasks: ${preview.totalTasks} (${preview.doneTasks} done — ${preview.taskCompletionPct}%)`,
+  ];
+
+  if (preview.requirements.total > 0) {
+    lines.push(
+      `Requirements: ${preview.requirements.total} (${preview.requirements.validated} validated, ${preview.requirements.active} active, ${preview.requirements.deferred} deferred)`,
+    );
+  }
+
+  const targetGsdExists = existsSync(join(process.cwd(), ".gsd"));
+  if (targetGsdExists) {
+    lines.push("");
+    lines.push("⚠ A .gsd directory already exists in the current working directory — it will be overwritten.");
+  }
+
+  // ── Confirmation via showNextAction ────────────────────────────────────────
+  const choice = await showNextAction(ctx as any, {
+    title: "Migration preview",
+    summary: lines,
+    actions: [
+      {
+        id: "confirm",
+        label: "Write .gsd directory",
+        description: `Migrate ${preview.milestoneCount} milestone(s) to ${process.cwd()}/.gsd`,
+        recommended: true,
+      },
+      {
+        id: "cancel",
+        label: "Cancel",
+        description: "Exit without writing anything",
+      },
+    ],
+    notYetMessage: "Run /gsd migrate again when ready.",
+  });
+
+  if (choice !== "confirm") {
+    ctx.ui.notify("Migration cancelled — no files were written.", "info");
+    return;
+  }
+
+  // ── Write ──────────────────────────────────────────────────────────────────
+  ctx.ui.notify("Writing .gsd directory…", "info");
+
+  const result = await writeGSDDirectory(project, process.cwd());
+  const gsdPath = join(process.cwd(), ".gsd");
+
+  ctx.ui.notify(
+    `✓ Migration complete — ${result.paths.length} file(s) written to .gsd/`,
+    "info",
+  );
+
+  // ── Post-write review offer ────────────────────────────────────────────────
+  const reviewChoice = await showNextAction(ctx as any, {
+    title: "Migration written",
+    summary: [
+      `${result.paths.length} files written to .gsd/`,
+      "",
+      "The agent can now review the migrated output against GSD-2 standards —",
+      "checking structure, content quality, deriveState() round-trip, and",
+      "requirement statuses. It will fix minor issues in-place.",
+    ],
+    actions: [
+      {
+        id: "review",
+        label: "Review migration",
+        description: "Agent audits the .gsd output and reports PASS/FAIL per category",
+        recommended: true,
+      },
+      {
+        id: "skip",
+        label: "Skip review",
+        description: "Trust the migration output as-is",
+      },
+    ],
+    notYetMessage: "Run /gsd migrate again to re-migrate, or review .gsd manually.",
+  });
+
+  if (reviewChoice === "review") {
+    dispatchReview(pi, sourcePath, gsdPath, preview);
+  }
+}

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

@@ -0,0 +1,42 @@
+// Barrel export for old .planning migration module
+
+export { handleMigrate } from './command.ts';
+export { parsePlanningDirectory } from './parser.ts';
+export { validatePlanningDirectory } from './validator.ts';
+export { transformToGSD } from './transformer.ts';
+export { writeGSDDirectory } from './writer.ts';
+export type { WrittenFiles, MigrationPreview } from './writer.ts';
+export { generatePreview } from './preview.ts';
+export type {
+  // Input types (old .planning format)
+  PlanningProject,
+  PlanningPhase,
+  PlanningPlan,
+  PlanningPlanFrontmatter,
+  PlanningPlanMustHaves,
+  PlanningSummary,
+  PlanningSummaryFrontmatter,
+  PlanningSummaryRequires,
+  PlanningRoadmap,
+  PlanningRoadmapMilestone,
+  PlanningRoadmapEntry,
+  PlanningRequirement,
+  PlanningResearch,
+  PlanningConfig,
+  PlanningQuickTask,
+  PlanningMilestone,
+  PlanningState,
+  PlanningPhaseFile,
+  ValidationResult,
+  ValidationIssue,
+  ValidationSeverity,
+  // Output types (GSD-2 format)
+  GSDProject,
+  GSDMilestone,
+  GSDSlice,
+  GSDTask,
+  GSDRequirement,
+  GSDSliceSummaryData,
+  GSDTaskSummaryData,
+  GSDBoundaryEntry,
+} from './types.ts';