gsd-pi 2.8.3 → 2.10.0

package/src/resources/extensions/gsd/git-service.ts

@@ -9,7 +9,8 @@
  */
 
 import { execSync } from "node:child_process";
-import { sep } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, sep } from "node:path";
 
 import {
   detectWorktreeName,
@@ -68,6 +69,86 @@ export const RUNTIME_EXCLUSION_PATHS: readonly string[] = [
   ".gsd/STATE.md",
 ];
 
+// ─── Integration Branch Metadata ───────────────────────────────────────────
+
+/**
+ * Path to the milestone metadata file that stores the integration branch.
+ * Format: .gsd/milestones/<MID>/<MID>-META.json
+ */
+function milestoneMetaPath(basePath: string, milestoneId: string): string {
+  return join(basePath, ".gsd", "milestones", milestoneId, `${milestoneId}-META.json`);
+}
+
+/**
+ * Read the integration branch recorded for a milestone.
+ * Returns null if no metadata file exists or the branch isn't set.
+ */
+export function readIntegrationBranch(basePath: string, milestoneId: string): string | null {
+  try {
+    const metaFile = milestoneMetaPath(basePath, milestoneId);
+    if (!existsSync(metaFile)) return null;
+    const data = JSON.parse(readFileSync(metaFile, "utf-8"));
+    const branch = data?.integrationBranch;
+    if (typeof branch === "string" && branch.trim() !== "" && VALID_BRANCH_NAME.test(branch)) {
+      return branch;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist the integration branch for a milestone.
+ *
+ * Called once when auto-mode starts on a milestone. Records the branch
+ * the user was on at that point, so that slice branches merge back to it
+ * instead of the repo's default branch.
+ *
+ * The file is committed immediately so it survives branch switches — the
+ * pre-switch auto-commit excludes `.gsd/` to avoid merge conflicts, and
+ * uncommitted `.gsd/` files are discarded during checkout.
+ *
+ * Skips writing if an integration branch is already recorded (idempotent
+ * across restarts) or if the current branch is already a GSD slice branch.
+ */
+export function writeIntegrationBranch(basePath: string, milestoneId: string, branch: string): void {
+  // Don't record slice branches as the integration target
+  if (SLICE_BRANCH_RE.test(branch)) return;
+  // Don't overwrite an existing integration branch
+  if (readIntegrationBranch(basePath, milestoneId) !== null) return;
+  // Validate
+  if (!VALID_BRANCH_NAME.test(branch)) return;
+
+  const metaFile = milestoneMetaPath(basePath, milestoneId);
+  mkdirSync(join(basePath, ".gsd", "milestones", milestoneId), { recursive: true });
+
+  // Merge with existing metadata if present
+  let existing: Record<string, unknown> = {};
+  try {
+    if (existsSync(metaFile)) {
+      existing = JSON.parse(readFileSync(metaFile, "utf-8"));
+    }
+  } catch { /* corrupt file — overwrite */ }
+
+  existing.integrationBranch = branch;
+  writeFileSync(metaFile, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+
+  // Commit immediately — .gsd/ files are discarded during branch switches
+  // (ensureSliceBranch excludes .gsd/ from pre-switch auto-commit and runs
+  // git checkout -- .gsd/ to prevent checkout conflicts). Without this
+  // commit, the metadata would be lost on the first branch switch.
+  try {
+    runGit(basePath, ["add", "--force", metaFile]);
+    runGit(basePath, ["commit", "-F", "-"], {
+      input: `chore(${milestoneId}): record integration branch`,
+    });
+  } catch {
+    // Non-fatal — file is on disk even if commit fails (e.g. nothing to commit
+    // because the file was already tracked with identical content)
+  }
+}
+
 // ─── Git Helper ────────────────────────────────────────────────────────────
 
 /**
@@ -115,11 +196,23 @@ export class GitServiceImpl {
   readonly basePath: string;
   readonly prefs: GitPreferences;
 
+  /** Active milestone ID — used to resolve the integration branch. */
+  private _milestoneId: string | null = null;
+
   constructor(basePath: string, prefs: GitPreferences = {}) {
     this.basePath = basePath;
     this.prefs = prefs;
   }
 
+  /**
+   * Set the active milestone ID for integration branch resolution.
+   * When set, getMainBranch() will check the milestone's metadata file
+   * for a recorded integration branch before falling back to repo defaults.
+   */
+  setMilestoneId(milestoneId: string | null): void {
+    this._milestoneId = milestoneId;
+  }
+
   /** Convenience wrapper: run git in this repo's basePath. */
   private git(args: string[], options: { allowFailure?: boolean; input?: string } = {}): string {
     return runGit(this.basePath, args, options);
@@ -212,9 +305,18 @@ export class GitServiceImpl {
   // ─── Branch Queries ────────────────────────────────────────────────────
 
   /**
-   * Get the "main" branch for this repo.
-   * In a worktree: returns worktree/<name> (the worktree's base branch).
-   * In the main tree: origin/HEAD symbolic-ref → main/master fallback → current branch.
+   * Get the "main" (integration) branch for this repo.
+   *
+   * Resolution order:
+   * 1. Explicit `main_branch` preference (user override, highest priority)
+   * 2. Milestone integration branch from metadata file (recorded at milestone start)
+   * 3. Worktree base branch (worktree/<name>)
+   * 4. origin/HEAD symbolic-ref → main/master fallback → current branch
+   *
+   * The integration branch (step 2) is what makes feature-branch workflows
+   * work correctly: when a user starts GSD on `f-123-new-thing`, that branch
+   * is recorded as the integration target, and all slice branches merge back
+   * to it instead of the repo's default branch.
    */
   getMainBranch(): string {
     // Explicit preference takes priority (double-check validity as defense-in-depth)
@@ -222,6 +324,16 @@ export class GitServiceImpl {
       return this.prefs.main_branch;
     }
 
+    // Check milestone integration branch — recorded when auto-mode starts
+    if (this._milestoneId) {
+      const integrationBranch = readIntegrationBranch(this.basePath, this._milestoneId);
+      if (integrationBranch) {
+        // Verify the branch still exists locally (could have been deleted)
+        const exists = this.git(["show-ref", "--verify", `refs/heads/${integrationBranch}`], { allowFailure: true });
+        if (exists) return integrationBranch;
+      }
+    }
+
     const wtName = detectWorktreeName(this.basePath);
     if (wtName) {
       const wtBranch = `worktree/${wtName}`;
@@ -537,6 +649,18 @@ export class GitServiceImpl {
       this.git(["commit", "-m", "chore: untrack .gsd/ runtime files before merge"], { allowFailure: true });
     }
 
+    // Also untrack runtime files from the slice branch to prevent
+    // modify/delete conflicts during squash-merge (#218)
+    this.git(["checkout", branch]);
+    for (const exclusion of RUNTIME_EXCLUSION_PATHS) {
+      this.git(["rm", "--cached", "-r", "--ignore-unmatch", exclusion], { allowFailure: true });
+    }
+    const branchUntrackDiff = this.git(["diff", "--cached", "--stat"], { allowFailure: true });
+    if (branchUntrackDiff?.trim()) {
+      this.git(["commit", "-m", "chore: untrack .gsd/ runtime files before merge"], { allowFailure: true });
+    }
+    this.git(["checkout", mainBranch]);
+
     // Merge slice branch — strategy is configurable via git.merge_strategy
     // preference. Default: "squash" (preserves existing behavior).
     // "merge" uses --no-ff which is more resilient to conflicts from
@@ -559,7 +683,7 @@ export class GitServiceImpl {
         if (allRuntime) {
           // Runtime-only conflicts: take ours and remove from index
           for (const f of conflictedFiles) {
-            this.git(["checkout", "--ours", "--", f], { allowFailure: true });
+            this.git(["checkout", "--theirs", "--", f], { allowFailure: true });
             this.git(["rm", "--cached", "--ignore-unmatch", f], { allowFailure: true });
           }
           this.git(["add", "-A"], { allowFailure: true });

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

@@ -112,6 +112,19 @@ function findMilestoneIds(basePath: string): string[] {
   }
 }
 
+/** Return the highest numeric suffix among milestone IDs (0 when the list is empty or has no numeric IDs). */
+export function maxMilestoneNum(milestoneIds: string[]): number {
+  return milestoneIds.reduce((max, id) => {
+    const num = parseInt(id.replace(/^M/, ""), 10);
+    return num > max ? num : max;
+  }, 0);
+}
+
+/** Derive the next milestone ID from existing IDs using max-based approach to avoid collisions after deletions. */
+export function nextMilestoneId(milestoneIds: string[]): string {
+  return `M${String(maxMilestoneNum(milestoneIds) + 1).padStart(3, "0")}`;
+}
+
 // ─── Queue ─────────────────────────────────────────────────────────────────────
 
 /**
@@ -153,12 +166,9 @@ export async function showQueue(
   const existingContext = await buildExistingMilestonesContext(basePath, milestoneIds, state);
 
   // ── Determine next milestone ID ─────────────────────────────────────
-  const maxNum = milestoneIds.reduce((max, id) => {
-    const num = parseInt(id.replace(/^M/, ""), 10);
-    return num > max ? num : max;
-  }, 0);
-  const nextId = `M${String(maxNum + 1).padStart(3, "0")}`;
-  const nextIdPlus1 = `M${String(maxNum + 2).padStart(3, "0")}`;
+  const max = maxMilestoneNum(milestoneIds);
+  const nextId = `M${String(max + 1).padStart(3, "0")}`;
+  const nextIdPlus1 = `M${String(max + 2).padStart(3, "0")}`;
 
   // ── Build preamble ──────────────────────────────────────────────────
   const activePart = state.activeMilestone
@@ -508,7 +518,7 @@ export async function showSmartEntry(
     }
 
     const milestoneIds = findMilestoneIds(basePath);
-    const nextId = `M${String(milestoneIds.length + 1).padStart(3, "0")}`;
+    const nextId = nextMilestoneId(milestoneIds);
     const isFirst = milestoneIds.length === 0;
 
     if (isFirst) {
@@ -570,7 +580,7 @@ export async function showSmartEntry(
 
     if (choice === "new_milestone") {
       const milestoneIds = findMilestoneIds(basePath);
-      const nextId = `M${String(milestoneIds.length + 1).padStart(3, "0")}`;
+      const nextId = nextMilestoneId(milestoneIds);
 
       pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
       dispatchWorkflow(pi, buildDiscussPrompt(nextId,
@@ -638,7 +648,7 @@ export async function showSmartEntry(
         }));
       } else if (choice === "skip_milestone") {
         const milestoneIds = findMilestoneIds(basePath);
-        const nextId = `M${String(milestoneIds.length + 1).padStart(3, "0")}`;
+        const nextId = nextMilestoneId(milestoneIds);
         pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
         dispatchWorkflow(pi, buildDiscussPrompt(nextId,
           `New milestone ${nextId}.`,

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

@@ -127,7 +127,7 @@ export default function (pi: ExtensionAPI) {
         ...params,
         timeout: params.timeout ?? DEFAULT_BASH_TIMEOUT_SECS,
       };
-      return baseBash.execute(toolCallId, paramsWithTimeout, signal, onUpdate, ctx);
+      return (baseBash as any).execute(toolCallId, paramsWithTimeout, signal, onUpdate, ctx);
     },
   };
   pi.registerTool(dynamicBash as any);
@@ -148,7 +148,7 @@ export default function (pi: ExtensionAPI) {
       ctx?: any,
     ) => {
       const fresh = createWriteTool(process.cwd());
-      return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
+      return (fresh as any).execute(toolCallId, params, signal, onUpdate, ctx);
     },
   };
   pi.registerTool(dynamicWrite as any);
@@ -164,7 +164,7 @@ export default function (pi: ExtensionAPI) {
       ctx?: any,
     ) => {
       const fresh = createReadTool(process.cwd());
-      return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
+      return (fresh as any).execute(toolCallId, params, signal, onUpdate, ctx);
     },
   };
   pi.registerTool(dynamicRead as any);
@@ -180,7 +180,7 @@ export default function (pi: ExtensionAPI) {
       ctx?: any,
     ) => {
       const fresh = createEditTool(process.cwd());
-      return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
+      return (fresh as any).execute(toolCallId, params, signal, onUpdate, ctx);
     },
   };
   pi.registerTool(dynamicEdit as any);
@@ -325,14 +325,24 @@ export default function (pi: ExtensionAPI) {
     // If auto-mode is already running, advance to next unit
     if (!isAutoActive()) return;
 
-    // If the agent was aborted (user pressed Escape), pause auto-mode
-    // instead of advancing. This preserves the conversation so the user
-    // can inspect what happened, interact with the agent, or resume.
+    // If the agent was aborted (user pressed Escape) or hit a provider
+    // error (fetch failure, rate limit, etc.), pause auto-mode instead of
+    // advancing. This preserves the conversation so the user can inspect
+    // what happened, interact with the agent, or resume.
     const lastMsg = event.messages[event.messages.length - 1];
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
       await pauseAuto(ctx, pi);
       return;
     }
+    if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
+      const errorDetail =
+        "errorMessage" in lastMsg && lastMsg.errorMessage
+          ? `: ${lastMsg.errorMessage}`
+          : "";
+      (ctx as any).log(`Auto-mode paused due to provider error${errorDetail}`);
+      await pauseAuto(ctx, pi);
+      return;
+    }
 
     await handleAgentEnd(ctx, pi);
   });

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

@@ -625,7 +625,7 @@ function validatePreferences(preferences: GSDPreferences): {
       }
       const validatedRule: GSDSkillRule = { when };
       for (const action of SKILL_ACTIONS) {
-        const values = normalizeStringList((rule as Record<string, unknown>)[action]);
+        const values = normalizeStringList((rule as unknown as Record<string, unknown>)[action]);
         if (values.length > 0) {
           validatedRule[action as keyof GSDSkillRule] = values as never;
         }

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -9,6 +9,8 @@ import {
   RUNTIME_EXCLUSION_PATHS,
   VALID_BRANCH_NAME,
   runGit,
+  readIntegrationBranch,
+  writeIntegrationBranch,
   type GitPreferences,
   type CommitOptions,
   type MergeSliceResult,
@@ -1370,6 +1372,230 @@ async function main(): Promise<void> {
     assert(true, "PreMergeCheckResult type exported and usable");
   }
 
+  // ═══════════════════════════════════════════════════════════════════════
+  // Integration branch — feature-branch workflow support
+  // ═══════════════════════════════════════════════════════════════════════
+
+  // ─── writeIntegrationBranch / readIntegrationBranch: round-trip ────────
+
+  console.log("\n=== Integration branch: write and read ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    // Initially no integration branch
+    assertEq(readIntegrationBranch(repo, "M001"), null, "readIntegrationBranch returns null when no metadata");
+
+    // Write integration branch
+    writeIntegrationBranch(repo, "M001", "f-123-new-thing");
+    assertEq(readIntegrationBranch(repo, "M001"), "f-123-new-thing", "readIntegrationBranch returns written branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── writeIntegrationBranch: idempotent — doesn't overwrite ───────────
+
+  console.log("\n=== Integration branch: idempotent write ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    writeIntegrationBranch(repo, "M001", "f-123-first");
+    writeIntegrationBranch(repo, "M001", "f-456-second"); // should NOT overwrite
+
+    assertEq(readIntegrationBranch(repo, "M001"), "f-123-first", "second write does not overwrite existing integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── writeIntegrationBranch: rejects slice branches ───────────────────
+
+  console.log("\n=== Integration branch: rejects slice branches ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    writeIntegrationBranch(repo, "M001", "gsd/M001/S01");
+    assertEq(readIntegrationBranch(repo, "M001"), null, "slice branches are not recorded as integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── writeIntegrationBranch: rejects invalid branch names ─────────────
+
+  console.log("\n=== Integration branch: rejects invalid names ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    writeIntegrationBranch(repo, "M001", "bad; rm -rf /");
+    assertEq(readIntegrationBranch(repo, "M001"), null, "invalid branch name is not recorded");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── getMainBranch: uses integration branch when milestone set ────────
+
+  console.log("\n=== getMainBranch: integration branch from milestone metadata ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    // Create a feature branch
+    run("git checkout -b f-123-feature", repo);
+    run("git checkout main", repo);
+
+    // Write integration branch metadata
+    writeIntegrationBranch(repo, "M001", "f-123-feature");
+
+    // Without milestone set, getMainBranch returns "main"
+    const svc = new GitServiceImpl(repo);
+    assertEq(svc.getMainBranch(), "main", "getMainBranch returns main when no milestone set");
+
+    // With milestone set, getMainBranch returns the integration branch
+    svc.setMilestoneId("M001");
+    assertEq(svc.getMainBranch(), "f-123-feature", "getMainBranch returns integration branch when milestone set");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── getMainBranch: main_branch pref still takes priority ─────────────
+
+  console.log("\n=== getMainBranch: main_branch pref overrides integration branch ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    run("git checkout -b f-123-feature", repo);
+    run("git checkout -b trunk", repo);
+    run("git checkout main", repo);
+
+    writeIntegrationBranch(repo, "M001", "f-123-feature");
+
+    // Explicit preference still wins
+    const svc = new GitServiceImpl(repo, { main_branch: "trunk" });
+    svc.setMilestoneId("M001");
+    assertEq(svc.getMainBranch(), "trunk", "main_branch preference overrides integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── getMainBranch: falls back when integration branch deleted ────────
+
+  console.log("\n=== getMainBranch: fallback when integration branch deleted ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    // Write metadata pointing to a branch that doesn't exist
+    writeIntegrationBranch(repo, "M001", "deleted-branch");
+
+    const svc = new GitServiceImpl(repo);
+    svc.setMilestoneId("M001");
+    assertEq(svc.getMainBranch(), "main", "getMainBranch falls back to main when integration branch no longer exists");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── End-to-end: feature branch workflow ──────────────────────────────
+
+  console.log("\n=== End-to-end: feature branch workflow ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    // Simulate: user creates feature branch and starts GSD
+    run("git checkout -b f-123-new-thing", repo);
+    createFile(repo, "setup.txt", "initial setup");
+    run("git add -A", repo);
+    run("git commit -m 'initial feature setup'", repo);
+
+    // Record integration branch (this is what auto.ts does at startup)
+    writeIntegrationBranch(repo, "M001", "f-123-new-thing");
+
+    // Create GitServiceImpl with milestone set
+    const svc = new GitServiceImpl(repo);
+    svc.setMilestoneId("M001");
+
+    // Verify getMainBranch returns the feature branch, not "main"
+    assertEq(svc.getMainBranch(), "f-123-new-thing", "e2e: getMainBranch returns feature branch");
+
+    // Create slice branch — should branch from f-123-new-thing (current)
+    svc.ensureSliceBranch("M001", "S01");
+    assertEq(svc.getCurrentBranch(), "gsd/M001/S01", "e2e: slice branch created");
+
+    // The slice branch should have the feature branch's commit
+    const log = run("git log --oneline", repo);
+    assert(log.includes("initial feature setup"), "e2e: slice branch inherits feature branch content");
+
+    // Do work on the slice branch
+    createFile(repo, "src/feature.ts", "export const feature = true;");
+    svc.commit({ message: "feat: add feature module" });
+
+    // switchToMain should go to feature branch
+    svc.switchToMain();
+    assertEq(svc.getCurrentBranch(), "f-123-new-thing", "e2e: switchToMain goes to feature branch, not main");
+
+    // mergeSliceToMain should merge into feature branch
+    const result = svc.mergeSliceToMain("M001", "S01", "Add feature module");
+    assertEq(result.mergedCommitMessage, "feat(M001/S01): Add feature module", "e2e: merge commit message correct");
+    assertEq(svc.getCurrentBranch(), "f-123-new-thing", "e2e: after merge, still on feature branch");
+
+    // The feature branch should have the merged work
+    const files = run("git ls-files", repo);
+    assert(files.includes("src/feature.ts"), "e2e: merged file exists on feature branch");
+
+    // Main should NOT have the merged work
+    run("git checkout main", repo);
+    const mainFiles = run("git ls-files", repo);
+    assert(!mainFiles.includes("src/feature.ts"), "e2e: main does NOT have merged work — it stays on the feature branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── Per-milestone isolation: different milestones, different targets ──
+
+  console.log("\n=== Integration branch: per-milestone isolation ===");
+
+  {
+    const repo = initBranchTestRepo();
+
+    run("git checkout -b feature-a", repo);
+    run("git checkout -b feature-b", repo);
+    run("git checkout main", repo);
+
+    writeIntegrationBranch(repo, "M001", "feature-a");
+    writeIntegrationBranch(repo, "M002", "feature-b");
+
+    const svc = new GitServiceImpl(repo);
+
+    svc.setMilestoneId("M001");
+    assertEq(svc.getMainBranch(), "feature-a", "M001 integration branch is feature-a");
+
+    svc.setMilestoneId("M002");
+    assertEq(svc.getMainBranch(), "feature-b", "M002 integration branch is feature-b");
+
+    svc.setMilestoneId(null);
+    assertEq(svc.getMainBranch(), "main", "no milestone set → falls back to main");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── Backward compatibility: no metadata → existing behavior ──────────
+
+  console.log("\n=== Integration branch: backward compat ===");
+
+  {
+    const repo = initBranchTestRepo();
+    const svc = new GitServiceImpl(repo);
+
+    // Set milestone but no metadata file exists
+    svc.setMilestoneId("M001");
+    assertEq(svc.getMainBranch(), "main", "backward compat: no metadata file → falls back to main");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
   // ─── untrackRuntimeFiles: removes tracked runtime files from index ───
 
   console.log("\n=== untrackRuntimeFiles ===");

package/src/resources/extensions/gsd/tests/migrate-command.test.ts

@@ -354,8 +354,8 @@ async function main(): Promise<void> {
       assert(state.phase !== undefined, 'pipeline: deriveState returns phase');
       assert(state.activeMilestone !== null, 'pipeline: deriveState has activeMilestone');
       assertEq(state.activeMilestone!.id, 'M001', 'pipeline: deriveState activeMilestone is M001');
-      assert(state.progress.slices !== undefined, 'pipeline: deriveState has slices progress');
-      assert(state.progress.tasks !== undefined, 'pipeline: deriveState has tasks progress');
+      assert(state.progress!.slices !== undefined, 'pipeline: deriveState has slices progress');
+      assert(state.progress!.tasks !== undefined, 'pipeline: deriveState has tasks progress');
 
     } finally {
       rmSync(base, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/migrate-transformer.test.ts

@@ -317,7 +317,7 @@ function makeResearch(fileName: string, content: string): PlanningResearch {
   assertEq(doneSlice?.tasks[0]?.summary?.duration, '2h', 'completion: summary duration from frontmatter');
   assertEq(doneSlice?.tasks[0]?.summary?.provides, ['feature-01'], 'completion: summary provides from frontmatter');
   assertEq(doneSlice?.tasks[0]?.summary?.keyFiles, ['file-01.ts'], 'completion: summary keyFiles from frontmatter');
-  assert(doneSlice?.tasks[0]?.summary?.whatHappened?.includes('Summary body'), 'completion: summary whatHappened from body');
+  assert(doneSlice?.tasks[0]?.summary?.whatHappened?.includes('Summary body') ?? false, 'completion: summary whatHappened from body');
   assert(doneSlice?.summary !== null, 'completion: done slice has slice summary');
   assert(activeSlice?.summary === null, 'completion: active slice has null summary');
   assertEq(doneSlice?.tasks[0]?.estimate, '2h', 'completion: task estimate from summary duration');

package/src/resources/extensions/gsd/tests/migrate-writer-integration.test.ts

@@ -234,18 +234,18 @@ async function main(): Promise<void> {
       assertEq(state.activeSlice!.id, 'S02', 'incomplete: deriveState activeSlice is S02');
       assert(state.activeTask !== null, 'incomplete: deriveState has activeTask');
       assertEq(state.activeTask!.id, 'T03', 'incomplete: deriveState activeTask is T03');
-      assert(state.progress.slices !== undefined, 'incomplete: deriveState has slices progress');
-      assertEq(state.progress.slices!.done, 1, 'incomplete: deriveState slices done count');
-      assertEq(state.progress.slices!.total, 2, 'incomplete: deriveState slices total count');
-      assert(state.progress.tasks !== undefined, 'incomplete: deriveState has tasks progress');
+      assert(state.progress!.slices !== undefined, 'incomplete: deriveState has slices progress');
+      assertEq(state.progress!.slices!.done, 1, 'incomplete: deriveState slices done count');
+      assertEq(state.progress!.slices!.total, 2, 'incomplete: deriveState slices total count');
+      assert(state.progress!.tasks !== undefined, 'incomplete: deriveState has tasks progress');
       // S02 has 1 task, 0 done (only active slice tasks counted)
-      assertEq(state.progress.tasks!.done, 0, 'incomplete: deriveState tasks done (in active slice)');
-      assertEq(state.progress.tasks!.total, 1, 'incomplete: deriveState tasks total (in active slice)');
+      assertEq(state.progress!.tasks!.done, 0, 'incomplete: deriveState tasks done (in active slice)');
+      assertEq(state.progress!.tasks!.total, 1, 'incomplete: deriveState tasks total (in active slice)');
       // Requirements
-      assertEq(state.requirements.active, 1, 'incomplete: deriveState requirements active');
-      assertEq(state.requirements.validated, 1, 'incomplete: deriveState requirements validated');
-      assertEq(state.requirements.deferred, 1, 'incomplete: deriveState requirements deferred');
-      assertEq(state.requirements.outOfScope, 1, 'incomplete: deriveState requirements outOfScope');
+      assertEq(state.requirements!.active, 1, 'incomplete: deriveState requirements active');
+      assertEq(state.requirements!.validated, 1, 'incomplete: deriveState requirements validated');
+      assertEq(state.requirements!.deferred, 1, 'incomplete: deriveState requirements deferred');
+      assertEq(state.requirements!.outOfScope, 1, 'incomplete: deriveState requirements outOfScope');
 
       // (f) generatePreview
       console.log('  --- generatePreview ---');