gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.b62439b9f

package/src/resources/extensions/gsd/tests/workflow-turn-reporter.test.ts

@@ -0,0 +1,87 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for workflow turn observer reporting adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createWorkflowTurnReporter } from "../auto/workflow-turn-reporter.ts";
+
+test("workflow turn reporter emits start and finish contracts", () => {
+  const starts: unknown[] = [];
+  const results: unknown[] = [];
+  let clearCount = 0;
+  const reporter = createWorkflowTurnReporter({
+    observer: {
+      onTurnStart: contract => starts.push(contract),
+      onPhaseResult: () => {},
+      onTurnResult: result => results.push(result),
+    },
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 3,
+    basePath: "/repo",
+    startedAt: "2026-05-04T00:00:00.000Z",
+    clearCurrentTurn: () => {
+      clearCount += 1;
+    },
+    now: () => "2026-05-04T00:00:01.000Z",
+  });
+
+  reporter.start();
+  reporter.finish({
+    status: "stopped",
+    failureClass: "manual-attention",
+    error: "blocked",
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+  });
+
+  assert.deepEqual(starts, [{
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 3,
+    basePath: "/repo",
+    startedAt: "2026-05-04T00:00:00.000Z",
+  }]);
+  assert.deepEqual(results, [{
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 3,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    status: "stopped",
+    failureClass: "manual-attention",
+    phaseResults: [],
+    error: "blocked",
+    startedAt: "2026-05-04T00:00:00.000Z",
+    finishedAt: "2026-05-04T00:00:01.000Z",
+  }]);
+  assert.equal(clearCount, 1);
+});
+
+test("workflow turn reporter finishes only once", () => {
+  const results: unknown[] = [];
+  let clearCount = 0;
+  const reporter = createWorkflowTurnReporter({
+    observer: {
+      onTurnStart: () => {},
+      onPhaseResult: () => {},
+      onTurnResult: result => results.push(result),
+    },
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 1,
+    basePath: "/repo",
+    startedAt: "start",
+    clearCurrentTurn: () => {
+      clearCount += 1;
+    },
+    now: () => "done",
+  });
+
+  reporter.finish({ status: "retry" });
+  reporter.finish({ status: "completed" });
+
+  assert.equal(results.length, 1);
+  assert.equal(clearCount, 1);
+});

package/src/resources/extensions/gsd/tests/workflow-unit-dispatch.test.ts

