@opengsd/gsd-pi 1.3.0-dev.965d1788 → 1.3.0-dev.cca9c184

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/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/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 ────────────────────────────────────────────────────────
 /**