gsd-pi 2.72.0 → 2.73.0-dev.27730dc

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

@@ -121,6 +121,25 @@ function openRawDb(path) {
     return new Database(path);
 }
 const SCHEMA_VERSION = 14;
+function indexExists(db, name) {
+    return !!db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
+}
+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
+    )
+  `);
+}
+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)");
+}
 function initSchema(db, fileBacked) {
     if (fileBacked)
         db.exec("PRAGMA journal_mode=WAL");
@@ -132,7 +151,7 @@ function initSchema(db, fileBacked) {
         db.exec("PRAGMA auto_vacuum = INCREMENTAL");
     if (fileBacked)
         db.exec("PRAGMA cache_size = -8000"); // 8 MB page cache
-    if (fileBacked)
+    if (fileBacked && process.platform !== "darwin")
         db.exec("PRAGMA mmap_size = 67108864"); // 64 MB mmap
     db.exec("PRAGMA temp_store = MEMORY");
     db.exec("PRAGMA foreign_keys = ON");
@@ -358,7 +377,7 @@ function initSchema(db, fileBacked) {
         db.exec("CREATE INDEX IF NOT EXISTS idx_milestones_status ON milestones(status)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id)");
-        db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
+        ensureVerificationEvidenceDedupIndex(db);
         // v14 index — slice dependency lookups
         db.exec("CREATE INDEX IF NOT EXISTS idx_slice_deps_target ON slice_dependencies(milestone_id, depends_on_slice_id)");
         db.exec(`CREATE VIEW IF NOT EXISTS active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL`);
@@ -668,7 +687,7 @@ function migrateSchema(db) {
             db.exec("CREATE INDEX IF NOT EXISTS idx_milestones_status ON milestones(status)");
             db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
             db.exec("CREATE INDEX IF NOT EXISTS idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id)");
-            db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
+            ensureVerificationEvidenceDedupIndex(db);
             db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
                 ":version": 13,
                 ":applied_at": new Date().toISOString(),
@@ -800,6 +819,7 @@ export function closeDatabase() {
         currentDb = null;
         currentPath = null;
         currentPid = 0;
+        _dbOpenAttempted = false;
     }
 }
 /** Run a full VACUUM — call sparingly (e.g. after milestone completion). */
@@ -1332,7 +1352,49 @@ export function setSliceSummaryMd(milestoneId, sliceId, summaryMd, uatMd) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE slices SET full_summary_md = :summary_md, full_uat_md = :uat_md WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId, ":summary_md": summaryMd, ":uat_md": uatMd });
 }
+function parseTaskArrayColumn(raw) {
+    if (typeof raw !== "string" || raw.trim() === "")
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed.map((value) => String(value));
+        if (parsed === null || parsed === undefined || parsed === "")
+            return [];
+        return [String(parsed)];
+    }
+    catch {
+        // Older/corrupt rows may contain comma-separated strings instead of JSON.
+        return raw
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean);
+    }
+}
 function rowToTask(row) {
+    const parseTaskArray = (value) => {
+        if (Array.isArray(value)) {
+            return value.filter((entry) => typeof entry === "string");
+        }
+        if (typeof value !== "string")
+            return [];
+        const trimmed = value.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()];
+            }
+        }
+        catch {
+            // Older/corrupt DB rows may contain raw comma-separated paths instead of JSON arrays.
+        }
+        return trimmed.split(",").map((entry) => entry.trim()).filter(Boolean);
+    };
     return {
         milestone_id: row["milestone_id"],
         slice_id: row["slice_id"],
@@ -1347,15 +1409,15 @@ function rowToTask(row) {
         blocker_discovered: row["blocker_discovered"] === 1,
         deviations: row["deviations"],
         known_issues: row["known_issues"],
-        key_files: JSON.parse(row["key_files"] || "[]"),
-        key_decisions: JSON.parse(row["key_decisions"] || "[]"),
+        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: JSON.parse(row["files"] || "[]"),
+        files: parseTaskArray(row["files"]),
         verify: row["verify"] ?? "",
-        inputs: JSON.parse(row["inputs"] || "[]"),
-        expected_output: JSON.parse(row["expected_output"] || "[]"),
+        inputs: parseTaskArray(row["inputs"]),
+        expected_output: parseTaskArray(row["expected_output"]),
         observability_impact: row["observability_impact"] ?? "",
         full_plan_md: row["full_plan_md"] ?? "",
         sequence: row["sequence"] ?? 0,
@@ -1812,6 +1874,21 @@ export function deleteSlice(milestoneId, sliceId) {
         currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId });
     });
 }
+export function deleteMilestone(milestoneId) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    transaction(() => {
+        currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM quality_gates WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM slice_dependencies WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM replan_history WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM assessments WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM artifacts WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM milestones WHERE id = :mid`).run({ ":mid": milestoneId });
+    });
+}
 export function updateSliceFields(milestoneId, sliceId, fields) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");

