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

package/dist/resources/extensions/gsd/bootstrap/tool-call-loop-guard.js

@@ -1,24 +1,31 @@
 /**
  * Tool-call loop guard.
  *
- * Detects when a model calls the same tool with identical arguments
- * repeatedly within a single agent turn. Works in both auto-mode and
- * interactive sessions by hooking into the `tool_call` event, which
- * fires before execution and can block the call.
+ * Detects when a model repeats tool calls within a single Agent Turn.
+ * Works in both auto-mode and interactive sessions by hooking into the
+ * native engine's `tool_call` event, which fires before execution and can
+ * block the call.
  *
- * The guard uses a sliding window: it tracks the last N tool signatures
- * and blocks when the same signature appears more than MAX_CONSECUTIVE
- * times in a row. Resets on each agent turn (session_start, agent_end)
- * and when a different tool call breaks the streak.
+ * The guard has two independent checks: a sliding window for identical
+ * tool signatures, and a per-tool-name cap for repeated calls with varied
+ * arguments. State resets at Agent Turn boundaries (session_start,
+ * agent_end) and the identical-signature streak also resets when a
+ * different tool call breaks the streak. Block messages instruct the model
+ * to stop tooling for the rest of that turn and answer in text.
  *
- * A second, independent check (#783 Brief C) tracks per-tool-name call
- * counts within a turn regardless of args. This catches improvisation
+ * The per-tool-name check (#783 Brief C) tracks call counts within a
+ * turn regardless of args, decaying after successful state-mutating tools.
+ * This catches improvisation
  * loops where the model attempts the same missing workflow tool through
  * varied surfaces (bash → `node -e` → CLI), each with a different
- * signature, so the identical-args streak never trips. Whichever guard
+ * signature, so the identical-args streak never trips, while allowing
+ * tool-heavy turns that are making file-mutation progress. Whichever guard
  * trips first blocks.
  */
 import { createHash } from "node:crypto";
+import { INHERENTLY_REPEATABLE_TOOL_SET } from "./core-session-tools.js";
+import { hasBrowserContractPrefix } from "../../shared/browser-contract.js";
+import { canonicalToolName } from "../engine-hook-contract.js";
 const MAX_CONSECUTIVE_IDENTICAL_CALLS = 4;
 /** Interactive/user-facing tools where even 1 duplicate is confusing. */
 const STRICT_LOOP_TOOLS = new Set(["ask_user_questions"]);
@@ -35,32 +42,16 @@ const MAX_CONSECUTIVE_STRICT = 1;
  */
 const PER_TOOL_DEFAULT_CAP = 6;
 const PER_TOOL_REPEATABLE_CAP = 15;
-/**
- * Inherently-repeatable tools: called many times per turn in normal work
- * (reading/writing several files, running several commands, searching). These
- * get PER_TOOL_REPEATABLE_CAP rather than the default. Keep this list
- * conservative — a tool here can be invoked up to PER_TOOL_REPEATABLE_CAP times
- * per turn before the guard blocks.
- */
-const REPEATABLE_TOOLS = new Set([
-    "read",
-    "write",
-    "edit",
-    "multi_edit",
-    "bash",
-    "grep",
-    "glob",
-    "search-the-web",
-    "fetch_page",
-    "todo_write",
-    "notebook_edit",
-]);
+const PER_TOOL_CAP_EXEMPT_TOOLS = new Set(["find", "glob", "grep", "ls", "read", "search_and_read"]);
+const STATE_MUTATING_TOOL_SET = new Set(["edit", "write", "multi_edit", "notebook_edit"]);
 let consecutiveCount = 0;
 let lastSignature = "";
 let lastToolName = "";
 let enabled = true;
 /** Per-tool-name call counts within the current turn (#783 Brief C). */
 const perToolCounts = new Map();
