gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

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) {
@@ -288,46 +407,72 @@ export async function executeSliceComplete(params, basePath = process.cwd()) {
             const m = s.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
             return m ? [m[1].trim(), m[2].trim()] : [s.trim(), ""];
         };
-        const wrapArray = (v) => v == null ? [] : Array.isArray(v) ? v : [v];
-        const coerced = { ...params };
-        coerced.provides = wrapArray(params.provides);
-        coerced.keyFiles = wrapArray(params.keyFiles);
-        coerced.keyDecisions = wrapArray(params.keyDecisions);
-        coerced.patternsEstablished = wrapArray(params.patternsEstablished);
-        coerced.observabilitySurfaces = wrapArray(params.observabilitySurfaces);
-        coerced.requirementsSurfaced = wrapArray(params.requirementsSurfaced);
-        coerced.drillDownPaths = wrapArray(params.drillDownPaths);
-        coerced.affects = wrapArray(params.affects);
-        coerced.filesModified = wrapArray(params.filesModified).map((f) => {
-            if (typeof f !== "string")
-                return f;
-            const [path, description] = splitPair(f);
-            return { path, description };
-        });
-        coerced.requires = wrapArray(params.requires).map((r) => {
-            if (typeof r !== "string")
-                return r;
-            const [slice, provides] = splitPair(r);
-            return { slice, provides };
-        });
-        coerced.requirementsAdvanced = wrapArray(params.requirementsAdvanced).map((r) => {
-            if (typeof r !== "string")
-                return r;
-            const [id, how] = splitPair(r);
-            return { id, how };
-        });
-        coerced.requirementsValidated = wrapArray(params.requirementsValidated).map((r) => {
-            if (typeof r !== "string")
-                return r;
-            const [id, proof] = splitPair(r);
-            return { id, proof };
-        });
-        coerced.requirementsInvalidated = wrapArray(params.requirementsInvalidated).map((r) => {
-            if (typeof r !== "string")
-                return r;
-            const [id, what] = splitPair(r);
-            return { id, what };
-        });
+        const wrapOptionalArray = (v) => v == null ? undefined : Array.isArray(v) ? v : [v];
+        const coerced = Object.fromEntries(Object.entries(params).filter(([, value]) => value !== undefined && value !== null));
+        const provides = wrapOptionalArray(params.provides);
+        if (provides !== undefined)
+            coerced.provides = provides;
+        const keyFiles = wrapOptionalArray(params.keyFiles);
+        if (keyFiles !== undefined)
+            coerced.keyFiles = keyFiles;
+        const keyDecisions = wrapOptionalArray(params.keyDecisions);
+        if (keyDecisions !== undefined)
+            coerced.keyDecisions = keyDecisions;
+        const patternsEstablished = wrapOptionalArray(params.patternsEstablished);
+        if (patternsEstablished !== undefined)
+            coerced.patternsEstablished = patternsEstablished;
+        const observabilitySurfaces = wrapOptionalArray(params.observabilitySurfaces);
+        if (observabilitySurfaces !== undefined)
+            coerced.observabilitySurfaces = observabilitySurfaces;
+        const requirementsSurfaced = wrapOptionalArray(params.requirementsSurfaced);
+        if (requirementsSurfaced !== undefined)
+            coerced.requirementsSurfaced = requirementsSurfaced;
+        const drillDownPaths = wrapOptionalArray(params.drillDownPaths);
+        if (drillDownPaths !== undefined)
+            coerced.drillDownPaths = drillDownPaths;
+        const affects = wrapOptionalArray(params.affects);
+        if (affects !== undefined)
+            coerced.affects = affects;
+        const filesModified = wrapOptionalArray(params.filesModified);
+        if (filesModified !== undefined)
+            coerced.filesModified = filesModified.map((f) => {
+                if (typeof f !== "string")
+                    return f;
+                const [path, description] = splitPair(f);
+                return { path, description };
+            });
+        const requires = wrapOptionalArray(params.requires);
+        if (requires !== undefined)
+            coerced.requires = requires.map((r) => {
+                if (typeof r !== "string")
+                    return r;
+                const [slice, provides] = splitPair(r);
+                return { slice, provides };
+            });
+        const requirementsAdvanced = wrapOptionalArray(params.requirementsAdvanced);
+        if (requirementsAdvanced !== undefined)
+            coerced.requirementsAdvanced = requirementsAdvanced.map((r) => {
+                if (typeof r !== "string")
+                    return r;
+                const [id, how] = splitPair(r);
+                return { id, how };
+            });
+        const requirementsValidated = wrapOptionalArray(params.requirementsValidated);
+        if (requirementsValidated !== undefined)
+            coerced.requirementsValidated = requirementsValidated.map((r) => {
+                if (typeof r !== "string")
+                    return r;
+                const [id, proof] = splitPair(r);
+                return { id, proof };
+            });
+        const requirementsInvalidated = wrapOptionalArray(params.requirementsInvalidated);
+        if (requirementsInvalidated !== undefined)
+            coerced.requirementsInvalidated = requirementsInvalidated.map((r) => {
+                if (typeof r !== "string")
+                    return r;
+                const [id, what] = splitPair(r);
+                return { id, what };
+            });
         const result = await handleCompleteSlice(coerced, basePath);
         if ("error" in result) {
             return {

package/dist/resources/extensions/gsd/tui/render-kit.js

@@ -53,6 +53,39 @@ export function statusGlyph(theme, level) {
         default: return theme.fg("dim", "○");
     }
 }
+/**
+ * Render a titled panel without vertical borders.
+ *
+ * Unlike {@link renderFrame}, this draws no `│` side bars — only a header rule
+ * with an inline title and a closing rule. Body lines are indented. Because no
+ * box-drawing character ever sits on a content line, terminal text selection
+ * copies clean text. Use this for inline output users may copy; keep
+ * {@link renderFrame} for transient overlays that benefit from a full box.
+ *
+ *   ── Title ────────────────────────────────
+ *
+ *     body line
+ *     body line
+ *   ──────────────────────────────────────────
+ */
+export function renderPanel(theme, title, inner, width, options = {}) {
+    if (width < 4) {
+        return [safeLine(title, width), ...inner.map((line) => safeLine(line, width))];
+    }
+    const ruleColor = options.ruleColor ?? "borderAccent";
+    const indent = Math.max(0, options.indent ?? 2);
+    const rule = (text) => theme.fg(ruleColor, text);
+    // Header rule: "── <title> ───────"
+    const lead = "── ";
+    const headerUsed = visibleWidth(lead) + visibleWidth(title) + 1;
+    const headerFill = Math.max(0, width - headerUsed);
+    const header = safeLine(rule(lead) + title + " " + rule("─".repeat(headerFill)), width, "");
+    // Body lines, indented so no chrome sits on copyable text.
+    const pad = " ".repeat(indent);
+    const contentWidth = Math.max(0, width - indent);
+    const body = inner.map((line) => safeLine(pad + safeLine(line, contentWidth), width, ""));
+    return [header, "", ...body, rule("─".repeat(width))];
+}
 export function renderFrame(theme, inner, width, options = {}) {
     if (width < 4)
         return inner.map((line) => safeLine(line, width));

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

@@ -74,6 +74,7 @@ export function manifestBudgetChars(unitType) {
 const CONTEXT_MODE_LANE_LABELS = {
     interview: "interview",
     research: "research",
+    triage: "triage",
     planning: "planning",
     execution: "execution",
     verification: "verification",
@@ -83,6 +84,7 @@ const CONTEXT_MODE_LANE_LABELS = {
 const CONTEXT_MODE_GUIDANCE_BY_LANE = {
     interview: "Use `gsd_resume` to restore prior discussion, `gsd_exec` for noisy discovery, and `gsd_exec_search` before repeating scans.",
     research: "Use `gsd_exec` for noisy research scans, `gsd_exec_search` before reruns, and `gsd_resume` to restore prior findings.",
+    triage: "Use `gsd_resume` to restore prior triage context, `gsd_exec_search` to reuse evidence, and `gsd_exec` for noisy validation checks.",
     planning: "Use `gsd_resume` for planning continuity, `gsd_exec` for noisy checks, and `gsd_exec_search` before rerunning diagnostics.",
     execution: "Use `gsd_exec` for builds, tests, and diagnostics, `gsd_exec_search` before reruns, and `gsd_resume` after compaction or resume.",
     verification: "Use `gsd_exec` for verification commands, `gsd_exec_search` to reuse prior evidence, and `gsd_resume` after compaction or resume.",

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 = {
@@ -122,6 +123,9 @@ export const KNOWN_UNIT_TYPES = [
     "run-uat",
     "gate-evaluate",
     "rewrite-docs",
+    // Sidecar units (triage, quick-task)
+    "triage-captures",
+    "quick-task",
     // Deep planning mode (project-level) units
     "workflow-preferences",
     "discuss-project",
@@ -185,11 +189,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         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.
-        tools: TOOLS_PLANNING_DISPATCH_REVIEW,
+        // Validation may need to run shell verification commands and apply source
+        // fixes before milestone closeout can proceed.
+        tools: TOOLS_ALL,
         artifacts: {
             inline: ["roadmap", "slice-summary", "slice-uat", "requirements", "decisions", "templates"],
             excerpt: [],
@@ -204,11 +206,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 +227,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: [],
@@ -293,10 +295,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        // See complete-milestone — same rationale: dispatch to reviewer / security /
-        // tester subagents to fan out review work without bloating this unit's
-        // context.
-        tools: TOOLS_PLANNING_DISPATCH_REVIEW,
+        // Slice closeout may need to run shell verification commands and apply
+        // source fixes before completion can be recorded.
+        tools: TOOLS_ALL,
         artifacts: {
             // Phase 3 migration (#4782): matches today's actual
             // buildCompleteSlicePrompt inlining order. Overrides prepend +
@@ -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: [],
@@ -407,6 +410,36 @@ export const UNIT_MANIFESTS = {
         },
         maxSystemPromptChars: COMMON_BUDGET_MEDIUM,
     },
+    "triage-captures": {
+        skills: { mode: "all" },
+        knowledge: "scoped",
+        memory: "prompt-relevant",
+        codebaseMap: false,
+        preferences: "active-only",
+        contextMode: "triage",
+        tools: TOOLS_PLANNING,
+        artifacts: {
+            inline: ["roadmap", "slice-plan", "slice-summary", "requirements", "decisions", "templates"],
+            excerpt: [],
+            onDemand: [],
+        },
+        maxSystemPromptChars: COMMON_BUDGET_MEDIUM,
+    },
+    "quick-task": {
+        skills: { mode: "all" },
+        knowledge: "full",
+        memory: "prompt-relevant",
+        codebaseMap: true,
+        preferences: "active-only",
+        contextMode: "execution",
+        tools: TOOLS_ALL,
+        artifacts: {
+            inline: ["roadmap", "slice-plan", "task-plan", "requirements", "decisions", "templates"],
+            excerpt: [],
+            onDemand: [],
+        },
+        maxSystemPromptChars: COMMON_BUDGET_MEDIUM,
+    },
     // ─── Deep planning mode (project-level) units ────────────────────────
     // workflow-preferences: default-writing stage that records
     // commit_policy / branch_model in PREFERENCES.md, defaults
@@ -509,3 +542,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`);