gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tools/reassess-roadmap.ts

@@ -0,0 +1,203 @@
+import { clearParseCache } from "../files.js";
+import {
+  transaction,
+  getMilestone,
+  getMilestoneSlices,
+  insertSlice,
+  updateSliceFields,
+  insertAssessment,
+  deleteSlice,
+} from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
+import { join } from "node:path";
+
+export interface SliceChangeInput {
+  sliceId: string;
+  title: string;
+  risk?: string;
+  depends?: string[];
+  demo?: string;
+}
+
+export interface ReassessRoadmapParams {
+  milestoneId: string;
+  completedSliceId: string;
+  verdict: string;
+  assessment: string;
+  sliceChanges: {
+    modified: SliceChangeInput[];
+    added: SliceChangeInput[];
+    removed: string[];
+  };
+}
+
+export interface ReassessRoadmapResult {
+  milestoneId: string;
+  completedSliceId: string;
+  assessmentPath: string;
+  roadmapPath: string;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function validateParams(params: ReassessRoadmapParams): ReassessRoadmapParams {
+  if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
+  if (!isNonEmptyString(params?.completedSliceId)) throw new Error("completedSliceId is required");
+  if (!isNonEmptyString(params?.verdict)) throw new Error("verdict is required");
+  if (!isNonEmptyString(params?.assessment)) throw new Error("assessment is required");
+
+  if (!params.sliceChanges || typeof params.sliceChanges !== "object") {
+    throw new Error("sliceChanges must be an object");
+  }
+
+  if (!Array.isArray(params.sliceChanges.modified)) {
+    throw new Error("sliceChanges.modified must be an array");
+  }
+
+  if (!Array.isArray(params.sliceChanges.added)) {
+    throw new Error("sliceChanges.added must be an array");
+  }
+
+  if (!Array.isArray(params.sliceChanges.removed)) {
+    throw new Error("sliceChanges.removed must be an array");
+  }
+
+  // Validate each modified slice
+  for (let i = 0; i < params.sliceChanges.modified.length; i++) {
+    const s = params.sliceChanges.modified[i];
+    if (!s || typeof s !== "object") throw new Error(`sliceChanges.modified[${i}] must be an object`);
+    if (!isNonEmptyString(s.sliceId)) throw new Error(`sliceChanges.modified[${i}].sliceId is required`);
+    if (!isNonEmptyString(s.title)) throw new Error(`sliceChanges.modified[${i}].title is required`);
+  }
+
+  // Validate each added slice
+  for (let i = 0; i < params.sliceChanges.added.length; i++) {
+    const s = params.sliceChanges.added[i];
+    if (!s || typeof s !== "object") throw new Error(`sliceChanges.added[${i}] must be an object`);
+    if (!isNonEmptyString(s.sliceId)) throw new Error(`sliceChanges.added[${i}].sliceId is required`);
+    if (!isNonEmptyString(s.title)) throw new Error(`sliceChanges.added[${i}].title is required`);
+  }
+
+  return params;
+}
+
+export async function handleReassessRoadmap(
+  rawParams: ReassessRoadmapParams,
+  basePath: string,
+): Promise<ReassessRoadmapResult | { error: string }> {
+  // ── Validate ──────────────────────────────────────────────────────
+  let params: ReassessRoadmapParams;
+  try {
+    params = validateParams(rawParams);
+  } catch (err) {
+    return { error: `validation failed: ${(err as Error).message}` };
+  }
+
+  // ── Verify milestone exists ───────────────────────────────────────
+  const milestone = getMilestone(params.milestoneId);
+  if (!milestone) {
+    return { error: `milestone not found: ${params.milestoneId}` };
+  }
+
+  // ── Structural enforcement ────────────────────────────────────────
+  const existingSlices = getMilestoneSlices(params.milestoneId);
+  const completedSliceIds = new Set<string>();
+  for (const slice of existingSlices) {
+    if (slice.status === "complete" || slice.status === "done") {
+      completedSliceIds.add(slice.id);
+    }
+  }
+
+  // Reject modifications to completed slices
+  for (const modifiedSlice of params.sliceChanges.modified) {
+    if (completedSliceIds.has(modifiedSlice.sliceId)) {
+      return { error: `cannot modify completed slice ${modifiedSlice.sliceId}` };
+    }
+  }
+
+  // Reject removal of completed slices
+  for (const removedId of params.sliceChanges.removed) {
+    if (completedSliceIds.has(removedId)) {
+      return { error: `cannot remove completed slice ${removedId}` };
+    }
+  }
+
+  // ── Compute assessment artifact path ──────────────────────────────
+  // Assessment lives in the completed slice's directory
+  const assessmentRelPath = join(
+    ".gsd", "milestones", params.milestoneId,
+    "slices", params.completedSliceId,
+    `${params.completedSliceId}-ASSESSMENT.md`,
+  );
+
+  // ── Transaction: DB mutations ─────────────────────────────────────
+  try {
+    transaction(() => {
+      // Record assessment
+      insertAssessment({
+        path: assessmentRelPath,
+        milestoneId: params.milestoneId,
+        sliceId: params.completedSliceId,
+        status: params.verdict,
+        scope: "roadmap",
+        fullContent: params.assessment,
+      });
+
+      // Apply slice modifications
+      for (const mod of params.sliceChanges.modified) {
+        updateSliceFields(params.milestoneId, mod.sliceId, {
+          title: mod.title,
+          risk: mod.risk,
+          depends: mod.depends,
+          demo: mod.demo,
+        });
+      }
+
+      // Insert new slices
+      for (const added of params.sliceChanges.added) {
+        insertSlice({
+          id: added.sliceId,
+          milestoneId: params.milestoneId,
+          title: added.title,
+          status: "pending",
+          risk: added.risk,
+          depends: added.depends,
+          demo: added.demo ?? "",
+        });
+      }
+
+      // Delete removed slices
+      for (const removedId of params.sliceChanges.removed) {
+        deleteSlice(params.milestoneId, removedId);
+      }
+    });
+  } catch (err) {
+    return { error: `db write failed: ${(err as Error).message}` };
+  }
+
+  // ── Render artifacts ──────────────────────────────────────────────
+  try {
+    const roadmapResult = await renderRoadmapFromDb(basePath, params.milestoneId);
+    const assessmentResult = await renderAssessmentFromDb(basePath, params.milestoneId, params.completedSliceId, {
+      verdict: params.verdict,
+      assessment: params.assessment,
+      completedSliceId: params.completedSliceId,
+    });
+
+    // ── Invalidate caches ─────────────────────────────────────────
+    invalidateStateCache();
+    clearParseCache();
+
+    return {
+      milestoneId: params.milestoneId,
+      completedSliceId: params.completedSliceId,
+      assessmentPath: assessmentResult.assessmentPath,
+      roadmapPath: roadmapResult.roadmapPath,
+    };
+  } catch (err) {
+    return { error: `render failed: ${(err as Error).message}` };
+  }
+}

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

@@ -0,0 +1,192 @@
+import { clearParseCache } from "../files.js";
+import {
+  transaction,
+  getSlice,
+  getSliceTasks,
+  getTask,
+  insertTask,
+  upsertTaskPlanning,
+  insertReplanHistory,
+  deleteTask,
+} from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderPlanFromDb, renderReplanFromDb } from "../markdown-renderer.js";
+
+export interface ReplanSliceTaskInput {
+  taskId: string;
+  title: string;
+  description: string;
+  estimate: string;
+  files: string[];
+  verify: string;
+  inputs: string[];
+  expectedOutput: string[];
+}
+
+export interface ReplanSliceParams {
+  milestoneId: string;
+  sliceId: string;
+  blockerTaskId: string;
+  blockerDescription: string;
+  whatChanged: string;
+  updatedTasks: ReplanSliceTaskInput[];
+  removedTaskIds: string[];
+}
+
+export interface ReplanSliceResult {
+  milestoneId: string;
+  sliceId: string;
+  replanPath: string;
+  planPath: string;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+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}` };
+  }
+
+  // ── Verify parent slice exists ────────────────────────────────────
+  const parentSlice = getSlice(params.milestoneId, params.sliceId);
+  if (!parentSlice) {
+    return { error: `missing parent slice: ${params.milestoneId}/${params.sliceId}` };
+  }
+
+  // ── Structural enforcement ────────────────────────────────────────
+  const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
+  const completedTaskIds = new Set<string>();
+  for (const task of existingTasks) {
+    if (task.status === "complete" || task.status === "done") {
+      completedTaskIds.add(task.id);
+    }
+  }
+
+  // Reject updates to completed tasks
+  for (const updatedTask of params.updatedTasks) {
+    if (completedTaskIds.has(updatedTask.taskId)) {
+      return { error: `cannot modify completed task ${updatedTask.taskId}` };
+    }
+  }
+
+  // Reject removal of completed tasks
+  for (const removedId of params.removedTaskIds) {
+    if (completedTaskIds.has(removedId)) {
+      return { error: `cannot remove completed task ${removedId}` };
+    }
+  }
+
+  // ── Transaction: DB mutations ─────────────────────────────────────
+  const existingTaskIds = new Set(existingTasks.map((t) => t.id));
+
+  try {
+    transaction(() => {
+      // 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 || [],
+          });
+        } 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 || [],
+          });
+        }
+      }
+
+      // 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}` };
+  }
+
+  // ── 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();
+
+    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/triage-resolution.ts

