@opengsd/gsd-pi 1.3.0-dev.72e3af2a → 1.3.0-dev.738160b9

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": {

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([";", "<", ">"]);

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

@@ -1,11 +1,12 @@
 // Project/App: gsd-pi
 // File Purpose: State manifest snapshot and restore orchestration for GSD workflow data.
 import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.js";
-import { atomicWriteSync } from "./atomic-write.js";
+import { atomicWriteAsync, atomicWriteSync } from "./atomic-write.js";
 import { getAllDecisionsFromMemories } from "./context-store.js";
 import { backfillDecisionsToMemories } from "./memory-backfill.js";
 import { invalidateAllCaches } from "./cache.js";
-import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { logWarning } from "./workflow-logger.js";
+import { readFileSync, existsSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 // ─── helpers ─────────────────────────────────────────────────────────────
 function requireDb() {
@@ -257,22 +258,131 @@ export function snapshotState() {
         return result;
     });
 }
-// ─── restore ─────────────────────────────────────────────────────────────
-//
-// The actual restore() implementation lives in gsd-db.ts (single-writer
-// invariant). This module only orchestrates reading the manifest file
-// and handing it to the writer.
-// ─── writeManifest ───────────────────────────────────────────────────────
+const manifestWrites = new Map();
+let processTeardownFlushInstalled = false;
+let beforeExitFlushStarted = false;
+function manifestWriteKey(basePath) {
+    return resolve(basePath);
+}
+function manifestFilePath(basePath) {
+    return join(resolve(basePath), ".gsd", "state-manifest.json");
+}
+function describeError(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function logManifestWriteFailure(filePath, err) {
+    logWarning("manifest", `state manifest write failed: ${describeError(err)}`, { file: filePath });
+}
+async function drainManifestWrites(key, state) {
+    let lastWriteError = null;
+    try {
+        while (state.latestJson !== null && state.syncFlushJson === null) {
+            const json = state.latestJson;
+            state.latestJson = null;
+            state.inFlightJson = json;
+            try {
+                await atomicWriteAsync(state.filePath, json);
+                if (state.syncFlushJson !== null) {
+                    atomicWriteSync(state.filePath, state.syncFlushJson);
+                    break;
+                }
+                lastWriteError = null;
+            }
+            catch (err) {
+                lastWriteError = err;
+                logManifestWriteFailure(state.filePath, err);
+            }
+            finally {
+                state.inFlightJson = null;
+            }
+        }
+    }
+    finally {
+        state.active = null;
+        if (state.latestJson === null && state.inFlightJson === null) {
+            manifestWrites.delete(key);
+        }
+    }
+    if (lastWriteError !== null && state.syncFlushJson === null) {
+        throw lastWriteError;
+    }
+}
+function enqueueManifestWrite(basePath, json) {
+    const key = manifestWriteKey(basePath);
+    let state = manifestWrites.get(key);
+    if (!state) {
+        state = {
+            filePath: manifestFilePath(basePath),
+            latestJson: null,
+            inFlightJson: null,
+            syncFlushJson: null,
+            active: null,
+        };
+        manifestWrites.set(key, state);
+    }
+    state.latestJson = json;
+    if (!state.active) {
+        const active = drainManifestWrites(key, state);
+        void active.catch(() => { });
+        state.active = active;
+    }
+}
 /**
- * Write current DB state to .gsd/state-manifest.json via atomicWriteSync.
+ * Queue current DB state for an async atomic write to .gsd/state-manifest.json.
  * Uses JSON.stringify with 2-space indent for git three-way merge friendliness.
  */
 export function writeManifest(basePath) {
     const manifest = snapshotState();
     const json = JSON.stringify(manifest, null, 2);
-    const dir = join(basePath, ".gsd");
-    mkdirSync(dir, { recursive: true });
-    atomicWriteSync(join(dir, "state-manifest.json"), json);
+    enqueueManifestWrite(basePath, json);
+}
+async function flushManifestByKey(key) {
+    for (;;) {
+        const active = manifestWrites.get(key)?.active;
+        if (!active)
+            return;
+        await active;
+    }
+}
+/**
+ * Wait for any queued manifest write for this base path to become durable.
+ */
+export async function flushManifest(basePath) {
+    await flushManifestByKey(manifestWriteKey(basePath));
+}
+export async function flushAllManifests() {
+    await Promise.all(Array.from(manifestWrites.keys(), key => flushManifestByKey(key)));
+}
+function flushAllManifestsSync() {
+    for (const [key, state] of manifestWrites) {
+        const json = state.latestJson ?? state.inFlightJson;
+        if (json === null)
+            continue;
+        try {
+            atomicWriteSync(state.filePath, json);
+            state.latestJson = null;
+            state.inFlightJson = null;
+            state.syncFlushJson = json;
+            manifestWrites.delete(key);
+        }
+        catch (err) {
+            logManifestWriteFailure(state.filePath, err);
+        }
+    }
+}
+export function installManifestFlushOnProcessTeardown() {
+    if (processTeardownFlushInstalled)
+        return;
+    processTeardownFlushInstalled = true;
+    process.once("beforeExit", () => {
+        if (beforeExitFlushStarted)
+            return;
+        beforeExitFlushStarted = true;
+        void flushAllManifests();
+    });
+    process.once("exit", () => {
+        flushAllManifestsSync();
+    });
 }
 // ─── readManifest ────────────────────────────────────────────────────────
 /**
@@ -317,7 +427,10 @@ function restoreArtifactProjections(basePath, manifest) {
     if (manifest.artifacts === undefined)
         return;
     for (const artifact of manifest.artifacts) {
-        atomicWriteSync(artifactProjectionPath(basePath, artifact.path), artifact.full_content ?? "");
+        const content = artifact.full_content ?? "";
+        if (content === "")
+            continue;
+        atomicWriteSync(artifactProjectionPath(basePath, artifact.path), content);
     }
 }
 // ─── bootstrapFromManifest ──────────────────────────────────────────────