@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.822c9439

package/src/resources/extensions/gsd/unit-tool-contracts.ts

@@ -1,198 +1,33 @@
 // Project/App: gsd-pi
-// File Purpose: Central Unit-to-tool contracts for phase-aware GSD tool surfaces.
-
-export interface UnitToolSurfaceContract {
-  allowedGsdTools: readonly string[];
-  requiredWorkflowTools: readonly string[];
-  forbiddenGsdTools?: Readonly<Record<string, string>>;
-}
-
-export const RUN_UAT_WORKFLOW_TOOL_NAMES = [
-  "gsd_uat_exec",
-  "gsd_uat_result_save",
-  "gsd_resume",
-  "gsd_milestone_status",
-  "gsd_journal_query",
-] as const;
-
-export const RUN_UAT_READ_ONLY_TOOL_NAMES = [
-  "find",
-  "glob",
-  "grep",
-  "ls",
-  "read",
-] as const;
-
-export const RUN_UAT_BROWSER_TOOL_NAMES = [
-  "browser_navigate",
-  "browser_click",
-  "browser_type",
-  "browser_fill_form",
-  "browser_click_ref",
-  "browser_fill_ref",
-  "browser_wait_for",
-  "browser_assert",
-  "browser_verify",
-  "browser_screenshot",
-  "browser_snapshot_refs",
-  "browser_find",
-  "browser_get_console_logs",
-  "browser_get_network_logs",
-  "browser_evaluate",
-  "browser_reload",
-  "browser_batch",
-  "browser_act",
-] as const;
+// File Purpose: Unit-to-tool contract views derived from the Unit Registry (ADR-033).
+//
+// The contract data lives in unit-registry.ts (one Unit Descriptor per unit
+// type). This file keeps the established import surface: the derived
+// `UNIT_TOOL_CONTRACTS` table and its accessor functions are unchanged for
+// consumers.
+
+import {
+  UNIT_REGISTRY,
+  type UnitToolSurfaceContract,
+  type UnitWorkflowToolName,
+} from "./unit-registry.js";
+
+export {
+  RUN_UAT_WORKFLOW_TOOL_NAMES,
+  RUN_UAT_READ_ONLY_TOOL_NAMES,
+  RUN_UAT_BROWSER_TOOL_NAMES,
+  type UnitToolSurfaceContract,
+  type UnitWorkflowToolName,
+  type UnitGsdToolName,
+} from "./unit-registry.js";
 
 export const RUN_UAT_TOOL_PRESENTATION_PLAN_ID = "run-uat/default-v1";
 
