gsd-pi 2.82.0 → 3.0.0-dev.6c9a50fd0

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,21 @@ 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";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { createRepositoryRegistryFromPreferences } from "../repository-registry.js";
+function validateRepositoryTargetIds(field, value) {
+    if (value === undefined)
+        return null;
+    const ids = validateStringArray(value, field);
+    if (ids.length === 0)
+        throw new Error(`${field} must include at least one repository id when provided`);
+    const deduped = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+    if (deduped.length === 0)
+        throw new Error(`${field} must include at least one repository id when provided`);
+    return deduped;
+}
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -28,6 +45,7 @@ function validateTasks(value) {
         const inputs = obj.inputs;
         const expectedOutput = obj.expectedOutput;
         const observabilityImpact = obj.observabilityImpact;
+        const targetRepositories = obj.targetRepositories;
         if (!isNonEmptyString(taskId))
             throw new Error(`tasks[${index}].taskId must be a non-empty string`);
         if (seen.has(taskId))
@@ -39,30 +57,26 @@ 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`);
         }
+        const validatedTargetRepositories = validateRepositoryTargetIds(`tasks[${index}].targetRepositories`, targetRepositories);
         return {
             taskId,
             title,
             description,
             estimate,
-            files,
+            files: validatedFiles,
             verify,
-            inputs,
-            expectedOutput,
+            inputs: validatedInputs,
+            expectedOutput: validatedExpectedOutput,
             observabilityImpact: typeof observabilityImpact === "string" ? observabilityImpact : "",
+            targetRepositories: validatedTargetRepositories ?? undefined,
         };
     });
 }
@@ -73,6 +87,7 @@ function validateParams(params) {
         throw new Error("sliceId is required");
     if (!isNonEmptyString(params?.goal))
         throw new Error("goal is required");
+    const validatedTargetRepositories = validateRepositoryTargetIds("targetRepositories", params.targetRepositories);
     return {
         ...params,
         // Keep optional enrichment fields empty when omitted. The renderer supplies
@@ -81,9 +96,94 @@ function validateParams(params) {
         proofLevel: params.proofLevel ?? "",
         integrationClosure: params.integrationClosure ?? "",
         observabilityImpact: params.observabilityImpact ?? "",
+        targetRepositories: validatedTargetRepositories ?? undefined,
         tasks: validateTasks(params.tasks),
     };
 }
+function loadRepositoryRegistry(basePath) {
+    const loaded = loadEffectiveGSDPreferences(basePath);
+    return createRepositoryRegistryFromPreferences(basePath, loaded?.preferences);
+}
+function validateReferencedRepositories(params, registry) {
+    const known = new Set(registry.repositories.map((repo) => repo.id));
+    const missing = [];
+    const noteMissing = (id) => {
+        if (!known.has(id) && !missing.includes(id))
+            missing.push(id);
+    };
+    for (const id of params.targetRepositories ?? [])
+        noteMissing(id);
+    for (const task of params.tasks) {
+        for (const id of task.targetRepositories ?? [])
+            noteMissing(id);
+    }
+    if (missing.length === 0)
+        return null;
+    return `unknown targetRepositories: ${missing.join(", ")}. Declared repositories: ${Array.from(known).join(", ")}`;
+}
+function resolveAllowedRootsForPathScope(params, registry) {
+    const requested = new Set();
+    for (const id of params.targetRepositories ?? [])
+        requested.add(id);
+    for (const task of params.tasks) {
+        for (const id of task.targetRepositories ?? [])
+            requested.add(id);
+    }
+    if (requested.size === 0)
+        return [registry.projectRoot];
+    const roots = Array.from(requested)
+        .map((id) => registry.byId.get(id)?.root)
+        .filter((root) => typeof root === "string");
+    return roots.length > 0 ? roots : [registry.projectRoot];
+}
+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 ?? "",
+        target_repositories: task.targetRepositories ?? params.targetRepositories ?? ["project"],
+        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 {
@@ -92,18 +192,29 @@ export async function handlePlanSlice(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
+    const repositoryRegistry = loadRepositoryRegistry(basePath);
+    const repoValidationError = validateReferencedRepositories(params, repositoryRegistry);
+    if (repoValidationError) {
+        return { error: `validation failed: ${repoValidationError}` };
+    }
+    const allowedAbsoluteRoots = resolveAllowedRootsForPathScope(params, repositoryRegistry);
     const pathScopeError = validatePlanningPathScope(basePath, params.tasks.flatMap((task, index) => [
         { field: `tasks[${index}].files`, values: task.files },
         { field: `tasks[${index}].inputs`, values: task.inputs },
         { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
-    ]));
+    ]), allowedAbsoluteRoots);
     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,16 +235,32 @@ 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,
                 proofLevel: params.proofLevel,
                 integrationClosure: params.integrationClosure,
                 observabilityImpact: params.observabilityImpact,
+                targetRepositories: params.targetRepositories ?? ["project"],
             });
+            for (const taskId of omittedTaskIds) {
+                deleteTask(params.milestoneId, params.sliceId, taskId);
+            }
             for (const task of params.tasks) {
                 insertTask({
                     id: task.taskId,
@@ -152,6 +279,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                     expectedOutput: task.expectedOutput,
                     observabilityImpact: task.observabilityImpact ?? "",
                     fullPlanMd: task.fullPlanMd,
+                    targetRepositories: task.targetRepositories ?? params.targetRepositories ?? ["project"],
                 });
             }
             // Seed quality gate rows inside the transaction — all-or-nothing with
@@ -176,6 +304,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) {
@@ -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/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.",