@stigmer/runner 3.10.0 → 3.11.1-dev.20260812192248

package/src/activities/emit-event.ts

@@ -9,12 +9,24 @@
  *
  * Supported delivery targets:
  * - webhook: HTTP POST with Content-Type: application/cloudevents+json
- * - signal:  Temporal signal to another running workflow's listen task
+ * - signal:  signal to another workflow execution's listen task, routed
+ *            through the server's SendSignal lane
+ *
+ * Signal delivery is deliberately server-mediated (oss#517): a direct
+ * Temporal client here would bypass the authorization boundary (any
+ * workflow could signal any workflow id in the namespace) and is
+ * structurally incompatible with payload encryption — emit→listen is
+ * the platform's only runner-to-runner channel, and under per-identity
+ * runner keys a sender-encrypted signal fails closed at a receiver
+ * holding a different key. The server re-produces the payload, so each
+ * side's codec passes it through.
  *
  * CloudEvents spec: https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md
  */
 
 import { randomUUID } from "node:crypto";
+import type { JsonObject } from "@bufbuild/protobuf";
+import { StigmerClient } from "../client/stigmer-client.js";
 import { loadConfig } from "../config.js";
 import { resolveRuntimePlaceholders } from "../workflow-engine/resolve.js";
 
@@ -24,7 +36,9 @@ export interface WebhookDeliveryTarget {
 }
 
 export interface SignalDeliveryTarget {
-  readonly workflow_id: string;
+  /** Target workflow execution id ("wfx_..."), as returned by run/create. */
+  readonly execution_id: string;
+  /** Signal name matching the target's listen task event id (verbatim). */
   readonly signal_name: string;
 }
 
@@ -54,6 +68,11 @@ export interface EmitEventResult {
 
 const WEBHOOK_TIMEOUT_MS = 30_000;
 
+// Delivery is best-effort by contract, so no single target may consume the
+// CallFunction activity's whole 5m startToClose budget. Same bound as the
+// webhook arm.
+const SIGNAL_TIMEOUT_MS = 30_000;
+
 function buildEnvelope(
   config: EmitEventConfig,
   executionId: string,
@@ -120,33 +139,53 @@ async function deliverWebhook(
   }
 }
 
+function buildClient(): StigmerClient {
+  const config = loadConfig();
+  return new StigmerClient({
+    endpoint: config.stigmerBackendEndpoint,
+    token: config.stigmerToken,
+  });
+}
+
 async function deliverSignal(
   envelope: Record<string, unknown>,
   target: SignalDeliveryTarget,
+  client: StigmerClient,
 ): Promise<DeliveryError | null> {
-  try {
-    const { Connection, Client } = await import("@temporalio/client");
-
-    // Resolve Temporal coordinates through the central config layer rather than
-    // reading env directly: signal delivery must dial the SAME cluster/namespace
-    // the worker connected with. config.ts is the single source of truth for the
-    // canonical TEMPORAL_SERVICE_ADDRESS / TEMPORAL_NAMESPACE resolution — reading
-    // env here would diverge (and previously dialed localhost via a stale name).
-    const config = loadConfig();
-    const temporalAddress = config.temporalAddress;
-    const temporalNamespace = config.temporalNamespace;
-
-    const connection = await Connection.connect({ address: temporalAddress });
-    const client = new Client({ connection, namespace: temporalNamespace });
-
-    const handle = client.workflow.getHandle(target.workflow_id);
-    await handle.signal(target.signal_name, envelope);
+  // Refuse the pre-oss#517 field by name: direct-addressing raw Temporal
+  // workflow ids is exactly the capability server mediation removes.
+  const legacyWorkflowId = (target as { workflow_id?: unknown }).workflow_id;
+  if (!target.execution_id) {
+    const reason = legacyWorkflowId
+      ? "signal delivery addresses workflow executions by 'execution_id' (\"wfx_...\"); 'workflow_id' is not supported"
+      : "signal delivery requires 'execution_id'";
+    return {
+      target: `signal:${String(legacyWorkflowId ?? "")}/${target.signal_name ?? ""}`,
+      error: reason,
+    };
+  }
+  if (!target.signal_name) {
+    return {
+      target: `signal:${target.execution_id}/`,
+      error: "signal delivery requires 'signal_name'",
+    };
+  }
 
+  try {
+    await client.sendWorkflowSignal(
+      target.execution_id,
+      target.signal_name,
+      envelope as JsonObject,
+      { timeoutMs: SIGNAL_TIMEOUT_MS },
+    );
     return null;
   } catch (err) {
+    // Server refusals arrive as ConnectErrors whose messages carry the code
+    // (e.g. [not_found], [failed_precondition] for terminal executions) —
+    // surfaced verbatim in delivery_errors, same contract as the webhook arm.
     const message = err instanceof Error ? err.message : String(err);
     return {
-      target: `signal:${target.workflow_id}/${target.signal_name}`,
+      target: `signal:${target.execution_id}/${target.signal_name}`,
       error: message,
     };
   }
@@ -173,13 +212,18 @@ export async function emitEventAction(
   const errors: DeliveryError[] = [];
   const env = runtimeEnv ?? {};
 
+  // One client serves all signal targets of this emit; constructed lazily so
+  // webhook-only emits never pay for a gRPC transport.
+  let client: StigmerClient | undefined;
+
   for (const target of config.delivery) {
     let err: DeliveryError | null = null;
 
     if ("webhook" in target) {
       err = await deliverWebhook(envelope, target.webhook, env);
     } else if ("signal" in target) {
-      err = await deliverSignal(envelope, target.signal);
+      client ??= buildClient();
+      err = await deliverSignal(envelope, target.signal, client);
     }
 
     if (err) {

package/src/activities/execute-cursor/__test-utils__/cursor-hook-harness.ts

@@ -108,6 +108,14 @@ export interface CursorHookHarnessOptions {
    * non-pausing "unattended" kind and the adapt-and-explain agent message.
    */
   unattendedSkip?: boolean;
+  /**
+   * Per-server enabled_tools allow-lists (issue #350) — restricted servers
+   * only. The hook's manifest arm denies a beforeMCPExecution call whose
+   * mcp_server_name is listed here with a tool name outside its list (kind
+   * "disabled", ahead of every approval bypass). hookMcp payloads carry
+   * mcp_server_name "srv".
+   */
+  mcpServerEnabledTools?: Record<string, string[]>;
 }
 
 /**
@@ -170,6 +178,7 @@ export function setupCursorHookHarness(opts: CursorHookHarnessOptions = {}): Cur
       opts.captureIgnored ?? false,
       opts.gitWorkspace ?? true,
       opts.unattendedSkip ?? false,
+      opts.mcpServerEnabledTools ?? {},
     );
     writeFileSync(statePath, JSON.stringify(state), "utf-8");
   }

package/src/activities/execute-cursor/__tests__/approval-gate.test.ts

@@ -219,6 +219,20 @@ describe("buildApprovalState", () => {
     expect((state as unknown as Record<string, unknown>).builtInGatedList).toBeUndefined();
   });
 
+  it("carries the enabled_tools manifest (issue #350) and defaults it to empty", () => {
+    // Default: no restriction — the hook's disabled arm is inert.
+    const bare = buildApprovalState(mcpPolicies, false, new Set());
+    expect(bare.mcpServerEnabledTools).toEqual({});
+
+    // Restricted servers ride through verbatim for the hook's server-scoped
+    // membership check.
+    const restricted = buildApprovalState(
+      mcpPolicies, false, new Set(), undefined, false, false, true, false,
+      { planton: ["get_cloud_resource"] },
+    );
+    expect(restricted.mcpServerEnabledTools).toEqual({ planton: ["get_cloud_resource"] });
+  });
+
   it("emits the CONTENT token when a grant carries a content digest", () => {
     const grants = [{ toolName: "edit", mcpServerSlug: "", key: "write", salient: "/x/gated.txt", contentDigest: "deadbeef", sourceToolCallId: "consent-1" }];
     const state = buildApprovalState(mcpPolicies, false, new Set(), grants);

package/src/activities/execute-cursor/__tests__/attachment-resolver.test.ts

@@ -114,6 +114,59 @@ describe("resolveAttachments", () => {
     expect(readFileSync(join(platformDir, "inputs", "data.csv"), "utf-8")).toBe("a,b,c");
   });
 
+  it("uniquifies duplicate filenames on the storage branch — neither file's bytes are lost (issue #364)", async () => {
+    // Before the fix this branch had no collision check and the second write
+    // silently overwrote the first.
+    const { storage } = makeInMemoryArtifactStorage();
+    await storage.upload("attachments/01AAA/report.pdf", Buffer.from("first bytes"), "application/pdf");
+    await storage.upload("attachments/01BBB/report.pdf", Buffer.from("second bytes"), "application/pdf");
+
+    const result = await resolveAttachments(
+      [
+        makeAttachment({ filename: "report.pdf", storageKey: "attachments/01AAA/report.pdf" }),
+        makeAttachment({ filename: "report.pdf", storageKey: "attachments/01BBB/report.pdf" }),
+      ],
+      options({ storage }),
+    );
+
+    expect(result).toEqual([
+      { filename: "report.pdf", relativePath: ".stigmer/inputs/report.pdf" },
+      {
+        filename: "report-2.pdf",
+        relativePath: ".stigmer/inputs/report-2.pdf",
+        renamedFrom: "report.pdf",
+      },
+    ]);
+    expect(readFileSync(join(platformDir, "inputs", "report.pdf"), "utf-8")).toBe("first bytes");
+    expect(readFileSync(join(platformDir, "inputs", "report-2.pdf"), "utf-8")).toBe("second bytes");
+  });
+
+  it("uniquifies duplicate filenames across the local and storage branches (one shared taken-set)", async () => {
+    const srcPath = join(workspaceDir, "notes.md");
+    writeFileSync(srcPath, "local copy");
+    const { storage } = makeInMemoryArtifactStorage();
+    await storage.upload("attachments/01ABC/notes.md", Buffer.from("uploaded copy"), "text/markdown");
+
+    const result = await resolveAttachments(
+      [
+        makeAttachment({ filename: "notes.md", storageKey: "", localPath: srcPath }),
+        makeAttachment({ filename: "notes.md", storageKey: "attachments/01ABC/notes.md" }),
+      ],
+      options({ storage }),
+    );
+
+    expect(result).toEqual([
+      { filename: "notes.md", relativePath: ".stigmer/inputs/notes.md" },
+      {
+        filename: "notes-2.md",
+        relativePath: ".stigmer/inputs/notes-2.md",
+        renamedFrom: "notes.md",
+      },
+    ]);
+    expect(readFileSync(join(platformDir, "inputs", "notes.md"), "utf-8")).toBe("local copy");
+    expect(readFileSync(join(platformDir, "inputs", "notes-2.md"), "utf-8")).toBe("uploaded copy");
+  });
+
   it("ignores localPath in cloud mode and downloads by storage key", async () => {
     const { storage } = makeInMemoryArtifactStorage();
     await storage.upload("attachments/01ABC/plan.md", Buffer.from("from storage"), "text/markdown");

package/src/activities/execute-cursor/__tests__/build-prompt.test.ts

@@ -14,7 +14,7 @@ import { ApprovalAction, InteractionMode } from "@stigmer/protos/ai/stigmer/agen
 import { PendingApprovalSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
 import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
 
-import { buildPrompt, isHitlReinvocation } from "../index.js";
+import { appendStructuredOutputDirective, buildPrompt, isHitlReinvocation, primarySendCarriesImages } from "../index.js";
 import type { BuildPromptInput } from "../index.js";
 import { buildReinvocationPrompt, formatInteractionModePrefix, formatImplementPlanSection, formatToolApprovalProtocol, buildToolApprovalRuleFile } from "../prompt-builder.js";
 import { PLAN_MODE_DIRECTIVE } from "../../../shared/plan-mode-prompt.js";
@@ -47,7 +47,7 @@ function input(overrides: Partial<BuildPromptInput>): BuildPromptInput {
     subAgents: [],
     workspaceDirs: ["/tmp/ws"],
     workspaceFileRefs: [],
-    attachmentPaths: [],
+    attachments: [],
     pendingApprovals: [],
     ...overrides,
   };
@@ -103,6 +103,10 @@ describe("buildPrompt", () => {
     expect(prompt).toContain("<available_datastores>");
     expect(prompt).toContain("- clinic");
     expect(prompt).toContain("describe_datastore");
+    // The standing failure-disclosure instruction (issue #325) is this
+    // harness's ONLY outage coverage: the Cursor SDK connects MCP itself,
+    // so the runner can never reconcile the live roster here.
+    expect(prompt).toContain("do not answer from memory");
   });
 
   it("omits the datastores section when the agent uses no datastores", () => {
@@ -251,7 +255,7 @@ describe("buildPrompt", () => {
   });
 });
 
-describe("isHitlReinvocation (the single discriminator for message-accompanied payloads)", () => {
+describe("isHitlReinvocation (paired with resolution.reason at every consumer — issue #366)", () => {
   it("is false with no decisions and false with an empty map", () => {
     expect(isHitlReinvocation(undefined)).toBe(false);
     expect(isHitlReinvocation(new Map())).toBe(false);
@@ -264,12 +268,121 @@ describe("isHitlReinvocation (the single discriminator for message-accompanied p
   });
 });
 
+describe("HITL recovery — fresh agent mid-HITL (issue #366)", () => {
+  const decisions = () =>
+    new Map<string, ApprovalAction>([["tool-call-1", ApprovalAction.APPROVE]]);
+  const approvals = () => [
+    create(PendingApprovalSchema, {
+      toolCallId: "tool-call-1",
+      toolName: "Write",
+      message: "Write file: gated.txt",
+    }),
+  ];
+  const recoveryInput = (overrides: Partial<BuildPromptInput> = {}) =>
+    input({
+      resolution: resolution("local", "created_after_resume_failure"),
+      approvalDecisions: decisions(),
+      pendingApprovals: approvals(),
+      ...overrides,
+    });
+
+  it("keeps the resumed-HITL prompt byte-identical to the bare reinvocation prompt (regression guard)", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "resumed_successfully"),
+        approvalDecisions: decisions(),
+        pendingApprovals: approvals(),
+      }),
+    );
+    expect(prompt).toBe(buildReinvocationPrompt(approvals(), decisions()));
+  });
+
+  it("rebuilds full context for a fresh agent mid-HITL: instructions, the ORIGINAL user message, the state-loss disclosure, and the decisions", () => {
+    const prompt = buildPrompt(recoveryInput());
+    // The pre-fix failure mode: bare decisions with no story.
+    expect(prompt).not.toBe(buildReinvocationPrompt(approvals(), decisions()));
+    expect(prompt).toContain("<agent_instructions>");
+    expect(prompt).toContain("<tool_approval_protocol>");
+    expect(prompt).toContain(`<user_request>\n${USER_MESSAGE}\n</user_request>`);
+    expect(prompt).toContain("<turn_recovery>");
+    expect(prompt).toContain("Write file: gated.txt");
+    expect(prompt).toContain("APPROVED");
+    // The opaque tool-call id must not leak into the prompt (reinvocation rule).
+    expect(prompt).not.toContain("tool-call-1");
+  });
+
+  it("orders the recovery chronologically: request, then the recovered work, then the decisions, ending on the continue directive", () => {
+    const prompt = buildPrompt(
+      recoveryInput({ turnRecoveryDigest: "Tool: Write file: draft.txt — completed" }),
+    );
+    const requestIdx = prompt.indexOf("<user_request>");
+    const recoveryIdx = prompt.indexOf("<turn_recovery>");
+    const decisionsIdx = prompt.indexOf("APPROVED");
+    expect(requestIdx).toBeGreaterThan(-1);
+    expect(recoveryIdx).toBeGreaterThan(requestIdx);
+    expect(decisionsIdx).toBeGreaterThan(recoveryIdx);
+    expect(prompt).toContain("Tool: Write file: draft.txt — completed");
+    expect(prompt.trimEnd().endsWith("do not ask the user for permission in prose.")).toBe(true);
+  });
+
+  it("discloses the state loss even with NO transcript — otherwise the decisions read as reactions to proposals this agent never made", () => {
+    const prompt = buildPrompt(recoveryInput({ turnRecoveryDigest: undefined }));
+    expect(prompt).toContain("<turn_recovery>");
+    expect(prompt).toContain("no transcript of your progress is available");
+  });
+
+  it("preserves already-applied semantics: exact-applied writes are described as done, not as work to redo", () => {
+    const prompt = buildPrompt(
+      recoveryInput({ appliedToolCallIds: new Set(["tool-call-1"]) }),
+    );
+    expect(prompt).toContain("ALREADY applied");
+    expect(prompt).not.toContain("Carry them out now");
+  });
+
+  it("carries the session-standing context a first turn would get — the replacement agent inherits the whole story, not just the blueprint", () => {
+    const prompt = buildPrompt(
+      recoveryInput({ contextBridge: "User: earlier thread\nAssistant: earlier reply" }),
+    );
+    expect(prompt).toContain("<previous_conversation_context>");
+    expect(prompt).toContain("User: earlier thread");
+  });
+
+  it("selects the recovery shape for ANY non-resumed reason — decisions-only is safe only when native context is guaranteed", () => {
+    // created_first_execution + decisions cannot happen in practice
+    // (decisions are reconstructed from a persisted transcript, which
+    // implies a prior invocation) — but if it ever did, the bare decisions
+    // prompt would reproduce the #366 amnesia. Fail safe.
+    const prompt = buildPrompt(
+      recoveryInput({ resolution: resolution("local", "created_first_execution") }),
+    );
+    expect(prompt).toContain("<turn_recovery>");
+    expect(prompt).toContain("<agent_instructions>");
+  });
+
+  it("primary send skips images ONLY for a resumed HITL agent (which holds them natively); every fresh agent gets the re-delivery", () => {
+    expect(primarySendCarriesImages(decisions(), "resumed_successfully")).toBe(false);
+    // The #366 vision corollary: fresh agent mid-HITL after a
+    // resolution-time resume failure.
+    expect(primarySendCarriesImages(decisions(), "created_after_resume_failure")).toBe(true);
+    // Non-HITL turns always carry the message's images, resumed or not.
+    expect(primarySendCarriesImages(undefined, "resumed_successfully")).toBe(true);
+    expect(primarySendCarriesImages(undefined, "created_first_execution")).toBe(true);
+  });
+
+  it("the structured-output directive is a pure append shared by the primary and recovery sends — absent schema, absent suffix", () => {
+    expect(appendStructuredOutputDirective("base", undefined)).toBe("base");
+    const withSchema = appendStructuredOutputDirective("base", { type: "object" });
+    expect(withSchema.startsWith("base\n\n---\nCRITICAL OUTPUT REQUIREMENT:")).toBe(true);
+    expect(withSchema).toContain('"type": "object"');
+  });
+});
+
 describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)", () => {
   const RESUMED = { resolution: resolution("local", "resumed_successfully") };
 
   it("announces this turn's attachments to a resumed agent (per-execution value, never inherited)", () => {
     const prompt = buildPrompt(
-      input({ ...RESUMED, attachmentPaths: [".stigmer/inputs/lease.pdf"] }),
+      input({ ...RESUMED, attachments: [{ path: ".stigmer/inputs/lease.pdf" }] }),
     );
     expect(prompt).toContain("<input_files>");
     expect(prompt).toContain("`.stigmer/inputs/lease.pdf`");
@@ -277,6 +390,23 @@ describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)"
     expect(prompt.endsWith(USER_MESSAGE)).toBe(true);
   });
 
+  it("discloses a duplicate-renamed attachment's original name (issue #364)", () => {
+    const prompt = buildPrompt(
+      input({
+        ...RESUMED,
+        attachments: [
+          { path: ".stigmer/inputs/report.pdf" },
+          { path: ".stigmer/inputs/report-2.pdf", renamedFrom: "report.pdf" },
+        ],
+      }),
+    );
+    expect(prompt).toContain(
+      "- `.stigmer/inputs/report-2.pdf` (renamed from duplicate 'report.pdf')",
+    );
+    // The first file keeps a clean entry — no disclosure noise.
+    expect(prompt).toContain("- `.stigmer/inputs/report.pdf`\n");
+  });
+
   it("keeps a resumed turn WITHOUT attachments byte-identical to the raw message (regression guard)", () => {
     const prompt = buildPrompt(input({ ...RESUMED }));
     expect(prompt).toBe(USER_MESSAGE);
@@ -286,7 +416,7 @@ describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)"
     const prompt = buildPrompt(
       input({
         ...RESUMED,
-        attachmentPaths: [".stigmer/inputs/photo.jpg"],
+        attachments: [{ path: ".stigmer/inputs/photo.jpg" }],
         conversationCatchup: "User also said hello on the channel.",
       }),
     );
@@ -300,7 +430,7 @@ describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)"
     const prompt = buildPrompt(
       input({
         ...RESUMED,
-        attachmentPaths: [".stigmer/inputs/a.jpg", ".stigmer/inputs/big.png"],
+        attachments: [{ path: ".stigmer/inputs/a.jpg" }, { path: ".stigmer/inputs/big.png" }],
         vision: {
           inlineFilenames: ["a.jpg"],
           notViewable: [{ path: ".stigmer/inputs/big.png", reason: "too_large" }],
@@ -316,7 +446,7 @@ describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)"
     const prompt = buildPrompt(
       input({
         resolution: resolution("local", "created_first_execution"),
-        attachmentPaths: [".stigmer/inputs/a.jpg"],
+        attachments: [{ path: ".stigmer/inputs/a.jpg" }],
         vision: { inlineFilenames: ["a.jpg"], notViewable: [] },
       }),
     );
@@ -336,7 +466,7 @@ describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)"
             message: "Write file: gated.txt",
           }),
         ],
-        attachmentPaths: [".stigmer/inputs/photo.jpg"],
+        attachments: [{ path: ".stigmer/inputs/photo.jpg" }],
         vision: { inlineFilenames: ["photo.jpg"], notViewable: [] },
       }),
     );
@@ -543,7 +673,10 @@ describe("formatImplementPlanSection", () => {
   const PLAN_PATH = ".stigmer/inputs/plan.md";
 
   it("wraps the attached-plan directive when the plan is among the attachments", () => {
-    const section = formatImplementPlanSection(true, [PLAN_PATH, ".stigmer/inputs/data.csv"]);
+    const section = formatImplementPlanSection(true, [
+      { path: PLAN_PATH },
+      { path: ".stigmer/inputs/data.csv" },
+    ]);
 
     expect(section).toBeDefined();
     expect(section!.startsWith("<implement_plan>")).toBe(true);
@@ -553,7 +686,9 @@ describe("formatImplementPlanSection", () => {
   });
 
   it("falls back to the conversation-plan directive when no plan attachment resolved", () => {
-    const section = formatImplementPlanSection(true, [".stigmer/inputs/data.csv"]);
+    const section = formatImplementPlanSection(true, [
+      { path: ".stigmer/inputs/data.csv" },
+    ]);
 
     expect(section).toBeDefined();
     expect(section).not.toContain("plan.md");
@@ -561,12 +696,12 @@ describe("formatImplementPlanSection", () => {
   });
 
   it("returns undefined for an ordinary (non-build) execution", () => {
-    expect(formatImplementPlanSection(false, [PLAN_PATH])).toBeUndefined();
-    expect(formatImplementPlanSection(undefined, [PLAN_PATH])).toBeUndefined();
+    expect(formatImplementPlanSection(false, [{ path: PLAN_PATH }])).toBeUndefined();
+    expect(formatImplementPlanSection(undefined, [{ path: PLAN_PATH }])).toBeUndefined();
   });
 
   it("carries the plan-derived progress-tracking instruction (Tier 3)", () => {
-    const section = formatImplementPlanSection(true, [PLAN_PATH]);
+    const section = formatImplementPlanSection(true, [{ path: PLAN_PATH }]);
 
     expect(section).toContain("to-do list");
     expect(section).toContain("break the plan into");
@@ -577,7 +712,7 @@ describe("formatImplementPlanSection", () => {
       input({
         resolution: resolution("local", "created_first_execution"),
         buildFromPlan: true,
-        attachmentPaths: [PLAN_PATH],
+        attachments: [{ path: PLAN_PATH }],
       }),
     );
 
@@ -593,7 +728,7 @@ describe("formatImplementPlanSection", () => {
       input({
         resolution: resolution("local", "resumed_successfully"),
         buildFromPlan: true,
-        attachmentPaths: [PLAN_PATH],
+        attachments: [{ path: PLAN_PATH }],
       }),
     );
 
@@ -611,7 +746,7 @@ describe("formatImplementPlanSection", () => {
       input({
         resolution: resolution("local", "resumed_successfully"),
         buildFromPlan: false,
-        attachmentPaths: [PLAN_PATH],
+        attachments: [{ path: PLAN_PATH }],
       }),
     );