@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

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

@@ -3,30 +3,62 @@
  *
  * Native Anthropic hooks stay eager. Heavy tool registration is deferred in
  * interactive mode so startup is not blocked on the full search tool stack.
+ *
+ * Provider gating: the Brave/Tavily/Ollama-backed tools (search-the-web,
+ * search_and_read) are only registered when a provider API key is actually
+ * configured (resolveSearchProvider() !== null). Without a key these tools can
+ * only return an auth error, so presenting them to the model is pure confusion
+ * — the agent reaches for a tool that cannot work. fetch_page is always
+ * registered because it works key-free via Jina Reader.
  */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
 import { registerSearchProviderCommand } from "./command-search-provider.js";
 import { registerNativeSearchHooks } from "./native-search.js";
-let toolsPromise = null;
+import { resolveSearchProvider } from "./provider.js";
+// fetch_page registration — always available (key-free via Jina Reader).
+let fetchToolPromise = null;
+// search-the-web + search_and_read registration — gated on provider key.
+let searchToolsPromise = null;
 let resetSearchLoopGuardStateRef = null;
-async function registerSearchTools(pi) {
-    if (!toolsPromise) {
-        toolsPromise = (async () => {
-            const [{ registerSearchTool, resetSearchLoopGuardState }, { registerFetchPageTool }, { registerLLMContextTool },] = await Promise.all([
+async function registerFetchTool(pi) {
+    if (!fetchToolPromise) {
+        fetchToolPromise = (async () => {
+            const { registerFetchPageTool } = await importExtensionModule(import.meta.url, "./tool-fetch-page.js");
+            registerFetchPageTool(pi);
+        })().catch((error) => {
+            fetchToolPromise = null;
+            throw error;
+        });
+    }
+    return fetchToolPromise;
+}
+/**
+ * Register the provider-backed search tools, but only when a search provider
+ * key is configured. Memoized so it registers at most once per process; the
+ * guard is re-evaluated on each session_start so a key added before a later
+ * session is picked up without a restart.
+ */
+async function registerProviderSearchTools(pi) {
+    if (resolveSearchProvider() === null)
+        return;
+    if (!searchToolsPromise) {
+        searchToolsPromise = (async () => {
+            const [{ registerSearchTool, resetSearchLoopGuardState }, { registerLLMContextTool },] = await Promise.all([
                 importExtensionModule(import.meta.url, "./tool-search.js"),
-                importExtensionModule(import.meta.url, "./tool-fetch-page.js"),
                 importExtensionModule(import.meta.url, "./tool-llm-context.js"),
             ]);
             resetSearchLoopGuardStateRef = resetSearchLoopGuardState;
             registerSearchTool(pi);
-            registerFetchPageTool(pi);
             registerLLMContextTool(pi);
         })().catch((error) => {
-            toolsPromise = null;
+            searchToolsPromise = null;
             throw error;
         });
     }
-    return toolsPromise;
+    return searchToolsPromise;
+}
+async function registerSearchTools(pi) {
+    await Promise.all([registerFetchTool(pi), registerProviderSearchTools(pi)]);
 }
 export default function (pi) {
     registerSearchProviderCommand(pi);

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

@@ -6,6 +6,7 @@
  */
 import { isAnthropicApi } from "@gsd/pi-ai";
 import { resolveSearchProviderFromPreferences } from "../gsd/preferences.js";
+import { resolveSearchProvider } from "./provider.js";
 /** Tool names for the Brave-backed custom search tools */
 export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 /** All custom search tool names that should be disabled when native search is active */
@@ -166,11 +167,24 @@ export function registerNativeSearchHooks(pi) {
             pi.setActiveTools(active.filter((t) => !CUSTOM_SEARCH_TOOL_NAMES.includes(t)));
         }
         else if (!isAnthropicProvider && wasAnthropic) {
-            // Switching away from Anthropic — re-enable custom search tools (they
-            // were disabled while native search was active). If keys are missing,
-            // user sees the error rather than tools silently vanishing.
+            // Switching away from Anthropic — re-enable custom search tools that were
+            // disabled while native search was active. Only re-add the Brave/Tavily/
+            // Ollama-backed tools when a provider key is actually configured: without
+            // a key they can only return an auth error, and re-adding their names
+            // would advertise a tool the model cannot use (and, when unregistered,
+            // leak a schema-less phantom name into the tool surface). google_search
+            // is owned by its own extension (which now gates its registration on
+            // Gemini creds); re-adding its name here is harmless either way — it
+            // activates if registered, or is dropped as a no-op if not.
             const active = pi.getActiveTools();
-            const toAdd = CUSTOM_SEARCH_TOOL_NAMES.filter((t) => !active.includes(t));
+            const providerConfigured = resolveSearchProvider() !== null;
+            const toAdd = CUSTOM_SEARCH_TOOL_NAMES.filter((t) => {
+                if (active.includes(t))
+                    return false;
+                if (BRAVE_TOOL_NAMES.includes(t))
+                    return providerConfigured;
+                return true;
+            });
             if (toAdd.length > 0) {
                 pi.setActiveTools([...active, ...toAdd]);
             }

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

@@ -96,14 +96,46 @@ function resolvePathGsdBrowserVersion(env) {
     }
     return cachedPathProbeVersion;
 }
+function resolveGsdBrowserNativeBinaryPath(launcherPath, platform = process.platform) {
+    const binDir = resolve(launcherPath, "..");
+    const nativeName = platform === "win32" ? "gsd-browser.exe" : "gsd-browser-bin";
+    return resolve(binDir, nativeName);
+}
+function isNodeShLauncher(launcherPath) {
+    try {
+        return readFileSync(launcherPath, "utf-8").startsWith("#!");
+    }
+    catch {
+        // Non-text launchers (native binaries) are runnable without a sibling shim.
+        return false;
+    }
+}
+/**
+ * The npm package ships a node launcher that execs `gsd-browser-bin` beside it.
+ * pnpm can skip postinstall, leaving only the launcher — which exits immediately
+ * and surfaces as MCP "Connection closed". Treat that layout as unavailable.
+ */
+function isGsdBrowserPackageLauncherRunnable(launcherPath) {
+    if (!existsSync(launcherPath))
+        return false;
+    const nativePath = resolveGsdBrowserNativeBinaryPath(launcherPath);
+    if (existsSync(nativePath))
+        return true;
+    return !isNodeShLauncher(launcherPath);
+}
 function shouldPreferPathGsdBrowser(env) {
     const pathVersion = resolvePathGsdBrowserVersion(env);
     if (!pathVersion)
         return false;
     const bundledVersion = resolveBundledGsdBrowserPackageVersion();
-    return !bundledVersion || compareSemverLocal(pathVersion, bundledVersion) > 0;
+    if (!bundledVersion || compareSemverLocal(pathVersion, bundledVersion) > 0) {
+        return true;
+    }
+    // Same or newer bundled semver still loses when the package launcher cannot run.
+    const bundledLauncher = resolveBundledGsdBrowserLauncherPath(env);
+    return bundledLauncher !== null && !isGsdBrowserPackageLauncherRunnable(bundledLauncher);
 }
-export function resolveBundledGsdBrowserCliPath(env = process.env) {
+function resolveBundledGsdBrowserLauncherPath(env = process.env) {
     const explicit = resolveExplicitGsdBrowserCliPath(env);
     if (explicit)
         return explicit;
@@ -127,6 +159,12 @@ export function resolveBundledGsdBrowserCliPath(env = process.env) {
     }
     return null;
 }
+export function resolveBundledGsdBrowserCliPath(env = process.env) {
+    const launcher = resolveBundledGsdBrowserLauncherPath(env);
+    if (!launcher || !isGsdBrowserPackageLauncherRunnable(launcher))
+        return null;
+    return launcher;
+}
 /**
  * Cheap availability probe for the gsd-browser CLI: explicit env overrides,
  * then the bundled @opengsd/gsd-browser binary (filesystem checks only), then

package/dist/resources/extensions/subagent/index.js

@@ -28,6 +28,7 @@ import { loadEffectiveGSDPreferences } from "../gsd/preferences.js";
 import { emitJournalEvent } from "../gsd/journal.js";
 import { CmuxClient, shellEscape } from "../cmux/index.js";
 import { buildShellEnvAssignments, createSubagentLaunchPlan, isSubagentChildProcess, } from "./launch.js";
+import { resolveSubagentWorktreeCwd } from "./worktree-cwd.js";
 import { SubagentRunStore, createInitialRunRecord, createSubagentTrackingName, deriveRunStatus, } from "./run-store.js";
 export { buildSubagentProcessArgs } from "./launch.js";
 const MAX_PARALLEL_TASKS = 8;
@@ -815,16 +816,19 @@ export default function (pi) {
                 : hasTasks && taskParams.some((task) => (task.context ?? contextMode) === "fork")
                     ? "fork"
                     : contextMode;
-            const dispatchChildren = dispatchAgents.map((agent, index) => ({
-                agent,
-                trackingName: dispatchTrackingNames[index],
-                task: dispatchTasks[index] ?? "",
-                cwd: hasChain
+            const dispatchChildren = dispatchAgents.map((agent, index) => {
+                const rawCwd = hasChain
                     ? chainParams[index]?.cwd
                     : hasTasks
                         ? taskParams[index]?.cwd
-                        : params.cwd,
-            }));
+                        : params.cwd;
+                return {
+                    agent,
+                    trackingName: dispatchTrackingNames[index],
+                    task: dispatchTasks[index] ?? "",
+                    cwd: resolveSubagentWorktreeCwd(ctx.cwd, rawCwd),
+                };
+            });
             try {
                 runStore.create(createInitialRunRecord({
                     runId: dispatchId,
@@ -1023,12 +1027,12 @@ export default function (pi) {
                     void (async () => {
                         let isolation = null;
                         try {
-                            const effectiveCwd = params.cwd ?? ctx.cwd;
+                            const effectiveCwd = resolveSubagentWorktreeCwd(ctx.cwd, params.cwd);
                             if (useIsolation) {
                                 const taskId = crypto.randomUUID();
                                 isolation = await createIsolation(effectiveCwd, taskId, isolationMode);
                             }
-                            const result = await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, undefined, (partial) => {
+                            const result = await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : effectiveCwd, undefined, undefined, (partial) => {
                                 if (partial.details?.results[0])
                                     persistRunResults([partial.details.results[0]]);
                             }, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0], params.thinking);
@@ -1087,7 +1091,8 @@ export default function (pi) {
                                 }
                             }
                         };
-                        const result = await runSingleAgent(ctx.cwd, agents, step.agent, taskWithContext, step.cwd, i + 1, signal, chainUpdate, makeDetails("chain"), step.model || params.model, step.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[i], step.thinking || params.thinking);
+                        const stepCwd = resolveSubagentWorktreeCwd(ctx.cwd, step.cwd);
+                        const result = await runSingleAgent(ctx.cwd, agents, step.agent, taskWithContext, stepCwd, i + 1, signal, chainUpdate, makeDetails("chain"), step.model || params.model, step.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[i], step.thinking || params.thinking);
                         results.push(result);
                         persistRunResults(results);
                         const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
@@ -1172,13 +1177,13 @@ export default function (pi) {
                             : runSingleAgent(ctx.cwd, agents, t.agent, t.task, runCwd, undefined, signal, updateParallelResult, makeDetails("parallel"), taskModel, t.context ?? contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[index], taskThinking);
                         const runTask = async () => {
                             let isolation = null;
-                            const effectiveCwd = t.cwd ?? ctx.cwd;
+                            const effectiveCwd = resolveSubagentWorktreeCwd(ctx.cwd, t.cwd);
                             try {
                                 if (useIsolation) {
                                     const taskId = crypto.randomUUID();
                                     isolation = await createIsolation(effectiveCwd, taskId, isolationMode);
                                 }
-                                const result = await executeOnce(isolation ? isolation.workDir : t.cwd);
+                                const result = await executeOnce(isolation ? isolation.workDir : effectiveCwd);
                                 if (isolation && result.exitCode === 0) {
                                     const patches = await isolation.captureDelta();
                                     const mergeResult = patches.length > 0
@@ -1235,7 +1240,7 @@ export default function (pi) {
                     let isolation = null;
                     let mergeResult;
                     try {
-                        const effectiveCwd = params.cwd ?? ctx.cwd;
+                        const effectiveCwd = resolveSubagentWorktreeCwd(ctx.cwd, params.cwd);
                         if (useIsolation) {
                             const taskId = crypto.randomUUID();
                             isolation = await createIsolation(effectiveCwd, taskId, isolationMode);
@@ -1247,8 +1252,8 @@ export default function (pi) {
                                 onUpdate(partial);
                         };
                         const result = cmuxSplitsEnabled
-                            ? await runSingleAgentInCmuxSplit(cmuxClient, "right", ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, singleUpdate, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0], params.thinking)
-                            : await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : params.cwd, undefined, signal, singleUpdate, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0], params.thinking);
+                            ? await runSingleAgentInCmuxSplit(cmuxClient, "right", ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : effectiveCwd, undefined, signal, singleUpdate, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0], params.thinking)
+                            : await runSingleAgent(ctx.cwd, agents, params.agent, params.task, isolation ? isolation.workDir : effectiveCwd, undefined, signal, singleUpdate, makeDetails("single"), params.model, contextMode, ctx.sessionManager, undefined, dispatchTrackingNames[0], params.thinking);
                         finalResults = [result];
                         // Capture and merge delta if isolated
                         if (isolation) {

package/dist/resources/extensions/subagent/worktree-cwd.js

@@ -0,0 +1,31 @@
+// Project/App: gsd-pi
+// File Purpose: Pin subagent cwd to the parent milestone worktree so parallel
+// reactive-execute children cannot spawn at the project root.
+import path from "node:path";
+import { isGsdWorktreePath } from "../gsd/worktree-root.js";
+function pathInside(parent, target) {
+    const parentWithSep = parent.endsWith(path.sep) ? parent : `${parent}${path.sep}`;
+    return target === parent || target.startsWith(parentWithSep);
+}
+/**
+ * Resolve the cwd for a subagent child. When the parent is already inside a GSD
+ * milestone worktree, children must stay in that worktree — even if the model
+ * omits `cwd` or passes the project root (the root-write leak vector for
+ * reactive-execute).
+ */
+export function resolveSubagentWorktreeCwd(parentCwd, taskCwd) {
+    const resolvedParent = path.resolve(parentCwd);
+    if (!isGsdWorktreePath(resolvedParent)) {
+        return taskCwd ? path.resolve(resolvedParent, taskCwd) : resolvedParent;
+    }
+    if (!taskCwd) {
+        return resolvedParent;
+    }
+    const resolvedTask = path.isAbsolute(taskCwd)
+        ? path.resolve(taskCwd)
+        : path.resolve(resolvedParent, taskCwd);
+    if (pathInside(resolvedParent, resolvedTask)) {
+        return resolvedTask;
+    }
+    return resolvedParent;
+}

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;
+}