@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0

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

@@ -13,7 +13,7 @@ import { existsSync } from "node:fs";
 import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, getLatestAssessmentByScope, updateMilestoneStatus, } from "../gsd-db.js";
 import { clearPathCache, relMilestoneFile } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
-import { isClosedStatus } from "../status-guards.js";
+import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { stripIdPrefix } from "../workflow-projections.js";
@@ -118,7 +118,7 @@ export async function handleCompleteMilestone(params, basePath) {
             guardError = `no slices found for milestone ${params.milestoneId}`;
             return;
         }
-        const incompleteSlices = slices.filter(s => !isClosedStatus(s.status));
+        const incompleteSlices = slices.filter(s => !isClosedStatus(s.status) && !isDeferredStatus(s.status));
         if (incompleteSlices.length > 0) {
             const incompleteIds = incompleteSlices.map(s => `${s.id} (status: ${s.status})`).join(", ");
             guardError = `incomplete slices: ${incompleteIds}`;
@@ -126,6 +126,8 @@ export async function handleCompleteMilestone(params, basePath) {
         }
         // Deep check: verify all tasks in all slices are complete
         for (const slice of slices) {
+            if (isDeferredStatus(slice.status))
+                continue;
             const tasks = getSliceTasks(params.milestoneId, slice.id);
             const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
             if (incompleteTasks.length > 0) {

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

@@ -21,7 +21,7 @@ import { classifyUatContent, escalatesArtifactUatToBrowser } from "../uat-policy
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, roadmapRenderMarksSliceDone } from "../markdown-renderer.js";
 import { isStaleWrite } from "../auto/turn-epoch.js";
-import { renderStateProjection, renderTopLevelQueueFromDb, renderTopLevelRoadmapFromDb } from "../workflow-projections.js";
+import { renderMilestoneShellProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
@@ -457,42 +457,11 @@ export async function handleCompleteSlice(params, basePath) {
     // ── Post-mutation hook: projections, manifest, event log ───────────────
     // Separate try/catch per step so a projection failure doesn't prevent
     // the event log entry (critical for worktree reconciliation).
-    //
-    // If the primary summary/UAT/roadmap write block failed (projectionStale),
-    // retry the milestone-level roadmap here so ROADMAP.md is not left stale
-    // after a committed slice completion. This restores the recovery that the
-    // removed flushWorkflowProjections/renderAllProjections provided.
-    if (projectionStale) {
-        try {
-            await renderRoadmapFromDb(artifactBasePath, params.milestoneId);
-        }
-        catch (projErr) {
-            logWarning("tool", `complete-slice milestone roadmap retry warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
-        }
-    }
-    try {
-        await renderRoadmapFromDb(artifactBasePath, params.milestoneId);
-    }
-    catch (projErr) {
-        logWarning("tool", `complete-slice milestone roadmap projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
-    }
-    try {
-        renderTopLevelRoadmapFromDb(artifactBasePath);
-    }
-    catch (projErr) {
-        logWarning("tool", `complete-slice roadmap projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
-    }
-    try {
-        renderTopLevelQueueFromDb(artifactBasePath);
-    }
-    catch (projErr) {
-        logWarning("tool", `complete-slice queue projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
-    }
     try {
-        await renderStateProjection(artifactBasePath);
+        await renderMilestoneShellProjections(artifactBasePath, params.milestoneId);
     }
     catch (projErr) {
-        logWarning("tool", `complete-slice state projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
+        logWarning("tool", `complete-slice projection warning for ${params.milestoneId}/${params.sliceId}: ${projErr.message}`);
     }
     try {
         writeManifest(artifactBasePath);

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

@@ -12,16 +12,16 @@
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, isDbAvailable, } from "../gsd-db.js";
-import { getWorkflowDatabasePath, openWorkflowDatabasePath } from "../db-workspace.js";
+import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
+import { getWorkflowDatabasePath, ensureWorkflowDbAtPath } from "../db-workspace.js";
 import { getGatesForTurn } from "../gate-registry.js";
 import { gsdProjectionRoot, clearPathCache, resolveMilestonePath, resolveSlicePath } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
-import { renderPlanCheckboxes, renderRoadmapFromDb } from "../markdown-renderer.js";
-import { renderStateProjection, renderSummaryContent, renderTopLevelQueueFromDb, renderTopLevelRoadmapFromDb, } from "../workflow-projections.js";
+import { renderPlanCheckboxes } from "../markdown-renderer.js";
+import { renderMilestoneShellProjections, renderSummaryContent, } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
@@ -45,39 +45,6 @@ function taskSummaryPath(basePath, milestoneId, sliceId, taskId) {
     // Fallback: legacy hardcoded path (milestone/slice dir not on disk yet)
     return join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks", `${taskId}-SUMMARY.md`);
 }
-async function renderCompleteTaskProjections(basePath, milestoneId) {
-    try {
-        await renderRoadmapFromDb(basePath, milestoneId);
-    }
-    catch (err) {
-        logWarning("projection", `renderRoadmapFromDb failed for ${milestoneId}: ${err.message}`);
-    }
-    try {
-        renderTopLevelRoadmapFromDb(basePath);
-    }
-    catch (err) {
-        logWarning("projection", `renderTopLevelRoadmapFromDb failed: ${err.message}`);
-    }
-    try {
-        renderTopLevelQueueFromDb(basePath);
-    }
-    catch (err) {
-        logWarning("projection", `renderTopLevelQueueFromDb failed: ${err.message}`);
-    }
-    try {
-        await renderStateProjection(basePath);
-    }
-    catch (err) {
-        logWarning("projection", `renderStateProjection failed: ${err.message}`);
-    }
-}
-function ensureCompleteTaskDbOpen(dbPath) {
-    if (!dbPath || dbPath === ":memory:")
-        return isDbAvailable();
-    if (isDbAvailable() && getWorkflowDatabasePath() === dbPath)
-        return true;
-    return openWorkflowDatabasePath(dbPath);
-}
 async function repairMissingTaskSummaryProjection(artifactBasePath, taskRow) {
     const summaryPath = taskSummaryPath(artifactBasePath, taskRow.milestone_id, taskRow.slice_id, taskRow.id);
     const summaryMd = renderSummaryContent(taskRow, taskRow.slice_id, taskRow.milestone_id, []);
@@ -94,7 +61,7 @@ async function repairMissingTaskSummaryProjection(artifactBasePath, taskRow) {
     clearPathCache();
     clearParseCache();
     try {
-        await renderCompleteTaskProjections(artifactBasePath, taskRow.milestone_id);
+        await renderMilestoneShellProjections(artifactBasePath, taskRow.milestone_id);
     }
     catch (projErr) {
         logWarning("tool", `complete-task repair projection warning: ${projErr.message}`);
@@ -358,7 +325,7 @@ export async function handleCompleteTask(params, basePath) {
         await saveFile(summaryPath, summaryMd);
         // Toggle or regenerate the plan projection from DB. Missing projection
         // files are rebuilt by the renderer instead of being skipped.
-        if (!ensureCompleteTaskDbOpen(rollbackDbPath)) {
+        if (!ensureWorkflowDbAtPath(rollbackDbPath)) {
             throw new Error(`database unavailable before plan projection render for ${params.milestoneId}/${params.sliceId}`);
         }
         const wrotePlan = await renderPlanCheckboxes(artifactBasePath, params.milestoneId, params.sliceId);
@@ -370,7 +337,7 @@ export async function handleCompleteTask(params, basePath) {
         logWarning("projection", `complete_task projection write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}`, { error: renderErr.message });
         let rollbackSucceeded = false;
         try {
-            ensureCompleteTaskDbOpen(rollbackDbPath);
+            ensureWorkflowDbAtPath(rollbackDbPath);
             deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
             updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, "pending");
             invalidateStateCache();
@@ -498,7 +465,7 @@ export async function handleCompleteTask(params, basePath) {
     // Separate try/catch per step so a projection failure doesn't prevent
     // the event log entry (critical for worktree reconciliation).
     try {
-        await renderCompleteTaskProjections(artifactBasePath, params.milestoneId);
+        await renderMilestoneShellProjections(artifactBasePath, params.milestoneId);
     }
     catch (projErr) {
         logWarning("tool", `complete-task projection warning: ${projErr.message}`);

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

@@ -28,9 +28,13 @@ function validateRepositoryTargetIds(field, value) {
     return deduped;
 }
 function validateTasks(value) {
-    if (!Array.isArray(value) || value.length === 0) {
-        throw new Error("tasks must be a non-empty array");
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        throw new Error("tasks must be an array");
     }
+    if (value.length === 0)
+        return undefined;
     const seen = new Set();
     return value.map((entry, index) => {
         if (!entry || typeof entry !== "object") {
@@ -129,7 +133,7 @@ function validateReferencedRepositories(params, registry, defaultTargets) {
     };
     for (const id of params.targetRepositories ?? defaultTargets)
         noteMissing(id);
-    for (const task of params.tasks) {
+    for (const task of params.tasks ?? []) {
         for (const id of task.targetRepositories ?? params.targetRepositories ?? defaultTargets)
             noteMissing(id);
     }
@@ -141,7 +145,7 @@ function resolveAllowedRootsForPathScope(params, registry, defaultTargets) {
     const requested = new Set();
     for (const id of params.targetRepositories ?? defaultTargets)
         requested.add(id);
-    for (const task of params.tasks) {
+    for (const task of params.tasks ?? []) {
         for (const id of task.targetRepositories ?? params.targetRepositories ?? defaultTargets)
             requested.add(id);
     }
@@ -153,7 +157,7 @@ function resolveAllowedRootsForPathScope(params, registry, defaultTargets) {
     return roots.length > 0 ? roots : [registry.projectRoot];
 }
 function toTaskRows(params, defaultTargets) {
-    return params.tasks.map((task, index) => ({
+    return (params.tasks ?? []).map((task, index) => ({
         milestone_id: params.milestoneId,
         slice_id: params.sliceId,
         id: task.taskId,
@@ -230,19 +234,21 @@ export async function handlePlanSlice(rawParams, basePath) {
         return { error: `validation failed: ${message}` };
     }
     const defaultTargets = defaultRepositoryTargets(repositoryRegistry);
+    const taskPayload = params.tasks ?? [];
+    const hasTaskPayload = taskPayload.length > 0;
     const repoValidationError = validateReferencedRepositories(params, repositoryRegistry, defaultTargets);
     if (repoValidationError) {
         return { error: `validation failed: ${repoValidationError}` };
     }
     const allowedAbsoluteRoots = resolveAllowedRootsForPathScope(params, repositoryRegistry, defaultTargets);
-    const pathOnlyError = validatePathOnlyPlanningFields(params.tasks.map((task, index) => ({
+    const pathOnlyError = validatePathOnlyPlanningFields(taskPayload.map((task, index) => ({
         field: `tasks[${index}].expectedOutput`,
         values: task.expectedOutput,
     })));
     if (pathOnlyError) {
         return { error: `validation failed: ${pathOnlyError}` };
     }
-    const pathScopeError = validatePlanningPathScope(basePath, params.tasks.flatMap((task, index) => [
+    const pathScopeError = validatePlanningPathScope(basePath, taskPayload.flatMap((task, index) => [
         { field: `tasks[${index}].files`, values: task.files },
         { field: `tasks[${index}].inputs`, values: task.inputs },
         { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
@@ -279,15 +285,17 @@ 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 newTaskIds = new Set(taskPayload.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 (hasTaskPayload) {
+                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)) {
@@ -301,34 +309,36 @@ export async function handlePlanSlice(rawParams, basePath) {
                 observabilityImpact: params.observabilityImpact,
                 targetRepositories: params.targetRepositories ?? defaultTargets,
             });
-            for (const taskId of omittedTaskIds) {
-                deleteTask(params.milestoneId, params.sliceId, taskId);
-            }
-            const existingTaskById = new Map(existingTasks.map((task) => [task.id, task]));
-            for (const task of params.tasks) {
-                const planning = {
-                    title: task.title,
-                    description: task.description,
-                    estimate: task.estimate,
-                    files: task.files,
-                    verify: task.verify,
-                    inputs: task.inputs,
-                    expectedOutput: task.expectedOutput,
-                    observabilityImpact: task.observabilityImpact ?? "",
-                    fullPlanMd: task.fullPlanMd,
-                    targetRepositories: task.targetRepositories ?? params.targetRepositories ?? defaultTargets,
-                };
-                const existingTask = existingTaskById.get(task.taskId);
-                if (!existingTask || !isClosedStatus(existingTask.status)) {
-                    insertTask({
-                        id: task.taskId,
-                        sliceId: params.sliceId,
-                        milestoneId: params.milestoneId,
+            if (hasTaskPayload) {
+                for (const taskId of omittedTaskIds) {
+                    deleteTask(params.milestoneId, params.sliceId, taskId);
+                }
+                const existingTaskById = new Map(existingTasks.map((task) => [task.id, task]));
+                for (const task of taskPayload) {
+                    const planning = {
                         title: task.title,
-                        status: "pending",
-                    });
+                        description: task.description,
+                        estimate: task.estimate,
+                        files: task.files,
+                        verify: task.verify,
+                        inputs: task.inputs,
+                        expectedOutput: task.expectedOutput,
+                        observabilityImpact: task.observabilityImpact ?? "",
+                        fullPlanMd: task.fullPlanMd,
+                        targetRepositories: task.targetRepositories ?? params.targetRepositories ?? defaultTargets,
+                    };
+                    const existingTask = existingTaskById.get(task.taskId);
+                    if (!existingTask || !isClosedStatus(existingTask.status)) {
+                        insertTask({
+                            id: task.taskId,
+                            sliceId: params.sliceId,
+                            milestoneId: params.milestoneId,
+                            title: task.title,
+                            status: "pending",
+                        });
+                    }
+                    upsertTaskPlanning(params.milestoneId, params.sliceId, task.taskId, planning);
                 }
-                upsertTaskPlanning(params.milestoneId, params.sliceId, task.taskId, planning);
             }
             // Seed quality gate rows inside the transaction — all-or-nothing with
             // the plan data so a crash can't leave orphaned gates without tasks.
@@ -337,7 +347,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                 insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "slice" });
             }
             const taskGates = resolveTaskGates(gateEvaluation);
-            for (const task of params.tasks) {
+            for (const task of taskPayload) {
                 for (const gid of taskGates) {
                     insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: task.taskId });
                 }
@@ -360,8 +370,13 @@ export async function handlePlanSlice(rawParams, basePath) {
             const artifactPath = relative(gsdProjectionRoot(basePath), taskPlanPath).replace(/\\/g, "/");
             deleteArtifactByPath(artifactPath);
         }
-        const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
-        setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+        const sliceTasks = getSliceTasks(params.milestoneId, params.sliceId);
+        const renderResult = sliceTasks.length === 0
+            ? { planPath: "", taskPlanPaths: [] }
+            : await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+        if (sliceTasks.length > 0) {
+            setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+        }
         invalidateStateCache();
         clearParseCache();
         // ── Post-mutation hook: manifest, event log ─────────────────────────

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

@@ -1,14 +1,16 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
-import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
+import { getGateIdsForTurn } from "../gate-registry.js";
+import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning, insertGateRow, setSliceSketchFlag } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb, renderPlanFromDb } from "../markdown-renderer.js";
-import { resolveSliceFile, resolveTasksDir } from "../paths.js";
+import { resolveTasksDir } from "../paths.js";
 import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
@@ -35,6 +37,12 @@ function validateParams(params) {
         expectedOutput: validateStringArray(params.expectedOutput, "expectedOutput"),
     };
 }
+function resolveTaskGates(basePath) {
+    const loaded = loadEffectiveGSDPreferences(basePath);
+    if (loaded?.preferences?.gate_evaluation?.task_gates === false)
+        return [];
+    return [...getGateIdsForTurn("execute-task")];
+}
 export async function handlePlanTask(rawParams, basePath) {
     let params;
     try {
@@ -57,6 +65,14 @@ export async function handlePlanTask(rawParams, basePath) {
     if (pathScopeError) {
         return { error: `validation failed: ${pathScopeError}` };
     }
+    let taskGates;
+    try {
+        taskGates = resolveTaskGates(basePath);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { error: `validation failed: ${message}` };
+    }
     // ── 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).
@@ -97,6 +113,9 @@ export async function handlePlanTask(rawParams, basePath) {
                 observabilityImpact: params.observabilityImpact ?? "",
                 fullPlanMd: params.fullPlanMd,
             });
+            for (const gid of taskGates) {
+                insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: params.taskId });
+            }
         });
     }
     catch (err) {
@@ -110,17 +129,21 @@ export async function handlePlanTask(rawParams, basePath) {
         // Flat-phase: tasks live as checkboxes in the slice plan's <tasks> block,
         // not as standalone TID-PLAN.md files. Re-render the slice plan so the
         // new/updated task appears in the plan file that gsd-core reads.
-        // Guard: resolveTasksDir is null in flat-phase (no tasks/ subdir exists);
-        //        only sync if a slice plan already exists (guards pre-plan-slice calls).
+        // Guard: resolveTasksDir is null in flat-phase (no tasks/ subdir exists).
+        let slicePlanSynced = false;
         try {
             const tDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-            if (!tDir && resolveSliceFile(basePath, params.milestoneId, params.sliceId, "PLAN")) {
+            if (!tDir) {
                 await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+                slicePlanSynced = true;
             }
         }
         catch (syncErr) {
             logWarning("tool", `plan-task: slice-plan sync failed: ${syncErr.message}`);
         }
+        if (slicePlanSynced) {
+            setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+        }
         invalidateStateCache();
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────────────

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

@@ -13,6 +13,7 @@ import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveSliceFile, resolveTa
 import { sendDesktopNotification } from "./notifications.js";
 import { getTask, getSlice, getSliceTasks, updateTaskStatus, resetSliceCascade } from "./gsd-db.js";
 import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
+import { UNIT_REGISTRY } from "./unit-registry.js";
 /**
  * Undo the last completed unit: revert git commits,
  * delete summary artifacts, and uncheck the task in PLAN.
@@ -35,15 +36,19 @@ export async function handleUndo(args, ctx, _pi, basePath) {
         ctx.ui.notify("Nothing to undo — no activity logs found.", "info");
         return;
     }
-    // Extract unit type and ID from the most recent activity log filename
-    // Format: <seq>-<unitType>-<unitId>.jsonl
-    const match = files[0].match(/^\d+-(.+?)-(.+)\.jsonl$/);
-    if (!match) {
+    // Extract unit type and ID from the most recent activity log filename.
+    // Both the unit type and the unit ID may contain hyphens, so anchor on the
+    // known unit-type vocabulary instead of guessing the unit-ID shape: a regex
+    // tuned to milestone-shaped IDs rejects project-level units whose IDs are
+    // symbolic (e.g. discuss-project uses PROJECT, workflow-preferences uses
+    // WORKFLOW-PREFS).
+    const parsed = parseActivityLogFilename(files[0]);
+    if (!parsed) {
         ctx.ui.notify("Nothing to undo — could not parse latest activity log.", "warning");
         return;
     }
-    const unitType = match[1];
-    const unitId = match[2].replace(/-/g, "/");
+    const unitType = parsed.unitType;
+    const unitId = parsed.unitId.replace(/-/g, "/");
     if (!force) {
         ctx.ui.notify(`Will undo: ${unitType} (${unitId})\n` +
             `This will:\n` +
@@ -87,6 +92,11 @@ export async function handleUndo(args, ctx, _pi, basePath) {
     if (unitType === "execute-task" && task !== undefined && slice !== undefined) {
         const [mid, sid, tid] = [milestone, slice, task];
         planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
+        if (getTask(mid, sid, tid)) {
+            updateTaskStatus(mid, sid, tid, "pending");
+            await renderPlanCheckboxes(basePath, mid, sid);
+            planUpdated = true;
+        }
     }
     // 3. Try to revert git commits from activity log
     let commitsReverted = 0;
@@ -318,6 +328,33 @@ export async function handleResetSlice(args, ctx, _pi, basePath) {
     ctx.ui.notify(results.join("\n"), "success");
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
+// Known unit types sorted longest-first so a more specific type (e.g.
+// "execute-task-simple") matches before a prefix of it ("execute-task") when
+// splitting "<seq>-<unitType>-<unitId>.jsonl".
+const UNIT_TYPES_BY_LENGTH_DESC = Object.keys(UNIT_REGISTRY).sort((a, b) => b.length - a.length);
+/**
+ * Parse an activity-log filename of the form `<seq>-<unitType>-<unitId>.jsonl`
+ * (the format written by activity-log.ts). Both the unit type and the unit ID
+ * may contain hyphens, so we anchor on the known unit-type vocabulary rather
+ * than guessing the ID shape. This keeps non-milestone IDs (e.g. PROJECT,
+ * WORKFLOW-PREFS) parseable. Returns null when the name has no sequence prefix
+ * or does not start with a recognised unit type.
+ */
+export function parseActivityLogFilename(filename) {
+    const seqMatch = filename.match(/^\d+-(.+)\.jsonl$/);
+    if (!seqMatch)
+        return null;
+    const rest = seqMatch[1];
+    for (const unitType of UNIT_TYPES_BY_LENGTH_DESC) {
+        const prefix = `${unitType}-`;
+        if (rest.startsWith(prefix)) {
+            const unitId = rest.slice(prefix.length);
+            if (unitId.length > 0)
+                return { unitType, unitId };
+        }
+    }
+    return null;
+}
 export function uncheckTaskInPlan(basePath, mid, sid, tid) {
     const slicePath = resolveSlicePath(basePath, mid, sid);
     if (!slicePath)

package/dist/resources/extensions/gsd/unit-registry.js

@@ -70,10 +70,11 @@ export const UNIT_REGISTRY = {
                 "gsd_milestone_status",
                 "gsd_plan_milestone",
                 "gsd_plan_slice",
+                "gsd_plan_task",
                 "gsd_decision_save",
                 "gsd_requirement_update",
             ],
-            requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice"],
+            requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice", "gsd_plan_task"],
         },
     },
     "discuss-milestone": {
@@ -172,13 +173,14 @@ export const UNIT_REGISTRY = {
             allowedGsdTools: [
                 "gsd_milestone_status",
                 "gsd_plan_slice",
+                "gsd_plan_task",
                 "gsd_reassess_roadmap",
                 "gsd_decision_save",
                 "gsd_exec",
                 "gsd_exec_search",
                 "gsd_resume",
             ],
-            requiredWorkflowTools: ["gsd_plan_slice", "gsd_reassess_roadmap"],
+            requiredWorkflowTools: ["gsd_plan_slice", "gsd_plan_task", "gsd_reassess_roadmap"],
         },
     },
     "refine-slice": {
@@ -298,7 +300,13 @@ export const UNIT_REGISTRY = {
         scopeClass: "execute-task",
         phaseChain: ["execution"],
         toolContract: {
-            allowedGsdTools: ["gsd_task_complete", "gsd_summary_save", "gsd_decision_save"],
+            allowedGsdTools: [
+                "gsd_milestone_status",
+                "gsd_task_complete",
+                "gsd_exec",
+                "gsd_summary_save",
+                "gsd_decision_save",
+            ],
             requiredWorkflowTools: ["gsd_task_complete", "gsd_summary_save"],
         },
     },

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

@@ -201,6 +201,13 @@ export function formatFailureContext(result) {
     }
     return header + body;
 }
+export function formatFailureSignature(result) {
+    return result.checks
+        .filter((check) => check.exitCode !== 0)
+        .map((check) => `${check.command.trim()}#${check.exitCode}`)
+        .sort()
+        .join("\n");
+}
 // ─── Gate Execution ─────────────────────────────────────────────────────────
 /** Characters that indicate shell control syntax when unquoted in a command string. */
 const UNQUOTED_SHELL_CONTROL_CHARS = new Set([";", "<", ">"]);