lsd-pi 1.0.0 → 1.1.0

package/src/resources/extensions/gsd/tools/reopen-slice.ts

@@ -1,126 +0,0 @@
-/**
- * reopen-slice handler — the core operation behind gsd_slice_reopen.
- *
- * Resets a completed slice back to "in_progress" and resets ALL of its
- * tasks back to "pending". This is intentional — if you're reopening a
- * slice, you're re-doing the work. Partial resets create ambiguous state.
- *
- * The parent milestone must still be open (not complete).
- */
-
-// GSD — reopen-slice tool handler
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-
-import {
-  getMilestone,
-  getSlice,
-  getSliceTasks,
-  updateSliceStatus,
-  updateTaskStatus,
-  transaction,
-} from "../gsd-db.js";
-import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
-import { writeManifest } from "../workflow-manifest.js";
-import { appendEvent } from "../workflow-events.js";
-
-export interface ReopenSliceParams {
-  milestoneId: string;
-  sliceId: string;
-  reason?: string;
-  /** Optional caller-provided identity for audit trail */
-  actorName?: string;
-  /** Optional caller-provided reason this action was triggered */
-  triggerReason?: string;
-}
-
-export interface ReopenSliceResult {
-  milestoneId: string;
-  sliceId: string;
-  tasksReset: number;
-}
-
-export async function handleReopenSlice(
-  params: ReopenSliceParams,
-  basePath: string,
-): Promise<ReopenSliceResult | { error: string }> {
-  // ── Validate required fields ────────────────────────────────────────────
-  if (!params.sliceId || typeof params.sliceId !== "string" || params.sliceId.trim() === "") {
-    return { error: "sliceId is required and must be a non-empty string" };
-  }
-  if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
-    return { error: "milestoneId is required and must be a non-empty string" };
-  }
-
-  // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-  let guardError: string | null = null;
-  let tasksResetCount = 0;
-
-  transaction(() => {
-    const milestone = getMilestone(params.milestoneId);
-    if (!milestone) {
-      guardError = `milestone not found: ${params.milestoneId}`;
-      return;
-    }
-    if (isClosedStatus(milestone.status)) {
-      guardError = `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
-      return;
-    }
-
-    const slice = getSlice(params.milestoneId, params.sliceId);
-    if (!slice) {
-      guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
-      return;
-    }
-    if (!isClosedStatus(slice.status)) {
-      guardError = `slice ${params.sliceId} is not complete (status: ${slice.status}) — nothing to reopen`;
-      return;
-    }
-
-    // Fetch tasks inside txn so the list is consistent with the slice status check
-    const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-    tasksResetCount = tasks.length;
-
-    updateSliceStatus(params.milestoneId, params.sliceId, "in_progress");
-    for (const task of tasks) {
-      updateTaskStatus(params.milestoneId, params.sliceId, task.id, "pending");
-    }
-  });
-
-  if (guardError) {
-    return { error: guardError };
-  }
-
-  // ── Invalidate caches ────────────────────────────────────────────────────
-  invalidateStateCache();
-
-  // ── Post-mutation hook ───────────────────────────────────────────────────
-  try {
-    await renderAllProjections(basePath, params.milestoneId);
-    writeManifest(basePath);
-    appendEvent(basePath, {
-      cmd: "reopen-slice",
-      params: {
-        milestoneId: params.milestoneId,
-        sliceId: params.sliceId,
-        reason: params.reason ?? null,
-        tasksReset: tasksResetCount,
-      },
-      ts: new Date().toISOString(),
-      actor: "agent",
-      actor_name: params.actorName,
-      trigger_reason: params.triggerReason,
-    });
-  } catch (hookErr) {
-    process.stderr.write(
-      `gsd: reopen-slice post-mutation hook warning: ${(hookErr as Error).message}\n`,
-    );
-  }
-
-  return {
-    milestoneId: params.milestoneId,
-    sliceId: params.sliceId,
-    tasksReset: tasksResetCount,
-  };
-}

package/src/resources/extensions/gsd/tools/reopen-task.ts

@@ -1,130 +0,0 @@
-/**
- * reopen-task handler — the core operation behind gsd_task_reopen.
- *
- * Resets a completed task back to "pending" so it can be re-done
- * without manual SQL surgery. The parent slice and milestone must
- * still be open (not complete) — you cannot reopen tasks inside a
- * closed slice.
- */
-
-// GSD — reopen-task tool handler
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-
-import {
-  getMilestone,
-  getSlice,
-  getTask,
-  updateTaskStatus,
-  transaction,
-} from "../gsd-db.js";
-import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
-import { writeManifest } from "../workflow-manifest.js";
-import { appendEvent } from "../workflow-events.js";
-
-export interface ReopenTaskParams {
-  milestoneId: string;
-  sliceId: string;
-  taskId: string;
-  reason?: string;
-  /** Optional caller-provided identity for audit trail */
-  actorName?: string;
-  /** Optional caller-provided reason this action was triggered */
-  triggerReason?: string;
-}
-
-export interface ReopenTaskResult {
-  milestoneId: string;
-  sliceId: string;
-  taskId: string;
-}
-
-export async function handleReopenTask(
-  params: ReopenTaskParams,
-  basePath: string,
-): Promise<ReopenTaskResult | { error: string }> {
-  // ── Validate required fields ────────────────────────────────────────────
-  if (!params.taskId || typeof params.taskId !== "string" || params.taskId.trim() === "") {
-    return { error: "taskId is required and must be a non-empty string" };
-  }
-  if (!params.sliceId || typeof params.sliceId !== "string" || params.sliceId.trim() === "") {
-    return { error: "sliceId is required and must be a non-empty string" };
-  }
-  if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
-    return { error: "milestoneId is required and must be a non-empty string" };
-  }
-
-  // ── Guards + DB write inside a single transaction (prevents TOCTOU) ────
-  let guardError: string | null = null;
-
-  transaction(() => {
-    const milestone = getMilestone(params.milestoneId);
-    if (!milestone) {
-      guardError = `milestone not found: ${params.milestoneId}`;
-      return;
-    }
-    if (isClosedStatus(milestone.status)) {
-      guardError = `cannot reopen task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
-      return;
-    }
-
-    const slice = getSlice(params.milestoneId, params.sliceId);
-    if (!slice) {
-      guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
-      return;
-    }
-    if (isClosedStatus(slice.status)) {
-      guardError = `cannot reopen task in a closed slice: ${params.sliceId} (status: ${slice.status}) — use gsd_slice_reopen first`;
-      return;
-    }
-
-    const task = getTask(params.milestoneId, params.sliceId, params.taskId);
-    if (!task) {
-      guardError = `task not found: ${params.milestoneId}/${params.sliceId}/${params.taskId}`;
-      return;
-    }
-    if (!isClosedStatus(task.status)) {
-      guardError = `task ${params.taskId} is not complete (status: ${task.status}) — nothing to reopen`;
-      return;
-    }
-
-    updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, "pending");
-  });
-
-  if (guardError) {
-    return { error: guardError };
-  }
-
-  // ── Invalidate caches ────────────────────────────────────────────────────
-  invalidateStateCache();
-
-  // ── Post-mutation hook ───────────────────────────────────────────────────
-  try {
-    await renderAllProjections(basePath, params.milestoneId);
-    writeManifest(basePath);
-    appendEvent(basePath, {
-      cmd: "reopen-task",
-      params: {
-        milestoneId: params.milestoneId,
-        sliceId: params.sliceId,
-        taskId: params.taskId,
-        reason: params.reason ?? null,
-      },
-      ts: new Date().toISOString(),
-      actor: "agent",
-      actor_name: params.actorName,
-      trigger_reason: params.triggerReason,
-    });
-  } catch (hookErr) {
-    process.stderr.write(
-      `gsd: reopen-task post-mutation hook warning: ${(hookErr as Error).message}\n`,
-    );
-  }
-
-  return {
-    milestoneId: params.milestoneId,
-    sliceId: params.sliceId,
-    taskId: params.taskId,
-  };
-}

