@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.72e3af2a

package/dist/resources/extensions/gsd/prompts/code-review.md

@@ -16,18 +16,20 @@ You are running the GSD **code-review** workflow — review source files changed
 
 1. **Determine the file set.** Use the explicit `--files` list if provided. Otherwise derive the changed source files from the active slice's recent commits / SUMMARY, or fall back to the git diff against the base branch. Exclude `.gsd/`, lockfiles, generated/vendored code, and docs unless `--files` names them.
 
-2. **Review each file** at the requested depth:
+2. **Gather diff-first context.** Run `git diff` for the file set (or the relevant commit range) and use that as the primary review evidence. Use `read` only when the diff is insufficient — new/untracked files, truncated hunks, or missing surrounding context needed for a finding. Do **not** read every changed file when the diff already covers the edits. If the Tool Call Loop Guard blocks a tool, stop calling tools for the rest of this turn and continue in text.
+
+3. **Review at the requested depth:**
    - **quick** — bugs, security, and correctness only.
    - **standard** (default) — quick + maintainability, error handling, edge cases.
    - **deep** — standard + performance, concurrency, API design, test coverage gaps.
 
    Ground every finding in the actual code with file path + line reference. Categorize each by severity (critical / warning / nit) and type (bug, security, quality, performance).
 
-3. **Write the review.** Produce `.gsd/reviews/{{reviewId}}-REVIEW.md` with the findings table and per-finding detail (location, issue, suggested fix).
+4. **Write the review.** Produce `.gsd/reviews/{{reviewId}}-REVIEW.md` with the findings table and per-finding detail (location, issue, suggested fix).
 
-4. **Present results.** Summarize counts by severity and list the critical findings first.
+5. **Present results.** Summarize counts by severity and list the critical findings first.
 
-5. **Fix mode** (only when `--fix` is set): for each finding that is safely auto-fixable (deterministic, no behavior change beyond the fix), apply it. After each fix batch, run the project's tests. Commit atomically with the finding IDs referenced in the message. Do not auto-apply findings that are ambiguous or that change public behavior — surface those for a human decision instead.
+6. **Fix mode** (only when `--fix` is set): for each finding that is safely auto-fixable (deterministic, no behavior change beyond the fix), apply it. After each fix batch, run the project's tests. Commit atomically with the finding IDs referenced in the message. Do not auto-apply findings that are ambiguous or that change public behavior — surface those for a human decision instead.
 
 ## Success criteria
 

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

@@ -8,8 +8,8 @@
  * Quick tasks live in `.gsd/quick/` and are tracked in STATE.md's
  * "Quick Tasks Completed" table.
  */
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { isAbsolute, join, relative } from "node:path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { QUICK_BRANCH_RE } from "./branch-patterns.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
@@ -19,6 +19,7 @@ import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat } from ".
 import { nativeHasStagedChanges } from "./native-git-bridge.js";
 import { resolveUokFlags } from "./uok/flags.js";
 let pendingQuickReturn = null;
