@opengsd/gsd-pi 1.2.0-dev.e8563f58 → 1.2.0-dev.fbdca60b

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

@@ -10,6 +10,7 @@
  * back committed DB state.
  */
 
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 
 import type { CompleteTaskParams, EscalationArtifact } from "../types.js";
@@ -35,7 +36,8 @@ import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanCheckboxes } from "../markdown-renderer.js";
-import { renderAllProjections, renderSummaryContent } from "../workflow-projections.js";
+import { renderSummaryContent } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
@@ -85,6 +87,49 @@ function taskSummaryPath(
   );
 }
 
+async function repairMissingTaskSummaryProjection(
+  artifactBasePath: string,
+  taskRow: TaskRow,
+): Promise<{ summaryPath: string; stale: boolean }> {
+  const summaryPath = taskSummaryPath(
+    artifactBasePath,
+    taskRow.milestone_id,
+    taskRow.slice_id,
+    taskRow.id,
+  );
+  const summaryMd = renderSummaryContent(taskRow, taskRow.slice_id, taskRow.milestone_id, []);
+  let stale = false;
+
+  try {
+    await saveFile(summaryPath, summaryMd);
+    await renderPlanCheckboxes(artifactBasePath, taskRow.milestone_id, taskRow.slice_id);
+  } catch (renderErr) {
+    stale = true;
+    logWarning(
+      "projection",
+      `complete_task missing-summary repair failed for ${taskRow.milestone_id}/${taskRow.slice_id}/${taskRow.id}`,
+      { error: (renderErr as Error).message },
+    );
+  }
+
+  invalidateStateCache();
+  clearPathCache();
+  clearParseCache();
+
+  try {
+    await flushWorkflowProjections(artifactBasePath, { milestoneId: taskRow.milestone_id });
+  } catch (projErr) {
+    logWarning("tool", `complete-task repair projection warning: ${(projErr as Error).message}`);
+  }
+  try {
+    writeManifest(artifactBasePath);
+  } catch (mfErr) {
+    logWarning("tool", `complete-task repair manifest warning: ${(mfErr as Error).message}`);
+  }
+
+  return { summaryPath, stale };
+}
+
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose
  * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
@@ -207,6 +252,7 @@ export async function handleCompleteTask(
   const completedAt = new Date().toISOString();
   let guardError: string | null = null;
   let summaryMd = "";
+  let repairTaskSummaryRow: TaskRow | null = null;
 
   // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
   // Building the artifact runs the full shape validation (2-4 options, unique
@@ -271,6 +317,17 @@ export async function handleCompleteTask(
         guardError = "__stale_duplicate__";
         return;
       }
+      const existingSummaryPath = taskSummaryPath(
+        artifactBasePath,
+        params.milestoneId,
+        params.sliceId,
+        params.taskId,
+      );
+      if (existingTask.full_summary_md.trim() && !existsSync(existingSummaryPath)) {
+        repairTaskSummaryRow = existingTask;
+        guardError = "__repair_missing_summary__";
+        return;
+      }
       guardError = `task ${params.taskId} is already complete — use gsd_task_reopen first if you need to redo it`;
       return;
     }
@@ -336,6 +393,18 @@ export async function handleCompleteTask(
     };
   }
 
+  if (guardError === "__repair_missing_summary__" && repairTaskSummaryRow) {
+    const repair = await repairMissingTaskSummaryProjection(artifactBasePath, repairTaskSummaryRow);
+    return {
+      taskId: params.taskId,
+      sliceId: params.sliceId,
+      milestoneId: params.milestoneId,
+      summaryPath: repair.summaryPath,
+      duplicate: true,
+      ...(repair.stale ? { stale: true } : {}),
+    };
+  }
+
   if (guardError) {
     return { error: guardError };
   }
