gsd-pi 2.63.0 → 2.64.0-dev.9c14bd0

package/dist/resources/extensions/gsd/bootstrap/query-tools.js

@@ -0,0 +1,85 @@
+// GSD2 — Read-only query tools exposing DB state to the LLM via the WAL connection
+import { Type } from "@sinclair/typebox";
+import { logWarning } from "../workflow-logger.js";
+export function registerQueryTools(pi) {
+    pi.registerTool({
+        name: "gsd_milestone_status",
+        label: "Milestone Status",
+        description: "Read the current status of a milestone and all its slices from the GSD database. " +
+            "Returns milestone metadata, per-slice status, and task counts per slice. " +
+            "Use this instead of querying .gsd/gsd.db directly via sqlite3 or better-sqlite3.",
+        promptSnippet: "Get milestone status, slice statuses, and task counts for a given milestoneId",
+        promptGuidelines: [
+            "Use this tool — not sqlite3 or better-sqlite3 — to inspect milestone or slice state from the DB.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID to query (e.g. M001)" }),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            try {
+                // Strictly read-only: only use an already-open DB connection.
+                // Do NOT call ensureDbOpen() — it can create/migrate the DB as a side effect.
+                const { isDbAvailable, getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, } = await import("../gsd-db.js");
+                if (!isDbAvailable()) {
+                    return {
+                        content: [{ type: "text", text: "Error: GSD database is not available." }],
+                        details: { operation: "milestone_status", error: "db_unavailable" },
+                    };
+                }
+                // Wrap all reads in a single transaction for snapshot consistency.
+                // SQLite WAL mode guarantees reads within a transaction see a single
+                // consistent snapshot, preventing torn reads from concurrent writes.
+                const adapter = _getAdapter();
+                adapter.exec("BEGIN"); // eslint-disable-line -- SQLite exec, not child_process
+                try {
+                    const milestone = getMilestone(params.milestoneId);
+                    if (!milestone) {
+                        adapter.exec("COMMIT"); // eslint-disable-line
+                        return {
+                            content: [{ type: "text", text: `Milestone ${params.milestoneId} not found in database.` }],
+                            details: { operation: "milestone_status", milestoneId: params.milestoneId, found: false },
+                        };
+                    }
+                    const sliceStatuses = getSliceStatusSummary(params.milestoneId);
+                    const slices = sliceStatuses.map((s) => {
+                        const counts = getSliceTaskCounts(params.milestoneId, s.id);
+                        return {
+                            id: s.id,
+                            status: s.status,
+                            taskCounts: counts,
+                        };
+                    });
+                    adapter.exec("COMMIT"); // eslint-disable-line
+                    const result = {
+                        milestoneId: milestone.id,
+                        title: milestone.title,
+                        status: milestone.status,
+                        createdAt: milestone.created_at,
+                        completedAt: milestone.completed_at,
+                        sliceCount: slices.length,
+                        slices,
+                    };
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                        details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
+                    };
+                }
+                catch (txErr) {
+                    try {
+                        adapter.exec("ROLLBACK");
+                    }
+                    catch { /* swallow */ } // eslint-disable-line
+                    throw txErr;
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logWarning("tool", `gsd_milestone_status tool failed: ${msg}`);
+                return {
+                    content: [{ type: "text", text: `Error querying milestone status: ${msg}` }],
+                    details: { operation: "milestone_status", error: msg },
+                };
+            }
+        },
+    });
+}

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

@@ -1,9 +1,11 @@
+// GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
 import { registerGSDCommand } from "../commands.js";
 import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
+import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 export function handleRecoverableExtensionProcessError(err) {
@@ -48,6 +50,7 @@ export function registerGsdExtension(pi) {
     registerDynamicTools(pi);
     registerDbTools(pi);
     registerJournalTools(pi);
+    registerQueryTools(pi);
     registerShortcuts(pi);
     registerHooks(pi);
 }

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

@@ -10,11 +10,14 @@ import { getDiscussionMilestoneId } from "../guided-flow.js";
 import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
 import { deriveState } from "../state.js";
-import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart } from "../auto.js";
+import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto.js";
 import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
 import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