+const pendingQuickReturnMisses = new Map();
 // ─── Quick Task Helpers ───────────────────────────────────────────────────────
 /**
  * Generate a URL-friendly slug from a description.
@@ -169,11 +170,36 @@ export function buildQuickCommitInstruction(basePath, root) {
         "   - Quick tasks run outside the auto-mode lifecycle — there is no system auto-commit, so commit directly here.",
     ].join("\n");
 }
+function readHeadBranchName(basePath) {
+    try {
+        const gitPath = join(basePath, ".git");
+        if (!existsSync(gitPath))
+            return null;
+        let headPath;
+        if (lstatSync(gitPath).isDirectory()) {
+            headPath = join(gitPath, "HEAD");
+        }
+        else {
+            const gitFile = readFileSync(gitPath, "utf-8").trim();
+            if (!gitFile.startsWith("gitdir: "))
+                return null;
+            headPath = join(resolve(basePath, gitFile.slice("gitdir: ".length)), "HEAD");
+        }
+        const head = readFileSync(headPath, "utf-8").trim();
+        if (!head.startsWith("ref: refs/heads/"))
+            return null;
+        return head.slice("ref: refs/heads/".length);
+    }
+    catch {
+        return null;
+    }
+}
 function quickReturnStatePath(basePath) {
     return join(gsdRoot(basePath), "runtime", "quick-return.json");
 }
 function persistPendingReturn(state) {
     pendingQuickReturn = state;
+    pendingQuickReturnMisses.delete(state.basePath);
     mkdirSync(join(gsdRoot(state.basePath), "runtime"), { recursive: true });
     writeFileSync(quickReturnStatePath(state.basePath), JSON.stringify(state) + "\n", "utf-8");
 }
@@ -181,6 +207,13 @@ function readPendingReturn(basePath) {
     if (pendingQuickReturn && pendingQuickReturn.basePath === basePath) {
         return pendingQuickReturn;
     }
+    if (pendingQuickReturnMisses.has(basePath)) {
+        const statePath = quickReturnStatePath(basePath);
+        if (!existsSync(statePath) && readHeadBranchName(basePath) === pendingQuickReturnMisses.get(basePath)) {
+            return null;
+        }
+        pendingQuickReturnMisses.delete(basePath);
+    }
     try {
         const raw = readFileSync(quickReturnStatePath(basePath), "utf-8");
         const parsed = JSON.parse(raw);
@@ -191,6 +224,7 @@ function readPendingReturn(basePath) {
             && typeof parsed.slug === "string"
             && typeof parsed.description === "string") {
             pendingQuickReturn = parsed;
+            pendingQuickReturnMisses.delete(basePath);
             return pendingQuickReturn;
         }
     }
@@ -200,14 +234,23 @@ function readPendingReturn(basePath) {
     const inferred = inferQuickReturnFromBranch(basePath);
     if (inferred) {
         pendingQuickReturn = inferred;
+        pendingQuickReturnMisses.delete(basePath);
         return inferred;
     }
+    const branchAtMiss = readHeadBranchName(basePath);
+    if (branchAtMiss) {
+        pendingQuickReturnMisses.set(basePath, branchAtMiss);
+    }
     return null;
 }
 function clearPendingReturn(basePath) {
     if (pendingQuickReturn?.basePath === basePath) {
         pendingQuickReturn = null;
     }
+    const branchAtMiss = readHeadBranchName(basePath);
+    if (branchAtMiss) {
+        pendingQuickReturnMisses.set(basePath, branchAtMiss);
+    }
     rmSync(quickReturnStatePath(basePath), { force: true });
 }
 function hasStagedChanges(basePath) {

package/dist/resources/extensions/gsd/session-forensics.js

@@ -176,11 +176,21 @@ export function extractTrace(entries) {
     }
     // Flush any pending tool calls that never got results (crash mid-tool)
     for (const [, pending] of pendingTools) {
+        const missingResultError = `Tool call ${pending.name} started but no toolResult was recorded`;
         toolCalls.push({
             name: pending.name,
             input: redactInput(pending.name, pending.input),
-            isError: false,
+            result: "missing tool result (stream/tool-call abort before execution)",
+            isError: true,
         });
+        errors.push(missingResultError);
+        // Mark the matching commandsRun entry as failed so it is consistent with
+        // the isError: true on the tool call above (bash/bg_shell only).
+        if (pending.name === "bash" || pending.name === "bg_shell") {
+            const lastCmd = findLast(commandsRun, c => c.command === String(pending.input.command));
+            if (lastCmd)
+                lastCmd.failed = true;
+        }
     }
     return {
         toolCalls,

package/dist/resources/extensions/gsd/skills/gsd-headless/references/commands.md

@@ -66,7 +66,7 @@ These commands dispatch native GSD prompts adapted to the milestone, slice, and
 | `progress` | Summarize recent work; can route `--next` or `--do "..."` |
 | `health` | Check `.gsd/` integrity (`--repair`, `--context`) |
 | `surface` | Manage surfaced skills and extensions |
-| `code-review` | Review changed source for bugs, security, and quality |
+| `code-review` | Review changed source diff-first for bugs, security, and quality |
 | `review` | Peer-review recent work across reviewer perspectives |
 | `audit-milestone` | Verify a milestone met its definition of done |
 | `audit-uat` | Audit outstanding UAT/verification items |

package/dist/resources/extensions/gsd/state/derive/cache.js

@@ -0,0 +1,28 @@
+// Project/App: gsd-pi
+// File Purpose: deriveState memoization cache and telemetry.
+const CACHE_TTL_MS = 100;
+let _stateCache = null;
+let _telemetry = { dbDeriveCount: 0 };
+export function getDeriveTelemetry() {
+    return { ..._telemetry };
+}
+export function resetDeriveTelemetry() {
+    _telemetry = { dbDeriveCount: 0 };
+}
+export function incrementDbDeriveCount() {
+    _telemetry.dbDeriveCount++;
+}
+export function invalidateStateCache() {
+    _stateCache = null;
+}
+export function readCachedDeriveState(cacheKey) {
+    if (_stateCache &&
+        _stateCache.basePath === cacheKey &&
+        Date.now() - _stateCache.timestamp < CACHE_TTL_MS) {
+        return _stateCache.result;
+    }
+    return null;
+}
+export function writeCachedDeriveState(cacheKey, result) {
+    _stateCache = { basePath: cacheKey, result, timestamp: Date.now() };
+}

package/dist/resources/extensions/gsd/state/derive/db-open.js

@@ -0,0 +1,39 @@
+// Project/App: gsd-pi
+// File Purpose: Workflow DB open helpers for state derivation.
+import { getAllMilestones, isDbAvailable, setMilestoneQueueOrder } from '../../gsd-db.js';
+import { openExistingWorkflowDatabase } from '../../db-workspace.js';
+import { loadQueueOrder, sortByQueueOrder } from '../../queue-order.js';
+export function syncQueueOrderProjectionToDb(basePath) {
+    const queueOrder = loadQueueOrder(basePath);
+    if (!queueOrder)
+        return;
+    const currentIds = getAllMilestones().map((m) => m.id);
+    const desiredIds = sortByQueueOrder(currentIds, queueOrder);
+    if (currentIds.length === desiredIds.length && currentIds.every((id, i) => id === desiredIds[i]))
+        return;
+    setMilestoneQueueOrder(desiredIds);
+}
+export function ensureExistingWorkflowDbOpen(basePath) {
+    const opened = isDbAvailable() || openExistingWorkflowDatabase(basePath).ok;
+    if (opened)
+        syncQueueOrderProjectionToDb(basePath);
+    return opened;
+}
+export function buildDbUnavailableState() {
+    return {
+        activeMilestone: null,
+        activeSlice: null,
+        activeTask: null,
+        phase: "pre-planning",
+        recentDecisions: [],
+        blockers: ["DB unavailable — runtime markdown state derivation is disabled"],
+        nextAction: "Open or create the canonical GSD database before deriving workflow state. If this project only has markdown state, run /gsd migrate explicitly.",
+        registry: [],
+        requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+        progress: { milestones: { done: 0, total: 0 } },
+    };
+}
+export function getRequestedMilestoneLock() {
+    const lock = process.env.GSD_MILESTONE_LOCK?.trim();
+    return lock || undefined;
+}