gsd-pi 2.33.1-dev.9bafd68 → 2.33.1-dev.c0b2610

package/packages/pi-coding-agent/src/core/agent-session.ts

@@ -1359,6 +1359,15 @@ export class AgentSession {
 		this.abortRetry();
 		this.agent.abort();
 		await this.agent.waitForIdle();
+		// Ensure agent_end is emitted even when abort interrupts a tool call (#1414).
+		// The agent may go idle without emitting agent_end if the abort happens
+		// between tool execution and response processing.
+		if (!this.isStreaming && this._extensionRunner) {
+			await this._extensionRunner.emit({
+				type: "agent_end",
+				messages: this.agent.state.messages,
+			});
+		}
 	}
 
 	/**

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -162,6 +162,77 @@ export function syncGsdStateToWorktree(mainBasePath: string, worktreePath_: stri
   return { synced };
 }
 
+/**
+ * Sync milestone artifacts from worktree back to the main external state directory.
+ * Called before milestone merge to ensure completion artifacts (SUMMARY, VALIDATION,
+ * updated ROADMAP) are visible from the project root (#1412).
+ *
+ * Only syncs .gsd/milestones/ content — root-level files (DECISIONS, REQUIREMENTS, etc.)
+ * are handled by the merge itself.
+ */
+export function syncWorktreeStateBack(mainBasePath: string, worktreePath: string, milestoneId: string): { synced: string[] } {
+  const mainGsd = gsdRoot(mainBasePath);
+  const wtGsd = gsdRoot(worktreePath);
+  const synced: string[] = [];
+
+  // If both resolve to the same directory (symlink), no sync needed
+  try {
+    const mainResolved = realpathSync(mainGsd);
+    const wtResolved = realpathSync(wtGsd);
+    if (mainResolved === wtResolved) return { synced };
+  } catch {
+    // Can't resolve — proceed with sync
+  }
+
+  const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
+  const mainMilestoneDir = join(mainGsd, "milestones", milestoneId);
+
+  if (!existsSync(wtMilestoneDir)) return { synced };
+  mkdirSync(mainMilestoneDir, { recursive: true });
+
+  // Sync milestone-level files (SUMMARY, VALIDATION, ROADMAP, CONTEXT)
+  try {
+    for (const entry of readdirSync(wtMilestoneDir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const src = join(wtMilestoneDir, entry.name);
+        const dst = join(mainMilestoneDir, entry.name);
+        try {
+          cpSync(src, dst, { force: true });
+          synced.push(`milestones/${milestoneId}/${entry.name}`);
+        } catch { /* non-fatal */ }
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  // Sync slice-level files (summaries, UATs)
+  const wtSlicesDir = join(wtMilestoneDir, "slices");
+  const mainSlicesDir = join(mainMilestoneDir, "slices");
+  if (existsSync(wtSlicesDir)) {
+    try {
+      for (const sliceEntry of readdirSync(wtSlicesDir, { withFileTypes: true })) {
+        if (!sliceEntry.isDirectory()) continue;
+        const sid = sliceEntry.name;
+        const wtSliceDir = join(wtSlicesDir, sid);
+        const mainSliceDir = join(mainSlicesDir, sid);
+        mkdirSync(mainSliceDir, { recursive: true });
+
+        for (const fileEntry of readdirSync(wtSliceDir, { withFileTypes: true })) {
+          if (fileEntry.isFile() && fileEntry.name.endsWith(".md")) {
+            const src = join(wtSliceDir, fileEntry.name);
+            const dst = join(mainSliceDir, fileEntry.name);
+            try {
+              cpSync(src, dst, { force: true });
+              synced.push(`milestones/${milestoneId}/slices/${sid}/${fileEntry.name}`);
+            } catch { /* non-fatal */ }
+          }
+        }
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  return { synced };
+}
+
 // ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
 
 /**

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

@@ -131,6 +131,7 @@ import {
   getAutoWorktreeOriginalBase,
   mergeMilestoneToMain,
   autoWorktreeBranch,
+  syncWorktreeStateBack,
 } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { consumeSignal } from "./session-status-io.js";
@@ -377,6 +378,16 @@ function tryMergeMilestone(ctx: ExtensionContext, milestoneId: string, mode: "tr
   // Worktree merge path
   if (isInAutoWorktree(s.basePath) && s.originalBasePath) {
     try {
+      // Sync completion artifacts from worktree → external state before merge (#1412)
+      try {
+        const { synced } = syncWorktreeStateBack(s.originalBasePath, s.basePath, milestoneId);
+        if (synced.length > 0) {
+          debugLog("worktree-reverse-sync", { milestoneId, synced: synced.length });
+        }
+      } catch (syncErr) {
+        debugLog("worktree-reverse-sync-failed", { milestoneId, error: getErrorMessage(syncErr) });
+      }
+
       const roadmapPath = resolveMilestoneFile(s.originalBasePath, milestoneId, "ROADMAP");
       if (!roadmapPath) {
         teardownAutoWorktree(s.originalBasePath, milestoneId);

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -13,8 +13,8 @@ function run(command: string, cwd: string): string {
 }
 
 async function main(): Promise<void> {
-  const base = mkdtempSync(join(tmpdir(), "gsd-repo-identity-"));
-  const stateDir = mkdtempSync(join(tmpdir(), "gsd-state-"));
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-repo-identity-")));
+  const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-")));
 
   try {
     process.env.GSD_STATE_DIR = stateDir;
@@ -38,7 +38,7 @@ async function main(): Promise<void> {
     assertEq(worktreeState, expectedExternalState, "worktree symlink target matches main repo external state dir");
     assertTrue(existsSync(join(worktreePath, ".gsd")), "worktree .gsd exists");
     assertTrue(lstatSync(join(worktreePath, ".gsd")).isSymbolicLink(), "worktree .gsd is a symlink");
-    assertEq(realpathSync(join(worktreePath, ".gsd")), expectedExternalState, "worktree .gsd symlink resolves to main repo external state dir");
+    assertEq(realpathSync(join(worktreePath, ".gsd")), realpathSync(expectedExternalState), "worktree .gsd symlink resolves to main repo external state dir");
 
     console.log("\n=== ensureGsdSymlink heals stale worktree symlinks ===");
     const staleState = join(stateDir, "projects", "stale-worktree-state");
@@ -47,7 +47,7 @@ async function main(): Promise<void> {
     symlinkSync(staleState, join(worktreePath, ".gsd"), "junction");
     const healedState = ensureGsdSymlink(worktreePath);
     assertEq(healedState, expectedExternalState, "stale worktree symlink is repaired to canonical external state dir");
-    assertEq(realpathSync(join(worktreePath, ".gsd")), expectedExternalState, "healed worktree symlink resolves to canonical external state dir");
+    assertEq(realpathSync(join(worktreePath, ".gsd")), realpathSync(expectedExternalState), "healed worktree symlink resolves to canonical external state dir");
 
     console.log("\n=== ensureGsdSymlink preserves worktree .gsd directories ===");
     rmSync(join(worktreePath, ".gsd"), { recursive: true, force: true });