gsd-pi 2.80.0 → 2.81.0

package/dist/resources/extensions/gsd/db-task-slice-rows.js

@@ -0,0 +1,86 @@
+// Project/App: GSD-2
+// File Purpose: Task and slice row mappers for the GSD database facade.
+export function parseTaskArrayColumn(raw) {
+    if (Array.isArray(raw)) {
+        return raw.filter((entry) => typeof entry === "string");
+    }
+    if (typeof raw !== "string")
+        return [];
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed.filter((entry) => typeof entry === "string");
+        }
+        if (typeof parsed === "string" && parsed.trim()) {
+            return [parsed.trim()];
+        }
+        if (parsed === null || parsed === undefined || parsed === "") {
+            return [];
+        }
+        return [String(parsed)];
+    }
+    catch {
+        return trimmed.split(",").map((entry) => entry.trim()).filter(Boolean);
+    }
+}
+export function rowToSlice(row) {
+    return {
+        milestone_id: row["milestone_id"],
+        id: row["id"],
+        title: row["title"],
+        status: row["status"],
+        risk: row["risk"],
+        depends: JSON.parse(row["depends"] || "[]"),
+        demo: row["demo"] ?? "",
+        created_at: row["created_at"],
+        completed_at: row["completed_at"] ?? null,
+        full_summary_md: row["full_summary_md"] ?? "",
+        full_uat_md: row["full_uat_md"] ?? "",
+        goal: row["goal"] ?? "",
+        success_criteria: row["success_criteria"] ?? "",
+        proof_level: row["proof_level"] ?? "",
+        integration_closure: row["integration_closure"] ?? "",
+        observability_impact: row["observability_impact"] ?? "",
+        sequence: row["sequence"] ?? 0,
+        replan_triggered_at: row["replan_triggered_at"] ?? null,
+        is_sketch: row["is_sketch"] ?? 0,
+        sketch_scope: row["sketch_scope"] ?? "",
+    };
+}
+export function rowToTask(row) {
+    return {
+        milestone_id: row["milestone_id"],
+        slice_id: row["slice_id"],
+        id: row["id"],
+        title: row["title"],
+        status: row["status"],
+        one_liner: row["one_liner"],
+        narrative: row["narrative"],
+        verification_result: row["verification_result"],
+        duration: row["duration"],
+        completed_at: row["completed_at"] ?? null,
+        blocker_discovered: row["blocker_discovered"] === 1,
+        deviations: row["deviations"],
+        known_issues: row["known_issues"],
+        key_files: parseTaskArrayColumn(row["key_files"]),
+        key_decisions: parseTaskArrayColumn(row["key_decisions"]),
+        full_summary_md: row["full_summary_md"],
+        description: row["description"] ?? "",
+        estimate: row["estimate"] ?? "",
+        files: parseTaskArrayColumn(row["files"]),
+        verify: row["verify"] ?? "",
+        inputs: parseTaskArrayColumn(row["inputs"]),
+        expected_output: parseTaskArrayColumn(row["expected_output"]),
+        observability_impact: row["observability_impact"] ?? "",
+        full_plan_md: row["full_plan_md"] ?? "",
+        sequence: row["sequence"] ?? 0,
+        blocker_source: row["blocker_source"] ?? "",
+        escalation_pending: row["escalation_pending"] ?? 0,
+        escalation_awaiting_review: row["escalation_awaiting_review"] ?? 0,
+        escalation_artifact_path: row["escalation_artifact_path"] ?? null,
+        escalation_override_applied_at: row["escalation_override_applied_at"] ?? null,
+    };
+}

package/dist/resources/extensions/gsd/db-transaction.js

@@ -0,0 +1,63 @@
+// Project/App: GSD-2
+// File Purpose: Transaction depth helper for the GSD database facade.
+export class DbTransactionRunner {
+    depth = 0;
+    isInTransaction() {
+        return this.depth > 0;
+    }
+    transaction(controls, fn) {
+        if (this.depth > 0) {
+            return this.runNested(fn);
+        }
+        controls.begin();
+        this.depth++;
+        try {
+            const result = fn();
+            controls.commit();
+            return result;
+        }
+        catch (err) {
+            controls.rollback();
+            throw err;
+        }
+        finally {
+            this.depth--;
+        }
+    }
+    readTransaction(controls, fn, logRollbackError) {
+        if (this.depth > 0) {
+            return this.runNested(fn);
+        }
+        controls.beginRead();
+        this.depth++;
+        try {
+            const result = fn();
+            controls.commit();
+            return result;
+        }
+        catch (err) {
+            try {
+                controls.rollback();
+            }
+            catch (rollbackErr) {
+                logRollbackError(rollbackErr instanceof Error ? rollbackErr : new Error(String(rollbackErr)));
+            }
+            throw err;
+        }
+        finally {
+            this.depth--;
+        }
+    }
+    runNested(fn) {
+        this.depth++;
+        try {
+            return fn();
+        }
+        finally {
+            this.depth--;
+        }
+    }
+}
+export function createDbTransactionRunner() {
+    return new DbTransactionRunner();
+}

package/dist/resources/extensions/gsd/db-verification-evidence-rows.js

@@ -0,0 +1,3 @@
+// Project/App: GSD-2
+// File Purpose: Verification evidence row contract for GSD workflow database consumers.
+export {};

package/dist/resources/extensions/gsd/db-verification-evidence-schema.js

