gsd-pi 2.63.0 → 2.64.0-dev.9c14bd0

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

@@ -20,7 +20,7 @@ import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { isClosedStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { renderAllProjections, stripIdPrefix } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -30,15 +30,23 @@ export interface CompleteMilestoneParams {
   title: string;
   oneLiner: string;
   narrative: string;
-  successCriteriaResults: string;
-  definitionOfDoneResults: string;
-  requirementOutcomes: string;
-  keyDecisions: string[];
-  keyFiles: string[];
-  lessonsLearned: string[];
-  followUps: string;
-  deviations: string;
   verificationPassed: boolean;
+  /** @optional — defaults to "Not provided." when omitted by models with limited tool-calling */
+  successCriteriaResults?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  definitionOfDoneResults?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  requirementOutcomes?: string;
+  /** @optional — defaults to [] when omitted */
+  keyDecisions?: string[];
+  /** @optional — defaults to [] when omitted */
+  keyFiles?: string[];
+  /** @optional — defaults to [] when omitted */
+  lessonsLearned?: string[];
+  /** @optional — defaults to "None." when omitted */
+  followUps?: string;
+  /** @optional — defaults to "None." when omitted */
+  deviations?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
@@ -52,22 +60,28 @@ export interface CompleteMilestoneResult {
 
 function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string {
   const now = new Date().toISOString();
+  const displayTitle = stripIdPrefix(params.title, params.milestoneId);
 
-  const keyDecisionsYaml = params.keyDecisions.length > 0
-    ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
+  // Apply defaults for optional enrichment fields (#2771)
+  const keyDecisions = params.keyDecisions ?? [];
+  const keyFiles = params.keyFiles ?? [];
+  const lessonsLearned = params.lessonsLearned ?? [];
+
+  const keyDecisionsYaml = keyDecisions.length > 0
+    ? keyDecisions.map(d => `  - ${d}`).join("\n")
     : "  - (none)";
 
-  const keyFilesYaml = params.keyFiles.length > 0
-    ? params.keyFiles.map(f => `  - ${f}`).join("\n")
+  const keyFilesYaml = keyFiles.length > 0
+    ? keyFiles.map(f => `  - ${f}`).join("\n")
     : "  - (none)";
 
-  const lessonsYaml = params.lessonsLearned.length > 0
-    ? params.lessonsLearned.map(l => `  - ${l}`).join("\n")
+  const lessonsYaml = lessonsLearned.length > 0
+    ? lessonsLearned.map(l => `  - ${l}`).join("\n")
     : "  - (none)";
 
   return `---
 id: ${params.milestoneId}
-title: "${params.title}"
+title: "${displayTitle}"
 status: complete
 completed_at: ${now}
 key_decisions:
@@ -78,7 +92,7 @@ lessons_learned:
 ${lessonsYaml}
 ---
 
-# ${params.milestoneId}: ${params.title}
+# ${params.milestoneId}: ${displayTitle}
 
 **${params.oneLiner}**
 
@@ -88,15 +102,15 @@ ${params.narrative}
 
 ## Success Criteria Results
 
-${params.successCriteriaResults}
+${params.successCriteriaResults ?? "Not provided."}
 
 ## Definition of Done Results
 
-${params.definitionOfDoneResults}
+${params.definitionOfDoneResults ?? "Not provided."}
 
 ## Requirement Outcomes
 
-${params.requirementOutcomes}
+${params.requirementOutcomes ?? "Not provided."}
 
 ## Deviations
 

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

@@ -46,58 +46,73 @@ export interface CompleteSliceResult {
 function renderSliceSummaryMarkdown(params: CompleteSliceParams): string {
   const now = new Date().toISOString();
 
-  const providesYaml = params.provides.length > 0
-    ? params.provides.map(p => `  - ${p}`).join("\n")
+  // Apply defaults for optional enrichment arrays (#2771)
+  const provides = params.provides ?? [];
+  const requires = params.requires ?? [];
+  const affects = params.affects ?? [];
+  const keyFiles = params.keyFiles ?? [];
+  const keyDecisions = params.keyDecisions ?? [];
+  const patternsEstablished = params.patternsEstablished ?? [];
+  const observabilitySurfaces = params.observabilitySurfaces ?? [];
+  const drillDownPaths = params.drillDownPaths ?? [];
+  const requirementsAdvanced = params.requirementsAdvanced ?? [];
+  const requirementsValidated = params.requirementsValidated ?? [];
+  const requirementsSurfaced = params.requirementsSurfaced ?? [];
+  const requirementsInvalidated = params.requirementsInvalidated ?? [];
+  const filesModified = params.filesModified ?? [];
+
+  const providesYaml = provides.length > 0
+    ? provides.map(p => `  - ${p}`).join("\n")
     : "  - (none)";
 
-  const requiresYaml = params.requires.length > 0
-    ? params.requires.map(r => `  - slice: ${r.slice}\n    provides: ${r.provides}`).join("\n")
+  const requiresYaml = requires.length > 0
+    ? requires.map(r => `  - slice: ${r.slice}\n    provides: ${r.provides}`).join("\n")
     : "  []";
 
-  const affectsYaml = params.affects.length > 0
-    ? params.affects.map(a => `  - ${a}`).join("\n")
+  const affectsYaml = affects.length > 0
+    ? affects.map(a => `  - ${a}`).join("\n")
     : "  []";
 
-  const keyFilesYaml = params.keyFiles.length > 0
-    ? params.keyFiles.map(f => `  - ${f}`).join("\n")
+  const keyFilesYaml = keyFiles.length > 0
+    ? keyFiles.map(f => `  - ${f}`).join("\n")
     : "  - (none)";
 
-  const keyDecisionsYaml = params.keyDecisions.length > 0
-    ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
+  const keyDecisionsYaml = keyDecisions.length > 0
+    ? keyDecisions.map(d => `  - ${d}`).join("\n")
     : "  - (none)";
 
-  const patternsYaml = params.patternsEstablished.length > 0
-    ? params.patternsEstablished.map(p => `  - ${p}`).join("\n")
+  const patternsYaml = patternsEstablished.length > 0
+    ? patternsEstablished.map(p => `  - ${p}`).join("\n")
     : "  - (none)";
 
-  const observabilityYaml = params.observabilitySurfaces.length > 0
-    ? params.observabilitySurfaces.map(o => `  - ${o}`).join("\n")
+  const observabilityYaml = observabilitySurfaces.length > 0
+    ? observabilitySurfaces.map(o => `  - ${o}`).join("\n")
     : "  - none";
 
-  const drillDownYaml = params.drillDownPaths.length > 0
-    ? params.drillDownPaths.map(d => `  - ${d}`).join("\n")
+  const drillDownYaml = drillDownPaths.length > 0
+    ? drillDownPaths.map(d => `  - ${d}`).join("\n")
     : "  []";
 
   // Requirements sections
-  const reqAdvanced = params.requirementsAdvanced.length > 0
-    ? params.requirementsAdvanced.map(r => `- ${r.id} — ${r.how}`).join("\n")
+  const reqAdvanced = requirementsAdvanced.length > 0
+    ? requirementsAdvanced.map(r => `- ${r.id} — ${r.how}`).join("\n")
     : "None.";
 
-  const reqValidated = params.requirementsValidated.length > 0
-    ? params.requirementsValidated.map(r => `- ${r.id} — ${r.proof}`).join("\n")
+  const reqValidated = requirementsValidated.length > 0
+    ? requirementsValidated.map(r => `- ${r.id} — ${r.proof}`).join("\n")
     : "None.";
 
-  const reqSurfaced = params.requirementsSurfaced.length > 0
-    ? params.requirementsSurfaced.map(r => `- ${r}`).join("\n")
+  const reqSurfaced = requirementsSurfaced.length > 0
+    ? requirementsSurfaced.map(r => `- ${r}`).join("\n")
     : "None.";
 
-  const reqInvalidated = params.requirementsInvalidated.length > 0
-    ? params.requirementsInvalidated.map(r => `- ${r.id} — ${r.what}`).join("\n")
+  const reqInvalidated = requirementsInvalidated.length > 0
+    ? requirementsInvalidated.map(r => `- ${r.id} — ${r.what}`).join("\n")
     : "None.";
 
   // Files modified
-  const filesMod = params.filesModified.length > 0
-    ? params.filesModified.map(f => `- \`${f.path}\` — ${f.description}`).join("\n")
+  const filesMod = filesModified.length > 0
+    ? filesModified.map(f => `- \`${f.path}\` — ${f.description}`).join("\n")
     : "None.";
 
   return `---

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

@@ -60,11 +60,11 @@ function paramsToTaskRow(params: CompleteTaskParams, completedAt: string): TaskR
     verification_result: params.verification,
     duration: "",
     completed_at: completedAt,
-    blocker_discovered: params.blockerDiscovered,
-    deviations: params.deviations,
-    known_issues: params.knownIssues,
-    key_files: params.keyFiles,
-    key_decisions: params.keyDecisions,
+    blocker_discovered: params.blockerDiscovered ?? false,
+    deviations: params.deviations ?? "",
+    known_issues: params.knownIssues ?? "",
+    key_files: params.keyFiles ?? [],
+    key_decisions: params.keyDecisions ?? [],
     full_summary_md: "",
     description: "",
     estimate: "",
@@ -152,14 +152,14 @@ export async function handleCompleteTask(
       narrative: params.narrative,
       verificationResult: params.verification,
       duration: "",
-      blockerDiscovered: params.blockerDiscovered,
-      deviations: params.deviations,
-      knownIssues: params.knownIssues,
-      keyFiles: params.keyFiles,
-      keyDecisions: params.keyDecisions,
+      blockerDiscovered: params.blockerDiscovered ?? false,
+      deviations: params.deviations ?? "None.",
+      knownIssues: params.knownIssues ?? "None.",
+      keyFiles: params.keyFiles ?? [],
+      keyDecisions: params.keyDecisions ?? [],
     });
 
-    for (const evidence of params.verificationEvidence) {
+    for (const evidence of (params.verificationEvidence ?? [])) {
       insertVerificationEvidence({
         taskId: params.taskId,
         sliceId: params.sliceId,
@@ -182,7 +182,7 @@ export async function handleCompleteTask(
 
   // Render summary markdown via the single source of truth (#2720)
   const taskRow = paramsToTaskRow(params, completedAt);
-  const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence);
+  const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence ?? []);
 
   // Resolve and write summary to disk
   let summaryPath: string;

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

@@ -5,6 +5,7 @@ import {
   transaction,
   getMilestone,
   getMilestoneSlices,
+  getSlice,
   insertMilestone,
   insertSlice,
   upsertMilestonePlanning,
@@ -33,24 +34,34 @@ export interface PlanMilestoneSliceInput {
 export interface PlanMilestoneParams {
   milestoneId: string;
   title: string;
+  vision: string;
+  slices: PlanMilestoneSliceInput[];
   status?: string;
   dependsOn?: string[];
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
   triggerReason?: 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[];
+  /** @optional — defaults to [] when omitted by models with limited tool-calling */
+  successCriteria?: string[];
+  /** @optional — defaults to [] when omitted */
+  keyRisks?: Array<{ risk: string; whyItMatters: string }>;
+  /** @optional — defaults to [] when omitted */
+  proofStrategy?: Array<{ riskOrUnknown: string; retireIn: string; whatWillBeProven: string }>;
+  /** @optional — defaults to "Not provided." when omitted */
+  verificationContract?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  verificationIntegration?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  verificationOperational?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  verificationUat?: string;
+  /** @optional — defaults to [] when omitted */
+  definitionOfDone?: string[];
+  /** @optional — defaults to "Not provided." when omitted */
+  requirementCoverage?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  boundaryMapMarkdown?: string;
 }
 
 export interface PlanMilestoneResult {
@@ -149,20 +160,21 @@ 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"),
+    // Apply defaults for optional enrichment fields (#2771)
+    successCriteria: params.successCriteria ? validateStringArray(params.successCriteria, "successCriteria") : [],
+    keyRisks: params.keyRisks ? validateRiskEntries(params.keyRisks) : [],
+    proofStrategy: params.proofStrategy ? validateProofStrategy(params.proofStrategy) : [],
+    verificationContract: params.verificationContract ?? "Not provided.",
+    verificationIntegration: params.verificationIntegration ?? "Not provided.",
+    verificationOperational: params.verificationOperational ?? "Not provided.",
+    verificationUat: params.verificationUat ?? "Not provided.",
+    definitionOfDone: params.definitionOfDone ? validateStringArray(params.definitionOfDone, "definitionOfDone") : [],
+    requirementCoverage: params.requirementCoverage ?? "Not provided.",
+    boundaryMapMarkdown: params.boundaryMapMarkdown ?? "Not provided.",
     slices: validateSlices(params.slices),
   };
 }
@@ -191,15 +203,19 @@ export async function handlePlanMilestone(
         return;
       }
 
-      // Guard: refuse to re-plan a milestone that has completed slices (#2960).
-      // INSERT OR IGNORE on slices won't overwrite existing rows, but a full
-      // re-plan after worktree recreation or DB resync can create new slice rows
-      // that shadow completed work. Block early when any slice is already done.
+      // Guard: refuse to re-plan a milestone that would drop completed slices (#2960).
+      // Allow re-planning when all completed slices are still present in the
+      // incoming plan — their status is preserved below (#2558). Block only when
+      // the new plan omits a completed slice, which could shadow completed work.
       const existingSlices = getMilestoneSlices(params.milestoneId);
       const completedSlices = existingSlices.filter(s => isClosedStatus(s.status));
       if (completedSlices.length > 0) {
-        guardError = `cannot re-plan milestone ${params.milestoneId}: ${completedSlices.length} slice(s) already completed (${completedSlices.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
-        return;
+        const incomingSliceIds = new Set(params.slices.map(s => s.sliceId));
+        const droppedCompleted = completedSlices.filter(s => !incomingSliceIds.has(s.id));
+        if (droppedCompleted.length > 0) {
+          guardError = `cannot re-plan milestone ${params.milestoneId}: ${droppedCompleted.length} completed slice(s) would be dropped (${droppedCompleted.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
+          return;
+        }
       }
 
       // Validate depends_on: all dependencies must exist and be complete
@@ -225,6 +241,8 @@ export async function handlePlanMilestone(
       });
 
       upsertMilestonePlanning(params.milestoneId, {
+        title: params.title,
+        status: params.status ?? "active",
         vision: params.vision,
         successCriteria: params.successCriteria,
         keyRisks: params.keyRisks,
@@ -236,14 +254,21 @@ export async function handlePlanMilestone(
         definitionOfDone: params.definitionOfDone,
         requirementCoverage: params.requirementCoverage,
         boundaryMapMarkdown: params.boundaryMapMarkdown,
-      }, params.title);
+      });
 
       for (const slice of params.slices) {
+        // Preserve completed/done status on re-plan (#2558).
+        // Without this, a re-plan after milestone transition would reset
+        // already-completed slices back to "pending".
+        const existing = getSlice(params.milestoneId, slice.sliceId);
+        const status = existing && (existing.status === "complete" || existing.status === "done")
+          ? existing.status
+          : "pending";
         insertSlice({
           id: slice.sliceId,
           milestoneId: params.milestoneId,
           title: slice.title,
-          status: "pending",
+          status,
           risk: slice.risk,
           depends: slice.depends,
           demo: slice.demo,

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

@@ -35,11 +35,15 @@ export interface PlanSliceParams {
   milestoneId: string;
   sliceId: string;
   goal: string;
-  successCriteria: string;
-  proofLevel: string;
-  integrationClosure: string;
-  observabilityImpact: string;
   tasks: PlanSliceTaskInput[];
+  /** @optional — defaults to "Not provided." when omitted by models with limited tool-calling */
+  successCriteria?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  proofLevel?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  integrationClosure?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  observabilityImpact?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
@@ -112,13 +116,14 @@ 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,
+    // Apply defaults for optional enrichment fields (#2771)
+    successCriteria: params.successCriteria ?? "Not provided.",
+    proofLevel: params.proofLevel ?? "Not provided.",
+    integrationClosure: params.integrationClosure ?? "Not provided.",
+    observabilityImpact: params.observabilityImpact ?? "Not provided.",
     tasks: validateTasks(params.tasks),
   };
 }

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

@@ -515,12 +515,18 @@ export interface CompleteTaskParams {
   oneLiner: string;
   narrative: string;
   verification: string;
-  keyFiles: string[];
-  keyDecisions: string[];
-  deviations: string;
-  knownIssues: string;
-  blockerDiscovered: boolean;
-  verificationEvidence: Array<{
+  /** @optional — defaults to [] when omitted by models with limited tool-calling */
+  keyFiles?: string[];
+  /** @optional — defaults to [] when omitted by models with limited tool-calling */
+  keyDecisions?: string[];
+  /** @optional — defaults to "None." when omitted */
+  deviations?: string;
+  /** @optional — defaults to "None." when omitted */
+  knownIssues?: string;
+  /** @optional — defaults to false when omitted */
+  blockerDiscovered?: boolean;
+  /** @optional — defaults to [] when omitted by models with limited tool-calling */
+  verificationEvidence?: Array<{
     command: string;
     exitCode: number;
     verdict: string;
@@ -541,23 +547,39 @@ export interface CompleteSliceParams {
   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[];
+  /** @optional — defaults to [] when omitted by models with limited tool-calling */
+  keyFiles?: string[];
+  /** @optional — defaults to [] when omitted */
+  keyDecisions?: string[];
+  /** @optional — defaults to [] when omitted */
+  patternsEstablished?: string[];
+  /** @optional — defaults to [] when omitted */
+  observabilitySurfaces?: string[];
+  /** @optional — defaults to "None." when omitted */
+  deviations?: string;
+  /** @optional — defaults to "None." when omitted */
+  knownLimitations?: string;
+  /** @optional — defaults to "None." when omitted */
+  followUps?: string;
+  /** @optional — defaults to [] when omitted */
+  requirementsAdvanced?: Array<{ id: string; how: string }>;
+  /** @optional — defaults to [] when omitted */
+  requirementsValidated?: Array<{ id: string; proof: string }>;
+  /** @optional — defaults to [] when omitted */
+  requirementsSurfaced?: string[];
+  /** @optional — defaults to [] when omitted */
+  requirementsInvalidated?: Array<{ id: string; what: string }>;
+  /** @optional — defaults to [] when omitted */
+  filesModified?: Array<{ path: string; description: string }>;
+  /** @optional — defaults to [] when omitted */
+  provides?: string[];
+  /** @optional — defaults to [] when omitted */
+  requires?: Array<{ slice: string; provides: string }>;
+  /** @optional — defaults to [] when omitted */
+  affects?: string[];
+  /** @optional — defaults to [] when omitted */
+  drillDownPaths?: string[];
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */

package/src/resources/extensions/gsd/verification-evidence.ts

@@ -52,6 +52,32 @@ export interface BrowserEvidenceJSON {
   duration: number;
 }
 
+export interface PreExecutionCheckJSON {
+  /** Check category: package, file, tool, endpoint, schema */
+  category: "package" | "file" | "tool" | "endpoint" | "schema";
+  /** What was checked (e.g., package name, file path) */
+  target: string;
+  /** Whether the check passed */
+  passed: boolean;
+  /** Human-readable message explaining the result */
+  message: string;
+  /** Whether this failure should block execution (only meaningful when passed=false) */
+  blocking?: boolean;
+}
+
+export interface PostExecutionCheckJSON {
+  /** Check category: import, signature, pattern */
+  category: "import" | "signature" | "pattern";
+  /** What was checked (e.g., file:line, function name) */
+  target: string;
+  /** Whether the check passed */
+  passed: boolean;
+  /** Human-readable message explaining the result */
+  message: string;
+  /** Whether this failure should block completion (only meaningful when passed=false) */
+  blocking?: boolean;
+}
+
 export interface EvidenceJSON {
   schemaVersion: 1;
   taskId: string;
@@ -65,6 +91,10 @@ export interface EvidenceJSON {
   runtimeErrors?: RuntimeErrorJSON[];
   auditWarnings?: AuditWarningJSON[];
   browser?: BrowserEvidenceJSON;
+  /** Pre-execution checks run before task execution (package existence, file refs, etc.) */
+  preExecutionChecks?: PreExecutionCheckJSON[];
+  /** Post-execution checks run after task completion (import resolution, signature drift, pattern consistency) */
+  postExecutionChecks?: PostExecutionCheckJSON[];
 }
 
 /**
@@ -124,6 +154,44 @@ export function writeVerificationJSON(
   writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
 }
 
+// ─── Pre-Execution Evidence ──────────────────────────────────────────────────
+
+export interface PreExecutionEvidenceJSON {
+  schemaVersion: 1;
+  milestoneId: string;
+  sliceId: string;
+  timestamp: number;
+  status: "pass" | "warn" | "fail";
+  durationMs: number;
+  checks: PreExecutionCheckJSON[];
+}
+
+/**
+ * Write pre-execution check results to a PRE-EXEC-VERIFY.json artifact
+ * in the slice directory.
+ */
+export function writePreExecutionEvidence(
+  result: { status: "pass" | "warn" | "fail"; checks: PreExecutionCheckJSON[]; durationMs: number },
+  sliceDir: string,
+  milestoneId: string,
+  sliceId: string,
+): void {
+  mkdirSync(sliceDir, { recursive: true });
+
+  const evidence: PreExecutionEvidenceJSON = {
+    schemaVersion: 1,
+    milestoneId,
+    sliceId,
+    timestamp: Date.now(),
+    status: result.status,
+    durationMs: result.durationMs,
+    checks: result.checks,
+  };
+
+  const filePath = join(sliceDir, `${sliceId}-PRE-EXEC-VERIFY.json`);
+  writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
+}
+
 // ─── Markdown Evidence Table ─────────────────────────────────────────────────
 
 /**

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -48,7 +48,8 @@ export type LogComponent =
   | "bootstrap"     // Extension bootstrap (system-context, agent-end)
   | "guided"        // Guided flow (discuss, plan wizards)
   | "registry"      // Rule registry hook state
-  | "renderer";     // Markdown renderer and projections
+  | "renderer"      // Markdown renderer and projections
+  | "safety";       // LLM safety harness
 
 export interface LogEntry {
   ts: string;