@opengsd/gsd-pi 1.2.0-dev.b1abb545 → 1.2.0-dev.e8563f58

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

@@ -4,6 +4,7 @@ import { existsSync, lstatSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join, resolve } from "node:path";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
+import { worktreesDirs } from "./worktree-placement.js";
 import { listWorktrees } from "./worktree-manager.js";
 import { getCurrentBranch } from "./worktree.js";
 const fsOnlyDeps = {
@@ -59,15 +60,17 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
             const projectRoot = resolve(input.projectRoot);
             const unitRoot = resolve(input.unitRoot);
             const isolationMode = input.isolationMode ?? "worktree";
-            const expectedRoot = isolationMode === "worktree"
-                ? join(projectRoot, ".gsd", "worktrees", milestoneId)
-                : projectRoot;
-            if (!samePath(unitRoot, expectedRoot)) {
+            // A milestone worktree may live in the canonical container or the
+            // legacy one (pre-placement-change worktrees keep their location).
+            const expectedRoots = isolationMode === "worktree"
+                ? worktreesDirs(projectRoot).map((dir) => join(dir, milestoneId))
+                : [projectRoot];
+            if (!expectedRoots.some((expectedRoot) => samePath(unitRoot, expectedRoot))) {
                 return failure("invalid-root", isolationMode === "worktree"
                     ? `Unit root ${unitRoot} is not the expected worktree root for ${milestoneId}.`
                     : `Unit root ${unitRoot} is not the project root while isolation mode is ${isolationMode}.`, isolationMode === "worktree"
                     ? "Prepare the Unit in its canonical milestone worktree before allowing source writes."
-                    : "Run the Unit from the project root when worktree isolation is disabled.", { expectedRoot, unitRoot });
+                    : "Run the Unit from the project root when worktree isolation is disabled.", { expectedRoot: expectedRoots[0], unitRoot });
             }
             if (!deps.existsSync(unitRoot)) {
                 return failure("worktree-missing", `Worktree root ${unitRoot} does not exist.`, "Create or recover the milestone worktree before dispatching the source-writing Unit.", { unitRoot });

package/dist/resources/extensions/gsd/worktree-session-state.js

@@ -1,4 +1,5 @@
 // GSD worktree session state
+import { findWorktreeSegment, projectRootFromWorktreePath } from "./worktree-root.js";
 let originalCwd = null;
 export function getWorktreeOriginalCwd() {
     return originalCwd;
@@ -12,22 +13,22 @@ export function clearWorktreeOriginalCwd() {
 export function ensureWorktreeOriginalCwdFromPath(cwd = process.cwd()) {
     if (originalCwd)
         return originalCwd;
-    const marker = `${/\\/.test(cwd) ? "\\" : "/"}.gsd${/\\/.test(cwd) ? "\\" : "/"}worktrees${/\\/.test(cwd) ? "\\" : "/"}`;
-    const markerIdx = cwd.indexOf(marker);
-    if (markerIdx !== -1) {
-        originalCwd = cwd.slice(0, markerIdx);
-    }
+    const root = projectRootFromWorktreePath(cwd);
+    if (root)
+        originalCwd = root;
     return originalCwd;
 }
 export function getActiveWorktreeName() {
     if (!originalCwd)
         return null;
-    const cwd = process.cwd();
-    const wtDir = `${originalCwd.replace(/[\\/]+$/, "")}/.gsd/worktrees`.replaceAll("\\", "/");
-    const normalizedCwd = cwd.replaceAll("\\", "/");
-    if (!normalizedCwd.startsWith(`${wtDir}/`))
+    const normalizedCwd = process.cwd().replaceAll("\\", "/");
+    const normalizedOriginal = originalCwd.replace(/[\\/]+$/, "").replaceAll("\\", "/");
+    const segment = findWorktreeSegment(normalizedCwd);
+    if (!segment)
         return null;
-    const rel = normalizedCwd.slice(wtDir.length + 1);
-    const name = rel.split("/")[0];
+    // Only treat the cwd as an active worktree of OUR project root.
+    if (normalizedCwd.slice(0, segment.gsdIdx) !== normalizedOriginal)
+        return null;
+    const name = normalizedCwd.slice(segment.afterWorktrees).split("/")[0];
     return name || null;
 }

package/dist/resources/extensions/search-the-web/native-search.js

@@ -214,9 +214,11 @@ export function registerNativeSearchHooks(pi) {
             isAnthropic = isAnthropicProvider && payloadLooksAnthropic !== false;
         }
         else {
-            // Last resort: session-restore paths where the SDK doesn't pass model.
-            // The model-name prefix is best-effort and assumes direct Anthropic.
-            isAnthropic = payloadLooksAnthropic === true;
+            // No authoritative provider info available (no event.model, no model_select).
+            // Do NOT inject native web_search — guessing on model name alone causes 400
+            // "unsupported_value" errors when the actual provider (copilot, openrouter,
+            // proxy, etc.) doesn't expose the server-side search tool (#648).
+            isAnthropic = false;
         }
         if (!isAnthropic)
             return;

package/dist/resources/extensions/shared/browser-contract.js

@@ -0,0 +1,59 @@
+// Project/App: gsd-pi
+// File Purpose: Browser Automation Contract — the single source for the canonical
+// Pi-facing browser tool vocabulary. Engine adapters (legacy Playwright, managed
+// gsd-browser), UAT policy, dispatch preflight, and evidence detection all derive
+// their browser tool knowledge from this module instead of re-listing names.
+/**
+ * Canonical `browser_*` tool names of the Browser Automation Contract.
+ *
+ * These are the product-level names Units see regardless of which Browser
+ * Automation Engine serves them (ADR-024). Adding a capability here is the
+ * one-line vocabulary change; the engine adapters and presentation surfaces
+ * are typed against this list, so missing coverage fails typecheck.
+ */
+export const BROWSER_CONTRACT_TOOL_NAMES = [
+    "browser_navigate",
+    "browser_click",
+    "browser_type",
+    "browser_fill_form",
+    "browser_click_ref",
+    "browser_fill_ref",
+    "browser_wait_for",
+    "browser_assert",
+    "browser_verify",
+    "browser_screenshot",
+    "browser_snapshot_refs",
+    "browser_find",
+    "browser_get_console_logs",
+    "browser_get_network_logs",
+    "browser_evaluate",
+    "browser_reload",
+    "browser_batch",
+    "browser_act",
+];
+const BROWSER_CONTRACT_TOOL_NAME_SET = new Set(BROWSER_CONTRACT_TOOL_NAMES);
+export function isBrowserContractToolName(name) {
+    return BROWSER_CONTRACT_TOOL_NAME_SET.has(name);
+}
+/**
+ * Whether a canonical (non-MCP-prefixed) tool name belongs to the browser tool
+ * family. Broader than the contract list on purpose: an External MCP Client or
+ * host integration may supply additional `browser_*` tools that still satisfy
+ * browser-backed UAT.
+ */
+export function hasBrowserContractPrefix(canonicalToolName) {
+    return canonicalToolName.startsWith("browser_");
+}
+/**
+ * Contract tool names whose appearance in prose marks browser-backed UAT
+ * activity (requirement or evidence language). Consumed by the
+ * browser-evidence regexes so textual detection stays derived from the
+ * contract vocabulary.
+ */
+export const BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES = [
+    "browser_assert",
+    "browser_batch",
+    "browser_find",
+    "browser_verify",
+    "browser_snapshot_refs",
+];

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

@@ -38,6 +38,28 @@ 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);
+}
+function resolveExplicitGsdBrowserCliPath(env) {
+    return env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim() || undefined;
+}
 function resolveBundledGsdBrowserPackageVersion() {
     try {
         const requireFromHere = createRequire(import.meta.url);
@@ -49,12 +71,20 @@ function resolveBundledGsdBrowserPackageVersion() {
         return null;
     }
 }
+// The `gsd-browser --version` subprocess result cannot change mid-session (the
+// engine-switch guard forbids restarting with a different engine), and both the
+// availability probe and the launch-config resolution ask for it at session
+// start — memoize so the up-to-2s spawn happens once per process.
+let cachedPathProbeVersion;
 function resolvePathGsdBrowserVersion(env) {
     const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
     if (explicit)
         return parseGsdBrowserVersion(explicit);
+    if (cachedPathProbeVersion !== undefined)
+        return cachedPathProbeVersion;
     try {
-        return 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"],
@@ -62,8 +92,9 @@ function resolvePathGsdBrowserVersion(env) {
         }));
     }
     catch {
-        return null;
+        cachedPathProbeVersion = null;
     }
+    return cachedPathProbeVersion;
 }
 function shouldPreferPathGsdBrowser(env) {
     const pathVersion = resolvePathGsdBrowserVersion(env);
@@ -73,7 +104,7 @@ function shouldPreferPathGsdBrowser(env) {
     return !bundledVersion || compareSemverLocal(pathVersion, bundledVersion) > 0;
 }
 export function resolveBundledGsdBrowserCliPath(env = process.env) {
-    const explicit = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+    const explicit = resolveExplicitGsdBrowserCliPath(env);
     if (explicit)
         return explicit;
     try {
@@ -96,6 +127,36 @@ export function resolveBundledGsdBrowserCliPath(env = process.env) {
     }
     return null;
 }
+/**
+ * Cheap availability probe for the gsd-browser CLI: explicit env overrides,
+ * then the bundled @opengsd/gsd-browser binary (filesystem checks only), then
+ * a PATH lookup (one short subprocess, memoized). Used by Browser Automation
+ * Engine resolution to decide whether the managed engine is provable before
+ * preferring it over legacy Playwright. `via` names the provable source, not
+ * necessarily the launch source — resolveGsdBrowserMcpLaunchConfig may still
+ * prefer a newer PATH CLI over the bundled one.
+ */
+export function resolveGsdBrowserCliAvailability(env = process.env) {
+    const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
+    if (explicitCommand) {
+        return { available: true, via: "explicit-env", detail: `GSD_BROWSER_MCP_COMMAND=${explicitCommand}` };
+    }
+    const explicitCliPath = resolveExplicitGsdBrowserCliPath(env);
+    if (explicitCliPath) {
+        return existsSync(explicitCliPath)
+            ? { available: true, via: "explicit-env", detail: `CLI at ${explicitCliPath}` }
+            : { available: false, detail: `configured gsd-browser CLI path does not exist: ${explicitCliPath}` };
+    }
+    const bundledCliPath = resolveBundledGsdBrowserCliPath(env);
+    if (bundledCliPath) {
+        return { available: true, via: "bundled", detail: `bundled CLI at ${bundledCliPath}` };
+    }
+    const pathVersion = resolvePathGsdBrowserVersion(env);
+    if (pathVersion) {
+        return { available: true, via: "path", detail: `gsd-browser ${pathVersion} on PATH` };
+    }
+    return { available: false, detail: "no bundled or PATH gsd-browser CLI found" };
+}
 export function buildGsdBrowserSessionName(projectRoot, suffix) {
     const resolvedProjectRoot = resolve(projectRoot);
     const base = sanitizeSessionSegment(basename(resolvedProjectRoot)) || "project";
@@ -103,13 +164,38 @@ export function buildGsdBrowserSessionName(projectRoot, suffix) {
     const cleanSuffix = suffix ? sanitizeSessionSegment(suffix) : "";
     return cleanSuffix ? `gsd-${base}-${hash}-${cleanSuffix}` : `gsd-${base}-${hash}`;
 }
+/**
+ * Recognize an MCP server config (from .mcp.json / Claude settings) as a
+ * gsd-browser server. Paired with resolveGsdBrowserMcpLaunchConfig: this module
+ * writes the config shape, so it also owns recognizing it. New launch shapes
+ * are taught here, in one place.
+ */
+export function isGsdBrowserMcpServerConfig(config) {
+    if (!isRecord(config))
+        return false;
+    const command = typeof config.command === "string" ? config.command : "";
+    if (command.includes("gsd-browser") || command.includes("@opengsd/gsd-browser")) {
+        return true;
+    }
+    if (isRecord(config.env)) {
+        const env = config.env;
+        if (typeof env.GSD_BROWSER_CLI_PATH === "string"
+            || typeof env.GSD_BROWSER_BIN_PATH === "string"
+            || typeof env.GSD_BROWSER_MCP_COMMAND === "string") {
+            return true;
+        }
+    }
+    const args = Array.isArray(config.args) ? config.args.filter((arg) => typeof arg === "string") : [];
+    return args.some((arg) => arg.includes("gsd-browser") || arg.includes("@opengsd/gsd-browser"));
+}
 export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env, options = {}) {
     const resolvedProjectRoot = resolve(projectRoot);
     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 explicitCliPath = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.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
         ? resolveBundledGsdBrowserCliPath(env)
@@ -119,6 +205,9 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
     // profile/cookies persist across pi sessions for the same project. gsd-browser
     // rejects --identity-scope unless --identity-key is also supplied.
     const identityKey = env.GSD_BROWSER_IDENTITY_KEY?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot);
+    // identity-project must be a safe identifier (no path separators); full paths
+    // cause daemon startup to fail with "invalid name".
+    const identityProject = env.GSD_BROWSER_IDENTITY_PROJECT?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot);
     const command = explicitCommand
         || explicitCliPath
         || (preferPathCli ? "gsd-browser" : undefined)
@@ -127,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",
@@ -136,7 +226,7 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
             "--identity-key",
             identityKey,
             "--identity-project",
-            resolvedProjectRoot,
+            identityProject,
         ];
     const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
     return {
@@ -149,3 +239,23 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
         sessionName,
     };
 }