+import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult } from "../safety/evidence-collector.js";
+import { classifyCommand } from "../safety/destructive-guard.js";
+import { logWarning as safetyLogWarning } from "../workflow-logger.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
@@ -187,6 +190,22 @@ export function registerHooks(pi) {
         if (result.block)
             return result;
     });
+    // ── Safety harness: evidence collection + destructive command warnings ──
+    pi.on("tool_call", async (event, ctx) => {
+        if (!isAutoActive())
+            return;
+        safetyRecordToolCall(event.toolName, event.input);
+        // Destructive command classification (warn only, never block)
+        if (isToolCallEventType("bash", event)) {
+            const classification = classifyCommand(event.input.command);
+            if (classification.destructive) {
+                safetyLogWarning("safety", `destructive command: ${classification.labels.join(", ")}`, {
+                    command: String(event.input.command).slice(0, 200),
+                });
+                ctx.ui.notify(`Destructive command detected: ${classification.labels.join(", ")}`, "warning");
+            }
+        }
+    });
     pi.on("tool_result", async (event) => {
         if (event.toolName !== "ask_user_questions")
             return;
@@ -243,6 +262,18 @@ export function registerHooks(pi) {
     });
     pi.on("tool_execution_end", async (event) => {
         markToolEnd(event.toolCallId);
+        // #2883: Capture tool invocation errors (malformed/truncated JSON arguments)
+        // so postUnitPreVerification can break the retry loop instead of re-dispatching.
+        if (event.isError && event.toolName.startsWith("gsd_")) {
+            const errorText = typeof event.result === "string"
+                ? event.result
+                : (typeof event.result?.content?.[0]?.text === "string" ? event.result.content[0].text : String(event.result));
+            recordToolInvocationError(event.toolName, errorText);
+        }
+        // Safety harness: record tool execution results for evidence cross-referencing
+        if (isAutoActive()) {
+            safetyRecordToolResult(event.toolCallId, event.toolName, event.result, event.isError);
+        }
     });
     pi.on("model_select", async (_event, ctx) => {
         await syncServiceTierStatus(ctx);

package/dist/resources/extensions/gsd/bootstrap/sanitize-complete-milestone.js

@@ -0,0 +1,54 @@
+/**
+ * Input sanitization for gsd_complete_milestone parameters.
+ *
+ * The Claude SDK deserializes tool-call JSON before the handler runs.
+ * When an LLM (especially smaller models like haiku) generates large markdown
+ * parameters, the JSON can arrive with subtly wrong types — numbers where
+ * strings are expected, null where arrays belong, string "true" instead of
+ * boolean true, etc.  This sanitizer normalizes all fields so
+ * handleCompleteMilestone never crashes on type mismatches.
+ *
+ * See: https://github.com/gsd-build/gsd-2/issues/3013
+ */
+/**
+ * Coerce an unknown value to a trimmed string.
+ * Returns "" for null / undefined.
+ */
+function toStr(v) {
+    if (v == null)
+        return "";
+    return String(v).trim();
+}
+/**
+ * Coerce an unknown value to an array of trimmed, non-empty strings.
+ * - If already an array, filter/trim each element.
+ * - Otherwise return [].
+ */
+function toStrArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v
+        .map((item) => (item == null ? "" : String(item).trim()))
+        .filter((s) => s.length > 0);
+}
+/**
+ * Sanitize raw params from the tool-call framework into well-typed
+ * CompleteMilestoneParams, tolerating type mismatches from LLM JSON quirks.
+ */
+export function sanitizeCompleteMilestoneParams(raw) {
+    return {
+        milestoneId: toStr(raw.milestoneId),
+        title: toStr(raw.title),
+        oneLiner: toStr(raw.oneLiner),
+        narrative: toStr(raw.narrative),
+        successCriteriaResults: toStr(raw.successCriteriaResults),
+        definitionOfDoneResults: toStr(raw.definitionOfDoneResults),
+        requirementOutcomes: toStr(raw.requirementOutcomes),
+        keyDecisions: toStrArray(raw.keyDecisions),
+        keyFiles: toStrArray(raw.keyFiles),
+        lessonsLearned: toStrArray(raw.lessonsLearned),
+        followUps: toStr(raw.followUps),
+        deviations: toStr(raw.deviations),
+        verificationPassed: raw.verificationPassed === true || raw.verificationPassed === "true",
+    };
+}

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -3,9 +3,10 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { logWarning } from "../workflow-logger.js";
 import { debugTime } from "../debug-logger.js";
-import { loadPrompt } from "../prompt-loader.js";
+import { loadPrompt, getTemplatesDir } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
 import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
+import { resolveSkillReference } from "../preferences-skills.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
 import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
@@ -15,6 +16,30 @@ import { formatOverridesSection, loadActiveOverrides, loadFile, parseContinue, p
 import { toPosixPath } from "../../shared/mod.js";
 import { markCmuxPromptShown, shouldPromptToEnableCmux } from "../../cmux/index.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+/**
+ * Bundled skill triggers — resolved dynamically at runtime instead of
+ * hardcoding absolute paths in the system prompt template. Only skills
+ * that actually exist on disk are included in the table. (#3575)
+ */
+const BUNDLED_SKILL_TRIGGERS = [
+    { trigger: "Frontend UI - web components, pages, landing pages, dashboards, React/HTML/CSS, styling", skill: "frontend-design" },
+    { trigger: "macOS or iOS apps - SwiftUI, Xcode, App Store", skill: "swiftui" },
+    { trigger: "Debugging - complex bugs, failing tests, root-cause investigation after standard approaches fail", skill: "debug-like-expert" },
+];
+function buildBundledSkillsTable() {
+    const cwd = process.cwd();
+    const rows = [];
+    for (const { trigger, skill } of BUNDLED_SKILL_TRIGGERS) {
+        const resolution = resolveSkillReference(skill, cwd);
+        if (resolution.method === "unresolved")
+            continue; // skill not installed — omit from prompt
+        rows.push(`| ${trigger} | \`${resolution.resolvedPath}\` |`);
+    }
+    if (rows.length === 0) {
+        return "*No bundled skills found. Install skills to `~/.agents/skills/` or `~/.claude/skills/`.*";
+    }
+    return `| Trigger | Skill to load |\n|---|---|\n${rows.join("\n")}`;
+}
 function warnDeprecatedAgentInstructions() {
     const paths = [
         join(gsdHome, "agent-instructions.md"),
@@ -32,7 +57,10 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     if (!existsSync(join(process.cwd(), ".gsd")))
         return undefined;
     const stopContextTimer = debugTime("context-inject");
-    const systemContent = loadPrompt("system");
+    const systemContent = loadPrompt("system", {
+        bundledSkillsTable: buildBundledSkillsTable(),
+        templatesDir: getTemplatesDir(),
+    });
     const loadedPreferences = loadEffectiveGSDPreferences();
     if (shouldPromptToEnableCmux(loadedPreferences?.preferences)) {
         markCmuxPromptShown();

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -27,21 +27,26 @@ export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
     const content = `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${prompt}`;
     pi.sendMessage({ customType: "gsd-doctor-heal", content, display: false }, { triggerTurn: true });
 }
-export async function handleDoctor(args, ctx, pi) {
+/** Parse doctor command args into structured flags and positionals (pure, no I/O). */
+export function parseDoctorArgs(args) {
     const trimmed = args.trim();
-    // Extract flags before positional parsing
     const jsonMode = trimmed.includes("--json");
     const dryRun = trimmed.includes("--dry-run");
+    const fixFlag = trimmed.includes("--fix");
     const includeBuild = trimmed.includes("--build");
     const includeTests = trimmed.includes("--test");
-    const stripped = trimmed.replace(/--json|--dry-run|--build|--test/g, "").trim();
+    const stripped = trimmed.replace(/--json|--dry-run|--build|--test|--fix/g, "").trim();
     const parts = stripped ? stripped.split(/\s+/) : [];
     const mode = parts[0] === "fix" || parts[0] === "heal" || parts[0] === "audit" ? parts[0] : "doctor";
     const requestedScope = mode === "doctor" ? parts[0] : parts[1];
+    return { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope };
+}
+export async function handleDoctor(args, ctx, pi) {
+    const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
     const effectiveScope = mode === "audit" ? requestedScope : scope;
     const report = await runGSDDoctor(projectRoot(), {
-        fix: mode === "fix" || mode === "heal" || dryRun,
+        fix: mode === "fix" || mode === "heal" || dryRun || fixFlag,
         dryRun,
         scope: effectiveScope,
         includeBuild,

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

@@ -13,3 +13,45 @@ export const DEFAULT_BASH_TIMEOUT_SECS = 120;
 export const DIR_CACHE_MAX = 200;
 /** Max parse-cache entries before eviction. */
 export const CACHE_MAX = 50;
+// ─── Tool Scoping ─────────────────────────────────────────────────────────────
+/**
+ * GSD tools allowed during discuss flows (#2949).
+ *
+ * xAI/Grok (and potentially other providers with grammar-based constrained
+ * decoding) return "Grammar is too complex" (HTTP 400) when the combined
+ * tool schemas exceed their internal grammar limit. The full GSD tool set
+ * registers ~33 tools with deeply nested schemas; discuss flows only need
+ * a small subset.
+ *
+ * By scoping tools to this allowlist during discuss dispatches, the grammar
+ * sent to the provider stays well under provider limits.
+ *
+ * Included tools and why:
+ *   - gsd_summary_save: writes CONTEXT.md artifacts (all discuss prompts)
+ *   - gsd_save_summary: alias for above
+ *   - gsd_decision_save: records decisions (discuss.md output phase)
+ *   - gsd_save_decision: alias for above
+ *   - gsd_plan_milestone: writes roadmap (discuss.md single/multi milestone)
+ *   - gsd_milestone_plan: alias for above
+ *   - gsd_milestone_generate_id: generates milestone IDs (discuss.md multi-milestone)
+ *   - gsd_generate_milestone_id: alias for above
+ *   - gsd_requirement_update: updates requirements during discuss
+ *   - gsd_update_requirement: alias for above
+ */
+export const DISCUSS_TOOLS_ALLOWLIST = [
+    // Context / summary writing
+    "gsd_summary_save",
+    "gsd_save_summary",
+    // Decision recording
+    "gsd_decision_save",
+    "gsd_save_decision",
+    // Milestone planning (needed for discuss.md output phase)
+    "gsd_plan_milestone",
+    "gsd_milestone_plan",
+    // Milestone ID generation (multi-milestone flow)
+    "gsd_milestone_generate_id",
+    "gsd_generate_milestone_id",
+    // Requirement updates
+    "gsd_requirement_update",
+    "gsd_update_requirement",
+];

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

@@ -402,6 +402,23 @@ export async function saveDecisionToDb(fields, basePath) {
             adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
             throw diskErr;
         }
+        // #2661: When a decision defers a slice, update the slice status in the DB
+        // so the dispatcher skips it. Without this, STATE.md and DECISIONS.md are
+        // in split-brain: the decision says "deferred" but the state still says
+        // "active", causing auto-mode to keep dispatching the deferred work.
+        try {
+            const sliceRef = extractDeferredSliceRef(fields);
+            if (sliceRef) {
+                db.updateSliceStatus(sliceRef.milestoneId, sliceRef.sliceId, 'deferred');
+            }
+        }
+        catch (deferErr) {
+            // Non-fatal — log but don't fail the decision save
+            logError('manifest', 'failed to update deferred slice status', {
+                fn: 'saveDecisionToDb',
+                error: String(deferErr.message),
+            });
+        }
         // Invalidate file-read caches so deriveState() sees the updated markdown.
         // Do NOT clear the artifacts table — we just wrote to it intentionally.
         invalidateStateCache();
@@ -414,6 +431,33 @@ export async function saveDecisionToDb(fields, basePath) {
         throw err;
     }
 }
+/**
+ * Extract a milestone/slice reference from a deferral decision.
+ *
+ * Detects deferrals by checking:
+ *   - scope contains "defer" (e.g., "deferral", "defer")
+ *   - choice or decision contains "defer" + an M###/S## pattern
+ *
+ * Returns { milestoneId, sliceId } if found, null otherwise.
+ */
+export function extractDeferredSliceRef(fields) {
+    const isDeferral = /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.scope) ||
+        /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.choice) ||
+        /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.decision);
+    if (!isDeferral)
+        return null;
+    // Look for M###/S## pattern in choice first, then decision
+    const slicePattern = /\b(M\d{3,4})\/(S\d{2,3})\b/;
+    const choiceMatch = fields.choice.match(slicePattern);
+    if (choiceMatch) {
+        return { milestoneId: choiceMatch[1], sliceId: choiceMatch[2] };
+    }
+    const decisionMatch = fields.decision.match(slicePattern);
+    if (decisionMatch) {
+        return { milestoneId: decisionMatch[1], sliceId: decisionMatch[2] };
+    }
+    return null;
+}
 // ─── Update Requirement in DB + Regenerate Markdown ───────────────────────
 /**
  * Update a requirement in DB and regenerate REQUIREMENTS.md.
@@ -422,10 +466,34 @@ export async function saveDecisionToDb(fields, basePath) {
 export async function updateRequirementInDb(id, updates, basePath) {
     try {
         const db = await import('./gsd-db.js');
-        const existing = db.getRequirementById(id);
-        // If requirement doesn't exist in DB, create a skeleton and merge updates.
-        // This handles the case where requirements were written to REQUIREMENTS.md
-        // but never imported into the database (see #2919).
+        let existing = db.getRequirementById(id);
+        // If requirement doesn't exist in DB, seed the entire requirements table
+        // from REQUIREMENTS.md first (#3346). This handles the standard workflow
+        // where requirements are authored in markdown during discussion but never
+        // imported into the database — making gsd_requirement_update always fail
+        // with "not_found" at milestone completion.
+        if (!existing) {
+            const reqFilePath = resolveGsdRootFile(basePath, 'REQUIREMENTS');
+            try {
+                const content = readFileSync(reqFilePath, 'utf-8');
+                const { parseRequirementsSections } = await import('./md-importer.js');
+                const parsed = parseRequirementsSections(content);
+                if (parsed.length > 0) {
+                    logWarning('manifest', `Seeding ${parsed.length} requirements from REQUIREMENTS.md into DB (first update triggers import)`, { fn: 'updateRequirementInDb' });
+                    for (const req of parsed) {
+                        // Only seed if not already in DB (avoid overwriting concurrent inserts)
+                        if (!db.getRequirementById(req.id)) {
+                            db.upsertRequirement(req);
+                        }
+                    }
+                    // Re-check after seeding
+                    existing = db.getRequirementById(id);
+                }
+            }
+            catch {
+                // REQUIREMENTS.md missing or unparseable — fall through to skeleton
+            }
+        }
         const base = existing ?? {
             id,
             class: '',

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

@@ -498,13 +498,29 @@ function getDbCompletionCounts() {
     };
 }
 // ─── Anomaly Detectors ───────────────────────────────────────────────────────
-function detectStuckLoops(units, anomalies) {
-    const counts = new Map();
+/**
+ * Detect units that were dispatched multiple times (stuck in a loop).
+ *
+ * Counts distinct dispatches by grouping on (type, id, startedAt) first to
+ * collapse idle-watchdog duplicate snapshots (#1943), then counts unique
+ * startedAt values per type/id to determine actual dispatch count.
+ *
+ * Exported for testability.
+ */
+export function detectStuckLoops(units, anomalies) {
+    // First, collect unique startedAt values per type/id key
+    const dispatchMap = new Map();
     for (const u of units) {
         const key = `${u.type}/${u.id}`;
-        counts.set(key, (counts.get(key) ?? 0) + 1);
+        let starts = dispatchMap.get(key);
+        if (!starts) {
+            starts = new Set();
+            dispatchMap.set(key, starts);
+        }
+        starts.add(u.startedAt);
     }
-    for (const [key, count] of counts) {
+    for (const [key, starts] of dispatchMap) {
+        const count = starts.size;
         if (count > 1) {
             const [unitType, ...idParts] = key.split("/");
             anomalies.push({

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

@@ -1023,11 +1023,12 @@ export function insertMilestone(m) {
         ":boundary_map_markdown": m.planning?.boundaryMapMarkdown ?? "",
     });
 }
-export function upsertMilestonePlanning(milestoneId, planning, title) {
+export function upsertMilestonePlanning(milestoneId, planning) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE milestones SET
-      title = COALESCE(:title, title),
+      title = COALESCE(NULLIF(:title, ''), title),
+      status = COALESCE(NULLIF(:status, ''), status),
       vision = COALESCE(:vision, vision),
       success_criteria = COALESCE(:success_criteria, success_criteria),
       key_risks = COALESCE(:key_risks, key_risks),
@@ -1041,7 +1042,8 @@ export function upsertMilestonePlanning(milestoneId, planning, title) {
       boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
      WHERE id = :id`).run({
         ":id": milestoneId,
-        ":title": title ?? null,
+        ":title": planning.title ?? "",
+        ":status": planning.status ?? "",
         ":vision": planning.vision ?? null,
         ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
         ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
@@ -1058,13 +1060,25 @@ export function upsertMilestonePlanning(milestoneId, planning, title) {
 export function insertSlice(s) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb.prepare(`INSERT OR IGNORE INTO slices (
+    currentDb.prepare(`INSERT INTO slices (
       milestone_id, id, title, status, risk, depends, demo, created_at,
       goal, success_criteria, proof_level, integration_closure, observability_impact, sequence
     ) VALUES (
       :milestone_id, :id, :title, :status, :risk, :depends, :demo, :created_at,
       :goal, :success_criteria, :proof_level, :integration_closure, :observability_impact, :sequence
-    )`).run({
+    )
+    ON CONFLICT (milestone_id, id) DO UPDATE SET
+      title = CASE WHEN :raw_title IS NOT NULL THEN excluded.title ELSE slices.title END,
+      status = CASE WHEN slices.status IN ('complete', 'done') THEN slices.status ELSE excluded.status END,
+      risk = CASE WHEN :raw_risk IS NOT NULL THEN excluded.risk ELSE slices.risk END,
+      depends = excluded.depends,
+      demo = CASE WHEN :raw_demo IS NOT NULL THEN excluded.demo ELSE slices.demo END,
+      goal = CASE WHEN :raw_goal IS NOT NULL THEN excluded.goal ELSE slices.goal END,
+      success_criteria = CASE WHEN :raw_success_criteria IS NOT NULL THEN excluded.success_criteria ELSE slices.success_criteria END,
+      proof_level = CASE WHEN :raw_proof_level IS NOT NULL THEN excluded.proof_level ELSE slices.proof_level END,
+      integration_closure = CASE WHEN :raw_integration_closure IS NOT NULL THEN excluded.integration_closure ELSE slices.integration_closure END,
+      observability_impact = CASE WHEN :raw_observability_impact IS NOT NULL THEN excluded.observability_impact ELSE slices.observability_impact END,
+      sequence = CASE WHEN :raw_sequence IS NOT NULL THEN excluded.sequence ELSE slices.sequence END`).run({
         ":milestone_id": s.milestoneId,
         ":id": s.id,
         ":title": s.title ?? "",
@@ -1079,6 +1093,16 @@ export function insertSlice(s) {
         ":integration_closure": s.planning?.integrationClosure ?? "",
         ":observability_impact": s.planning?.observabilityImpact ?? "",
         ":sequence": s.sequence ?? 0,
+        // Raw sentinel params: NULL when caller omitted the field, used in ON CONFLICT guards
+        ":raw_title": s.title ?? null,
+        ":raw_risk": s.risk ?? null,
+        ":raw_demo": s.demo ?? null,
+        ":raw_goal": s.planning?.goal ?? null,
+        ":raw_success_criteria": s.planning?.successCriteria ?? null,
+        ":raw_proof_level": s.planning?.proofLevel ?? null,
+        ":raw_integration_closure": s.planning?.integrationClosure ?? null,
+        ":raw_observability_impact": s.planning?.observabilityImpact ?? null,
+        ":raw_sequence": s.sequence ?? null,
     });
 }
 export function upsertSlicePlanning(milestoneId, sliceId, planning) {
@@ -1574,19 +1598,31 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
                  definition_of_done, requirement_coverage, boundary_map_markdown
           FROM wt.milestones
         `).run());
-                // Merge slices — preserve worktree progress (status, summaries, planning)
+                // Merge slices — preserve worktree progress but never downgrade completed status (#2558).
+                // Uses INSERT OR REPLACE with a subquery that picks the best status — if the main DB
+                // already has a completed slice, keep that status even if the worktree copy is stale.
                 merged.slices = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO slices (
             milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
             full_summary_md, full_uat_md, goal, success_criteria, proof_level,
             integration_closure, observability_impact, sequence, replan_triggered_at
           )
-          SELECT milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
-                 full_summary_md, full_uat_md, goal, success_criteria, proof_level,
-                 integration_closure, observability_impact, sequence, replan_triggered_at
-          FROM wt.slices
+          SELECT w.milestone_id, w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.risk, w.depends, w.demo, w.created_at,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.full_summary_md, w.full_uat_md, w.goal, w.success_criteria, w.proof_level,
+                 w.integration_closure, w.observability_impact, w.sequence, w.replan_triggered_at
+          FROM wt.slices w
+          LEFT JOIN slices m ON m.milestone_id = w.milestone_id AND m.id = w.id
         `).run());
-                // Merge tasks — preserve execution results, status, summaries
+                // Merge tasks — preserve execution results, never downgrade completed status (#2558)
                 merged.tasks = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO tasks (
             milestone_id, slice_id, id, title, status, one_liner, narrative,
@@ -1595,12 +1631,23 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             description, estimate, files, verify, inputs, expected_output,
             observability_impact, full_plan_md, sequence
           )
-          SELECT milestone_id, slice_id, id, title, status, one_liner, narrative,
-                 verification_result, duration, completed_at, blocker_discovered,
-                 deviations, known_issues, key_files, key_decisions, full_summary_md,
-                 description, estimate, files, verify, inputs, expected_output,
-                 observability_impact, full_plan_md, sequence
-          FROM wt.tasks
+          SELECT w.milestone_id, w.slice_id, w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.one_liner, w.narrative,
+                 w.verification_result, w.duration,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.blocker_discovered,
+                 w.deviations, w.known_issues, w.key_files, w.key_decisions, w.full_summary_md,
+                 w.description, w.estimate, w.files, w.verify, w.inputs, w.expected_output,
+                 w.observability_impact, w.full_plan_md, w.sequence
+          FROM wt.tasks w
+          LEFT JOIN tasks m ON m.milestone_id = w.milestone_id AND m.slice_id = w.slice_id AND m.id = w.id
         `).run());
                 // Merge memories — keep worktree-learned insights
                 merged.memories = countChanges(adapter.prepare(`