@@ -0,0 +1,19 @@
+// Project/App: GSD-2
+// File Purpose: Verification evidence SQLite schema helpers for the GSD database facade.
+import { indexExists } from "./db-schema-metadata.js";
+export function dedupeVerificationEvidenceRows(db) {
+    db.exec(`
+    DELETE FROM verification_evidence
+    WHERE rowid NOT IN (
+      SELECT MIN(rowid)
+      FROM verification_evidence
+      GROUP BY task_id, slice_id, milestone_id, command, verdict
+    )
+  `);
+}
+export function ensureVerificationEvidenceDedupIndex(db) {
+    if (indexExists(db, "idx_verification_evidence_dedup"))
+        return;
+    dedupeVerificationEvidenceRows(db);
+    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
+}

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/ecosystem/gsd-extension-api.js

@@ -127,6 +127,8 @@ export function createGSDExtensionAPI(pi, sharedHandlers) {
         getActiveTools: () => pi.getActiveTools(),
         getAllTools: () => pi.getAllTools(),
         setActiveTools: (...args) => pi.setActiveTools(...args),
+        getVisibleSkills: () => pi.getVisibleSkills(),
+        setVisibleSkills: (...args) => pi.setVisibleSkills(...args),
         getCommands: () => pi.getCommands(),
         // ── Model & thinking ───────────────────────────────────────────────
         setModel: (...args) => pi.setModel(...args),

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Mid-execution escalation artifact and state helpers for GSD tasks.
 // GSD Extension — ADR-011 Phase 2 Mid-Execution Escalation
 //
 // A single module that owns: escalation artifact I/O, detection, resolution,

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Git operations, commit-message formatting, and turn git actions.
 /**
  * GSD Git Service
  *
@@ -13,6 +15,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";
@@ -48,6 +51,10 @@ export function buildTaskCommitMessage(ctx) {
             .join("\n");
         bodyParts.push(fileLines);
     }
+    const contextLines = buildTaskCommitContextLines(ctx);
+    if (contextLines.length > 0) {
+        bodyParts.push(`GSD context:\n${contextLines.join("\n")}`);
+    }
     // Trailers: GSD-Task first, then Resolves
     bodyParts.push(`GSD-Task: ${ctx.taskId}`);
     if (ctx.issueNumber) {
@@ -55,6 +62,31 @@ export function buildTaskCommitMessage(ctx) {
     }
     return `${subject}\n\n${bodyParts.join("\n\n")}`;
 }
+function buildTaskCommitContextLines(ctx) {
+    const lines = [];
+    const milestone = formatNamedContext(ctx.milestoneId, ctx.milestoneTitle);
+    const slice = formatNamedContext(ctx.sliceId, ctx.sliceTitle);
+    const taskId = ctx.taskDisplayId ?? ctx.taskId.split("/").pop();
+    const task = formatNamedContext(taskId, ctx.taskTitle);
+    if (milestone)
+        lines.push(`- Milestone: ${milestone}`);
+    if (slice)
+        lines.push(`- Slice: ${slice}`);
+    if (task)
+        lines.push(`- Task: ${task}`);
+    return lines;
+}
+function formatNamedContext(id, title) {
+    const cleanId = id?.trim();
+    const cleanTitle = title?.trim();
+    if (!cleanId && !cleanTitle)
+        return null;
+    if (!cleanId)
+        return cleanTitle ?? null;
+    if (!cleanTitle || cleanTitle === cleanId)
+        return cleanId;
+    return `${cleanId} - ${cleanTitle}`;
+}
 function sanitizeCommitSubjectDescription(value) {
     const cleaned = value
         .replace(/[\x00-\x1F\x7F]+/g, " ")
@@ -535,14 +567,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;
@@ -823,7 +886,12 @@ export function createDraftPR(basePath, milestoneId, title, body, opts) {
             args.push("--head", opts.head);
         if (opts?.base)
             args.push("--base", opts.base);
-        const result = execFileSync("gh", args, { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
+        const result = execFileSync("gh", args, {
+            cwd: basePath,
+            encoding: "utf8",
+            timeout: 30000,
+            env: opts?.env ?? GIT_NO_PROMPT_ENV,
+        });
         return result.trim();
     }
     catch {

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

@@ -89,10 +89,16 @@ export function writeGraph(runDir, graph) {
     renameSync(tmpPath, filePath);
 }
 /**
- * Get the next pending step whose dependencies are all complete.
+ * Return whether a graph step status satisfies dependency edges.
+ */
+export function isTerminalStepStatus(status) {
+    return status === "complete" || status === "expanded";
+}
+/**
+ * Get the next pending step whose dependencies are all terminal.
  *
  * Returns the first step (in array order) with status "pending" where
- * every step in its `dependsOn` list has status "complete".
+ * every step in its `dependsOn` list has status "complete" or "expanded".
  *
  * @param graph — the workflow graph to query
  * @returns The next dispatchable step, or null if none available
@@ -102,7 +108,7 @@ export function getNextPendingStep(graph) {
     for (const step of graph.steps) {
         if (step.status !== "pending")
             continue;
-        const depsComplete = step.dependsOn.every((depId) => statusMap.get(depId) === "complete");
+        const depsComplete = step.dependsOn.every((depId) => isTerminalStepStatus(statusMap.get(depId)));
         if (depsComplete)
             return step;
     }