package/dist/resources/extensions/gsd/key-manager.js

@@ -26,6 +26,8 @@ export const PROVIDER_REGISTRY = [
     { id: "custom-openai", label: "Custom (OpenAI-compat)", category: "llm", envVar: "CUSTOM_OPENAI_API_KEY" },
     { id: "cerebras", label: "Cerebras", category: "llm", envVar: "CEREBRAS_API_KEY" },
     { id: "azure-openai-responses", label: "Azure OpenAI", category: "llm", envVar: "AZURE_OPENAI_API_KEY" },
+    { id: "alibaba-coding-plan", label: "Alibaba Coding Plan", category: "llm", envVar: "ALIBABA_API_KEY", dashboardUrl: "bailian.console.aliyun.com" },
+    { id: "alibaba-dashscope", label: "Alibaba DashScope", category: "llm", envVar: "DASHSCOPE_API_KEY", dashboardUrl: "dashscope.console.aliyun.com" },
     // Tool Keys
     { id: "context7", label: "Context7 Docs", category: "tool", envVar: "CONTEXT7_API_KEY", dashboardUrl: "context7.com/dashboard" },
     { id: "jina", label: "Jina Page Extract", category: "tool", envVar: "JINA_API_KEY", dashboardUrl: "jina.ai/api" },

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -15,7 +15,8 @@ import { join } from "node:path";
 import { resolveMilestonePath, resolveMilestoneFile, buildMilestoneFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
-import { getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 // ─── Park ──────────────────────────────────────────────────────────────────
 /**
@@ -99,12 +100,29 @@ export function discardMilestone(basePath, milestoneId) {
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;
+    try {
+        removeWorktree(basePath, milestoneId, {
+            branch: `milestone/${milestoneId}`,
+            deleteBranch: true,
+        });
+    }
+    catch (err) {
+        logWarning("engine", `discardMilestone worktree cleanup failed for ${milestoneId}: ${err.message}`);
+    }
     rmSync(mDir, { recursive: true, force: true });
     // Prune from queue order if present
     const order = loadQueueOrder(basePath);
     if (order && order.includes(milestoneId)) {
         saveQueueOrder(basePath, order.filter(id => id !== milestoneId));
     }
+    if (isDbAvailable()) {
+        try {
+            deleteMilestone(milestoneId);
+        }
+        catch (err) {
+            logWarning("engine", `discardMilestone DB cleanup failed for ${milestoneId}: ${err.message}`);
+        }
+    }
     invalidateAllCaches();
     return true;
 }

package/dist/resources/extensions/gsd/preferences-skills.js

@@ -9,7 +9,6 @@ import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import { statSync } from "node:fs";
 import { validatePreferences } from "./preferences-validation.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
 /**
  * Known skill directories, in priority order.
  * Searches both the skills.sh ecosystem directory (~/.agents/skills/) and
@@ -130,36 +129,5 @@ export function resolveAllSkillReferences(preferences, cwd) {
     }
     return { resolutions, warnings };
 }
-/**
- * Format a skill reference for the system prompt.
- * If resolved, shows the path so the agent knows exactly where to read.
- * If unresolved, marks it clearly.
- */
-export function formatSkillRef(ref, resolutions) {
-    const resolution = resolutions.get(ref);
-    if (!resolution || resolution.method === "unresolved") {
-        return `${ref} (⚠ not found — check skill name or path)`;
-    }
-    // For absolute paths where SKILL.md is just appended, don't clutter the output
-    if (resolution.method === "absolute-path" || resolution.method === "absolute-dir") {
-        return ref;
-    }
-    // For bare names resolved from skill directories, show the resolved path
-    return `${ref} → \`${resolution.resolvedPath}\``;
-}
-/**
- * Resolve the skill discovery mode from effective preferences.
- * Defaults to "suggest" -- skills are identified during research but not installed automatically.
- */
-export function resolveSkillDiscoveryMode() {
-    const prefs = loadEffectiveGSDPreferences();
-    return prefs?.preferences.skill_discovery ?? "suggest";
-}
-/**
- * Resolve the skill staleness threshold in days.
- * Returns 0 if disabled, default 60 if not configured.
- */
-export function resolveSkillStalenessDays() {
-    const prefs = loadEffectiveGSDPreferences();
-    return prefs?.preferences.skill_staleness_days ?? 60;
-}
+// resolveSkillDiscoveryMode and resolveSkillStalenessDays moved to
+// preferences.ts to break circular dependency (they need loadEffectiveGSDPreferences).

package/dist/resources/extensions/gsd/preferences-types.js

@@ -92,3 +92,18 @@ export const KNOWN_UNIT_TYPES = [
     "discuss-milestone", "discuss-slice", "worktree-merge",
 ];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
+/**
+ * Format a skill reference for the system prompt.
+ * If resolved, shows the path so the agent knows exactly where to read.
+ * If unresolved, marks it clearly.
+ */
+export function formatSkillRef(ref, resolutions) {
+    const resolution = resolutions.get(ref);
+    if (!resolution || resolution.method === "unresolved") {
+        return `${ref} (⚠ not found — check skill name or path)`;
+    }
+    if (resolution.method === "absolute-path" || resolution.method === "absolute-dir") {
+        return ref;
+    }
+    return `${ref} → \`${resolution.resolvedPath}\``;
+}

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

@@ -17,13 +17,23 @@ import { parse as parseYaml } from "yaml";
 import { normalizeStringArray } from "../shared/format-utils.js";
 import { logWarning } from "./workflow-logger.js";
 import { resolveProfileDefaults as _resolveProfileDefaults } from "./preferences-models.js";
-import { KNOWN_PREFERENCE_KEYS, MODE_DEFAULTS, } from "./preferences-types.js";
+import { KNOWN_PREFERENCE_KEYS, MODE_DEFAULTS, formatSkillRef, } from "./preferences-types.js";
 import { validatePreferences } from "./preferences-validation.js";
-import { formatSkillRef } from "./preferences-skills.js";
 // ─── Re-exports: validation ─────────────────────────────────────────────────
 export { validatePreferences } from "./preferences-validation.js";
 // ─── Re-exports: skills ─────────────────────────────────────────────────────
-export { resolveAllSkillReferences, resolveSkillDiscoveryMode, resolveSkillStalenessDays, } from "./preferences-skills.js";
+export { resolveAllSkillReferences } from "./preferences-skills.js";
+// These lived in preferences-skills.ts but imported loadEffectiveGSDPreferences
+// back from this file, creating a circular dependency. Moved here since they
+// are trivial wrappers over loadEffectiveGSDPreferences.
+export function resolveSkillDiscoveryMode() {
+    const prefs = loadEffectiveGSDPreferences();
+    return prefs?.preferences.skill_discovery ?? "suggest";
+}
+export function resolveSkillStalenessDays() {
+    const prefs = loadEffectiveGSDPreferences();
+    return prefs?.preferences.skill_staleness_days ?? 60;
+}
 // ─── Re-exports: models ─────────────────────────────────────────────────────
 export { resolveModelForUnit, resolveModelWithFallbacksForUnit, getNextFallbackModel, isTransientNetworkError, validateModelId, updatePreferencesModels, resolveDynamicRoutingConfig, resolveAutoSupervisorConfig, resolveProfileDefaults, resolveEffectiveProfile, resolveInlineLevel, resolveContextSelection, resolveSearchProviderFromPreferences, } from "./preferences-models.js";
 // ─── Path Constants & Getters ───────────────────────────────────────────────
@@ -304,6 +314,9 @@ function mergePreferences(base, override) {
         github: (base.github || override.github)
             ? { ...(base.github ?? {}), ...(override.github ?? {}) }
             : undefined,
+        experimental: (base.experimental || override.experimental)
+            ? { ...(base.experimental ?? {}), ...(override.experimental ?? {}) }
+            : undefined,
         service_tier: override.service_tier ?? base.service_tier,
         forensics_dedup: override.forensics_dedup ?? base.forensics_dedup,
         show_token_cost: override.show_token_cost ?? base.show_token_cost,

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -132,10 +132,13 @@ export function loadPrompt(name, vars = {}) {
         }
     }
     for (const [key, value] of Object.entries(effectiveVars)) {
+        const safeValue = key === "workingDirectory" && typeof value === "string"
+            ? value.replaceAll("\\", "/")
+            : value;
         // Use split/join instead of replaceAll to avoid JavaScript's special
         // replacement patterns ($', $`, $&) being interpreted in the value.
         // See: https://github.com/gsd-build/gsd-2/issues/2968
-        content = content.split(`{{${key}}}`).join(value);
+        content = content.split(`{{${key}}}`).join(safeValue);
     }
     return content.trim();
 }

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -49,31 +49,132 @@ This happens ONCE, before the first round. The goal: your first questions should
 
 For subsequent rounds, continue investigating between rounds — check docs, search, or scout as needed to make each round's questions smarter. But the first-round investigation is mandatory and explicit. Distribute searches across turns rather than clustering them in one turn.
 
-## Question Rounds
+## Layered Question Rounds
 
-Ask **1–3 questions per round**. Keep each round tightly focused on one or two of the depth checklist dimensions — do not try to cover all six in one round.
+Questions are organized into four layers. Each layer targets a specific depth dimension. At each layer: ask 1-3 open questions per round, investigate between rounds as needed, and gate before advancing.
 
-**If `{{structuredQuestionsAvailable}}` is `true`:** use `ask_user_questions` for each round. 1–3 questions per call, each as a separate question object. Keep option labels short (3–5 words). Always include a freeform "Other / let me explain" option. When the user picks that option or writes a long freeform answer, switch to plain text follow-up for that thread before resuming structured questions. **IMPORTANT: Call `ask_user_questions` exactly once per turn. Never make multiple calls with the same or overlapping questions — wait for the user's response before asking the next round.**
+**Default to open questions.** Use `ask_user_questions` only when there are 2-3 genuinely distinct paths with clear tradeoffs (e.g., "REST vs GraphQL" or "Postgres vs SQLite"). For nuanced design questions, ask in plain text and let the user explain.
 
-**If `{{structuredQuestionsAvailable}}` is `false`:** ask questions in plain text. Keep each round to 1–3 focused questions. Wait for answers before asking the next round.
+**If `{{structuredQuestionsAvailable}}` is `true`:** use `ask_user_questions` for binary/ternary choices. Keep option labels short (3-5 words). Always include a freeform "Other / let me explain" option. When the user picks that option or writes a long freeform answer, switch to plain text follow-up for that thread before resuming structured questions. **IMPORTANT: Call `ask_user_questions` exactly once per turn. Never make multiple calls with the same or overlapping questions — wait for the user's response before asking the next round.**
 
-After each answer set, investigate further if any answer opens a new unknown, then ask the next round.
+**If `{{structuredQuestionsAvailable}}` is `false`:** ask questions in plain text. Keep each round to 1-3 focused questions. Wait for answers before asking the next round.
 
-### Round cadence
+**Incremental persistence:** After every 2 question rounds (across any layer), silently save a `{{milestoneId}}-CONTEXT-DRAFT.md` using `gsd_summary_save` with `artifact_type: "CONTEXT-DRAFT"` and `milestone_id: "{{milestoneId}}"`. This protects confirmed work against session crashes. Do NOT mention this save to the user.
 
-After each round of answers, decide whether you already have enough depth to write strong output.
+### Identify Work Type
 
-- **Incremental persistence:** After every 2 question rounds, silently save a `{{milestoneId}}-CONTEXT-DRAFT.md` using `gsd_summary_save` with `artifact_type: "CONTEXT-DRAFT"` and `milestone_id: "{{milestoneId}}"`. This protects confirmed work against session crashes. Do NOT mention this save to the user.
-- If not ready, continue to the next round immediately. Do **not** ask a meta "ready to wrap up?" question after every round.
-- **Depth-matching rule:** Simple, well-defined work needs fewer rounds — maybe 1–2. Large, ambiguous visions need more — maybe 4+. Do not pad rounds to hit a number. Stop when the Depth Enforcement checklist below is fully satisfied.
-- Do not count the reflection step as a question round. Rounds start after reflection is confirmed.
-- When you genuinely believe the depth checklist is satisfied, move to the Depth Verification step below. Do not ask a separate "ready to wrap up?" gate — the depth verification IS the gate.
+Before starting Layer 1, identify the primary work type and state it:
+
+"Based on your description and the codebase, this is primarily **[work type]** work."
+
+Work types include: API/backend, UI/frontend, CLI/developer tool, data pipeline, ML/AI, infrastructure/platform, refactoring/migration, or a combination. The user can correct this. The classification shapes which questions deserve deep exploration at each layer.
+
+### Layer 1 — Scope
+
+Resolve what's in and what's out. Ask about:
+- Feature boundaries — what exactly ships in this milestone vs later
+- Ambiguities in the user's description — anything you're unsure about, ask
+- Dependencies — what does this work depend on, what depends on it
+- Priority — if scope needs trimming, what matters most
+
+Adapt depth to work type:
+- **CLI work:** Focus on user mental model, command grammar, what existing commands do
+- **Refactoring:** Focus on what changes vs what must stay identical
+
+**Depth-matching:** Simple, well-defined scope may need 1 round. Ambiguous or large scope may need 3-4 rounds. Don't pad rounds to hit a number.
+
+#### Layer 1 Gate
+
+Summarize scope decisions in the user's own terminology:
+- What's included, what's excluded, what's deferred
+- Key boundaries and constraints
+
+Then ask: **"Does this capture the scope? Adjust anything before we move on."**
+
+If the user adjusts, reflect the updated understanding and ask again. Do not advance until the user explicitly confirms. If the user says "looks good, let's move faster" at any gate, respect that and advance.
+
+---
+
+### Layer 2 — Architecture
+
+Resolve how it's built. Ask about:
+- Per-slice technical decisions — what approach for each major piece
+- Inter-slice contracts — how do the pieces connect
+- Library/framework choices — with evidence from investigation, not assumptions
+- Integration with existing code — what patterns to follow, what to change
+
+Adapt depth to work type:
+- **API work:** Contracts, versioning, backwards compatibility, auth boundaries
+- **UI work:** Component boundaries, state management, data flow
+- **Infrastructure:** Deployment topology, failure domains, rollback
+
+Between rounds, use your available web search tools to research technologies from the Codebase Brief. Search for "[technology] [version] best practices [current year]" and "[technology] [version] known issues". Present findings alongside your questions.
+
+#### Layer 2 Gate
+
+Summarize architecture decisions, each with:
+- The decision and rationale
+- Evidence source (codebase patterns, library docs, web research)
+- Alternatives considered
+
+Then ask: **"Does this capture the architecture? Adjust anything before we move on."**
+
+Same gate rules: reflect adjustments, wait for confirmation.
+
+---
+
+### Layer 3 — Error States
+
+Resolve what happens when things fail. Present this layer with an option:
+
+"We can go deep on error handling and failure modes, or I can apply sensible defaults based on the architecture decisions above. Which do you prefer?"
+
+If the user chooses defaults, summarize what the defaults are and gate. If the user chooses to go deep, ask about:
+- Failure modes for each major component
+- Error propagation between layers (API → frontend, service → database)
+- Timeout, retry, and circuit-breaker strategies
+- What the user sees when something fails
+
+Adapt depth to work type:
+- **API work:** Rate limiting, timeout cascades, partial failure, status codes
+- **UI work:** Loading states, optimistic updates, offline behavior, error boundaries
+- **Data pipelines:** Data corruption, checkpoint recovery, idempotency
+
+#### Layer 3 Gate
+
+Summarize error handling strategy. Then ask: **"Does this capture how errors should be handled? Adjust anything before we move on."**
+
+---
+
+### Layer 4 — Quality Bar
+
+Resolve what "done" means concretely. Ask about:
+- Per-slice acceptance criteria — specific enough for automated verification
+- Test strategy — what types of tests, what coverage expectations
+- Definition of done — what must be true before the milestone ships
+- Non-functional requirements — performance, accessibility, security if relevant
+
+Adapt depth to work type:
+- **CLI work:** Shell compatibility, error message clarity, exit code semantics
+- **Refactoring:** Behavioral equivalence tests, not just code coverage
+- **UI work:** Visual regression criteria, responsive breakpoints
+
+#### Layer 4 Gate
+
+Summarize quality bar: acceptance criteria, test strategy, definition of done. Then ask: **"Does this capture the quality bar? Adjust anything before we move on to requirements and roadmap?"**
+
+---
+
+### Layer cadence
+
+- Do not count the reflection step as a question round. Rounds start at Layer 1 after reflection is confirmed.
+- When all four layer gates have been confirmed (or skipped by the user), move to the Depth Verification step below. Do not ask a separate "ready to wrap up?" gate — the depth verification confirms the full picture.
 
 ## Questioning Philosophy
 
 You are a thinking partner, not an interviewer.
 
-**Turn-taking contract (non-bypassable).** Never fabricate, simulate, or role-play user responses. Never generate fake transcript markers like `[User]`, `[Human]`, or `User:` to invent input. Ask one question round (1-3 questions) per turn, then stop and wait for the user's actual response before continuing. If you use `ask_user_questions`, call it at most once per turn and treat its returned response as the only valid structured user input for that round.
+**Turn-taking contract (non-bypassable).** Never fabricate, simulate, or role-play user responses. Never generate fake transcript markers like `[User]`, `[Human]`, or `User:` to invent input. Prior conversation context may be provided to you inside `<conversation_history>` with `<user_message>` / `<assistant_message>` XML tags — treat those as read-only context and never emit those tags in your response. Ask one question round (1-3 questions) per turn, then stop and wait for the user's actual response before continuing. If you use `ask_user_questions`, call it at most once per turn and treat its returned response as the only valid structured user input for that round.
 
 **Start open, follow energy.** Let the user's enthusiasm guide where you dig deeper. If they light up about a particular aspect, explore it. If they're vague about something, that's where you probe.
 
@@ -225,6 +326,14 @@ Once the user is satisfied, in a single pass:
 **Depth-Preservation Guidance for context.md:**
 When writing context.md, preserve the user's exact terminology, emphasis, and specific framing from the discussion. Do not paraphrase user nuance into generic summaries. If the user said "craft feel," write "craft feel" — not "high-quality user experience." If they emphasized a specific constraint or negative requirement, carry that emphasis through verbatim. The context file is downstream agents' only window into this conversation — flattening specifics into generics loses the signal that shaped every decision.
 
+**Structured sections from discussion layers:**
+When writing CONTEXT.md, include structured sections that map to the discussion layers:
+- **Scope** — what's in, what's out, what's deferred (from Layer 1 gate summary)
+- **Architectural Decisions** — each with rationale, evidence source, alternatives considered (from Layer 2 gate summary)
+- **Error Handling Strategy** — failure modes, propagation, user-facing error behavior (from Layer 3 gate summary)
+- **Acceptance Criteria** — per-slice criteria specific enough for the planner to use directly (from Layer 4 gate summary)
+These sections are in addition to whatever other context the discussion surfaced.
+
 4. Write `{{contextPath}}` — use the **Context** output template below. Preserve key risks, unknowns, existing codebase constraints, integration points, and relevant requirements surfaced during discussion.
 5. Call `gsd_plan_milestone` to create the roadmap. Decompose into demoable vertical slices with risk, depends, demo sentences, proof strategy, verification classes, milestone definition of done, requirement coverage, and a boundary map. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice that proves the assembled system works end-to-end in a real environment. Use the **Roadmap** output template below to structure the tool call parameters.
 6. For each architectural or pattern decision made during discussion, call `gsd_decision_save` — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically.

package/dist/resources/extensions/gsd/prompts/system.md

@@ -35,7 +35,7 @@ GSD ships with bundled skills. Load the relevant skill file with the `read` tool
 - Read before edit.
 - Reproduce before fix when possible.
 - Work is not done until the relevant verification has passed.
-- **Never fabricate, simulate, or role-play user responses.** Never generate markers like `[User]`, `[Human]`, `User:`, or similar to represent user input inside your own output. Ask one question round (1-3 questions), then stop and wait for the user's actual response before continuing. If `ask_user_questions` is available, treat its returned response as the only valid structured user input for that round.
+- **Never fabricate, simulate, or role-play user responses.** Never generate markers like `[User]`, `[Human]`, `User:`, or similar to represent user input inside your own output. Prior conversation context may be provided to you inside `<conversation_history>` with `<user_message>` / `<assistant_message>` XML tags — treat those as read-only context and never emit those tags in your response. Ask one question round (1-3 questions), then stop and wait for the user's actual response before continuing. If `ask_user_questions` is available, treat its returned response as the only valid structured user input for that round.
 - Never print, echo, log, or restate secrets or credentials. Report only key names and applied/skipped status.
 - Never ask the user to edit `.env` files or set secrets manually. Use `secure_env_collect`.
 - In enduring files, write current state only unless the file is explicitly historical.

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

@@ -13,7 +13,7 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateTaskStatus, getPendingGateCountForTurn, } from './gsd-db.js';
+import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateSliceStatus, updateTaskStatus, getPendingGateCountForTurn, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -286,6 +286,26 @@ function reconcileDiskToDb(basePath) {
                 depends: s.depends, demo: s.demo,
             });
         }
