elanous 0.2.35 → 0.2.36

package/src/llm.ts

@@ -2,6 +2,7 @@
 // Unified streaming interface for Grok (xAI), OpenAI, Anthropic, Local (OpenAI-compatible).
 // Auto-routes based on model name prefix, or picks the first available provider.
 
+import { wellFormedLLMMessages } from './llm-wellformed.js';
 import { createHash } from 'node:crypto';
 import { testFakeLlmEnabled, testFakeLlmProvider } from './ux-sim/fake-llm.js';
 import { realpathSync } from 'node:fs';
@@ -4460,6 +4461,12 @@ function providerByName(name: string): LLMProvider | undefined {
   return PROVIDERS[name] ?? automaticProviderCandidates().find((candidate) => candidate.name === name);
 }
 
+/** TUI-400-AUTOHEAL-FALLBACK — 같은 턴에서 `failedProviders` 가 실패했을 때 `llm.fallbackChain`(⊕ auto 후보)의
+ *  «다음» 공급자. 턴 안 폴백과 같은 해석(`explainFallbackCandidates`)을 그대로 쓴다 — 체인을 따로 읽지 않는다. */
+export function nextTurnFallbackProvider(failedProviders: readonly string[]): LLMProvider | undefined {
+  return firstAvailableFallbackProvider(new Set(failedProviders), {});
+}
+
 function firstAvailableFallbackProvider(attempted: ReadonlySet<string>, opts: LLMOpts): LLMProvider | undefined {
   // A candidate may lose its credential between chain enumeration and the
   // switch. Keep scanning the ordered chain instead of stopping at that slot.
@@ -4745,6 +4752,11 @@ async function consumeProviderText(
   let full = '';
   let usage: ObservedUsage | undefined;
   try {
+    const wf = wellFormedLLMMessages(messages);
+    if (wf.fixedMessages > 0) {
+      debug.log('llm.request', 'lone-surrogate-fixed', { site: 'streamLLM', provider: provider.name, messages: wf.fixedMessages, strings: wf.fixedStrings }, { level: 'warn' });
+      messages = wf.messages;
+    }
     iterator = (provider.streamChat
       ? provider.streamChat(messages, opts)
       : provider.chat(messages, opts))[Symbol.asyncIterator]();
@@ -5863,7 +5875,7 @@ const TOOL_LOOP_PHASE_DIRECTIVES: Record<ToolLoopFollowupPhase, (autoNarrowedRea
     + 'Stop gathering more files and run the code, tests, or repro command first via RunShell/Bash, or answer in plain text if execution is unnecessary.',
   'repair-action': () =>
     'REPAIR ACTION REQUIRED — execution has already failed or a debugging repair step is armed. '
-    + 'Stop gathering more files and move to Edit/Write/RunShell/Bash or a narrow code-intel followup (Read/Lsp/AstGrep/Grep content/count), '
+    + 'Stop gathering more files and move to Edit/Write/RunShell/Bash or a narrow code-intel followup (Read/ListDir/Lsp/AstGrep/Grep content/count), '
     + 'ops ledger/delegate tools (MsgList/MsgPost/MsgAck/Checklist*/AgentOutput) still run, '
     + 'or answer in plain text if no code change is needed (e.g. a read-only investigation whose finding is the deliverable).',
   'verify-action': () =>
@@ -7800,6 +7812,10 @@ const REPAIR_ACTION_TOOLS = new Set([
   'Plan',
   'MarkStepDone',
   'Read',
+  // ListDir is always one directory, never recursive — as narrow as Read. A failed step
+  // is often «is the output there?»; rejecting it pushed the model to `ls` via shell
+  // (n8n session 10-22: ListDir show_hidden=true ×2 rejected after a benign exit 128).
+  'ListDir',
   'Lsp',
   'AstGrep',
   'ast_grep_search',
@@ -8229,14 +8245,19 @@ export async function streamLLMWithTools(
   messages: LLMMessage[],
   handlers: StreamWithToolsHandlers,
   opts: LLMOpts & { provider?: LLMProvider; missionContext?: { missionId: string; phaseId: string; onOverload?: (info: { turn: number; consecutiveFailures: number; reason: string }) => void; pollSignal?: () => { kind: 'abort' | 'pause'; reason?: string } | undefined }; contextStrategy?: import('./agent-substrate/context-strategy.js').ContextStrategy;
+    /** TUI-400-AUTOHEAL-FALLBACK — 이 턴을 «이 공급자부터» 연다(`provider` 와 달리 폴백은 그대로 허용).
+     *  모델은 그 공급자의 기본 모델(앞 공급자 모델 이름은 안 옮긴다 — 호출부가 `model` 을 비운다). */
+    initialProvider?: LLMProvider;
+    /** 이 턴 폴백 후보에서 뺄 공급자(이미 같은 턴에서 실패한 쪽 — 되돌아가지 않게). */
+    skipProviders?: readonly string[];
   } = {},
 ): Promise<string> {
-  const provider = opts.provider ?? resolveDefaultProvider(opts.model);
+  const provider = opts.provider ?? opts.initialProvider ?? resolveDefaultProvider(opts.model);
   const initial = finalizeStreamingProviderModel(provider, opts.model ?? provider.defaultModel);
   let activeProvider = initial.provider;
   let activeModel = initial.model;
   opts.onResolvedProvider?.(activeProvider.name, activeModel);
-  const attemptedProviders = new Set<string>([activeProvider.name]);
+  const attemptedProviders = new Set<string>([activeProvider.name, ...(opts.skipProviders ?? [])]);
   let blockedProviders: ProviderFallbackAttempt[] = [];
   const effectiveModel = activeModel;
   const modelFamily = getModelFamily(effectiveModel);
@@ -8794,6 +8815,12 @@ export async function streamLLMWithTools(
           activeModel = finalized.model;
           opts.onResolvedProvider?.(activeProvider.name, activeModel);
           turnOpts = { ...turnOpts, model: activeModel };
+          // 짝 없는 서로게이트(잘린 이모지)가 섞이면 공급자가 본문 JSON 을 못 읽는다(10-22 n8n 매 턴 400) — 이력 자체를 고친다(다음 요청에 다시 안 실리게).
+          const wf = wellFormedLLMMessages(history);
+          if (wf.fixedMessages > 0) {
+            debug.log('llm.request', 'lone-surrogate-fixed', { site: 'tool-loop', provider: activeProvider.name, messages: wf.fixedMessages, strings: wf.fixedStrings }, { level: 'warn' });
+            history.splice(0, history.length, ...wf.messages);
+          }
           streamIter = activeProvider.streamChat!(history, turnOpts)[Symbol.asyncIterator]();
         }
         step = await Promise.race([
@@ -11985,7 +12012,11 @@ export function anyProviderAvailable(userConfig?: UserConfig): boolean {
       } catch { return false; }
     }
   } catch { /* fall through to env check */ }
-  return Object.values(PROVIDERS).some(p => p.name !== 'bedrock' && p.name !== 'opengateway' && p.available()); // 명시 전용 공급자는 auto 가용성 아님
+  if (Object.values(PROVIDERS).some(p => p.name !== 'bedrock' && p.name !== 'opengateway' && p.available())) return true; // 명시 전용 공급자는 auto 가용성 아님
+  // 시험 fake 를 «공급자 있음» 으로 치는 것은 격리 라이브 TUI 무대가 명시로 켤 때만(ELANOUS_TEST_FAKE_LLM_AS_PROVIDER=1).
+  //   ⛔ gate 시험 env 는 ELANOUS_TEST_FAKE_LLM=1 을 «전역» 으로 켠다(scripts/lib/gate-test-env.ts) — 그 스위치만으로 가용성이
+  //   참이 되면 «아무것도 없으면 false» 계약과 가용성으로 갈리는 기능(dart·dig-engine 등)이 gate 에서 모두 바뀐다(열차 #30208 introduced 2).
+  return process.env.ELANOUS_TEST_FAKE_LLM_AS_PROVIDER === '1' && testFakeLlmEnabled();
 }
 
 /** 직결 배선이 없는 계열 → OpenRouter 에서 그 벤더의 대표 모델(사다리 `openrouter` 에 선 것). */

package/src/loops/msg-wake.ts

@@ -5,7 +5,8 @@
 //   sse        — 아무것도 안 한다(구독자가 이미 듣는다)
 //   cron       — 다음 틱에 읽는다 · `wake-deferred` 로그만
 //   pty-inject — elanous TUI(pty 별명 = 자리 소문자)가 턴 idle 일 때만 한 줄 주입
-//   herdr      — 자리 폴더 `herdr.pane` 의 pane 이 agent_status=idle 일 때만 한 줄 주입
+//   herdr      — 자리 폴더 `herdr.pane` 의 pane 이 idle(·done) 일 때만 한 줄 주입 — `eln herdr prompt` 와 같은 생산 함수
+//                (`herdrPrompt` · `agent get` 상태 확인 → bracketed `pane run` 한 번). working/blocked 는 넣지 않고 busy.
 //   none       — stderr 경고 한 줄 · 해석 실패는 «모름»으로 남긴다(«없다»로 위장 금지)
 // ⛔ 우편은 입력칸에 넣지 않는다(대표 10-15 01:20) — 기본은 입력칸 주입 0. 10-15 01:10 사고: 대표 가 치던 문장에
 //    깨움 한 줄 ⊕ Enter 가 섞여 제출됐다(«에이전트 idle ≠ 사람이 안 친다»). 자리 폴더에서 푼 대상(pty 별명·
@@ -20,7 +21,6 @@
 //    상한(시도 3 · 2시간) → `gave-up`. 관측 = `loops.msg-wake` deferred | redelivered | gave-up.
 //    재두드림 «전»에 그 주소 미읽음을 잰다 — 0 이면 두드리지 않고 줄을 지운다(`dropped-read` · H4-FOLLOW ③).
 
-import { spawn } from 'node:child_process';
 import { Database } from 'bun:sqlite';
 import { randomUUID } from 'node:crypto';
 import { existsSync, lstatSync, mkdirSync, readFileSync } from 'node:fs';
@@ -30,6 +30,7 @@ import { dirname, join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 import { readUnreadCount } from '../msg/msg-store.js';
+import { herdrPrompt, type HerdrCliRunner } from '../pty-shell/herdr-prompt.js';
 import { listPtyManifestRows } from '../pty-shell/pty-manifest.js';
 import { messageRouteFor, type MessageWake } from './msg-address.js';
 
@@ -75,8 +76,8 @@ export interface WakeDeps {
   hasOptIn?: (path: string) => boolean;
   /** Loads the pty writer (the CLI module is heavy, so it is imported only when a pty wake is due). */
   ptyInjector?: () => Promise<(ptyId: string, line: string) => Promise<void>>;
-  herdrStatus?: (paneId: string, signal: AbortSignal) => Promise<string>;
-  herdrInject?: (paneId: string, line: string, signal: AbortSignal) => Promise<void>;
+  /** The herdr CLI runner `herdrPrompt` drives (`agent get` · `pane run`). Default: the real `herdr` (HERDR_BIN_PATH · PATH). */
+  herdrRun?: HerdrCliRunner;
   warn?: (line: string) => void;
   /** Unread count for an address before a deferred re-knock (H4-FOLLOW ③). null = «모름» (never drops). Default: the msg ledger. */
   readUnread?: (address: string) => number | null;
@@ -178,29 +179,6 @@ function releaseClaim(claim: WakeClaim): void {
   } catch { /* a stale claim only delays the next wake by one window */ }
 }
 
-function run(cmd: string, args: string[], timeoutMs: number, signal: AbortSignal): Promise<string> {
-  return new Promise((resolve, reject) => {
-    if (signal.aborted) { reject(new Error(`${cmd} aborted`)); return; }
-    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], signal });
-    let out = '';
-    const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error(`${cmd} timeout`)); }, timeoutMs);
-    child.stdout.on('data', chunk => { out += String(chunk); });
-    child.on('error', error => { clearTimeout(timer); reject(error); });
-    child.on('close', code => { clearTimeout(timer); code === 0 ? resolve(out) : reject(new Error(`${cmd} exit ${code}`)); });
-  });
-}
-
-async function defaultHerdrStatus(paneId: string, signal: AbortSignal): Promise<string> {
-  const parsed = JSON.parse(await run('herdr', ['pane', 'get', paneId], WAKE_TIMEOUT_MS, signal)) as { result?: { pane?: { agent_status?: unknown } } };
-  const status = parsed.result?.pane?.agent_status;
-  return typeof status === 'string' ? status : 'unknown';
-}
-
-async function defaultHerdrInject(paneId: string, line: string, signal: AbortSignal): Promise<void> {
-  // `pane run` = send-text ⊕ Enter 한 번에.
-  await run('herdr', ['pane', 'run', paneId, line], WAKE_TIMEOUT_MS, signal);
-}
-
 async function defaultPtyInjector(): Promise<(ptyId: string, line: string) => Promise<void>> {
   const { runPtyText } = await import('../cli/pty-takeover-cli.js');
   return async (ptyId, line) => {
@@ -261,17 +239,35 @@ export async function wakeRecipient(address: string, msgId: number, message: { f
         injecting = true;
         await inject(resolution.target!, line);
       } else {
-        const status = await (deps.herdrStatus ?? defaultHerdrStatus)(resolution.target!, controller.signal);
-        if (status !== 'idle') return done('busy', `agent_status=${status}`);
-        // 조회 사이 자리의 pane 이 바뀌었으면 옛 pane 에 넣지 않는다 — 주소→대상을 다시 푼다.
-        const again = resolveWake(address, deps);
-        // opt-in 은 주입 직전에 «먼저» 다시 본다 — 기다리는 사이 `wake-inject` 를 지웠으면(대상이 바뀌었어도) 주입 0.
-        if (!seatOptedIn(address, deps)) { resolution = { ...resolution, optIn: false }; return done('skipped', 'human-pane-no-opt-in'); }
-        if (again.wake !== 'herdr' || again.target !== resolution.target) return done('busy', `target-moved:${again.target ?? again.wake}`);
-        // ⛔ 마감은 «주입 바로 앞»에서 — 재해석이 늦어 넘겼어도 새 주입 0.
-        if (expired()) return done('timeout');
-        injecting = true;
-        await (deps.herdrInject ?? defaultHerdrInject)(resolution.target!, line, controller.signal);
+        // `eln herdr prompt` 와 같은 생산 함수 — 상태 확인(idle·done 만) → 제출 앞 관문 → bracketed `pane run` 한 번.
+        // 라벨은 묻지 않는다(anyAgent): 자리 폴더가 이미 대상을 정했고, claude/codex pane 도 예전처럼 깨운다.
+        const target = resolution.target!;
+        const prompted = await herdrPrompt({ target, text: line, anyAgent: true, paneFallback: true, timeoutMs: Math.max(1, deadline - Date.now()) }, {
+          ...(deps.herdrRun ? { run: deps.herdrRun } : {}),
+          beforeSubmit: () => {
+            // opt-in 은 주입 직전에 «먼저» 다시 본다 — 기다리는 사이 `wake-inject` 를 지웠으면(대상이 바뀌었어도) 주입 0.
+            if (!seatOptedIn(address, deps)) { resolution = { ...resolution, optIn: false }; return 'human-pane-no-opt-in'; }
+            // 조회 사이 자리의 pane 이 바뀌었으면 옛 pane 에 넣지 않는다 — 주소→대상을 다시 푼다.
+            const again = resolveWake(address, deps);
+            if (again.wake !== 'herdr' || again.target !== target) return `target-moved:${again.target ?? again.wake}`;
+            // ⛔ 마감은 «주입 바로 앞»에서 — 재해석이 늦어 넘겼어도 새 주입 0.
+            if (expired()) return 'timeout';
+            injecting = true;
+            return undefined;
+          },
+        });
+        if (!prompted.accepted) injecting = false;
+        const reason = prompted.reason;
+        const result: WakeResult = reason === 'submitted' ? 'injected'
+          : reason === 'human-pane-no-opt-in' ? 'skipped'
+            : reason === 'timeout' ? 'timeout'
+              : reason.startsWith('target-moved:') || reason === 'agent_working' || reason === 'agent_blocked' || reason === 'agent_unknown' ? 'busy'
+                : 'failed';
+        const outReason = result === 'busy' && !reason.startsWith('target-moved:') ? `agent_status=${prompted.status ?? 'unknown'}`
+          : result === 'injected' || result === 'timeout' ? undefined : reason;
+        logPending('herdr-prompt', { seat: address.trim().toUpperCase(), msgId, target, result, accepted: prompted.accepted, reason,
+          ...(prompted.status ? { status: prompted.status } : {}), ...(prompted.agent ? { agent: prompted.agent } : {}), ms: prompted.ms });
+        if (result !== 'injected') return done(result, outReason);
       }
       return done('injected');
     } catch (error) {
@@ -309,7 +305,7 @@ export async function wakeRecipient(address: string, msgId: number, message: { f
 
 interface PendingWakeRow { address: string; first_msg_id: number; last_msg_id: number; last_from: string; count: number; since: number; attempts: number; reason: string }
 
-export type PendingWakeEvent = 'deferred' | 'redelivered' | 'gave-up' | 'dropped-read' | 'skip';
+export type PendingWakeEvent = 'deferred' | 'redelivered' | 'gave-up' | 'dropped-read' | 'skip' | 'herdr-prompt';
 
 function logPending(event: PendingWakeEvent, data: Record<string, unknown>): void {
   try { debug.log('loops.msg-wake', event, data); } catch { /* observability is fail-open */ }

package/src/loops/orchestrator/inbox.ts

@@ -3,6 +3,7 @@ import { classifySeatTrafficProposal } from '../../seat-loop/traffic-signal.js';
 import { debug } from '../../debug/log.js';
 import { LOOP_MESSAGE_ROUTES } from '../msg-address.js';
 import { replyWithAgent, type AgentReplyInput } from '../agent-reply.js';
+import { knowhowAdvice, type KnowhowAdvice, type KnowhowOptions } from './knowhow-pack.js';
 import type { RoleLlmSpec } from '../../user-config.js';
 import type { LLMProvider } from '../../llm.js';
 
@@ -28,18 +29,59 @@ function trafficProposal(request: Message): 'hold' | 'UNHOLD' | null {
     ? null : classifySeatTrafficProposal(request.body);
 }
 
-/** This loop suggests traffic moves; it never changes traffic.json. */
-export function coordinatorReply(request: Message): string {
+export interface CoordinatorInboxOptions {
+  /** `false` disables the resident knowhow pack (traffic rule only). */
+  knowhow?: KnowhowOptions | false;
+}
+
+const NO_LOCK_LINE = '실제 잠금 변경은 수행하지 않았습니다.';
+
+function flatten(text: string, max: number): string {
+  const flat = text.replace(/\s+/g, ' ').trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+
+/** Propose a resident K item: cite the pack, the item id and the measurement it was judged by. */
+function knowhowProposal(advice: KnowhowAdvice): { proposal: string; evidence: string } {
+  const cite = `${advice.packVersion} 팩 ${advice.packHash} · ${advice.item.id} «${advice.item.title}»`;
+  const measurement = `재는 명령: \`${advice.item.command}\` → ${advice.detail}`;
+  if (advice.freshness === 'stale') {
+    return {
+      proposal: `모름 — 노하우 낡음 의심 (${advice.item.id})`,
+      evidence: `${cite} · ${measurement} — 기대와 어긋나 처방을 제안하지 않습니다. OP 가 항목을 갱신해야 합니다.`,
+    };
+  }
+  const freshness = advice.freshness === 'confirmed' ? '기대 일치'
+    : advice.freshness === 'unverifiable' ? '기대 문면 — 사람 확인' : '재지 못함 — 사람 확인';
+  return {
+    proposal: `${advice.item.id} — ${flatten(advice.item.prescription, 240)}`,
+    evidence: `${cite} · ${measurement} (${freshness}) — 제안만 하고 어떤 쓰기도 하지 않습니다.`,
+  };
+}
+
+/** This loop suggests traffic moves and quotes knowhow; it never changes traffic.json or the ledgers. */
+export function coordinatorReply(request: Message, knowhow: KnowhowOptions | false = {}): string {
   const traffic = trafficProposal(request);
-  const proposal = traffic === 'hold' ? 'hold 제안' : traffic === 'UNHOLD' ? 'UNHOLD 제안' : '모름 — OP/자리 판단 필요';
-  const evidence = traffic === 'hold' ? '자리 메시지에 «손 구현 착수»가 있습니다.'
-    : traffic === 'UNHOLD' ? '자리 메시지에 «첫 줄 확정»이 있습니다.'
-      : '착수·첫 줄 확정을 확정 진술로 확인하지 못했습니다. 칸·traffic 근거를 사람이 확인해야 합니다.';
-  return `re #${request.id}\n제안: ${proposal}\n근거: ${evidence}\n실제 잠금 변경은 수행하지 않았습니다.`;
+  if (traffic !== null) {
+    const proposal = traffic === 'hold' ? 'hold 제안' : 'UNHOLD 제안';
+    const evidence = traffic === 'hold' ? '자리 메시지에 «손 구현 착수»가 있습니다.'
+      : '자리 메시지에 «첫 줄 확정»이 있습니다.';
+    return `re #${request.id}\n제안: ${proposal}\n근거: ${evidence}\n${NO_LOCK_LINE}`;
+  }
+  const advice = knowhow === false ? null : knowhowAdvice(request.body, knowhow);
+  if (advice) {
+    const { proposal, evidence } = knowhowProposal(advice);
+    return `re #${request.id}\n제안: ${proposal}\n근거: ${evidence}\n${NO_LOCK_LINE}`;
+  }
+  const candidate = flatten(request.body, 200);
+  debug.log('loop.coordinator-knowhow', 'candidate', { requestId: request.id, from: request.from, question: candidate });
+  return `re #${request.id}\n제안: 모름 — OP/자리 판단 필요\n근거: 착수·첫 줄 확정을 확정 진술로 확인하지 못했고, `
+    + `맞는 K-OP 노하우 항목도 없습니다. 칸·traffic 근거를 사람이 확인해야 합니다.\n`
+    + `노하우 후보: ${candidate} — 새 K-OP 항목의 입력으로 쓸 수 있습니다.\n${NO_LOCK_LINE}`;
 }
 
 /** Single reply writer: prefer the durable thread link, while recognizing pre-migration body markers. */
-function writeCoordinatorReply(store: MsgStore, request: Message): { id: number; posted: boolean } {
+function writeCoordinatorReply(store: MsgStore, request: Message, replyText: string): { id: number; posted: boolean } {
   const marker = `re #${request.id}`;
   const linked = store.db.query(`SELECT id FROM msg_messages WHERE sender = ? AND recipient = ?
     AND reply_to = ? AND kind = 'reply' ORDER BY id LIMIT 1`).get(RECIPIENT, request.from, request.id) as { id: number } | null;
@@ -49,12 +91,14 @@ function writeCoordinatorReply(store: MsgStore, request: Message): { id: number;
     .get(RECIPIENT, request.from, marker, marker.length + 1, `${marker}\n`) as { id: number } | null;
   if (legacy) return { id: legacy.id, posted: false };
   const reply = store.post({ from: RECIPIENT, to: request.from,
-    body: coordinatorReply(request).slice(marker.length + 1), kind: 'reply', replyTo: request.id });
+    body: replyText.slice(marker.length + 1), kind: 'reply', replyTo: request.id });
   return { id: reply.id, posted: true };
 }
 
 /** One transaction ties a reply to its acknowledgement. A retry finds the durable receipt. */
-export function runCoordinatorInbox(inputStore?: MsgStore, limit = 100, path?: string): CoordinatorInboxResult {
+export function runCoordinatorInbox(inputStore?: MsgStore, limit = 100, path?: string,
+  options: CoordinatorInboxOptions = {}): CoordinatorInboxResult {
+  const knowhow = options.knowhow ?? {};
   const store = inputStore ?? openMsgStore(path);
   const ownStore = inputStore === undefined;
   let replied = 0;
@@ -70,10 +114,14 @@ export function runCoordinatorInbox(inputStore?: MsgStore, limit = 100, path?: s
         continue;
       }
       const key = `coord-inbox:${request.id}:${request.from}`;
+      // Measurement runs outside the write transaction: a pack command never holds the ledger lock.
+      const known = store.db.query('SELECT message_id FROM msg_provenance WHERE provenance_key = ?')
+        .get(key) as { message_id: number } | null;
+      const replyText = known ? '' : coordinatorReply(request, knowhow);
       const result = store.db.transaction(() => {
         const existing = store.db.query('SELECT message_id FROM msg_provenance WHERE provenance_key = ?')
           .get(key) as { message_id: number } | null;
-        const reply = existing ? { id: existing.message_id, posted: false } : writeCoordinatorReply(store, request);
+        const reply = existing ? { id: existing.message_id, posted: false } : writeCoordinatorReply(store, request, replyText);
         if (!existing) store.db.query('INSERT INTO msg_provenance(provenance_key, message_id) VALUES (?, ?)').run(key, reply.id);
         store.ack(RECIPIENT, request.id);
         return { posted: reply.posted };