gsd-pi 2.22.0 → 2.24.0

package/dist/resources/extensions/gsd/diff-context.ts

@@ -6,7 +6,7 @@
  * Standalone module: only imports node:child_process and node:path.
  */
 
-import { execFileSync } from "node:child_process";
+import { execFileSync, execFile } from "node:child_process";
 import { resolve } from "node:path";
 
 // ─── Types ──────────────────────────────────────────────────────────────────
@@ -32,10 +32,23 @@ const EXEC_OPTS = {
   stdio: ["pipe", "pipe", "pipe"] as ["pipe", "pipe", "pipe"],
 };
 
-function git(args: string[], cwd: string): string {
+/** Synchronous git — used where sequential control flow is required (fallback paths). */
+function gitSync(args: string[], cwd: string): string {
   return execFileSync("git", args, { ...EXEC_OPTS, cwd }).trim();
 }
 
+/** Async git — returns stdout on success, empty string on any error. */
+function gitAsync(args: string[], cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      args,
+      { encoding: "utf-8", timeout: 5000, cwd },
+      (err, stdout) => resolve(err ? "" : stdout.trim()),
+    );
+  });
+}
+
 function splitLines(output: string): string[] {
   return output
     .split("\n")
@@ -49,6 +62,8 @@ function splitLines(output: string): string[] {
  * Returns recently-changed file paths, deduplicated and sorted by recency
  * (most recent first). Combines committed diffs, staged changes, and
  * unstaged/untracked files from `git status`.
+ *
+ * The three git queries (log, diff --cached, status) run concurrently.
  */
 export async function getRecentlyChangedFiles(
   cwd: string,
@@ -59,40 +74,23 @@ export async function getRecentlyChangedFiles(
   const dir = resolve(cwd);
 
   try {
-    // 1. Committed changes in the last N commits (or since sinceDays)
-    let committedFiles: string[] = [];
-    try {
-      const days = Math.max(1, Math.floor(Number(sinceDays)));
-      if (!Number.isFinite(days)) throw new Error("invalid sinceDays");
-      const raw = git(["log", "--diff-filter=ACMR", "--name-only", "--pretty=format:", `--since=${days} days ago`], dir);
-      committedFiles = splitLines(raw);
-    } catch {
-      // Fallback: use HEAD~10
-      try {
-        const raw = git(["diff", "--name-only", "HEAD~10"], dir);
-        committedFiles = splitLines(raw);
-      } catch {
-        // Shallow clone or <10 commits — ignore
-      }
-    }
-
-    // 2. Staged changes
-    let stagedFiles: string[] = [];
-    try {
-      const raw = git(["diff", "--cached", "--name-only"], dir);
-      stagedFiles = splitLines(raw);
-    } catch {
-      // ignore
-    }
-
-    // 3. Unstaged / untracked via porcelain status
-    let statusFiles: string[] = [];
-    try {
-      const raw = git(["status", "--porcelain"], dir);
-      statusFiles = splitLines(raw).map((line) => line.slice(3)); // strip XY + space
-    } catch {
-      // ignore
-    }
+    const days = Math.max(1, Math.floor(Number(sinceDays)));
+    if (!Number.isFinite(days)) throw new Error("invalid sinceDays");
+
+    // Run all three queries concurrently — they read independent git state
+    const [logRaw, stagedRaw, statusRaw] = await Promise.all([
+      // 1. Committed changes since N days ago (fallback to HEAD~10 on error)
+      gitAsync(["log", "--diff-filter=ACMR", "--name-only", "--pretty=format:", `--since=${days} days ago`], dir)
+        .then((out) => out || gitAsync(["diff", "--name-only", "HEAD~10"], dir)),
+      // 2. Staged changes
+      gitAsync(["diff", "--cached", "--name-only"], dir),
+      // 3. Unstaged / untracked
+      gitAsync(["status", "--porcelain"], dir),
+    ]);
+
+    const committedFiles = splitLines(logRaw);
+    const stagedFiles = splitLines(stagedRaw);
+    const statusFiles = splitLines(statusRaw).map((line) => line.slice(3)); // strip XY + space
 
     // Deduplicate, preserving insertion order (most-recent-first: status → staged → committed)
     const seen = new Set<string>();
@@ -113,6 +111,9 @@ export async function getRecentlyChangedFiles(
 
 /**
  * Returns richer change metadata: change type and approximate line counts.
+ *
+ * The three git queries (diff --cached --numstat, diff --numstat, status --porcelain)
+ * run concurrently — they read independent git state.
  */
 export async function getChangedFilesWithContext(
   cwd: string,
@@ -120,6 +121,13 @@ export async function getChangedFilesWithContext(
   const dir = resolve(cwd);
 
   try {
+    // Run all three queries concurrently
+    const [cachedNumstat, unstagedNumstat, statusRaw] = await Promise.all([
+      gitAsync(["diff", "--cached", "--numstat"], dir),
+      gitAsync(["diff", "--numstat"], dir),
+      gitAsync(["status", "--porcelain"], dir),
+    ]);
+
     const result: ChangedFileInfo[] = [];
     const seen = new Set<string>();
 
@@ -131,57 +139,42 @@ export async function getChangedFilesWithContext(
     };
 
     // 1. Staged files with numstat
-    try {
-      const numstat = git(["diff", "--cached", "--numstat"], dir);
-      for (const line of splitLines(numstat)) {
-        const [added, deleted, filePath] = line.split("\t");
-        if (!filePath) continue;
-        const lines =
-          added === "-" || deleted === "-"
-            ? undefined
-            : Number(added) + Number(deleted);
-        add({ path: filePath, changeType: "staged", linesChanged: lines });
-      }
-    } catch {
-      // ignore
+    for (const line of splitLines(cachedNumstat)) {
+      const [added, deleted, filePath] = line.split("\t");
+      if (!filePath) continue;
+      const lines =
+        added === "-" || deleted === "-"
+          ? undefined
+          : Number(added) + Number(deleted);
+      add({ path: filePath, changeType: "staged", linesChanged: lines });
     }
 
     // 2. Unstaged modifications with numstat
-    try {
-      const numstat = git(["diff", "--numstat"], dir);
-      for (const line of splitLines(numstat)) {
-        const [added, deleted, filePath] = line.split("\t");
-        if (!filePath) continue;
-        const lines =
-          added === "-" || deleted === "-"
-            ? undefined
-            : Number(added) + Number(deleted);
-        add({ path: filePath, changeType: "modified", linesChanged: lines });
-      }
-    } catch {
-      // ignore
+    for (const line of splitLines(unstagedNumstat)) {
+      const [added, deleted, filePath] = line.split("\t");
+      if (!filePath) continue;
+      const lines =
+        added === "-" || deleted === "-"
+          ? undefined
+          : Number(added) + Number(deleted);
+      add({ path: filePath, changeType: "modified", linesChanged: lines });
     }
 
     // 3. Untracked / deleted from porcelain status
-    try {
-      const raw = git(["status", "--porcelain"], dir);
-      for (const line of splitLines(raw)) {
-        const code = line.slice(0, 2);
-        const filePath = line.slice(3);
-        if (seen.has(filePath)) continue;
-
-        if (code.includes("?")) {
-          add({ path: filePath, changeType: "added" });
-        } else if (code.includes("D")) {
-          add({ path: filePath, changeType: "deleted" });
-        } else if (code.includes("A")) {
-          add({ path: filePath, changeType: "added" });
-        } else {
-          add({ path: filePath, changeType: "modified" });
-        }
+    for (const line of splitLines(statusRaw)) {
+      const code = line.slice(0, 2);
+      const filePath = line.slice(3);
+      if (seen.has(filePath)) continue;
+
+      if (code.includes("?")) {
+        add({ path: filePath, changeType: "added" });
+      } else if (code.includes("D")) {
+        add({ path: filePath, changeType: "deleted" });
+      } else if (code.includes("A")) {
+        add({ path: filePath, changeType: "added" });
+      } else {
+        add({ path: filePath, changeType: "modified" });
       }
-    } catch {
-      // ignore
     }
 
     return result;

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

@@ -11,6 +11,7 @@ import { RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { nativeIsRepo, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached } from "./native-git-bridge.js";
 import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.js";
 import { ensureGitignore } from "./gitignore.js";
+import { readAllSessionStatuses, isSessionStale, removeSessionStatus } from "./session-status-io.js";
 
 export type DoctorSeverity = "info" | "warning" | "error";
 export type DoctorIssueCode =
@@ -24,6 +25,7 @@ export type DoctorIssueCode =
   | "all_tasks_done_roadmap_not_checked"
   | "slice_checked_missing_summary"
   | "slice_checked_missing_uat"
+  | "all_slices_done_missing_milestone_validation"
   | "all_slices_done_missing_milestone_summary"
   | "task_done_must_haves_not_verified"
   | "active_requirement_missing_owner"
@@ -36,12 +38,14 @@ export type DoctorIssueCode =
   | "tracked_runtime_files"
   | "legacy_slice_branches"
   | "stale_crash_lock"
+  | "stale_parallel_session"
   | "orphaned_completed_units"
   | "stale_hook_state"
   | "activity_log_bloat"
   | "state_file_stale"
   | "state_file_missing"
-  | "gitignore_missing_patterns";
+  | "gitignore_missing_patterns"
+  | "unresolvable_dependency";
 
 export interface DoctorIssue {
   severity: DoctorSeverity;
@@ -709,6 +713,31 @@ async function checkRuntimeHealth(
     // Non-fatal — crash lock check failed
   }
 
+  // ── Stale parallel sessions ────────────────────────────────────────────
+  try {
+    const parallelStatuses = readAllSessionStatuses(basePath);
+    for (const status of parallelStatuses) {
+      if (isSessionStale(status)) {
+        issues.push({
+          severity: "warning",
+          code: "stale_parallel_session",
+          scope: "project",
+          unitId: status.milestoneId,
+          message: `Stale parallel session for ${status.milestoneId} (PID ${status.pid}, started ${new Date(status.startedAt).toISOString()}, last heartbeat ${new Date(status.lastHeartbeat).toISOString()}) — process is no longer running`,
+          file: `.gsd/parallel/${status.milestoneId}.status.json`,
+          fixable: true,
+        });
+
+        if (shouldFix("stale_parallel_session")) {
+          removeSessionStatus(basePath, status.milestoneId);
+          fixesApplied.push(`cleaned up stale parallel session for ${status.milestoneId}`);
+        }
+      }
+    }
+  } catch {
+    // Non-fatal — parallel session check failed
+  }
+
   // ── Orphaned completed-units keys ─────────────────────────────────────
   try {
     const completedKeysFile = join(root, "completed-units.json");
@@ -1041,17 +1070,37 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
         });
       }
 
+      // Check for unresolvable dependency IDs — catches range syntax like "S01-S04"
+      // that the parser expanded but that don't match any actual slice in the roadmap.
+      // Also catches plain typos or IDs referencing slices not yet defined.
+      const knownSliceIds = new Set(roadmap.slices.map(s => s.id));
+      for (const dep of slice.depends) {
+        if (!knownSliceIds.has(dep)) {
+          issues.push({
+            severity: "warning",
+            code: "unresolvable_dependency",
+            scope: "slice",
+            unitId,
+            message: `Slice ${unitId} depends on "${dep}" which is not a slice ID in this roadmap. This permanently blocks the slice. Use comma-separated IDs: \`depends:[S01,S02]\``,
+            file: relMilestoneFile(basePath, milestoneId, "ROADMAP"),
+            fixable: false,
+          });
+        }
+      }
+
       const slicePath = resolveSlicePath(basePath, milestoneId, slice.id);
       if (!slicePath) continue;
 
       const tasksDir = resolveTasksDir(basePath, milestoneId, slice.id);
       if (!tasksDir) {
         issues.push({
-          severity: "error",
+          severity: slice.done ? "warning" : "error",
           code: "missing_tasks_dir",
           scope: "slice",
           unitId,
-          message: `Missing tasks directory for ${unitId}`,
+          message: slice.done
+            ? `Missing tasks directory for ${unitId} (slice is complete — cosmetic only)`
+            : `Missing tasks directory for ${unitId}`,
           file: relSlicePath(basePath, milestoneId, slice.id),
           fixable: true,
         });
@@ -1065,15 +1114,17 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
       const planContent = planPath ? await loadFile(planPath) : null;
       const plan = planContent ? parsePlan(planContent) : null;
       if (!plan) {
-        issues.push({
-          severity: "warning",
-          code: "missing_slice_plan",
-          scope: "slice",
-          unitId,
-          message: `Slice ${unitId} has no plan file`,
-          file: relSliceFile(basePath, milestoneId, slice.id, "PLAN"),
-          fixable: false,
-        });
+        if (!slice.done) {
+          issues.push({
+            severity: "warning",
+            code: "missing_slice_plan",
+            scope: "slice",
+            unitId,
+            message: `Slice ${unitId} has no plan file`,
+            file: relSliceFile(basePath, milestoneId, slice.id, "PLAN"),
+            fixable: false,
+          });
+        }
         continue;
       }
 
@@ -1236,6 +1287,19 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
       }
     }
 
+    // Milestone-level check: all slices done but no validation file
+    if (isMilestoneComplete(roadmap) && !resolveMilestoneFile(basePath, milestoneId, "VALIDATION") && !resolveMilestoneFile(basePath, milestoneId, "SUMMARY")) {
+      issues.push({
+        severity: "info",
+        code: "all_slices_done_missing_milestone_validation",
+        scope: "milestone",
+        unitId: milestoneId,
+        message: `All slices are done but ${milestoneId}-VALIDATION.md is missing — milestone is in validating-milestone phase`,
+        file: relMilestoneFile(basePath, milestoneId, "VALIDATION"),
+        fixable: false,
+      });
+    }
+
     // Milestone-level check: all slices done but no milestone summary
     if (isMilestoneComplete(roadmap) && !resolveMilestoneFile(basePath, milestoneId, "SUMMARY")) {
       issues.push({

package/dist/resources/extensions/gsd/exit-command.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 
-type StopAutoFn = (ctx: ExtensionCommandContext, pi: ExtensionAPI) => Promise<void>;
+type StopAutoFn = (ctx: ExtensionCommandContext, pi: ExtensionAPI, reason?: string) => Promise<void>;
 
 export function registerExitCommand(
   pi: ExtensionAPI,
@@ -11,7 +11,7 @@ export function registerExitCommand(
     handler: async (_args: string, ctx: ExtensionCommandContext) => {
       // Stop auto-mode first so locks and activity state are cleaned up before shutdown.
       const stopAuto = deps.stopAuto ?? (await import("./auto.js")).stopAuto;
-      await stopAuto(ctx, pi);
+      await stopAuto(ctx, pi, "Graceful exit");
       ctx.shutdown();
     },
   });

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

@@ -27,6 +27,7 @@ import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
 import { formatDuration } from "./history.js";
+import { getAutoWorktreePath } from "./auto-worktree.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -54,6 +55,7 @@ interface ForensicReport {
   basePath: string;
   activeMilestone: string | null;
   activeSlice: string | null;
+  activeWorktree: string | null;
   unitTraces: UnitTrace[];
   metrics: MetricsLedger | null;
   completedKeys: string[];
@@ -143,8 +145,11 @@ async function buildForensicReport(basePath: string): Promise<ForensicReport> {
     activeSlice = state.activeSlice?.id ?? null;
   } catch { /* state derivation failure is non-fatal */ }
 
-  // 2. Scan activity logs (last 5)
-  const unitTraces = scanActivityLogs(basePath);
+  // 1b. Check for active auto-worktree
+  const activeWorktree = activeMilestone ? getAutoWorktreePath(basePath, activeMilestone) : null;
+
+  // 2. Scan activity logs (last 5) — worktree-aware
+  const unitTraces = scanActivityLogs(basePath, activeMilestone);
 
   // 3. Load metrics
   const metrics = loadLedgerFromDisk(basePath);
@@ -178,20 +183,16 @@ async function buildForensicReport(basePath: string): Promise<ForensicReport> {
     }
   }
 
-  // 8. GSD version
-  let gsdVersion = "unknown";
-  try {
-    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "../../../../package.json");
-    if (existsSync(pkgPath)) {
-      gsdVersion = JSON.parse(readFileSync(pkgPath, "utf-8")).version ?? "unknown";
-    }
-  } catch { /* non-fatal */ }
+  // 8. GSD version — use GSD_VERSION env var set by the loader at startup.
+  // Extensions run from ~/.gsd/agent/extensions/gsd/ at runtime, so path-traversal
+  // from import.meta.url would resolve to ~/package.json (wrong on every system).
+  const gsdVersion = process.env.GSD_VERSION || "unknown";
 
   // 9. Run anomaly detectors
   if (metrics?.units) detectStuckLoops(metrics.units, anomalies);
   if (metrics?.units) detectCostSpikes(metrics.units, anomalies);
   detectTimeouts(unitTraces, anomalies);
-  detectMissingArtifacts(completedKeys, basePath, anomalies);
+  detectMissingArtifacts(completedKeys, basePath, activeMilestone, anomalies);
   detectCrash(crashLock, anomalies);
   detectDoctorIssues(doctorIssues, anomalies);
   detectErrorTraces(unitTraces, anomalies);
@@ -202,6 +203,7 @@ async function buildForensicReport(basePath: string): Promise<ForensicReport> {
     basePath,
     activeMilestone,
     activeSlice,
+    activeWorktree: activeWorktree ? relative(basePath, activeWorktree) : null,
     unitTraces,
     metrics,
     completedKeys,
@@ -216,48 +218,78 @@ async function buildForensicReport(basePath: string): Promise<ForensicReport> {
 
 const ACTIVITY_FILENAME_RE = /^(\d+)-(.+?)-(.+)\.jsonl$/;
 
-function scanActivityLogs(basePath: string): UnitTrace[] {
-  const activityDir = join(gsdRoot(basePath), "activity");
-  if (!existsSync(activityDir)) return [];
-
-  const files = readdirSync(activityDir).filter(f => f.endsWith(".jsonl")).sort();
-  const lastFiles = files.slice(-5);
-  const traces: UnitTrace[] = [];
-
-  for (const file of lastFiles) {
-    const match = ACTIVITY_FILENAME_RE.exec(file);
-    if (!match) continue;
-
-    const seq = parseInt(match[1]!, 10);
-    const unitType = match[2]!;
-    const unitId = match[3]!;
-    const filePath = join(activityDir, file);
-
-    let entries: unknown[] = [];
-    const nativeResult = nativeParseJsonlTail(filePath, MAX_JSONL_BYTES);
-    if (nativeResult) {
-      entries = nativeResult.entries;
-    } else {
-      try {
-        const raw = readFileSync(filePath, "utf-8");
-        entries = parseJSONL(raw);
-      } catch { continue; }
+function scanActivityLogs(basePath: string, activeMilestone?: string | null): UnitTrace[] {
+  const activityDirs = resolveActivityDirs(basePath, activeMilestone);
+  const allTraces: UnitTrace[] = [];
+
+  for (const activityDir of activityDirs) {
+    if (!existsSync(activityDir)) continue;
+
+    const files = readdirSync(activityDir).filter(f => f.endsWith(".jsonl")).sort();
+    const lastFiles = files.slice(-5);
+
+    for (const file of lastFiles) {
+      const match = ACTIVITY_FILENAME_RE.exec(file);
+      if (!match) continue;
+
+      const seq = parseInt(match[1]!, 10);
+      const unitType = match[2]!;
+      const unitId = match[3]!;
+      const filePath = join(activityDir, file);
+
+      let entries: unknown[] = [];
+      const nativeResult = nativeParseJsonlTail(filePath, MAX_JSONL_BYTES);
+      if (nativeResult) {
+        entries = nativeResult.entries;
+      } else {
+        try {
+          const raw = readFileSync(filePath, "utf-8");
+          entries = parseJSONL(raw);
+        } catch { continue; }
+      }
+
+      const trace = extractTrace(entries);
+      const stat = statSync(filePath, { throwIfNoEntry: false });
+
+      allTraces.push({
+        file: activityDirs.length > 1 ? `[${relative(basePath, activityDir)}] ${file}` : file,
+        unitType,
+        unitId,
+        seq,
+        trace,
+        mtime: stat?.mtimeMs ?? 0,
+      });
     }
+  }
 
-    const trace = extractTrace(entries);
-    const stat = statSync(filePath, { throwIfNoEntry: false });
-
-    traces.push({
-      file,
-      unitType,
-      unitId,
-      seq,
-      trace,
-      mtime: stat?.mtimeMs ?? 0,
-    });
+  // Sort by mtime descending so the most recent traces (regardless of source) come first
+  return allTraces.sort((a, b) => b.mtime - a.mtime).slice(0, 5);
+}
+
+/**
+ * Resolve activity directories to scan for forensics.
+ * If an active auto-worktree exists for the milestone, its activity dir
+ * is included first (preferred) so stale root logs don't mask worktree progress.
+ */
+function resolveActivityDirs(basePath: string, activeMilestone?: string | null): string[] {
+  const dirs: string[] = [];
+
+  // Check for active auto-worktree activity logs
+  if (activeMilestone) {
+    const wtPath = getAutoWorktreePath(basePath, activeMilestone);
+    if (wtPath) {
+      const wtActivityDir = join(wtPath, ".gsd", "activity");
+      if (existsSync(wtActivityDir)) {
+        dirs.push(wtActivityDir);
+      }
+    }
   }
 
-  return traces.sort((a, b) => b.seq - a.seq);
+  // Always include root activity logs
+  const rootActivityDir = join(gsdRoot(basePath), "activity");
+  dirs.push(rootActivityDir);
+
+  return dirs;
 }
 
 // ─── Completed Keys Loader ────────────────────────────────────────────────────
@@ -336,21 +368,27 @@ function detectTimeouts(traces: UnitTrace[], anomalies: ForensicAnomaly[]): void
   }
 }
 
-function detectMissingArtifacts(completedKeys: string[], basePath: string, anomalies: ForensicAnomaly[]): void {
+function detectMissingArtifacts(completedKeys: string[], basePath: string, activeMilestone: string | null, anomalies: ForensicAnomaly[]): void {
+  // Also check the worktree path for artifacts — they may exist there but not at root
+  const wtBasePath = activeMilestone ? getAutoWorktreePath(basePath, activeMilestone) : null;
+
   for (const key of completedKeys) {
     const slashIdx = key.indexOf("/");
     if (slashIdx === -1) continue;
     const unitType = key.slice(0, slashIdx);
     const unitId = key.slice(slashIdx + 1);
 
-    if (!verifyExpectedArtifact(unitType, unitId, basePath)) {
+    const rootHasArtifact = verifyExpectedArtifact(unitType, unitId, basePath);
+    const wtHasArtifact = wtBasePath ? verifyExpectedArtifact(unitType, unitId, wtBasePath) : false;
+
+    if (!rootHasArtifact && !wtHasArtifact) {
       anomalies.push({
         type: "missing-artifact",
         severity: "error",
         unitType,
         unitId,
         summary: `Completed key ${key} but artifact missing or invalid`,
-        details: `The unit is recorded as completed but verifyExpectedArtifact() returns false. The completion state is stale.`,
+        details: `The unit is recorded as completed but verifyExpectedArtifact() returns false at both project root and worktree. The completion state is stale.`,
       });
     }
   }
@@ -416,6 +454,7 @@ function saveForensicReport(basePath: string, report: ForensicReport, problemDes
     `**GSD Version:** ${report.gsdVersion}`,
     `**Active Milestone:** ${report.activeMilestone ?? "none"}`,
     `**Active Slice:** ${report.activeSlice ?? "none"}`,
+    `**Active Worktree:** ${report.activeWorktree ?? "none"}`,
     ``,
     `## Problem Description`,
     ``,
@@ -559,6 +598,10 @@ function formatReportForPrompt(report: ForensicReport): string {
   sections.push(`### GSD Version: ${report.gsdVersion}`);
   sections.push(`### Active Milestone: ${report.activeMilestone ?? "none"}`);
   sections.push(`### Active Slice: ${report.activeSlice ?? "none"}`);
+  if (report.activeWorktree) {
+    sections.push(`### Active Worktree: ${report.activeWorktree}`);
+    sections.push(`Note: Activity logs were scanned from both the worktree and the project root. Worktree logs take priority.`);
+  }
 
   let result = sections.join("\n");
   if (result.length > MAX_BYTES) {

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

@@ -19,6 +19,7 @@ const GSD_RUNTIME_PATTERNS = [
   ".gsd/forensics/",
   ".gsd/runtime/",
   ".gsd/worktrees/",
+  ".gsd/parallel/",
   ".gsd/auto.lock",
   ".gsd/metrics.json",
   ".gsd/completed-units.json",