-export const UNIT_TOOL_CONTRACTS: Record<string, UnitToolSurfaceContract> = {
-  "research-milestone": {
-    allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_summary_save"],
-  },
-  "plan-milestone": {
-    allowedGsdTools: [
-      "gsd_milestone_status",
-      "gsd_plan_milestone",
-      "gsd_plan_slice",
-      "gsd_decision_save",
-      "gsd_requirement_update",
-    ],
-    requiredWorkflowTools: ["gsd_milestone_status", "gsd_plan_milestone", "gsd_plan_slice"],
-  },
-  "discuss-milestone": {
-    allowedGsdTools: [
-      "gsd_summary_save",
-      "gsd_decision_save",
-      "gsd_requirement_save",
-      "gsd_requirement_update",
-      "gsd_plan_milestone",
-      "gsd_milestone_generate_id",
-    ],
-    requiredWorkflowTools: [
-      "ask_user_questions",
-      "gsd_summary_save",
-      "gsd_requirement_save",
-      "gsd_requirement_update",
-      "gsd_plan_milestone",
-      "gsd_milestone_generate_id",
-    ],
-  },
-  "discuss-slice": {
-    allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
-    requiredWorkflowTools: ["ask_user_questions", "gsd_summary_save"],
-  },
-  "validate-milestone": {
-    allowedGsdTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap", "subagent"],
-    requiredWorkflowTools: ["gsd_milestone_status", "gsd_validate_milestone", "gsd_reassess_roadmap"],
-  },
-  "complete-milestone": {
-    allowedGsdTools: [
-      "gsd_milestone_status",
-      "gsd_requirement_update",
-      "gsd_summary_save",
-      "gsd_complete_milestone",
-      "subagent",
-    ],
-    requiredWorkflowTools: [
-      "gsd_milestone_status",
-      "gsd_requirement_update",
-      "gsd_summary_save",
-      "gsd_complete_milestone",
-    ],
-  },
-  "research-slice": {
-    allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_summary_save"],
-  },
-  "plan-slice": {
-    allowedGsdTools: ["gsd_plan_slice", "gsd_reassess_roadmap", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_plan_slice", "gsd_reassess_roadmap"],
-  },
-  "refine-slice": {
-    allowedGsdTools: ["gsd_plan_slice", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_plan_slice"],
-  },
-  "replan-slice": {
-    allowedGsdTools: ["gsd_replan_slice", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_replan_slice"],
-  },
-  "complete-slice": {
-    allowedGsdTools: [
-      "gsd_slice_complete",
-      "gsd_task_reopen",
-      "gsd_replan_slice",
-      "gsd_decision_save",
-      "gsd_requirement_update",
-      "gsd_summary_save",
-      "subagent",
-    ],
-    requiredWorkflowTools: [
-      "gsd_slice_complete",
-      "gsd_task_reopen",
-      "gsd_replan_slice",
-      "gsd_requirement_update",
-      "gsd_summary_save",
-    ],
-    forbiddenGsdTools: {
-      gsd_uat_result_save: "Run UAT owns persisted UAT Assessment.",
-    },
-  },
-  "reassess-roadmap": {
-    allowedGsdTools: ["gsd_milestone_status", "gsd_reassess_roadmap"],
-    requiredWorkflowTools: ["gsd_milestone_status", "gsd_reassess_roadmap"],
-  },
-  "execute-task": {
-    allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_task_complete"],
-  },
-  "execute-task-simple": {
-    allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_task_complete"],
-  },
-  "reactive-execute": {
-    allowedGsdTools: ["gsd_task_complete", "gsd_summary_save", "gsd_decision_save"],
-    requiredWorkflowTools: ["gsd_task_complete", "gsd_summary_save"],
-  },
-  "run-uat": {
-    allowedGsdTools: [...RUN_UAT_WORKFLOW_TOOL_NAMES, "subagent"],
-    requiredWorkflowTools: [...RUN_UAT_WORKFLOW_TOOL_NAMES],
-    forbiddenGsdTools: {
-      gsd_exec: "Use gsd_uat_exec so acceptance evidence is typed as UAT-owned.",
-      gsd_save_gate_result: "gsd_uat_result_save owns the aggregate UAT gate.",
-      gsd_summary_save: "gsd_uat_result_save owns persisted UAT Assessment writes.",
-    },
-  },
-  "gate-evaluate": {
-    allowedGsdTools: ["gsd_save_gate_result"],
-    requiredWorkflowTools: ["gsd_save_gate_result"],
-  },
-  "rewrite-docs": {
-    allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
-    requiredWorkflowTools: [],
-  },
-  "workflow-preferences": {
-    allowedGsdTools: ["gsd_summary_save"],
-    requiredWorkflowTools: [],
-  },
-  "discuss-project": {
-    allowedGsdTools: ["gsd_summary_save", "gsd_decision_save", "gsd_requirement_save"],
-    requiredWorkflowTools: ["ask_user_questions", "gsd_summary_save"],
-  },
-  "discuss-requirements": {
-    allowedGsdTools: ["gsd_requirement_save", "gsd_summary_save"],
-    requiredWorkflowTools: ["ask_user_questions", "gsd_requirement_save", "gsd_summary_save"],
-  },
-  "research-decision": {
-    allowedGsdTools: ["gsd_summary_save"],
-    requiredWorkflowTools: ["ask_user_questions"],
-  },
-  "research-project": {
-    allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
-    requiredWorkflowTools: [],
-  },
-};
+export const UNIT_TOOL_CONTRACTS: Record<string, UnitToolSurfaceContract> = Object.fromEntries(
+  Object.entries(UNIT_REGISTRY).flatMap(([unitType, descriptor]) =>
+    descriptor.toolContract ? [[unitType, descriptor.toolContract]] : [],
+  ),
+);
 
 export const AUTO_UNIT_SCOPED_TOOLS: Record<string, readonly string[]> = Object.fromEntries(
   Object.entries(UNIT_TOOL_CONTRACTS).map(([unitType, contract]) => [unitType, contract.allowedGsdTools]),
@@ -202,7 +37,7 @@ export function getUnitToolSurfaceContract(unitType: string): UnitToolSurfaceCon
   return UNIT_TOOL_CONTRACTS[unitType];
 }
 
-export function getRequiredWorkflowToolsForUnit(unitType: string): string[] {
+export function getRequiredWorkflowToolsForUnit(unitType: string): UnitWorkflowToolName[] {
   return [...(UNIT_TOOL_CONTRACTS[unitType]?.requiredWorkflowTools ?? [])];
 }
 

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

@@ -137,7 +137,7 @@ export function isValidMilestoneVerdict(verdict: string): verdict is ValidationV
  * Extract the UAT type from content, defaulting to `"artifact-driven"`.
  *
  * The `"artifact-driven"` fallback is the original default used throughout
- * the codebase when a UAT file lacks an explicit `## UAT Type` section.
+ * the codebase when a UAT file has no parseable UAT mode declaration.
  */
 export function getUatType(content: string): UatType {
   return getDeclaredUatType(content);

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/web-app-uat.ts

@@ -1,10 +1,12 @@
 // Project/App: gsd-pi
-// File Purpose: Web-app detection and Playwright/UAT guidance for planning and slice closeout.
+// File Purpose: Web-app detection and browser-UAT guidance for planning and slice closeout.
 
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
+import { resolveAmbientBrowserEngineResolution, type BrowserEngineResolution } from "../browser-tools/engine/selection.js";
 import { detectWebApp } from "../browser-tools/web-app-detect.js";
+import { UAT_MODE_POLICIES, type UatType } from "./uat-policy.js";
 
 export { detectWebApp };
 
@@ -47,24 +49,61 @@ export function findPlaywrightTestScript(projectRoot: string): string | null {
   return null;
 }
 
+function describeBrowserToolBacking(engineResolution: BrowserEngineResolution): string {
+  switch (engineResolution.engine) {
+    case "gsd-browser":
+      return "This project looks browser-facing. GSD exposes `browser_*` tools backed by the managed gsd-browser engine for run-uat.";
+    case "legacy":
+      return "This project looks browser-facing. GSD exposes Playwright-backed `browser_*` tools for run-uat.";
+    case "off":
+      return "This project looks browser-facing, but Pi browser tools are disabled (GSD_BROWSER_ENGINE=off) — prefer `runtime-executable` UAT with automated browser test commands.";
+  }
+}
+
+// One bullet per recommended UAT mode; `mode` keys into UAT_MODE_POLICIES so
+// modes that require browser tools drop out of the guidance when the resolved
+// engine provides none (mixed/live-runtime share one bullet and one policy bit).
+const UAT_MODE_GUIDANCE: ReadonlyArray<{ mode: UatType; bullet: string }> = [
+  {
+    mode: "browser-executable",
+    bullet: "- `browser-executable` — navigate to `http://localhost:…`, click, screenshot, assert via `browser_*` tools during run-uat",
+  },
+  {
+    mode: "runtime-executable",
+    bullet: "- `runtime-executable` — run an automated browser test command via `gsd_uat_exec` (for example `npx playwright test`)",
+  },
+  {
+    mode: "mixed",
+    bullet: "- `mixed` / `live-runtime` — combine runtime startup checks with interactive browser verification",
+  },
+];
+
 /**
  * Markdown block injected into plan/complete-slice prompts when the project
- * looks browser-facing. Returns null for CLI/library-only repos.
+ * looks browser-facing. Returns null for CLI/library-only repos. Guidance is
+ * composed from the resolved Browser Automation Engine so prompts never claim
+ * an engine the runtime is not using; `engineResolution` is injectable for
+ * tests and defaults to the ambient resolution.
  */
-export function buildWebAppUatGuidanceBlock(projectRoot: string): string | null {
+export function buildWebAppUatGuidanceBlock(
+  projectRoot: string,
+  engineResolution?: BrowserEngineResolution,
+): string | null {
   if (!detectWebApp(projectRoot)) return null;
 
+  const resolvedEngine = engineResolution ?? resolveAmbientBrowserEngineResolution(projectRoot);
+  const browserToolsAvailable = resolvedEngine.engine !== "off";
   const playwrightScript = findPlaywrightTestScript(projectRoot);
   const hasPlaywright = hasPlaywrightTestDependency(projectRoot) || playwrightScript !== null;
   const lines = [
     "### Web App UAT (detected)",
     "",
-    "This project looks browser-facing. GSD exposes Playwright-backed `browser_*` tools by default for run-uat.",
+    describeBrowserToolBacking(resolvedEngine),
     "",
     "**UAT modes (pick one per slice — do not use `artifact-driven` for browser steps):**",
-    "- `browser-executable` — navigate to `http://localhost:…`, click, screenshot, assert via `browser_*` tools during run-uat",
-    "- `runtime-executable` — run an automated browser test command via `gsd_uat_exec` (for example `npx playwright test`)",
-    "- `mixed` / `live-runtime` — combine runtime startup checks with interactive browser verification",
+    ...UAT_MODE_GUIDANCE
+      .filter(({ mode }) => browserToolsAvailable || !UAT_MODE_POLICIES[mode].browserTools)
+      .map(({ bullet }) => bullet),
     "",
     "**Planning / closeout rules:**",
     "- Preconditions must name the dev-server command and URL (for example `npm run dev` → `http://localhost:3000`)",
@@ -93,8 +132,12 @@ export function buildWebAppUatGuidanceBlock(projectRoot: string): string | null
       "**Playwright scaffolding (first UI slice):** no `playwright` / `@playwright/test` dependency yet.",
       "- Add a planning task that installs Playwright, adds `playwright.config.ts`, and creates a minimal smoke spec (for example `e2e/smoke.spec.ts`)",
       "- Task `verify` should run `npx playwright test` (or the focused spec) with a safe, simple command",
-      "- Until specs exist, use `browser-executable` UAT with localhost preconditions and interactive `browser_*` checks at slice closeout",
     );
+    if (browserToolsAvailable) {
+      lines.push(
+        "- Until specs exist, use `browser-executable` UAT with localhost preconditions and interactive `browser_*` checks at slice closeout",
+      );
+    }
   }
 
   return lines.join("\n");

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);