gsd-pi 2.82.0-dev.ed17d078d → 3.0.0

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

@@ -1,7 +1,9 @@
+import { existsSync, rmSync } from "node:fs";
+import { join, relative } from "node:path";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
-import { isNonEmptyString } from "../validation.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, } from "../gsd-db.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
+import { transaction, getMilestone, getSlice, getSliceTasks, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, setSliceSketchFlag, deleteTask, deleteArtifactByPath, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -9,6 +11,8 @@ import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { validatePlanningPathScope } from "../planning-path-scope.js";
+import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
+import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -39,17 +43,11 @@ function validateTasks(value) {
             throw new Error(`tasks[${index}].description must be a non-empty string`);
         if (!isNonEmptyString(estimate))
             throw new Error(`tasks[${index}].estimate must be a non-empty string`);
-        if (!Array.isArray(files) || files.some((item) => !isNonEmptyString(item))) {
-            throw new Error(`tasks[${index}].files must be an array of non-empty strings`);
-        }
+        const validatedFiles = validateStringArray(files, `tasks[${index}].files`);
         if (!isNonEmptyString(verify))
             throw new Error(`tasks[${index}].verify must be a non-empty string`);
-        if (!Array.isArray(inputs) || inputs.some((item) => !isNonEmptyString(item))) {
-            throw new Error(`tasks[${index}].inputs must be an array of non-empty strings`);
-        }
-        if (!Array.isArray(expectedOutput) || expectedOutput.some((item) => !isNonEmptyString(item))) {
-            throw new Error(`tasks[${index}].expectedOutput must be an array of non-empty strings`);
-        }
+        const validatedInputs = validateStringArray(inputs, `tasks[${index}].inputs`);
+        const validatedExpectedOutput = validateStringArray(expectedOutput, `tasks[${index}].expectedOutput`);
         if (observabilityImpact !== undefined && !isNonEmptyString(observabilityImpact)) {
             throw new Error(`tasks[${index}].observabilityImpact must be a non-empty string when provided`);
         }
@@ -58,10 +56,10 @@ function validateTasks(value) {
             title,
             description,
             estimate,
-            files,
+            files: validatedFiles,
             verify,
-            inputs,
-            expectedOutput,
+            inputs: validatedInputs,
+            expectedOutput: validatedExpectedOutput,
             observabilityImpact: typeof observabilityImpact === "string" ? observabilityImpact : "",
         };
     });
@@ -84,6 +82,53 @@ function validateParams(params) {
         tasks: validateTasks(params.tasks),
     };
 }
