gsd-pi 2.80.0-dev.c5c38454b → 2.80.0-dev.cf9433f56

package/dist/resources/extensions/gsd/clean-root-preflight.js

@@ -16,6 +16,31 @@ import { execFileSync } from "node:child_process";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { logWarning } from "./workflow-logger.js";
 import { nativeHasChanges } from "./native-git-bridge.js";
+function findPreflightStashRef(basePath, milestoneId, stashMarker) {
+    const markerPrefix = `gsd-preflight-stash:${milestoneId}:`;
+    let fallbackRef = null;
+    try {
+        const list = execFileSync("git", ["stash", "list", "--format=%gd%x00%s"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        });
+        for (const line of list.split("\n")) {
+            const [ref, subject] = line.split("\x00");
+            if (!ref || !subject)
+                continue;
+            if (stashMarker && subject.includes(stashMarker))
+                return ref;
+            if (!fallbackRef && subject.includes(markerPrefix))
+                fallbackRef = ref;
+        }
+    }
+    catch (err) {
+        logWarning("preflight", `stash list failed before restore: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return fallbackRef;
+}
 /**
  * Check the working tree for dirty files before a milestone merge.
  *
@@ -47,7 +72,8 @@ export function preflightCleanRoot(basePath, milestoneId, notify) {
     notify(warnMsg, "warning");
     // Push the stash
     try {
-        execFileSync("git", ["stash", "push", "--include-untracked", "-m", "gsd-preflight-stash"], {
+        const stashMarker = `gsd-preflight-stash:${milestoneId}:${process.pid}:${Date.now()}:${process.hrtime.bigint().toString(36)}`;
+        execFileSync("git", ["stash", "push", "--include-untracked", "-m", `gsd-preflight-stash [${stashMarker}]`], {
             cwd: basePath,
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf-8",
@@ -55,6 +81,7 @@ export function preflightCleanRoot(basePath, milestoneId, notify) {
         });
         return {
             stashPushed: true,
+            stashMarker,
             summary: `Stashed uncommitted changes before merge (milestone ${milestoneId}).`,
         };
     }
@@ -73,9 +100,17 @@ export function preflightCleanRoot(basePath, milestoneId, notify) {
  * Any pop error (e.g. conflict) is logged and notified but does NOT throw —
  * the merge already completed successfully.
  */
-export function postflightPopStash(basePath, milestoneId, notify) {
+export function postflightPopStash(basePath, milestoneId, stashMarker, notify) {
+    let stashRef = null;
     try {
-        execFileSync("git", ["stash", "pop"], {
+        stashRef = findPreflightStashRef(basePath, milestoneId, stashMarker);
+        if (!stashRef) {
+            const msg = `No matching GSD preflight stash found for milestone ${milestoneId}; leaving stash list untouched.`;
+            logWarning("preflight", msg);
+            notify(msg, "warning");
+            return;
+        }
+        execFileSync("git", ["stash", "pop", stashRef], {
             cwd: basePath,
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf-8",
@@ -86,7 +121,10 @@ export function postflightPopStash(basePath, milestoneId, notify) {
     catch (err) {
         // Pop conflicts mean the merged code collides with the stashed changes.
         // Log a warning — the user needs to resolve manually, but the merge succeeded.
-        const msg = `git stash pop failed after merge of milestone ${milestoneId}: ${err instanceof Error ? err.message : String(err)}. Run "git stash pop" manually to restore your changes.`;
+        const restoreHint = stashRef
+            ? `Run "git stash pop ${stashRef}" or "git stash apply ${stashRef}" manually to restore the correct stash.`
+            : `Run "git stash list" to find the matching GSD preflight stash before restoring manually.`;
+        const msg = `git stash pop ${stashRef ?? ""}`.trim() + ` failed after merge of milestone ${milestoneId}: ${err instanceof Error ? err.message : String(err)}. ${restoreHint}`;
         logWarning("preflight", msg);
         notify(msg, "warning");
     }

package/dist/resources/extensions/gsd/commands/dispatcher.js

@@ -33,5 +33,10 @@ export async function handleGSDCommand(args, ctx, pi) {
     }
     if (handled)
         return;
+    if (trimmed.includes(" ")) {
+        const { handleDo } = await import("../commands-do.js");
+        await handleDo(trimmed, ctx, pi);
+        return;
+    }
     ctx.ui.notify(`Unknown: /gsd ${trimmed}. Run /gsd help for available commands.`, "warning");
 }

package/dist/resources/extensions/gsd/context-budget.js

@@ -7,7 +7,7 @@
  *
  * @see D001 (module location), D002 (200K fallback), D003 (section-boundary truncation)
  */
-import { getCharsPerToken } from "./token-counter.js";
+import { getCharsPerToken, isAccurateCountingAvailable, countTokensSync, } from "./token-counter.js";
 // ─── Budget ratio constants ──────────────────────────────────────────────────
 // Percentages of total context window allocated to each budget category.
 // These are applied after tokens→chars conversion.
@@ -23,6 +23,22 @@ const CHARS_PER_TOKEN = 4;
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 /** Conservative effective context for Claude Code subscription routing (#4676) */
 const CLAUDE_CODE_EFFECTIVE_CONTEXT_WINDOW = 200_000;
+/**
+ * Cached empirical chars-per-token from a tiktoken probe, keyed by provider.
+ * countTokensSync's fallback path is provider-aware, so we cache per-provider
+ * to preserve that distinction once the encoder warms. The cl100k_base encoder
+ * itself gives a stable ratio for ASCII English so a single probe per provider
+ * key is sufficient. Empty map means "not yet probed" or "encoder unavailable".
+ */
+const _empiricalCharsPerTokenByProvider = new Map();
+/**
+ * Test hook — clears the empirical chars-per-token cache so test cases that
+ * assert against the static char-ratio fallback aren't polluted by a prior
+ * tiktoken-warmed run in the same process. Production code must not call this.
+ */
+export function _resetEmpiricalCacheForTest() {
+    _empiricalCharsPerTokenByProvider.clear();
+}
 /** Percentage of context consumed before suggesting a continue-here checkpoint */
 const CONTINUE_THRESHOLD_PERCENT = 70;
 // ─── Task count bounds ───────────────────────────────────────────────────────
@@ -46,7 +62,26 @@ const TASK_COUNT_TIERS = [
 export function computeBudgets(contextWindow, provider) {
     const effectiveWindow = contextWindow > 0 ? contextWindow : DEFAULT_CONTEXT_WINDOW;
     const charsPerToken = provider ? getCharsPerToken(provider) : CHARS_PER_TOKEN;
-    const totalChars = effectiveWindow * charsPerToken;
+    // Prefer the tiktoken encoder for total-char estimation when it has been
+    // warmed (initTokenCounter resolved). The cl100k_base ratio is stable for
+    // ASCII English, so probe once per provider and cache — computeBudgets is
+    // called multiple times per prompt build and the probe encode is otherwise
+    // wasted work.
+    let totalChars;
+    if (isAccurateCountingAvailable()) {
+        const providerKey = provider ?? "__default__";
+        let empirical = _empiricalCharsPerTokenByProvider.get(providerKey);
+        if (empirical === undefined) {
+            const probe = "the quick brown fox jumps over the lazy dog ".repeat(64);
+            const probeTokens = countTokensSync(probe, provider);
+            empirical = probeTokens > 0 ? probe.length / probeTokens : charsPerToken;
+            _empiricalCharsPerTokenByProvider.set(providerKey, empirical);
+        }
+        totalChars = effectiveWindow * empirical;
+    }
+    else {
+        totalChars = effectiveWindow * charsPerToken;
+    }
     return {
         summaryBudgetChars: Math.floor(totalChars * SUMMARY_RATIO),
         inlineContextBudgetChars: Math.floor(totalChars * INLINE_CONTEXT_RATIO),

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

@@ -29,6 +29,7 @@ import { _getAdapter, isDbAvailable } from "./gsd-db.js";
 import { gsdRoot, normalizeRealPath } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { effectiveLockFile } from "./session-lock.js";
+import { isInFlightRuntimePhase, listUnitRuntimeRecords } from "./unit-runtime.js";
 const SESSION_FILE_KV_KEY = "session_file";
 function lockPath(basePath) {
     return join(gsdRoot(basePath), effectiveLockFile());
@@ -72,9 +73,37 @@ function getLatestDispatchForWorker(workerId) {
      LIMIT 1`).get({ ":worker_id": workerId });
     return row ?? null;
 }
-function workerToLockData(worker) {
+function latestInFlightRuntimeRecord(basePath) {
+    const records = listUnitRuntimeRecords(basePath).filter((record) => isInFlightRuntimePhase(record.phase));
+    if (records.length === 0)
+        return null;
+    return records.sort((a, b) => {
+        const bTime = b.updatedAt || b.startedAt || 0;
+        const aTime = a.updatedAt || a.startedAt || 0;
+        return bTime - aTime;
+    })[0] ?? null;
+}
+function runtimeRecordToLockData(worker, record, sessionFile) {
+    const startedAt = Number.isFinite(record.startedAt)
+        ? new Date(record.startedAt).toISOString()
+        : worker.started_at;
+    return {
+        pid: worker.pid,
+        startedAt: worker.started_at,
+        unitType: record.unitType,
+        unitId: record.unitId,
+        unitStartedAt: startedAt,
+        sessionFile,
+    };
+}
+function workerToLockData(basePath, worker) {
     const dispatch = getLatestDispatchForWorker(worker.worker_id);
     const sessionFile = getRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY) ?? undefined;
+    if (!dispatch) {
+        const runtimeRecord = latestInFlightRuntimeRecord(basePath);
+        if (runtimeRecord)
+            return runtimeRecordToLockData(worker, runtimeRecord, sessionFile);
+    }
     return {
         pid: worker.pid,
         startedAt: worker.started_at,
@@ -172,7 +201,7 @@ export function readCrashLock(basePath) {
             const projectRoot = normalizeRealPath(basePath);
             const stale = findStaleWorkerForProject(projectRoot);
             if (stale)
-                return workerToLockData(stale);
+                return workerToLockData(basePath, stale);
         }
         catch {
             // Fall through to the legacy lock-file compatibility path.
@@ -232,18 +261,32 @@ export function formatCrashInfo(lock) {
 export function emitCrashRecoveredUnitEnd(basePath, lock) {
     if (!lock.unitType || !lock.unitId || lock.unitType === "starting")
         return;
+    emitOpenUnitEndForUnit(basePath, lock.unitType, lock.unitId, "crash-recovered");
+}
+export function emitOpenUnitEndForUnit(basePath, unitType, unitId, status, errorContext) {
     try {
         const all = queryJournal(basePath);
-        const starts = all.filter((e) => e.eventType === "unit-start" && e.data?.unitId === lock.unitId);
+        const starts = all.filter((e) => e.eventType === "unit-start" &&
+            e.data?.unitType === unitType &&
+            e.data?.unitId === unitId);
         if (starts.length === 0)
-            return;
-        const lastStart = starts[starts.length - 1];
+            return false;
+        const lastStart = [...starts].reverse().find((start) => {
+            return !all.some((e) => e.eventType === "unit-end" &&
+                e.data?.unitType === unitType &&
+                e.data?.unitId === unitId &&
+                e.causedBy?.flowId === start.flowId &&
+                e.causedBy?.seq === start.seq);
+        });
+        if (!lastStart)
+            return false;
         const alreadyClosed = all.some((e) => e.eventType === "unit-end" &&
-            e.data?.unitId === lock.unitId &&
+            e.data?.unitType === unitType &&
+            e.data?.unitId === unitId &&
             e.causedBy?.flowId === lastStart.flowId &&
             e.causedBy?.seq === lastStart.seq);
         if (alreadyClosed)
-            return;
+            return false;
         const maxSeq = all
             .filter((e) => e.flowId === lastStart.flowId)
             .reduce((max, e) => Math.max(max, e.seq), lastStart.seq);
@@ -253,16 +296,19 @@ export function emitCrashRecoveredUnitEnd(basePath, lock) {
             seq: maxSeq + 1,
             eventType: "unit-end",
             data: {
-                unitType: lock.unitType,
-                unitId: lock.unitId,
-                status: "crash-recovered",
+                unitType,
+                unitId,
+                status,
                 artifactVerified: false,
+                ...(errorContext ? { errorContext } : {}),
             },
             causedBy: { flowId: lastStart.flowId, seq: lastStart.seq },
         });
+        return true;
     }
     catch {
         // Never throw from crash recovery path.
+        return false;
     }
 }
 /**

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -253,6 +253,45 @@ export function markCanceled(dispatchId, reason) {
      SET status = 'canceled', ended_at = :ended_at, exit_reason = :reason
      WHERE id = :id AND status IN ('pending','claimed','running')`).run({ ":id": dispatchId, ":ended_at": now, ":reason": reason });
 }
+/**
+ * Best-effort signal/crash cleanup: cancel the latest active dispatch owned by
+ * a worker when the process is exiting before the normal loop can settle it.
+ */
+export function markLatestActiveForWorkerCanceled(workerId, reason) {
+    if (!isDbAvailable())
+        return false;
+    const now = new Date().toISOString();
+    const db = _getAdapter();
+    const result = transaction(() => {
+        return db.prepare(`UPDATE unit_dispatches
+       SET status = 'canceled', ended_at = :ended_at, exit_reason = :reason
+       WHERE id = (
+         SELECT id FROM unit_dispatches
+         WHERE worker_id = :worker_id
+           AND status IN ('pending','claimed','running')
+         ORDER BY id DESC
+         LIMIT 1
+       )`).run({
+            ":ended_at": now,
+            ":reason": reason,
+            ":worker_id": workerId,
+        });
+    });
+    const changes = typeof result.changes === "number"
+        ? result.changes
+        : 0;
+    if (changes <= 0)
+        return false;
+    insertAuditEvent({
+        eventId: randomUUID(),
+        traceId: workerId,
+        category: "orchestration",
+        type: "dispatch-canceled",
+        ts: now,
+        payload: { workerId, reason },
+    });
+    return true;
+}
 /**
  * Fetch the most recent N dispatches for a unit. Used by recordDispatchClaim
  * callers to compute attempt_n and by detect-stuck.ts (B3) to consult

package/dist/resources/extensions/gsd/db-base-schema.js

@@ -46,7 +46,8 @@ export function createBaseSchemaObjects(db, hooks) {
       slice_id TEXT DEFAULT NULL,
       task_id TEXT DEFAULT NULL,
       full_content TEXT NOT NULL DEFAULT '',
-      imported_at TEXT NOT NULL DEFAULT ''
+      imported_at TEXT NOT NULL DEFAULT '',
+      content_hash TEXT DEFAULT NULL
     )
   `);
     db.exec(`
@@ -64,7 +65,8 @@ export function createBaseSchemaObjects(db, hooks) {
       hit_count INTEGER NOT NULL DEFAULT 0,
       scope TEXT NOT NULL DEFAULT 'project',
       tags TEXT NOT NULL DEFAULT '[]',
-      structured_fields TEXT DEFAULT NULL
+      structured_fields TEXT DEFAULT NULL,
+      last_hit_at TEXT DEFAULT NULL
     )
   `);
     db.exec(`

package/dist/resources/extensions/gsd/db-migration-steps.js

@@ -379,6 +379,12 @@ export function applyMigrationV26MilestoneCommitAttributions(db) {
   `);
     db.exec("CREATE INDEX IF NOT EXISTS idx_milestone_commit_attr_milestone ON milestone_commit_attributions(milestone_id)");
 }
+export function applyMigrationV27ArtifactHash(db) {
+    ensureColumn(db, "artifacts", "content_hash", "ALTER TABLE artifacts ADD COLUMN content_hash TEXT DEFAULT NULL");
+}
+export function applyMigrationV28MemoryLastHitAt(db) {
+    ensureColumn(db, "memories", "last_hit_at", "ALTER TABLE memories ADD COLUMN last_hit_at TEXT DEFAULT NULL");
+}
 export function applyMigrationV22QualityGateRepair(db, hooks) {
     const qgInfo = db.prepare("PRAGMA table_info(quality_gates)").all();
     const taskIdCol = qgInfo.find((r) => r["name"] === "task_id");

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

@@ -5,6 +5,7 @@
  * Used by init-wizard.ts and guided-flow.ts to determine what onboarding
  * flow to show when entering a project directory.
  */
+import { execFileSync } from "node:child_process";
 import { existsSync, openSync, readSync, closeSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, parse as parsePath } from "node:path";
 import { homedir } from "node:os";
@@ -171,6 +172,7 @@ const TEST_MARKERS = [
 const RECURSIVE_SCAN_IGNORED_DIRS = new Set([
     ".git",
     ".gsd",
+    ".bg-shell",
     ".planning",
     ".plans",
     ".claude",
@@ -194,6 +196,7 @@ const RECURSIVE_SCAN_IGNORED_DIRS = new Set([
     "DerivedData",
     "out",
 ]);
+const PROJECT_CONTENT_EXCLUDE_DIRS = RECURSIVE_SCAN_IGNORED_DIRS;
 /** Project file markers safe to detect recursively via suffix matching. */
 const ROOT_ONLY_PROJECT_FILES = new Set([
     ".github/workflows",
@@ -429,6 +432,109 @@ export function detectProjectSignals(basePath) {
         verificationCommands,
     };
 }
+function normalizeGitPath(file) {
+    return file.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function isProjectContentFile(file) {
+    const normalized = normalizeGitPath(file);
+    if (!normalized || normalized.endsWith("/"))
+        return false;
+    if (normalized === ".gitignore" || normalized === ".gitattributes")
+        return false;
+    const parts = normalized.split("/");
+    if (parts.some((part) => PROJECT_CONTENT_EXCLUDE_DIRS.has(part)))
+        return false;
+    if (normalized.endsWith(".DS_Store"))
+        return false;
+    return true;
+}
+function runGitLines(basePath, args) {
+    try {
+        const output = execFileSync("git", args, {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf-8",
+        }).trim();
+        return output ? output.split("\n").map((line) => line.trim()).filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function listTrackedProjectFiles(basePath) {
+    return runGitLines(basePath, ["ls-files"])
+        .map(normalizeGitPath)
+        .filter(isProjectContentFile);
+}
+function listUntrackedProjectFiles(basePath) {
+    return runGitLines(basePath, ["ls-files", "--others", "--exclude-standard"])
+        .map(normalizeGitPath)
+        .filter(isProjectContentFile);
+}
+function hasKnownProjectMarkers(basePath, signals) {
+    if (signals.detectedFiles.length > 0)
+        return true;
+    if (signals.xcodePlatforms.length > 0)
+        return true;
+    return false;
+}
+/**
+ * Classify repo presence separately from ecosystem/tooling markers.
+ *
+ * Known project files identify tooling. Git-tracked/non-ignored content
+ * identifies whether this is an existing project at all. This keeps small
+ * static or documentation repos from being mislabeled as greenfield.
+ */
+export function classifyProject(basePath) {
+    const signals = detectProjectSignals(basePath);
+    const markers = [...signals.detectedFiles];
+    if (!signals.isGitRepo) {
+        return {
+            kind: "invalid-repo",
+            signals,
+            trackedFiles: [],
+            untrackedFiles: [],
+            contentFiles: [],
+            markers,
+            reason: "missing .git",
+        };
+    }
+    const trackedFiles = listTrackedProjectFiles(basePath);
+    const untrackedFiles = listUntrackedProjectFiles(basePath);
+    const contentFiles = [...new Set([...trackedFiles, ...untrackedFiles])];
+    const hasMarkers = hasKnownProjectMarkers(basePath, signals);
+    if (hasMarkers) {
+        return {
+            kind: "typed-existing",
+            signals,
+            trackedFiles,
+            untrackedFiles,
+            contentFiles,
+            markers,
+            reason: markers.length > 0 ? `detected markers: ${markers.join(", ")}` : "detected project structure",
+        };
+    }
+    if (contentFiles.length > 0) {
+        return {
+            kind: "untyped-existing",
+            signals,
+            trackedFiles,
+            untrackedFiles,
+            contentFiles,
+            markers,
+            reason: "project content exists but no recognized tooling markers were found",
+        };
+    }
+    return {
+        kind: "greenfield",
+        signals,
+        trackedFiles,
+        untrackedFiles,
+        contentFiles,
+        markers,
+        reason: "no tracked or non-ignored project content",
+    };
+}
 // ─── Xcode Platform Detection ───────────────────────────────────────────────────
 /** Known SDKROOT values → canonical platform names. */
 const SDKROOT_MAP = {

package/dist/resources/extensions/gsd/git-service.js

@@ -13,6 +13,7 @@ import { isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { logWarning } from "./workflow-logger.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeAddPaths, nativeResetSoft, nativeCommitSubject, _resetHasChangesCache, } from "./native-git-bridge.js";
@@ -535,14 +536,45 @@ export class GitServiceImpl {
         if (keyFiles.length === 0)
             return false;
         const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
-        const paths = Array.from(new Set(keyFiles
+        const normalized = keyFiles
             .map(file => normalizeRepoRelativePath(this.basePath, file))
             .filter((file) => file !== null)
-            .filter(file => !isExcludedScopedPath(file, allExclusions))));
+            .filter(file => !isExcludedScopedPath(file, allExclusions));
+        // Drop entries that don't exist on disk. The LLM occasionally lists files
+        // it intended to write but didn't (or names them with wrong casing/path).
+        // Pre-`b304f738b` `git add -A` swallowed these silently; the scoped
+        // pathspec form passes each path explicitly, so a single bad entry made
+        // the whole commit fail (see #5500). Filter so valid paths still commit.
+        const missing = [];
+        const existing = [];
+        for (const path of normalized) {
+            if (existsSync(join(this.basePath, path))) {
+                existing.push(path);
+            }
+            else {
+                missing.push(path);
+            }
+        }
+        if (missing.length > 0) {
+            logWarning("engine", `scoped stage: dropping ${missing.length} non-existent keyFile(s) from task commit: ${missing.join(", ")}`, { file: "git-service.ts" });
+        }
+        const paths = Array.from(new Set(existing));
         if (paths.length === 0)
             return false;
-        nativeAddPaths(this.basePath, paths);
-        return true;
+        try {
+            nativeAddPaths(this.basePath, paths);
+            return true;
+        }
+        catch (err) {
+            // Defense-in-depth: even after existence filtering, libgit2/git can
+            // still reject paths (gitignore matches, case-only differences on
+            // case-insensitive FS, submodule boundaries). Returning false lets
+            // autoCommit fall through to smartStage so the commit still goes out
+            // — restoring the resilience the unscoped path used to provide.
+            const msg = err instanceof Error ? err.message : String(err);
+            logWarning("engine", `scoped stage failed (${msg}); falling back to smartStage`, { file: "git-service.ts" });
+            return false;
+        }
     }
     /** Tracks whether runtime file cleanup has run this session. */
     _runtimeFilesCleanedUp = false;