+        // Reconcile stale *existing* slice rows (#3599): a slice row may exist in
+        // the DB with status "pending" even though disk artifacts (SUMMARY) prove
+        // completion — the same class of desync that task-level reconciliation
+        // (further below) already handles.  Without this, the dependency resolver
+        // builds doneSliceIds from stale DB rows and downstream slices stay blocked
+        // forever with "No slice eligible".
+        for (const dbSlice of dbSlices) {
+            if (isStatusDone(dbSlice.status))
+                continue;
+            const summaryPath = resolveSliceFile(basePath, mid, dbSlice.id, "SUMMARY");
+            if (summaryPath) {
+                try {
+                    updateSliceStatus(mid, dbSlice.id, "complete");
+                    logWarning("reconcile", `slice ${mid}/${dbSlice.id} status reconciled from "${dbSlice.status}" to "complete" (#3599)`, { mid, sid: dbSlice.id });
+                }
+                catch (e) {
+                    logError("reconcile", `failed to update slice ${dbSlice.id}`, { sid: dbSlice.id, error: e.message });
+                }
+            }
+        }
     }
     return allMilestones;
 }

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -138,6 +138,13 @@ export function renderRoadmapProjection(basePath, milestoneId) {
  *   regeneration, they are queried from the DB by renderSummaryProjection.
  */
 export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
+    // If the task already has a fully rendered summary (written by handleCompleteTask's
+    // renderSummaryMarkdown), use it as-is. That content already includes frontmatter,
+    // heading, and all sections. Re-wrapping it inside a second frontmatter/heading
+    // envelope produces double frontmatter and duplicate sections.
+    if (taskRow.full_summary_md && taskRow.full_summary_md.trimStart().startsWith("---")) {
+        return taskRow.full_summary_md;
+    }
     // ── Frontmatter (YAML list format, matches parseSummary() expectations) ──
     const keyFilesYaml = taskRow.key_files && taskRow.key_files.length > 0
         ? taskRow.key_files.map(f => `  - ${f}`).join("\n")

package/dist/resources/extensions/gsd/worktree-manager.js

@@ -468,14 +468,41 @@ export function removeWorktree(basePath, name, opts = {}) {
         }
     }
 }