+function toTaskRows(params) {
+    return params.tasks.map((task, index) => ({
+        milestone_id: params.milestoneId,
+        slice_id: params.sliceId,
+        id: task.taskId,
+        title: task.title,
+        status: "pending",
+        one_liner: "",
+        narrative: "",
+        verification_result: "",
+        duration: "",
+        completed_at: null,
+        blocker_discovered: false,
+        deviations: "",
+        known_issues: "",
+        key_files: [],
+        key_decisions: [],
+        full_summary_md: "",
+        description: task.description,
+        estimate: task.estimate,
+        files: task.files,
+        verify: task.verify,
+        inputs: task.inputs,
+        expected_output: task.expectedOutput,
+        observability_impact: task.observabilityImpact ?? "",
+        full_plan_md: task.fullPlanMd ?? "",
+        sequence: index + 1,
+        blocker_source: "",
+        escalation_pending: 0,
+        escalation_awaiting_review: 0,
+        escalation_artifact_path: null,
+        escalation_override_applied_at: null,
+    }));
+}
+function validateTaskPathsBeforePersist(params, basePath) {
+    const taskRows = toTaskRows(params);
+    const checks = [
+        ...checkFilePathConsistency(taskRows, basePath),
+        ...checkTaskOrdering(taskRows, basePath),
+    ];
+    const blocking = checks.filter((check) => !check.passed && check.blocking);
+    if (blocking.length === 0)
+        return null;
+    return blocking
+        .map((check) => `[${check.category}] ${check.target}: ${check.message}`)
+        .join("\n");
+}
 export async function handlePlanSlice(rawParams, basePath) {
     let params;
     try {
@@ -100,10 +145,15 @@ export async function handlePlanSlice(rawParams, basePath) {
     if (pathScopeError) {
         return { error: `validation failed: ${pathScopeError}` };
     }
+    const pathError = validateTaskPathsBeforePersist(params, basePath);
+    if (pathError) {
+        return { error: `pre-execution validation failed:\n${pathError}` };
+    }
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     // Guards must be inside the transaction so the state they check cannot
     // change between the read and the write (#2723).
     let guardError = null;
+    let omittedTaskIds = [];
     try {
         transaction(() => {
             const parentMilestone = getMilestone(params.milestoneId);
@@ -124,9 +174,21 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first`;
                 return;
             }
+            const newTaskIds = new Set(params.tasks.map((task) => task.taskId));
+            const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
+            omittedTaskIds = existingTasks
+                .filter((task) => !newTaskIds.has(task.id))
+                .map((task) => task.id);
+            for (const task of existingTasks) {
+                if (!newTaskIds.has(task.id) && isClosedStatus(task.status)) {
+                    guardError = `cannot remove completed task ${task.id}`;
+                    return;
+                }
+            }
             if (isDeferredStatus(parentSlice.status)) {
                 updateSliceStatus(params.milestoneId, params.sliceId, "pending");
             }
+            setSliceSketchFlag(params.milestoneId, params.sliceId, false);
             upsertSlicePlanning(params.milestoneId, params.sliceId, {
                 goal: params.goal,
                 successCriteria: params.successCriteria,
@@ -134,6 +196,9 @@ export async function handlePlanSlice(rawParams, basePath) {
                 integrationClosure: params.integrationClosure,
                 observabilityImpact: params.observabilityImpact,
             });
+            for (const taskId of omittedTaskIds) {
+                deleteTask(params.milestoneId, params.sliceId, taskId);
+            }
             for (const task of params.tasks) {
                 insertTask({
                     id: task.taskId,
@@ -176,6 +241,14 @@ export async function handlePlanSlice(rawParams, basePath) {
         return { error: guardError };
     }
     try {
+        const tasksDir = join(gsdProjectionRoot(basePath), "milestones", params.milestoneId, "slices", params.sliceId, "tasks");
+        for (const taskId of omittedTaskIds) {
+            const taskPlanPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
+            if (existsSync(taskPlanPath))
+                rmSync(taskPlanPath, { force: true });
+            const artifactPath = relative(gsdProjectionRoot(basePath), taskPlanPath).replace(/\\/g, "/");
+            deleteArtifactByPath(artifactPath);
+        }
         const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
         invalidateStateCache();
         clearParseCache();

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Adapts shared GSD workflow handlers for MCP executor calls.
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
@@ -12,6 +14,9 @@ import { handleCompleteSlice } from "./complete-slice.js";
 import { handlePlanMilestone } from "./plan-milestone.js";
 import { handlePlanSlice } from "./plan-slice.js";
 import { handleReplanSlice } from "./replan-slice.js";
+import { handleReopenMilestone } from "./reopen-milestone.js";
+import { handleReopenSlice } from "./reopen-slice.js";
+import { handleReopenTask } from "./reopen-task.js";
 import { handleReassessRoadmap } from "./reassess-roadmap.js";
 import { handleValidateMilestone } from "./validate-milestone.js";
 import { logError, logWarning } from "../workflow-logger.js";
@@ -274,6 +279,120 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         };
     }
 }
+export async function executeTaskReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen task." }],
+            details: { operation: "reopen_task", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenTask(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening task: ${result.error}` }],
+                details: { operation: "reopen_task", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened task ${result.taskId} (${result.sliceId}/${result.milestoneId})` }],
+            details: {
+                operation: "reopen_task",
+                taskId: result.taskId,
+                sliceId: result.sliceId,
+                milestoneId: result.milestoneId,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_task tool failed: ${msg}`, { tool: "gsd_task_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening task: ${msg}` }],
+            details: { operation: "reopen_task", error: msg },
+            isError: true,
+        };
+    }
+}
+export async function executeSliceReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen slice." }],
+            details: { operation: "reopen_slice", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenSlice(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening slice: ${result.error}` }],
+                details: { operation: "reopen_slice", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened slice ${result.sliceId} (${result.milestoneId})` }],
+            details: {
+                operation: "reopen_slice",
+                sliceId: result.sliceId,
+                milestoneId: result.milestoneId,
+                tasksReset: result.tasksReset,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_slice tool failed: ${msg}`, { tool: "gsd_slice_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening slice: ${msg}` }],
+            details: { operation: "reopen_slice", error: msg },
+            isError: true,
+        };
+    }
+}
+export async function executeMilestoneReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen milestone." }],
+            details: { operation: "reopen_milestone", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenMilestone(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening milestone: ${result.error}` }],
+                details: { operation: "reopen_milestone", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened milestone ${result.milestoneId}` }],
+            details: {
+                operation: "reopen_milestone",
+                milestoneId: result.milestoneId,
+                slicesReset: result.slicesReset,
+                tasksReset: result.tasksReset,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_milestone tool failed: ${msg}`, { tool: "gsd_milestone_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening milestone: ${msg}` }],
+            details: { operation: "reopen_milestone", error: msg },
+            isError: true,
+        };
+    }
+}
 export async function executeSliceComplete(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -73,6 +73,7 @@ const COMMON_BUDGET_SMALL = 250_000; // ~65K tokens
 // allowed-path set for the docs policy lives in one reviewable place.
 const TOOLS_ALL = { mode: "all" };
 const TOOLS_PLANNING = { mode: "planning" };
+const TOOLS_VERIFICATION = { mode: "verification" };
 // Like TOOLS_PLANNING but permits dispatch to read-only recon/planning
 // specialists. Runtime-enforced by write-gate.ts before the subagent tool runs.
 const TOOLS_PLANNING_DISPATCH_RECON = {
@@ -187,8 +188,8 @@ export const UNIT_MANIFESTS = {
         contextMode: "verification",
         // planning-dispatch: validation is a verification-fan-out unit. It reads
         // the milestone surface and dispatches reviewer/security/tester subagents
-        // to report findings without touching user source. Mirrors
-        // complete-milestone's policy. Write isolation to .gsd/ is preserved.
+        // to report findings without touching user source. Write isolation to
+        // .gsd/ is preserved.
         tools: TOOLS_PLANNING_DISPATCH_REVIEW,
         artifacts: {
             inline: ["roadmap", "slice-summary", "slice-uat", "requirements", "decisions", "templates"],
@@ -204,11 +205,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        // planning-dispatch: completion is a high-leverage place to fan out to
-        // reviewer / security / tester subagents. They read the diff and report
-        // findings; they do not write user source. Write isolation to .gsd/ is
-        // preserved.
-        tools: TOOLS_PLANNING_DISPATCH_REVIEW,
+        // Milestone closeout must run unrestricted shell verification commands
+        // against the final diff before recording completion.
+        tools: TOOLS_ALL,
         artifacts: {
             // #4780 landed slice-summary as excerpt for this unit; phase 2 of
             // the architecture will read this manifest as the source of truth
@@ -227,7 +226,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: true,
         preferences: "active-only",
         contextMode: "research",
-        tools: TOOLS_PLANNING,
+        // Multi-slice research dispatches use the research-slice unit contract to
+        // fan out scout subagents that write .gsd research artifacts.
+        tools: TOOLS_PLANNING_DISPATCH_RECON,
         artifacts: {
             inline: ["roadmap", "milestone-research", "dependency-summaries", "templates"],
             excerpt: [],
@@ -365,7 +366,7 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        tools: TOOLS_PLANNING,
+        tools: TOOLS_VERIFICATION,
         artifacts: {
             // Phase 3 migration (#4782): manifest matches today's actual
             // buildRunUatPrompt inlining. Prior phase-1 entry listed
@@ -384,7 +385,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        tools: TOOLS_PLANNING,
+        // Gate evaluation fans out tester-style subagents, which read the slice
+        // plan and report via the DB-backed gate-result tool.
+        tools: TOOLS_PLANNING_DISPATCH_REVIEW,
         artifacts: {
             inline: ["slice-plan", "prior-task-summaries"],
             excerpt: [],
@@ -509,3 +512,22 @@ export const UNIT_MANIFESTS = {
 export function resolveManifest(unitType) {
     return UNIT_MANIFESTS[unitType] ?? null;
 }
+export function compileSubagentPermissionContract(policy) {
+    if (!policy) {
+        return { allowed: false, allowedSubagents: [], toolsMode: "unknown" };
+    }
+    if (policy.mode === "all") {
+        return { allowed: true, allowedSubagents: ["*"], toolsMode: policy.mode };
+    }
+    if (policy.mode === "planning-dispatch") {
+        return {
+            allowed: true,
+            allowedSubagents: [...policy.allowedSubagents],
+            toolsMode: policy.mode,
+        };
+    }
+    return { allowed: false, allowedSubagents: [], toolsMode: policy.mode };
+}
+export function resolveSubagentPermissionContract(unitType) {
+    return compileSubagentPermissionContract(resolveManifest(unitType)?.tools);
+}

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

@@ -5,6 +5,27 @@
 export function isNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
+/**
+ * Characters that are used as delimiters in GSD state management documents
+ * and should not appear in milestone or slice titles.
+ */
+const TITLE_DELIMITER_RE = /[\u2014\u2013\/]/; // em dash, en dash, forward slash
+/**
+ * Check whether a milestone or slice title contains characters that conflict
+ * with GSD's state document delimiter conventions.
+ * Returns a human-readable description of the problem, or null if the title is safe.
+ */
+export function validateTitle(title) {
+    if (TITLE_DELIMITER_RE.test(title)) {
+        const found = [];
+        if (/[\u2014\u2013]/.test(title))
+            found.push("em/en dash (\u2014 or \u2013)");
+        if (/\//.test(title))
+            found.push("forward slash (/)");
+        return `title contains ${found.join(" and ")}, which conflict with GSD state document delimiters`;
+    }
+    return null;
+}
 /**
  * Validate that `value` is an array of non-empty strings.
  * Throws with a message referencing `field` on failure.
@@ -12,7 +33,8 @@ export function isNonEmptyString(value) {
  */
 export function validateStringArray(value, field) {
     if (!Array.isArray(value)) {
-        throw new Error(`${field} must be an array`);
+        const received = value === null ? "null" : typeof value;
+        throw new Error(`${field} must be an array of strings, not ${received}`);
     }
     if (value.some((item) => !isNonEmptyString(item))) {
         throw new Error(`${field} must contain only non-empty strings`);

package/dist/resources/extensions/gsd/verification-gate.js

@@ -3,7 +3,7 @@
 // Discovery order (D003): preference → task plan verify → package.json scripts.
 // First non-empty source wins.
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { DEFAULT_COMMAND_TIMEOUT_MS } from "./constants.js";
 import { rewriteCommandWithRtk } from "../shared/rtk.js";
@@ -27,7 +27,8 @@ const PACKAGE_SCRIPT_KEYS = ["typecheck", "lint", "test"];
  *   1. Explicit preference commands
  *   2. Task plan verify field (split on &&)
  *   3. package.json scripts (typecheck, lint, test)
- *   4. None found
+ *   4. Python pytest project markers
+ *   5. None found
  */
 export function discoverCommands(options) {
     // 1. Preference commands
@@ -72,9 +73,57 @@ export function discoverCommands(options) {
             // Malformed package.json — fall through to "none"
         }
     }
-    // 4. Nothing found
+    const pythonCommand = discoverPythonPytestCommand(options.cwd);
+    if (pythonCommand) {
+        return { commands: [pythonCommand], source: "python-project" };
+    }
+    // 5. Nothing found
     return { commands: [], source: "none" };
 }
+function discoverPythonPytestCommand(cwd) {
+    const hasPythonTestFiles = hasPythonTests(join(cwd, "tests"));
+    const hasPytestConfig = existsSync(join(cwd, "pytest.ini"));
+    const pyprojectPath = join(cwd, "pyproject.toml");
+    const hasPyproject = existsSync(pyprojectPath);
+    if (!hasPythonTestFiles && !hasPytestConfig && !hasPyproject) {
+        return null;
+    }
+    if (hasPytestConfig || hasPythonTestFiles) {
+        return "python3 -m pytest";
+    }
+    try {
+        const pyproject = readFileSync(pyprojectPath, "utf-8");
+        if (pyproject.includes("[tool.pytest]") ||
+            pyproject.includes("[tool.pytest.") ||
+            pyproject.includes("[pytest]") ||
+            pyproject.includes("[tool:pytest]")) {
+            return "python3 -m pytest";
+        }
+    }
+    catch {
+        // Ignore unreadable pyproject.toml and fall through.
+    }
+    return null;
+}
+function hasPythonTests(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory() && hasPythonTests(path)) {
+            return true;
+        }
+        if (entry.isFile() && /^test_.*\.py$|^.*_test\.py$/.test(entry.name)) {
+            return true;
+        }
+    }
+    return false;
+}
 // ─── Failure Context Formatting ──────────────────────────────────────────────
 /** Maximum chars of stderr to include per failed check in failure context. */
 const MAX_STDERR_PER_CHECK = 2_000;
@@ -112,7 +161,7 @@ export function formatFailureContext(result) {
 }
 // ─── Gate Execution ─────────────────────────────────────────────────────────
 /** Characters that indicate shell injection when found in a command string. */
-const SHELL_INJECTION_PATTERN = /[;|`]|\$\(/;
+const SHELL_INJECTION_PATTERN = /[;|`<>]|\$\(/;
 /**
  * Known executable first-tokens that are safe to run.
  * Lowercase commands, common build/test tools, and npm/yarn/pnpm invocations.
@@ -148,6 +197,7 @@ const KNOWN_COMMAND_PREFIXES = new Set([
  * Heuristics (any true → prose-like):
  *   1. First token starts with an uppercase letter and the string has 4+ words
  *   2. String contains commas followed by spaces (prose clause structure)
+ *   3. First token has no ASCII letters or digits and the string has 4+ words
  */
 export function isLikelyCommand(cmd) {
     const trimmed = cmd.trim();
@@ -173,16 +223,27 @@ export function isLikelyCommand(cmd) {
     // First token has uppercase letters and no path separators → prose
     if (/[A-Z]/.test(firstToken) && !firstToken.includes("/"))
         return false;
+    // Non-ASCII prose with multiple words should not be executed as a command.
+    if (!/[A-Za-z0-9]/.test(firstToken) && tokens.length >= 4)
+        return false;
     return true;
 }
 /**
  * Validate a command string for obvious shell injection patterns.
  * Returns the command unchanged if safe, or null if suspicious.
  */
+export function validateVerificationCommand(cmd) {
+    if (SHELL_INJECTION_PATTERN.test(cmd)) {
+        return { ok: false, reason: "contains shell control syntax such as pipes, redirects, semicolons, backticks, or command substitution" };
+    }
+    if (!isLikelyCommand(cmd)) {
+        return { ok: false, reason: "does not look like a runnable command" };
+    }
+    return { ok: true };
+}
 function sanitizeCommand(cmd) {
-    if (SHELL_INJECTION_PATTERN.test(cmd))
-        return null;
-    if (!isLikelyCommand(cmd))
+    const validation = validateVerificationCommand(cmd);
+    if (!validation.ok)
         return null;
     return cmd;
 }

package/dist/resources/extensions/gsd/verification-verdict.js

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Host-owned verification verdict policy for auto-mode units.
+export function decideVerificationVerdict(unitType, result) {
+    if (unitType === "execute-task" && result.discoverySource === "none" && result.checks.length === 0) {
+        return {
+            passed: false,
+            reason: "no-host-checks",
+            retryable: false,
+            failureContext: "No runnable host-owned verification command was discovered. Add project verification_commands or a runnable task-plan Verify command before completing this execute-task.",
+        };
+    }
+    if (!result.passed) {
+        return {
+            passed: false,
+            reason: "checks-failed",
+            retryable: true,
+            failureContext: "",
+        };
+    }
+    return {
+        passed: true,
+        reason: "passed",
+        retryable: false,
+        failureContext: "",
+    };
+}

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

@@ -322,6 +322,16 @@ function hasAskUserQuestionsTool(activeTools) {
         return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === "ask_user_questions";
     });
 }
+function hasRequiredTool(requiredTool, activeTools) {
+    return activeTools.some((toolName) => {
+        if (toolName === requiredTool)
+            return true;
+        if (!toolName.startsWith("mcp__"))
+            return false;
+        const toolSeparator = toolName.indexOf("__", "mcp__".length);
+        return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === requiredTool;
+    });
+}
 function workflowMcpStructuredQuestionsOptIn(env = process.env) {
     const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS;
     return value === "1" || value === "true";
@@ -352,8 +362,14 @@ export function getWorkflowTransportSupportError(provider, requiredTools, option
     if (!launch) {
         return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root. You can also configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
     }
-    const missing = [...new Set(requiredTools)].filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
+    const uniqueRequired = [...new Set(requiredTools)];
+    const missing = (options.activeTools && options.activeTools.length > 0)
+        ? uniqueRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools))
+        : uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
     if (missing.length === 0)
         return null;
+    if (options.activeTools && options.activeTools.length > 0) {
+        return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the active runtime toolset currently exposes only ${options.activeTools.slice().sort().join(", ")}.`;
+    }
     return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the workflow MCP transport currently exposes only ${Array.from(MCP_WORKFLOW_TOOL_SURFACE).sort().join(", ")}.`;
 }

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

@@ -150,11 +150,11 @@ export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
     }
     // ── 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")
-        : "  - (none)";
+        ? `\n${taskRow.key_files.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const keyDecisionsYaml = taskRow.key_decisions && taskRow.key_decisions.length > 0
-        ? taskRow.key_decisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${taskRow.key_decisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     // Derive verification_result from evidence if available
     const evidenceList = evidence ?? [];
     const allPassed = evidenceList.length > 0 &&
@@ -182,10 +182,8 @@ export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
 id: ${taskRow.id}
 parent: ${sliceId}
 milestone: ${milestoneId}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
+key_files:${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
 duration: ${taskRow.duration || ""}
 verification_result: ${verificationResult}
 completed_at: ${taskRow.completed_at || ""}