gsd-pi 2.37.1 → 2.38.0-dev.96dc7fb

package/dist/resources/extensions/gsd/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./index.js"
     ]
   }
 }

package/dist/resources/extensions/gsd/preferences-types.js

@@ -65,11 +65,12 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "compression_strategy",
     "context_selection",
     "widget_mode",
+    "reactive_execution",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [
     "research-milestone", "plan-milestone", "research-slice", "plan-slice",
-    "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
+    "execute-task", "reactive-execute", "complete-slice", "replan-slice", "reassess-roadmap",
     "run-uat", "complete-milestone",
 ];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -500,6 +500,48 @@ export function validatePreferences(preferences) {
             validated.parallel = parallel;
         }
     }
+    // ─── Reactive Execution ─────────────────────────────────────────────────
+    if (preferences.reactive_execution !== undefined) {
+        if (typeof preferences.reactive_execution === "object" && preferences.reactive_execution !== null) {
+            const re = preferences.reactive_execution;
+            const validRe = {};
+            if (re.enabled !== undefined) {
+                if (typeof re.enabled === "boolean")
+                    validRe.enabled = re.enabled;
+                else
+                    errors.push("reactive_execution.enabled must be a boolean");
+            }
+            if (re.max_parallel !== undefined) {
+                const mp = typeof re.max_parallel === "number" ? re.max_parallel : Number(re.max_parallel);
+                if (Number.isFinite(mp) && mp >= 1 && mp <= 8) {
+                    validRe.max_parallel = Math.floor(mp);
+                }
+                else {
+                    errors.push("reactive_execution.max_parallel must be a number between 1 and 8");
+                }
+            }
+            if (re.isolation_mode !== undefined) {
+                if (re.isolation_mode === "same-tree") {
+                    validRe.isolation_mode = "same-tree";
+                }
+                else {
+                    errors.push('reactive_execution.isolation_mode must be "same-tree"');
+                }
+            }
+            const knownReKeys = new Set(["enabled", "max_parallel", "isolation_mode"]);
+            for (const key of Object.keys(re)) {
+                if (!knownReKeys.has(key)) {
+                    warnings.push(`unknown reactive_execution key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(validRe).length > 0) {
+                validated.reactive_execution = validRe;
+            }
+        }
+        else {
+            errors.push("reactive_execution must be an object");
+        }
+    }
     // ─── Verification Preferences ───────────────────────────────────────────
     if (preferences.verification_commands !== undefined) {
         if (Array.isArray(preferences.verification_commands)) {

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -61,13 +61,14 @@ Then:
    - a concrete, action-oriented title
    - the inline task entry fields defined in the plan.md template (Why / Files / Do / Verify / Done when)
    - a matching task plan file with description, steps, must-haves, verification, inputs, and expected output
+   - **Inputs and Expected Output must list concrete backtick-wrapped file paths** (e.g. `` `src/types.ts` ``). These are machine-parsed to derive task dependencies — vague prose without paths breaks parallel execution. Every task must have at least one output file path.
    - Observability Impact section **only if the task touches runtime boundaries, async flows, or error paths** — omit it otherwise
 6. Write `{{outputPath}}`
 7. Write individual task plans in `{{slicePath}}/tasks/`: `T01-PLAN.md`, `T02-PLAN.md`, etc.
 8. **Self-audit the plan.** Walk through each check — if any fail, fix the plan files before moving on:
     - **Completion semantics:** If every task were completed exactly as written, the slice goal/demo should actually be true.
     - **Requirement coverage:** Every must-have in the slice maps to at least one task. No must-have is orphaned. If `REQUIREMENTS.md` exists, every Active requirement this slice owns maps to at least one task.
-    - **Task completeness:** Every task has steps, must-haves, verification, inputs, and expected output — none are blank or vague.
+    - **Task completeness:** Every task has steps, must-haves, verification, inputs, and expected output — none are blank or vague. Inputs and Expected Output list backtick-wrapped file paths, not prose descriptions.
     - **Dependency correctness:** Task ordering is consistent. No task references work from a later task.
     - **Key links planned:** For every pair of artifacts that must connect, there is an explicit step that wires them.
     - **Scope sanity:** Target 2–5 steps and 3–8 files per task. 10+ steps or 12+ files — must split. Each task must be completable in a single fresh context window.

package/dist/resources/extensions/gsd/prompts/reactive-execute.md

@@ -0,0 +1,41 @@
+# Reactive Task Execution — Parallel Dispatch
+
+**Working directory:** `{{workingDirectory}}`
+**Milestone:** {{milestoneId}} — {{milestoneTitle}}
+**Slice:** {{sliceId}} — {{sliceTitle}}
+
+## Mission
+
+You are executing **multiple tasks in parallel** for this slice. The task graph below shows which tasks are ready for simultaneous execution based on their input/output dependencies.
+
+**Critical rule:** Use the `subagent` tool in **parallel mode** to dispatch all ready tasks simultaneously. Each subagent gets a self-contained execute-task prompt. After all subagents return, verify each task's outputs and write summaries.
+
+## Task Dependency Graph
+
+{{graphContext}}
+
+## Ready Tasks for Parallel Dispatch
+
+{{readyTaskCount}} tasks are ready for parallel execution:
+
+{{readyTaskList}}
+
+## Execution Protocol
+
+1. **Dispatch all ready tasks** using `subagent` in parallel mode. Each subagent prompt is provided below.
+2. **Wait for all subagents** to complete.
+3. **Verify each task's outputs** — check that expected files were created/modified and that verification commands pass.
+4. **Write task summaries** for each completed task using the task-summary template.
+5. **Mark completed tasks** as done in the slice plan (checkbox `[x]`).
+6. **Commit** all changes with a clear message covering the parallel batch.
+
+If any subagent fails:
+- Write a summary for the failed task with `blocker_discovered: true`
+- Continue marking the successful tasks as done
+- The orchestrator will handle re-dispatch on the next iteration
+
+## Subagent Prompts
+
+{{subagentPrompts}}
+
+{{inlinedTemplates}}

package/dist/resources/extensions/gsd/reactive-graph.js

@@ -0,0 +1,227 @@
+/**
+ * Reactive Task Graph — derives dependency edges from task plan IO signatures.
+ *
+ * Pure functions that build a DAG from task IO intersections and resolve
+ * which tasks are currently ready for parallel dispatch. Used by the
+ * reactive-execute dispatch path (ADR-004).
+ *
+ * Graph derivation and resolution functions are pure (no filesystem access).
+ * The `loadSliceTaskIO` loader at the bottom is the only async/IO function.
+ */
+import { loadFile, parsePlan, parseTaskPlanIO } from "./files.js";
+import { resolveTasksDir, resolveTaskFiles } from "./paths.js";
+import { join } from "node:path";
+import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
+import { existsSync, unlinkSync } from "node:fs";
+// ─── Graph Construction ───────────────────────────────────────────────────
+/**
+ * Build a dependency graph from task IO signatures.
+ *
+ * A task T_b depends on T_a when any of T_b's inputFiles appear in T_a's
+ * outputFiles. Self-references are excluded.
+ *
+ * Tasks are returned in the same order as the input array.
+ */
+export function deriveTaskGraph(tasks) {
+    // Build output → producer lookup
+    const outputToProducer = new Map();
+    for (const task of tasks) {
+        for (const outFile of task.outputFiles) {
+            const existing = outputToProducer.get(outFile);
+            if (existing) {
+                existing.push(task.id);
+            }
+            else {
+                outputToProducer.set(outFile, [task.id]);
+            }
+        }
+    }
+    return tasks.map((task) => {
+        const deps = new Set();
+        for (const inFile of task.inputFiles) {
+            const producers = outputToProducer.get(inFile);
+            if (producers) {
+                for (const pid of producers) {
+                    if (pid !== task.id)
+                        deps.add(pid);
+                }
+            }
+        }
+        return {
+            ...task,
+            dependsOn: [...deps].sort(),
+        };
+    });
+}
+// ─── Ready Set Resolution ─────────────────────────────────────────────────
+/**
+ * Return task IDs whose dependencies are all in `completed`.
+ * Excludes tasks that are already done or in-flight.
+ */
+export function getReadyTasks(graph, completed, inFlight) {
+    return graph
+        .filter((node) => {
+        if (node.done || completed.has(node.id) || inFlight.has(node.id))
+            return false;
+        return node.dependsOn.every((dep) => completed.has(dep));
+    })
+        .map((node) => node.id);
+}
+// ─── Conflict-Free Subset Selection ──────────────────────────────────────
+/**
+ * Greedy selection of non-conflicting tasks up to `maxParallel`.
+ *
+ * Two tasks conflict if they share any outputFile. We also exclude tasks
+ * whose outputs overlap with `inFlightOutputs` (files being written by
+ * tasks currently in progress).
+ */
+export function chooseNonConflictingSubset(readyIds, graph, maxParallel, inFlightOutputs) {
+    const nodeMap = new Map(graph.map((n) => [n.id, n]));
+    const claimed = new Set(inFlightOutputs);
+    const selected = [];
+    for (const id of readyIds) {
+        if (selected.length >= maxParallel)
+            break;
+        const node = nodeMap.get(id);
+        if (!node)
+            continue;
+        // Check for output overlap with already-selected or in-flight
+        const conflicts = node.outputFiles.some((f) => claimed.has(f));
+        if (conflicts)
+            continue;
+        // Claim this task's outputs
+        for (const f of node.outputFiles)
+            claimed.add(f);
+        selected.push(id);
+    }
+    return selected;
+}
+// ─── Graph Quality Checks ─────────────────────────────────────────────────
+/**
+ * Returns true if any incomplete task has 0 inputFiles AND 0 outputFiles.
+ *
+ * An ambiguous graph means IO annotations are too sparse to derive reliable
+ * edges — the dispatcher should fall back to sequential execution.
+ */
+export function isGraphAmbiguous(graph) {
+    return graph.some((node) => !node.done &&
+        node.inputFiles.length === 0 &&
+        node.outputFiles.length === 0);
+}
+/**
+ * Detect deadlock: no tasks are ready and none are in-flight, yet incomplete
+ * tasks remain. This indicates a circular dependency or impossible state.
+ */
+export function detectDeadlock(graph, completed, inFlight) {
+    const incomplete = graph.filter((n) => !n.done && !completed.has(n.id) && !inFlight.has(n.id));
+    if (incomplete.length === 0)
+        return false; // all done
+    if (inFlight.size > 0)
+        return false; // something is running, wait for it
+    // Nothing in flight, but incomplete tasks remain — check if any are ready
+    const ready = getReadyTasks(graph, completed, inFlight);
+    return ready.length === 0;
+}
+// ─── Graph Metrics ────────────────────────────────────────────────────────
+/** Compute summary metrics for logging. */
+export function graphMetrics(graph) {
+    const completed = new Set(graph.filter((n) => n.done).map((n) => n.id));
+    const ready = getReadyTasks(graph, completed, new Set());
+    const edgeCount = graph.reduce((sum, n) => sum + n.dependsOn.length, 0);
+    return {
+        taskCount: graph.length,
+        edgeCount,
+        readySetSize: ready.length,
+        ambiguous: isGraphAmbiguous(graph),
+    };
+}
+// ─── IO Loader (async, filesystem) ────────────────────────────────────────
+/**
+ * Load TaskIO for all tasks in a slice by reading the slice plan (for done
+ * status and task IDs) and individual task plan files (for IO sections).
+ *
+ * Returns [] when the slice plan or tasks directory doesn't exist.
+ */
+export async function loadSliceTaskIO(basePath, mid, sid) {
+    const { resolveSliceFile } = await import("./paths.js");
+    const slicePlanPath = resolveSliceFile(basePath, mid, sid, "PLAN");
+    const planContent = slicePlanPath ? await loadFile(slicePlanPath) : null;
+    if (!planContent)
+        return [];
+    const plan = parsePlan(planContent);
+    const tDir = resolveTasksDir(basePath, mid, sid);
+    if (!tDir)
+        return [];
+    const results = [];
+    for (const taskEntry of plan.tasks) {
+        const planFiles = resolveTaskFiles(tDir, "PLAN");
+        const taskFileName = planFiles.find((f) => f.toUpperCase().startsWith(taskEntry.id.toUpperCase() + "-"));
+        if (!taskFileName) {
+            // Task plan file missing — include with empty IO (will trigger ambiguous)
+            results.push({
+                id: taskEntry.id,
+                title: taskEntry.title,
+                inputFiles: [],
+                outputFiles: [],
+                done: taskEntry.done,
+            });
+            continue;
+        }
+        const taskContent = await loadFile(join(tDir, taskFileName));
+        if (!taskContent) {
+            results.push({
+                id: taskEntry.id,
+                title: taskEntry.title,
+                inputFiles: [],
+                outputFiles: [],
+                done: taskEntry.done,
+            });
+            continue;
+        }
+        const io = parseTaskPlanIO(taskContent);
+        results.push({
+            id: taskEntry.id,
+            title: taskEntry.title,
+            inputFiles: io.inputFiles,
+            outputFiles: io.outputFiles,
+            done: taskEntry.done,
+        });
+    }
+    return results;
+}
+// ─── State Persistence ────────────────────────────────────────────────────
+function reactiveStatePath(basePath, mid, sid) {
+    return join(basePath, ".gsd", "runtime", `${mid}-${sid}-reactive.json`);
+}
+function isReactiveState(data) {
+    if (!data || typeof data !== "object")
+        return false;
+    const d = data;
+    return typeof d.sliceId === "string" && Array.isArray(d.completed) && Array.isArray(d.dispatched);
+}
+/**
+ * Load persisted reactive execution state for a slice.
+ * Returns null when no state file exists or the file is invalid.
+ */
+export function loadReactiveState(basePath, mid, sid) {
+    return loadJsonFileOrNull(reactiveStatePath(basePath, mid, sid), isReactiveState);
+}
+/**
+ * Save reactive execution state to disk.
+ */
+export function saveReactiveState(basePath, mid, sid, state) {
+    saveJsonFile(reactiveStatePath(basePath, mid, sid), state);
+}
+/**
+ * Remove the reactive state file when a slice completes.
+ */
+export function clearReactiveState(basePath, mid, sid) {
+    const path = reactiveStatePath(basePath, mid, sid);
+    try {
+        if (existsSync(path))
+            unlinkSync(path);
+    }
+    catch {
+        // Non-fatal
+    }
+}

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -42,11 +42,19 @@ estimated_files: {{estimatedFiles}}
 
 ## Inputs
 
+<!-- Every input MUST be a backtick-wrapped file path. These paths are machine-parsed to
+     derive task dependencies — vague descriptions without paths break dependency detection.
+     For the first task in a slice with no prior task outputs, list the existing source files
+     this task reads or modifies. -->
+
 - `{{filePath}}` — {{whatThisTaskNeedsFromPriorWork}}
-- {{priorTaskSummaryInsight}}
 
 ## Expected Output
 
-<!-- This task should produce a real increment toward making the slice goal/demo true. A full slice plan should not be able to mark every task complete while the claimed slice behavior still does not work at the stated proof level. -->
+<!-- Every output MUST be a backtick-wrapped file path — the specific files this task creates
+     or modifies. These paths are machine-parsed to derive task dependencies.
+     This task should produce a real increment toward making the slice goal/demo true. A full
+     slice plan should not be able to mark every task complete while the claimed slice behavior
+     still does not work at the stated proof level. -->
 
-- `{{filePath}}` — {{whatThisTaskShouldProduceOrModify}}
+- `{{filePath}}` — {{whatThisTaskCreatesOrModifies}}

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

@@ -57,42 +57,61 @@ export function captureIntegrationBranch(basePath, milestoneId, options) {
     writeIntegrationBranch(basePath, milestoneId, current, options);
 }
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────
+/**
+ * Find the worktrees segment in a path, supporting both direct
+ * (`/.gsd/worktrees/`) and symlink-resolved (`/.gsd/projects/<hash>/worktrees/`)
+ * layouts.  When `.gsd` is a symlink to `~/.gsd/projects/<hash>`, resolved
+ * paths contain the intermediate `projects/<hash>/` segment that the old
+ * single-marker check missed.
+ */
+function findWorktreeSegment(normalizedPath) {
+    // Direct layout: /.gsd/worktrees/<name>
+    const directMarker = "/.gsd/worktrees/";
+    const idx = normalizedPath.indexOf(directMarker);
+    if (idx !== -1) {
+        return { gsdIdx: idx, afterWorktrees: idx + directMarker.length };
+    }
+    // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/<name>
+    const symlinkRe = /\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//;
+    const match = normalizedPath.match(symlinkRe);
+    if (match && match.index !== undefined) {
+        return { gsdIdx: match.index, afterWorktrees: match.index + match[0].length };
+    }
+    return null;
+}
 /**
  * Detect the active worktree name from the current working directory.
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
  */
 export function detectWorktreeName(basePath) {
     const normalizedPath = basePath.replaceAll("\\", "/");
-    const marker = "/.gsd/worktrees/";
-    const idx = normalizedPath.indexOf(marker);
-    if (idx === -1)
+    const seg = findWorktreeSegment(normalizedPath);
+    if (!seg)
         return null;
-    const afterMarker = normalizedPath.slice(idx + marker.length);
+    const afterMarker = normalizedPath.slice(seg.afterWorktrees);
     const name = afterMarker.split("/")[0];
     return name || null;
 }
 /**
  * Resolve the project root from a path that may be inside a worktree.
- * If the path contains `/.gsd/worktrees/<name>/`, returns the portion
- * before `/.gsd/`. Otherwise returns the input unchanged.
+ * If the path contains a worktrees segment, returns the portion before
+ * `/.gsd/`. Otherwise returns the input unchanged.
  *
  * Use this in commands that call `process.cwd()` to ensure they always
  * operate against the real project root, not a worktree subdirectory.
  */
 export function resolveProjectRoot(basePath) {
     const normalizedPath = basePath.replaceAll("\\", "/");
-    const marker = "/.gsd/worktrees/";
-    const idx = normalizedPath.indexOf(marker);
-    if (idx === -1)
+    const seg = findWorktreeSegment(normalizedPath);
+    if (!seg)
         return basePath;
-    // Return the original path up to the .gsd/ marker (un-normalized)
-    // Account for potential OS-specific separators
+    // Return the original path up to the /.gsd/ boundary
     const sep = basePath.includes("\\") ? "\\" : "/";
-    const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
-    const idxOs = basePath.indexOf(markerOs);
-    if (idxOs !== -1)
-        return basePath.slice(0, idxOs);
-    return basePath.slice(0, idx);
+    const gsdMarker = `${sep}.gsd${sep}`;
+    const gsdIdx = basePath.indexOf(gsdMarker);
+    if (gsdIdx !== -1)
+        return basePath.slice(0, gsdIdx);
+    return basePath.slice(0, seg.gsdIdx);
 }
 /**
  * Get the slice branch name, namespaced by worktree when inside one.

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

@@ -360,7 +360,7 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, si
             }
     }
 }
-async function runSingleAgentInCmuxSplit(cmuxClient, direction, defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails) {
+async function runSingleAgentInCmuxSplit(cmuxClient, directionOrSurfaceId, defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails) {
     const agent = agents.find((a) => a.name === agentName);
     if (!agent) {
         return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
@@ -397,7 +397,12 @@ async function runSingleAgentInCmuxSplit(cmuxClient, direction, defaultCwd, agen
         const stdoutPath = path.join(tmpOutputDir, "stdout.jsonl");
         const stderrPath = path.join(tmpOutputDir, "stderr.log");
         const exitPath = path.join(tmpOutputDir, "exit.code");
-        const cmuxSurfaceId = await cmuxClient.createSplit(direction);
+        // Accept either a pre-created surface ID or a direction to create a new split
+        const isDirection = directionOrSurfaceId === "right" || directionOrSurfaceId === "down"
+            || directionOrSurfaceId === "left" || directionOrSurfaceId === "up";
+        const cmuxSurfaceId = isDirection
+            ? await cmuxClient.createSplit(directionOrSurfaceId)
+            : directionOrSurfaceId;
         if (!cmuxSurfaceId) {
             return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
         }
@@ -656,10 +661,14 @@ export default function (pi) {
                 const MAX_RETRIES = 1; // Retry failed tasks once
                 const batchId = crypto.randomUUID();
                 const batchSize = params.tasks.length;
+                // Pre-create a grid layout for cmux splits so agents get a clean tiled arrangement
+                const gridSurfaces = cmuxSplitsEnabled
+                    ? await cmuxClient.createGridLayout(Math.min(batchSize, MAX_CONCURRENCY))
+                    : [];
                 const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
                     const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
                     const runTask = () => cmuxSplitsEnabled
-                        ? runSingleAgentInCmuxSplit(cmuxClient, index % 2 === 0 ? "right" : "down", ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, signal, (partial) => {
+                        ? runSingleAgentInCmuxSplit(cmuxClient, gridSurfaces[index] ?? (index % 2 === 0 ? "right" : "down"), ctx.cwd, agents, t.agent, t.task, t.cwd, undefined, signal, (partial) => {
                             if (partial.details?.results[0]) {
                                 allResults[index] = partial.details.results[0];
                                 emitParallelUpdate();

package/dist/resources/extensions/universal-config/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./index.js"
     ]
   }
 }

package/dist/welcome-screen.d.ts

@@ -0,0 +1,12 @@
+/**
+ * GSD Welcome Screen
+ *
+ * Rendered to stderr before the TUI takes over.
+ * No box, no panels — logo with metadata alongside, dim hint below.
+ */
+export interface WelcomeScreenOptions {
+    version: string;
+    modelName?: string;
+    provider?: string;
+}
+export declare function printWelcomeScreen(opts: WelcomeScreenOptions): void;

package/dist/welcome-screen.js

@@ -0,0 +1,53 @@
+/**
+ * GSD Welcome Screen
+ *
+ * Rendered to stderr before the TUI takes over.
+ * No box, no panels — logo with metadata alongside, dim hint below.
+ */
+import os from 'node:os';
+import chalk from 'chalk';
+import { GSD_LOGO } from './logo.js';
+function getShortCwd() {
+    const cwd = process.cwd();
+    const home = os.homedir();
+    return cwd.startsWith(home) ? '~' + cwd.slice(home.length) : cwd;
+}
+export function printWelcomeScreen(opts) {
+    if (!process.stderr.isTTY)
+        return;
+    const { version, modelName, provider } = opts;
+    const shortCwd = getShortCwd();
+    // Info lines to sit alongside the logo (one per logo row)
+    const modelLine = [modelName, provider].filter(Boolean).join('  ·  ');
+    const INFO = [
+        `  ${chalk.bold('Get Shit Done')}  ${chalk.dim('v' + version)}`,
+        undefined,
+        modelLine ? `  ${chalk.dim(modelLine)}` : undefined,
+        `  ${chalk.dim(shortCwd)}`,
+        undefined,
+        undefined,
+    ];
+    const lines = [''];
+    for (let i = 0; i < GSD_LOGO.length; i++) {
+        lines.push(chalk.cyan(GSD_LOGO[i]) + (INFO[i] ?? ''));
+    }
+    // Tool status + hint — dim, aligned under the info text
+    const pad = ' '.repeat(28) + '  '; // aligns with the info text column
+    const toolParts = [];
+    if (process.env.BRAVE_API_KEY)
+        toolParts.push('Brave ✓');
+    if (process.env.BRAVE_ANSWERS_KEY)
+        toolParts.push('Answers ✓');
+    if (process.env.JINA_API_KEY)
+        toolParts.push('Jina ✓');
+    if (process.env.TAVILY_API_KEY)
+        toolParts.push('Tavily ✓');
+    if (process.env.CONTEXT7_API_KEY)
+        toolParts.push('Context7 ✓');
+    if (toolParts.length > 0) {
+        lines.push(chalk.dim(pad + ['Web search loaded', ...toolParts].join('  ·  ')));
+    }
+    lines.push(chalk.dim(pad + '/gsd to begin  ·  /gsd help for all commands'));
+    lines.push('');
+    process.stderr.write(lines.join('\n') + '\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.37.1",
+  "version": "2.38.0-dev.96dc7fb",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {
@@ -84,6 +84,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.73.0",
+    "@anthropic-ai/vertex-sdk": "^0.14.4",
     "@aws-sdk/client-bedrock-runtime": "^3.983.0",
     "@clack/prompts": "^1.1.0",
     "@google/genai": "^1.40.0",

package/packages/pi-ai/dist/env-api-keys.js

@@ -53,6 +53,19 @@ export function getEnvApiKey(provider) {
     if (provider === "anthropic") {
         return process.env.ANTHROPIC_OAUTH_TOKEN || process.env.ANTHROPIC_API_KEY;
     }
+    // Anthropic on Vertex AI uses Application Default Credentials.
+    // Detected via ANTHROPIC_VERTEX_PROJECT_ID (same env var as Claude Code).
+    if (provider === "anthropic-vertex") {
+        const hasProject = !!process.env.ANTHROPIC_VERTEX_PROJECT_ID;
+        if (hasProject) {
+            return "<authenticated>";
+        }
+        // Fall back to Google Cloud project env vars
+        const hasGoogleProject = !!(process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT);
+        if (hasGoogleProject && hasVertexAdcCredentials()) {
+            return "<authenticated>";
+        }
+    }
     // Vertex AI uses Application Default Credentials, not API keys.
     // Auth is configured via `gcloud auth application-default login`.
     if (provider === "google-vertex") {