gsd-pi 2.50.0 → 2.51.0-dev.ae8f7cb

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

@@ -10,6 +10,7 @@
  * telling the LLM which files to read and what to do.
  */
 import { deriveState } from "./state.js";
+import { parseUnitId } from "./unit-id.js";
 import { getManifestStatus } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -31,6 +32,7 @@ import { runGSDDoctor, rebuildState } from "./doctor.js";
 import { preDispatchHealthGate, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
 import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
+import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
@@ -122,6 +124,11 @@ function deregisterSigtermHandler() {
 export function getAutoDashboardData() {
     const ledger = getLedger();
     const totals = ledger ? getProjectTotals(ledger.units) : null;
+    const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ?? null;
+    const rtkSavings = sessionId && s.basePath
+        ? getRtkSessionSavings(s.basePath, sessionId)
+        : null;
+    const rtkEnabled = loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true;
     // Pending capture count — lazy check, non-fatal
     let pendingCaptureCount = 0;
     try {
@@ -145,6 +152,8 @@ export function getAutoDashboardData() {
         totalCost: totals?.cost ?? 0,
         totalTokens: totals?.tokens.total ?? 0,
         pendingCaptureCount,
+        rtkSavings,
+        rtkEnabled,
     };
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
@@ -361,8 +370,11 @@ export async function stopAuto(ctx, pi, reason) {
         // When the milestone is complete (has a SUMMARY), merge the worktree branch
         // back to main so code isn't stranded on the worktree branch (#2317).
         // For incomplete milestones, preserve the branch for later resumption.
+        //
+        // Skip if phases.ts already merged this milestone — avoids the double
+        // mergeAndExit that fails because the branch was already deleted (#2645).
         try {
-            if (s.currentMilestoneId) {
+            if (s.currentMilestoneId && !s.milestoneMergedInPhases) {
                 const notifyCtx = ctx
                     ? { notify: ctx.ui.notify.bind(ctx.ui) }
                     : { notify: () => { } };
@@ -927,15 +939,13 @@ const widgetStateAccessors = {
  * dispatching a unit. The LLM should never need to mkdir or git checkout.
  */
 function ensurePreconditions(unitType, unitId, base, state) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
+    const { milestone: mid, slice: sid } = parseUnitId(unitId);
     const mDir = resolveMilestonePath(base, mid);
     if (!mDir) {
         const newDir = join(milestonesDir(base), mid);
         mkdirSync(join(newDir, "slices"), { recursive: true });
     }
-    if (parts.length >= 2) {
-        const sid = parts[1];
+    if (sid !== undefined) {
         const mDirResolved = resolveMilestonePath(base, mid);
         if (mDirResolved) {
             const slicesDir = join(mDirResolved, "slices");

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -13,6 +13,8 @@ import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markTool
 import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
+import { startRtkStatusUpdates, stopRtkStatusUpdates } from "../rtk-status.js";
+import { rewriteCommandWithRtk } from "../../shared/rtk.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
@@ -21,10 +23,19 @@ async function syncServiceTierStatus(ctx) {
     ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
 }
 export function registerHooks(pi) {
+    // Route all agent bash tool commands through RTK rewrite when opted in.
+    // This is a no-op when RTK is disabled or not installed.
+    pi.on("bash_transform", async (event) => {
+        const rewritten = rewriteCommandWithRtk(event.command);
+        if (rewritten === event.command)
+            return undefined;
+        return { command: rewritten };
+    });
     pi.on("session_start", async (_event, ctx) => {
         resetWriteGateState();
         resetToolCallLoopGuard();
         await syncServiceTierStatus(ctx);
+        startRtkStatusUpdates(ctx);
         // Apply show_token_cost preference (#1515)
         try {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -69,6 +80,10 @@ export function registerHooks(pi) {
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
         loadToolApiKeys();
+        startRtkStatusUpdates(ctx);
+    });
+    pi.on("session_fork", async (_event, ctx) => {
+        startRtkStatusUpdates(ctx);
     });
     pi.on("before_agent_start", async (event, ctx) => {
         return buildBeforeAgentStartResult(event, ctx);
@@ -115,6 +130,7 @@ export function registerHooks(pi) {
         }));
     });
     pi.on("session_shutdown", async (_event, ctx) => {
+        stopRtkStatusUpdates(ctx);
         if (isParallelActive()) {
             try {
                 await shutdownParallel(process.cwd());

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());