gsd-pi 2.82.0-dev.c22380fc3 → 2.82.0-dev.e7a7f1ed5

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -2,7 +2,8 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { gsdHome } from "../gsd-home.js";
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|new-project|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|workflow|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language|worktree|eval-review";
+import { VISUAL_BRIEF_MODES } from "../../visual-brief/prompts.js";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|brief|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|new-project|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|workflow|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language|worktree|eval-review";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -12,6 +13,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "status", desc: "Progress dashboard" },
     { cmd: "widget", desc: "Cycle widget: full → small → min → off" },
     { cmd: "visualize", desc: "Open 10-tab workflow visualizer (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)" },
+    { cmd: "brief", desc: "Generate a visual HTML brief: diagram, plan, diff review, recap, table, or slides" },
     { 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,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "eval-review", desc: "Audit a slice's AI evaluation strategy and write a scored EVAL-REVIEW.md (--force, --show)" },
 ];
 const NESTED_COMPLETIONS = {
+    brief: VISUAL_BRIEF_MODES.map((mode) => ({ cmd: mode.mode, desc: mode.description })),
     auto: [
         { cmd: "--verbose", desc: "Show detailed execution output" },
         { cmd: "--debug", desc: "Enable debug logging" },

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",
@@ -69,6 +73,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 +187,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 +403,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-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-prefs-wizard.js

@@ -571,10 +571,15 @@ async function configureModels(ctx, prefs) {
     ];
     const models = prefs.models ?? {};
     const availableModels = ctx.modelRegistry.getAvailable();
-    if (availableModels.length > 0) {
+    const getAllWithDiscovered = ctx.modelRegistry.getAllWithDiscovered;
+    const availableProviders = new Set(availableModels.map((m) => m.provider));
+    const selectableModels = typeof getAllWithDiscovered === "function"
+        ? 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/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);
@@ -166,21 +178,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/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([
@@ -49,7 +49,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/doctor-git-checks.js

@@ -7,7 +7,7 @@ import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
-import { listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
+import { createWorktree, listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
 import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
@@ -50,6 +50,21 @@ function isSameOrNestedPath(candidate, container) {
     return normalizedCandidate === normalizedContainer ||
         normalizedCandidate.startsWith(`${normalizedContainer}/`);
 }
+function hasProjectContentOnDisk(dirPath) {
+    try {
+        for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+            if (entry.name === ".git" || entry.name === ".gsd")
+                continue;
+            if (entry.name === ".DS_Store")
+                continue;
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
 function getSnapshotDiffCheckFailure(basePath) {
     const failures = [];
     for (const args of [["--cached"], []]) {
@@ -104,6 +119,36 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 const isComplete = milestoneEntry
                     ? await isCompletedMilestoneTerminal(basePath, milestoneId)
                     : false;
+                if (!isComplete && !hasProjectContentOnDisk(wt.path) && hasProjectContentOnDisk(basePath)) {
+                    issues.push({
+                        severity: "error",
+                        code: "worktree_empty_with_project_content",
+                        scope: "milestone",
+                        unitId: milestoneId,
+                        message: `Worktree ${wt.path} has no project content, but project root ${basePath} does. Run doctor --fix to recreate the worktree.`,
+                        fixable: true,
+                    });
+                    if (shouldFix("worktree_empty_with_project_content")) {
+                        try {
+                            nativeWorktreeRemove(basePath, wt.path, true);
+                            const recreated = createWorktree(basePath, milestoneId, {
+                                branch: wt.branch,
+                                reuseExistingBranch: true,
+                            });
+                            const reset = spawnSync("git", ["reset", "--hard"], {
+                                cwd: recreated.path,
+                                encoding: "utf-8",
+                            });
+                            if (reset.status !== 0) {
+                                throw new Error(reset.stderr || reset.error?.message || "git reset --hard failed");
+                            }
+                            fixesApplied.push(`recreated empty worktree ${wt.path}`);
+                        }
+                        catch {
+                            fixesApplied.push(`failed to recreate empty worktree ${wt.path}`);
+                        }
+                    }
+                }
                 if (isComplete) {
                     issues.push({
                         severity: "warning",

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -5,7 +5,7 @@ import { milestonesDir, gsdRoot, resolveGsdRootFile } from "./paths.js";
 import { deriveState, isGhostMilestone, isReusableGhostMilestone } from "./state.js";
 import { saveFile } from "./files.js";
 import { nativeIsRepo, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
-import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.js";
+import { readCrashLock, isLockProcessAlive, clearStaleWorkerLock } from "./crash-recovery.js";
 import { getActiveAutoWorkers } from "./db/auto-workers.js";
 import { normalizeRealPath } from "./paths.js";
 import { ensureGitignore, isGsdGitignored } from "./gitignore.js";
@@ -46,7 +46,7 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                     fixable: true,
                 });
                 if (shouldFix("stale_crash_lock")) {
-                    clearLock(basePath);
+                    clearStaleWorkerLock(basePath);
                     fixesApplied.push("cleared stale auto-mode worker state");
                 }
             }
@@ -70,15 +70,32 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 // heartbeat for this project?" — readCrashLock returns null for
                 // healthy live workers (it surfaces stale ones only), so we must
                 // consult getActiveAutoWorkers directly.
-                const projectRoot = normalizeRealPath(basePath);
-                const activeWorkers = getActiveAutoWorkers().filter((w) => w.project_root_realpath === projectRoot && isLockProcessAlive({
-                    pid: w.pid,
-                    startedAt: w.started_at,
-                    unitType: "starting",
-                    unitId: "bootstrap",
-                    unitStartedAt: w.started_at,
-                }));
-                const lockHolderAlive = activeWorkers.length > 0;
+                let lockHolderAlive = false;
+                try {
+                    const projectRoot = normalizeRealPath(basePath);
+                    for (const worker of getActiveAutoWorkers()) {
+                        if (worker.project_root_realpath !== projectRoot)
+                            continue;
+                        try {
+                            if (isLockProcessAlive({
+                                pid: worker.pid,
+                                startedAt: worker.started_at,
+                                unitType: "starting",
+                                unitId: "bootstrap",
+                                unitStartedAt: worker.started_at,
+                            })) {
+                                lockHolderAlive = true;
+                                break;
+                            }
+                        }
+                        catch {
+                            // Ignore malformed worker rows or transient PID probe failures.
+                        }
+                    }
+                }
+                catch {
+                    // If worker lookup fails, continue with the stranded lock diagnosis.
+                }
                 if (!lockHolderAlive) {
                     issues.push({
                         severity: "error",

package/dist/resources/extensions/gsd/doctor.js

@@ -12,37 +12,11 @@ import { GLOBAL_STATE_CODES } from "./doctor-types.js";
 import { checkGitHealth, checkRuntimeHealth, checkGlobalHealth, checkEngineHealth } from "./doctor-checks.js";
 import { checkEnvironmentHealth } from "./doctor-environment.js";
 import { runProviderChecks } from "./doctor-providers.js";
+import { validateTitle } from "./validation.js";
 export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDoctorIssuesForPrompt, formatDoctorReportJson } from "./doctor-format.js";
 export { runEnvironmentChecks, runFullEnvironmentChecks, formatEnvironmentReport } from "./doctor-environment.js";
 export { computeProgressScore, computeProgressScoreWithContext, formatProgressLine, formatProgressReport } from "./progress-score.js";
-/**
- * Characters that are used as delimiters in GSD state management documents
- * and should not appear in milestone or slice titles.
- *
- * - "\u2014" (em dash, U+2014): used as a display separator in STATE.md and other docs.
- *   A title containing "\u2014" makes the separator ambiguous, corrupting state display
- *   and confusing the LLM agent that reads and writes these files.
- * - "\u2013" (en dash, U+2013): visually similar to em dash; same ambiguity risk.
- * - "/" (forward slash, U+002F): used as the path separator in unit IDs (M001/S01)
- *   and git branch names (gsd/M001/S01). A slash in a title can break path resolution.
- */
-const TITLE_DELIMITER_RE = /[\u2014\u2013\/]/; // em dash, en dash, forward slash
-/**
- * Check whether a milestone or slice title contains characters that conflict
- * with GSD's state document delimiter conventions.
- * Returns a human-readable description of the problem, or null if the title is safe.
- */
-export function validateTitle(title) {
-    if (TITLE_DELIMITER_RE.test(title)) {
-        const found = [];
-        if (/[\u2014\u2013]/.test(title))
-            found.push("em/en dash (\u2014 or \u2013)");
-        if (/\//.test(title))
-            found.push("forward slash (/)");
-        return `title contains ${found.join(" and ")}, which conflict with GSD state document delimiters`;
-    }
-    return null;
-}
+export { validateTitle } from "./validation.js";
 function validatePreferenceShape(preferences) {
     const issues = [];
     const listFields = ["always_use_skills", "prefer_skills", "avoid_skills", "custom_instructions"];