@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/codebase-generator.ts

@@ -10,10 +10,15 @@
 
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join, dirname, extname } from "node:path";
+import { join, dirname, extname, relative, sep } from "node:path";
 
 import { execSync } from "node:child_process";
 import { gsdRoot } from "./paths.js";
+import {
+  createRepositoryRegistryFromPreferences,
+  type RepositoryRegistry,
+} from "./repository-registry.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -28,6 +33,8 @@ export interface CodebaseMapMetadata {
   fingerprint: string;
   fileCount: number;
   truncated: boolean;
+  /** Repo ids whose files appear in a workspace-aware map (parent mode only). */
+  repositories?: string[];
 }
 
 export interface EnsureCodebaseMapOptions {
@@ -48,12 +55,16 @@ export interface EnsureCodebaseMapResult {
 interface FileEntry {
   path: string;
   description: string;
+  /** Declaring repo id for workspace-aware maps (parent mode); undefined otherwise. */
+  repo?: string;
 }
 
 interface DirectoryGroup {
   path: string;
   files: FileEntry[];
   collapsed: boolean;
+  /** Repo id this group belongs to for workspace-aware maps; undefined otherwise. */
+  repo?: string;
 }
 
 interface ResolvedCodebaseMapOptions {
@@ -66,6 +77,8 @@ interface ResolvedCodebaseMapOptions {
 interface EnumeratedFiles {
   files: string[];
   truncated: boolean;
+  /** Per-file repo labels aligned with `files` (workspace-aware maps only). */
+  repos?: string[];
 }
 
 // ─── Defaults ────────────────────────────────────────────────────────────────
@@ -209,13 +222,99 @@ function lsFiles(basePath: string): string[] {
  * Enumerate tracked files, applying exclusions and the maxFiles cap.
  * Returns both the file list and whether truncation occurred.
  */
-function enumerateFiles(basePath: string, excludes: string[], maxFiles: number): { files: string[]; truncated: boolean } {
+function enumerateFiles(basePath: string, excludes: string[], maxFiles: number): EnumeratedFiles {
   const allFiles = lsFiles(basePath);
   const filtered = allFiles.filter((f) => !shouldExclude(f, excludes));
   const truncated = filtered.length > maxFiles;
   return { files: truncated ? filtered.slice(0, maxFiles) : filtered, truncated };
 }
 
+/**
+ * Build a workspace-aware registry for parent mode, or null when the project is
+ * single-repo (no declared child repositories). Returns null so the caller falls
+ * back to the legacy single-root enumeration and produces byte-identical output.
+ */
+function loadWorkspaceRegistry(basePath: string): RepositoryRegistry | null {
+  const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
+  const workspace = preferences?.workspace;
+  const mode = workspace?.mode ?? "project";
+  // Parent mode is only meaningful with at least one declared child repo; the
+  // implicit "project" repo is always present, so require a declared non-project id.
+  const hasDeclaredChildRepo = workspace?.repositories
+    ? Object.keys(workspace.repositories).some((id) => id !== "project")
+    : false;
+  if (mode !== "parent" || !hasDeclaredChildRepo) {
+    return null;
+  }
+  return createRepositoryRegistryFromPreferences(basePath, preferences);
+}
+
+/** Stable key fragment for workspace-aware enumeration inputs (mode + declared repos). */
+function workspaceEnumerationSignature(basePath: string): string {
+  const registry = loadWorkspaceRegistry(basePath);
+  if (!registry) return "single-root";
+  return JSON.stringify({
+    mode: registry.mode,
+    repositories: registry.repositories
+      .map((repo) => ({ id: repo.id, root: repo.root }))
+      .sort((a, b) => a.id.localeCompare(b.id)),
+  });
+}
+
+/**
+ * Enumerate tracked files across every declared repository in a parent workspace.
+ * Child-repo paths are rewritten to be workspace-relative (e.g. `frontend/src/x`)
+ * and tagged with their declaring repo id so the map can render repo-labelled
+ * sections. The maxFiles cap is applied across the union of all repositories.
+ */
+function enumerateWorkspaceFiles(
+  registry: RepositoryRegistry,
+  excludes: string[],
+  maxFiles: number,
+): EnumeratedFiles {
+  type WorkspaceEntry = { workspacePath: string; repoId: string };
+  const perRepo: WorkspaceEntry[][] = [];
+  const seen = new Set<string>();
+  let totalEligible = 0;
+
+  for (const repo of registry.repositories) {
+    const rawFiles = lsFiles(repo.root);
+    const repoPrefix = relative(registry.projectRoot, repo.root).split(sep).join("/");
+    const repoEntries: WorkspaceEntry[] = [];
+
+    for (const file of rawFiles) {
+      // Rewrite before exclusion so workspace-relative patterns (e.g. frontend/…) apply.
+      const workspacePath = repoPrefix ? `${repoPrefix}/${file}` : file;
+      if (shouldExclude(workspacePath, excludes)) continue;
+      if (seen.has(workspacePath)) continue;
+      seen.add(workspacePath);
+      totalEligible++;
+      repoEntries.push({ workspacePath, repoId: repo.id });
+    }
+    perRepo.push(repoEntries);
+  }
+
+  const files: string[] = [];
+  const repos: string[] = [];
+  const indices = new Array(perRepo.length).fill(0);
+
+  while (files.length < maxFiles) {
+    let progressed = false;
+    for (let i = 0; i < perRepo.length; i++) {
+      if (indices[i] < perRepo[i].length) {
+        const entry = perRepo[i][indices[i]++];
+        files.push(entry.workspacePath);
+        repos.push(entry.repoId);
+        progressed = true;
+        if (files.length >= maxFiles) break;
+      }
+    }
+    if (!progressed) break;
+  }
+
+  return { files, repos, truncated: totalEligible > files.length };
+}
+
 function resolveGeneratorOptions(options?: CodebaseMapOptions): ResolvedCodebaseMapOptions {
   const excludes = [...DEFAULT_EXCLUDES, ...(options?.excludePatterns ?? [])];
   const maxFiles = options?.maxFiles ?? DEFAULT_MAX_FILES;
@@ -236,10 +335,12 @@ function computeCodebaseFingerprint(
   files: string[],
   resolved: ResolvedCodebaseMapOptions,
   truncated: boolean,
+  repos?: string[],
 ): string {
   return createHash("sha1")
     .update(JSON.stringify({
       files,
+      ...(repos ? { repos } : {}),
       truncated,
       optionSignature: resolved.optionSignature,
     }))
@@ -252,32 +353,61 @@ function groupByDirectory(
   files: string[],
   descriptions: Map<string, string>,
   collapseThreshold: number,
+  repos?: string[],
 ): DirectoryGroup[] {
   const dirMap = new Map<string, FileEntry[]>();
 
-  for (const file of files) {
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
     const dir = dirname(file);
-    const dirKey = dir === "." ? "" : dir;
-    if (!dirMap.has(dirKey)) {
-      dirMap.set(dirKey, []);
+    const dirPath = dir === "." ? "" : dir;
+    const repoId = repos?.[i];
+    const groupKey = repoId !== undefined ? `${repoId}\0${dirPath}` : dirPath;
+    if (!dirMap.has(groupKey)) {
+      dirMap.set(groupKey, []);
     }
-    dirMap.get(dirKey)!.push({
+    dirMap.get(groupKey)!.push({
       path: file,
       description: descriptions.get(file) ?? "",
+      repo: repoId,
     });
   }
 
   const groups: DirectoryGroup[] = [];
-  const sortedDirs = [...dirMap.keys()].sort();
+  const repoOrder = new Map<string, number>();
+  if (repos) {
+    for (let i = 0; i < repos.length; i++) {
+      if (!repoOrder.has(repos[i])) {
+        repoOrder.set(repos[i], repoOrder.size);
+      }
+    }
+  }
+  const sortedDirs = [...dirMap.keys()].sort((a, b) => {
+    // Single-repo (project) mode must stay byte-identical to the pre-workspace
+    // output, which ordered directories with a bare `.sort()` (UTF-16 code-unit
+    // order, so uppercase sorts before lowercase). localeCompare would diverge
+    // for mixed-case names (e.g. "Zoo" before "apple" flips), so preserve
+    // code-unit ordering here; only the repo-partitioning key is added on top.
+    if (!repos) return a < b ? -1 : a > b ? 1 : 0;
+    const repoA = dirMap.get(a)![0]?.repo ?? "";
+    const repoB = dirMap.get(b)![0]?.repo ?? "";
+    const orderA = repoOrder.get(repoA) ?? 0;
+    const orderB = repoOrder.get(repoB) ?? 0;
+    if (orderA !== orderB) return orderA - orderB;
+    return a.localeCompare(b);
+  });
 
-  for (const dir of sortedDirs) {
-    const dirFiles = dirMap.get(dir)!;
+  for (const groupKey of sortedDirs) {
+    const dirFiles = dirMap.get(groupKey)!;
     dirFiles.sort((a, b) => a.path.localeCompare(b.path));
+    const dirPath = repos ? groupKey.slice(groupKey.indexOf("\0") + 1) : groupKey;
 
     groups.push({
-      path: dir,
+      path: dirPath,
       files: dirFiles,
       collapsed: dirFiles.length > collapseThreshold,
+      // Each group is scoped to one repo in workspace-aware mode.
+      repo: dirFiles[0]?.repo,
     });
   }
 
@@ -304,7 +434,19 @@ function renderCodebaseMap(
   }
   lines.push("");
 
+  let emittedRepo: string | undefined;
   for (const group of groups) {
+    // In a workspace-aware map, partition directories under their declaring
+    // repository. `## [repo-id]` headings are used (not `###`) so they never
+    // collide with the per-directory `### <dir>/` headings or the
+    // `parseCodebaseMap` list-item regexes. Groups are sorted by declaring
+    // repo (enumeration order) then directory path so each repo is contiguous.
+    if (group.repo && group.repo !== emittedRepo) {
+      emittedRepo = group.repo;
+      lines.push(`## [${group.repo}]`);
+      lines.push("");
+    }
+
     const heading = group.path || "(root)";
     lines.push(`### ${heading}/`);
 
@@ -361,13 +503,15 @@ function buildCodebaseMap(
 } {
   const listed = enumerated ?? enumerateFiles(basePath, resolved.excludes, resolved.maxFiles);
   const descriptions = existingDescriptions ?? new Map<string, string>();
-  const groups = groupByDirectory(listed.files, descriptions, resolved.collapseThreshold);
+  const groups = groupByDirectory(listed.files, descriptions, resolved.collapseThreshold, listed.repos);
   const generatedAt = new Date().toISOString().split(".")[0] + "Z";
+  const repoIds = listed.repos ? Array.from(new Set(listed.repos)) : undefined;
   const metadata: CodebaseMapMetadata = {
     generatedAt,
-    fingerprint: computeCodebaseFingerprint(listed.files, resolved, listed.truncated),
+    fingerprint: computeCodebaseFingerprint(listed.files, resolved, listed.truncated, listed.repos),
     fileCount: listed.files.length,
     truncated: listed.truncated,
+    ...(repoIds ? { repositories: repoIds } : {}),
   };
   const content = renderCodebaseMap(groups, listed.files.length, listed.truncated, metadata);
 
@@ -387,13 +531,28 @@ function buildCodebaseMap(
  * Generate a fresh CODEBASE.md from scratch.
  * Preserves existing descriptions if `existingDescriptions` is provided.
  */
+/**
+ * Resolve workspace-aware enumeration for parent mode, or undefined to fall
+ * back to the legacy single-root enumeration. Centralized so all three public
+ * entry points (generate/update/ensure) share one discovery path.
+ */
+function resolveWorkspaceEnumeration(
+  basePath: string,
+  resolved: ResolvedCodebaseMapOptions,
+): EnumeratedFiles | undefined {
+  const registry = loadWorkspaceRegistry(basePath);
+  if (!registry) return undefined;
+  return enumerateWorkspaceFiles(registry, resolved.excludes, resolved.maxFiles);
+}
+
 export function generateCodebaseMap(
   basePath: string,
   options?: CodebaseMapOptions,
   existingDescriptions?: Map<string, string>,
 ): { content: string; fileCount: number; truncated: boolean; files: string[]; fingerprint: string; generatedAt: string } {
   const resolved = resolveGeneratorOptions(options);
-  return buildCodebaseMap(basePath, resolved, existingDescriptions);
+  const enumerated = resolveWorkspaceEnumeration(basePath, resolved);
+  return buildCodebaseMap(basePath, resolved, existingDescriptions, enumerated);
 }
 
 /**
@@ -427,7 +586,8 @@ export function updateCodebaseMap(
 
   // Generate new map preserving descriptions — reuse the returned file list
   // to avoid a second enumeration (prevents race between content and stats).
-  const result = buildCodebaseMap(basePath, resolved, existingDescriptions);
+  const enumerated = resolveWorkspaceEnumeration(basePath, resolved);
+  const result = buildCodebaseMap(basePath, resolved, existingDescriptions, enumerated);
   const currentSet = new Set(result.files);
 
   // Count changes
@@ -467,7 +627,7 @@ export function ensureCodebaseMapFresh(
   ensureOptions?: EnsureCodebaseMapOptions,
 ): EnsureCodebaseMapResult {
   const resolved = resolveGeneratorOptions(options);
-  const cacheKey = `${basePath}::${resolved.optionSignature}`;
+  const cacheKey = `${basePath}::${resolved.optionSignature}::${workspaceEnumerationSignature(basePath)}`;
   const ttlMs = ensureOptions?.ttlMs ?? DEFAULT_REFRESH_TTL_MS;
   const force = ensureOptions?.force === true;
   const now = Date.now();
@@ -481,8 +641,9 @@ export function ensureCodebaseMapFresh(
   }
 
   const existing = readCodebaseMap(basePath);
-  const listed = enumerateFiles(basePath, resolved.excludes, resolved.maxFiles);
-  const fingerprint = computeCodebaseFingerprint(listed.files, resolved, listed.truncated);
+  const listed = resolveWorkspaceEnumeration(basePath, resolved)
+    ?? enumerateFiles(basePath, resolved.excludes, resolved.maxFiles);
+  const fingerprint = computeCodebaseFingerprint(listed.files, resolved, listed.truncated, listed.repos);
 
   const cacheAndReturn = (result: EnsureCodebaseMapResult): EnsureCodebaseMapResult => {
     freshnessCache.set(cacheKey, { checkedAt: now, result });

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

@@ -200,7 +200,7 @@ export async function handleAutoCommand(trimmed: string, ctx: ExtensionCommandCo
       }
       return true;
     }
-    await pauseAuto(ctx, pi);
+    await pauseAuto(ctx, pi, undefined, { abortActiveTurn: true });
     return true;
   }
 

package/src/resources/extensions/gsd/commands/handlers/core.ts

@@ -4,7 +4,9 @@ import type { GSDState } from "../../types.js";
 import { createRequire } from "node:module";
 
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
+import { isRepositoryDirty } from "../../git-service.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, availableModelIdsFromRegistry, modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences } from "../../preferences.js";
+import { createRepositoryRegistryFromPreferences } from "../../repository-registry.js";
 import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard, handleLanguage } from "../../commands-prefs-wizard.js";
 import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
@@ -220,7 +222,7 @@ export async function handleStatus(ctx: ExtensionCommandContext): Promise<void>
   );
 
   if (result === undefined) {
-    ctx.ui.notify(formatTextStatus(state), "info");
+    ctx.ui.notify(formatTextStatus(state, basePath), "info");
   }
 }
 
@@ -610,7 +612,8 @@ export async function handleCoreCommand(
   return false;
 }
 
-export function formatTextStatus(state: GSDState): string {
+export function formatTextStatus(state: GSDState, basePath?: string): string {
+  const root = basePath ?? projectRoot();
   const lines: string[] = ["GSD Status\n"];
   lines.push(formatProgressLine(computeProgressScore()));
   lines.push("");
@@ -653,7 +656,7 @@ export function formatTextStatus(state: GSDState): string {
     }
   }
 
-  const envResults = runEnvironmentChecks(projectRoot());
+  const envResults = runEnvironmentChecks(root);
   const envIssues = envResults.filter((result) => result.status !== "ok");
   if (envIssues.length > 0) {
     lines.push("");
@@ -663,5 +666,38 @@ export function formatTextStatus(state: GSDState): string {
     }
   }
 
+  // Parent-workspace per-repository git health (#818). No-op for single-repo
+  // projects; surfaces which declared child repos have uncommitted changes.
+  const repoBlock = buildWorkspaceRepoStatusBlock(root);
+  if (repoBlock) {
+    lines.push("");
+    lines.push("Repositories:");
+    lines.push(repoBlock);
+  }
+
   return lines.join("\n");
 }
+
+/**
+ * Build a per-repository dirty/clean summary for parent-workspace status.
+ * Returns "" for single-repo (project-mode) projects so the status output is
+ * unchanged; otherwise one line per declared child repository.
+ */
+function buildWorkspaceRepoStatusBlock(basePath: string): string {
+  let registry;
+  try {
+    registry = createRepositoryRegistryFromPreferences(basePath, loadEffectiveGSDPreferences(basePath)?.preferences);
+  } catch {
+    return "";
+  }
+  if (registry.mode !== "parent") return "";
+  const childRepos = registry.repositories.filter((repo) => repo.id !== "project");
+  if (childRepos.length === 0) return "";
+
+  return childRepos
+    .map((repo) => {
+      const dirty = isRepositoryDirty(repo.root);
+      return `  ${dirty ? "✗" : "✓"} ${repo.id}${repo.role ? ` — ${repo.role}` : ""}${dirty ? " (uncommitted changes)" : " (clean)"}`;
+    })
+    .join("\n");
+}

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -551,6 +551,17 @@ export function buildCategorySummaries(prefs: Record<string, unknown>): Record<s
     if (parts.length > 0) integrationsSummary = parts.join(", ");
   }
 
+  // Workspace (parent-workspace multi-repo)
+  const workspace = prefs.workspace as Record<string, unknown> | undefined;
+  const workspaceRepos = workspace?.repositories as Record<string, unknown> | undefined;
+  let workspaceSummary = "(single-repo)";
+  {
+    const parts: string[] = [];
+    if (workspace?.mode) parts.push(`mode: ${workspace.mode}`);
+    if (workspaceRepos && Object.keys(workspaceRepos).length > 0) parts.push(`${Object.keys(workspaceRepos).length} repo(s)`);
+    if (parts.length > 0) workspaceSummary = parts.join(", ");
+  }
+
   return {
     mode: modeSummary,
     models: modelsSummary,
@@ -568,6 +579,7 @@ export function buildCategorySummaries(prefs: Record<string, unknown>): Record<s
     hooks: hooksSummary,
     uok: uokSummary,
     integrations: integrationsSummary,
+    workspace: workspaceSummary,
   };
 }
 
@@ -758,7 +770,10 @@ async function configureDynamicRouting(ctx: ExtensionCommandContext, prefs: Reco
   const hooks = await promptBoolean(ctx, "Route hook sessions dynamically", dr.hooks, true);
   if (hooks !== undefined) dr.hooks = hooks;
 
-  const flatRate = await promptBoolean(ctx, "Allow dynamic routing for flat-rate providers", dr.allow_flat_rate_providers, false);
+  // Opt-out flag (#1115): routing is allowed for flat-rate providers by
+  // default; only an explicit `false` suppresses it. The default hint reflects
+  // that allow-by-default behavior.
+  const flatRate = await promptBoolean(ctx, "Allow dynamic routing for flat-rate providers", dr.allow_flat_rate_providers, true);
   if (flatRate !== undefined) dr.allow_flat_rate_providers = flatRate;
 
   // tier_models.light / standard / heavy — optional model IDs
@@ -968,6 +983,114 @@ async function configureSkills(ctx: ExtensionCommandContext, prefs: Record<strin
   applyNumber(prefs, "skill_staleness_days", staleness);
 }
 
+async function configureWorkspace(ctx: ExtensionCommandContext, prefs: Record<string, unknown>): Promise<void> {
+  type RepoConfig = { path: string; role?: string; verification?: string[]; commit_policy?: "auto" | "skip" };
+  let workspace = (prefs.workspace ?? {}) as { mode?: "project" | "parent"; repositories?: Record<string, RepoConfig> };
+
+  // Mode
+  const mode = await promptEnum(ctx, "Workspace mode", workspace.mode, ["project", "parent"]);
+  if (mode !== undefined) workspace = { ...workspace, mode: mode as "project" | "parent" };
+
+  if (workspace.mode !== "parent") {
+    // Single-repo mode: drop any declared repositories and persist.
+    if (workspace.repositories && Object.keys(workspace.repositories).length > 0) {
+      const clear = await promptBoolean(ctx, "Clear declared repositories (switch to single-repo)?", false, false);
+      if (clear) workspace = { mode: workspace.mode };
+    }
+    persistWorkspace(prefs, workspace);
+    return;
+  }
+
+  // Parent mode — edit child repositories via a sub-menu.
+  let repositories = { ...(workspace.repositories ?? {}) };
+  while (true) {
+    const ids = Object.keys(repositories).sort();
+    const summary = ids.length === 0 ? "(no repositories — parent mode requires at least one)" : `${ids.length} repo(s)`;
+    const listLabels = ids.map((id) => {
+      const r = repositories[id];
+      const roleStr = r.role ? ` — ${r.role}` : "";
+      const policyStr = r.commit_policy === "skip" ? " [skip]" : "";
+      return `${id} (${r.path})${roleStr}${policyStr}`;
+    });
+    const choice = await ctx.ui.select(`Declared repositories — ${summary}`, [...listLabels, "Add repository", "Done"]);
+    const pick = typeof choice === "string" ? choice : "";
+    if (!pick || pick === "Done") break;
+    if (pick === "Add repository") {
+      const idInput = await ctx.ui.input("Repository id (letters, digits, . _ -; 'project' is reserved):", "");
+      const id = typeof idInput === "string" ? idInput.trim() : "";
+      if (!id || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id)) {
+        ctx.ui.notify("Invalid repository id — must match ^[A-Za-z0-9][A-Za-z0-9._-]*$ and cannot be 'project'.", "warning");
+        continue;
+      }
+      if (id === "project" || repositories[id]) {
+        ctx.ui.notify(`Repository id "${id}" is reserved or already declared.`, "warning");
+        continue;
+      }
+      const pathInput = await ctx.ui.input("Repository path (relative to project root, e.g. frontend):", "");
+      const path = typeof pathInput === "string" ? pathInput.trim() : "";
+      if (!path) { ctx.ui.notify("Repository path is required.", "warning"); continue; }
+      const repo: RepoConfig = { path };
+      const roleInput = await ctx.ui.input("Role/label (optional):", "");
+      if (typeof roleInput === "string" && roleInput.trim()) repo.role = roleInput.trim();
+      const verifyInput = await ctx.ui.input("Verification commands (comma- or newline-separated, optional):", "");
+      if (typeof verifyInput === "string" && verifyInput.trim()) {
+        const cmds = parseStringList(verifyInput);
+        if (cmds.length > 0) repo.verification = cmds;
+      }
+      const policy = await promptEnum(ctx, "Commit policy", undefined, ["auto", "skip"]);
+      if (policy === "skip") repo.commit_policy = "skip";
+      repositories[id] = repo;
+    } else {
+      // Edit/delete an existing repo (the first token is the id).
+      const id = pick.split(" ")[0];
+      if (!repositories[id]) continue;
+      const editChoice = await ctx.ui.select(
+        `Repository ${id}`,
+        ["Edit path", "Edit role", "Edit verification", "Edit commit policy", "Delete repository", "Cancel"],
+      );
+      const ec = typeof editChoice === "string" ? editChoice : "";
+      if (!ec || ec === "Cancel") continue;
+      if (ec === "Delete repository") {
+        delete repositories[id];
+      } else if (ec === "Edit path") {
+        const v = await ctx.ui.input("Repository path:", repositories[id].path);
+        if (typeof v === "string" && v.trim()) repositories[id] = { ...repositories[id], path: v.trim() };
+      } else if (ec === "Edit role") {
+        const v = await ctx.ui.input("Role/label (blank to clear):", repositories[id].role ?? "");
+        if (typeof v === "string" && v.trim()) repositories[id] = { ...repositories[id], role: v.trim() };
+        else if (typeof v === "string") { const { role, ...rest } = repositories[id]; void role; repositories[id] = rest; }
+      } else if (ec === "Edit verification") {
+        const v = await ctx.ui.input("Verification commands (blank to clear):", (repositories[id].verification ?? []).join(", "));
+        if (typeof v === "string" && v.trim()) {
+          const cmds = parseStringList(v);
+          if (cmds.length > 0) repositories[id] = { ...repositories[id], verification: cmds };
+        } else if (typeof v === "string") {
+          const { verification, ...rest } = repositories[id]; void verification; repositories[id] = rest;
+        }
+      } else if (ec === "Edit commit policy") {
+        const policy = await promptEnum(ctx, "Commit policy", repositories[id].commit_policy, ["auto", "skip"]);
+        if (policy === "skip") repositories[id] = { ...repositories[id], commit_policy: "skip" };
+        else { const { commit_policy, ...rest } = repositories[id]; void commit_policy; repositories[id] = rest; }
+      }
+    }
+  }
+
+  if (Object.keys(repositories).length === 0) {
+    ctx.ui.notify("Parent mode requires at least one repository — mode not saved.", "warning");
+    return;
+  }
+  persistWorkspace(prefs, { mode: "parent", repositories });
+}
+
+/** Persist the workspace config onto prefs, dropping it entirely when empty. */
+function persistWorkspace(prefs: Record<string, unknown>, workspace: { mode?: string; repositories?: Record<string, unknown> }): void {
+  if (!workspace.mode && (!workspace.repositories || Object.keys(workspace.repositories).length === 0)) {
+    delete prefs.workspace;
+    return;
+  }
+  prefs.workspace = workspace;
+}
+
 async function configureSkillRules(ctx: ExtensionCommandContext, prefs: Record<string, unknown>): Promise<void> {
   type Rule = { when: string; use?: string[]; prefer?: string[]; avoid?: string[] };
   let rules: Rule[] = Array.isArray(prefs.skill_rules) ? [...prefs.skill_rules as Rule[]] : [];
@@ -1176,6 +1299,14 @@ async function configureVerification(ctx: ExtensionCommandContext, prefs: Record
   const maxRetries = await promptInteger(ctx, "Verification max retries", prefs.verification_max_retries, "2");
   applyNumber(prefs, "verification_max_retries", maxRetries);
 
+  const perUnitCap = await promptNumber(
+    ctx,
+    "Per-unit cost cap (USD; retry cost ceiling, blank = clear to default)",
+    prefs.per_unit_cost_cap_usd,
+    "5.0",
+  );
+  applyNumber(prefs, "per_unit_cost_cap_usd", perUnitCap);
+
   const ev = await promptBoolean(ctx, "Enhanced verification (master toggle)", prefs.enhanced_verification, true);
   if (ev !== undefined) prefs.enhanced_verification = ev;
   const evPre = await promptBoolean(ctx, "Enhanced verification — pre-execution checks", prefs.enhanced_verification_pre, true);
@@ -1228,7 +1359,7 @@ async function configureContextCodebase(ctx: ExtensionCommandContext, prefs: Rec
   const maskTurns = await promptInteger(ctx, "Observation mask turns (1–50)", cm.observation_mask_turns, "8");
   if (maskTurns !== undefined && maskTurns !== "clear") cm.observation_mask_turns = maskTurns;
   else if (maskTurns === "clear") delete cm.observation_mask_turns;
-  const thresh = await promptNumber(ctx, "Compaction threshold percent (0.5–0.95)", cm.compaction_threshold_percent, "0.60");
+  const thresh = await promptNumber(ctx, "Soft context warning threshold percent (0.5–0.95)", cm.compaction_threshold_percent, "0.60");
   if (thresh !== undefined && thresh !== "clear") cm.compaction_threshold_percent = thresh;
   else if (thresh === "clear") delete cm.compaction_threshold_percent;
   const toolMax = await promptInteger(ctx, "Tool result max chars (200–10000)", cm.tool_result_max_chars, "800");
@@ -1621,6 +1752,7 @@ export async function handlePrefsWizard(
       `Hooks           ${summaries.hooks}`,
       `UoK             ${summaries.uok}`,
       `Integrations    ${summaries.integrations}`,
+      `Workspace       ${summaries.workspace}`,
       `Advanced        ${summaries.advanced}`,
       `── Save & Exit ──`,
     ];
@@ -1644,6 +1776,7 @@ export async function handlePrefsWizard(
     else if (choice.startsWith("Hooks"))         await configureHooks(ctx, prefs);
     else if (choice.startsWith("UoK"))           await configureUoK(ctx, prefs);
     else if (choice.startsWith("Integrations"))  await configureIntegrations(ctx, prefs);
+    else if (choice.startsWith("Workspace"))     await configureWorkspace(ctx, prefs);
     else if (choice.startsWith("Advanced"))      await configureAdvanced(ctx, prefs);
   }
 
@@ -1780,6 +1913,7 @@ export function serializePreferencesToFrontmatter(prefs: Record<string, unknown>
     "reactive_execution", "gate_evaluation",
     "auto_visualize", "auto_report",
     "verification_commands", "verification_auto_fix", "verification_max_retries",
+    "per_unit_cost_cap_usd",
     "enhanced_verification", "enhanced_verification_pre",
     "enhanced_verification_post", "enhanced_verification_strict",
     "safety_harness",

package/src/resources/extensions/gsd/commands-usage.ts

@@ -112,7 +112,7 @@ function formatThresholdLines(): string[] {
 
   const compactionThreshold = prefs?.context_management?.compaction_threshold_percent;
   if (typeof compactionThreshold === "number") {
-    lines.push(`Compaction: ${Math.round(compactionThreshold * 100)}%`);
+    lines.push(`Soft context warning: ${Math.round(compactionThreshold * 100)}%`);
   }
 
   return lines;

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

@@ -315,8 +315,19 @@ async function handleRemove(args: string, ctx: ExtensionCommandContext): Promise
   }
 
   try {
-    removeWorktree(basePath, name, { deleteBranch: true });
-    ctx.ui.notify(`Removed worktree ${name}.`, "info");
+    const removed = removeWorktree(basePath, name, { deleteBranch: true });
+    if (removed) {
+      ctx.ui.notify(`Removed worktree ${name}.`, "info");
+    } else {
+      ctx.ui.notify(
+        [
+          `Worktree removal aborted for "${name}" to preserve uncommitted changes.`,
+          "",
+          "Manual quarantine recovery may be needed before retrying removal.",
+        ].join("\n"),
+        "warning",
+      );
+    }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     ctx.ui.notify(

package/src/resources/extensions/gsd/db/engine.ts

@@ -47,7 +47,11 @@ import {
   applyMigrationV28MemoryLastHitAt,
   applyMigrationV29RepositoryTargets,
 } from "../db-migration-steps.js";
-import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "../db-memory-fts-schema.js";
+import {
+  isMemoriesFtsAvailableSchema,
+  rebuildMemoriesFtsSchemaOnce,
+  tryCreateMemoriesFtsSchema,
+} from "../db-memory-fts-schema.js";
 import { createDbOpenState, type DbOpenPhase } from "../db-open-state.js";
 import { createRuntimeKvTableV25 } from "../db-runtime-kv-schema.js";
 import { getCurrentSchemaVersion, recordSchemaVersion } from "../db-schema-metadata.js";
@@ -134,6 +138,9 @@ function initSchema(db: DbAdapter, fileBacked: boolean, dbPath: string | null):
   }
 
   migrateSchema(db, dbPath);
+  rebuildMemoriesFtsSchemaOnce(db, {
+    onRebuildFailed: (message) => logWarning("db", message),
+  });
 }
 
 export function _isLikelyWslDrvFsPathForTest(dbPath: string | null): boolean {