@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/verdict-parser.ts

@@ -5,10 +5,9 @@
  * (e.g. `passed` → `pass`) are applied consistently across the codebase.
  */
 
-import { extractUatType } from "./files.js";
-import type { UatType } from "./files.js";
 import { splitFrontmatter, parseFrontmatterMap } from "../shared/frontmatter.js";
 import { parse as parseYaml } from "yaml";
+import { getDeclaredUatType, isPartialEligibleUatType, type UatType } from "./uat-policy.js";
 
 function normalizeVerdict(value: unknown): string | undefined {
   if (typeof value !== "string") return undefined;
@@ -103,12 +102,6 @@ export const UAT_ACCEPTABLE_VERDICTS: readonly string[] = ["pass", "passed"];
  * UAT types whose results may legitimately produce a `partial` verdict
  * when all automatable checks pass but human-only checks remain.
  */
-const PARTIAL_ELIGIBLE_UAT_TYPES: readonly UatType[] = [
-  "mixed",
-  "human-experience",
-  "live-runtime",
-];
-
 /**
  * Check whether a verdict is acceptable for a given UAT type.
  *
@@ -117,7 +110,7 @@ const PARTIAL_ELIGIBLE_UAT_TYPES: readonly UatType[] = [
  */
 export function isAcceptableUatVerdict(verdict: string, uatType: UatType | undefined): boolean {
   if (UAT_ACCEPTABLE_VERDICTS.includes(verdict)) return true;
-  if (verdict === "partial" && uatType && (PARTIAL_ELIGIBLE_UAT_TYPES as readonly string[]).includes(uatType)) {
+  if (verdict === "partial" && isPartialEligibleUatType(uatType)) {
     return true;
   }
   return false;
@@ -147,5 +140,5 @@ export function isValidMilestoneVerdict(verdict: string): verdict is ValidationV
  * the codebase when a UAT file lacks an explicit `## UAT Type` section.
  */
 export function getUatType(content: string): UatType {
-  return extractUatType(content) ?? "artifact-driven";
+  return getDeclaredUatType(content);
 }

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

@@ -6,24 +6,70 @@ import {
   readTransaction,
   restoreManifest,
 } from "./gsd-db.js";
-import type { MilestoneRow } from "./db-milestone-artifact-rows.js";
+import type { ArtifactRow, MilestoneRow } from "./db-milestone-artifact-rows.js";
 import type { SliceRow, TaskRow } from "./db-task-slice-rows.js";
 import type { VerificationEvidenceRow } from "./db-verification-evidence-rows.js";
-import type { Decision } from "./types.js";
+import type { Decision, GateRow, Requirement } from "./types.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { getAllDecisionsFromMemories } from "./context-store.js";
+import { backfillDecisionsToMemories } from "./memory-backfill.js";
+import { invalidateAllCaches } from "./cache.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 
 // ─── Manifest Types ──────────────────────────────────────────────────────
 
+export interface ManifestArtifactRow extends ArtifactRow {
+  content_hash: string | null;
+}
+
+export interface ReplanHistoryManifestRow {
+  id: number;
+  milestone_id: string;
+  slice_id: string | null;
+  task_id: string | null;
+  summary: string;
+  previous_artifact_path: string | null;
+  replacement_artifact_path: string | null;
+  created_at: string;
+}
+
+export interface AssessmentManifestRow {
+  path: string;
+  milestone_id: string;
+  slice_id: string | null;
+  task_id: string | null;
+  status: string;
+  scope: string;
+  full_content: string;
+  created_at: string;
+}
+
+export interface MilestoneCommitAttributionManifestRow {
+  commit_sha: string;
+  milestone_id: string;
+  slice_id: string | null;
+  task_id: string | null;
+  source: string;
+  confidence: number;
+  files_json: string;
+  created_at: string;
+}
+
 export interface StateManifest {
   version: 1;
   exported_at: string; // ISO 8601
+  requirements?: Requirement[];
+  artifacts?: ManifestArtifactRow[];
   milestones: MilestoneRow[];
   slices: SliceRow[];
   tasks: TaskRow[];
   decisions: Decision[];
+  replan_history?: ReplanHistoryManifestRow[];
+  assessments?: AssessmentManifestRow[];
+  quality_gates?: GateRow[];
   verification_evidence: VerificationEvidenceRow[];
+  milestone_commit_attributions?: MilestoneCommitAttributionManifestRow[];
 }
 
 // ─── helpers ─────────────────────────────────────────────────────────────
@@ -51,11 +97,26 @@ export function toNumeric(value: unknown, fallback: number | null = null): numbe
   return fallback;
 }
 
+function mergeDecisionSurfaces(legacyDecisions: Decision[], memoryDecisions: Decision[]): Decision[] {
+  const byId = new Map<string, Decision>();
+  for (const decision of legacyDecisions) {
+    byId.set(decision.id, decision);
+  }
+  for (const decision of memoryDecisions) {
+    byId.set(decision.id, decision);
+  }
+  return Array.from(byId.values()).sort((a, b) => {
+    const seqDelta = (a.seq ?? 0) - (b.seq ?? 0);
+    return seqDelta === 0 ? a.id.localeCompare(b.id) : seqDelta;
+  });
+}
+
 // ─── snapshotState ───────────────────────────────────────────────────────
 
 /**
- * Capture complete DB state as a StateManifest.
- * Reads all rows from milestones, slices, tasks, decisions, verification_evidence.
+ * Capture DB-backed workflow state as a StateManifest.
+ * Runtime soft state and append-only audit streams stay outside this recovery
+ * substrate; correctness records and persisted evidence are included.
  *
  * Note: rows returned from raw queries are plain objects with TEXT columns for
  * JSON arrays. We parse them into typed Row objects using the same logic as
@@ -67,6 +128,34 @@ export function snapshotState(): StateManifest {
   // Wrap all reads in a deferred transaction so the snapshot is consistent
   // (all SELECTs see the same DB state even if a concurrent write lands between them).
   return readTransaction(() => {
+  const rawRequirements = db.prepare("SELECT * FROM requirements ORDER BY id").all() as Record<string, unknown>[];
+  const requirements: Requirement[] = rawRequirements.map((r) => ({
+    id: r["id"] as string,
+    class: (r["class"] as string) ?? "",
+    status: (r["status"] as string) ?? "",
+    description: (r["description"] as string) ?? "",
+    why: (r["why"] as string) ?? "",
+    source: (r["source"] as string) ?? "",
+    primary_owner: (r["primary_owner"] as string) ?? "",
+    supporting_slices: (r["supporting_slices"] as string) ?? "",
+    validation: (r["validation"] as string) ?? "",
+    notes: (r["notes"] as string) ?? "",
+    full_content: (r["full_content"] as string) ?? "",
+    superseded_by: (r["superseded_by"] as string) ?? null,
+  }));
+
+  const rawArtifacts = db.prepare("SELECT * FROM artifacts ORDER BY path").all() as Record<string, unknown>[];
+  const artifacts: ManifestArtifactRow[] = rawArtifacts.map((r) => ({
+    path: r["path"] as string,
+    artifact_type: (r["artifact_type"] as string) ?? "",
+    milestone_id: (r["milestone_id"] as string) ?? null,
+    slice_id: (r["slice_id"] as string) ?? null,
+    task_id: (r["task_id"] as string) ?? null,
+    full_content: (r["full_content"] as string) ?? "",
+    imported_at: (r["imported_at"] as string) ?? "",
+    content_hash: (r["content_hash"] as string) ?? null,
+  }));
+
   const rawMilestones = db.prepare(
     "SELECT * FROM milestones ORDER BY CASE WHEN sequence > 0 THEN 0 ELSE 1 END, sequence, id",
   ).all() as Record<string, unknown>[];
@@ -152,7 +241,7 @@ export function snapshotState(): StateManifest {
   }));
 
   const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all() as Record<string, unknown>[];
-  const decisions: Decision[] = rawDecisions.map((r) => ({
+  const legacyDecisions: Decision[] = rawDecisions.map((r) => ({
     seq: toNumeric(r["seq"], 0) as number,
     id: r["id"] as string,
     when_context: (r["when_context"] as string) ?? "",
@@ -165,6 +254,45 @@ export function snapshotState(): StateManifest {
     source: (r["source"] as string) ?? "discussion",
     superseded_by: (r["superseded_by"] as string) ?? null,
   }));
+  const decisions = mergeDecisionSurfaces(legacyDecisions, getAllDecisionsFromMemories());
+
+  const rawReplanHistory = db.prepare("SELECT * FROM replan_history ORDER BY id").all() as Record<string, unknown>[];
+  const replan_history: ReplanHistoryManifestRow[] = rawReplanHistory.map((r) => ({
+    id: toNumeric(r["id"], 0) as number,
+    milestone_id: (r["milestone_id"] as string) ?? "",
+    slice_id: (r["slice_id"] as string) ?? null,
+    task_id: (r["task_id"] as string) ?? null,
+    summary: (r["summary"] as string) ?? "",
+    previous_artifact_path: (r["previous_artifact_path"] as string) ?? null,
+    replacement_artifact_path: (r["replacement_artifact_path"] as string) ?? null,
+    created_at: (r["created_at"] as string) ?? "",
+  }));
+
+  const rawAssessments = db.prepare("SELECT * FROM assessments ORDER BY path").all() as Record<string, unknown>[];
+  const assessments: AssessmentManifestRow[] = rawAssessments.map((r) => ({
+    path: r["path"] as string,
+    milestone_id: (r["milestone_id"] as string) ?? "",
+    slice_id: (r["slice_id"] as string) ?? null,
+    task_id: (r["task_id"] as string) ?? null,
+    status: (r["status"] as string) ?? "",
+    scope: (r["scope"] as string) ?? "",
+    full_content: (r["full_content"] as string) ?? "",
+    created_at: (r["created_at"] as string) ?? "",
+  }));
+
+  const rawQualityGates = db.prepare("SELECT * FROM quality_gates ORDER BY milestone_id, slice_id, gate_id, task_id").all() as Record<string, unknown>[];
+  const quality_gates: GateRow[] = rawQualityGates.map((r) => ({
+    milestone_id: r["milestone_id"] as string,
+    slice_id: r["slice_id"] as string,
+    gate_id: r["gate_id"] as GateRow["gate_id"],
+    scope: r["scope"] as GateRow["scope"],
+    task_id: (r["task_id"] as string) ?? "",
+    status: r["status"] as GateRow["status"],
+    verdict: r["status"] === "pending" ? null : (r["verdict"] as GateRow["verdict"]),
+    rationale: (r["rationale"] as string) ?? "",
+    findings: (r["findings"] as string) ?? "",
+    evaluated_at: (r["evaluated_at"] as string) ?? null,
+  }));
 
   const rawEvidence = db.prepare("SELECT * FROM verification_evidence ORDER BY id").all() as Record<string, unknown>[];
   const verification_evidence: VerificationEvidenceRow[] = rawEvidence.map((r) => ({
@@ -179,14 +307,34 @@ export function snapshotState(): StateManifest {
     created_at: r["created_at"] as string,
   }));
 
+  const rawCommitAttributions = db.prepare(
+    "SELECT * FROM milestone_commit_attributions ORDER BY milestone_id, commit_sha",
+  ).all() as Record<string, unknown>[];
+  const milestone_commit_attributions: MilestoneCommitAttributionManifestRow[] = rawCommitAttributions.map((r) => ({
+    commit_sha: r["commit_sha"] as string,
+    milestone_id: r["milestone_id"] as string,
+    slice_id: (r["slice_id"] as string) ?? null,
+    task_id: (r["task_id"] as string) ?? null,
+    source: (r["source"] as string) ?? "recorded",
+    confidence: toNumeric(r["confidence"], 1) as number,
+    files_json: (r["files_json"] as string) ?? "[]",
+    created_at: (r["created_at"] as string) ?? "",
+  }));
+
   const result: StateManifest = {
     version: 1,
     exported_at: new Date().toISOString(),
+    requirements,
+    artifacts,
     milestones,
     slices,
     tasks,
     decisions,
+    replan_history,
+    assessments,
+    quality_gates,
     verification_evidence,
+    milestone_commit_attributions,
   };
 
   return result;
@@ -232,20 +380,55 @@ export function readManifest(basePath: string): StateManifest | null {
     throw new Error(`Unsupported manifest version: ${parsed.version}`);
   }
 
-  // Validate required fields to avoid cryptic errors during restore
+  // Validate required fields to avoid cryptic errors during restore.
   if (!Array.isArray(parsed.milestones) || !Array.isArray(parsed.slices) ||
       !Array.isArray(parsed.tasks) || !Array.isArray(parsed.decisions) ||
       !Array.isArray(parsed.verification_evidence)) {
     throw new Error("Malformed manifest: missing or invalid required arrays");
   }
 
+  for (const key of ["requirements", "artifacts", "replan_history", "assessments", "quality_gates", "milestone_commit_attributions"] as const) {
+    if (parsed[key] !== undefined && !Array.isArray(parsed[key])) {
+      throw new Error(`Malformed manifest: ${key} must be an array when present`);
+    }
+  }
+
   return parsed;
 }
 
+function stripGsdPrefix(path: string): string {
+  return path.startsWith(".gsd/") ? path.slice(".gsd/".length) : path;
+}
+
+function artifactProjectionPath(basePath: string, artifactPath: string): string {
+  const gsdDir = resolve(basePath, ".gsd");
+  const fullPath = resolve(gsdDir, stripGsdPrefix(artifactPath));
+  const rel = relative(gsdDir, fullPath);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`Malformed manifest: artifact path escapes .gsd: ${artifactPath}`);
+  }
+  return fullPath;
+}
+
+function restoreArtifactProjections(basePath: string, manifest: StateManifest): void {
+  if (manifest.artifacts === undefined) return;
+
+  for (const artifact of manifest.artifacts) {
+    atomicWriteSync(
+      artifactProjectionPath(basePath, artifact.path),
+      artifact.full_content ?? "",
+    );
+  }
+}
+
 // ─── bootstrapFromManifest ──────────────────────────────────────────────
 
 /**
  * Read state-manifest.json and restore DB state from it.
+ * Rehydrates artifact projection files for restored artifacts so file-based
+ * fallback paths see the same evidence as the DB.
+ * Re-mirrors restored legacy decisions into memories so the ADR-013
+ * memory-backed decision readers see bootstrapped decisions immediately.
  * Returns true if bootstrap succeeded, false if manifest file doesn't exist.
  */
 export function bootstrapFromManifest(basePath: string): boolean {
@@ -256,5 +439,8 @@ export function bootstrapFromManifest(basePath: string): boolean {
   }
 
   restoreManifest(manifest);
+  restoreArtifactProjections(basePath, manifest);
+  backfillDecisionsToMemories();
+  invalidateAllCaches();
   return true;
 }

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/workflow-projections.ts

@@ -546,6 +546,15 @@ export async function regenerateIfMissing(
     return false;
   }
 
+  // A sketch slice (or any slice not yet planned into tasks) legitimately has
+  // no PLAN.md to project. renderPlanFromDb throws on a zero-task slice, so
+  // skip cleanly here rather than logging a spurious failure. The PLAN.md will
+  // be created once the slice is refined and its first task is written through
+  // the single writer.
+  if (fileType === "PLAN" && getSliceTasks(milestoneId, sliceId).length === 0) {
+    return false;
+  }
+
   // Regenerate the missing file. Each renderer may swallow its own errors
   // (e.g. renderStateProjection), so confirm the file actually exists on
   // disk before reporting success — true must mean "file is there now".

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/gsd/worktree-state-projection.ts

@@ -123,36 +123,29 @@ function forceOverwriteAssessmentsWithVerdict(
   }
 }
 
-function syncTopLevelMilestoneArtifacts(
+function syncOtherMilestoneArtifacts(
   srcMilestonesDir: string,
   dstMilestonesDir: string,
+  currentMilestoneId: string,
 ): void {
   if (!existsSync(srcMilestonesDir)) return;
 
   try {
     for (const milestoneEntry of readdirSync(srcMilestonesDir, { withFileTypes: true })) {
       if (!milestoneEntry.isDirectory()) continue;
+      // The current milestone is already fully projected by the caller's
+      // additive safeCopyRecursive; skip it here to avoid redundant work.
+      if (milestoneEntry.name === currentMilestoneId) continue;
       const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
       const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
 
-      try {
-        mkdirSync(dstMilestoneDir, { recursive: true });
-        for (const fileEntry of readdirSync(srcMilestoneDir, { withFileTypes: true })) {
-          if (!fileEntry.isFile()) continue;
-          if (!fileEntry.name.endsWith(".md") && !fileEntry.name.endsWith(".json")) continue;
-
-          safeCopy(
-            join(srcMilestoneDir, fileEntry.name),
-            join(dstMilestoneDir, fileEntry.name),
-            { force: false },
-          );
-        }
-      } catch (err) {
-        logWarning(
-          "worktree",
-          `milestone top-level artifact sync failed (${milestoneEntry.name}): ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
+      // Additively project the entire milestone subtree (force:false), not just
+      // top-level files. Prior completed milestones keep their per-slice and
+      // per-task SUMMARY.md / UAT.md on disk so the worktree's stale-render
+      // detector doesn't flag them as missing (DB has summary, disk doesn't).
+      // force:false preserves any worktree-local files (#1886 invariant) and
+      // only fills in files absent from the worktree projection.
+      safeCopyRecursive(srcMilestoneDir, dstMilestoneDir, { force: false });
     }
   } catch (err) {
     logWarning(
@@ -248,9 +241,16 @@ export function _projectRootToWorktreeImpl(
     { force: false },
   );
 
-  // Additively project missing top-level milestone files for all milestones
-  // so worktree-bound units can verify future-milestone context artifacts.
-  syncTopLevelMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"));
+  // Additively project the full subtree of every OTHER milestone so
+  // worktree-bound units can read prior-milestone context artifacts and so
+  // completed milestones retain their per-slice/per-task SUMMARY.md and
+  // UAT.md on the worktree filesystem (otherwise the stale-render detector
+  // flags them as "complete in DB but missing on disk").
+  syncOtherMilestoneArtifacts(
+    join(prGsd, "milestones"),
+    join(wtGsd, "milestones"),
+    milestoneId,
+  );
 
   // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
   // The additive-only copy above preserves worktree-local files, but

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,
       ];

package/src/resources/extensions/shared/tests/format-utils.test.ts

@@ -11,6 +11,7 @@ import {
   centerLine,
   fitColumns,
 } from "../layout-utils.js";
+import { visibleWidth } from "@gsd/pi-tui";
 
 describe("formatDuration", () => {
   it("formats seconds", () => {
@@ -59,8 +60,10 @@ describe("joinColumns", () => {
 
   it("truncates when content overflows", () => {
     const result = joinColumns("a".repeat(20), "b".repeat(20), 30);
-    // Should be truncated to 30 chars
-    assert.ok(result.length <= 30);
+    // truncateToWidth is ANSI-aware and brackets the ellipsis with zero-width
+    // SGR resets, so the visible width — not the raw string length — is the
+    // invariant that must hold within the column budget.
+    assert.ok(visibleWidth(result) <= 30);
   });
 });
 
@@ -72,7 +75,9 @@ describe("centerLine", () => {
 
   it("truncates when content exceeds width", () => {
     const result = centerLine("abcdefgh", 4);
-    assert.ok(result.length <= 4);
+    // Visible width is the meaningful budget; the result may carry zero-width
+    // SGR reset codes around the ellipsis (see truncateToWidth).
+    assert.ok(visibleWidth(result) <= 4);
   });
 });
 

package/src/resources/extensions/subagent/agents.ts

@@ -15,6 +15,8 @@ export interface AgentConfig {
 	description: string;
 	tools?: string[];
 	model?: string;
+	/** Default reasoning effort for this agent, forwarded as `--thinking` (#508). */
+	thinking?: string;
 	conflictsWith?: string[];
 	systemPrompt: string;
 	source: "user" | "project";
@@ -31,6 +33,7 @@ interface AgentFrontmatter extends Record<string, unknown> {
 	description?: string;
 	tools?: string | string[];
 	model?: string;
+	thinking?: string;
 	conflicts_with?: string;
 }
 
@@ -100,6 +103,7 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			description: frontmatter.description,
 			tools: tools && tools.length > 0 ? tools : undefined,
 			model: frontmatter.model,
+			thinking: typeof frontmatter.thinking === "string" ? frontmatter.thinking : undefined,
 			conflictsWith,
 			systemPrompt: body,
 			source,