gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.2e8b124f7

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

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
 import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath } from "../../preferences.js";
 import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard, handleLanguage } from "../../commands-prefs-wizard.js";
@@ -7,6 +8,8 @@ import { handleCmux } from "../../commands-cmux.js";
 import { setSessionModelOverride } from "../../session-model-override.js";
 import { projectRoot } from "../context.js";
 import { formattedShortcutPair } from "../../shortcut-defs.js";
+import { getVisualBriefOutputDir } from "../../../visual-brief/artifact-policy.js";
+import { buildVisualBriefPrompt, parseVisualBriefArgs, VISUAL_BRIEF_USAGE } from "../../../visual-brief/prompts.js";
 export function showHelp(ctx, args = "") {
     const summaryLines = [
         "GSD — Get Shit Done\n",
@@ -22,6 +25,7 @@ export function showHelp(ctx, args = "") {
         `  /gsd parallel watch Parallel monitor  (${formattedShortcutPair("parallel")})`,
         `  /gsd notifications  Notification history  (${formattedShortcutPair("notifications")})`,
         "  /gsd visualize      Interactive 10-tab TUI",
+        "  /gsd brief <mode>   Visual HTML brief (diagram, plan, diff, recap, table, slides)",
         "  /gsd queue          Show queued/dispatched units",
         "",
         "COURSE CORRECTION",
@@ -61,6 +65,7 @@ export function showHelp(ctx, args = "") {
         "  /gsd new-project    Bootstrap a new project (use --deep for staged project-level discovery)",
         "  /gsd quick          Execute a quick task without full planning overhead",
         "  /gsd dispatch       Dispatch a specific phase directly  [research|plan|execute|complete|uat|replan]",
+        "  /gsd verdict <v>    Override milestone validation verdict  [pass|needs-attention|needs-remediation] [--milestone Mxxx] [--rationale \"...\"]",
         "  /gsd parallel       Parallel milestone orchestration  [start|status|stop|pause|resume|merge|watch]",
         "  /gsd workflow       Custom workflow lifecycle  [new|run|list|validate|pause|resume]",
         "",
@@ -69,6 +74,7 @@ export function showHelp(ctx, args = "") {
         `  /gsd parallel watch Open parallel worker monitor  (${formattedShortcutPair("parallel")})`,
         "  /gsd widget         Cycle status widget  [full|small|min|off]",
         "  /gsd visualize      Interactive 10-tab TUI (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)",
+        "  /gsd brief <mode>   Generate a visual HTML brief  [diagram|plan|diff|recap|table|slides] [topic] [--slides]",
         "  /gsd queue          Show queued/dispatched units and execution order",
         "  /gsd history        View execution history  [--cost] [--phase] [--model] [N]",
         "  /gsd changelog      Show categorized release notes  [version]",
@@ -182,6 +188,34 @@ export async function handleVisualize(ctx) {
         ctx.ui.notify("Visualizer requires an interactive terminal. Use /gsd status for a text-based overview.", "warning");
     }
 }
+export async function handleBrief(args, ctx, pi) {
+    const request = parseVisualBriefArgs(args);
+    if (!request) {
+        ctx.ui.notify(VISUAL_BRIEF_USAGE, "info");
+        return;
+    }
+    if (!pi?.sendUserMessage) {
+        ctx.ui.notify("Visual brief generation is unavailable in this context.", "warning");
+        return;
+    }
+    const outputDir = getVisualBriefOutputDir();
+    const version = resolveGsdVersion();
+    pi.sendUserMessage(buildVisualBriefPrompt(request, { outputDir, version }));
+}
+const briefRequire = createRequire(import.meta.url);
+function resolveGsdVersion() {
+    const envVersion = process.env.GSD_VERSION?.trim();
+    if (envVersion)
+        return envVersion;
+    try {
+        const pkg = briefRequire("../../../../../../package.json");
+        const fromPkg = typeof pkg.version === "string" ? pkg.version.trim() : "";
+        return fromPkg || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function handleSetup(args, ctx, pi) {
     const { detectProjectState, hasGlobalSetup } = await import("../../detection.js");
     const { isOnboardingComplete, readOnboardingRecord } = await import("../../onboarding-state.js");
@@ -370,6 +404,10 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
         await handleVisualize(ctx);
         return true;
     }
+    if (trimmed === "brief" || trimmed.startsWith("brief ")) {
+        await handleBrief(trimmed.replace(/^brief\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     if (trimmed === "widget" || trimmed.startsWith("widget ")) {
         const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await import("../../auto-dashboard.js");
         const arg = trimmed.replace(/^widget\s*/, "").trim();

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

@@ -14,6 +14,21 @@ import { handleSessionReport } from "../../commands-session-report.js";
 import { handlePrBranch } from "../../commands-pr-branch.js";
 import { currentDirectoryRoot, projectRoot } from "../context.js";
 export async function handleOpsCommand(trimmed, ctx, pi) {
+    const directDispatchAlias = new Map([
+        ["research-milestone", "research"],
+        ["research-slice", "research"],
+        ["plan-milestone", "plan"],
+        ["plan-slice", "plan"],
+        ["execute-task", "execute"],
+        ["complete-slice", "complete"],
+        ["validate-milestone", "uat"],
+        ["complete-milestone", "complete"],
+    ]);
+    const aliasPhase = directDispatchAlias.get(trimmed);
+    if (aliasPhase) {
+        await dispatchDirectPhase(ctx, pi, aliasPhase, projectRoot());
+        return true;
+    }
     if (trimmed === "init") {
         const { detectProjectState } = await import("../../detection.js");
         const { handleReinit, showProjectInit } = await import("../../init-wizard.js");
@@ -183,6 +198,11 @@ Examples:
         await dispatchDirectPhase(ctx, pi, phase, projectRoot());
         return true;
     }
+    if (trimmed === "verdict" || trimmed.startsWith("verdict ")) {
+        const { handleVerdict } = await import("../../commands-verdict.js");
+        await handleVerdict(trimmed.replace(/^verdict\s*/, "").trim(), ctx, projectRoot());
+        return true;
+    }
     if (trimmed === "notifications" || trimmed.startsWith("notifications ")) {
         const { handleNotificationsCommand } = await import("./notifications-handler.js");
         await handleNotificationsCommand(trimmed.replace(/^notifications\s*/, "").trim(), ctx, pi);

package/dist/resources/extensions/gsd/commands-bootstrap.js

@@ -1,4 +1,5 @@
 import { importExtensionModule } from "@gsd/pi-coding-agent";
+import { VISUAL_BRIEF_MODES } from "../visual-brief/prompts.js";
 const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -7,6 +8,7 @@ const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "pause", desc: "Pause auto-mode (preserves state, /gsd auto to resume)" },
     { cmd: "status", desc: "Progress dashboard" },
     { cmd: "visualize", desc: "Open workflow visualizer" },
+    { cmd: "brief", desc: "Generate a visual HTML brief" },
     { cmd: "queue", desc: "Queue and reorder future milestones" },
     { cmd: "quick", desc: "Execute a quick task without full planning overhead" },
     { cmd: "discuss", desc: "Discuss architecture and decisions" },
@@ -75,6 +77,9 @@ function getGsdArgumentCompletions(prefix) {
             { cmd: "--dry-run", desc: "Preview next step without executing" },
         ], "next");
     }
+    if (parts[0] === "brief" && parts.length <= 2) {
+        return filterStartsWith(partial, VISUAL_BRIEF_MODES.map((mode) => ({ cmd: mode.mode, desc: mode.description })), "brief");
+    }
     if ((parts[0] === "new-project" || parts[0] === "new-milestone") && parts.length <= 2) {
         return filterStartsWith(partial, [
             { cmd: "--deep", desc: "Enable deep planning mode (staged project-level discovery)" },

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

@@ -101,6 +101,8 @@ export async function handleDoctor(args, ctx, pi) {
     const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
     const effectiveScope = mode === "audit" ? requestedScope : scope;
+    const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+    await ensureDbOpen(projectRoot());
     const report = await runGSDDoctor(projectRoot(), {
         fix: mode === "fix" || mode === "heal" || dryRun || fixFlag,
         dryRun,

package/dist/resources/extensions/gsd/commands-mcp-status.js

@@ -13,6 +13,10 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { ensureProjectWorkflowMcpConfig } from "./mcp-project-config.js";
 import { gsdHome } from "./gsd-home.js";
+export function hasHostMcpTool(systemPrompt, serverName) {
+    const marker = `mcp__${serverName}__`;
+    return systemPrompt.includes(marker);
+}
 export function formatMcpInitResult(status, configPath, targetPath) {
     const summary = status === "created"
         ? "Created project MCP config."
@@ -132,6 +136,7 @@ export async function handleMcpStatus(args, ctx) {
     const trimmed = args.trim();
     const lowered = trimmed.toLowerCase();
     const configs = readMcpConfigs();
+    const systemPrompt = ctx.getSystemPrompt();
     // /gsd mcp init [dir]
     if (!lowered || lowered === "status") {
         // handled below
@@ -175,6 +180,8 @@ export async function handleMcpStatus(args, ctx) {
         catch {
             // mcp-client may not expose status helpers — that's fine
         }
+        if (!connected && !error && hasHostMcpTool(systemPrompt, serverName))
+            connected = true;
         ctx.ui.notify(formatMcpServerDetail({
             name: config.name,
             transport: config.transport,
@@ -206,6 +213,8 @@ export async function handleMcpStatus(args, ctx) {
             catch {
                 // Fall back to unknown state
             }
+            if (!connected && !error && hasHostMcpTool(systemPrompt, config.name))
+                connected = true;
             statuses.push({
                 name: config.name,
                 transport: config.transport,

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -571,10 +571,18 @@ async function configureModels(ctx, prefs) {
     ];
     const models = prefs.models ?? {};
     const availableModels = ctx.modelRegistry.getAvailable();
-    if (availableModels.length > 0) {
+    // Call getAllWithDiscovered as a method so `this` stays bound to the
+    // registry — invoking a detached reference loses `this` and the method's
+    // internal `this.models` access throws.
+    const registry = ctx.modelRegistry;
+    const availableProviders = new Set(availableModels.map((m) => m.provider));
+    const selectableModels = typeof registry.getAllWithDiscovered === "function"
+        ? registry.getAllWithDiscovered().filter((m) => availableProviders.has(m.provider))
+        : availableModels;
+    if (selectableModels.length > 0) {
         // Group models by provider, sorted alphabetically
         const byProvider = new Map();
-        for (const m of availableModels) {
+        for (const m of selectableModels) {
             let group = byProvider.get(m.provider);
             if (!group) {
                 group = [];

package/dist/resources/extensions/gsd/commands-verdict.js

@@ -0,0 +1,139 @@
+import { loadFile } from "./files.js";
+import { resolveMilestoneFile } from "./paths.js";
+import { deriveState } from "./state.js";
+import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
+import { VALIDATION_VERDICTS, extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
+const USAGE = 'Usage: /gsd verdict <pass|needs-attention|needs-remediation> [--milestone Mxxx] [--rationale "..."]';
+function tokenize(raw) {
+    const tokens = [];
+    const re = /"([^"]*)"|(\S+)/g;
+    let match;
+    while ((match = re.exec(raw)) !== null) {
+        tokens.push(match[1] ?? match[2]);
+    }
+    return tokens;
+}
+function parseArgs(raw) {
+    const tokens = tokenize(raw);
+    const out = {};
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "--milestone") {
+            const next = tokens[++i];
+            if (!next)
+                return { error: "--milestone requires a milestone ID" };
+            out.milestoneId = next;
+        }
+        else if (t === "--rationale") {
+            const next = tokens[++i];
+            if (next == null)
+                return { error: "--rationale requires a value" };
+            out.rationale = next;
+        }
+        else if (!out.verdict) {
+            if (!isValidMilestoneVerdict(t)) {
+                return {
+                    error: `Invalid verdict "${t}". Must be one of: ${VALIDATION_VERDICTS.join(", ")}`,
+                };
+            }
+            out.verdict = t;
+        }
+        else {
+            return { error: `Unexpected argument: ${t}` };
+        }
+    }
+    return out;
+}
+function extractRemediationRound(content) {
+    const fm = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fm)
+        return 0;
+    const m = fm[1].match(/^remediation_round:\s*(\d+)/im);
+    return m ? Number.parseInt(m[1], 10) : 0;
+}
+function extractSection(content, heading) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Match section bodies bounded by the next "## " heading or end-of-string.
+    // Leading "\n" prefix lets a single pattern handle first-line headings too.
+    // No /m flag — we want `$` to mean end-of-string, not end-of-line.
+    const re = new RegExp(`\\n## ${escaped}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+    const m = ("\n" + content).match(re);
+    if (!m)
+        return undefined;
+    return m[1].replace(/\s+$/, "");
+}
+export function parseValidationFile(content) {
+    return {
+        verdict: extractVerdict(content),
+        remediationRound: extractRemediationRound(content),
+        successCriteriaChecklist: extractSection(content, "Success Criteria Checklist") ?? "",
+        sliceDeliveryAudit: extractSection(content, "Slice Delivery Audit") ?? "",
+        crossSliceIntegration: extractSection(content, "Cross-Slice Integration") ?? "",
+        requirementCoverage: extractSection(content, "Requirement Coverage") ?? "",
+        verificationClasses: extractSection(content, "Verification Class Compliance"),
+        verdictRationale: extractSection(content, "Verdict Rationale") ?? "",
+        remediationPlan: extractSection(content, "Remediation Plan"),
+    };
+}
+export async function handleVerdict(rawArgs, ctx, basePath) {
+    if (!rawArgs.trim()) {
+        ctx.ui.notify(USAGE, "warning");
+        return;
+    }
+    const parsed = parseArgs(rawArgs);
+    if ("error" in parsed) {
+        ctx.ui.notify(`${parsed.error}\n${USAGE}`, "warning");
+        return;
+    }
+    if (!parsed.verdict) {
+        ctx.ui.notify(USAGE, "warning");
+        return;
+    }
+    let milestoneId = parsed.milestoneId;
+    if (!milestoneId) {
+        const state = await deriveState(basePath);
+        if (!state.activeMilestone) {
+            ctx.ui.notify("No active milestone — pass --milestone Mxxx to target a specific milestone.", "warning");
+            return;
+        }
+        milestoneId = state.activeMilestone.id;
+    }
+    const validationPath = resolveMilestoneFile(basePath, milestoneId, "VALIDATION");
+    if (!validationPath) {
+        ctx.ui.notify(`No VALIDATION file found for ${milestoneId}. Run gsd_validate_milestone first to produce one.`, "warning");
+        return;
+    }
+    const existing = await loadFile(validationPath);
+    if (!existing) {
+        ctx.ui.notify(`Could not read VALIDATION file for ${milestoneId} (${validationPath}).`, "warning");
+        return;
+    }
+    const current = parseValidationFile(existing);
+    if (parsed.verdict !== "pass" && !parsed.rationale) {
+        ctx.ui.notify(`--rationale is required when overriding to ${parsed.verdict}.`, "warning");
+        return;
+    }
+    const verdictRationale = parsed.rationale ?? "Manually overridden via /gsd verdict";
+    const result = await executeValidateMilestone({
+        milestoneId,
+        verdict: parsed.verdict,
+        remediationRound: current.remediationRound,
+        successCriteriaChecklist: current.successCriteriaChecklist,
+        sliceDeliveryAudit: current.sliceDeliveryAudit,
+        crossSliceIntegration: current.crossSliceIntegration,
+        requirementCoverage: current.requirementCoverage,
+        verificationClasses: current.verificationClasses,
+        verdictRationale,
+        remediationPlan: current.remediationPlan,
+    }, basePath);
+    if (result.isError) {
+        const msg = result.content[0]?.type === "text" ? result.content[0].text : "Unknown error";
+        ctx.ui.notify(msg, "error");
+        return;
+    }
+    const prevVerdict = current.verdict ?? "unknown";
+    ctx.ui.notify(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${parsed.verdict}`, "success");
+    if (parsed.verdict === "needs-remediation") {
+        ctx.ui.notify("Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.", "info");
+    }
+}

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -23,7 +23,9 @@
 import { emitJournalEvent, queryJournal, } from "./journal.js";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import { findStaleWorkerForProject, getAllAutoWorkers, } from "./db/auto-workers.js";
+import { findStaleWorkerForProject, getAllAutoWorkers, markWorkerCrashed, markWorkerStopping, } from "./db/auto-workers.js";
+import { forceReleaseLeasesForWorker } from "./db/milestone-leases.js";
+import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { getRuntimeKv, setRuntimeKv, deleteRuntimeKv } from "./db/runtime-kv.js";
 import { _getAdapter, isDbAvailable } from "./gsd-db.js";
 import { gsdRoot, normalizeRealPath } from "./paths.js";
@@ -34,6 +36,16 @@ const SESSION_FILE_KV_KEY = "session_file";
 function lockPath(basePath) {
     return join(gsdRoot(basePath), effectiveLockFile());
 }
+function clearLegacyLockFile(basePath) {
+    try {
+        const p = lockPath(basePath);
+        if (existsSync(p))
+            unlinkSync(p);
+    }
+    catch {
+        // Best-effort.
+    }
+}
 function readLegacyLock(basePath) {
     try {
         const p = lockPath(basePath);
@@ -145,14 +157,21 @@ export function writeLock(basePath, unitType, unitId, sessionFile) {
     catch {
         // Best-effort — never throw from the lock writer.
     }
-    if (!isDbAvailable() || !sessionFile)
+    if (!isDbAvailable())
         return;
     try {
         const projectRoot = normalizeRealPath(basePath);
         const worker = findActiveWorkerForCurrentProcess(projectRoot);
         if (!worker)
             return;
-        setRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY, sessionFile);
+        if (sessionFile) {
+            setRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY, sessionFile);
+        }
+        else {
+            // Preliminary unit locks (before runUnit/newSession settles) must clear
+            // any prior pointer so crash recovery cannot ingest stale cross-unit context.
+            deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        }
     }
     catch {
         // Best-effort — never throw from the lock writer.
@@ -166,21 +185,47 @@ export function writeLock(basePath, unitType, unitId, sessionFile) {
  * stale session-file pointer.
  */
 export function clearLock(basePath) {
+    clearLegacyLockFile(basePath);
+    if (!isDbAvailable())
+        return;
     try {
-        const p = lockPath(basePath);
-        if (existsSync(p))
-            unlinkSync(p);
+        const projectRoot = normalizeRealPath(basePath);
+        const staleWorker = findStaleWorkerForProject(projectRoot);
+        if (staleWorker) {
+            markWorkerCrashed(staleWorker.worker_id);
+            forceReleaseLeasesForWorker(staleWorker.worker_id);
+            deleteRuntimeKv("worker", staleWorker.worker_id, SESSION_FILE_KV_KEY);
+            return;
+        }
+        const worker = findActiveWorkerForCurrentProcess(projectRoot);
+        if (worker)
+            deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        const stale = findStaleWorkerForProject(projectRoot);
+        if (stale) {
+            markWorkerStopping(stale.worker_id);
+            deleteRuntimeKv("worker", stale.worker_id, SESSION_FILE_KV_KEY);
+        }
     }
     catch {
         // Best-effort.
     }
+}
+/**
+ * Clear a stale DB-backed worker lock after readCrashLock/findStaleWorkerForProject
+ * has identified a dead worker. Unlike clearLock(), this targets the stale
+ * worker row instead of the current process's active worker.
+ */
+export function clearStaleWorkerLock(basePath) {
+    clearLegacyLockFile(basePath);
     if (!isDbAvailable())
         return;
     try {
         const projectRoot = normalizeRealPath(basePath);
-        const worker = findActiveWorkerForCurrentProcess(projectRoot);
+        const worker = findStaleWorkerForProject(projectRoot);
         if (!worker)
             return;
+        markLatestActiveForWorkerCanceled(worker.worker_id, "crash-recovered");
+        markWorkerCrashed(worker.worker_id);
         deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
     }
     catch {

package/dist/resources/extensions/gsd/db/milestone-leases.js

@@ -193,6 +193,30 @@ export function releaseMilestoneLease(workerId, milestoneId, fencingToken) {
         return changes === 1;
     });
 }
+/**
+ * Force-release all held leases for a worker.
+ *
+ * Used by crash recovery once PID liveness has confirmed the worker is dead.
+ * No fencing token is required because this path is cleanup-only for a
+ * non-running process.
+ */
+export function forceReleaseLeasesForWorker(workerId) {
+    if (!isDbAvailable())
+        return 0;
+    const db = _getAdapter();
+    let changes = 0;
+    transaction(() => {
+        const result = db.prepare(`UPDATE milestone_leases
+       SET status = 'released'
+       WHERE worker_id = :worker_id
+         AND status = 'held'`).run({ ":worker_id": workerId });
+        changes =
+            typeof result.changes === "number"
+                ? result.changes
+                : 0;
+    });
+    return changes;
+}
 /**
  * Read current lease row for diagnostics. Returns null if no row exists.
  */

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -391,16 +391,17 @@ export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20)
     if (!isDbAvailable())
         return [];
     const db = _getAdapter();
-    const rows = db.prepare(`SELECT ud.unit_id
+    const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
      FROM unit_dispatches ud
      INNER JOIN workers w ON w.worker_id = ud.worker_id
      WHERE w.project_root_realpath = :project_root_realpath
+       AND w.status != 'crashed'
      ORDER BY ud.started_at DESC, ud.id DESC
      LIMIT :limit`).all({
         ":project_root_realpath": projectRootRealpath,
         ":limit": limit,
     });
-    return rows.reverse().map((r) => ({ key: r.unit_id }));
+    return rows.reverse().map((r) => ({ key: `${r.unit_type}/${r.unit_id}` }));
 }
 /**
  * Fetch dispatches for a milestone filtered by status. Useful for janitors

package/dist/resources/extensions/gsd/db-base-schema.js

@@ -149,6 +149,7 @@ export function createBaseSchemaObjects(db, hooks) {
       proof_level TEXT NOT NULL DEFAULT '',
       integration_closure TEXT NOT NULL DEFAULT '',
       observability_impact TEXT NOT NULL DEFAULT '',
+      target_repositories TEXT NOT NULL DEFAULT '[]',
       sequence INTEGER DEFAULT 0,
       replan_triggered_at TEXT DEFAULT NULL,
       is_sketch INTEGER NOT NULL DEFAULT 0,
@@ -188,6 +189,7 @@ export function createBaseSchemaObjects(db, hooks) {
       expected_output TEXT NOT NULL DEFAULT '[]',
       observability_impact TEXT NOT NULL DEFAULT '',
       full_plan_md TEXT NOT NULL DEFAULT '',
+      target_repositories TEXT NOT NULL DEFAULT '[]',
       sequence INTEGER DEFAULT 0,
       PRIMARY KEY (milestone_id, slice_id, id),
       FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)

package/dist/resources/extensions/gsd/db-migration-steps.js

@@ -385,6 +385,10 @@ export function applyMigrationV27ArtifactHash(db) {
 export function applyMigrationV28MemoryLastHitAt(db) {
     ensureColumn(db, "memories", "last_hit_at", "ALTER TABLE memories ADD COLUMN last_hit_at TEXT DEFAULT NULL");
 }
+export function applyMigrationV29RepositoryTargets(db) {
+    ensureColumn(db, "slices", "target_repositories", "ALTER TABLE slices ADD COLUMN target_repositories TEXT NOT NULL DEFAULT '[]'");
+    ensureColumn(db, "tasks", "target_repositories", "ALTER TABLE tasks ADD COLUMN target_repositories TEXT NOT NULL DEFAULT '[]'");
+}
 export function applyMigrationV22QualityGateRepair(db, hooks) {
     const qgInfo = db.prepare("PRAGMA table_info(quality_gates)").all();
     const taskIdCol = qgInfo.find((r) => r["name"] === "task_id");

package/dist/resources/extensions/gsd/db-task-slice-rows.js

@@ -48,6 +48,7 @@ export function rowToSlice(row) {
         replan_triggered_at: row["replan_triggered_at"] ?? null,
         is_sketch: row["is_sketch"] ?? 0,
         sketch_scope: row["sketch_scope"] ?? "",
+        target_repositories: parseTaskArrayColumn(row["target_repositories"]),
     };
 }
 export function rowToTask(row) {
@@ -82,5 +83,6 @@ export function rowToTask(row) {
         escalation_awaiting_review: row["escalation_awaiting_review"] ?? 0,
         escalation_artifact_path: row["escalation_artifact_path"] ?? null,
         escalation_override_applied_at: row["escalation_override_applied_at"] ?? null,
+        target_repositories: parseTaskArrayColumn(row["target_repositories"]),
     };
 }

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -4,7 +4,7 @@ import { findMilestoneIds } from "./guided-flow.js";
 import { parseUnitId } from "./unit-id.js";
 import { isDbAvailable, getMilestoneSlices, getMilestone } from "./gsd-db.js";
 import { parseRoadmap } from "./parsers-legacy.js";
-import { isClosedStatus } from "./status-guards.js";
+import { isClosedStatus, isSkippedForDispatch } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { readFileSync } from "node:fs";
 const SLICE_DISPATCH_TYPES = new Set([
@@ -14,6 +14,50 @@ const SLICE_DISPATCH_TYPES = new Set([
     "execute-task",
     "complete-slice",
 ]);
+const CONSECUTIVE_SAME_UNIT_CAP_TYPES = new Set([
+    "complete-milestone",
+    "validate-milestone",
+    "research-slice",
+]);
+const CONSECUTIVE_SAME_UNIT_CAP = 2;
+/**
+ * Prevent repeated dispatches of the same unit within the same phase.
+ *
+ * Applies only to unit types in `CONSECUTIVE_SAME_UNIT_CAP_TYPES`. The first
+ * dispatch for a unit/phase pair starts a counter, unit or phase changes reset
+ * tracking, and dispatch is blocked once the counter reaches
+ * `CONSECUTIVE_SAME_UNIT_CAP`.
+ *
+ * Side effects: mutates `state.consecutiveDispatchCount`,
+ * `state.lastDispatchedKey`, and `state.lastDispatchPhase`.
+ *
+ * Returns `null` when dispatch is allowed, or a blocker message (including
+ * guidance to run `/gsd resume`) when the cap is reached.
+ */
+export function getConsecutiveDispatchBlocker(state, phase, unitType, unitId) {
+    if (!CONSECUTIVE_SAME_UNIT_CAP_TYPES.has(unitType))
+        return null;
+    if (!state.consecutiveDispatchCount)
+        state.consecutiveDispatchCount = new Map();
+    const key = `${unitType}:${unitId}`;
+    const phaseChanged = state.lastDispatchPhase !== phase;
+    const switchedUnit = state.lastDispatchedKey !== key;
+    if (phaseChanged || switchedUnit) {
+        state.consecutiveDispatchCount.clear();
+        state.consecutiveDispatchCount.set(key, 1);
+        state.lastDispatchedKey = key;
+        state.lastDispatchPhase = phase;
+        return null;
+    }
+    const count = state.consecutiveDispatchCount.get(key) ?? 0;
+    if (count >= CONSECUTIVE_SAME_UNIT_CAP) {
+        return `Cannot dispatch ${unitType} ${unitId}: dispatched ${count} consecutive times; same-unit repeat cap reached. Resolve via /gsd resume.`;
+    }
+    state.consecutiveDispatchCount.set(key, count + 1);
+    state.lastDispatchedKey = key;
+    state.lastDispatchPhase = phase;
+    return null;
+}
 export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unitId) {
     if (!SLICE_DISPATCH_TYPES.has(unitType))
         return null;
@@ -49,7 +93,7 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
         //      DB-backed projects must not treat SUMMARY.md as authoritative.
         if (isDbAvailable()) {
             const milestoneRow = getMilestone(mid);
-            if (milestoneRow && isClosedStatus(milestoneRow.status))
+            if (milestoneRow && isSkippedForDispatch(milestoneRow.status))
                 continue;
         }
         else {

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -147,6 +147,14 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `unique_milestone_ids`: boolean — when `true`, generates milestone IDs in `M{seq}-{rand6}` format (e.g. `M001-eh88as`) instead of plain sequential `M001`. Prevents ID collisions in team workflows where multiple contributors create milestones concurrently. Both formats coexist — existing `M001`-style milestones remain valid. Default: `false`.
 
+- `workspace`: optional parent-workspace repository registry. Keys:
+  - `mode`: `"project"` or `"parent"` — registry mode for repository lookup. Default: `"project"`.
+  - `repositories`: object keyed by repository id. A default `"project"` repository pointing at the project root is always available, even when not listed here (and can be overridden by explicitly defining `"project"`). Each repository supports:
+    - `path`: string — repository root path relative to project root.
+    - `role`: string — optional human label for prompts/reporting.
+    - `verification`: string[] — optional default verification commands.
+    - `commit_policy`: `"auto"` or `"skip"` — optional turn-commit policy for auto-mode commit actions. Defaults to `"auto"` when omitted. `"skip"` suppresses commit execution for that target repo.
+
 - `budget_ceiling`: number — maximum dollar amount to spend on auto-mode. When reached, behavior is controlled by `budget_enforcement`. Default: no limit.
 
 - `budget_enforcement`: `"warn"`, `"pause"`, or `"halt"` — action taken when `budget_ceiling` is reached.