+/**
+ * CLI invocation that starts the gsd-browser session daemon with the same
+ * session and identity flags as {@link resolveGsdBrowserMcpLaunchConfig}, so
+ * browser UAT can warm Chrome/CDP before the first MCP navigation.
+ */
+export function resolveGsdBrowserDaemonStartInvocation(projectRoot, env = process.env, options = {}) {
+    const launch = resolveGsdBrowserMcpLaunchConfig(projectRoot, env, options);
+    const mcpIndex = launch.args.indexOf("mcp");
+    if (mcpIndex < 0) {
+        throw new Error("gsd-browser launch config is missing mcp subcommand");
+    }
+    const prefix = launch.args.slice(0, mcpIndex);
+    const sessionFlags = launch.args.slice(mcpIndex + 1);
+    return {
+        command: launch.command,
+        args: [...prefix, "daemon", "start", ...sessionFlags],
+        cwd: launch.cwd,
+        ...(launch.env ? { env: launch.env } : {}),
+    };
+}

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/shared/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/resources/skills/create-skill/references/executable-code.md

@@ -45,7 +45,7 @@ skill-name/
 **Reference pattern**: In SKILL.md, reference scripts using the `scripts/` path:
 
 ```bash
-python ~/.claude/skills/skill-name/scripts/analyze.py input.har
+python ~/.agents/skills/skill-name/scripts/analyze.py input.har
 ```
 </scripts_directory>
 </file_organization>