+let mutationEpoch = 0;
+const perToolLastMutationEpoch = new Map();
 /** Hash tool name + args into a compact signature for comparison. */
 function hashToolCall(toolName, args) {
     const h = createHash("sha256");
@@ -84,7 +75,8 @@ function hashToolCall(toolName, args) {
  *  1. Identical-signature streak (MAX_CONSECUTIVE_IDENTICAL_CALLS, strict for
  *     ask_user_questions).
  *  2. Per-tool-name cap (PER_TOOL_DEFAULT_CAP / PER_TOOL_REPEATABLE_CAP),
- *     independent of args — catches improvisation loops (#783).
+ *     independent of args, reset after file-mutation progress — catches
+ *     improvisation loops (#783).
  */
 export function checkToolCallLoop(toolName, args) {
     if (!enabled)
@@ -107,16 +99,31 @@ export function checkToolCallLoop(toolName, args) {
             block: true,
             reason: `Tool loop detected (identical args): ${toolName} called ${consecutiveCount} times ` +
                 `with identical arguments. Blocking to prevent infinite loop. ` +
-                `Try a different approach or modify your arguments.`,
+                `Do not retry this tool or call other tools this turn — stop and respond to the user in text.`,
             count: consecutiveCount,
         };
     }
     // ── Guard 2: per-tool-name cap, independent of args (#783 Brief C) ──
     // Catches improvisation loops where the same tool is invoked many times with
     // varied args (e.g. retrying a missing workflow tool via bash/node -e/CLI).
-    const perToolCount = (perToolCounts.get(toolName) ?? 0) + 1;
+    const priorPerToolCount = (perToolLastMutationEpoch.get(toolName) ?? mutationEpoch) < mutationEpoch
+        ? 0
+        : (perToolCounts.get(toolName) ?? 0);
+    const perToolCount = priorPerToolCount + 1;
     perToolCounts.set(toolName, perToolCount);
-    const perToolCap = REPEATABLE_TOOLS.has(toolName)
+    perToolLastMutationEpoch.set(toolName, mutationEpoch);
+    // Read-only navigation tools are normal context gathering; Guard 1 still
+    // catches true reread loops with identical arguments. Browser Automation
+    // Contract tools (browser_*) are the same shape: a browser-backed UAT makes
+    // many distinct-arg calls (read a message, count edits, inspect a card, …),
+    // so the arg-independent per-tool cap misfires on legitimate verification;
+    // Guard 1's identical-signature streak still catches a genuinely stuck
+    // browser loop.
+    if (PER_TOOL_CAP_EXEMPT_TOOLS.has(toolName) ||
+        hasBrowserContractPrefix(canonicalToolName(toolName))) {
+        return { block: false, count: consecutiveCount };
+    }
+    const perToolCap = INHERENTLY_REPEATABLE_TOOL_SET.has(toolName)
         ? PER_TOOL_REPEATABLE_CAP
         : PER_TOOL_DEFAULT_CAP;
     if (perToolCount > perToolCap) {
@@ -124,12 +131,21 @@ export function checkToolCallLoop(toolName, args) {
             block: true,
             reason: `Tool loop detected (repeated tool): ${toolName} called ${perToolCount} times ` +
                 `this turn (cap ${perToolCap}). Blocking to prevent infinite loop. ` +
-                `The tool may be unavailable or failing repeatedly — try a different approach.`,
+                `The tool may be unavailable or failing repeatedly. ` +
+                `Do not retry this tool or pivot to other tools this turn — stop and respond to the user in text.`,
             count: perToolCount,
         };
     }
     return { block: false, count: consecutiveCount };
 }
+/** Record successful mutation progress so Guard 2 can decay on the next count. */
+export function recordToolCallLoopMutation(toolName) {
+    if (!enabled)
+        return;
+    if (!STATE_MUTATING_TOOL_SET.has(toolName))
+        return;
+    mutationEpoch++;
+}
 /** Reset the guard state. Call at agent turn boundaries. */
 export function resetToolCallLoopGuard() {
     consecutiveCount = 0;
@@ -137,6 +153,8 @@ export function resetToolCallLoopGuard() {
     lastToolName = "";
     enabled = true;
     perToolCounts.clear();
+    mutationEpoch = 0;
+    perToolLastMutationEpoch.clear();
 }
 /** Disable the guard (e.g. during shutdown). */
 export function disableToolCallLoopGuard() {
@@ -145,6 +163,8 @@ export function disableToolCallLoopGuard() {
     lastSignature = "";
     lastToolName = "";
     perToolCounts.clear();
+    mutationEpoch = 0;
+    perToolLastMutationEpoch.clear();
 }
 /** Get current consecutive count for diagnostics. */
 export function getToolCallLoopCount() {

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -81,8 +81,18 @@ function createEmptyWriteGateState() {
     };
 }
 const writeGateStatesByBasePath = new Map();
+/**
+ * Write-gate snapshots are project-scoped, not worktree-scoped. When auto-mode
+ * routes MCP tool writes to `.gsd-worktrees/<MID>/`, depth verification still
+ * lands in the authoritative project `.gsd/runtime/` tree (or external-state
+ * symlink target). Without this canonicalization, `loadWriteGateSnapshot(worktree)`
+ * sees an empty snapshot and CONTEXT saves loop forever (#M020 gate loop).
+ */
+function resolveWriteGateSnapshotRoot(basePath) {
+    return resolve(resolveWorktreeProjectRoot(basePath));
+}
 function writeGateStateKey(basePath) {
-    return resolve(basePath);
+    return resolveWriteGateSnapshotRoot(basePath);
 }
 function getWriteGateState(basePath = process.cwd()) {
     const key = writeGateStateKey(basePath);
@@ -123,16 +133,17 @@ function shouldPersistWriteGateSnapshot(env = process.env) {
     return v !== "0" && v !== "false";
 }
 function writeGateSnapshotPath(basePath) {
-    return join(basePath, ".gsd", "runtime", "write-gate-state.json");
+    return join(resolveWriteGateSnapshotRoot(basePath), ".gsd", "runtime", "write-gate-state.json");
 }
 function ensureWriteGateSnapshotDirectory(basePath) {
-    const gsdPath = join(basePath, ".gsd");
+    const snapshotRoot = resolveWriteGateSnapshotRoot(basePath);
+    const gsdPath = join(snapshotRoot, ".gsd");
     if (!existsSync(gsdPath)) {
         try {
             const stat = lstatSync(gsdPath);
             if (stat.isSymbolicLink()) {
                 const target = readlinkSync(gsdPath);
-                mkdirSync(isAbsolute(target) ? target : resolve(basePath, target), { recursive: true });
+                mkdirSync(isAbsolute(target) ? target : resolve(snapshotRoot, target), { recursive: true });
             }
         }
         catch {
@@ -936,7 +947,7 @@ function allowedPlanningDispatchAgentsList() {
     return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
 }
 function allowsControlledSubagentDispatch(policy) {
-    return ((policy.mode === "planning-dispatch" || policy.mode === "verification") &&
+    return ((policy.mode === "planning-dispatch" || policy.mode === "verification" || policy.mode === "workflow-only") &&
         Array.isArray(policy.allowedSubagents));
 }
 function warnMissingControlledDispatchAgentClasses(unitType, mode, toolName) {
@@ -964,6 +975,7 @@ function warnMissingControlledDispatchAgentClasses(unitType, mode, toolName) {
 const PLANNING_SAFE_TOOLS = new Set([
     "read", "grep", "find", "ls", "glob",
     "ask_user_questions",
+    "memory_query",
     "search-the-web", "resolve_library", "get_library_docs", "fetch_page",
     "search_and_read",
 ]);
@@ -1020,6 +1032,9 @@ function planningBlock(unitType, mode, what) {
  *                  → allows Bash for project verification commands, keeps
  *                    writes restricted to .gsd/, and permits subagent dispatch
  *                    only when the manifest declares allowedSubagents.
+ *   - "workflow-only"
+ *                  → allows reads, GSD workflow tools, and declared read-only
+ *                    subagents; blocks generic Bash and direct file writes.
  *
  * `pathOrCommand` is the file path for write/edit-shaped tools and the
  * shell command for bash. Other tools ignore this argument.
@@ -1090,6 +1105,15 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
         }
         return planningBlock(unitType, policy.mode, "subagent dispatch is not permitted in planning units");
     }
+    if (policy.mode === "workflow-only") {
+        if (tool === "bash") {
+            return planningBlock(unitType, policy.mode, `bash is not permitted; use the unit's dedicated GSD workflow tools for durable validation output`);
+        }
+        if (PLANNING_WRITE_TOOLS.has(tool)) {
+            return planningBlock(unitType, policy.mode, `cannot ${tool} "${pathOrCommand}" — direct artifact writes are disabled; call the required GSD workflow tool instead`);
+        }
+        return planningBlock(unitType, policy.mode, `tool "${tool}" is not on the workflow-only allowlist`);
+    }
     if (tool === "bash") {
         if (policy.mode === "verification") {
             if (BASH_VERIFICATION_RE.test(pathOrCommand) || BASH_READ_ONLY_RE.test(pathOrCommand))

package/dist/resources/extensions/gsd/closeout-consistency-gate.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getLatestAssessmentByScope, getMilestone, getMilestoneSlices, getPendingGates, getSliceTasks, insertAssessment, isDbAvailable, transaction, } from "./gsd-db.js";
 import { getWorkflowDatabasePath, refreshWorkflowDatabaseFromDisk, } from "./db-workspace.js";
-import { isClosedStatus } from "./status-guards.js";
+import { isClosedStatus, isDeferredStatus } from "./status-guards.js";
 import { closeQualityGatesFromEvidence } from "./quality-gate-closure.js";
 import { insertMilestoneValidationGates } from "./milestone-validation-gates.js";
 import { relMilestoneFile, resolveSliceFile } from "./paths.js";
@@ -144,6 +144,8 @@ export function checkCloseoutConsistencyGate(milestoneId, options = {}) {
         });
     }
     for (const slice of slices) {
+        if (isDeferredStatus(slice.status))
+            continue;
         if (!isClosedStatus(slice.status)) {
             return blocked("slice-open", `Closeout consistency blocked for ${milestoneId}: slice ${slice.id} status is "${slice.status}".`);
         }

package/dist/resources/extensions/gsd/codebase-generator.js

@@ -9,9 +9,11 @@
  */
 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, } from "./repository-registry.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
 // ─── Defaults ────────────────────────────────────────────────────────────────
 const DEFAULT_EXCLUDES = [
     // ── AI / tooling meta ──
@@ -144,6 +146,84 @@ function enumerateFiles(basePath, excludes, maxFiles) {
     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) {
+    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) {
+    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, excludes, maxFiles) {
+    const perRepo = [];
+    const seen = new Set();
+    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 = [];
+        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 = [];
+    const repos = [];
+    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) {
     const excludes = [...DEFAULT_EXCLUDES, ...(options?.excludePatterns ?? [])];
     const maxFiles = options?.maxFiles ?? DEFAULT_MAX_FILES;
@@ -159,38 +239,69 @@ function resolveGeneratorOptions(options) {
         }),
     };
 }
-function computeCodebaseFingerprint(files, resolved, truncated) {
+function computeCodebaseFingerprint(files, resolved, truncated, repos) {
     return createHash("sha1")
         .update(JSON.stringify({
         files,
+        ...(repos ? { repos } : {}),
         truncated,
         optionSignature: resolved.optionSignature,
     }))
         .digest("hex");
 }
 // ─── Grouping ────────────────────────────────────────────────────────────────
-function groupByDirectory(files, descriptions, collapseThreshold) {
+function groupByDirectory(files, descriptions, collapseThreshold, repos) {
     const dirMap = new Map();
-    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 = [];
-    const sortedDirs = [...dirMap.keys()].sort();
-    for (const dir of sortedDirs) {
-        const dirFiles = dirMap.get(dir);
+    const repoOrder = new Map();
+    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 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,
         });
     }
     return groups;
@@ -207,7 +318,18 @@ function renderCodebaseMap(groups, totalFiles, truncated, metadata) {
         lines.push(`Note: Truncated to first ${totalFiles} files. Run with higher --max-files to include all.`);
     }
     lines.push("");
+    let emittedRepo;
     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}/`);
         if (group.collapsed) {
@@ -250,13 +372,15 @@ function renderCodebaseMap(groups, totalFiles, truncated, metadata) {
 function buildCodebaseMap(basePath, resolved, existingDescriptions, enumerated) {
     const listed = enumerated ?? enumerateFiles(basePath, resolved.excludes, resolved.maxFiles);
     const descriptions = existingDescriptions ?? new Map();
-    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 = {
         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);
     return {
@@ -273,9 +397,21 @@ function buildCodebaseMap(basePath, resolved, existingDescriptions, enumerated)
  * 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, resolved) {
+    const registry = loadWorkspaceRegistry(basePath);
+    if (!registry)
+        return undefined;
+    return enumerateWorkspaceFiles(registry, resolved.excludes, resolved.maxFiles);
+}
 export function generateCodebaseMap(basePath, options, existingDescriptions) {
     const resolved = resolveGeneratorOptions(options);
-    return buildCodebaseMap(basePath, resolved, existingDescriptions);
+    const enumerated = resolveWorkspaceEnumeration(basePath, resolved);
+    return buildCodebaseMap(basePath, resolved, existingDescriptions, enumerated);
 }
 /**
  * Incremental update: re-scan files, preserve existing descriptions,
@@ -293,7 +429,8 @@ export function updateCodebaseMap(basePath, options) {
     const existingFiles = new Set(existingDescriptions.keys());
     // 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
     let added = 0;
@@ -326,7 +463,7 @@ function clearFreshnessCache(basePath) {
 }
 export function ensureCodebaseMapFresh(basePath, options, ensureOptions) {
     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();
@@ -338,8 +475,9 @@ export function ensureCodebaseMapFresh(basePath, options, ensureOptions) {
         }
     }
     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) => {
         freshnessCache.set(cacheKey, { checkedAt: now, result });
         return result;

package/dist/resources/extensions/gsd/commands/handlers/auto.js

@@ -190,7 +190,7 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
             }
             return true;
         }
-        await pauseAuto(ctx, pi);
+        await pauseAuto(ctx, pi, undefined, { abortActiveTurn: true });
         return true;
     }
     if (trimmed === "rate" || trimmed.startsWith("rate ")) {

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -1,6 +1,8 @@
 import { createRequire } from "node:module";
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
-import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, modelIdsForProfileResolution, resolveProfileAnchorProvider, resolveDisabledModelProvidersFromPreferences } from "../../preferences.js";
+import { isRepositoryDirty } from "../../git-service.js";
+import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, 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";
@@ -206,7 +208,7 @@ export async function handleStatus(ctx) {
         },
     });
     if (result === undefined) {
-        ctx.ui.notify(formatTextStatus(state), "info");
+        ctx.ui.notify(formatTextStatus(state, basePath), "info");
     }
 }
 export async function fireStatusViaCommand(ctx) {
@@ -539,7 +541,8 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
     }
     return false;
 }
-export function formatTextStatus(state) {
+export function formatTextStatus(state, basePath) {
+    const root = basePath ?? projectRoot();
     const lines = ["GSD Status\n"];
     lines.push(formatProgressLine(computeProgressScore()));
     lines.push("");
@@ -582,7 +585,7 @@ export function formatTextStatus(state) {
             lines.push(`  ${icon} ${milestone.id}: ${milestone.title} (${milestone.status})`);
         }
     }
-    const envResults = runEnvironmentChecks(projectRoot());
+    const envResults = runEnvironmentChecks(root);
     const envIssues = envResults.filter((result) => result.status !== "ok");
     if (envIssues.length > 0) {
         lines.push("");
@@ -591,5 +594,38 @@ export function formatTextStatus(state) {
             lines.push(`  ${issue.status === "error" ? "✗" : "⚠"} ${issue.message}`);
         }
     }
+    // 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) {
+    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");
+}