gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.5a170d0

package/dist/resources/extensions/gsd/definition-loader.js

@@ -0,0 +1,352 @@
+/**
+ * definition-loader.ts — Parse and validate V1 YAML workflow definitions.
+ *
+ * Loads definition YAML files from `.gsd/workflow-defs/`, validates the
+ * V1 schema shape, and returns typed TypeScript objects. Pure functions
+ * with no engine or runtime dependencies — just `yaml` and `node:fs`.
+ *
+ * YAML uses snake_case (`depends_on`, `context_from`) per project convention (P005).
+ * TypeScript uses camelCase (`dependsOn`, `contextFrom`).
+ *
+ * Observability: All validation errors are collected into a string[] — callers
+ * can log, surface in dashboards, or return to agents for self-repair.
+ * substituteParams errors include the offending key name for traceability.
+ */
+import { parse } from "yaml";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+// ─── Validation ──────────────────────────────────────────────────────────
+/**
+ * Validate a parsed (but untyped) YAML object against the V1 workflow schema.
+ *
+ * Collects all errors (does not short-circuit) so a single call reveals
+ * every problem with the definition.
+ *
+ * Unknown fields are silently accepted for forward compatibility with
+ * S05/S06 features (`context_from`, `verify`, `iterate`).
+ */
+export function validateDefinition(parsed) {
+    const errors = [];
+    if (parsed == null || typeof parsed !== "object") {
+        return { valid: false, errors: ["Definition must be a non-null object"] };
+    }
+    const def = parsed;
+    // version: must be 1 (number)
+    if (def.version === undefined || def.version === null) {
+        errors.push("Missing required field: version");
+    }
+    else if (def.version !== 1) {
+        errors.push(`Unsupported version: ${def.version} (expected 1)`);
+    }
+    // name: must be a non-empty string
+    if (typeof def.name !== "string" || def.name.trim() === "") {
+        errors.push("Missing or empty required field: name");
+    }
+    // steps: must be a non-empty array
+    if (!Array.isArray(def.steps)) {
+        errors.push("Missing required field: steps (must be an array)");
+    }
+    else if (def.steps.length === 0) {
+        errors.push("steps must contain at least one step");
+    }
+    else {
+        // Track whether all steps have valid IDs — graph-level checks only run when true
+        let allStepIdsValid = true;
+        for (let i = 0; i < def.steps.length; i++) {
+            const step = def.steps[i];
+            if (step == null || typeof step !== "object") {
+                errors.push(`Step at index ${i} is not an object`);
+                allStepIdsValid = false;
+                continue;
+            }
+            // Required step fields
+            if (typeof step.id !== "string" || step.id.trim() === "") {
+                errors.push(`Step at index ${i} missing required field: id`);
+                allStepIdsValid = false;
+            }
+            if (typeof step.name !== "string" || step.name.trim() === "") {
+                errors.push(`Step at index ${i} missing required field: name`);
+            }
+            if (typeof step.prompt !== "string" || step.prompt.trim() === "") {
+                errors.push(`Step at index ${i} missing required field: prompt`);
+            }
+            // produces: path traversal guard
+            if (Array.isArray(step.produces)) {
+                for (const p of step.produces) {
+                    if (typeof p === "string" && p.includes("..")) {
+                        errors.push(`Step "${step.id}" produces path contains disallowed '..': ${p}`);
+                    }
+                }
+            }
+            // iterate: optional, but if present must conform to IterateConfig shape
+            if (step.iterate !== undefined) {
+                const it = step.iterate;
+                const sid = typeof step.id === "string" ? step.id : `index ${i}`;
+                if (it == null || typeof it !== "object" || Array.isArray(it)) {
+                    errors.push(`Step "${sid}" iterate must be an object with "source" and "pattern" fields`);
+                }
+                else {
+                    const itObj = it;
+                    if (typeof itObj.source !== "string" || itObj.source.trim() === "") {
+                        errors.push(`Step "${sid}" iterate.source must be a non-empty string`);
+                    }
+                    else if (itObj.source.includes("..")) {
+                        errors.push(`Step "${sid}" iterate.source contains disallowed '..' path traversal`);
+                    }
+                    if (typeof itObj.pattern !== "string" || itObj.pattern.trim() === "") {
+                        errors.push(`Step "${sid}" iterate.pattern must be a non-empty string`);
+                    }
+                    else {
+                        const pat = itObj.pattern;
+                        let regexValid = true;
+                        try {
+                            new RegExp(pat);
+                        }
+                        catch {
+                            regexValid = false;
+                            errors.push(`Step "${sid}" iterate.pattern is not a valid regex: ${pat}`);
+                        }
+                        if (regexValid && !/\((?!\?)/.test(pat)) {
+                            errors.push(`Step "${sid}" iterate.pattern must contain at least one capture group`);
+                        }
+                    }
+                }
+            }
+            // verify: optional, but if present must conform to VerifyPolicy shape
+            if (step.verify !== undefined) {
+                const v = step.verify;
+                const sid = typeof step.id === "string" ? step.id : `index ${i}`;
+                if (v == null || typeof v !== "object" || Array.isArray(v)) {
+                    errors.push(`Step "${sid}" verify must be an object with a "policy" field`);
+                }
+                else {
+                    const vObj = v;
+                    const VALID_POLICIES = ["content-heuristic", "shell-command", "prompt-verify", "human-review"];
+                    if (typeof vObj.policy !== "string" || !VALID_POLICIES.includes(vObj.policy)) {
+                        errors.push(`Step "${sid}" verify.policy must be one of: ${VALID_POLICIES.join(", ")}`);
+                    }
+                    else {
+                        // Policy-specific required field checks
+                        if (vObj.policy === "shell-command") {
+                            if (typeof vObj.command !== "string" || vObj.command.trim() === "") {
+                                errors.push(`Step "${sid}" verify policy "shell-command" requires a non-empty "command" field`);
+                            }
+                        }
+                        if (vObj.policy === "prompt-verify") {
+                            if (typeof vObj.prompt !== "string" || vObj.prompt.trim() === "") {
+                                errors.push(`Step "${sid}" verify policy "prompt-verify" requires a non-empty "prompt" field`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // ─── Graph-level validations (only when all step IDs are valid) ────
+        if (allStepIdsValid) {
+            const steps = def.steps;
+            // 1. Duplicate step ID check
+            const idCounts = new Map();
+            for (const step of steps) {
+                const id = step.id;
+                idCounts.set(id, (idCounts.get(id) ?? 0) + 1);
+            }
+            for (const [id, count] of idCounts) {
+                if (count > 1) {
+                    errors.push(`Duplicate step id: ${id}`);
+                }
+            }
+            // Build valid ID set for remaining checks
+            const validIds = new Set(steps.map((s) => s.id));
+            // 2. Dangling dependency check + 3. Self-referencing dependency check
+            for (const step of steps) {
+                const sid = step.id;
+                const deps = Array.isArray(step.requires)
+                    ? step.requires
+                    : Array.isArray(step.depends_on)
+                        ? step.depends_on
+                        : [];
+                for (const depId of deps) {
+                    if (depId === sid) {
+                        errors.push(`Step '${sid}' depends on itself`);
+                    }
+                    else if (!validIds.has(depId)) {
+                        errors.push(`Step '${sid}' requires unknown step '${depId}'`);
+                    }
+                }
+            }
+            // 4. Cycle detection (DFS) — only when no duplicate IDs
+            if (![...idCounts.values()].some((c) => c > 1)) {
+                // Build adjacency list: step → its dependencies
+                const adj = new Map();
+                for (const step of steps) {
+                    const sid = step.id;
+                    const deps = Array.isArray(step.requires)
+                        ? step.requires
+                        : Array.isArray(step.depends_on)
+                            ? step.depends_on
+                            : [];
+                    adj.set(sid, deps.filter((d) => validIds.has(d) && d !== sid));
+                }
+                const WHITE = 0, GRAY = 1, BLACK = 2;
+                const color = new Map();
+                for (const id of validIds)
+                    color.set(id, WHITE);
+                const parent = new Map();
+                function dfs(node) {
+                    color.set(node, GRAY);
+                    for (const dep of adj.get(node) ?? []) {
+                        if (color.get(dep) === GRAY) {
+                            // Back edge found — reconstruct cycle path
+                            const cycle = [dep, node];
+                            let cur = node;
+                            while (parent.has(cur) && parent.get(cur) !== null && parent.get(cur) !== dep) {
+                                cur = parent.get(cur);
+                                cycle.push(cur);
+                            }
+                            cycle.push(dep);
+                            cycle.reverse();
+                            return cycle;
+                        }
+                        if (color.get(dep) === WHITE) {
+                            parent.set(dep, node);
+                            const result = dfs(dep);
+                            if (result)
+                                return result;
+                        }
+                    }
+                    color.set(node, BLACK);
+                    return null;
+                }
+                for (const id of validIds) {
+                    if (color.get(id) === WHITE) {
+                        parent.set(id, null);
+                        const cycle = dfs(id);
+                        if (cycle) {
+                            errors.push(`Cycle detected: ${cycle.join(" → ")}`);
+                            break; // One cycle error is enough
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+// ─── Loading ─────────────────────────────────────────────────────────────
+/**
+ * Load and validate a YAML workflow definition from the filesystem.
+ *
+ * Reads `<defsDir>/<name>.yaml`, parses YAML, validates the V1 schema,
+ * and converts snake_case YAML keys to camelCase TypeScript types.
+ *
+ * @param defsDir — directory containing definition YAML files
+ * @param name — definition filename without extension
+ * @returns Parsed and validated WorkflowDefinition
+ * @throws Error if file is missing, YAML is malformed, or schema is invalid
+ */
+export function loadDefinition(defsDir, name) {
+    const filePath = join(defsDir, `${name}.yaml`);
+    if (!existsSync(filePath)) {
+        throw new Error(`Definition file not found: ${filePath}`);
+    }
+    const raw = readFileSync(filePath, "utf-8");
+    let parsed;
+    try {
+        parsed = parse(raw);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to parse YAML in ${filePath}: ${msg}`);
+    }
+    const { valid, errors } = validateDefinition(parsed);
+    if (!valid) {
+        throw new Error(`Invalid workflow definition in ${filePath}:\n  - ${errors.join("\n  - ")}`);
+    }
+    // Convert snake_case YAML → camelCase TypeScript
+    const yamlDef = parsed;
+    const yamlSteps = yamlDef.steps;
+    return {
+        version: yamlDef.version,
+        name: yamlDef.name,
+        description: typeof yamlDef.description === "string" ? yamlDef.description : undefined,
+        params: yamlDef.params != null && typeof yamlDef.params === "object"
+            ? Object.fromEntries(Object.entries(yamlDef.params).map(([k, v]) => [k, String(v)]))
+            : undefined,
+        steps: yamlSteps.map((s) => ({
+            id: s.id,
+            name: s.name,
+            prompt: s.prompt,
+            requires: Array.isArray(s.requires)
+                ? s.requires
+                : Array.isArray(s.depends_on)
+                    ? s.depends_on
+                    : [],
+            produces: Array.isArray(s.produces) ? s.produces : [],
+            contextFrom: Array.isArray(s.context_from) ? s.context_from : undefined,
+            verify: s.verify,
+            iterate: (s.iterate != null && typeof s.iterate === "object")
+                ? s.iterate
+                : undefined,
+        })),
+    };
+}
+// ─── Parameter Substitution ──────────────────────────────────────────────
+/** Regex matching `{{key}}` placeholders — captures the key name. */
+const PARAM_PATTERN = /\{\{(\w+)\}\}/g;
+/**
+ * Replace `{{key}}` placeholders in a single prompt string.
+ *
+ * Exported for use by the engine on iteration-instance prompts that live
+ * in GRAPH.yaml (outside the definition's step list).
+ *
+ * @throws Error if any merged param value contains `..` (path-traversal guard)
+ */
+export function substitutePromptString(prompt, merged) {
+    return prompt.replace(PARAM_PATTERN, (match, key) => {
+        const value = merged[key];
+        return value !== undefined ? value : match;
+    });
+}
+/**
+ * Replace `{{key}}` placeholders in all step prompts with param values.
+ *
+ * Merge order: `definition.params` (defaults) ← `overrides` (CLI wins).
+ * Returns a **new** WorkflowDefinition — the input is never mutated.
+ *
+ * @throws Error if any param value contains `..` (path-traversal guard)
+ * @throws Error if any `{{key}}` remains unresolved after substitution
+ */
+export function substituteParams(definition, overrides) {
+    const merged = {
+        ...(definition.params ?? {}),
+        ...(overrides ?? {}),
+    };
+    // Path-traversal guard: reject any value containing ".."
+    for (const [key, value] of Object.entries(merged)) {
+        if (value.includes("..")) {
+            throw new Error(`Parameter "${key}" contains disallowed '..' (path traversal): ${value}`);
+        }
+    }
+    // Substitute in each step prompt
+    const substitutedSteps = definition.steps.map((step) => ({
+        ...step,
+        prompt: substitutePromptString(step.prompt, merged),
+    }));
+    // Check for unresolved placeholders
+    const unresolved = new Set();
+    for (const step of substitutedSteps) {
+        let m;
+        const re = new RegExp(PARAM_PATTERN.source, "g");
+        while ((m = re.exec(step.prompt)) !== null) {
+            unresolved.add(m[1]);
+        }
+    }
+    if (unresolved.size > 0) {
+        const keys = [...unresolved].sort().join(", ");
+        throw new Error(`Unresolved parameter(s) in step prompts: ${keys}`);
+    }
+    return {
+        ...definition,
+        steps: substitutedSteps,
+    };
+}

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

@@ -11,7 +11,7 @@ import { homedir } from "node:os";
 import { gsdRoot } from "./paths.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Project File Markers ───────────────────────────────────────────────────────
-const PROJECT_FILES = [
+export const PROJECT_FILES = [
     "package.json",
     "Cargo.toml",
     "go.mod",

package/dist/resources/extensions/gsd/dev-execution-policy.js

@@ -0,0 +1,24 @@
+/**
+ * dev-execution-policy.ts — DevExecutionPolicy implementation.
+ *
+ * Stub policy for the dev engine. All methods return safe defaults.
+ * Real verification/closeout continues running through phases.ts via LoopDeps.
+ * Wiring this policy into the loop is S04's responsibility.
+ */
+export class DevExecutionPolicy {
+    async prepareWorkspace(_basePath, _milestoneId) {
+        // no-op — workspace preparation handled by existing GSD logic
+    }
+    async selectModel(_unitType, _unitId, _context) {
+        return null; // use default model selection
+    }
+    async verify(_unitType, _unitId, _context) {
+        return "continue";
+    }
+    async recover(_unitType, _unitId, _context) {
+        return { outcome: "retry" };
+    }
+    async closeout(_unitType, _unitId, _context) {
+        return { committed: false, artifacts: [] };
+    }
+}

package/dist/resources/extensions/gsd/dev-workflow-engine.js

@@ -0,0 +1,82 @@
+/**
+ * dev-workflow-engine.ts — DevWorkflowEngine implementation.
+ *
+ * Implements WorkflowEngine by delegating to existing GSD state derivation
+ * and dispatch logic. This is the "dev" engine — it wraps the current GSD
+ * auto-mode behavior behind the engine-polymorphic interface.
+ */
+import { deriveState } from "./state.js";
+import { resolveDispatch } from "./auto-dispatch.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+// ─── Bridge: DispatchAction → EngineDispatchAction ────────────────────────
+/**
+ * Map a GSD-specific DispatchAction (which carries `matchedRule`, `unitType`,
+ * etc.) to the engine-generic EngineDispatchAction discriminated union.
+ *
+ * Exported for unit testing.
+ */
+export function bridgeDispatchAction(da) {
+    switch (da.action) {
+        case "dispatch":
+            return {
+                action: "dispatch",
+                step: {
+                    unitType: da.unitType,
+                    unitId: da.unitId,
+                    prompt: da.prompt,
+                },
+            };
+        case "stop":
+            return {
+                action: "stop",
+                reason: da.reason,
+                level: da.level,
+            };
+        case "skip":
+            return { action: "skip" };
+    }
+}
+// ─── DevWorkflowEngine ───────────────────────────────────────────────────
+export class DevWorkflowEngine {
+    engineId = "dev";
+    async deriveState(basePath) {
+        const gsd = await deriveState(basePath);
+        return {
+            phase: gsd.phase,
+            currentMilestoneId: gsd.activeMilestone?.id ?? null,
+            activeSliceId: gsd.activeSlice?.id ?? null,
+            activeTaskId: gsd.activeTask?.id ?? null,
+            isComplete: gsd.phase === "complete",
+            raw: gsd,
+        };
+    }
+    async resolveDispatch(state, context) {
+        const gsd = state.raw;
+        const mid = gsd.activeMilestone?.id ?? "";
+        const midTitle = gsd.activeMilestone?.title ?? "";
+        const loaded = loadEffectiveGSDPreferences();
+        const prefs = loaded?.preferences ?? undefined;
+        const dispatchCtx = {
+            basePath: context.basePath,
+            mid,
+            midTitle,
+            state: gsd,
+            prefs,
+        };
+        const result = await resolveDispatch(dispatchCtx);
+        return bridgeDispatchAction(result);
+    }
+    async reconcile(state, _completedStep) {
+        return {
+            outcome: state.isComplete ? "milestone-complete" : "continue",
+        };
+    }
+    getDisplayMetadata(state) {
+        return {
+            engineLabel: "GSD Dev",
+            currentPhase: state.phase,
+            progressSummary: `${state.currentMilestoneId ?? "no milestone"} / ${state.activeSliceId ?? "—"} / ${state.activeTaskId ?? "—"}`,
+            stepCount: null,
+        };
+    }
+}

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

@@ -745,6 +745,7 @@ export async function runGSDDoctor(basePath, options) {
             }
             catch { /* non-fatal */ }
             let allTasksDone = plan.tasks.length > 0;
+            let taskUncheckedByDoctor = false;
             for (const task of plan.tasks) {
                 const taskUnitId = `${unitId}/${task.id}`;
                 const summaryPath = resolveTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY");
@@ -762,6 +763,7 @@ export async function runGSDDoctor(basePath, options) {
                     dryRunCanFix("task_done_missing_summary", `uncheck ${task.id} in plan for ${taskUnitId}`);
                     if (shouldFix("task_done_missing_summary")) {
                         await markTaskUndoneInPlan(basePath, milestoneId, slice.id, task.id, fixesApplied);
+                        taskUncheckedByDoctor = true;
                     }
                 }
                 if (!task.done && hasSummary) {
@@ -822,6 +824,14 @@ export async function runGSDDoctor(basePath, options) {
                 }
                 allTasksDone = allTasksDone && task.done;
             }
+            // ── #1850: cascade slice uncheck when task_done_missing_summary fires ──
+            // When doctor unchecks tasks inside a done slice, the slice must also be
+            // unchecked so the state machine re-enters the executing phase. Without
+            // this, state.ts skips done slices and the unchecked tasks never run,
+            // causing doctor to fire again on every start (infinite loop).
+            if (taskUncheckedByDoctor && slice.done) {
+                await markSliceUndoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
+            }
             // Blocker-without-replan detection
             const replanPath = resolveSliceFile(basePath, milestoneId, slice.id, "REPLAN");
             if (!replanPath) {
@@ -898,7 +908,7 @@ export async function runGSDDoctor(basePath, options) {
                     fixable: true,
                 });
                 dryRunCanFix("all_tasks_done_roadmap_not_checked", `mark ${slice.id} done in roadmap`);
-                if (shouldFix("all_tasks_done_roadmap_not_checked") && (hasSliceSummary || issues.some(issue => issue.code === "all_tasks_done_missing_slice_summary" && issue.unitId === unitId))) {
+                if (shouldFix("all_tasks_done_roadmap_not_checked") && (hasSliceSummary || existsSync(join(slicePath, `${slice.id}-SUMMARY.md`)))) {
                     await markSliceDoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
                 }
             }

package/dist/resources/extensions/gsd/engine-resolver.js

@@ -0,0 +1,40 @@
+/**
+ * engine-resolver.ts — Route sessions to engine/policy pairs.
+ *
+ * Routes `null` and `"dev"` engine IDs to the DevWorkflowEngine/DevExecutionPolicy
+ * pair. Any other non-null engine ID is treated as a custom workflow engine that
+ * reads its state from an `activeRunDir`. Respects `GSD_ENGINE_BYPASS=1` kill
+ * switch to skip the engine layer entirely.
+ */
+import { DevWorkflowEngine } from "./dev-workflow-engine.js";
+import { DevExecutionPolicy } from "./dev-execution-policy.js";
+import { CustomWorkflowEngine } from "./custom-workflow-engine.js";
+import { CustomExecutionPolicy } from "./custom-execution-policy.js";
+/**
+ * Resolve an engine/policy pair for the given session.
+ *
+ * - `null` or `"dev"` → DevWorkflowEngine + DevExecutionPolicy
+ * - any other non-null ID → CustomWorkflowEngine(activeRunDir) + CustomExecutionPolicy()
+ *   (requires activeRunDir to be a non-empty string)
+ *
+ * Note: `GSD_ENGINE_BYPASS=1` is checked in autoLoop before calling this function.
+ */
+export function resolveEngine(session) {
+    const { activeEngineId, activeRunDir } = session;
+    if (activeEngineId === null || activeEngineId === "dev") {
+        return {
+            engine: new DevWorkflowEngine(),
+            policy: new DevExecutionPolicy(),
+        };
+    }
+    // Any non-null, non-"dev" engine ID is a custom workflow engine.
+    // activeRunDir is required — the engine reads GRAPH.yaml from it.
+    if (!activeRunDir || typeof activeRunDir !== "string") {
+        throw new Error(`Custom engine "${activeEngineId}" requires activeRunDir to be a non-empty string, ` +
+            `got: ${JSON.stringify(activeRunDir)}`);
+    }
+    return {
+        engine: new CustomWorkflowEngine(activeRunDir),
+        policy: new CustomExecutionPolicy(activeRunDir),
+    };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * engine-types.ts — Engine-polymorphic type contracts.
+ *
+ * LEAF NODE: This file must have ZERO imports from any GSD module.
+ * Only `node:` imports are permitted. All engine/policy interfaces
+ * depend on these types; nothing here depends on GSD internals.
+ */
+export {};

package/dist/resources/extensions/gsd/execution-policy.js

@@ -0,0 +1,8 @@
+/**
+ * execution-policy.ts — ExecutionPolicy interface.
+ *
+ * Defines the policy layer that governs model selection, verification,
+ * recovery, and closeout for each execution step. Imports only from
+ * the leaf-node engine-types.
+ */
+export {};

package/dist/resources/extensions/gsd/exit-command.js

@@ -4,8 +4,18 @@ export function registerExitCommand(pi, deps = {}) {
         description: "Exit GSD gracefully",
         handler: async (_args, ctx) => {
             // Stop auto-mode first so locks and activity state are cleaned up before shutdown.
-            const stopAuto = deps.stopAuto ?? (await importExtensionModule(import.meta.url, "./auto.js")).stopAuto;
-            await stopAuto(ctx, pi, "Graceful exit");
+            // Wrapped in try/catch: if gsd-pi was updated on disk mid-session, the dynamic
+            // import may resolve a new auto-worktree.js whose static imports reference
+            // exports absent from the process-cached native-git-bridge.js (ESM cache is
+            // immutable). The user's work is already saved — this is cleanup only.
+            try {
+                const stopAuto = deps.stopAuto ?? (await importExtensionModule(import.meta.url, "./auto.js")).stopAuto;
+                await stopAuto(ctx, pi, "Graceful exit");
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                ctx.ui?.notify?.(`Auto-mode cleanup skipped (module version mismatch): ${msg}`, "warning");
+            }
             ctx.shutdown();
         },
     });

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

@@ -2,7 +2,7 @@
 // Generate shareable reports of milestone work in JSON or markdown format.
 import { writeFileSync, mkdirSync } from "node:fs";
 import { join, basename } from "node:path";
-import { exec } from "node:child_process";
+import { execFile } from "node:child_process";
 import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk, } from "./metrics.js";
 import { gsdRoot } from "./paths.js";
 import { formatDuration, fileLink } from "../shared/format-utils.js";
@@ -13,18 +13,14 @@ import { getErrorMessage } from "./error-utils.js";
  * Non-blocking, non-fatal — failures are silently ignored.
  */
 export function openInBrowser(filePath) {
-    const cmd = process.platform === "darwin" ? "open" :
-        process.platform === "win32" ? "start" :
-            "xdg-open";
-    // On Windows, `start` needs an empty title argument when the path has spaces
-    const args = process.platform === "win32"
-        ? `"" "${filePath}"`
-        : `"${filePath}"`;
-    exec(`${cmd} ${args}`, (err) => {
-        // Non-fatal — if the browser can't be opened, the file path is still shown
-        if (err)
-            void err;
-    });
+    if (process.platform === "win32") {
+        // PowerShell's Start-Process handles paths with '&' and spaces safely.
+        execFile("powershell", ["-c", `Start-Process '${filePath.replace(/'/g, "''")}'`], () => { });
+    }
+    else {
+        const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+        execFile(cmd, [filePath], () => { });
+    }
 }
 /**
  * Write an export file directly, without requiring an ExtensionCommandContext.

package/dist/resources/extensions/gsd/extension-manifest.json

@@ -8,8 +8,8 @@
   "provides": {
     "tools": [
       "bash", "write", "read", "edit",
-      "gsd_save_decision", "gsd_save_summary",
-      "gsd_update_requirement", "gsd_generate_milestone_id"
+      "gsd_decision_save", "gsd_summary_save",
+      "gsd_requirement_update", "gsd_milestone_generate_id"
     ],
     "commands": ["gsd", "kill", "worktree", "exit"],
     "hooks": ["session_start"],