@@ -12,6 +12,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import type { Classification, CaptureEntry } from "./captures.js";
@@ -90,19 +91,37 @@ export function executeReplan(
     const triggerPath = join(
       basePath, ".gsd", "milestones", mid, "slices", sid, `${sid}-REPLAN-TRIGGER.md`,
     );
+    const ts = new Date().toISOString();
     const content = [
       `# Replan Trigger`,
       ``,
       `**Source:** Capture ${capture.id}`,
       `**Capture:** ${capture.text}`,
       `**Rationale:** ${capture.rationale ?? "User-initiated replan via capture triage"}`,
-      `**Triggered:** ${new Date().toISOString()}`,
+      `**Triggered:** ${ts}`,
       ``,
       `This file was created by the triage pipeline. The next dispatch cycle`,
       `will detect it and enter the replanning-slice phase.`,
     ].join("\n");
 
     writeFileSync(triggerPath, content, "utf-8");
+
+    // Also write replan_triggered_at column for DB-backed detection
+    try {
+      const req = createRequire(import.meta.url);
+      const { isDbAvailable, _getAdapter } = req("./gsd-db.js");
+      if (isDbAvailable()) {
+        const adapter = _getAdapter();
+        if (adapter) {
+          adapter.prepare(
+            "UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid",
+          ).run({ ":ts": ts, ":mid": mid, ":sid": sid });
+        }
+      }
+    } catch {
+      // DB write is best-effort — disk file is the primary trigger for fallback path
+    }
+
     return true;
   } catch {
     return false;

package/src/resources/extensions/gsd/types.ts

@@ -499,3 +499,53 @@ export interface BrowserFlowResult {
   checksPassed: number;
   duration: number;
 }
+
+// ─── Complete Task Params (gsd_complete_task tool input) ─────────────────
+
+export interface CompleteTaskParams {
+  taskId: string;
+  sliceId: string;
+  milestoneId: string;
+  oneLiner: string;
+  narrative: string;
+  verification: string;
+  keyFiles: string[];
+  keyDecisions: string[];
+  deviations: string;
+  knownIssues: string;
+  blockerDiscovered: boolean;
+  verificationEvidence: Array<{
+    command: string;
+    exitCode: number;
+    verdict: string;
+    durationMs: number;
+  }>;
+}
+
+// ─── Complete Slice Params (gsd_complete_slice tool input) ───────────────
+
+export interface CompleteSliceParams {
+  sliceId: string;
+  milestoneId: string;
+  sliceTitle: string;
+  oneLiner: string;
+  narrative: string;
+  verification: string;
+  keyFiles: string[];
+  keyDecisions: string[];
+  patternsEstablished: string[];
+  observabilitySurfaces: string[];
+  deviations: string;
+  knownLimitations: string;
+  followUps: string;
+  requirementsAdvanced: Array<{ id: string; how: string }>;
+  requirementsValidated: Array<{ id: string; proof: string }>;
+  requirementsSurfaced: string[];
+  requirementsInvalidated: Array<{ id: string; what: string }>;
+  filesModified: Array<{ path: string; description: string }>;
+  uatContent: string;
+  provides: string[];
+  requires: Array<{ slice: string; provides: string }>;
+  affects: string[];
+  drillDownPaths: string[];
+}