borgmcp 3.2.0 → 3.4.0

package/src/config-utils.ts

@@ -28,13 +28,13 @@ import type { LaunchAccessPaths } from './launch-access.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-// gh#client#18: canonical hook commands stored in JSON are shell-escaped
-// absolute paths. Bare names and stale/other-install absolute paths are
-// migrated to this form on every hook write.
-const HOOK_COMMAND = shellEscape(resolveRegenPath());
-const CLEAR_REWAKE_HOOK_COMMAND = shellEscape(resolveClearRewakePath());
-const AUDIT_HOOK_COMMAND = shellEscape(resolveLogAuditPath());
-const FOREIGN_PATH_REMINDER_HOOK_COMMAND = shellEscape(resolveForeignPathReminderPath());
+// client#394: hook commands are stable npm bin names. They intentionally stay
+// unquoted: each is a fixed single shell token with no metacharacters. Legacy
+// quoted bare names and install-specific absolute paths migrate to this form.
+const HOOK_COMMAND = 'borg-regen';
+const CLEAR_REWAKE_HOOK_COMMAND = 'borg-clear-rewake';
+const AUDIT_HOOK_COMMAND = 'borg-log-audit';
+const FOREIGN_PATH_REMINDER_HOOK_COMMAND = 'borg-foreign-path-reminder';
 const MCP_COMMAND = 'borg-mcp';
 
 /**
@@ -234,8 +234,7 @@ function addSessionStartHookAt(settingsFile: string, includeClearRewake = false)
   return true;
 }
 
-// gh#client#18: match bare names (old configs), stale absolute paths (other
-// installations), shell-escaped canonical paths, and unescaped canonical paths.
+// Match stable bare names plus legacy install-specific absolute forms.
 function commandMatches(entryCommand: string, bareName: string, absolutePath: string): boolean {
   const escaped = shellEscape(absolutePath);
   if (entryCommand === escaped || entryCommand === absolutePath || entryCommand === bareName) return true;
@@ -254,7 +253,7 @@ function commandMatches(entryCommand: string, bareName: string, absolutePath: st
  *      absolute command — always owned, no marker required (fixes neutral-path
  *      false negatives that broke idempotency)
  *  (c) Foreign-install heuristic: absolute path ending in an owned basename
- *      AND containing a borg package marker (borgmcp|borg-mcp) in the path
+ *      immediately below an exact borgmcp|borg-mcp/dist package path
  *  This prevents false-positive ownership of unrelated scripts that happen
  *  to share a basename (e.g. /opt/custom-tool/regen.js). */
 function ownedCanonical(command: string): string | null {
@@ -273,9 +272,16 @@ function ownedCanonical(command: string): string | null {
   if (command === AUDIT_HOOK_COMMAND || stripped === resolveLogAuditPath()) return AUDIT_HOOK_COMMAND;
   if (command === FOREIGN_PATH_REMINDER_HOOK_COMMAND || stripped === resolveForeignPathReminderPath()) return FOREIGN_PATH_REMINDER_HOOK_COMMAND;
 
-  // (c) Foreign-install heuristic: absolute path + owned basename + borg marker
-  if (stripped.startsWith('/') && (stripped.includes('borgmcp') || stripped.includes('borg-mcp'))) {
-    const name = stripped.split('/').pop() ?? '';
+  // (c) Foreign-install heuristic: require exact path segments shaped like a
+  // package root. A substring such as /opt/borgmcp-tools/ is not ownership.
+  const segments = stripped.split('/');
+  const packageIndex = segments.length - 3;
+  const packageShaped = packageIndex >= 0 &&
+    (segments[packageIndex] === 'borgmcp' || segments[packageIndex] === 'borg-mcp') &&
+    segments[packageIndex + 1] === 'dist' &&
+    packageIndex + 2 === segments.length - 1;
+  if (stripped.startsWith('/') && packageShaped) {
+    const name = segments.at(-1) ?? '';
     if (name === 'regen.js') return HOOK_COMMAND;
     if (name === 'clear-rewake.js') return CLEAR_REWAKE_HOOK_COMMAND;
     if (name === 'log-audit.js') return AUDIT_HOOK_COMMAND;
@@ -311,6 +317,7 @@ function migrateAndDedupOwnedHooks(entries: any[]): boolean {
   // object across all entries. Remove only the duplicate hook objects, not
   // entire entries (preserving unrelated siblings and entry metadata).
   const seenCanonicals = new Set<string>();
+  const emptiedByOwnedDedup = new Set<any>();
   for (const entry of entries) {
     if (!Array.isArray(entry?.hooks)) continue;
     const before = entry.hooks.length;
@@ -326,11 +333,13 @@ function migrateAndDedupOwnedHooks(entries: any[]): boolean {
       return true;
     });
     if (entry.hooks.length !== before) changed = true;
+    if (before > 0 && entry.hooks.length === 0) emptiedByOwnedDedup.add(entry);
   }
 
-  // Phase 3: Remove entries that became empty after dedup
+  // Phase 3: remove only entries emptied by removal of duplicate Borg-owned
+  // hooks. Pre-existing empty or unusual operator entries remain byte-stable.
   for (let i = entries.length - 1; i >= 0; i--) {
-    if (!Array.isArray(entries[i]?.hooks) || entries[i].hooks.length === 0) {
+    if (emptiedByOwnedDedup.has(entries[i])) {
       entries.splice(i, 1);
       changed = true;
     }
@@ -339,9 +348,165 @@ function migrateAndDedupOwnedHooks(entries: any[]): boolean {
   return changed;
 }
 
-/** Strict canonical match: only the shell-escaped canonical form.
- *  gh#client#18: raw unescaped paths are NOT canonical — a path with spaces
- *  or metacharacters would break at shell-fire time if not escaped. */
+export interface RefreshManagedAgentHookConfigOptions {
+  homeDir?: string;
+}
+
+export interface ManagedAgentHookConfigHealth {
+  path: string;
+  status: 'absent' | 'ok' | 'stale' | 'invalid';
+  detail?: string;
+}
+
+function globalManagedAgentHookConfigPaths(homeDir: string): string[] {
+  return [
+    path.join(homeDir, '.claude', 'settings.json'),
+    path.join(homeDir, '.codex', 'hooks.json'),
+  ];
+}
+
+function realDirectory(pathname: string): boolean {
+  try {
+    const stat = fs.lstatSync(pathname);
+    return stat.isDirectory() && !stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Enumerate only Borg's canonical two-level managed-worktree layout. Every
+ * traversed component must be a real directory; symlinks are never followed.
+ */
+export function managedAgentHookConfigPaths(homeDir: string = CONFIG_HOME): string[] {
+  const paths = globalManagedAgentHookConfigPaths(homeDir);
+  const borgDir = path.join(homeDir, '.borg');
+  if (!realDirectory(borgDir)) return paths;
+  const root = path.join(borgDir, 'worktrees');
+  if (!realDirectory(root)) return paths;
+
+  for (const repo of fs.readdirSync(root, { withFileTypes: true })) {
+    const repoPath = path.join(root, repo.name);
+    if (!repo.isDirectory() || !realDirectory(repoPath)) continue;
+    for (const worktree of fs.readdirSync(repoPath, { withFileTypes: true })) {
+      const worktreePath = path.join(repoPath, worktree.name);
+      if (!worktree.isDirectory() || !realDirectory(worktreePath)) continue;
+      const claudeDir = path.join(worktreePath, '.claude');
+      if (!realDirectory(claudeDir)) continue;
+      const settingsFile = path.join(claudeDir, 'settings.local.json');
+      try {
+        if (fs.lstatSync(settingsFile).isSymbolicLink()) continue;
+      } catch {
+        // No settings file in this canonical worktree; nothing to inventory.
+        continue;
+      }
+      paths.push(settingsFile);
+    }
+  }
+  return paths;
+}
+
+function refreshHookFile(configPath: string): boolean {
+  if (!fs.existsSync(configPath)) return false;
+  const config = readJsonFile(configPath);
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error('top-level value is not an object');
+  }
+  const hooks = config.hooks;
+  if (hooks === undefined) return false;
+  if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) {
+    throw new Error('hooks is not an object');
+  }
+  let changed = false;
+  for (const entries of Object.values(hooks)) {
+    if (!Array.isArray(entries)) continue;
+    changed = migrateAndDedupOwnedHooks(entries) || changed;
+  }
+  if (changed) writeJsonFile(configPath, config);
+  return changed;
+}
+
+/**
+ * Heal stale Borg-owned hook commands in global agent files and canonical
+ * managed worktrees. Non-Borg hooks and noncanonical worktree roots are left
+ * untouched. Later files are still attempted when one file is invalid.
+ */
+export function refreshManagedAgentHookConfigs(
+  options: RefreshManagedAgentHookConfigOptions = {},
+): string[] {
+  const homeDir = options.homeDir ?? CONFIG_HOME;
+  const refreshed: string[] = [];
+  const failures: string[] = [];
+  let configPaths = globalManagedAgentHookConfigPaths(homeDir);
+  try {
+    configPaths = managedAgentHookConfigPaths(homeDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    failures.push(`hook inventory ${path.join(homeDir, '.borg', 'worktrees')}: ${message}`);
+  }
+  for (const configPath of configPaths) {
+    try {
+      if (refreshHookFile(configPath)) refreshed.push(configPath);
+    } catch (error) {
+      const label = configPath.endsWith(path.join('.codex', 'hooks.json'))
+        ? 'Codex'
+        : 'Claude Code';
+      const message = error instanceof Error ? error.message : String(error);
+      failures.push(`${label} ${configPath}: ${message}`);
+    }
+  }
+  if (failures.length > 0) {
+    throw new Error(`Could not refresh managed agent hooks: ${failures.join('; ')}`);
+  }
+  return refreshed;
+}
+
+/** Read-only mirror of the updater's stale-command predicate. */
+export function inspectManagedAgentHookConfigs(
+  homeDir: string = CONFIG_HOME,
+): ManagedAgentHookConfigHealth[] {
+  let configPaths = globalManagedAgentHookConfigPaths(homeDir);
+  let inventoryIssue: ManagedAgentHookConfigHealth | null = null;
+  try {
+    configPaths = managedAgentHookConfigPaths(homeDir);
+  } catch (error) {
+    inventoryIssue = {
+      path: path.join(homeDir, '.borg', 'worktrees'),
+      status: 'invalid',
+      detail: `inventory failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+  const health = configPaths.map((configPath): ManagedAgentHookConfigHealth => {
+    if (!fs.existsSync(configPath)) return { path: configPath, status: 'absent' };
+    try {
+      const config = readJsonFile(configPath);
+      if (!config || typeof config !== 'object' || Array.isArray(config)) {
+        return { path: configPath, status: 'invalid', detail: 'top-level value is not an object' };
+      }
+      if (config.hooks === undefined) return { path: configPath, status: 'ok' };
+      if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) {
+        return { path: configPath, status: 'invalid', detail: 'hooks is not an object' };
+      }
+      const copy = structuredClone(config.hooks);
+      let stale = false;
+      for (const entries of Object.values(copy)) {
+        if (Array.isArray(entries)) stale = migrateAndDedupOwnedHooks(entries) || stale;
+      }
+      return { path: configPath, status: stale ? 'stale' : 'ok' };
+    } catch (error) {
+      return {
+        path: configPath,
+        status: 'invalid',
+        detail: error instanceof Error ? error.message : String(error),
+      };
+    }
+  });
+  if (inventoryIssue) health.push(inventoryIssue);
+  return health;
+}
+
+/** Strict canonical match. Quoted bare and legacy path forms are owned but
+ * require migration before they count as the one current command form. */
 function isCanonicalCommand(entryCommand: string, canonical: string): boolean {
   return entryCommand === canonical;
 }
@@ -368,7 +533,7 @@ function hasCommandHook(entries: any[], command: string): boolean {
   );
 }
 
-/** Strict: only the shell-escaped canonical form (no bare-name fallback). */
+/** Strict: only the current unquoted bare canonical form. */
 function hasCanonicalCommandHook(entries: any[], command: string): boolean {
   return entries.some((entry: any) =>
     Array.isArray(entry?.hooks) &&
@@ -1002,7 +1167,7 @@ export function isCodexUserPromptSubmitHookRegistered(hooksPath: string = CODEX_
  * `type: "local"`. Safe-default: any read error returns `false`.
  */
 export function isOpenCodeMcpServerConfigured(
-  configPath: string = OPENCODE_CONFIG_PATH
+  configPath: string = path.join(borgHomeRoot(), '.config', 'opencode', 'opencode.json')
 ): boolean {
   try {
     if (!fs.existsSync(configPath)) return false;

package/src/index.ts

@@ -73,7 +73,7 @@ import {
   pinMcpSeatIdentity,
 } from './cubes.js';
 import { isEntryInvocation, monitorStateRootForWorktree } from './inbox-monitor.js';
-import { addSessionStartHook, addUserPromptSubmitHook } from './config-utils.js';
+import { addUserPromptSubmitHook } from './config-utils.js';
 import {
   humanAgo,
   formatLogEntryMarkdown,
@@ -282,12 +282,6 @@ export async function main() {
   const readinessProbe = isMcpReadinessProbe();
   const openCodeRuntime = resolveSessionAgentKind() === 'opencode';
   const startupServices = {
-    // Auto-register the SessionStart hook so existing users get borg-regen
-    // auto-orientation on session start without re-running borg setup. Idempotent.
-    sessionStartHook: () => {
-      addSessionStartHook();
-    },
-
     // Auto-register the UserPromptSubmit audit hook so the drone gets a
     // nudge if the previous assistant span used state-changing tools
     // without calling borg_log. Domain-agnostic — knows nothing about git

package/src/log-audit-core.ts

@@ -0,0 +1,81 @@
+export const LOG_AUDIT_NUDGE = (count: number): string =>
+  `Heads up: ${count}+ state-changing tool calls since the last \`borg_log\` post. ` +
+  'If that work was a substantive unit (a change that ships, a blocker hit, a finding ' +
+  "worth sharing), post to the cube log per your role's conventions before continuing.";
+
+/**
+ * Pure transcript scan shared by the Claude hook and the OpenCode plugin.
+ * Accepts both Claude JSONL entries and OpenCode SDK message records.
+ */
+export function evaluateLogAudit(
+  entries: readonly any[],
+  renderNudge: (count: number) => string = (count) =>
+    `Heads up: ${count}+ state-changing tool calls since the last \`borg_log\` post. ` +
+    'If that work was a substantive unit (a change that ships, a blocker hit, a finding ' +
+    "worth sharing), post to the cube log per your role's conventions before continuing.",
+): string | null {
+  const materialTools = new Set([
+    'Edit', 'Write', 'MultiEdit', 'NotebookEdit', 'Bash',
+    'edit', 'write', 'bash', 'apply_patch', 'exec_command',
+    'functions.exec_command', 'functions.apply_patch',
+  ]);
+  const logTools = new Set(['mcp__borg__borg_log', 'borg_borg_log']);
+  const threshold = 3;
+  const maxScan = 400;
+
+  const role = (entry: any): unknown =>
+    entry?.type ?? entry?.role ?? entry?.info?.role;
+  const parts = (entry: any): any[] => {
+    const value = entry?.message?.content ?? entry?.content ?? entry?.parts ?? [];
+    return Array.isArray(value) ? value : [];
+  };
+  const isUserPrompt = (entry: any): boolean => {
+    if (role(entry) !== 'user') return false;
+    const content = entry?.message?.content ?? entry?.content ?? entry?.parts;
+    if (typeof content === 'string') return content.trim().length > 0;
+    return Array.isArray(content) && content.some((part) =>
+      part?.type === 'text' && typeof part.text === 'string' && part.text.trim().length > 0,
+    );
+  };
+  const isAssistant = (entry: any): boolean => {
+    const value = role(entry);
+    return value === 'assistant' || value === 'response_item';
+  };
+  const toolName = (part: any): string | null => {
+    if (part?.type === 'tool_use' && typeof part.name === 'string') return part.name;
+    if ((part?.type === 'tool' || part?.type === 'tool_call') && typeof part.tool === 'string') {
+      return part.tool;
+    }
+    return null;
+  };
+
+  let index = entries.length - 1;
+  if (index >= 0 && isUserPrompt(entries[index])) index--;
+  let material = 0;
+  let scanned = 0;
+  for (; index >= 0 && scanned < maxScan; index--, scanned++) {
+    const entry = entries[index];
+    if (!isAssistant(entry)) continue;
+
+    const payload = entry?.payload;
+    const payloadTool =
+      payload?.type === 'function_call' || payload?.type === 'custom_tool_call'
+        ? payload.name
+        : null;
+    if (typeof payloadTool === 'string') {
+      if (logTools.has(payloadTool)) return material >= threshold ? renderNudge(material) : null;
+      if (materialTools.has(payloadTool)) material++;
+      if (material >= threshold) return renderNudge(material);
+    }
+
+    const content = parts(entry);
+    for (let partIndex = content.length - 1; partIndex >= 0; partIndex--) {
+      const name = toolName(content[partIndex]);
+      if (!name) continue;
+      if (logTools.has(name)) return material >= threshold ? renderNudge(material) : null;
+      if (materialTools.has(name)) material++;
+      if (material >= threshold) return renderNudge(material);
+    }
+  }
+  return null;
+}

package/src/log-audit.ts

@@ -16,9 +16,9 @@
  *      gets a turn of breathing room after each post.
  *
  * Stays generic — knows nothing about git, branches, or any project's
- * conventions. Only the Anthropic tool name `mcp__borg__borg_log` and a
- * small set of canonical mutating tool names. If no cube is active in
- * this project, silently exits.
+ * conventions. Its pure scan core recognizes the Borg log tool names used by
+ * Claude/Codex and OpenCode plus a small set of canonical mutating tool names.
+ * If no cube is active in this project, silently exits.
  *
  * Hook input arrives as JSON on stdin (Claude Code's standard hook
  * contract). The relevant field is `transcript_path`.
@@ -28,92 +28,13 @@ import { existsSync, readFileSync } from 'node:fs';
 import { getActiveCube } from './cubes.js';
 import { handleVersionFlag } from './version.js';
 import { gateAllowsActivation } from './launch-gate.js';
-
-const MATERIAL_TOOLS = new Set([
-  'Edit',
-  'Write',
-  'MultiEdit',
-  'NotebookEdit',
-  'Bash',
-  'apply_patch',
-  'exec_command',
-  'functions.exec_command',
-  'functions.apply_patch',
-]);
-
-const LOG_TOOL = 'mcp__borg__borg_log';
-
-// Number of state-changing tool calls since the last borg_log that the
-// drone is allowed before the audit nudges. 1 false-positives on
-// diagnostic Bash (git status, ls, etc.); 3 has been comfortable in
-// dogfooding — any substantive work crosses it within a turn or two.
-const MATERIAL_THRESHOLD = 3;
-
-// Cap on how many transcript entries we scan backwards before giving up.
-// Sessions with thousands of turns still resolve in milliseconds at this
-// bound, and anything truly old is no longer "the last span the drone
-// failed to log."
-const MAX_SCAN = 400;
+import { evaluateLogAudit } from './log-audit-core.js';
 
 interface HookInput {
   transcript_path?: string;
   cwd?: string;
 }
 
-function isUserPrompt(entry: any): boolean {
-  const type = entry?.type ?? entry?.role;
-  if (type !== 'user') return false;
-  const content = entry?.message?.content ?? entry?.content;
-  if (typeof content === 'string') return content.trim().length > 0;
-  if (!Array.isArray(content)) return false;
-  // A "real" user prompt has at least one text block. A tool_result-only
-  // user message is a continuation of an assistant span, not a prompt.
-  return content.some((b: any) => b?.type === 'text');
-}
-
-function isAssistant(entry: any): boolean {
-  const type = entry?.type ?? entry?.role;
-  return type === 'assistant' || type === 'response_item';
-}
-
-type ScanFinding =
-  | { kind: 'cooldown' } // hit a borg_log before threshold — suppress
-  | { kind: 'over_threshold'; count: number } // accumulated >= threshold
-  | { kind: 'under_threshold'; count: number }; // ran out of transcript
-
-function scanAssistant(entry: any, state: { material: number; loggedRecently: boolean }): void {
-  const payload = entry?.payload;
-  const payloadToolName =
-    payload?.type === 'function_call' || payload?.type === 'custom_tool_call'
-      ? payload.name
-      : null;
-  if (typeof payloadToolName === 'string') {
-    if (payloadToolName === LOG_TOOL) {
-      state.loggedRecently = true;
-      return;
-    }
-    if (MATERIAL_TOOLS.has(payloadToolName)) state.material += 1;
-  }
-
-  const content = entry?.message?.content ?? entry?.content ?? [];
-  if (!Array.isArray(content)) return;
-  // Walk the blocks newest-first WITHIN the entry. The caller already
-  // visits entries newest-first. Counting forward within an entry would
-  // either miss post-log material work (if log is in the same entry as
-  // later material blocks) or inflate the count with pre-log work that
-  // the log already covered. Reversing here keeps "material since the
-  // last log" honest at block granularity.
-  for (let i = content.length - 1; i >= 0; i--) {
-    const block = content[i];
-    if (block?.type !== 'tool_use') continue;
-    if (block.name === LOG_TOOL) {
-      state.loggedRecently = true;
-      return;
-    }
-    if (MATERIAL_TOOLS.has(block.name)) state.material += 1;
-  }
-}
-
 async function readStdin(): Promise<string> {
   if (process.stdin.isTTY) return '';
   const chunks: Buffer[] = [];
@@ -158,40 +79,8 @@ async function main(): Promise<void> {
   const lines = readFileSync(input.transcript_path, 'utf-8').split('\n').filter(Boolean);
   if (lines.length === 0) return;
 
-  // Walk the transcript backwards from the end. The trailing entry MAY
-  // be the user prompt that triggered this hook; skip it if so. From
-  // there, accumulate material tool calls until either we hit a borg_log
-  // (cooldown — suppress) or we cross MATERIAL_THRESHOLD (nudge). The
-  // scan stops after MAX_SCAN entries to bound work on huge sessions.
-  let i = lines.length - 1;
-  const tail = safeParse(lines[i]);
-  if (tail && isUserPrompt(tail)) i--;
-
-  const state = { material: 0, loggedRecently: false };
-  let scanned = 0;
-  for (; i >= 0 && scanned < MAX_SCAN; i--, scanned++) {
-    const entry = safeParse(lines[i]);
-    if (!entry) continue;
-    if (isAssistant(entry)) {
-      scanAssistant(entry, state);
-      // Threshold has primacy over cooldown: when both could fire on the
-      // same entry (e.g. an entry containing [log, Bash, Bash, Bash]
-      // where the reversed scan first counts 3 material blocks before
-      // hitting the log), we want the nudge — the post-log material
-      // work hasn't been logged yet.
-      if (state.material >= MATERIAL_THRESHOLD) {
-        process.stdout.write(
-          `Heads up: ${state.material}+ state-changing tool calls since the last \`borg_log\` post. ` +
-          'If that work was a substantive unit (a change that ships, a blocker hit, a finding ' +
-          "worth sharing), post to the cube log per your role's conventions before continuing.\n"
-        );
-        return;
-      }
-      if (state.loggedRecently) return; // cooldown
-    }
-  }
-  // Reached MAX_SCAN or start of transcript without finding either a
-  // log call or enough material work. Silent.
+  const nudge = evaluateLogAudit(lines.map(safeParse).filter((entry) => entry !== null));
+  if (nudge) process.stdout.write(`${nudge}\n`);
 }
 
 function safeParse(line: string): any | null {

package/src/opencode-drone.ts

@@ -3,6 +3,7 @@ import { createHash, randomUUID } from 'crypto';
 import { createServer } from 'node:net';
 import { join } from 'path';
 import { tmpdir } from 'os';
+import { OPENCODE_INJECTED_ENTRY_METADATA_KEY } from './opencode-plugin.js';
 
 const LOG_FILE = join(tmpdir(), 'borg-opencode-drone.log');
 function log(msg: string) {
@@ -511,7 +512,11 @@ async function deliverOpenCodeEntry(
     let status: number | null = null;
     try {
       status = await promptSession(target.id, {
-        parts: [{ type: 'text', text: delivery.text }],
+        parts: [{
+          type: 'text',
+          text: delivery.text,
+          metadata: { [OPENCODE_INJECTED_ENTRY_METADATA_KEY]: true },
+        }],
       });
     } catch (err) {
       log(`entry ${delivery.entryId} submission outcome unavailable: ${err}`);