@@ -0,0 +1,160 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode unit dispatch contract adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { SidecarItem } from "../auto/session.ts";
+import type { IterationContext, IterationData, LoopState } from "../auto/types.ts";
+import type { UokGraphNode } from "../uok/contracts.ts";
+import {
+  runUnitPhaseViaContract,
+  type UnitDispatchScheduler,
+  type UnitPhaseResult,
+} from "../auto/workflow-unit-dispatch.ts";
+
+function makeIterData(overrides?: Partial<IterationData>): IterationData {
+  return {
+    unitType: "execute-task",
+    unitId: "M001/S001/T001",
+    prompt: "Run task",
+    finalPrompt: "Run task",
+    pauseAfterUatDispatch: false,
+    state: {} as IterationData["state"],
+    mid: "M001",
+    midTitle: "Milestone 1",
+    isRetry: false,
+    previousTier: undefined,
+    ...overrides,
+  };
+}
+
+function makeSidecarItem(kind: SidecarItem["kind"]): SidecarItem {
+  return {
+    kind,
+    unitType: `sidecar/${kind}`,
+    unitId: kind,
+    prompt: `Run ${kind}`,
+  };
+}
+
+class FakeScheduler implements UnitDispatchScheduler {
+  readonly handlers = new Map<UokGraphNode["kind"], (node: UokGraphNode) => Promise<void>>();
+  nodes: UokGraphNode[] = [];
+  options: unknown;
+  runHandler = true;
+
+  registerHandler(kind: UokGraphNode["kind"], handler: (node: UokGraphNode) => Promise<void>): void {
+    this.handlers.set(kind, handler);
+  }
+
+  async run(nodes: UokGraphNode[], options: { parallel: false; maxWorkers: 1 }): Promise<void> {
+    this.nodes = nodes;
+    this.options = options;
+    if (this.runHandler) {
+      await this.handlers.get(nodes[0]!.kind)?.(nodes[0]!);
+    }
+  }
+}
+
+test("runUnitPhaseViaContract calls legacy runner directly", async () => {
+  const result: UnitPhaseResult = { action: "next", data: { unitStartedAt: 1 } };
+  const calls: unknown[] = [];
+  const sidecarItem = makeSidecarItem("hook");
+
+  const outcome = await runUnitPhaseViaContract(
+    "legacy-direct",
+    { iteration: 3 } as IterationContext,
+    makeIterData(),
+    {} as LoopState,
+    sidecarItem,
+    {
+      runUnitPhase: async (...args) => {
+        calls.push(args);
+        return result;
+      },
+      createScheduler: () => assert.fail("createScheduler should not be called"),
+    },
+  );
+
+  assert.equal(outcome, result);
+  assert.equal(calls.length, 1);
+  assert.equal((calls[0] as unknown[])[3], sidecarItem);
+});
+
+test("runUnitPhaseViaContract dispatches through scheduler in uok mode", async () => {
+  const scheduler = new FakeScheduler();
+  const result: UnitPhaseResult = { action: "next", data: { requestDispatchedAt: 2 } };
+
+  const outcome = await runUnitPhaseViaContract(
+    "uok-scheduler",
+    { iteration: 4 } as IterationContext,
+    makeIterData(),
+    {} as LoopState,
+    undefined,
+    {
+      runUnitPhase: async () => result,
+      createScheduler: () => scheduler,
+    },
+  );
+
+  assert.equal(outcome, result);
+  assert.deepEqual(Array.from(scheduler.handlers.keys()), [
+    "unit",
+    "hook",
+    "subagent",
+    "team-worker",
+    "verification",
+    "reprocess",
+  ]);
+  assert.deepEqual(scheduler.nodes, [{
+    id: "dispatch:4:execute-task:M001/S001/T001",
+    kind: "unit",
+    dependsOn: [],
+    metadata: {
+      unitType: "execute-task",
+      unitId: "M001/S001/T001",
+    },
+  }]);
+  assert.deepEqual(scheduler.options, { parallel: false, maxWorkers: 1 });
+});
+
+test("runUnitPhaseViaContract maps sidecar kind to scheduler node kind", async () => {
+  const scheduler = new FakeScheduler();
+
+  await runUnitPhaseViaContract(
+    "uok-scheduler",
+    { iteration: 1 } as IterationContext,
+    makeIterData({ unitType: "sidecar/triage", unitId: "triage-1" }),
+    {} as LoopState,
+    makeSidecarItem("triage"),
+    {
+      runUnitPhase: async () => ({ action: "next", data: {} }),
+      createScheduler: () => scheduler,
+    },
+  );
+
+  assert.equal(scheduler.nodes[0]?.kind, "verification");
+});
+
+test("runUnitPhaseViaContract breaks when scheduler never runs a handler", async () => {
+  const scheduler = new FakeScheduler();
+  scheduler.runHandler = false;
+
+  const outcome = await runUnitPhaseViaContract(
+    "uok-scheduler",
+    { iteration: 1 } as IterationContext,
+    makeIterData(),
+    {} as LoopState,
+    undefined,
+    {
+      runUnitPhase: async () => assert.fail("runUnitPhase should not be called"),
+      createScheduler: () => scheduler,
+    },
+  );
+
+  assert.deepEqual(outcome, {
+    action: "break",
+    reason: "scheduler-dispatch-missing-result",
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-worker-heartbeat.test.ts

@@ -0,0 +1,123 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode worker heartbeat adapter.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  maintainWorkerHeartbeat,
+  type MaintainWorkerHeartbeatDeps,
+  type WorkerHeartbeatSession,
+} from "../auto/workflow-worker-heartbeat.ts";
+
+function makeDeps(overrides?: Partial<MaintainWorkerHeartbeatDeps>): {
+  deps: MaintainWorkerHeartbeatDeps;
+  calls: unknown[];
+  errors: unknown[];
+} {
+  const calls: unknown[] = [];
+  const errors: unknown[] = [];
+  const deps: MaintainWorkerHeartbeatDeps = {
+    heartbeatAutoWorker: workerId => calls.push(["heartbeat", workerId]),
+    refreshMilestoneLease: (workerId, milestoneId, token) => {
+      calls.push(["refresh", workerId, milestoneId, token]);
+      return true;
+    },
+    logHeartbeatFailure: err => errors.push(err),
+    ...overrides,
+  };
+  return { deps, calls, errors };
+}
+
+test("maintainWorkerHeartbeat no-ops without a worker id", () => {
+  const { deps, calls, errors } = makeDeps();
+
+  maintainWorkerHeartbeat({}, deps);
+
+  assert.deepEqual(calls, []);
+  assert.deepEqual(errors, []);
+});
+
+test("maintainWorkerHeartbeat refreshes worker heartbeat without active lease", () => {
+  const { deps, calls, errors } = makeDeps();
+
+  maintainWorkerHeartbeat({ workerId: "worker-1" }, deps);
+
+  assert.deepEqual(calls, [["heartbeat", "worker-1"]]);
+  assert.deepEqual(errors, []);
+});
+
+test("maintainWorkerHeartbeat refreshes active milestone lease when token exists", () => {
+  const { deps, calls, errors } = makeDeps();
+  const session: WorkerHeartbeatSession = {
+    workerId: "worker-1",
+    currentMilestoneId: "M001",
+    milestoneLeaseToken: 7,
+  };
+
+  maintainWorkerHeartbeat(session, deps);
+
+  assert.deepEqual(calls, [
+    ["heartbeat", "worker-1"],
+    ["refresh", "worker-1", "M001", 7],
+  ]);
+  assert.deepEqual(errors, []);
+});
+
+test("maintainWorkerHeartbeat skips lease refresh when token is null", () => {
+  const { deps, calls, errors } = makeDeps();
+
+  maintainWorkerHeartbeat({
+    workerId: "worker-1",
+    currentMilestoneId: "M001",
+    milestoneLeaseToken: null,
+  }, deps);
+
+  assert.deepEqual(calls, [["heartbeat", "worker-1"]]);
+  assert.deepEqual(errors, []);
+});
+
+test("maintainWorkerHeartbeat logs and suppresses heartbeat failures", () => {
+  const failure = new Error("db unavailable");
+  const { deps, calls, errors } = makeDeps({
+    heartbeatAutoWorker: workerId => {
+      calls.push(["heartbeat", workerId]);
+      throw failure;
+    },
+  });
+
+  assert.doesNotThrow(() => {
+    maintainWorkerHeartbeat({
+      workerId: "worker-1",
+      currentMilestoneId: "M001",
+      milestoneLeaseToken: 7,
+    }, deps);
+  });
+
+  assert.deepEqual(calls, [["heartbeat", "worker-1"]]);
+  assert.deepEqual(errors, [failure]);
+});
+
+test("maintainWorkerHeartbeat logs and suppresses lease refresh failures", () => {
+  const failure = new Error("lease stale");
+  const { deps, calls, errors } = makeDeps({
+    refreshMilestoneLease: (workerId, milestoneId, token) => {
+      calls.push(["refresh", workerId, milestoneId, token]);
+      throw failure;
+    },
+  });
+
+  assert.doesNotThrow(() => {
+    maintainWorkerHeartbeat({
+      workerId: "worker-1",
+      currentMilestoneId: "M001",
+      milestoneLeaseToken: 7,
+    }, deps);
+  });
+
+  assert.deepEqual(calls, [
+    ["heartbeat", "worker-1"],
+    ["refresh", "worker-1", "M001", 7],
+  ]);
+  assert.deepEqual(errors, [failure]);
+});

package/src/resources/extensions/gsd/tests/worktree-submodule-safety.test.ts

@@ -17,8 +17,8 @@
  *
  * This rewrite builds a real git parent repo + local submodule, creates
  * a worktree, dirties a tracked file inside the submodule, then invokes
- * `removeWorktree` and asserts observable behaviour on stderr (where
- * `logWarning` writes) and on the filesystem (the worktree is gone).
+ * `removeWorktree` and asserts observable behaviour through the workflow log
+ * buffer and on the filesystem (the worktree is gone).
  */
 
 import { describe, test, beforeEach, afterEach } from "node:test";
@@ -35,6 +35,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { createWorktree, removeWorktree } from "../worktree-manager.ts";
+import { _resetLogs, peekLogs } from "../workflow-logger.ts";
 
 interface Harness {
   parent: string;
@@ -112,53 +113,38 @@ function makeHarness(): Harness {
   };
 }
 
-/** Capture stderr writes during `fn`. `logWarning` writes to stderr, so
- * this reveals warnings emitted by the worktree-manager. */
-function captureStderr(fn: () => void): string {
-  const streamAny = process.stderr as unknown as {
-    write: (chunk: string | Uint8Array, ...rest: unknown[]) => boolean;
-  };
-  const original = streamAny.write.bind(streamAny);
-  const chunks: string[] = [];
-  streamAny.write = (chunk: string | Uint8Array): boolean => {
-    chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8"));
-    return true;
-  };
-  try {
-    fn();
-  } finally {
-    streamAny.write = original;
-  }
-  return chunks.join("");
+function workflowLogMessages(): string {
+  return peekLogs().map((entry) => entry.message).join("\n");
 }
 
 describe("removeWorktree preserves submodule uncommitted state (#2337)", () => {
   let h: Harness;
 
   beforeEach(() => {
+    _resetLogs();
     h = makeHarness();
   });
 
   afterEach(() => {
     h.cleanup();
+    _resetLogs();
   });
 
   test("clean submodules: worktree removes without stashing or submodule warnings", () => {
     const wt = createWorktree(h.parent, "cleanwt");
     runGit(wt.path, ["submodule", "update", "--init", "--recursive"]);
 
-    const stderr = captureStderr(() => {
-      removeWorktree(h.parent, "cleanwt");
-    });
+    removeWorktree(h.parent, "cleanwt");
+    const logs = workflowLogMessages();
 
     assert.ok(!existsSync(wt.path), "worktree directory should be gone");
     assert.doesNotMatch(
-      stderr,
+      logs,
       /Saved uncommitted submodule changes to rescue branch/,
       "clean submodule must not trigger rescue-branch creation",
     );
     assert.doesNotMatch(
-      stderr,
+      logs,
       /Submodule rescue branch creation failed/,
       "clean submodule must not trigger rescue-branch failure warning",
     );
@@ -191,21 +177,20 @@ describe("removeWorktree preserves submodule uncommitted state (#2337)", () => {
       `precondition: submodule must be diverged, got: "${subStatus}"`,
     );
 
-    const stderr = captureStderr(() => {
-      removeWorktree(h.parent, "dirtywt");
-    });
+    removeWorktree(h.parent, "dirtywt");
+    const logs = workflowLogMessages();
 
     // Worktree is gone: force fallback succeeded.
     assert.ok(!existsSync(wt.path), "worktree directory should be removed");
 
     // The code path that fires on dirty submodules emits one of these
-    // two warnings. Either indicates the detection ran — the ONLY
+    // warnings. Any of these indicates the detection ran — the ONLY
     // observable that would fail if someone removed the
     // `if (hasSubmoduleChanges)` branch and went straight to force
     // removal. This is the assertion that #4823 demanded in place of
     // the tautological `src.includes("submodule") && src.includes("force")`.
     assert.match(
-      stderr,
+      logs,
       /Saved uncommitted submodule changes to rescue branch|Submodule rescue branch creation failed|Submodule changes detected/,
       "dirty submodule must trigger detection-and-warning path",
     );
@@ -231,12 +216,11 @@ describe("removeWorktree preserves submodule uncommitted state (#2337)", () => {
       renameSync(modPath, hiddenPath);
     }
 
-    const stderr = captureStderr(() => {
-      removeWorktree(h.parent, "no-gitmodules");
-    });
+    removeWorktree(h.parent, "no-gitmodules");
+    const logs = workflowLogMessages();
 
     assert.doesNotMatch(
-      stderr,
+      logs,
       /Saved uncommitted submodule changes to rescue branch/,
       "missing .gitmodules should skip submodule detection entirely",
     );

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

@@ -1,3 +1,4 @@
+// GSD2 complete-milestone tool handler
 /**
  * complete-milestone handler — the core operation behind gsd_complete_milestone.
  *
@@ -57,6 +58,7 @@ export interface CompleteMilestoneResult {
   milestoneId: string;
   summaryPath: string;
   stale?: boolean;
+  alreadyComplete?: boolean;
 }
 
 function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string {
@@ -143,6 +145,7 @@ export async function handleCompleteMilestone(
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
   let guardError: string | null = null;
+  let alreadyComplete = false;
 
   transaction(() => {
     // State machine preconditions (inside txn for atomicity)
@@ -152,7 +155,7 @@ export async function handleCompleteMilestone(
       return;
     }
     if (isClosedStatus(milestone.status)) {
-      guardError = `milestone ${params.milestoneId} is already complete`;
+      alreadyComplete = true;
       return;
     }
 
@@ -238,14 +241,16 @@ export async function handleCompleteMilestone(
     logWarning("tool", `complete-milestone manifest warning: ${(mfErr as Error).message}`);
   }
   try {
-    appendEvent(basePath, {
-      cmd: "complete-milestone",
-      params: { milestoneId: params.milestoneId },
-      ts: new Date().toISOString(),
-      actor: "agent",
-      actor_name: params.actorName,
-      trigger_reason: params.triggerReason,
-    });
+    if (!alreadyComplete) {
+      appendEvent(basePath, {
+        cmd: "complete-milestone",
+        params: { milestoneId: params.milestoneId },
+        ts: new Date().toISOString(),
+        actor: "agent",
+        actor_name: params.actorName,
+        trigger_reason: params.triggerReason,
+      });
+    }
   } catch (eventErr) {
     logError("tool", `complete-milestone event log FAILED — completion invisible to reconciliation`, { error: (eventErr as Error).message });
   }
@@ -254,5 +259,6 @@ export async function handleCompleteMilestone(
     milestoneId: params.milestoneId,
     summaryPath,
     ...(projectionStale ? { stale: true } : {}),
+    ...(alreadyComplete ? { alreadyComplete: true } : {}),
   };
 }

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

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Complete-task tool handler for GSD workflow state and summaries.
+
 /**
  * complete-task handler — the core operation behind gsd_complete_task.
  *
@@ -55,7 +58,7 @@ export interface CompleteTaskResult {
   stale?: boolean;
 }
 
-import type { TaskRow } from "../gsd-db.js";
+import type { TaskRow } from "../db-task-slice-rows.js";
 
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -477,12 +477,17 @@ export async function executeCompleteMilestone(
       isError: true,
       };
     }
+    const message = result.alreadyComplete
+      ? `Milestone ${result.milestoneId} is already complete. Summary available at ${result.summaryPath}`
+      : `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}`;
     return {
-      content: [{ type: "text", text: `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}` }],
+      content: [{ type: "text", text: message }],
       details: {
         operation: "complete_milestone",
         milestoneId: result.milestoneId,
         summaryPath: result.summaryPath,
+        ...(result.alreadyComplete ? { alreadyComplete: true } : {}),
+        ...(result.stale ? { stale: true } : {}),
       },
     };
   } catch (err) {

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

@@ -113,7 +113,7 @@ const CONTEXT_MODE_LANE_LABELS: Record<Exclude<ContextModePolicy, "none">, strin
 };
 
 const CONTEXT_MODE_GUIDANCE =
-  "Use `gsd_exec` for noisy scans, builds, and tests so full output stays out of prompt context; call `gsd_exec_search` before repeating prior runs; call `gsd_resume` after compaction or resume to recover stored execution context.";
+  "Use `gsd_exec` for noisy commands, `gsd_exec_search` before reruns, and `gsd_resume` after compaction or resume.";
 
 /**
  * Render the Context Mode instruction lane for a unit type. Unknown unit

package/src/resources/extensions/gsd/uok/kernel.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Selects the UOK kernel path and records parity diagnostics.
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -9,6 +11,7 @@ import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
 import { setUnifiedAuditEnabled } from "./audit-toggle.js";
 import { resolveUokFlags } from "./flags.js";
 import { createTurnObserver } from "./loop-adapter.js";
+import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
 
 interface RunAutoLoopWithUokArgs {
   ctx: ExtensionContext;
@@ -54,10 +57,14 @@ export async function runAutoLoopWithUok(args: RunAutoLoopWithUokArgs): Promise<
   const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
   const flags = resolveUokFlags(prefs);
   setUnifiedAuditEnabled(flags.auditUnified);
+  const pathLabel = resolveKernelPathLabel(flags);
+  if (pathLabel !== "uok-kernel") {
+    incrementLegacyTelemetry("legacy.uokFallbackUsed");
+  }
 
   writeParityEvent(s.basePath, {
     ts: new Date().toISOString(),
-    path: resolveKernelPathLabel(flags),
+    path: pathLabel,
     flags,
     phase: "enter",
   });
@@ -98,7 +105,7 @@ export async function runAutoLoopWithUok(args: RunAutoLoopWithUokArgs): Promise<
     }
     writeParityEvent(s.basePath, {
       ts: new Date().toISOString(),
-      path: resolveKernelPathLabel(flags),
+      path: pathLabel,
       flags,
       phase: "exit",
       status: "ok",
@@ -106,7 +113,7 @@ export async function runAutoLoopWithUok(args: RunAutoLoopWithUokArgs): Promise<
   } catch (err) {
     writeParityEvent(s.basePath, {
       ts: new Date().toISOString(),
-      path: resolveKernelPathLabel(flags),
+      path: pathLabel,
       flags,
       phase: "exit",
       status: "error",

package/src/resources/extensions/gsd/uok/plan-v2.ts

@@ -1,9 +1,13 @@
+// Project/App: GSD-2
+// File Purpose: UOK plan v2 graph compilation from GSD workflow state.
+
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 import type { GSDState, Phase } from "../types.js";
 import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
-import { isDbAvailable, getMilestoneSlices, getSliceTasks, type SliceRow } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "../gsd-db.js";
+import type { SliceRow } from "../db-task-slice-rows.js";
 import type { UokGraphNode } from "./contracts.js";
 
 const PLAN_V2_CLARIFY_ROUND_LIMIT = 3;