gsd-pi 2.50.0 → 2.51.0-dev.859cedb

package/dist/resource-loader.js

@@ -1,7 +1,7 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
-import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
+import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, openSync, closeSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
@@ -352,9 +352,12 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
  *
  * - extensions/ → ~/.gsd/agent/extensions/   (overwrite when version changes)
  * - agents/     → ~/.gsd/agent/agents/        (overwrite when version changes)
- * - skills/     → ~/.gsd/agent/skills/        (overwrite when version changes)
  * - GSD-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
  *
+ * Skills are NOT synced here. They are installed by the user via the
+ * skills.sh CLI (`npx skills add <repo>`) into ~/.agents/skills/ — the
+ * industry-standard Agent Skills ecosystem directory.
+ *
  * Skips the copy when the managed-resources.json version matches the current
  * GSD version, avoiding ~128ms of synchronous cpSync on every startup.
  * After `npm update -g @glittercowboy/gsd`, versions will differ and the
@@ -375,6 +378,9 @@ export function initResources(agentDir) {
     // launch, not just during resource syncs. A stale/broken symlink makes ALL
     // extensions fail to resolve @gsd/* packages, rendering GSD non-functional.
     ensureNodeModulesSymlink(agentDir);
+    // Migrate legacy skills on every launch (not gated by manifest) so that
+    // partial-failure retries don't wait for a version bump.
+    migrateSkillsToEcosystemDir(agentDir);
     // Skip the full copy when both version AND content fingerprint match.
     // Version-only checks miss same-version content changes (npm link dev workflow,
     // hotfixes within a release). The content hash catches those at ~1ms cost.
@@ -389,7 +395,13 @@ export function initResources(agentDir) {
     // Sync bundled resources — overwrite so updates land on next launch.
     syncResourceDir(bundledExtensionsDir, join(agentDir, 'extensions'));
     syncResourceDir(join(resourcesDir, 'agents'), join(agentDir, 'agents'));
-    syncResourceDir(join(resourcesDir, 'skills'), join(agentDir, 'skills'));
+    // Skills are no longer force-synced here. Users install skills via the
+    // skills.sh CLI (`npx skills add <repo>`) into ~/.agents/skills/ which
+    // is the industry-standard Agent Skills ecosystem directory.
+    //
+    // Migration from the legacy ~/.gsd/agent/skills/ directory is handled
+    // above the manifest check so it runs on every launch (including retries
+    // after partial copy failures).
     // Sync GSD-WORKFLOW.md to agentDir as a fallback for when GSD_WORKFLOW_PATH
     // env var is not set (e.g. fork/dev builds, alternative entry points).
     const workflowSrc = join(resourcesDir, 'GSD-WORKFLOW.md');
@@ -405,6 +417,129 @@ export function initResources(agentDir) {
     writeManagedResourceManifest(agentDir);
     ensureRegistryEntries(join(agentDir, 'extensions'));
 }
+// ─── Legacy Skill Migration ──────────────────────────────────────────────────────
+/**
+ * One-time migration: copy user-customized skills from the old
+ * ~/.gsd/agent/skills/ directory into ~/.agents/skills/.
+ *
+ * The migration is conservative:
+ *  - Only skill directories containing a SKILL.md are considered.
+ *  - Copies, does not move — the old directory stays intact so downgrading
+ *    to a pre-migration GSD version still works.
+ *  - Collision-safe — if a skill name already exists in the target, the
+ *    existing ecosystem skill wins (user may have already installed a newer
+ *    version via skills.sh).
+ *  - Writes a `.migrated-to-agents` marker inside the legacy directory so
+ *    the migration runs at most once.
+ */
+function migrateSkillsToEcosystemDir(agentDir) {
+    const legacyDir = join(agentDir, 'skills');
+    const markerPath = join(legacyDir, '.migrated-to-agents');
+    // Already migrated or no legacy dir — nothing to do
+    if (!existsSync(legacyDir))
+        return;
+    // Atomic marker check — 'wx' fails if file already exists, preventing races
+    // when two GSD processes start simultaneously.
+    let markerFd;
+    try {
+        markerFd = openSync(markerPath, 'wx');
+    }
+    catch {
+        return; // marker already exists (another process won the race, or already migrated)
+    }
+    try {
+        const ecosystemDir = join(homedir(), '.agents', 'skills');
+        mkdirSync(ecosystemDir, { recursive: true });
+        const entries = readdirSync(legacyDir, { withFileTypes: true });
+        let migrated = 0;
+        let candidates = 0;
+        for (const entry of entries) {
+            // Handle both real directories and symlinks pointing to directories
+            const isDir = entry.isDirectory();
+            const isSymlink = entry.isSymbolicLink();
+            if (!isDir && !isSymlink)
+                continue;
+            const sourcePath = join(legacyDir, entry.name);
+            // For symlinks, verify the target is a directory
+            if (isSymlink) {
+                try {
+                    const stat = statSync(sourcePath);
+                    if (!stat.isDirectory())
+                        continue;
+                }
+                catch {
+                    continue; // broken symlink — skip
+                }
+            }
+            const skillMd = join(sourcePath, 'SKILL.md');
+            if (!existsSync(skillMd))
+                continue;
+            const target = join(ecosystemDir, entry.name);
+            if (existsSync(target))
+                continue; // ecosystem version wins
+            candidates++;
+            try {
+                if (isSymlink) {
+                    // Recreate the symlink in the ecosystem directory using an absolute
+                    // target. Relative symlinks would resolve from the new parent dir
+                    // (~/.agents/skills/) instead of the original (~/.gsd/agent/skills/),
+                    // pointing to the wrong location.
+                    const rawTarget = readlinkSync(sourcePath);
+                    const absTarget = resolve(dirname(sourcePath), rawTarget);
+                    symlinkSync(absTarget, target);
+                }
+                else {
+                    cpSync(sourcePath, target, { recursive: true });
+                }
+                migrated++;
+            }
+            catch {
+                // non-fatal — skip this skill
+            }
+        }
+        // If any skills failed to copy, remove the marker so migration retries
+        // on the next launch.  This keeps the legacy dir as fallback until every
+        // skill has been successfully migrated.
+        if (migrated < candidates) {
+            try {
+                closeSync(markerFd);
+                markerFd = -1;
+            }
+            catch { /* non-fatal */ }
+            try {
+                unlinkSync(markerPath);
+            }
+            catch { /* non-fatal */ }
+            return;
+        }
+        // Write migration info to the marker
+        try {
+            writeFileSync(markerFd, `Migrated ${migrated} skill(s) to ${ecosystemDir} on ${new Date().toISOString()}\n`);
+        }
+        catch { /* non-fatal */ }
+    }
+    catch {
+        // can't create ecosystem dir or read legacy dir — close fd first (required on Windows
+        // where unlinkSync fails on open handles), then remove marker so we retry next launch
+        try {
+            closeSync(markerFd);
+            markerFd = -1;
+        }
+        catch { /* non-fatal */ }
+        try {
+            unlinkSync(markerPath);
+        }
+        catch { /* non-fatal */ }
+    }
+    finally {
+        if (markerFd !== -1) {
+            try {
+                closeSync(markerFd);
+            }
+            catch { /* non-fatal */ }
+        }
+    }
+}
 export function hasStaleCompiledExtensionSiblings(extensionsDir) {
     if (!existsSync(extensionsDir))
         return false;

package/dist/resources/extensions/async-jobs/async-bash-tool.js

@@ -7,11 +7,12 @@
  */
 import { getShellConfig, sanitizeCommand, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, } from "@gsd/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { createWriteStream } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { randomBytes } from "node:crypto";
+import { rewriteCommandWithRtk } from "../shared/rtk.js";
 const schema = Type.Object({
     command: Type.String({ description: "Bash command to execute in the background" }),
     timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional)" })),
@@ -22,19 +23,33 @@ function getTempFilePath() {
     return join(tmpdir(), `pi-async-bash-${id}.log`);
 }
 /**
- * Kill a process and its children. Uses process group kill on Unix.
+ * Kill a process and its children (cross-platform).
+ * Uses process group kill on Unix; taskkill /F /T on Windows.
  */
 function killTree(pid) {
-    try {
-        // Kill the process group (negative PID)
-        process.kill(-pid, "SIGTERM");
+    if (process.platform === "win32") {
+        try {
+            spawnSync("taskkill", ["/F", "/T", "/PID", String(pid)], {
+                timeout: 5_000,
+                stdio: "ignore",
+            });
+        }
+        catch {
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch { /* already exited */ }
+        }
     }
-    catch {
+    else {
         try {
-            process.kill(pid, "SIGTERM");
+            process.kill(-pid, "SIGTERM");
         }
         catch {
-            // Already exited
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch { /* already exited */ }
         }
     }
 }
@@ -93,10 +108,15 @@ function executeBashInBackground(command, cwd, signal, timeout) {
             reject(err);
         } };
         const { shell, args } = getShellConfig();
-        const resolvedCommand = sanitizeCommand(command);
+        const rewrittenCommand = rewriteCommandWithRtk(command);
+        const resolvedCommand = sanitizeCommand(rewrittenCommand);
+        // On Windows, detached: true sets CREATE_NEW_PROCESS_GROUP which can
+        // cause EINVAL in VSCode/ConPTY terminal contexts.  The bg-shell
+        // extension already guards this (process-manager.ts); align here.
+        // Process-tree cleanup uses taskkill /F /T on Windows regardless.
         const child = spawn(shell, [...args, resolvedCommand], {
             cwd,
-            detached: true,
+            detached: process.platform !== "win32",
             env: { ...process.env },
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -116,14 +136,8 @@ function executeBashInBackground(command, cwd, signal, timeout) {
                 // If the process ignores SIGTERM, escalate to SIGKILL
                 sigkillHandle = setTimeout(() => {
                     if (child.pid) {
-                        try {
-                            process.kill(-child.pid, "SIGKILL");
-                        }
-                        catch { /* ignore */ }
-                        try {
-                            process.kill(child.pid, "SIGKILL");
-                        }
-                        catch { /* ignore */ }
+                        // killTree already uses taskkill /F /T on Windows
+                        killTree(child.pid);
                     }
                     // Hard deadline: if even SIGKILL doesn't trigger 'close',
                     // force-resolve so the job doesn't hang forever (#2186).

package/dist/resources/extensions/async-jobs/job-manager.js

@@ -121,7 +121,10 @@ export class AsyncJobManager {
     deliverResult(job) {
         if (!this.onJobComplete)
             return;
-        this.onJobComplete(job);
+        // Defer delivery by one microtask so await_job's .then() chain runs first
+        // and can set job.awaited = true before onJobComplete checks it (#2762).
+        const cb = this.onJobComplete;
+        queueMicrotask(() => cb(job));
     }
     scheduleEviction(id) {
         const existing = this.evictionTimers.get(id);

package/dist/resources/extensions/bg-shell/interaction.js

@@ -2,6 +2,7 @@
  * Expect-style interactions: send_and_wait, run on session, query shell environment.
  */
 import { randomUUID } from "node:crypto";
+import { rewriteCommandWithRtk } from "../shared/rtk.js";
 // ── Query Shell Environment ────────────────────────────────────────────────
 export async function queryShellEnv(bg, timeout, signal) {
     const sentinel = `__GSD_ENV_${randomUUID().slice(0, 8)}__`;
@@ -97,9 +98,10 @@ export async function runOnSession(bg, command, timeout, signal) {
     // Snapshot current output buffer position
     const startIndex = bg.output.length;
     // Write the sentinel-wrapped command to stdin
+    const rewrittenCommand = rewriteCommandWithRtk(command);
     const wrappedCommand = [
         `echo ${startMarker}`,
-        command,
+        rewrittenCommand,
         `${exitVar}=$?`,
         `echo ${endMarker} $${exitVar}`,
     ].join("\n");

package/dist/resources/extensions/bg-shell/process-manager.js

@@ -7,6 +7,7 @@ import { randomUUID } from "node:crypto";
 import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { getShellConfig, sanitizeCommand } from "@gsd/pi-coding-agent";
+import { rewriteCommandWithRtk } from "../shared/rtk.js";
 import { MAX_BUFFER_LINES, MAX_EVENTS, DEAD_PROCESS_TTL, } from "./types.js";
 import { restoreWindowsVTInput, formatUptime } from "./utilities.js";
 import { analyzeLine } from "./output-formatter.js";
@@ -101,7 +102,9 @@ export function startProcess(opts) {
     const env = { ...process.env, ...(opts.env || {}) };
     const { shell, args: shellArgs } = getShellConfig();
     // Shell sessions default to the user's shell if no command specified
-    const command = processType === "shell" && !opts.command ? shell : opts.command;
+    const command = processType === "shell" && !opts.command
+        ? shell
+        : rewriteCommandWithRtk(opts.command);
     const proc = spawn(shell, [...shellArgs, sanitizeCommand(command)], {
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "pipe"],

package/dist/resources/extensions/claude-code-cli/partial-builder.js

@@ -210,7 +210,12 @@ export class PartialMessageBuilder {
                         block.arguments = JSON.parse(jsonStr);
                     }
                     catch {
+                        // Stream was truncated mid-tool-call — JSON is garbage.
+                        // Preserve the raw string for diagnostics but signal the
+                        // malformation explicitly so downstream consumers can
+                        // distinguish this from a healthy tool completion (#2574).
                         block.arguments = { _raw: jsonStr };
+                        return { type: "toolcall_end", contentIndex, toolCall: block, partial: this.partial, malformedArguments: true };
                     }
                     return { type: "toolcall_end", contentIndex, toolCall: block, partial: this.partial };
                 }

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -88,6 +88,19 @@ function makeErrorMessage(model, errorMsg) {
         timestamp: Date.now(),
     };
 }
+/**
+ * Generator exhaustion without a terminal result means the SDK stream was
+ * interrupted mid-turn. Surface it as an error so downstream recovery logic
+ * can classify and retry it instead of treating it as a clean completion.
+ */
+export function makeStreamExhaustedErrorMessage(model, lastTextContent) {
+    const errorMsg = "stream_exhausted_without_result";
+    const message = makeErrorMessage(model, errorMsg);
+    if (lastTextContent) {
+        message.content = [{ type: "text", text: lastTextContent }];
+    }
+    return message;
+}
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------
@@ -278,25 +291,11 @@ async function pumpSdkMessages(model, context, options, stream) {
                     break;
             }
         }
-        // Generator exhausted without a result message (unexpected)
-        const fallbackContent = [];
-        if (lastTextContent) {
-            fallbackContent.push({ type: "text", text: lastTextContent });
-        }
-        if (fallbackContent.length === 0) {
-            fallbackContent.push({ type: "text", text: "(Claude Code session ended without a response)" });
-        }
-        const fallback = {
-            role: "assistant",
-            content: fallbackContent,
-            api: "anthropic-messages",
-            provider: "claude-code",
-            model: modelId,
-            usage: { ...ZERO_USAGE },
-            stopReason: "stop",
-            timestamp: Date.now(),
-        };
-        stream.push({ type: "done", reason: "stop", message: fallback });
+        // Generator exhaustion without a terminal result is a stream interruption,
+        // not a successful completion. Emitting an error lets GSD classify it as a
+        // transient provider failure instead of advancing auto-mode state.
+        const fallback = makeStreamExhaustedErrorMessage(modelId, lastTextContent);
+        stream.push({ type: "error", reason: "error", error: fallback });
     }
     catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);

package/dist/resources/extensions/gsd/auto/phases.js

@@ -219,6 +219,8 @@ export async function runPreDispatch(ic, loopState) {
             if (s.currentMilestoneId) {
                 try {
                     deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+                    // Prevent stopAuto from attempting the same merge (#2645)
+                    s.milestoneMergedInPhases = true;
                 }
                 catch (mergeErr) {
                     if (mergeErr instanceof MergeConflictError) {
@@ -284,6 +286,8 @@ export async function runPreDispatch(ic, loopState) {
         if (s.currentMilestoneId) {
             try {
                 deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
+                // Prevent stopAuto from attempting the same merge (#2645)
+                s.milestoneMergedInPhases = true;
             }
             catch (mergeErr) {
                 if (mergeErr instanceof MergeConflictError) {
@@ -334,7 +338,18 @@ export async function runDispatch(ic, preData, loopState) {
     });
     if (dispatchResult.action === "stop") {
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-stop", rule: dispatchResult.matchedRule, data: { reason: dispatchResult.reason } });
-        await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
+        // Warning-level stops are recoverable human checkpoints (e.g. UAT verdict
+        // gate) — pause instead of hard-stopping so the session is resumable with
+        // `/gsd auto`. Error/info-level stops remain hard stops for infrastructure
+        // failures and terminal conditions respectively.
+        // See: https://github.com/gsd-build/gsd-2/issues/2474
+        if (dispatchResult.level === "warning") {
+            ctx.ui.notify(dispatchResult.reason, "warning");
+            await deps.pauseAuto(ctx, pi);
+        }
+        else {
+            await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
+        }
         debugLog("autoLoop", { phase: "exit", reason: "dispatch-stop" });
         return { action: "break", reason: "dispatch-stop" };
     }
@@ -738,6 +753,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
     }
     if (unitResult.status === "cancelled") {
+        // Provider-error pause: pauseAuto already handled cleanup and scheduled
+        // recovery. Don't hard-stop — just break out of the loop (#2762).
+        if (unitResult.errorContext?.category === "provider") {
+            debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
+            return { action: "break", reason: "provider-pause" };
+        }
         ctx.ui.notify(`Session creation timed out or was cancelled for ${unitType} ${unitId}. Will retry.`, "warning");
         await deps.stopAuto(ctx, pi, "Session creation failed");
         debugLog("autoLoop", { phase: "exit", reason: "session-failed" });

package/dist/resources/extensions/gsd/auto/session.js

@@ -64,6 +64,10 @@ export class AutoSession {
     // ── Isolation degradation ────────────────────────────────────────────
     /** Set to true when worktree creation fails; prevents merge of nonexistent branch. */
     isolationDegraded = false;
+    // ── Merge guard ──────────────────────────────────────────────────────
+    /** Set to true after phases.ts successfully calls mergeAndExit, so that
+     *  stopAuto does not attempt the same merge a second time (#2645). */
+    milestoneMergedInPhases = false;
     // ── Dispatch circuit breakers ──────────────────────────────────────
     rewriteAttemptCount = 0;
     // ── Metrics ──────────────────────────────────────────────────────────────
@@ -144,6 +148,7 @@ export class AutoSession {
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
         this.isolationDegraded = false;
+        this.milestoneMergedInPhases = false;
         // Signal handler
         this.sigtermHandler = null;
         // Loop promise state lives in auto-loop.ts module scope

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

@@ -19,6 +19,7 @@ import { getActiveWorktreeName } from "./worktree-command.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 import { parseUnitId } from "./unit-id.js";
+import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -383,6 +384,18 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         let pulseBright = true;
         let cachedLines;
         let cachedWidth;
+        let cachedRtkLabel;
+        const refreshRtkLabel = () => {
+            try {
+                const sessionId = ctx.sessionManager.getSessionId();
+                const savings = sessionId ? getRtkSessionSavings(accessors.getBasePath(), sessionId) : null;
+                cachedRtkLabel = formatRtkSavingsLabel(savings);
+            }
+            catch {
+                cachedRtkLabel = null;
+            }
+        };
+        refreshRtkLabel();
         const pulseTimer = setInterval(() => {
             pulseBright = !pulseBright;
             cachedLines = undefined;
@@ -392,13 +405,16 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         // task/slice completion mid-unit. Without this, the progress bar only
         // updates at dispatch time, appearing frozen during long-running units.
         // 15s (vs 5s) reduces synchronous file I/O on the hot path.
-        const progressRefreshTimer = mid ? setInterval(() => {
+        const progressRefreshTimer = setInterval(() => {
             try {
-                updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+                if (mid) {
+                    updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+                }
+                refreshRtkLabel();
                 cachedLines = undefined;
             }
             catch { /* non-fatal */ }
-        }, 15_000) : null;
+        }, 15_000);
         return {
             render(width) {
                 if (cachedLines && cachedWidth === width)
@@ -659,6 +675,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     if (statsLine) {
                         lines.push(rightAlign("", statsLine, width));
                     }
+                    if (cachedRtkLabel) {
+                        lines.push(rightAlign("", theme.fg("dim", cachedRtkLabel), width));
+                    }
                 }
                 // PWD line with last commit info right-aligned
                 const lastCommit = getLastCommit(accessors.getBasePath());