package/dist/resources/skills/create-skill/workflows/add-reference.md

@@ -10,16 +10,21 @@
 ## Step 1: Select the Skill
 
 ```bash
-ls ~/.claude/skills/
+# User-global skills
+ls ~/.agents/skills/ 2>/dev/null
+# Project-local skills
+ls .agents/skills/ 2>/dev/null
 ```
 
 Present numbered list, ask: "Which skill needs a new reference?"
 
+Determine `{skill-path}`: use `.agents/skills/{skill-name}` (project-local) if found there, otherwise `~/.agents/skills/{skill-name}` (user-global). Project-local takes precedence because the skill catalog loads it first on name collision.
+
 ## Step 2: Analyze Current Structure
 
 ```bash
-cat ~/.claude/skills/{skill-name}/SKILL.md
-ls ~/.claude/skills/{skill-name}/references/ 2>/dev/null
+cat {skill-path}/SKILL.md
+ls {skill-path}/references/ 2>/dev/null
 ```
 
 Determine:

package/dist/resources/skills/create-skill/workflows/add-script.md

@@ -12,6 +12,8 @@ Ask (if not already provided):
 - Which skill needs a script?
 - What operation should the script perform?
 
+Determine `{skill-path}`: use `.agents/skills/{skill-name}` (project-local) if found there, otherwise `~/.agents/skills/{skill-name}` (user-global). Project-local takes precedence because the skill catalog loads it first on name collision.
+
 ## Step 2: Analyze Script Need
 
 Confirm this is a good script candidate:
@@ -24,7 +26,7 @@ If not a good fit, suggest alternatives (inline code in workflow, reference exam
 ## Step 3: Create Scripts Directory
 
 ```bash
-mkdir -p ~/.claude/skills/{skill-name}/scripts
+mkdir -p {skill-path}/scripts
 ```
 
 ## Step 4: Design Script
@@ -58,7 +60,7 @@ set -euo pipefail
 ## Step 6: Make Executable (if bash)
 
 ```bash
-chmod +x ~/.claude/skills/{skill-name}/scripts/{script-name}.sh
+chmod +x {skill-path}/scripts/{script-name}.sh
 ```
 
 ## Step 7: Update Workflow to Use Script

package/dist/resources/skills/create-skill/workflows/add-template.md

@@ -12,6 +12,8 @@ Ask (if not already provided):
 - Which skill needs a template?
 - What output does this template structure?
 
+Determine `{skill-path}`: use `.agents/skills/{skill-name}` (project-local) if found there, otherwise `~/.agents/skills/{skill-name}` (user-global). Project-local takes precedence because the skill catalog loads it first on name collision.
+
 ## Step 2: Analyze Template Need
 
 Confirm this is a good template candidate:
@@ -24,7 +26,7 @@ If not a good fit, suggest alternatives (workflow guidance, reference examples).
 ## Step 3: Create Templates Directory
 
 ```bash
-mkdir -p ~/.claude/skills/{skill-name}/templates
+mkdir -p {skill-path}/templates
 ```
 
 ## Step 4: Design Template Structure