gsd-pi 2.50.0 → 2.51.0-dev.7d435fe

package/dist/resources/extensions/gsd/claude-import.js

@@ -79,16 +79,50 @@ function isMarketplacePath(pluginPath) {
 }
 /**
  * Detect which plugin roots are marketplaces and which are legacy flat paths.
+ *
+ * Claude Code stores marketplace sources under ~/.claude/plugins/marketplaces/.
+ * Each subdirectory (e.g. marketplaces/confluent/) is a marketplace repo that
+ * contains .claude-plugin/marketplace.json. The parent directory itself does not
+ * have a marketplace.json, so we scan one level deeper when the root isn't
+ * directly a marketplace.
  */
-function categorizePluginRoots(pluginRoots) {
+export function categorizePluginRoots(pluginRoots) {
     const marketplaces = [];
     const flat = [];
+    const seen = new Set();
     for (const root of pluginRoots) {
         if (isMarketplacePath(root)) {
-            marketplaces.push(root);
+            if (!seen.has(root)) {
+                marketplaces.push(root);
+                seen.add(root);
+            }
         }
         else {
-            flat.push(root);
+            // The root itself isn't a marketplace — check if it's a container of
+            // marketplaces (e.g. ~/.claude/plugins/marketplaces/ contains subdirs
+            // like confluent/, claude-hud/, each with their own marketplace.json).
+            let foundChild = false;
+            try {
+                const entries = readdirSync(root, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    if (SKIP_DIRS.has(entry.name))
+                        continue;
+                    const childPath = join(root, entry.name);
+                    if (isMarketplacePath(childPath) && !seen.has(childPath)) {
+                        marketplaces.push(childPath);
+                        seen.add(childPath);
+                        foundChild = true;
+                    }
+                }
+            }
+            catch {
+                // Can't read directory — fall through to flat
+            }
+            if (!foundChild) {
+                flat.push(root);
+            }
         }
     }
     return { marketplaces, flat };
@@ -145,20 +179,37 @@ export function discoverClaudePlugins(cwd) {
     const seen = new Set();
     for (const root of pluginRoots) {
         walkDirs(root, (dir) => {
+            // Recognize both npm-style plugins (package.json) and Claude Code plugins
+            // (.claude-plugin/plugin.json). Claude marketplace-installed plugins use
+            // the latter format exclusively.
             const pkgPath = join(dir, "package.json");
-            if (!existsSync(pkgPath))
+            const claudePluginPath = join(dir, ".claude-plugin", "plugin.json");
+            const hasPkg = existsSync(pkgPath);
+            const hasClaudePlugin = existsSync(claudePluginPath);
+            if (!hasPkg && !hasClaudePlugin)
                 return;
             const resolvedDir = resolve(dir);
             if (seen.has(resolvedDir))
                 return;
             seen.add(resolvedDir);
             let packageName;
-            try {
-                const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-                packageName = pkg.name;
+            if (hasPkg) {
+                try {
+                    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+                    packageName = pkg.name;
+                }
+                catch {
+                    packageName = undefined;
+                }
             }
-            catch {
-                packageName = undefined;
+            else if (hasClaudePlugin) {
+                try {
+                    const manifest = JSON.parse(readFileSync(claudePluginPath, "utf8"));
+                    packageName = manifest.name;
+                }
+                catch {
+                    packageName = undefined;
+                }
             }
             results.push({
                 type: "plugin",

package/dist/resources/extensions/gsd/commands/handlers/auto.js

@@ -4,6 +4,7 @@ import { enableDebug } from "../../debug-logger.js";
 import { isAutoActive, isAutoPaused, pauseAuto, startAuto, stopAuto, stopAutoRemote } from "../../auto.js";
 import { handleRate } from "../../commands-rate.js";
 import { guardRemoteSession, projectRoot } from "../context.js";
+import { findMilestoneIds } from "../../milestone-id-utils.js";
 /**
  * Parse --yolo flag and optional file path from the auto command string.
  * Supports: `/gsd auto --yolo path/to/file.md` or `/gsd auto -y path/to/file.md`
@@ -22,6 +23,40 @@ function parseYoloFlag(trimmed) {
     const rest = trimmed.replace(match[0], "").replace(/\s+/g, " ").trim();
     return { yoloSeedFile: filePath, rest };
 }
+/**
+ * Extract a milestone ID (e.g. M016 or M001-a3b4c5) from the command string.
+ * Returns the matched ID and the remaining string with the ID removed.
+ * The milestone ID pattern matches the format used by findMilestoneIds: M\d+ with
+ * an optional -[a-z0-9]{6} suffix for unique milestone IDs.
+ */
+export function parseMilestoneTarget(input) {
+    const match = input.match(/\b(M\d+(?:-[a-z0-9]{6})?)\b/);
+    if (!match)
+        return { milestoneId: null, rest: input };
+    const rest = input.replace(match[0], "").replace(/\s+/g, " ").trim();
+    return { milestoneId: match[1], rest };
+}
+/**
+ * Set GSD_MILESTONE_LOCK to target a specific milestone, then run `fn`.
+ * Clears the env var when `fn` resolves or rejects, so the lock does not
+ * leak into subsequent commands in the same process.
+ */
+async function withMilestoneLock(milestoneId, fn) {
+    const previous = process.env.GSD_MILESTONE_LOCK;
+    process.env.GSD_MILESTONE_LOCK = milestoneId;
+    try {
+        await fn();
+    }
+    finally {
+        // Restore previous value (undefined → delete, else restore).
+        if (previous === undefined) {
+            delete process.env.GSD_MILESTONE_LOCK;
+        }
+        else {
+            process.env.GSD_MILESTONE_LOCK = previous;
+        }
+    }
+}
 export async function handleAutoCommand(trimmed, ctx, pi) {
     if (trimmed === "next" || trimmed.startsWith("next ")) {
         if (trimmed.includes("--dry-run")) {
@@ -29,23 +64,46 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
             await handleDryRun(ctx, projectRoot());
             return true;
         }
-        const verboseMode = trimmed.includes("--verbose");
-        const debugMode = trimmed.includes("--debug");
+        const { milestoneId, rest: afterMilestone } = parseMilestoneTarget(trimmed);
+        const verboseMode = afterMilestone.includes("--verbose");
+        const debugMode = afterMilestone.includes("--debug");
         if (debugMode)
             enableDebug(projectRoot());
         if (!(await guardRemoteSession(ctx, pi)))
             return true;
-        await startAuto(ctx, pi, projectRoot(), verboseMode, { step: true });
+        // Validate the milestone target exists and is not already complete.
+        if (milestoneId) {
+            const allIds = findMilestoneIds(projectRoot());
+            if (!allIds.includes(milestoneId)) {
+                ctx.ui.notify(`Milestone ${milestoneId} does not exist. Available: ${allIds.join(", ") || "(none)"}`, "error");
+                return true;
+            }
+        }
+        if (milestoneId) {
+            await withMilestoneLock(milestoneId, () => startAuto(ctx, pi, projectRoot(), verboseMode, { step: true }));
+        }
+        else {
+            await startAuto(ctx, pi, projectRoot(), verboseMode, { step: true });
+        }
         return true;
     }
     if (trimmed === "auto" || trimmed.startsWith("auto ")) {
-        const { yoloSeedFile, rest } = parseYoloFlag(trimmed);
-        const verboseMode = rest.includes("--verbose");
-        const debugMode = rest.includes("--debug");
+        const { yoloSeedFile, rest: afterYolo } = parseYoloFlag(trimmed);
+        const { milestoneId, rest: afterMilestone } = parseMilestoneTarget(afterYolo);
+        const verboseMode = afterMilestone.includes("--verbose");
+        const debugMode = afterMilestone.includes("--debug");
         if (debugMode)
             enableDebug(projectRoot());
         if (!(await guardRemoteSession(ctx, pi)))
             return true;
+        // Validate the milestone target exists and is not already complete.
+        if (milestoneId) {
+            const allIds = findMilestoneIds(projectRoot());
+            if (!allIds.includes(milestoneId)) {
+                ctx.ui.notify(`Milestone ${milestoneId} does not exist. Available: ${allIds.join(", ") || "(none)"}`, "error");
+                return true;
+            }
+        }
         if (yoloSeedFile) {
             const resolved = resolve(projectRoot(), yoloSeedFile);
             if (!existsSync(resolved)) {
@@ -63,6 +121,11 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
             const { showHeadlessMilestoneCreation } = await import("../../guided-flow.js");
             await showHeadlessMilestoneCreation(ctx, pi, projectRoot(), seedContent);
         }
+        else if (milestoneId) {
+            // Target a specific milestone — use GSD_MILESTONE_LOCK so state
+            // derivation only sees this milestone (#2521).
+            await withMilestoneLock(milestoneId, () => startAuto(ctx, pi, projectRoot(), verboseMode));
+        }
         else {
             await startAuto(ctx, pi, projectRoot(), verboseMode);
         }

package/dist/resources/extensions/gsd/commands-config.js

@@ -18,6 +18,11 @@ export const TOOL_KEYS = [
     { id: "jina", env: "JINA_API_KEY", label: "Jina Page Extract", hint: "jina.ai/api" },
     { id: "groq", env: "GROQ_API_KEY", label: "Groq Voice", hint: "console.groq.com" },
 ];
+function getStoredToolKey(auth, providerId) {
+    const creds = auth.getCredentialsForProvider(providerId);
+    const cred = creds.find((c) => c.type === "api_key" && c.key);
+    return cred?.type === "api_key" ? cred.key : undefined;
+}
 /**
  * Load tool API keys from auth.json into environment variables.
  * Called at session startup to ensure tools have access to their credentials.
@@ -29,9 +34,9 @@ export function loadToolApiKeys() {
             return;
         const auth = AuthStorage.create(authPath);
         for (const tool of TOOL_KEYS) {
-            const cred = auth.get(tool.id);
-            if (cred && cred.type === "api_key" && cred.key && !process.env[tool.env]) {
-                process.env[tool.env] = cred.key;
+            const key = getStoredToolKey(auth, tool.id);
+            if (key && !process.env[tool.env]) {
+                process.env[tool.env] = key;
             }
         }
     }
@@ -49,13 +54,13 @@ export async function handleConfig(ctx) {
     // Show current status
     const statusLines = ["GSD Tool Configuration\n"];
     for (const tool of TOOL_KEYS) {
-        const hasKey = !!process.env[tool.env] || !!auth.get(tool.id)?.key;
+        const hasKey = !!process.env[tool.env] || !!getStoredToolKey(auth, tool.id);
         statusLines.push(`  ${hasKey ? "\u2713" : "\u2717"} ${tool.label}${hasKey ? "" : ` \u2014 get key at ${tool.hint}`}`);
     }
     ctx.ui.notify(statusLines.join("\n"), "info");
     // Ask which tools to configure
     const options = TOOL_KEYS.map(t => {
-        const hasKey = !!process.env[t.env] || !!auth.get(t.id)?.key;
+        const hasKey = !!process.env[t.env] || !!getStoredToolKey(auth, t.id);
         return `${t.label} ${hasKey ? "(configured \u2713)" : "(not set)"}`;
     });
     options.push("(done)");

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -650,7 +650,7 @@ export function serializePreferencesToFrontmatter(prefs) {
 }
 export async function ensurePreferencesFile(path, ctx, scope) {
     if (!existsSync(path)) {
-        const template = await loadFile(join(dirname(fileURLToPath(import.meta.url)), "templates", "preferences.md"));
+        const template = await loadFile(join(dirname(fileURLToPath(import.meta.url)), "templates", "PREFERENCES.md"));
         if (!template) {
             ctx.ui.notify("Could not load GSD preferences template.", "error");
             return;

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -63,14 +63,18 @@ export function readCrashLock(basePath) {
 /**
  * Check whether the process that wrote the lock is still running.
  * Uses `process.kill(pid, 0)` which sends no signal but checks liveness.
- * Returns false if the PID matches our own (recycled PID from a prior run).
+ * Returns true if the PID matches our own — we are the lock holder (#2470).
  */
 export function isLockProcessAlive(lock) {
     const pid = lock.pid;
     if (!Number.isInteger(pid) || pid <= 0)
         return false;
+    // Our own PID means WE hold this lock — we are alive. (#2470)
+    // Callers that need to distinguish "our lock" from "someone else's lock"
+    // (e.g. startAuto checking for a prior crashed session with a recycled PID)
+    // already guard with `crashLock.pid !== process.pid` before calling us.
     if (pid === process.pid)
-        return false;
+        return true;
     try {
         process.kill(pid, 0);
         return true;

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

@@ -11,6 +11,7 @@
  * - recover() returns retry — simple default recovery strategy.
  */
 import { runCustomVerification } from "./custom-verification.js";
+import { parseUnitId } from "./unit-id.js";
 export class CustomExecutionPolicy {
     runDir;
     constructor(runDir) {
@@ -32,8 +33,8 @@ export class CustomExecutionPolicy {
      * to determine which policy to apply.
      */
     async verify(_unitType, unitId, _context) {
-        const parts = unitId.split("/");
-        const stepId = parts[parts.length - 1];
+        const { milestone, slice, task } = parseUnitId(unitId);
+        const stepId = task ?? slice ?? milestone;
         return runCustomVerification(this.runDir, stepId);
     }
     /** Default recovery: retry the step. */

package/dist/resources/extensions/gsd/custom-verification.js

@@ -20,6 +20,7 @@ import { readFileSync, existsSync, statSync } from "node:fs";
 import { resolve, sep } from "node:path";
 import { spawnSync } from "node:child_process";
 import { readFrozenDefinition } from "./custom-workflow-engine.js";
+import { rewriteCommandWithRtk } from "../shared/rtk.js";
 /**
  * Run custom verification for a specific step in a workflow run.
  *
@@ -131,7 +132,8 @@ function handleShellCommand(runDir, verify) {
         console.warn(`custom-verification: shell-command contains suspicious pattern, skipping: ${verify.command}`);
         return "pause";
     }
-    const result = spawnSync("sh", ["-c", verify.command], {
+    const rewrittenCommand = rewriteCommandWithRtk(verify.command);
+    const result = spawnSync("sh", ["-c", rewrittenCommand], {
         cwd: runDir,
         timeout: 30_000,
         encoding: "utf-8",

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

@@ -16,6 +16,7 @@ import { join } from "node:path";
 import { parse } from "yaml";
 import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
+import { parseUnitId } from "./unit-id.js";
 /** Read and parse the frozen DEFINITION.yaml from a run directory. */
 export function readFrozenDefinition(runDir) {
     const defPath = join(runDir, "DEFINITION.yaml");
@@ -136,8 +137,8 @@ export class CustomWorkflowEngine {
     async reconcile(state, completedStep) {
         const graph = state.raw;
         // Extract stepId from "<workflowName>/<stepId>"
-        const parts = completedStep.unitId.split("/");
-        const stepId = parts[parts.length - 1];
+        const { milestone, slice, task } = parseUnitId(completedStep.unitId);
+        const stepId = task ?? slice ?? milestone;
         const updatedGraph = markStepComplete(graph, stepId);
         writeGraph(this.runDir, updatedGraph);
         const allDone = updatedGraph.steps.every((s) => s.status === "complete" || s.status === "expanded");

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -482,6 +482,10 @@ export class GSDDashboardOverlay {
             if (cacheRate > 0) {
                 lines.push(row(`${th.fg("dim", "cache hit rate:")} ${th.fg("text", `${cacheRate}%`)}`));
             }
+            if (this.dashData.rtkEnabled && this.dashData.rtkSavings && this.dashData.rtkSavings.commands > 0) {
+                const rtk = this.dashData.rtkSavings;
+                lines.push(row(`${th.fg("dim", "rtk saved:")} ${th.fg("text", formatTokenCount(rtk.savedTokens))} ${th.fg("dim", `(${Math.round(rtk.savingsPct)}% · ${rtk.commands} cmd${rtk.commands === 1 ? "" : "s"})`)}`));
+            }
         }
         // Environment health section (#1221) — only show issues
         const envResults = runEnvironmentChecks(this.dashData.basePath || process.cwd());