package/src/resources/extensions/gsd/tools/replan-slice.ts

@@ -1,243 +0,0 @@
-import { clearParseCache } from "../files.js";
-import {
-  transaction,
-  getSlice,
-  getSliceTasks,
-  getTask,
-  insertTask,
-  upsertTaskPlanning,
-  insertReplanHistory,
-  deleteTask,
-} from "../gsd-db.js";
-import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
-import { isNonEmptyString } from "../validation.js";
-import { renderPlanFromDb, renderReplanFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
-import { writeManifest } from "../workflow-manifest.js";
-import { appendEvent } from "../workflow-events.js";
-
-export interface ReplanSliceTaskInput {
-  taskId: string;
-  title: string;
-  description: string;
-  estimate: string;
-  files: string[];
-  verify: string;
-  inputs: string[];
-  expectedOutput: string[];
-  fullPlanMd?: string;
-}
-
-export interface ReplanSliceParams {
-  milestoneId: string;
-  sliceId: string;
-  blockerTaskId: string;
-  blockerDescription: string;
-  whatChanged: string;
-  updatedTasks: ReplanSliceTaskInput[];
-  removedTaskIds: string[];
-  /** Optional caller-provided identity for audit trail */
-  actorName?: string;
-  /** Optional caller-provided reason this action was triggered */
-  triggerReason?: string;
-}
-
-export interface ReplanSliceResult {
-  milestoneId: string;
-  sliceId: string;
-  replanPath: string;
-  planPath: string;
-}
-
-function validateParams(params: ReplanSliceParams): ReplanSliceParams {
-  if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
-  if (!isNonEmptyString(params?.sliceId)) throw new Error("sliceId is required");
-  if (!isNonEmptyString(params?.blockerTaskId)) throw new Error("blockerTaskId is required");
-  if (!isNonEmptyString(params?.blockerDescription)) throw new Error("blockerDescription is required");
-  if (!isNonEmptyString(params?.whatChanged)) throw new Error("whatChanged is required");
-
-  if (!Array.isArray(params.updatedTasks)) {
-    throw new Error("updatedTasks must be an array");
-  }
-
-  if (!Array.isArray(params.removedTaskIds)) {
-    throw new Error("removedTaskIds must be an array");
-  }
-
-  // Validate each updated task
-  for (let i = 0; i < params.updatedTasks.length; i++) {
-    const t = params.updatedTasks[i];
-    if (!t || typeof t !== "object") throw new Error(`updatedTasks[${i}] must be an object`);
-    if (!isNonEmptyString(t.taskId)) throw new Error(`updatedTasks[${i}].taskId is required`);
-    if (!isNonEmptyString(t.title)) throw new Error(`updatedTasks[${i}].title is required`);
-  }
-
-  return params;
-}
-
-export async function handleReplanSlice(
-  rawParams: ReplanSliceParams,
-  basePath: string,
-): Promise<ReplanSliceResult | { error: string }> {
-  // ── Validate ──────────────────────────────────────────────────────
-  let params: ReplanSliceParams;
-  try {
-    params = validateParams(rawParams);
-  } catch (err) {
-    return { error: `validation failed: ${(err as Error).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).
-  let guardError: string | null = null;
-  let existingTaskIds: Set<string> = new Set();
-
-  try {
-    transaction(() => {
-      // Verify parent slice exists and is not closed
-      const parentSlice = getSlice(params.milestoneId, params.sliceId);
-      if (!parentSlice) {
-        guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
-        return;
-      }
-      if (isClosedStatus(parentSlice.status)) {
-        guardError = `cannot replan a closed slice: ${params.sliceId} (status: ${parentSlice.status})`;
-        return;
-      }
-
-      // Verify blocker task exists and is complete
-      const blockerTask = getTask(params.milestoneId, params.sliceId, params.blockerTaskId);
-      if (!blockerTask) {
-        guardError = `blockerTaskId not found: ${params.milestoneId}/${params.sliceId}/${params.blockerTaskId}`;
-        return;
-      }
-      if (!isClosedStatus(blockerTask.status)) {
-        guardError = `blockerTaskId ${params.blockerTaskId} is not complete (status: ${blockerTask.status}) — the blocker task must be finished before a replan is triggered`;
-        return;
-      }
-
-      // Structural enforcement — reject modifications/removal of completed tasks
-      const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
-      const completedTaskIds = new Set<string>();
-      for (const task of existingTasks) {
-        if (isClosedStatus(task.status)) {
-          completedTaskIds.add(task.id);
-        }
-      }
-
-      for (const updatedTask of params.updatedTasks) {
-        if (completedTaskIds.has(updatedTask.taskId)) {
-          guardError = `cannot modify completed task ${updatedTask.taskId}`;
-          return;
-        }
-      }
-
-      for (const removedId of params.removedTaskIds) {
-        if (completedTaskIds.has(removedId)) {
-          guardError = `cannot remove completed task ${removedId}`;
-          return;
-        }
-      }
-
-      existingTaskIds = new Set(existingTasks.map((t) => t.id));
-
-      // Record replan history
-      insertReplanHistory({
-        milestoneId: params.milestoneId,
-        sliceId: params.sliceId,
-        taskId: params.blockerTaskId,
-        summary: params.whatChanged,
-      });
-
-      // Apply task updates (upsert existing, insert new)
-      for (const updatedTask of params.updatedTasks) {
-        if (existingTaskIds.has(updatedTask.taskId)) {
-          // Update existing task's planning fields
-          upsertTaskPlanning(params.milestoneId, params.sliceId, updatedTask.taskId, {
-            title: updatedTask.title,
-            description: updatedTask.description || "",
-            estimate: updatedTask.estimate || "",
-            files: updatedTask.files || [],
-            verify: updatedTask.verify || "",
-            inputs: updatedTask.inputs || [],
-            expectedOutput: updatedTask.expectedOutput || [],
-            fullPlanMd: updatedTask.fullPlanMd,
-          });
-        } else {
-          // Insert new task then set planning fields
-          insertTask({
-            id: updatedTask.taskId,
-            sliceId: params.sliceId,
-            milestoneId: params.milestoneId,
-            title: updatedTask.title,
-            status: "pending",
-          });
-          upsertTaskPlanning(params.milestoneId, params.sliceId, updatedTask.taskId, {
-            title: updatedTask.title,
-            description: updatedTask.description || "",
-            estimate: updatedTask.estimate || "",
-            files: updatedTask.files || [],
-            verify: updatedTask.verify || "",
-            inputs: updatedTask.inputs || [],
-            expectedOutput: updatedTask.expectedOutput || [],
-            fullPlanMd: updatedTask.fullPlanMd,
-          });
-        }
-      }
-
-      // Delete removed tasks
-      for (const removedId of params.removedTaskIds) {
-        deleteTask(params.milestoneId, params.sliceId, removedId);
-      }
-    });
-  } catch (err) {
-    return { error: `db write failed: ${(err as Error).message}` };
-  }
-
-  if (guardError) {
-    return { error: guardError };
-  }
-
-  // ── Render artifacts ──────────────────────────────────────────────
-  try {
-    const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
-    const replanResult = await renderReplanFromDb(basePath, params.milestoneId, params.sliceId, {
-      blockerTaskId: params.blockerTaskId,
-      blockerDescription: params.blockerDescription,
-      whatChanged: params.whatChanged,
-    });
-
-    // ── Invalidate caches ─────────────────────────────────────────
-    invalidateStateCache();
-    clearParseCache();
-
-    // ── Post-mutation hook: projections, manifest, event log ─────
-    try {
-      await renderAllProjections(basePath, params.milestoneId);
-      writeManifest(basePath);
-      appendEvent(basePath, {
-        cmd: "replan-slice",
-        params: { milestoneId: params.milestoneId, sliceId: params.sliceId, blockerTaskId: params.blockerTaskId },
-        ts: new Date().toISOString(),
-        actor: "agent",
-        actor_name: params.actorName,
-        trigger_reason: params.triggerReason,
-      });
-    } catch (hookErr) {
-      process.stderr.write(
-        `gsd: replan-slice post-mutation hook warning: ${(hookErr as Error).message}\n`,
-      );
-    }
-
-    return {
-      milestoneId: params.milestoneId,
-      sliceId: params.sliceId,
-      replanPath: replanResult.replanPath,
-      planPath: renderResult.planPath,
-    };
-  } catch (err) {
-    return { error: `render failed: ${(err as Error).message}` };
-  }
-}

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -1,156 +0,0 @@
-/**
- * validate-milestone handler — the core operation behind gsd_validate_milestone.
- *
- * Persists milestone validation results to the assessments table and
- * quality_gates table, renders VALIDATION.md to disk, and invalidates caches.
- *
- * #2945 Bug 4: Previously only wrote to assessments — quality_gates records
- * were never persisted, causing M002+ milestones to have zero gate records
- * despite passing validation.
- */
-
-import { join } from "node:path";
-
-import {
-  transaction,
-  insertAssessment,
-  deleteAssessmentByScope,
-  getMilestoneSlices,
-} from "../gsd-db.js";
-import { resolveMilestonePath, clearPathCache } from "../paths.js";
-import { saveFile, clearParseCache } from "../files.js";
-import { invalidateStateCache } from "../state.js";
-import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
-import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
-
-export interface ValidateMilestoneParams {
-  milestoneId: string;
-  verdict: "pass" | "needs-attention" | "needs-remediation";
-  remediationRound: number;
-  successCriteriaChecklist: string;
-  sliceDeliveryAudit: string;
-  crossSliceIntegration: string;
-  requirementCoverage: string;
-  verificationClasses?: string;
-  verdictRationale: string;
-  remediationPlan?: string;
-}
-
-export interface ValidateMilestoneResult {
-  milestoneId: string;
-  verdict: string;
-  validationPath: string;
-}
-
-function renderValidationMarkdown(params: ValidateMilestoneParams): string {
-  let md = `---
-verdict: ${params.verdict}
-remediation_round: ${params.remediationRound}
----
-
-# Milestone Validation: ${params.milestoneId}
-
-## Success Criteria Checklist
-${params.successCriteriaChecklist}
-
-## Slice Delivery Audit
-${params.sliceDeliveryAudit}
-
-## Cross-Slice Integration
-${params.crossSliceIntegration}
-
-## Requirement Coverage
-${params.requirementCoverage}
-
-${params.verificationClasses ? `## Verification Class Compliance
-${params.verificationClasses}
-
-` : ""}
-## Verdict Rationale
-${params.verdictRationale}
-`;
-
-  if (params.verdict === "needs-remediation" && params.remediationPlan) {
-    md += `\n## Remediation Plan\n${params.remediationPlan}\n`;
-  }
-
-  return md;
-}
-
-export async function handleValidateMilestone(
-  params: ValidateMilestoneParams,
-  basePath: string,
-): Promise<ValidateMilestoneResult | { error: string }> {
-  if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
-    return { error: "milestoneId is required and must be a non-empty string" };
-  }
-  if (!isValidMilestoneVerdict(params.verdict)) {
-    return { error: `verdict must be one of: ${VALIDATION_VERDICTS.join(", ")}` };
-  }
-
-  // ── Resolve paths and render markdown ────────────────────────────────
-  const validationMd = renderValidationMarkdown(params);
-
-  let validationPath: string;
-  const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
-  if (milestoneDir) {
-    validationPath = join(milestoneDir, `${params.milestoneId}-VALIDATION.md`);
-  } else {
-    const gsdDir = join(basePath, ".gsd");
-    const manualDir = join(gsdDir, "milestones", params.milestoneId);
-    validationPath = join(manualDir, `${params.milestoneId}-VALIDATION.md`);
-  }
-
-  // ── DB write first — matches complete-task/complete-slice pattern ───
-  // Write DB before disk so a crash between the two leaves a recoverable
-  // state: the DB row exists but the file is missing, which projection
-  // rendering can regenerate. The inverse (file exists, no DB row) is
-  // harder to detect and recover from (#2725).
-  const validatedAt = new Date().toISOString();
-
-  transaction(() => {
-    insertAssessment({
-      path: validationPath,
-      milestoneId: params.milestoneId,
-      sliceId: null,
-      taskId: null,
-      status: params.verdict,
-      scope: 'milestone-validation',
-      fullContent: validationMd,
-    });
-
-    // #2945 Bug 4: persist quality_gates records alongside the assessment.
-    // Previously only the assessment was written, leaving M002+ milestones
-    // with zero quality_gate records despite passing validation.
-    const slices = getMilestoneSlices(params.milestoneId);
-    const sliceId = slices.length > 0 ? slices[0].id : "_milestone";
-    insertMilestoneValidationGates(
-      params.milestoneId,
-      sliceId,
-      params.verdict,
-      validatedAt,
-    );
-  });
-
-  // ── Filesystem render (outside transaction) ────────────────────────────
-  // If disk render fails, roll back the DB row so state stays consistent.
-  try {
-    await saveFile(validationPath, validationMd);
-  } catch (renderErr) {
-    process.stderr.write(
-      `gsd-db: validate_milestone — disk render failed, rolling back DB row: ${(renderErr as Error).message}\n`,
-    );
-    deleteAssessmentByScope(params.milestoneId, 'milestone-validation');
-    return { error: `disk render failed: ${(renderErr as Error).message}` };
-  }
-
-  invalidateStateCache();
-  clearPathCache();
-  clearParseCache();
-
-  return {
-    milestoneId: params.milestoneId,
-    verdict: params.verdict,
-    validationPath,
-  };
-}