gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

package/dist/resources/extensions/gsd/prompts/workflow-oneshot.md

@@ -0,0 +1,26 @@
+# Oneshot Workflow: {{displayName}}
+
+You are running a **oneshot** workflow called `{{name}}`. Oneshot workflows are
+prompt-only — there is no STATE.json, no phase tracking, no artifact directory,
+and no resume mechanism. Just execute the instructions below and return.
+
+## User Arguments
+
+`{{userArgs}}`
+
+(If empty, use sensible defaults from the workflow body.)
+
+## Workflow Instructions
+
+{{body}}
+
+## Execution Rules
+
+1. **No scaffolding.** Do not create `.gsd/workflows/` directories, STATE.json
+   files, or run directories unless the instructions explicitly tell you to
+   write a specific artifact.
+2. **No branch switching.** Work on the current branch.
+3. **Be concise.** Oneshot workflows produce a single focused output (a report,
+   a summary, a code change, a PR comment) — finish in this turn.
+4. **Ask only when blocked.** If the instructions need information you can't
+   discover, ask one clear question. Otherwise proceed.

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

@@ -15,8 +15,9 @@
 import { mkdirSync, writeFileSync, existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { stringify } from "yaml";
-import { loadDefinition, substituteParams } from "./definition-loader.js";
+import { loadDefinition, loadDefinitionFromFile, substituteParams } from "./definition-loader.js";
 import { initializeGraph, writeGraph, readGraph } from "./graph.js";
+import { resolvePlugin } from "./workflow-plugins.js";
 // ─── Constants ───────────────────────────────────────────────────────────
 const RUNS_DIR = "workflow-runs";
 const DEFS_DIR = "workflow-defs";
@@ -42,38 +43,57 @@ function deriveStatus(graph) {
     return "pending";
 }
 // ─── Public API ──────────────────────────────────────────────────────────
+/**
+ * Create a run directory from an explicit definition file path.
+ * Preferred over `createRun` when the caller has already resolved the file
+ * (e.g. via the plugin resolver).
+ */
+export function createRunFromDefinition(basePath, defName, definitionFile, overrides) {
+    const rawDef = loadDefinitionFromFile(definitionFile);
+    const def = overrides
+        ? substituteParams(rawDef, overrides)
+        : substituteParams(rawDef);
+    const timestamp = makeTimestamp();
+    const runDir = join(basePath, ".gsd", RUNS_DIR, defName, timestamp);
+    mkdirSync(runDir, { recursive: true });
+    writeFileSync(join(runDir, "DEFINITION.yaml"), stringify(def), "utf-8");
+    const graph = initializeGraph(def);
+    writeGraph(runDir, graph);
+    if (overrides && Object.keys(overrides).length > 0) {
+        writeFileSync(join(runDir, "PARAMS.json"), JSON.stringify(overrides, null, 2), "utf-8");
+    }
+    return runDir;
+}
 /**
  * Create a new isolated run directory for a workflow definition.
  *
- * 1. Loads the definition from `<basePath>/.gsd/workflow-defs/<defName>.yaml`
- * 2. Applies parameter substitution if overrides are provided
- * 3. Creates `<basePath>/.gsd/workflow-runs/<defName>/<timestamp>/`
- * 4. Writes frozen DEFINITION.yaml, initialized GRAPH.yaml, and optional PARAMS.json
+ * Resolution order:
+ *   1. Plugin resolver (project → global → bundled), YAML format only.
+ *   2. Legacy `.gsd/workflow-defs/<defName>.yaml`.
  *
- * @param basePath — project root directory
- * @param defName — definition filename (without .yaml extension)
- * @param overrides — optional parameter overrides (merged with definition defaults)
- * @returns Full path to the created run directory
- * @throws Error if the definition file doesn't exist or is invalid
+ * Creates `<basePath>/.gsd/workflow-runs/<defName>/<timestamp>/` containing
+ * DEFINITION.yaml (frozen), GRAPH.yaml (initialized), and optional PARAMS.json.
+ *
+ * @throws Error if no matching definition is found anywhere.
  */
 export function createRun(basePath, defName, overrides) {
+    // Try the unified plugin resolver first — honors project/global overrides.
+    const plugin = resolvePlugin(basePath, defName);
+    if (plugin && plugin.format === "yaml") {
+        return createRunFromDefinition(basePath, defName, plugin.path, overrides);
+    }
+    // Fall back to legacy `.gsd/workflow-defs/<defName>.yaml`.
     const defsDir = join(basePath, ".gsd", DEFS_DIR);
-    // Load and validate the definition
     const rawDef = loadDefinition(defsDir, defName);
-    // Apply parameter substitution if overrides provided
     const def = overrides
         ? substituteParams(rawDef, overrides)
-        : substituteParams(rawDef); // still resolve default params if any
-    // Create the run directory
+        : substituteParams(rawDef);
     const timestamp = makeTimestamp();
     const runDir = join(basePath, ".gsd", RUNS_DIR, defName, timestamp);
     mkdirSync(runDir, { recursive: true });
-    // Freeze the definition as DEFINITION.yaml
     writeFileSync(join(runDir, "DEFINITION.yaml"), stringify(def), "utf-8");
-    // Initialize and write GRAPH.yaml
     const graph = initializeGraph(def);
     writeGraph(runDir, graph);
-    // Write PARAMS.json if overrides were provided
     if (overrides && Object.keys(overrides).length > 0) {
         writeFileSync(join(runDir, "PARAMS.json"), JSON.stringify(overrides, null, 2), "utf-8");
     }

package/dist/resources/extensions/gsd/safety/evidence-collector.js

@@ -32,11 +32,11 @@ export function getFilePaths() {
  * Record a tool call at dispatch time (before execution).
  * Exit codes and output are filled in by recordToolResult after execution.
  */
-export function recordToolCall(toolName, input) {
+export function recordToolCall(toolCallId, toolName, input) {
     if (toolName === "bash" || toolName === "Bash") {
         unitEvidence.push({
             kind: "bash",
-            toolCallId: "",
+            toolCallId,
             command: String(input.command ?? ""),
             exitCode: -1,
             outputSnippet: "",
@@ -46,7 +46,7 @@ export function recordToolCall(toolName, input) {
     else if (toolName === "write" || toolName === "Write") {
         unitEvidence.push({
             kind: "write",
-            toolCallId: "",
+            toolCallId,
             path: String(input.file_path ?? input.path ?? ""),
             timestamp: Date.now(),
         });
@@ -54,44 +54,29 @@ export function recordToolCall(toolName, input) {
     else if (toolName === "edit" || toolName === "Edit") {
         unitEvidence.push({
             kind: "edit",
-            toolCallId: "",
+            toolCallId,
             path: String(input.file_path ?? input.path ?? ""),
             timestamp: Date.now(),
         });
     }
 }
 /**
- * Record a tool execution result. Matches the most recent unresolved entry
- * of the same kind and fills in the toolCallId, exit code, and output.
+ * Record a tool execution result. Matches the entry by toolCallId (assigned
+ * at dispatch time) and fills in exit code + output. Prior versions matched
+ * by `kind + empty-string` which corrupted parallel tool calls.
  */
 export function recordToolResult(toolCallId, toolName, result, isError) {
-    const normalizedName = toolName.toLowerCase();
-    if (normalizedName === "bash") {
-        const entry = findLastUnresolved("bash");
-        if (entry) {
-            entry.toolCallId = toolCallId;
-            const text = extractResultText(result);
-            entry.outputSnippet = text.slice(0, 500);
-            const exitMatch = text.match(/Command exited with code (\d+)/);
-            entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
-        }
-    }
-    else if (normalizedName === "write" || normalizedName === "edit") {
-        const entry = findLastUnresolved(normalizedName);
-        if (entry) {
-            entry.toolCallId = toolCallId;
-        }
+    const entry = unitEvidence.find(e => e.toolCallId === toolCallId);
+    if (!entry)
+        return;
+    if (entry.kind === "bash") {
+        const text = extractResultText(result);
+        entry.outputSnippet = text.slice(0, 500);
+        const exitMatch = text.match(/Command exited with code (\d+)/);
+        entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
     }
 }
 // ─── Internals ──────────────────────────────────────────────────────────────
-function findLastUnresolved(kind) {
-    for (let i = unitEvidence.length - 1; i >= 0; i--) {
-        if (unitEvidence[i].kind === kind && unitEvidence[i].toolCallId === "") {
-            return unitEvidence[i];
-        }
-    }
-    return undefined;
-}
 function extractResultText(result) {
     if (typeof result === "string")
         return result;

package/dist/resources/extensions/gsd/slice-parallel-orchestrator.js

@@ -21,6 +21,7 @@ import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager
 import { writeSessionStatus, } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";
 import { getErrorMessage } from "./error-utils.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 let sliceState = null;
 // ─── Public API ────────────────────────────────────────────────────────────
@@ -62,7 +63,7 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
     const started = [];
     const errors = [];
     // Filter out conflicting slices (conservative: check all pairs)
-    const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices);
+    const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices, opts.useExecutionGraph === true);
     // Limit to maxWorkers
     const toSpawn = safeSlices.slice(0, maxWorkers);
     for (const slice of toSpawn) {
@@ -176,7 +177,16 @@ export function resetSliceOrchestrator() {
  * Greedy: add slices to the safe set in order; skip any that conflict
  * with an already-included slice.
  */
-function filterConflictingSlices(basePath, milestoneId, slices) {
+function filterConflictingSlices(basePath, milestoneId, slices, useExecutionGraph) {
+    if (useExecutionGraph) {
+        const selectedIds = selectConflictFreeBatch({
+            orderedIds: slices.map((slice) => slice.id),
+            maxParallel: slices.length,
+            hasConflict: (candidate, existing) => hasFileConflict(basePath, milestoneId, candidate, existing),
+        });
+        const selected = new Set(selectedIds);
+        return slices.filter((slice) => selected.has(slice.id));
+    }
     const safe = [];
     for (const candidate of slices) {
         let conflictsWithSafe = false;

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

@@ -13,7 +13,9 @@ 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, updateSliceStatus, updateTaskStatus, getPendingGateCountForTurn, } from './gsd-db.js';
+import { loadEffectiveGSDPreferences } from './preferences.js';
+import { detectPendingEscalation } from './escalation.js';
+import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateSliceStatus, updateTaskStatus, getPendingGateCountForTurn, autoHealSketchFlags, } 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
@@ -271,7 +273,11 @@ function reconcileDiskToDb(basePath) {
         try {
             roadmapContent = readFileSync(roadmapPath, "utf-8");
         }
-        catch {
+        catch (err) {
+            logWarning("state", "reconcileDiskToDb: roadmap read failed, skipping milestone", {
+                mid,
+                error: err.message,
+            });
             continue;
         }
         const parsed = parseRoadmap(roadmapContent);
@@ -706,7 +712,13 @@ export async function deriveStateFromDb(basePath) {
     if (allSlicesDone) {
         return handleAllSlicesDone(basePath, activeMilestone, registry, requirements, milestoneProgress, sliceProgress);
     }
-    const activeSliceContext = resolveSliceDependencies(activeMilestoneSlices);
+    // ADR-011 auto-heal: if a slice has a PLAN on disk but is still flagged is_sketch=1
+    // (e.g. a crash between plan-slice write and the sketch flip), reconcile before
+    // running phase derivation so the flag doesn't misroute state.
+    autoHealSketchFlags(activeMilestone.id, (sid) => !!resolveSliceFile(basePath, activeMilestone.id, sid, "PLAN"));
+    // Re-read slices after auto-heal so downstream reads see fresh is_sketch values.
+    const healedSlices = getMilestoneSlices(activeMilestone.id);
+    const activeSliceContext = resolveSliceDependencies(healedSlices);
     if (!activeSliceContext.activeSlice) {
         // If locked slice wasn't found, it returns null but logs warning, we need to return 'blocked'
         if (process.env.GSD_SLICE_LOCK) {
@@ -726,9 +738,23 @@ export async function deriveStateFromDb(basePath) {
             progress: { milestones: milestoneProgress, slices: sliceProgress },
         };
     }
-    const { activeSlice } = activeSliceContext;
+    const { activeSlice, activeSliceRow } = activeSliceContext;
     const planFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "PLAN");
     if (!planFile) {
+        // ADR-011: sketch slices with progressive_planning enabled enter the
+        // `refining` phase — a refine-slice unit expands the sketch into a full plan
+        // before execution. When the flag is off, sketches are indistinguishable
+        // from a missing plan and fall through to the normal `planning` phase.
+        const progressive = loadEffectiveGSDPreferences()?.preferences?.phases?.progressive_planning === true;
+        if (progressive && activeSliceRow?.is_sketch === 1) {
+            return {
+                activeMilestone, activeSlice, activeTask: null,
+                phase: 'refining', recentDecisions: [], blockers: [],
+                nextAction: `Refine sketch slice ${activeSlice.id} (${activeSlice.title}) using prior slice context.`,
+                registry, requirements,
+                progress: { milestones: milestoneProgress, slices: sliceProgress },
+            };
+        }
         return {
             activeMilestone, activeSlice, activeTask: null,
             phase: 'planning', recentDecisions: [], blockers: [],
@@ -807,6 +833,28 @@ export async function deriveStateFromDb(basePath) {
             };
         }
     }
+    // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
+    // next task. `awaiting_review` tasks (continueWithDefault=true) are NOT
+    // surfaced here — they let the loop continue.
+    //
+    // We do NOT gate this on `phases.mid_execution_escalation` — creation of
+    // new escalations is gated at the write site (tools/complete-task.ts:315),
+    // but any escalation_pending row already persisted in the DB must be
+    // honored even if the user later toggles the flag off. Otherwise those
+    // rows would silently orphan, the loop would advance past the paused task,
+    // and the user's prior resolution never lands.
+    const escalatingTaskId = detectPendingEscalation(tasks, basePath);
+    if (escalatingTaskId) {
+        return {
+            activeMilestone, activeSlice, activeTask,
+            phase: 'escalating-task', recentDecisions: [],
+            blockers: [`Task ${escalatingTaskId} requires a user decision before the loop can proceed`],
+            nextAction: `Run /gsd escalate show ${escalatingTaskId} to review, then /gsd escalate resolve ${escalatingTaskId} <choice> to proceed.`,
+            activeWorkspace: undefined,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+        };
+    }
     if (!blockerTaskId) {
         const isTriggered = checkReplanTrigger(basePath, activeMilestone.id, activeSlice.id);
         if (isTriggered) {

package/dist/resources/extensions/gsd/templates/PREFERENCES.md

@@ -39,6 +39,24 @@ dynamic_routing:
   budget_pressure:
   cross_provider:
   hooks:
+uok:
+  enabled: true
+  legacy_fallback:
+    enabled: false
+  gates:
+    enabled: true
+  model_policy:
+    enabled: true
+  execution_graph:
+    enabled: true
+  gitops:
+    enabled: true
+    turn_action: commit
+    turn_push: false
+  audit_unified:
+    enabled: true
+  plan_v2:
+    enabled: true
 auto_visualize:
 auto_report:
 parallel:
@@ -71,6 +89,7 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# language:
 # experimental:
 #   rtk: false
 ---

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -354,6 +354,26 @@ export async function handleCompleteSlice(params, basePath) {
     catch (eventErr) {
         logError("tool", `complete-slice event log FAILED — completion invisible to reconciliation`, { error: eventErr.message });
     }
+    // Fire-and-forget graph rebuild — must NOT await, must NOT crash slice completion.
+    // Dynamic import of the package name (not a relative path) so it resolves
+    // correctly via package.json#exports in both development and production.
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    (async () => {
+        try {
+            const graphMod = await import("@gsd-build/mcp-server");
+            if (typeof graphMod.buildGraph !== "function"
+                || typeof graphMod.writeGraph !== "function"
+                || typeof graphMod.resolveGsdRoot !== "function") {
+                throw new Error("graph helpers unavailable from @gsd-build/mcp-server");
+            }
+            const g = await graphMod.buildGraph(basePath);
+            await graphMod.writeGraph(graphMod.resolveGsdRoot(basePath), g);
+        }
+        catch (graphErr) {
+            // Graph rebuild is best-effort — log at warning level but never propagate
+            logWarning("tool", `complete-slice graph rebuild failed (non-fatal): ${graphErr.message ?? String(graphErr)}`);
+        }
+    })();
     return {
         sliceId: params.sliceId,
         milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -20,6 +20,8 @@ import { renderAllProjections, renderSummaryContent } from "../workflow-projecti
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { buildEscalationArtifact, writeEscalationArtifact } from "../escalation.js";
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose
  * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
@@ -80,6 +82,11 @@ function paramsToTaskRow(params, completedAt) {
         observability_impact: "",
         full_plan_md: "",
         sequence: 0,
+        blocker_source: "",
+        escalation_pending: 0,
+        escalation_awaiting_review: 0,
+        escalation_artifact_path: null,
+        escalation_override_applied_at: null,
     };
 }
 /**
@@ -111,6 +118,39 @@ export async function handleCompleteTask(params, basePath) {
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
     let guardError = null;
+    // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
+    // Building the artifact runs the full shape validation (2-4 options, unique
+    // ids, recommendation references a real id). If the payload is malformed
+    // we must reject the call before marking the task complete, writing
+    // SUMMARY.md, flipping the plan checkbox, or closing execute-task gates —
+    // otherwise a rejected payload would leave the task marked complete with
+    // no escalation recorded, and the loop would silently advance past it.
+    // The filesystem write happens later (after side effects) because that's
+    // the cheapest ordering and validation is where 99% of failures live.
+    let validatedEscalationArtifact = null;
+    let escalationWriteEnabled = false;
+    if (params.escalation) {
+        escalationWriteEnabled = loadEffectiveGSDPreferences()?.preferences?.phases?.mid_execution_escalation === true;
+        if (escalationWriteEnabled) {
+            try {
+                validatedEscalationArtifact = buildEscalationArtifact({
+                    taskId: params.taskId,
+                    sliceId: params.sliceId,
+                    milestoneId: params.milestoneId,
+                    question: params.escalation.question,
+                    options: params.escalation.options,
+                    recommendation: params.escalation.recommendation,
+                    recommendationRationale: params.escalation.recommendationRationale,
+                    continueWithDefault: params.escalation.continueWithDefault,
+                });
+            }
+            catch (validationErr) {
+                return {
+                    error: `complete-task escalation payload invalid for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${validationErr.message}`,
+                };
+            }
+        }
+    }
     transaction(() => {
         // State machine preconditions (inside txn for atomicity).
         // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
@@ -239,6 +279,46 @@ export async function handleCompleteTask(params, basePath) {
     catch (gateErr) {
         logWarning("tool", `complete-task gate close warning for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${gateErr.message}`);
     }
+    // ── ADR-011 Phase 2: write escalation artifact (opt-in) ────────────────
+    // Validation already happened BEFORE side effects — this block only
+    // performs the disk write for a pre-validated artifact. For
+    // continueWithDefault=false, a write failure here would otherwise leave
+    // the task marked complete with SUMMARY.md + closed gates but no
+    // escalation, which silently advances the loop past a pause the user
+    // asked for. We compensate by reverting the DB-level completion: set
+    // status back to 'pending' and delete the verification_evidence rows
+    // (same shape as the disk-render-failure rollback above). SUMMARY.md
+    // on disk is left in place because the next complete-task retry will
+    // overwrite it; gate rows are UPSERT-keyed per task and will also be
+    // overwritten. This restores the invariant that deriveState() sees a
+    // consistent "task not done" view so the loop re-dispatches the task.
+    if (validatedEscalationArtifact) {
+        try {
+            writeEscalationArtifact(basePath, validatedEscalationArtifact);
+        }
+        catch (escalationErr) {
+            const msg = `complete-task escalation write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${escalationErr.message}`;
+            logWarning("tool", msg);
+            if (validatedEscalationArtifact.continueWithDefault === false) {
+                // Compensating rollback: revert DB completion so the loop pauses on
+                // re-dispatch instead of silently advancing. Mirror the existing
+                // renderErr rollback (line ~261).
+                try {
+                    deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
+                    updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+                    invalidateStateCache();
+                    logWarning("tool", `complete-task rolled back DB completion for ${params.milestoneId}/${params.sliceId}/${params.taskId} after escalation write failure; SUMMARY.md left on disk for retry.`);
+                }
+                catch (rollbackErr) {
+                    logWarning("tool", `complete-task rollback failed after escalation write failure for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${rollbackErr.message}`);
+                }
+                return { error: msg };
+            }
+        }
+    }
+    else if (params.escalation && !escalationWriteEnabled) {
+        logWarning("tool", `complete-task received escalation payload but phases.mid_execution_escalation is not enabled; ignoring (${params.milestoneId}/${params.sliceId}/${params.taskId})`);
+    }
     // Invalidate all caches
     invalidateStateCache();
     clearPathCache();

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -61,6 +61,15 @@ function validateSlices(value) {
         const proofLevel = obj.proofLevel;
         const integrationClosure = obj.integrationClosure;
         const observabilityImpact = obj.observabilityImpact;
+        const isSketchRaw = obj.isSketch;
+        const sketchScopeRaw = obj.sketchScope;
+        // ADR-011: preserve the 3-valued semantics of isSketch (true / false / absent).
+        // Callers that omit isSketch must receive `undefined` here so `insertSlice`'s
+        // ON CONFLICT clause preserves any existing is_sketch on the row rather than
+        // silently overwriting a legitimate sketch to non-sketch.
+        const isSketch = isSketchRaw === true ? true
+            : isSketchRaw === false ? false
+                : undefined;
         if (!isNonEmptyString(sliceId))
             throw new Error(`slices[${index}].sliceId must be a non-empty string`);
         if (seen.has(sliceId))
@@ -77,14 +86,22 @@ function validateSlices(value) {
             throw new Error(`slices[${index}].demo must be a non-empty string`);
         if (!isNonEmptyString(goal))
             throw new Error(`slices[${index}].goal must be a non-empty string`);
-        if (!isNonEmptyString(successCriteria))
-            throw new Error(`slices[${index}].successCriteria must be a non-empty string`);
-        if (!isNonEmptyString(proofLevel))
-            throw new Error(`slices[${index}].proofLevel must be a non-empty string`);
-        if (!isNonEmptyString(integrationClosure))
-            throw new Error(`slices[${index}].integrationClosure must be a non-empty string`);
-        if (!isNonEmptyString(observabilityImpact))
-            throw new Error(`slices[${index}].observabilityImpact must be a non-empty string`);
+        // ADR-011: sketch slices may defer the heavyweight planning fields to refine-slice.
+        if (isSketch === true) {
+            if (!isNonEmptyString(sketchScopeRaw)) {
+                throw new Error(`slices[${index}].sketchScope must be a non-empty string when isSketch is true`);
+            }
+        }
+        else {
+            if (!isNonEmptyString(successCriteria))
+                throw new Error(`slices[${index}].successCriteria must be a non-empty string`);
+            if (!isNonEmptyString(proofLevel))
+                throw new Error(`slices[${index}].proofLevel must be a non-empty string`);
+            if (!isNonEmptyString(integrationClosure))
+                throw new Error(`slices[${index}].integrationClosure must be a non-empty string`);
+            if (!isNonEmptyString(observabilityImpact))
+                throw new Error(`slices[${index}].observabilityImpact must be a non-empty string`);
+        }
         return {
             sliceId,
             title,
@@ -92,10 +109,14 @@ function validateSlices(value) {
             depends,
             demo,
             goal,
-            successCriteria,
-            proofLevel,
-            integrationClosure,
-            observabilityImpact,
+            successCriteria: isNonEmptyString(successCriteria) ? successCriteria : "",
+            proofLevel: isNonEmptyString(proofLevel) ? proofLevel : "",
+            integrationClosure: isNonEmptyString(integrationClosure) ? integrationClosure : "",
+            observabilityImpact: isNonEmptyString(observabilityImpact) ? observabilityImpact : "",
+            isSketch,
+            // Only carry the sketch scope through if the caller explicitly provided it
+            // — preserves ON CONFLICT semantics for re-plans that omit the field.
+            sketchScope: sketchScopeRaw === undefined ? undefined : (isNonEmptyString(sketchScopeRaw) ? sketchScopeRaw : ""),
         };
     });
 }
@@ -209,6 +230,10 @@ export async function handlePlanMilestone(rawParams, basePath) {
                     depends: slice.depends,
                     demo: slice.demo,
                     sequence: i + 1, // Preserve agent-ordered sequence (#3356)
+                    // ADR-011: pass undefined through so ON CONFLICT preserves existing values
+                    // when the caller omitted the fields on a re-plan.
+                    isSketch: slice.isSketch,
+                    sketchScope: slice.sketchScope,
                 });
                 upsertSlicePlanning(params.milestoneId, slice.sliceId, {
                     goal: slice.goal,

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -1,7 +1,7 @@
 import { clearParseCache } from "../files.js";
-import { isClosedStatus } from "../status-guards.js";
+import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, } from "../gsd-db.js";
+import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -114,6 +114,9 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first`;
                 return;
             }
+            if (isDeferredStatus(parentSlice.status)) {
+                updateSliceStatus(params.milestoneId, params.sliceId, "pending");
+            }
             upsertSlicePlanning(params.milestoneId, params.sliceId, {
                 goal: params.goal,
                 successCriteria: params.successCriteria,