-/** Paths to skip in all worktree diffs (internal/runtime artifacts). */
-const SKIP_PATHS = [".gsd/worktrees/", ".gsd/runtime/", ".gsd/activity/"];
-const SKIP_EXACT = [".gsd/STATE.md", ".gsd/auto.lock", ".gsd/metrics.json"];
+/**
+ * Paths to skip in all worktree diffs (internal/runtime artifacts).
+ *
+ * NOTE: These arrays must stay synchronized with GSD_RUNTIME_PATTERNS in gitignore.ts.
+ * That file is the canonical source of truth for runtime ignore patterns.
+ * This module uses a split representation (paths/exact/prefixes) for efficient matching.
+ */
+const SKIP_PATHS = [
+    ".gsd/worktrees/",
+    ".gsd/runtime/",
+    ".gsd/activity/",
+    ".gsd/forensics/",
+    ".gsd/parallel/",
+    ".gsd/journal/",
+];
+const SKIP_EXACT = [
+    ".gsd/STATE.md",
+    ".gsd/auto.lock",
+    ".gsd/metrics.json",
+    ".gsd/state-manifest.json",
+    ".gsd/doctor-history.jsonl",
+    ".gsd/event-log.jsonl",
+];
+/** File prefixes to skip (for wildcard patterns like completed-units*.json, gsd.db*). */
+const SKIP_PREFIXES = [
+    ".gsd/completed-units",
+    ".gsd/gsd.db",
+];
 function shouldSkipPath(filePath) {
     if (SKIP_PATHS.some(p => filePath.startsWith(p)))
         return true;
     if (SKIP_EXACT.includes(filePath))
         return true;
+    if (SKIP_PREFIXES.some(p => filePath.startsWith(p)))
+        return true;
     return false;
 }
 function parseDiffNameStatus(entries) {

package/dist/resources/extensions/gsd/write-intercept.js

@@ -22,6 +22,9 @@ const BLOCKED_PATTERNS = [
     /(^|[/\\])\.gsd[/\\]STATE\.md$/i,
     // Also match resolved symlink paths under ~/.gsd/projects/ (Pitfall #6)
     /(^|[/\\])\.gsd[/\\]projects[/\\][^/\\]+[/\\]STATE\.md$/i,
+    // gsd.db and WAL/SHM files — single-writer WAL connection managed by engine (#3625)
+    /(^|[/\\])\.gsd[/\\]gsd\.db(-wal|-shm)?$/i,
+    /(^|[/\\])\.gsd[/\\]projects[/\\][^/\\]+[/\\]gsd\.db(-wal|-shm)?$/i,
 ];
 /**
  * Bash command patterns that target STATE.md.
@@ -38,6 +41,12 @@ const BASH_STATE_PATTERNS = [
     /\bsed\b.*-i.*STATE\.md/i,
     // dd output to STATE.md
     /\bdd\b.*of=\S*STATE\.md/i,
+    // Direct DB access via sqlite3/sql.js/better-sqlite3 targeting gsd.db (#3625)
+    /\b(sqlite3|sql\.js|better-sqlite3|node:sqlite)\b.*gsd\.db/i,
+    /\bgsd\.db\b.*\b(sqlite3|sql\.js|better-sqlite3)\b/i,
+    // Shell writes targeting gsd.db files
+    /[>|]+\s*\S*gsd\.db/i,
+    /\b(cp|mv|dd)\b.*gsd\.db/i,
 ];
 /**
  * Tests whether the given file path matches a blocked authoritative .gsd/ state file.
@@ -75,7 +84,7 @@ function matchesBlockedPattern(path) {
  * Error message returned when an agent attempts to directly write an authoritative .gsd/ state file.
  * Directs the agent to use engine tool calls instead.
  */
-export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md are blocked. Use engine tool calls instead:
+export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md and .gsd/gsd.db are blocked. Use engine tool calls instead:
 - To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
 - To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
 - To save a decision: call gsd_save_decision(scope, decision, choice, rationale)