gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

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

@@ -0,0 +1,245 @@
+/**
+ * complete-task handler — the core operation behind gsd_complete_task.
+ *
+ * Validates inputs, writes task row to DB in a transaction, then (outside
+ * the transaction) renders SUMMARY.md to disk, toggles the plan checkbox,
+ * stores the rendered markdown in the DB for D004 recovery, and invalidates
+ * caches.
+ */
+
+import { join } from "node:path";
+import { mkdirSync, existsSync } from "node:fs";
+
+import type { CompleteTaskParams } from "../types.js";
+import {
+  transaction,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  insertVerificationEvidence,
+  _getAdapter,
+} from "../gsd-db.js";
+import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
+import { saveFile, clearParseCache } from "../files.js";
+import { invalidateStateCache } from "../state.js";
+import { renderPlanCheckboxes } from "../markdown-renderer.js";
+
+export interface CompleteTaskResult {
+  taskId: string;
+  sliceId: string;
+  milestoneId: string;
+  summaryPath: string;
+}
+
+/**
+ * Render task summary markdown matching the template format.
+ * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
+ */
+function renderSummaryMarkdown(params: CompleteTaskParams): string {
+  const now = new Date().toISOString();
+  const keyFilesYaml = params.keyFiles.length > 0
+    ? params.keyFiles.map(f => `  - ${f}`).join("\n")
+    : "  - (none)";
+  const keyDecisionsYaml = params.keyDecisions.length > 0
+    ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
+    : "  - (none)";
+
+  // Build verification evidence table rows
+  let evidenceTable = "| # | Command | Exit Code | Verdict | Duration |\n|---|---------|-----------|---------|----------|\n";
+  if (params.verificationEvidence.length > 0) {
+    params.verificationEvidence.forEach((e, i) => {
+      evidenceTable += `| ${i + 1} | \`${e.command}\` | ${e.exitCode} | ${e.verdict} | ${e.durationMs}ms |\n`;
+    });
+  } else {
+    evidenceTable += "| — | No verification commands discovered | — | — | — |\n";
+  }
+
+  // Determine verification_result from evidence
+  const allPassed = params.verificationEvidence.length > 0 &&
+    params.verificationEvidence.every(e => e.exitCode === 0 || e.verdict.includes("✅") || e.verdict.toLowerCase().includes("pass"));
+  const verificationResult = allPassed ? "passed" : (params.verificationEvidence.length === 0 ? "untested" : "mixed");
+
+  // Extract a title from the oneLiner or taskId
+  const title = params.oneLiner || params.taskId;
+
+  return `---
+id: ${params.taskId}
+parent: ${params.sliceId}
+milestone: ${params.milestoneId}
+key_files:
+${keyFilesYaml}
+key_decisions:
+${keyDecisionsYaml}
+duration: ""
+verification_result: ${verificationResult}
+completed_at: ${now}
+blocker_discovered: ${params.blockerDiscovered}
+---
+
+# ${params.taskId}: ${title}
+
+**${params.oneLiner}**
+
+## What Happened
+
+${params.narrative}
+
+## Verification
+
+${params.verification}
+
+## Verification Evidence
+
+${evidenceTable}
+
+## Deviations
+
+${params.deviations || "None."}
+
+## Known Issues
+
+${params.knownIssues || "None."}
+
+## Files Created/Modified
+
+${params.keyFiles.map(f => `- \`${f}\``).join("\n") || "None."}
+`;
+}
+
+/**
+ * Handle the complete_task operation end-to-end.
+ *
+ * 1. Validate required fields
+ * 2. Write DB in a transaction (milestone, slice, task, verification evidence)
+ * 3. Render SUMMARY.md to disk
+ * 4. Toggle plan checkbox
+ * 5. Store rendered markdown back in DB (for D004 recovery)
+ * 6. Invalidate caches
+ */
+export async function handleCompleteTask(
+  params: CompleteTaskParams,
+  basePath: string,
+): Promise<CompleteTaskResult | { 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" };
+  }
+
+  // ── DB writes inside a transaction ──────────────────────────────────────
+  const completedAt = new Date().toISOString();
+
+  transaction(() => {
+    insertMilestone({ id: params.milestoneId });
+    insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
+    insertTask({
+      id: params.taskId,
+      sliceId: params.sliceId,
+      milestoneId: params.milestoneId,
+      title: params.oneLiner,
+      status: "complete",
+      oneLiner: params.oneLiner,
+      narrative: params.narrative,
+      verificationResult: params.verification,
+      duration: "",
+      blockerDiscovered: params.blockerDiscovered,
+      deviations: params.deviations,
+      knownIssues: params.knownIssues,
+      keyFiles: params.keyFiles,
+      keyDecisions: params.keyDecisions,
+    });
+
+    for (const evidence of params.verificationEvidence) {
+      insertVerificationEvidence({
+        taskId: params.taskId,
+        sliceId: params.sliceId,
+        milestoneId: params.milestoneId,
+        command: evidence.command,
+        exitCode: evidence.exitCode,
+        verdict: evidence.verdict,
+        durationMs: evidence.durationMs,
+      });
+    }
+  });
+
+  // ── Filesystem operations (outside transaction) ─────────────────────────
+  // If disk render fails, roll back the DB status so deriveState() and
+  // verifyExpectedArtifact() stay consistent (both say "not done").
+
+  // Render summary markdown
+  const summaryMd = renderSummaryMarkdown(params);
+
+  // Resolve and write summary to disk
+  let summaryPath: string;
+  const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+  if (tasksDir) {
+    summaryPath = join(tasksDir, `${params.taskId}-SUMMARY.md`);
+  } else {
+    // Tasks dir doesn't exist on disk yet — build path manually and ensure dirs
+    const gsdDir = join(basePath, ".gsd");
+    const manualTasksDir = join(gsdDir, "milestones", params.milestoneId, "slices", params.sliceId, "tasks");
+    mkdirSync(manualTasksDir, { recursive: true });
+    summaryPath = join(manualTasksDir, `${params.taskId}-SUMMARY.md`);
+  }
+
+  try {
+    await saveFile(summaryPath, summaryMd);
+
+    // Toggle plan checkbox via renderer module
+    const planPath = resolveSliceFile(basePath, params.milestoneId, params.sliceId, "PLAN");
+    if (planPath) {
+      await renderPlanCheckboxes(basePath, params.milestoneId, params.sliceId);
+    } else {
+      process.stderr.write(
+        `gsd-db: complete_task — could not find plan file for ${params.sliceId}/${params.milestoneId}, skipping checkbox toggle\n`,
+      );
+    }
+  } catch (renderErr) {
+    // Disk render failed — roll back DB status so state stays consistent
+    process.stderr.write(
+      `gsd-db: complete_task — disk render failed, rolling back DB status: ${(renderErr as Error).message}\n`,
+    );
+    const rollbackAdapter = _getAdapter();
+    if (rollbackAdapter) {
+      rollbackAdapter.prepare(
+        `UPDATE tasks SET status = 'pending' WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`,
+      ).run({
+        ":mid": params.milestoneId,
+        ":sid": params.sliceId,
+        ":tid": params.taskId,
+      });
+    }
+    invalidateStateCache();
+    return { error: `disk render failed: ${(renderErr as Error).message}` };
+  }
+
+  // Store rendered markdown in DB for D004 recovery
+  const adapter = _getAdapter();
+  if (adapter) {
+    adapter.prepare(
+      `UPDATE tasks SET full_summary_md = :md WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`,
+    ).run({
+      ":md": summaryMd,
+      ":mid": params.milestoneId,
+      ":sid": params.sliceId,
+      ":tid": params.taskId,
+    });
+  }
+
+  // Invalidate all caches
+  invalidateStateCache();
+  clearPathCache();
+  clearParseCache();
+
+  return {
+    taskId: params.taskId,
+    sliceId: params.sliceId,
+    milestoneId: params.milestoneId,
+    summaryPath,
+  };
+}

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

@@ -0,0 +1,249 @@
+import { clearParseCache } from "../files.js";
+import {
+  transaction,
+  insertMilestone,
+  insertSlice,
+  upsertMilestonePlanning,
+  upsertSlicePlanning,
+  _getAdapter,
+} from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderRoadmapFromDb } from "../markdown-renderer.js";
+
+export interface PlanMilestoneSliceInput {
+  sliceId: string;
+  title: string;
+  risk: string;
+  depends: string[];
+  demo: string;
+  goal: string;
+  successCriteria: string;
+  proofLevel: string;
+  integrationClosure: string;
+  observabilityImpact: string;
+}
+
+export interface PlanMilestoneParams {
+  milestoneId: string;
+  title: string;
+  status?: string;
+  dependsOn?: string[];
+  vision: string;
+  successCriteria: string[];
+  keyRisks: Array<{ risk: string; whyItMatters: string }>;
+  proofStrategy: Array<{ riskOrUnknown: string; retireIn: string; whatWillBeProven: string }>;
+  verificationContract: string;
+  verificationIntegration: string;
+  verificationOperational: string;
+  verificationUat: string;
+  definitionOfDone: string[];
+  requirementCoverage: string;
+  boundaryMapMarkdown: string;
+  slices: PlanMilestoneSliceInput[];
+}
+
+export interface PlanMilestoneResult {
+  milestoneId: string;
+  roadmapPath: string;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function validateStringArray(value: unknown, field: string): string[] {
+  if (!Array.isArray(value)) {
+    throw new Error(`${field} must be an array`);
+  }
+  if (value.some((item) => !isNonEmptyString(item))) {
+    throw new Error(`${field} must contain only non-empty strings`);
+  }
+  return value;
+}
+
+function validateRiskEntries(value: unknown): Array<{ risk: string; whyItMatters: string }> {
+  if (!Array.isArray(value)) {
+    throw new Error("keyRisks must be an array");
+  }
+  return value.map((entry, index) => {
+    if (!entry || typeof entry !== "object") {
+      throw new Error(`keyRisks[${index}] must be an object`);
+    }
+    const risk = (entry as Record<string, unknown>).risk;
+    const whyItMatters = (entry as Record<string, unknown>).whyItMatters;
+    if (!isNonEmptyString(risk) || !isNonEmptyString(whyItMatters)) {
+      throw new Error(`keyRisks[${index}] must include non-empty risk and whyItMatters`);
+    }
+    return { risk, whyItMatters };
+  });
+}
+
+function validateProofStrategy(value: unknown): Array<{ riskOrUnknown: string; retireIn: string; whatWillBeProven: string }> {
+  if (!Array.isArray(value)) {
+    throw new Error("proofStrategy must be an array");
+  }
+  return value.map((entry, index) => {
+    if (!entry || typeof entry !== "object") {
+      throw new Error(`proofStrategy[${index}] must be an object`);
+    }
+    const riskOrUnknown = (entry as Record<string, unknown>).riskOrUnknown;
+    const retireIn = (entry as Record<string, unknown>).retireIn;
+    const whatWillBeProven = (entry as Record<string, unknown>).whatWillBeProven;
+    if (!isNonEmptyString(riskOrUnknown) || !isNonEmptyString(retireIn) || !isNonEmptyString(whatWillBeProven)) {
+      throw new Error(`proofStrategy[${index}] must include non-empty riskOrUnknown, retireIn, and whatWillBeProven`);
+    }
+    return { riskOrUnknown, retireIn, whatWillBeProven };
+  });
+}
+
+function validateSlices(value: unknown): PlanMilestoneSliceInput[] {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("slices must be a non-empty array");
+  }
+
+  const seen = new Set<string>();
+  return value.map((entry, index) => {
+    if (!entry || typeof entry !== "object") {
+      throw new Error(`slices[${index}] must be an object`);
+    }
+    const obj = entry as Record<string, unknown>;
+    const sliceId = obj.sliceId;
+    const title = obj.title;
+    const risk = obj.risk;
+    const depends = obj.depends;
+    const demo = obj.demo;
+    const goal = obj.goal;
+    const successCriteria = obj.successCriteria;
+    const proofLevel = obj.proofLevel;
+    const integrationClosure = obj.integrationClosure;
+    const observabilityImpact = obj.observabilityImpact;
+
+    if (!isNonEmptyString(sliceId)) throw new Error(`slices[${index}].sliceId must be a non-empty string`);
+    if (seen.has(sliceId)) throw new Error(`slices[${index}].sliceId must be unique`);
+    seen.add(sliceId);
+    if (!isNonEmptyString(title)) throw new Error(`slices[${index}].title must be a non-empty string`);
+    if (!isNonEmptyString(risk)) throw new Error(`slices[${index}].risk must be a non-empty string`);
+    if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item))) {
+      throw new Error(`slices[${index}].depends must be an array of non-empty strings`);
+    }
+    if (!isNonEmptyString(demo)) throw new Error(`slices[${index}].demo must be a non-empty string`);
+    if (!isNonEmptyString(goal)) throw new Error(`slices[${index}].goal must be a non-empty string`);
+    if (!isNonEmptyString(successCriteria)) throw new Error(`slices[${index}].successCriteria must be a non-empty string`);
+    if (!isNonEmptyString(proofLevel)) throw new Error(`slices[${index}].proofLevel must be a non-empty string`);
+    if (!isNonEmptyString(integrationClosure)) throw new Error(`slices[${index}].integrationClosure must be a non-empty string`);
+    if (!isNonEmptyString(observabilityImpact)) throw new Error(`slices[${index}].observabilityImpact must be a non-empty string`);
+
+    return {
+      sliceId,
+      title,
+      risk,
+      depends,
+      demo,
+      goal,
+      successCriteria,
+      proofLevel,
+      integrationClosure,
+      observabilityImpact,
+    };
+  });
+}
+
+function validateParams(params: PlanMilestoneParams): PlanMilestoneParams {
+  if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
+  if (!isNonEmptyString(params?.title)) throw new Error("title is required");
+  if (!isNonEmptyString(params?.vision)) throw new Error("vision is required");
+  if (!isNonEmptyString(params?.verificationContract)) throw new Error("verificationContract is required");
+  if (!isNonEmptyString(params?.verificationIntegration)) throw new Error("verificationIntegration is required");
+  if (!isNonEmptyString(params?.verificationOperational)) throw new Error("verificationOperational is required");
+  if (!isNonEmptyString(params?.verificationUat)) throw new Error("verificationUat is required");
+  if (!isNonEmptyString(params?.requirementCoverage)) throw new Error("requirementCoverage is required");
+  if (!isNonEmptyString(params?.boundaryMapMarkdown)) throw new Error("boundaryMapMarkdown is required");
+
+  return {
+    ...params,
+    dependsOn: params.dependsOn ? validateStringArray(params.dependsOn, "dependsOn") : [],
+    successCriteria: validateStringArray(params.successCriteria, "successCriteria"),
+    keyRisks: validateRiskEntries(params.keyRisks),
+    proofStrategy: validateProofStrategy(params.proofStrategy),
+    definitionOfDone: validateStringArray(params.definitionOfDone, "definitionOfDone"),
+    slices: validateSlices(params.slices),
+  };
+}
+
+export async function handlePlanMilestone(
+  rawParams: PlanMilestoneParams,
+  basePath: string,
+): Promise<PlanMilestoneResult | { error: string }> {
+  let params: PlanMilestoneParams;
+  try {
+    params = validateParams(rawParams);
+  } catch (err) {
+    return { error: `validation failed: ${(err as Error).message}` };
+  }
+
+  try {
+    transaction(() => {
+      insertMilestone({
+        id: params.milestoneId,
+        title: params.title,
+        status: params.status ?? "active",
+        depends_on: params.dependsOn ?? [],
+      });
+
+      upsertMilestonePlanning(params.milestoneId, {
+        vision: params.vision,
+        successCriteria: params.successCriteria,
+        keyRisks: params.keyRisks,
+        proofStrategy: params.proofStrategy,
+        verificationContract: params.verificationContract,
+        verificationIntegration: params.verificationIntegration,
+        verificationOperational: params.verificationOperational,
+        verificationUat: params.verificationUat,
+        definitionOfDone: params.definitionOfDone,
+        requirementCoverage: params.requirementCoverage,
+        boundaryMapMarkdown: params.boundaryMapMarkdown,
+      });
+
+      for (const slice of params.slices) {
+        insertSlice({
+          id: slice.sliceId,
+          milestoneId: params.milestoneId,
+          title: slice.title,
+          status: "pending",
+          risk: slice.risk,
+          depends: slice.depends,
+          demo: slice.demo,
+        });
+        upsertSlicePlanning(params.milestoneId, slice.sliceId, {
+          goal: slice.goal,
+          successCriteria: slice.successCriteria,
+          proofLevel: slice.proofLevel,
+          integrationClosure: slice.integrationClosure,
+          observabilityImpact: slice.observabilityImpact,
+        });
+      }
+    });
+  } catch (err) {
+    return { error: `db write failed: ${(err as Error).message}` };
+  }
+
+  let roadmapPath: string;
+  try {
+    const renderResult = await renderRoadmapFromDb(basePath, params.milestoneId);
+    roadmapPath = renderResult.roadmapPath;
+  } catch (renderErr) {
+    process.stderr.write(
+      `gsd-db: plan_milestone — render failed (DB rows preserved for debugging): ${(renderErr as Error).message}\n`,
+    );
+    invalidateStateCache();
+    return { error: `render failed: ${(renderErr as Error).message}` };
+  }
+
+  invalidateStateCache();
+  clearParseCache();
+
+  return {
+    milestoneId: params.milestoneId,
+    roadmapPath,
+  };
+}

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

@@ -0,0 +1,194 @@
+import { clearParseCache } from "../files.js";
+import {
+  transaction,
+  getSlice,
+  insertTask,
+  upsertSlicePlanning,
+  upsertTaskPlanning,
+  _getAdapter,
+} from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderPlanFromDb } from "../markdown-renderer.js";
+
+export interface PlanSliceTaskInput {
+  taskId: string;
+  title: string;
+  description: string;
+  estimate: string;
+  files: string[];
+  verify: string;
+  inputs: string[];
+  expectedOutput: string[];
+  observabilityImpact?: string;
+}
+
+export interface PlanSliceParams {
+  milestoneId: string;
+  sliceId: string;
+  goal: string;
+  successCriteria: string;
+  proofLevel: string;
+  integrationClosure: string;
+  observabilityImpact: string;
+  tasks: PlanSliceTaskInput[];
+}
+
+export interface PlanSliceResult {
+  milestoneId: string;
+  sliceId: string;
+  planPath: string;
+  taskPlanPaths: string[];
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function validateStringArray(value: unknown, field: string): string[] {
+  if (!Array.isArray(value)) {
+    throw new Error(`${field} must be an array`);
+  }
+  if (value.some((item) => !isNonEmptyString(item))) {
+    throw new Error(`${field} must contain only non-empty strings`);
+  }
+  return value;
+}
+
+function validateTasks(value: unknown): PlanSliceTaskInput[] {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("tasks must be a non-empty array");
+  }
+
+  const seen = new Set<string>();
+  return value.map((entry, index) => {
+    if (!entry || typeof entry !== "object") {
+      throw new Error(`tasks[${index}] must be an object`);
+    }
+    const obj = entry as Record<string, unknown>;
+    const taskId = obj.taskId;
+    const title = obj.title;
+    const description = obj.description;
+    const estimate = obj.estimate;
+    const files = obj.files;
+    const verify = obj.verify;
+    const inputs = obj.inputs;
+    const expectedOutput = obj.expectedOutput;
+    const observabilityImpact = obj.observabilityImpact;
+
+    if (!isNonEmptyString(taskId)) throw new Error(`tasks[${index}].taskId must be a non-empty string`);
+    if (seen.has(taskId)) throw new Error(`tasks[${index}].taskId must be unique`);
+    seen.add(taskId);
+    if (!isNonEmptyString(title)) throw new Error(`tasks[${index}].title must be a non-empty string`);
+    if (!isNonEmptyString(description)) throw new Error(`tasks[${index}].description must be a non-empty string`);
+    if (!isNonEmptyString(estimate)) throw new Error(`tasks[${index}].estimate must be a non-empty string`);
+    if (!Array.isArray(files) || files.some((item) => !isNonEmptyString(item))) {
+      throw new Error(`tasks[${index}].files must be an array of non-empty strings`);
+    }
+    if (!isNonEmptyString(verify)) throw new Error(`tasks[${index}].verify must be a non-empty string`);
+    if (!Array.isArray(inputs) || inputs.some((item) => !isNonEmptyString(item))) {
+      throw new Error(`tasks[${index}].inputs must be an array of non-empty strings`);
+    }
+    if (!Array.isArray(expectedOutput) || expectedOutput.some((item) => !isNonEmptyString(item))) {
+      throw new Error(`tasks[${index}].expectedOutput must be an array of non-empty strings`);
+    }
+    if (observabilityImpact !== undefined && !isNonEmptyString(observabilityImpact)) {
+      throw new Error(`tasks[${index}].observabilityImpact must be a non-empty string when provided`);
+    }
+
+    return {
+      taskId,
+      title,
+      description,
+      estimate,
+      files,
+      verify,
+      inputs,
+      expectedOutput,
+      observabilityImpact: typeof observabilityImpact === "string" ? observabilityImpact : "",
+    };
+  });
+}
+
+function validateParams(params: PlanSliceParams): PlanSliceParams {
+  if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
+  if (!isNonEmptyString(params?.sliceId)) throw new Error("sliceId is required");
+  if (!isNonEmptyString(params?.goal)) throw new Error("goal is required");
+  if (!isNonEmptyString(params?.successCriteria)) throw new Error("successCriteria is required");
+  if (!isNonEmptyString(params?.proofLevel)) throw new Error("proofLevel is required");
+  if (!isNonEmptyString(params?.integrationClosure)) throw new Error("integrationClosure is required");
+  if (!isNonEmptyString(params?.observabilityImpact)) throw new Error("observabilityImpact is required");
+
+  return {
+    ...params,
+    tasks: validateTasks(params.tasks),
+  };
+}
+
+export async function handlePlanSlice(
+  rawParams: PlanSliceParams,
+  basePath: string,
+): Promise<PlanSliceResult | { error: string }> {
+  let params: PlanSliceParams;
+  try {
+    params = validateParams(rawParams);
+  } catch (err) {
+    return { error: `validation failed: ${(err as Error).message}` };
+  }
+
+  const parentSlice = getSlice(params.milestoneId, params.sliceId);
+  if (!parentSlice) {
+    return { error: `missing parent slice: ${params.milestoneId}/${params.sliceId}` };
+  }
+
+  try {
+    transaction(() => {
+      upsertSlicePlanning(params.milestoneId, params.sliceId, {
+        goal: params.goal,
+        successCriteria: params.successCriteria,
+        proofLevel: params.proofLevel,
+        integrationClosure: params.integrationClosure,
+        observabilityImpact: params.observabilityImpact,
+      });
+
+      for (const task of params.tasks) {
+        insertTask({
+          id: task.taskId,
+          sliceId: params.sliceId,
+          milestoneId: params.milestoneId,
+          title: task.title,
+          status: "pending",
+        });
+        upsertTaskPlanning(params.milestoneId, params.sliceId, task.taskId, {
+          title: task.title,
+          description: task.description,
+          estimate: task.estimate,
+          files: task.files,
+          verify: task.verify,
+          inputs: task.inputs,
+          expectedOutput: task.expectedOutput,
+          observabilityImpact: task.observabilityImpact ?? "",
+        });
+      }
+    });
+  } catch (err) {
+    return { error: `db write failed: ${(err as Error).message}` };
+  }
+
+  try {
+    const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+    invalidateStateCache();
+    clearParseCache();
+    return {
+      milestoneId: params.milestoneId,
+      sliceId: params.sliceId,
+      planPath: renderResult.planPath,
+      taskPlanPaths: renderResult.taskPlanPaths,
+    };
+  } catch (renderErr) {
+    process.stderr.write(
+      `gsd-db: plan_slice — render failed (DB rows preserved for debugging): ${(renderErr as Error).message}\n`,
+    );
+    invalidateStateCache();
+    return { error: `render failed: ${(renderErr as Error).message}` };
+  }
+}