@@ -452,6 +521,25 @@ export async function handleCompleteTask(
       }
     }
   } else if (params.escalation && !escalationWriteEnabled) {
+    if (params.escalation.continueWithDefault === false) {
+      const msg = `complete-task received a hard-blocker escalation (continueWithDefault=false) but phases.mid_execution_escalation is disabled for ${params.milestoneId}/${params.sliceId}/${params.taskId}; reverting to pending instead of silently advancing.`;
+      logWarning("tool", msg);
+      try {
+        deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
+        updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+        invalidateStateCache();
+        logWarning(
+          "tool",
+          `complete-task rolled back DB completion for ${params.milestoneId}/${params.sliceId}/${params.taskId} because hard-blocker escalation handling is disabled; SUMMARY.md left on disk for retry.`,
+        );
+      } catch (rollbackErr) {
+        logWarning(
+          "tool",
+          `complete-task rollback failed after disabled hard-blocker escalation for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${(rollbackErr as Error).message}`,
+        );
+      }
+      return { error: msg };
+    }
     logWarning(
       "tool",
       `complete-task received escalation payload but phases.mid_execution_escalation is not enabled; ignoring (${params.milestoneId}/${params.sliceId}/${params.taskId})`,
@@ -467,7 +555,7 @@ export async function handleCompleteTask(
   // Separate try/catch per step so a projection failure doesn't prevent
   // the event log entry (critical for worktree reconciliation).
   try {
-    await renderAllProjections(artifactBasePath, params.milestoneId);
+    await flushWorkflowProjections(artifactBasePath, { milestoneId: params.milestoneId });
   } catch (projErr) {
     logWarning("tool", `complete-task projection warning: ${(projErr as Error).message}`);
   }

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

@@ -21,7 +21,7 @@ import {
 import type { GateEvaluationConfig, GateId } from "../types.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -468,7 +468,7 @@ export async function handlePlanSlice(
 
     // ── Post-mutation hook: projections, manifest, event log ─────────────
     try {
-      await renderAllProjections(basePath, params.milestoneId);
+      await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
       writeManifest(basePath);
       appendEvent(basePath, {
         cmd: "plan-slice",

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

@@ -4,7 +4,7 @@ import { isNonEmptyString, validateStringArray } from "../validation.js";
 import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -142,7 +142,7 @@ export async function handlePlanTask(
 
     // ── Post-mutation hook: projections, manifest, event log ─────────────
     try {
-      await renderAllProjections(basePath, params.milestoneId);
+      await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
       writeManifest(basePath);
       appendEvent(basePath, {
         cmd: "plan-task",

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

@@ -16,7 +16,7 @@ import {
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -306,7 +306,7 @@ export async function handleReassessRoadmap(
 
     // ── Post-mutation hook: projections, manifest, event log ─────
     try {
-      await renderAllProjections(basePath, params.milestoneId);
+      await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
       writeManifest(basePath);
       appendEvent(basePath, {
         cmd: "reassess-roadmap",

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

@@ -15,7 +15,7 @@ import {
   reopenMilestoneCascade,
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -98,7 +98,7 @@ export async function handleReopenMilestone(
 
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
-    await renderAllProjections(basePath, params.milestoneId);
+    await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
     writeManifest(basePath);
     appendEvent(basePath, {
       cmd: "reopen-milestone",

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

@@ -16,7 +16,7 @@ import {
   reopenSliceCascade,
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -97,7 +97,7 @@ export async function handleReopenSlice(
 
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
-    await renderAllProjections(basePath, params.milestoneId);
+    await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
     writeManifest(basePath);
     appendEvent(basePath, {
       cmd: "reopen-slice",

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

@@ -19,7 +19,7 @@ import {
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -119,7 +119,7 @@ export async function handleReopenTask(
 
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
-    await renderAllProjections(basePath, params.milestoneId);
+    await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
     writeManifest(basePath);
     appendEvent(basePath, {
       cmd: "reopen-task",

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

@@ -13,7 +13,7 @@ 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 { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -216,7 +216,7 @@ export async function handleReplanSlice(
 
     // ── Post-mutation hook: projections, manifest, event log ─────
     try {
-      await renderAllProjections(basePath, params.milestoneId);
+      await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
       writeManifest(basePath);
       appendEvent(basePath, {
         cmd: "replan-slice",

package/src/resources/extensions/gsd/unit-context-composer.ts

@@ -187,7 +187,7 @@ const TOOL_SURFACE_GUIDANCE_BY_UNIT: Record<string, string> = {
   "run-uat":
     "Do not call `gsd_exec`, `Bash`, `Write`, or `Edit` — they are unavailable in this unit. Run every automated check through `gsd_uat_exec` with the appropriate `intent`. For browser UAT modes, use `browser_*` tools when presented; if browser automation fails, record the failure honestly and use `gsd_uat_exec` for the best objective substitute.",
   "complete-slice":
-    "Run slice-level verification through `gsd_exec` (or MCP-scoped `mcp__…__gsd_exec`), not direct `bash`. Do not call `gsd_uat_result_save` — run-uat owns persisted UAT assessment. On verification failure, do not edit user source files in this unit.",
+    "Run slice-level verification through `gsd_exec` (or MCP-scoped `mcp__…__gsd_exec`), not direct `bash`. Capture learnings through `gsd_capture_thought` (or MCP-scoped `mcp__…__gsd_capture_thought`), not bare `capture_thought`, when workflow MCP tools are presented. Do not call `gsd_uat_result_save` — run-uat owns persisted UAT assessment. On verification failure, do not edit user source files in this unit.",
   "gate-evaluate":
     "Dispatch only **tester** subagents via `subagent`. Persist each gate with `gsd_save_gate_result`. Do not use `ToolSearch` — it is not available.",
   "reactive-execute":

package/src/resources/extensions/gsd/unit-registry.ts

@@ -220,15 +220,19 @@ export const UNIT_REGISTRY = {
     phaseChain: ["completion"],
     toolContract: {
       allowedGsdTools: [
+        "gsd_exec",
         "gsd_slice_complete",
         "gsd_task_reopen",
         "gsd_replan_slice",
         "gsd_decision_save",
+        "gsd_capture_thought",
         "gsd_requirement_update",
         "gsd_summary_save",
         "subagent",
       ],
       requiredWorkflowTools: [
+        "gsd_exec",
+        "gsd_capture_thought",
         "gsd_slice_complete",
         "gsd_task_reopen",
         "gsd_replan_slice",
@@ -254,8 +258,21 @@ export const UNIT_REGISTRY = {
     scopeClass: "execute-task",
     phaseChain: ["execution"],
     toolContract: {
-      allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-      requiredWorkflowTools: ["gsd_task_complete"],
+      allowedGsdTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+        "gsd_decision_save",
+      ],
+      requiredWorkflowTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+      ],
     },
   },
   "execute-task-simple": {
@@ -263,8 +280,21 @@ export const UNIT_REGISTRY = {
     scopeClass: "execute-task",
     phaseChain: ["execution_simple", "execution"],
     toolContract: {
-      allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-      requiredWorkflowTools: ["gsd_task_complete"],
+      allowedGsdTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+        "gsd_decision_save",
+      ],
+      requiredWorkflowTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+      ],
     },
   },
   "reactive-execute": {

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

@@ -15,6 +15,9 @@ export interface VerificationVerdict {
   failureContext: string;
 }
 
+export const NO_HOST_CHECKS_FAILURE_CONTEXT =
+  "No runnable host-owned verification command was discovered. Add project verification_commands in .gsd/PREFERENCES.md or a runnable task-plan Verify command, then resume with /gsd next.";
+
 export function decideVerificationVerdict(
   unitType: string,
   result: VerificationGateResult,
@@ -33,8 +36,7 @@ export function decideVerificationVerdict(
       passed: false,
       reason: "no-host-checks",
       retryable: false,
-      failureContext:
-        "No runnable host-owned verification command was discovered. Add project verification_commands or a runnable task-plan Verify command before completing this execute-task.",
+      failureContext: NO_HOST_CHECKS_FAILURE_CONTEXT,
     };
   }
 

package/src/resources/extensions/gsd/workflow-event-ledger.ts

@@ -0,0 +1,131 @@
+import { createHash } from "node:crypto";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { atomicWriteSync } from "./atomic-write.js";
+import { resolveGsdPathContract } from "./paths.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
+import { normalizeWorkflowEventCommand } from "./workflow-event-vocabulary.js";
+import type { WorkflowEvent } from "./workflow-events.js";
+
+export const WORKFLOW_EVENT_LOG_FILENAME = "event-log.jsonl";
+
+export interface WorkflowEventLedgerLocation {
+  projectRoot: string;
+  workRoot: string;
+  projectGsd: string;
+  worktreeGsd: string | null;
+  projectLogPath: string;
+  worktreeLogPath: string | null;
+  isWorktree: boolean;
+}
+
+export type WorkflowEventInput = Omit<WorkflowEvent, "hash" | "session_id"> & {
+  actor_name?: string;
+  trigger_reason?: string;
+};
+
+export function resolveWorkflowEventLedgerLocation(
+  basePath: string,
+  originalProjectRoot?: string | null,
+): WorkflowEventLedgerLocation {
+  const contract = resolveGsdPathContract(basePath, originalProjectRoot);
+  return {
+    projectRoot: contract.projectRoot,
+    workRoot: contract.workRoot,
+    projectGsd: contract.projectGsd,
+    worktreeGsd: contract.worktreeGsd,
+    projectLogPath: join(contract.projectGsd, WORKFLOW_EVENT_LOG_FILENAME),
+    worktreeLogPath: contract.worktreeGsd
+      ? join(contract.worktreeGsd, WORKFLOW_EVENT_LOG_FILENAME)
+      : null,
+    isWorktree: contract.isWorktree,
+  };
+}
+
+export function workflowEventLogPath(basePath: string): string {
+  return resolveWorkflowEventLedgerLocation(basePath).projectLogPath;
+}
+
+export function workflowEventArchivePath(basePath: string, milestoneId: string): string {
+  const location = resolveWorkflowEventLedgerLocation(basePath);
+  return join(location.projectGsd, `event-log-${milestoneId}.jsonl.archived`);
+}
+
+export function readWorktreeEventLogPath(worktreeBasePath: string): string {
+  const location = resolveWorkflowEventLedgerLocation(worktreeBasePath);
+  return location.worktreeLogPath ?? location.projectLogPath;
+}
+
+export function buildWorkflowEvent(event: WorkflowEventInput, sessionId: string): WorkflowEvent {
+  const hash = createHash("sha256")
+    .update(JSON.stringify({ cmd: event.cmd, params: event.params }))
+    .digest("hex")
+    .slice(0, 16);
+
+  return {
+    v: 2,
+    ...event,
+    hash,
+    session_id: sessionId,
+  };
+}
+
+export function appendWorkflowEvent(
+  basePath: string,
+  event: WorkflowEventInput,
+  sessionId: string,
+): WorkflowEvent {
+  const fullEvent = buildWorkflowEvent(event, sessionId);
+  const location = resolveWorkflowEventLedgerLocation(basePath);
+
+  mkdirSync(location.projectGsd, { recursive: true });
+  appendFileSync(location.projectLogPath, `${JSON.stringify(fullEvent)}\n`, "utf-8");
+  emitWorkflowEventAudit(location.projectRoot, fullEvent);
+  return fullEvent;
+}
+
+export function writeWorkflowEventLog(basePath: string, events: readonly WorkflowEvent[]): void {
+  const location = resolveWorkflowEventLedgerLocation(basePath);
+  mkdirSync(location.projectGsd, { recursive: true });
+  const content = events.map((event) => JSON.stringify(event)).join("\n") + (events.length > 0 ? "\n" : "");
+  atomicWriteSync(location.projectLogPath, content);
+}
+
+export function writeWorktreeEventLog(
+  worktreeBasePath: string,
+  events: readonly WorkflowEvent[],
+): void {
+  const location = resolveWorkflowEventLedgerLocation(worktreeBasePath);
+  const logPath = location.worktreeLogPath ?? location.projectLogPath;
+  mkdirSync(dirname(logPath), { recursive: true });
+  const content = events.map((event) => JSON.stringify(event)).join("\n") + (events.length > 0 ? "\n" : "");
+  atomicWriteSync(logPath, content);
+}
+
+function emitWorkflowEventAudit(basePath: string, event: WorkflowEvent): void {
+  if (!isUnifiedAuditEnabled()) return;
+  try {
+    const normalized = normalizeWorkflowEventCommand(event.cmd) ?? "unknown";
+    emitUokAuditEvent(
+      basePath,
+      buildAuditEnvelope({
+        traceId: event.session_id,
+        category: "orchestration",
+        type: `workflow-event-${normalized}`,
+        payload: {
+          cmd: event.cmd,
+          params: event.params,
+          actor: event.actor,
+          actorName: event.actor_name,
+          triggerReason: event.trigger_reason,
+          eventTs: event.ts,
+          hash: event.hash,
+        },
+      }),
+    );
+  } catch {
+    // Best-effort: audit projection must never block the workflow event ledger.
+  }
+}

package/src/resources/extensions/gsd/workflow-event-vocabulary.ts

@@ -0,0 +1,59 @@
+import type { WorkflowEvent } from "./workflow-events.js";
+
+export interface WorkflowEventEntityKey {
+  type: string;
+  id: string;
+}
+
+export function normalizeWorkflowEventCommand(cmd: unknown): string | null {
+  return typeof cmd === "string" ? cmd.replace(/-/g, "_") : null;
+}
+
+/**
+ * Workflow progress events are keyed by the domain entity they mutate.
+ * Keep command aliases and conflict identity in this module so replay,
+ * conflict detection, and tests do not each grow their own vocabulary.
+ */
+export function workflowEventEntityKey(event: WorkflowEvent): WorkflowEventEntityKey | null {
+  const p = event.params;
+  const cmd = normalizeWorkflowEventCommand(event.cmd);
+  if (!cmd) return null;
+
+  switch (cmd) {
+    case "complete_task":
+    case "start_task":
+    case "skip_task":
+    case "report_blocker":
+    case "record_verification":
+    case "plan_task":
+      return typeof p["taskId"] === "string"
+        ? { type: "task", id: p["taskId"] }
+        : null;
+
+    case "complete_slice":
+    case "replan_slice":
+      return typeof p["sliceId"] === "string"
+        ? { type: "slice", id: p["sliceId"] }
+        : null;
+
+    case "plan_slice":
+      return typeof p["sliceId"] === "string"
+        ? { type: "slice_plan", id: p["sliceId"] }
+        : null;
+
+    case "complete_milestone":
+    case "plan_milestone":
+      return typeof p["milestoneId"] === "string"
+        ? { type: "milestone", id: p["milestoneId"] }
+        : null;
+
+    case "save_decision":
+      if (typeof p["scope"] === "string" && typeof p["decision"] === "string") {
+        return { type: "decision", id: `${p["scope"]}:${p["decision"]}` };
+      }
+      return null;
+
+    default:
+      return null;
+  }
+}

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

@@ -1,8 +1,13 @@
-import { createHash, randomUUID } from "node:crypto";
-import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { readFileSync, existsSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { withFileLockSync } from "./file-lock.js";
+import {
+  appendWorkflowEvent,
+  workflowEventArchivePath,
+  workflowEventLogPath,
+  type WorkflowEventInput,
+} from "./workflow-event-ledger.js";
 import { logWarning } from "./workflow-logger.js";
 
 // ─── Session ID ───────────────────────────────────────────────────────────
@@ -40,22 +45,9 @@ export interface WorkflowEvent {
  */
 export function appendEvent(
   basePath: string,
-  event: Omit<WorkflowEvent, "hash" | "session_id"> & { actor_name?: string; trigger_reason?: string },
+  event: WorkflowEventInput,
 ): void {
-  const hash = createHash("sha256")
-    .update(JSON.stringify({ cmd: event.cmd, params: event.params }))
-    .digest("hex")
-    .slice(0, 16);
-
-  const fullEvent: WorkflowEvent = {
-    v: 2,
-    ...event,
-    hash,
-    session_id: ENGINE_SESSION_ID,
-  };
-  const dir = join(basePath, ".gsd");
-  mkdirSync(dir, { recursive: true });
-  appendFileSync(join(dir, "event-log.jsonl"), JSON.stringify(fullEvent) + "\n", "utf-8");
+  appendWorkflowEvent(basePath, event, ENGINE_SESSION_ID);
 }
 
 // ─── readEvents ──────────────────────────────────────────────────────────
@@ -125,8 +117,8 @@ export function compactMilestoneEvents(
   basePath: string,
   milestoneId: string,
 ): { archived: number } {
-  const logPath = join(basePath, ".gsd", "event-log.jsonl");
-  const archivePath = join(basePath, ".gsd", `event-log-${milestoneId}.jsonl.archived`);
+  const logPath = workflowEventLogPath(basePath);
+  const archivePath = workflowEventArchivePath(basePath, milestoneId);
 
   return withFileLockSync(logPath, () => {
     const allEvents = readEvents(logPath);

package/src/resources/extensions/gsd/workflow-mcp-auto-prep.ts

@@ -4,6 +4,7 @@ import {
   type EnsureProjectWorkflowMcpConfigResult,
   ensureProjectWorkflowMcpConfig,
 } from "./mcp-project-config.js";
+import { warmWorkflowMcpProbeInBackground } from "./workflow-mcp-readiness-cache.js";
 import { usesWorkflowMcpTransport } from "./workflow-mcp.js";
 
 interface WorkflowMcpAutoPrepContext {
@@ -75,6 +76,7 @@ export function prepareWorkflowMcpForProject(
     if (result.status !== "unchanged") {
       prepCtx.ui?.notify?.(`GSD MCP Server Prepared at ${result.configPath}`, "info");
     }
+    warmWorkflowMcpProbeInBackground(projectRoot);
     return result;
   } catch (err) {
     prepCtx.ui?.notify?.(