@opengsd/gsd-pi 1.1.1-dev.75048e7 → 1.1.1-dev.9f86580

package/src/resources/extensions/gsd/unit-tool-contracts.ts

@@ -52,8 +52,14 @@ export const UNIT_TOOL_CONTRACTS: Record<string, UnitToolSurfaceContract> = {
     requiredWorkflowTools: ["gsd_summary_save"],
   },
   "plan-milestone": {
-    allowedGsdTools: ["gsd_plan_milestone", "gsd_decision_save", "gsd_requirement_update"],
-    requiredWorkflowTools: ["gsd_plan_milestone"],
+    allowedGsdTools: [
+      "gsd_milestone_status",
+      "gsd_plan_milestone",
+      "gsd_plan_slice",
+      "gsd_decision_save",
+      "gsd_requirement_update",
+    ],
+    requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice"],
   },
   "discuss-milestone": {
     allowedGsdTools: [
@@ -77,27 +83,38 @@ export const UNIT_TOOL_CONTRACTS: Record<string, UnitToolSurfaceContract> = {
     requiredWorkflowTools: ["gsd_summary_save"],
   },
   "validate-milestone": {
-    allowedGsdTools: ["gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],
+    allowedGsdTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],
     requiredWorkflowTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap"],
   },
   "complete-milestone": {
-    allowedGsdTools: ["gsd_complete_milestone", "subagent"],
-    requiredWorkflowTools: ["gsd_milestone_status", "gsd_complete_milestone"],
+    allowedGsdTools: [
+      "gsd_milestone_status",
+      "gsd_requirement_update",
+      "gsd_summary_save",
+      "gsd_complete_milestone",
+      "subagent",
+    ],
+    requiredWorkflowTools: [
+      "gsd_milestone_status",
+      "gsd_requirement_update",
+      "gsd_summary_save",
+      "gsd_complete_milestone",
+    ],
   },
   "research-slice": {
     allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
     requiredWorkflowTools: ["gsd_summary_save"],
   },
   "plan-slice": {
-    allowedGsdTools: ["gsd_plan_slice", "gsd_plan_task", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_plan_slice"],
+    allowedGsdTools: ["gsd_plan_slice", "gsd_reassess_roadmap", "gsd_decision_save"],
+    requiredWorkflowTools: ["gsd_plan_slice", "gsd_reassess_roadmap"],
   },
   "refine-slice": {
-    allowedGsdTools: ["gsd_plan_slice", "gsd_plan_task", "gsd_decision_save"],
-    requiredWorkflowTools: [],
+    allowedGsdTools: ["gsd_plan_slice", "gsd_decision_save"],
+    requiredWorkflowTools: ["gsd_plan_slice"],
   },
   "replan-slice": {
-    allowedGsdTools: ["gsd_replan_slice", "gsd_plan_task", "gsd_decision_save"],
+    allowedGsdTools: ["gsd_replan_slice", "gsd_decision_save"],
     requiredWorkflowTools: ["gsd_replan_slice"],
   },
   "complete-slice": {
@@ -107,15 +124,22 @@ export const UNIT_TOOL_CONTRACTS: Record<string, UnitToolSurfaceContract> = {
       "gsd_replan_slice",
       "gsd_decision_save",
       "gsd_requirement_update",
+      "gsd_summary_save",
       "subagent",
     ],
-    requiredWorkflowTools: ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice"],
+    requiredWorkflowTools: [
+      "gsd_slice_complete",
+      "gsd_task_reopen",
+      "gsd_replan_slice",
+      "gsd_requirement_update",
+      "gsd_summary_save",
+    ],
     forbiddenGsdTools: {
       gsd_uat_result_save: "Run UAT owns persisted UAT Assessment.",
     },
   },
   "reassess-roadmap": {
-    allowedGsdTools: ["gsd_reassess_roadmap"],
+    allowedGsdTools: ["gsd_milestone_status", "gsd_reassess_roadmap"],
     requiredWorkflowTools: ["gsd_milestone_status", "gsd_reassess_roadmap"],
   },
   "execute-task": {
@@ -127,8 +151,8 @@ export const UNIT_TOOL_CONTRACTS: Record<string, UnitToolSurfaceContract> = {
     requiredWorkflowTools: ["gsd_task_complete"],
   },
   "reactive-execute": {
-    allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_task_complete"],
+    allowedGsdTools: ["gsd_task_complete", "gsd_summary_save", "gsd_decision_save"],
+    requiredWorkflowTools: ["gsd_task_complete", "gsd_summary_save"],
   },
   "run-uat": {
     allowedGsdTools: [...RUN_UAT_WORKFLOW_TOOL_NAMES, "subagent"],

package/src/resources/extensions/gsd/workflow-mcp.ts

@@ -487,10 +487,9 @@ export function getWorkflowTransportSupportError(
   }
 
   const uniqueRequired = [...new Set(requiredTools)];
-  const piRuntimeRequired = uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
   const missing = (options.activeTools && options.activeTools.length > 0)
-    ? piRuntimeRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools!))
-    : piRuntimeRequired;
+    ? uniqueRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools!))
+    : uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
   if (missing.length === 0) return null;
 
   if (options.activeTools && options.activeTools.length > 0) {

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

@@ -259,6 +259,38 @@ export function resolveCanonicalMilestoneRoot(
   return wtPath;
 }
 
+/**
+ * Build human-facing guidance for manually validating a milestone's work.
+ *
+ * When a milestone runs in a git worktree, its checkout lives under the hidden
+ * `.gsd/worktrees/<MID>/` path that a human can't easily discover. The UAT
+ * pause/handoff and the saved assessment use this to tell the human exactly
+ * where to `cd` to run or inspect the app before signing off on NEEDS-HUMAN
+ * checks, rather than leaving them to hunt for a buried path.
+ *
+ * Returns null when no milestone id is available.
+ */
+export function buildManualValidationGuidance(
+  basePath: string,
+  milestoneId: string,
+  opts: { uatPath?: string } = {},
+): string | null {
+  if (!milestoneId) return null;
+  const validationRoot = resolveCanonicalMilestoneRoot(basePath, milestoneId);
+  const inWorktree = validationRoot.includes(`${sep}.gsd${sep}worktrees${sep}`);
+  const lines: string[] = [`Validate the work here: ${validationRoot}`];
+  if (inWorktree) {
+    lines.push(
+      "This milestone runs in a git worktree, so the code lives under the hidden " +
+        `\`.gsd/worktrees/\` path. Open it with: cd "${validationRoot}"`,
+    );
+  }
+  if (opts.uatPath) {
+    lines.push(`Follow the UAT checklist at: ${opts.uatPath}`);
+  }
+  return lines.join("\n");
+}
+
 // ─── Core Operations ───────────────────────────────────────────────────────
 
 /**

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

@@ -0,0 +1,103 @@
+// Project/App: gsd-pi
+// File Purpose: Deterministically re-enter the active milestone's worktree on a
+// cold start (after /quit + relaunch). Without this, Claude Code relaunches with
+// cwd at the project root, and a bare /gsd leaves the agent there — forcing it to
+// search the filesystem ("git worktree list", branch sniffing) to find its way
+// back into the worktree. The worktree path is fully derivable from state, so we
+// resolve and chdir into it directly instead.
+
+import { readdirSync } from "node:fs";
+
+import { enterAutoWorktree, getAutoWorktreePath } from "./auto-worktree.js";
+import { getIsolationMode } from "./preferences.js";
+import { worktreesDir } from "./worktree-manager.js";
+import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";
+
+interface LiveWorktree {
+  id: string;
+  path: string;
+}
+
+/**
+ * Enumerate the live (valid git) auto-worktrees under <projectRoot>/.gsd/worktrees/.
+ * Reuses getAutoWorktreePath's validation so stray directories are ignored.
+ */
+function liveMilestoneWorktrees(projectRoot: string): LiveWorktree[] {
+  let names: string[];
+  try {
+    names = readdirSync(worktreesDir(projectRoot));
+  } catch {
+    return [];
+  }
+  const live: LiveWorktree[] = [];
+  for (const id of names) {
+    const path = getAutoWorktreePath(projectRoot, id);
+    if (path) live.push({ id, path });
+  }
+  return live;
+}
+
+/**
+ * If we're sitting at the project root with worktree isolation enabled and the
+ * active milestone has a live worktree, chdir into it. No-op when already inside
+ * a worktree, when isolation is off, or when the target is ambiguous.
+ *
+ * Single live worktree → enter it (covers the common case without deriveState).
+ * Multiple live worktrees → disambiguate by the active milestone from state;
+ * if that can't be resolved unambiguously, do nothing.
+ *
+ * Best-effort: any failure resolves to a no-op so it can never block startup.
+ *
+ * @returns the worktree path entered, or null when nothing was done.
+ */
+export async function reenterActiveWorktreeIfNeeded(
+  basePath: string,
+  opts: { notify?: (message: string) => void } = {},
+): Promise<string | null> {
+  let projectRoot: string;
+  try {
+    projectRoot = resolveWorktreeProjectRoot(basePath);
+  } catch {
+    return null;
+  }
+
+  // Only worktree-isolation projects have worktrees to re-enter.
+  if (getIsolationMode(projectRoot) !== "worktree") return null;
+
+  // Already inside a worktree (warm session, or auto-mode already entered) —
+  // nothing to do.
+  let cwd: string;
+  try {
+    cwd = process.cwd();
+  } catch {
+    return null;
+  }
+  if (isGsdWorktreePath(cwd)) return null;
+
+  const live = liveMilestoneWorktrees(projectRoot);
+  if (live.length === 0) return null;
+
+  let target: LiveWorktree | null = live.length === 1 ? live[0]! : null;
+  if (!target) {
+    // Multiple live worktrees — disambiguate by the active milestone.
+    try {
+      const { deriveState } = await import("./state.js");
+      const state = await deriveState(projectRoot);
+      const activeId = state.activeMilestone?.id;
+      target = activeId ? live.find((w) => w.id === activeId) ?? null : null;
+    } catch {
+      target = null;
+    }
+  }
+  if (!target) return null;
+
+  try {
+    const entered = enterAutoWorktree(projectRoot, target.id);
+    opts.notify?.(`Resumed in worktree for ${target.id}.`);
+    return entered;
+  } catch {
+    // Worktree vanished or chdir failed — leave cwd as-is, caller falls back to
+    // the project root.
+    return null;
+  }
+}

package/src/resources/extensions/shared/gsd-browser-cli.ts

@@ -140,6 +140,10 @@ export function resolveGsdBrowserMcpLaunchConfig(
     : null;
   const sessionName =
     options.sessionName?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot, options.sessionSuffix);
+  // Stable per-project identity key (no per-session suffix) so the browser
+  // profile/cookies persist across pi sessions for the same project. gsd-browser
+  // rejects --identity-scope unless --identity-key is also supplied.
+  const identityKey = env.GSD_BROWSER_IDENTITY_KEY?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot);
   const command =
     explicitCommand
     || explicitCliPath
@@ -155,6 +159,8 @@ export function resolveGsdBrowserMcpLaunchConfig(
         sessionName,
         "--identity-scope",
         "project",
+        "--identity-key",
+        identityKey,
         "--identity-project",
         resolvedProjectRoot,
       ];