@opengsd/gsd-pi 1.2.0-dev.fb12b103 → 1.2.0-dev.fbdca60b

package/dist/resources/extensions/gsd/workflow-reconcile.js

@@ -2,6 +2,8 @@ import { join } from "node:path";
 import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { readEvents, findForkPoint, getSessionId } from "./workflow-events.js";
+import { normalizeWorkflowEventCommand, workflowEventEntityKey, } from "./workflow-event-vocabulary.js";
+import { readWorktreeEventLogPath, workflowEventLogPath, writeWorkflowEventLog, writeWorktreeEventLog, } from "./workflow-event-ledger.js";
 import { transaction, updateTaskStatus, updateSliceStatus, updateMilestoneStatus, getSliceTasks, insertMilestone, getMilestoneSlices, insertVerificationEvidence, upsertDecision, setTaskBlockerDiscovered, insertOrIgnoreSlice, insertOrIgnoreTask, } from "./gsd-db.js";
 import { openWorkflowDatabasePath } from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
@@ -48,14 +50,11 @@ function replayEvents(events) {
     transaction(() => {
         for (const event of events) {
             const p = event.params;
-            // Normalize cmd format: completion tools write hyphens ("complete-task"),
-            // legacy logs use underscores ("complete_task"). Accept both formats.
-            // Type guard: malformed event lines with non-string cmd are skipped.
-            if (typeof event.cmd !== "string") {
+            const cmd = normalizeWorkflowEventCommand(event.cmd);
+            if (!cmd) {
                 logWarning("reconcile", `Event with non-string cmd skipped: ${JSON.stringify(event.cmd)}`);
                 continue;
             }
-            const cmd = event.cmd.replace(/-/g, "_");
             switch (cmd) {
                 case "complete_task": {
                     const milestoneId = p["milestoneId"];
@@ -199,43 +198,7 @@ function replayEvents(events) {
  * (e.g. unknown or future cmds).
  */
 export function extractEntityKey(event) {
-    const p = event.params;
-    // Normalize cmd format: accept both hyphens and underscores
-    if (typeof event.cmd !== "string")
-        return null;
-    const cmd = event.cmd.replace(/-/g, "_");
-    switch (cmd) {
-        case "complete_task":
-        case "start_task":
-        case "skip_task":
-        case "report_blocker":
-        case "record_verification":
-        case "plan_task":
-            return typeof p["taskId"] === "string"
-                ? { type: "task", id: p["taskId"] }
-                : null;
-        case "complete_slice":
-        case "replan_slice":
-            return typeof p["sliceId"] === "string"
-                ? { type: "slice", id: p["sliceId"] }
-                : null;
-        case "plan_slice":
-            return typeof p["sliceId"] === "string"
-                ? { type: "slice_plan", id: p["sliceId"] }
-                : null;
-        case "complete_milestone":
-        case "plan_milestone":
-            return typeof p["milestoneId"] === "string"
-                ? { type: "milestone", id: p["milestoneId"] }
-                : null;
-        case "save_decision":
-            if (typeof p["scope"] === "string" && typeof p["decision"] === "string") {
-                return { type: "decision", id: `${p["scope"]}:${p["decision"]}` };
-            }
-            return null;
-        default:
-            return null;
-    }
+    return workflowEventEntityKey(event);
 }
 // ─── detectConflicts ──────────────────────────────────────────────────────────
 /**
@@ -302,12 +265,6 @@ function rewriteDivergedEventsForEntity(divergedEvents, entityType, entityId, re
     }
     return rewritten;
 }
-function writeEventLog(basePath, events) {
-    const dir = join(basePath, ".gsd");
-    mkdirSync(dir, { recursive: true });
-    const content = events.map((e) => JSON.stringify(e)).join("\n") + (events.length > 0 ? "\n" : "");
-    atomicWriteSync(join(dir, "event-log.jsonl"), content);
-}
 // ─── writeConflictsFile ───────────────────────────────────────────────────────
 /**
  * Write a human-readable CONFLICTS.md to basePath/.gsd/CONFLICTS.md.
@@ -375,10 +332,15 @@ export function reconcileWorktreeLogs(mainBasePath, worktreeBasePath) {
 }
 function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     // Step 1: Read both logs
-    const mainLogPath = join(mainBasePath, ".gsd", "event-log.jsonl");
-    const wtLogPath = join(worktreeBasePath, ".gsd", "event-log.jsonl");
+    const mainLogPath = workflowEventLogPath(mainBasePath);
+    const wtLogPath = readWorktreeEventLogPath(worktreeBasePath);
     const mainEvents = readEvents(mainLogPath);
     const wtEvents = readEvents(wtLogPath);
+    // Canonical worktree appends are already durable in the project ledger.
+    // Empty/missing worktree shards are legacy-only absence, not divergence.
+    if (wtEvents.length === 0) {
+        return { autoMerged: 0, conflicts: [] };
+    }
     // Step 2: Find fork point
     const forkPoint = findForkPoint(mainEvents, wtEvents);
     // Step 3: Slice diverged sets
@@ -412,9 +374,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     }
     const baseEvents = mainEvents.slice(0, forkPoint + 1);
     const mergedLog = baseEvents.concat(merged);
-    const logContent = mergedLog.map((e) => JSON.stringify(e)).join("\n") + (mergedLog.length > 0 ? "\n" : "");
-    mkdirSync(join(mainBasePath, ".gsd"), { recursive: true });
-    atomicWriteSync(join(mainBasePath, ".gsd", "event-log.jsonl"), logContent);
+    writeWorkflowEventLog(mainBasePath, mergedLog);
     // Step 8: Replay into DB (wrapped in a transaction by replayEvents)
     openWorkflowDatabasePath(resolveGsdPathContract(mainBasePath).projectDb);
     replayEvents(merged);
@@ -533,8 +493,8 @@ pick) {
         throw new Error(`No conflict found for entity ${entityKey}`);
     const conflict = conflicts[idx];
     const eventsToReplay = pick === "main" ? conflict.mainSideEvents : conflict.worktreeSideEvents;
-    const mainLogPath = join(basePath, ".gsd", "event-log.jsonl");
-    const wtLogPath = join(worktreeBasePath, ".gsd", "event-log.jsonl");
+    const mainLogPath = workflowEventLogPath(basePath);
+    const wtLogPath = readWorktreeEventLogPath(worktreeBasePath);
     const mainEvents = readEvents(mainLogPath);
     const wtEvents = readEvents(wtLogPath);
     const forkPoint = findForkPoint(mainEvents, wtEvents);
@@ -547,7 +507,12 @@ pick) {
         : rewriteDivergedEventsForEntity(mainDiverged, entityType, entityId, eventsToReplay);
     const targetBasePath = pick === "main" ? worktreeBasePath : basePath;
     const targetBaseEvents = pick === "main" ? wtBaseEvents : mainBaseEvents;
-    writeEventLog(targetBasePath, targetBaseEvents.concat(rewrittenTargetEvents));
+    if (pick === "main") {
+        writeWorktreeEventLog(targetBasePath, targetBaseEvents.concat(rewrittenTargetEvents));
+    }
+    else {
+        writeWorkflowEventLog(targetBasePath, targetBaseEvents.concat(rewrittenTargetEvents));
+    }
     // Replay resolved events through the DB (updates DB state)
     openWorkflowDatabasePath(resolveGsdPathContract(basePath).projectDb);
     replayEvents(eventsToReplay);

package/dist/resources/extensions/gsd/worktree-lifecycle.js

@@ -32,6 +32,7 @@ import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain, } fr
 // callers — production wiring previously injected them via deps; the seam
 // added type churn without enabling test variation.
 import { loadEffectiveGSDPreferences, getIsolationMode } from "./preferences.js";
+import { isolationDegradedFallbackGuidance, worktreeCreationFailedGuidance } from "./guidance.js";
 import { invalidateAllCaches } from "./cache.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { getMilestone, insertMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
@@ -343,7 +344,7 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx, opts = {}) {
                 s.basePath = basePath;
                 rebuildGitService(s, deps);
                 invalidateAllCaches();
-                ctx.notify(`Worktree isolation is degraded. Fell back to branch milestone/${milestoneId}.`, "warning");
+                ctx.notify(isolationDegradedFallbackGuidance(milestoneId), "warning");
                 return { ok: true, mode: "branch", path: basePath };
             }
             catch (err) {
@@ -517,7 +518,7 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx, opts = {}) {
             eventType: "worktree-create-failed",
             data: { milestoneId, error: msg, fallback: "project-root" },
         });
-        ctx.notify(`Auto-worktree creation for ${milestoneId} failed: ${msg}. Continuing in project root.`, "warning");
+        ctx.notify(worktreeCreationFailedGuidance(milestoneId, msg), "warning");
         // Degrade isolation for the rest of this session so mergeAndExit
         // doesn't try to merge a nonexistent worktree branch (#2483)
         s.isolationDegraded = true;

package/dist/resources/extensions/gsd/worktree-manager.js

@@ -528,7 +528,13 @@ export function removeWorktree(basePath, name, opts = {}) {
     // inside .gsd/worktrees/ — a symlink inside the directory could point out.
     const resolvedPathSafe = isInsideWorktreesDir(basePath, resolvedWtPath);
     // If we're inside the worktree, move out first — git can't remove an in-use directory
-    const cwd = process.cwd();
+    let cwd;
+    try {
+        cwd = process.cwd();
+    }
+    catch {
+        cwd = basePath;
+    }
     const resolvedCwd = existsSync(cwd) ? realpathSync(cwd) : cwd;
     if (resolvedCwd === resolvedWtPath || resolvedCwd.startsWith(resolvedWtPath + sep)) {
         process.chdir(basePath);

package/dist/resources/extensions/gsd/worktree-safety.js

@@ -90,38 +90,40 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
                 return failure("worktree-git-marker-not-file", `Worktree root ${unitRoot} has a .git directory, not a registered worktree .git file.`, "Use a registered GSD worktree instead of a copied or nested repository.", { gitMarker });
             }
             let registered;
-            try {
-                registered = deps.listRegisteredWorktrees?.(projectRoot);
-            }
-            catch (error) {
-                return failure("worktree-git-probe-failed", `Unable to list registered worktrees for project root ${projectRoot}.`, "Recover or recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, error: errorMessage(error) });
-            }
-            if (registered && !registered.some((worktree) => samePath(worktree.path, unitRoot))) {
-                const wasPreviouslyTracked = unregisteredRecoveryFailed.has(unitRoot);
-                let attemptedPrune = false;
-                if (!wasPreviouslyTracked && deps.pruneRegisteredWorktrees) {
-                    attemptedPrune = true;
-                    try {
-                        deps.pruneRegisteredWorktrees(projectRoot);
-                        const rechecked = deps.listRegisteredWorktrees?.(projectRoot);
-                        if (rechecked?.some((worktree) => samePath(worktree.path, unitRoot))) {
-                            unregisteredRecoveryFailed.delete(unitRoot);
-                            registered = rechecked;
+            if (isolationMode === "worktree") {
+                try {
+                    registered = deps.listRegisteredWorktrees?.(projectRoot);
+                }
+                catch (error) {
+                    return failure("worktree-git-probe-failed", `Unable to list registered worktrees for project root ${projectRoot}.`, "Recover or recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, error: errorMessage(error) });
+                }
+                if (registered && !registered.some((worktree) => samePath(worktree.path, unitRoot))) {
+                    const wasPreviouslyTracked = unregisteredRecoveryFailed.has(unitRoot);
+                    let attemptedPrune = false;
+                    if (!wasPreviouslyTracked && deps.pruneRegisteredWorktrees) {
+                        attemptedPrune = true;
+                        try {
+                            deps.pruneRegisteredWorktrees(projectRoot);
+                            const rechecked = deps.listRegisteredWorktrees?.(projectRoot);
+                            if (rechecked?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                                unregisteredRecoveryFailed.delete(unitRoot);
+                                registered = rechecked;
+                            }
+                            else {
+                                unregisteredRecoveryFailed.add(unitRoot);
+                            }
                         }
-                        else {
+                        catch (error) {
                             unregisteredRecoveryFailed.add(unitRoot);
+                            return failure("worktree-git-probe-failed", `Unable to recover unregistered worktree root ${unitRoot}.`, "Run 'git worktree prune', then recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { projectRoot, unitRoot, error: errorMessage(error) });
                         }
                     }
-                    catch (error) {
-                        unregisteredRecoveryFailed.add(unitRoot);
-                        return failure("worktree-git-probe-failed", `Unable to recover unregistered worktree root ${unitRoot}.`, "Run 'git worktree prune', then recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, unitRoot, error: errorMessage(error) });
+                    if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                        return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, attemptedPrune || wasPreviouslyTracked
+                            ? "Worktree recovery was attempted but the root is still unregistered. Recreate or re-register the milestone worktree before dispatching the source-writing Unit."
+                            : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot, attemptedPrune, trackedAsFailed: unregisteredRecoveryFailed.has(unitRoot) });
                     }
                 }
-                if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
-                    return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, attemptedPrune || wasPreviouslyTracked
-                        ? "Worktree recovery was attempted but the root is still unregistered. Recreate or re-register the milestone worktree before dispatching the source-writing Unit."
-                        : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot, attemptedPrune, trackedAsFailed: unregisteredRecoveryFailed.has(unitRoot) });
-                }
             }
             if (input.emptyWorktreeWithProjectContent) {
                 return failure("empty-worktree-with-project-content", `Worktree root ${unitRoot} has no project content, but the project root does.`, "Resolve untracked project-root content or recreate the worktree so source writes stay isolated.", { unitRoot, projectRoot });

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

@@ -195,7 +195,14 @@ export function resolveGitHeadPath(dir) {
  */
 export function nudgeGitBranchCache(previousCwd) {
     const now = new Date();
-    for (const dir of [previousCwd, process.cwd()]) {
+    let currentCwd = null;
+    try {
+        currentCwd = process.cwd();
+    }
+    catch {
+        currentCwd = null;
+    }
+    for (const dir of [previousCwd, currentCwd].filter((dir) => Boolean(dir))) {
         try {
             const headPath = resolveGitHeadPath(dir);
             if (headPath)

package/dist/resources/extensions/mcp-client/manager.js

@@ -30,6 +30,8 @@ const CHILD_ENV_ALLOWLIST = new Set([
     "XDG_CACHE_HOME",
 ]);
 const MCP_STDERR_MAX_BYTES = 4096;
+/** Short-lived stdio probes must not register/kill production MCP PIDs (see probe-mode.ts). */
+export const GSD_MCP_PROBE_ENV = "GSD_MCP_PROBE";
 let cachedStatus = null;
 let cachedStatusKey = "";
 export function clearMcpConfigCache() {
@@ -259,7 +261,10 @@ export async function testMcpServerConnection(nameOrConfig, options = {}) {
             transport = new StdioClientTransport({
                 command: config.command ?? "",
                 args: config.args,
-                env: buildMcpChildEnv(config.env),
+                env: {
+                    ...buildMcpChildEnv(config.env),
+                    [GSD_MCP_PROBE_ENV]: "1",
+                },
                 cwd: config.cwd,
                 stderr: "pipe",
             });

package/dist/resources/extensions/shared/gsd-browser-cli.js

@@ -38,6 +38,22 @@ function compareSemverLocal(a, b) {
 function parseGsdBrowserVersion(output) {
     return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
 }
+function splitCommandLine(commandLine) {
+    const parts = commandLine.match(/(?:"[^"]*"|'[^']*'|[^\s"']+)/g) ?? [];
+    return parts.map((part) => {
+        const quote = part[0];
+        if ((quote === '"' || quote === "'") && part.endsWith(quote)) {
+            return part.slice(1, -1);
+        }
+        return part;
+    });
+}
+function buildPathGsdBrowserVersionInvocation(platform) {
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/d", "/s", "/c", "gsd-browser", "--version"] };
+    }
+    return { command: "gsd-browser", args: ["--version"] };
+}
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -67,7 +83,8 @@ function resolvePathGsdBrowserVersion(env) {
     if (cachedPathProbeVersion !== undefined)
         return cachedPathProbeVersion;
     try {
-        cachedPathProbeVersion = parseGsdBrowserVersion(execFileSync("gsd-browser", ["--version"], {
+        const invocation = buildPathGsdBrowserVersionInvocation(process.platform);
+        cachedPathProbeVersion = parseGsdBrowserVersion(execFileSync(invocation.command, invocation.args, {
             encoding: "utf-8",
             env,
             stdio: ["ignore", "pipe", "ignore"],
@@ -176,7 +193,8 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
     const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
     const explicitArgs = parseJsonEnv(env, "GSD_BROWSER_MCP_ARGS");
     const explicitEnv = parseJsonEnv(env, "GSD_BROWSER_MCP_ENV");
-    const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
+    const explicitCommandLine = env.GSD_BROWSER_MCP_COMMAND?.trim();
+    const [explicitCommand, ...explicitCommandArgs] = explicitCommandLine ? splitCommandLine(explicitCommandLine) : [];
     const explicitCliPath = resolveExplicitGsdBrowserCliPath(env);
     const preferPathCli = !explicitCommand && !explicitCliPath && shouldPreferPathGsdBrowser(env);
     const bundledCliPath = !explicitCommand && !explicitCliPath && !preferPathCli
@@ -198,6 +216,7 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
     const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
         ? explicitArgs.map(String)
         : [
+            ...explicitCommandArgs,
             ...(bundledCliPath ? [bundledCliPath] : []),
             "mcp",
             "--session",

package/dist/resources/shared/gsd-browser-path-sync.js

@@ -0,0 +1,214 @@
+import { execFileSync } from 'node:child_process';
+import { chmodSync, copyFileSync, existsSync, lstatSync, readlinkSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, delimiter as pathDelimiter, resolve as resolvePath } from 'node:path';
+import { isPnpmInstall, pathStartsWith } from './package-manager-detection.js';
+function isBunGlobalInstall(argv1, env) {
+    if ('bun' in process.versions)
+        return true;
+    if (!argv1)
+        return false;
+    const bunBinDirs = [];
+    if (env.BUN_INSTALL)
+        bunBinDirs.push(join(env.BUN_INSTALL, 'bin'));
+    bunBinDirs.push(join(homedir(), '.bun', 'bin'));
+    return bunBinDirs.some((dir) => pathStartsWith(argv1, dir));
+}
+function gsdBrowserBinaryName(platform) {
+    return platform === 'win32' ? 'gsd-browser.cmd' : 'gsd-browser';
+}
+function tryResolveFromBinDir(binDir, platform) {
+    const primary = join(binDir, gsdBrowserBinaryName(platform));
+    if (existsSync(primary))
+        return primary;
+    if (platform === 'win32') {
+        const fallback = join(binDir, 'gsd-browser');
+        if (existsSync(fallback))
+            return fallback;
+    }
+    return null;
+}
+function tryResolveFromPackageRoot(rootDir, platform) {
+    const candidate = join(rootDir, '@opengsd', 'gsd-browser', 'bin', gsdBrowserBinaryName(platform));
+    if (existsSync(candidate))
+        return candidate;
+    if (platform === 'win32') {
+        const fallback = join(rootDir, '@opengsd', 'gsd-browser', 'bin', 'gsd-browser');
+        if (existsSync(fallback))
+            return fallback;
+    }
+    return null;
+}
+function tryExecLookup(command, args, env, platform, resolve) {
+    try {
+        const dir = execFileSync(command, args, {
+            encoding: 'utf-8',
+            env,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000,
+        }).trim();
+        return resolve(dir, platform);
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePathBinary(env, platform) {
+    if (platform === 'win32') {
+        try {
+            const out = execFileSync('where', ['gsd-browser'], {
+                encoding: 'utf-8',
+                env,
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 5000,
+            }).trim();
+            const first = out.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+            return first && existsSync(first) ? first : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    for (const entry of (env.PATH ?? '').split(pathDelimiter)) {
+        if (!entry)
+            continue;
+        const candidate = join(entry, 'gsd-browser');
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function resolveRealPath(pathValue) {
+    try {
+        return realpathSync(pathValue);
+    }
+    catch {
+        return resolvePath(pathValue);
+    }
+}
+function resolveSymlinkTarget(pathCli) {
+    try {
+        const stat = lstatSync(pathCli);
+        if (!stat.isSymbolicLink())
+            return pathCli;
+        const target = readlinkSync(pathCli);
+        return isAbsolute(target) ? target : resolvePath(dirname(pathCli), target);
+    }
+    catch {
+        // PATH entry vanished or is inaccessible between resolution and sync.
+        // Fall back to the original path; subsequent sync will surface a useful
+        // error rather than escaping as an unhandled throw.
+        return pathCli;
+    }
+}
+function resolveHomeDir(env) {
+    const fromEnv = env.HOME?.trim() || env.USERPROFILE?.trim();
+    return resolvePath(fromEnv || homedir());
+}
+function canAutoSyncTarget(targetPath, env) {
+    const home = resolveHomeDir(env);
+    const resolved = resolvePath(targetPath);
+    return pathStartsWith(resolved, home);
+}
+function syncBinary(installedCli, targetPath, platform) {
+    const source = resolveRealPath(installedCli);
+    copyFileSync(source, targetPath);
+    if (platform !== 'win32') {
+        chmodSync(targetPath, 0o755);
+    }
+}
+/**
+ * Resolve the gsd-browser binary installed by the active global package manager.
+ */
+export function resolveGlobalGsdBrowserCliPath(options = {}) {
+    const env = options.env ?? process.env;
+    const argv1 = options.argv1 ?? process.argv[1];
+    const platform = options.platform ?? process.platform;
+    if (isBunGlobalInstall(argv1, env)) {
+        return (tryExecLookup('bun', ['pm', 'bin', '-g'], env, platform, tryResolveFromBinDir)
+            ?? (env.BUN_INSTALL ? tryResolveFromBinDir(join(env.BUN_INSTALL, 'bin'), platform) : null)
+            ?? tryResolveFromBinDir(join(homedir(), '.bun', 'bin'), platform));
+    }
+    if (isPnpmInstall(argv1, env)) {
+        return (tryExecLookup('pnpm', ['bin', '-g'], env, platform, tryResolveFromBinDir)
+            ?? tryExecLookup('pnpm', ['root', '-g'], env, platform, tryResolveFromPackageRoot));
+    }
+    return (tryExecLookup('npm', ['bin', '-g'], env, platform, tryResolveFromBinDir)
+        ?? tryExecLookup('npm', ['root', '-g'], env, platform, tryResolveFromPackageRoot));
+}
+/**
+ * Resolve the gsd-browser binary that wins on PATH (`command -v` / `where`).
+ */
+export function resolveGsdBrowserOnPath(env = process.env, platform = process.platform) {
+    return resolvePathBinary(env, platform);
+}
+/**
+ * After a global gsd-browser install, ensure the PATH-resolved binary matches
+ * the freshly installed global binary when an older copy is shadowing it.
+ */
+export function reconcileGsdBrowserPathAfterInstall(options) {
+    const env = options.env ?? process.env;
+    const argv1 = options.argv1 ?? process.argv[1];
+    const platform = options.platform ?? process.platform;
+    const installedCli = resolveGlobalGsdBrowserCliPath({ env, argv1, platform });
+    if (!installedCli) {
+        return { action: 'none' };
+    }
+    const pathCli = resolveGsdBrowserOnPath(env, platform);
+    const installedReal = resolveRealPath(installedCli);
+    if (pathCli && resolveRealPath(pathCli) === installedReal) {
+        return { action: 'none', pathCli, installedCli };
+    }
+    const pathVersion = options.resolvePathVersion(env);
+    if (pathVersion && options.compareSemver(pathVersion, options.latestVersion) >= 0) {
+        return { action: 'none', pathCli: pathCli ?? undefined, installedCli };
+    }
+    if (!pathCli) {
+        return {
+            action: 'shadowed',
+            installedCli,
+            message: 'Installed gsd-browser globally, but no gsd-browser was found on PATH. Add your package manager global bin directory to PATH.',
+        };
+    }
+    const syncTarget = resolveSymlinkTarget(pathCli);
+    if (!canAutoSyncTarget(syncTarget, env)) {
+        return {
+            action: 'shadowed',
+            pathCli,
+            installedCli,
+            syncTarget,
+            message: `PATH resolves gsd-browser to ${pathCli}, but the updated global install is at ${installedCli}. ` +
+                'Move your package manager global bin directory ahead of the stale location on PATH, or update the stale binary manually.',
+        };
+    }
+    let syncSucceeded = false;
+    try {
+        syncBinary(installedCli, syncTarget, platform);
+        syncSucceeded = true;
+    }
+    catch {
+        // Fall through to shadowed guidance.
+    }
+    if (syncSucceeded) {
+        const refreshedVersion = options.resolvePathVersion(env);
+        const verified = refreshedVersion !== null
+            && options.compareSemver(refreshedVersion, options.latestVersion) >= 0;
+        return {
+            action: 'synced',
+            pathCli,
+            installedCli,
+            syncTarget,
+            message: verified
+                ? `Synced PATH-resolved gsd-browser at ${syncTarget} to the updated global install.`
+                : `Synced PATH-resolved gsd-browser at ${syncTarget} to the updated global install. Could not verify the new version on PATH; restart your shell or rerun if it still reports the old version.`,
+        };
+    }
+    return {
+        action: 'shadowed',
+        pathCli,
+        installedCli,
+        syncTarget,
+        message: `PATH resolves gsd-browser to ${pathCli}, but the updated global install is at ${installedCli}. ` +
+            'Move your package manager global bin directory ahead of the stale location on PATH, or update the stale binary manually.',
+    };
+}

package/dist/resources/shared/package-manager-detection.js

@@ -9,7 +9,7 @@ function hasPnpmPath(value) {
         normalized.endsWith('/pnpm.cjs') ||
         normalized.endsWith('/pnpm.js'));
 }
-function pathStartsWith(pathValue, dir) {
+export function pathStartsWith(pathValue, dir) {
     if (!pathValue)
         return false;
     const resolvedPath = resolvePath(pathValue);

package/dist/resources/skills/create-skill/SKILL.md

@@ -174,6 +174,9 @@ description: ...          # What it does AND when to use it (third person)
 ---
 ```
 
+Frontmatter must parse as YAML. Quote description values containing `:` or use
+a folded block (`description: >`) for longer trigger descriptions.
+
 Name conventions: `create-*`, `manage-*`, `setup-*`, `generate-*`, `build-*`
 </yaml_requirements>
 

package/dist/resources/skills/create-skill/references/skill-structure.md

@@ -109,6 +109,7 @@ description: What it does and when to use it (third person, specific triggers)
 - No XML tags
 - Third person (never first or second person)
 - Include what it does AND when to use it
+- Must parse as YAML; quote values containing `:` or use `description: >`
 
 **Critical rule**: Always write in third person.
 - ✅ "Processes Excel files and generates reports"

package/dist/runtime-checks.d.ts

@@ -25,3 +25,13 @@ export declare function checkNodeVersion(versionString: string, min?: number): {
  * real subprocess.
  */
 export declare function requireGit(execFn: (cmd: string, args: ReadonlyArray<string>) => unknown): boolean;
+/**
+ * Fast presence check for `git`: scan the directories on `$PATH` for a `git`
+ * executable (plus Windows `.exe`/`.cmd` variants) instead of spawning
+ * `git --version`. The subprocess form costs ~15ms on every startup and showed
+ * up as ~5% of cold-start CPU; a filesystem `existsSync` scan is far cheaper and
+ * answers the same gate ("is git installed"). Returns true if a candidate path
+ * exists. `env`/`platform` are injectable so this can be unit-tested without a
+ * real $PATH.
+ */
+export declare function gitAvailableOnPath(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;

package/dist/runtime-checks.js

@@ -1,5 +1,7 @@
 // Runtime dependency checks — pure helpers used by loader.ts.
 // Extracted so they can be unit-tested without spawning the full loader.
+import { existsSync } from 'fs';
+import { delimiter, join } from 'path';
 /**
  * Minimum supported Node.js major version. Kept in sync with
  * `engines.node` in package.json — see test
@@ -36,3 +38,28 @@ export function requireGit(execFn) {
         return false;
     }
 }
+/**
+ * Fast presence check for `git`: scan the directories on `$PATH` for a `git`
+ * executable (plus Windows `.exe`/`.cmd` variants) instead of spawning
+ * `git --version`. The subprocess form costs ~15ms on every startup and showed
+ * up as ~5% of cold-start CPU; a filesystem `existsSync` scan is far cheaper and
+ * answers the same gate ("is git installed"). Returns true if a candidate path
+ * exists. `env`/`platform` are injectable so this can be unit-tested without a
+ * real $PATH.
+ */
+export function gitAvailableOnPath(env = process.env, platform = process.platform) {
+    const pathValue = env.PATH ?? env.Path ?? env.path ?? '';
+    if (pathValue.length === 0)
+        return false;
+    const dirs = pathValue.split(delimiter).filter((d) => d.length > 0);
+    const names = platform === 'win32'
+        ? (env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').map((ext) => `git${ext.toLowerCase()}`).concat('git')
+        : ['git'];
+    for (const dir of dirs) {
+        for (const name of names) {
+            if (existsSync(join(dir, name)))
+                return true;
+        }
+    }
+    return false;
+}