gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

package/packages/daemon/src/index.ts

@@ -44,3 +44,12 @@ export {
   formatGenericEvent,
   formatEvent,
 } from './event-formatter.js';
+export {
+  escapeXml,
+  generatePlist,
+  getPlistPath,
+  install as installLaunchAgent,
+  uninstall as uninstallLaunchAgent,
+  status as launchAgentStatus,
+} from './launchd.js';
+export type { PlistOptions, LaunchdStatus, RunCommandFn } from './launchd.js';

package/packages/daemon/src/launchd.test.ts

@@ -0,0 +1,356 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir, homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import {
+  escapeXml,
+  generatePlist,
+  getPlistPath,
+  install,
+  uninstall,
+  status,
+} from './launchd.js';
+import type { PlistOptions, RunCommandFn, LaunchdStatus } from './launchd.js';
+
+// ---------- helpers ----------
+
+function tmpDir(): string {
+  return mkdtempSync(join(tmpdir(), `launchd-test-${randomUUID().slice(0, 8)}-`));
+}
+
+const cleanupDirs: string[] = [];
+afterEach(() => {
+  while (cleanupDirs.length) {
+    const d = cleanupDirs.pop()!;
+    if (existsSync(d)) rmSync(d, { recursive: true, force: true });
+  }
+});
+
+function basePlistOpts(overrides?: Partial<PlistOptions>): PlistOptions {
+  return {
+    nodePath: '/usr/local/bin/node',
+    scriptPath: '/usr/local/lib/gsd-daemon/dist/cli.js',
+    configPath: join(homedir(), '.gsd', 'daemon.yaml'),
+    ...overrides,
+  };
+}
+
+// ---------- escapeXml ----------
+
+describe('escapeXml', () => {
+  it('escapes & < > " \'', () => {
+    assert.equal(escapeXml('a&b<c>d"e\'f'), 'a&amp;b&lt;c&gt;d&quot;e&apos;f');
+  });
+
+  it('leaves plain strings untouched', () => {
+    assert.equal(escapeXml('/usr/local/bin/node'), '/usr/local/bin/node');
+  });
+
+  it('escapes paths with spaces and special chars', () => {
+    const input = '/Users/John & Jane/my "project"/file.js';
+    const output = escapeXml(input);
+    assert.ok(output.includes('&amp;'));
+    assert.ok(output.includes('&quot;'));
+    // Verify no raw unescaped & remain (all & are part of &amp; &lt; etc.)
+    assert.equal(output, '/Users/John &amp; Jane/my &quot;project&quot;/file.js');
+  });
+});
+
+// ---------- generatePlist ----------
+
+describe('generatePlist', () => {
+  it('produces valid XML with plist header', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.startsWith('<?xml version="1.0"'));
+    assert.ok(xml.includes('<!DOCTYPE plist'));
+    assert.ok(xml.includes('<plist version="1.0">'));
+    assert.ok(xml.includes('</plist>'));
+  });
+
+  it('includes label com.gsd.daemon', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<string>com.gsd.daemon</string>'));
+  });
+
+  it('uses the absolute node path from opts', () => {
+    const opts = basePlistOpts({ nodePath: '/home/user/.nvm/versions/node/v22.0.0/bin/node' });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('<string>/home/user/.nvm/versions/node/v22.0.0/bin/node</string>'));
+  });
+
+  it('includes NVM bin directory in PATH', () => {
+    const opts = basePlistOpts({ nodePath: '/home/user/.nvm/versions/node/v22.0.0/bin/node' });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('/home/user/.nvm/versions/node/v22.0.0/bin'));
+  });
+
+  it('sets KeepAlive with SuccessfulExit false', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>KeepAlive</key>'));
+    assert.ok(xml.includes('<key>SuccessfulExit</key>'));
+    assert.ok(xml.includes('<false/>'));
+  });
+
+  it('sets RunAtLoad true', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>RunAtLoad</key>'));
+    assert.ok(xml.includes('<true/>'));
+  });
+
+  it('includes --config with the config path', () => {
+    const configPath = '/custom/path/daemon.yaml';
+    const xml = generatePlist(basePlistOpts({ configPath }));
+    assert.ok(xml.includes('<string>--config</string>'));
+    assert.ok(xml.includes(`<string>${configPath}</string>`));
+  });
+
+  it('includes HOME environment variable', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>HOME</key>'));
+    assert.ok(xml.includes(`<string>${homedir()}</string>`));
+  });
+
+  it('includes StandardOutPath and StandardErrorPath', () => {
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>StandardOutPath</key>'));
+    assert.ok(xml.includes('<key>StandardErrorPath</key>'));
+  });
+
+  it('escapes special characters in paths', () => {
+    const opts = basePlistOpts({
+      configPath: '/Users/John & Jane/config.yaml',
+    });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('John &amp; Jane'));
+    assert.ok(!xml.includes('John & Jane'));
+  });
+
+  it('uses custom stdout/stderr paths when provided', () => {
+    const opts = basePlistOpts({
+      stdoutPath: '/tmp/my-stdout.log',
+      stderrPath: '/tmp/my-stderr.log',
+    });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('<string>/tmp/my-stdout.log</string>'));
+    assert.ok(xml.includes('<string>/tmp/my-stderr.log</string>'));
+  });
+
+  it('uses custom working directory when provided', () => {
+    const opts = basePlistOpts({
+      workingDirectory: '/custom/work/dir',
+    });
+    const xml = generatePlist(opts);
+    assert.ok(xml.includes('<string>/custom/work/dir</string>'));
+  });
+});
+
+// ---------- getPlistPath ----------
+
+describe('getPlistPath', () => {
+  it('returns ~/Library/LaunchAgents/com.gsd.daemon.plist', () => {
+    const expected = join(homedir(), 'Library', 'LaunchAgents', 'com.gsd.daemon.plist');
+    assert.equal(getPlistPath(), expected);
+  });
+});
+
+// ---------- install ----------
+
+describe('install', () => {
+  let tmp: string;
+  let fakePlistPath: string;
+
+  // We can't mock getPlistPath directly, but we can verify the commands
+  // issued and the plist content by intercepting runCommand and filesystem ops.
+  // For filesystem testing, we test the functions that call writeFileSync indirectly
+  // by verifying the runCommand calls and returned values.
+
+  it('calls launchctl load with the plist path', () => {
+    const calls: string[] = [];
+    const mockRun: RunCommandFn = (cmd: string) => {
+      calls.push(cmd);
+      return '';
+    };
+
+    // install will try to write to the real plist path, so we need to be careful.
+    // We test the command flow by catching the writeFileSync error (dir may not exist in CI)
+    // or by letting it proceed in local dev.
+    try {
+      install(basePlistOpts(), mockRun);
+    } catch {
+      // writeFileSync may fail if ~/Library/LaunchAgents doesn't exist in test env
+    }
+
+    const loadCalls = calls.filter(c => c.startsWith('launchctl load'));
+    const listCalls = calls.filter(c => c.startsWith('launchctl list'));
+    // Should have at least attempted launchctl load
+    assert.ok(loadCalls.length > 0 || calls.length > 0, 'Expected launchctl commands to be called');
+  });
+
+  it('generates valid plist content when called', () => {
+    // Test that the plist content would be correct by testing generatePlist
+    // (install is a thin wrapper around generatePlist + writeFile + launchctl)
+    const xml = generatePlist(basePlistOpts());
+    assert.ok(xml.includes('<key>Label</key>'));
+    assert.ok(xml.includes('<string>com.gsd.daemon</string>'));
+  });
+
+  it('handles idempotent install (unloads first if plist exists)', () => {
+    const calls: string[] = [];
+    const mockRun: RunCommandFn = (cmd: string) => {
+      calls.push(cmd);
+      return '';
+    };
+
+    // To simulate idempotent install, we need an existing plist file.
+    // Since install writes to getPlistPath(), we test the command sequence.
+    try {
+      install(basePlistOpts(), mockRun);
+      // Second install
+      install(basePlistOpts(), mockRun);
+    } catch {
+      // filesystem may not be writable
+    }
+
+    // The second install should have tried to unload first
+    const unloadCalls = calls.filter(c => c.startsWith('launchctl unload'));
+    // If the plist path exists, we expect at least one unload attempt on second call
+    // This is a command-level check; filesystem existence depends on environment
+  });
+});
+
+// ---------- uninstall ----------
+
+describe('uninstall', () => {
+  it('calls launchctl unload when plist would exist', () => {
+    const calls: string[] = [];
+    const mockRun: RunCommandFn = (cmd: string) => {
+      calls.push(cmd);
+      return '';
+    };
+
+    // uninstall checks existsSync(plistPath) — if plist doesn't exist, it's a no-op
+    uninstall(mockRun);
+
+    // If plist doesn't exist in test environment, calls should be empty (graceful)
+    // That's the "handles missing plist gracefully" case
+  });
+
+  it('handles missing plist gracefully (no-op)', () => {
+    const calls: string[] = [];
+    const mockRun: RunCommandFn = (cmd: string) => {
+      calls.push(cmd);
+      return '';
+    };
+
+    // Shouldn't throw even if plist doesn't exist
+    assert.doesNotThrow(() => uninstall(mockRun));
+  });
+
+  it('handles already-unloaded agent gracefully', () => {
+    const mockRun: RunCommandFn = (cmd: string) => {
+      if (cmd.includes('launchctl unload')) {
+        throw new Error('Could not find specified service');
+      }
+      return '';
+    };
+
+    // Should not throw even if launchctl unload fails
+    assert.doesNotThrow(() => uninstall(mockRun));
+  });
+});
+
+// ---------- status ----------
+
+describe('status', () => {
+  it('parses running daemon output (PID present)', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return '{\n\t"PID" = 1234;\n\t"Label" = "com.gsd.daemon";\n}\nPID\tStatus\tLabel\n1234\t0\tcom.gsd.daemon\n';
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+    assert.equal(result.pid, 1234);
+    assert.equal(result.lastExitStatus, 0);
+  });
+
+  it('parses stopped daemon output (no PID)', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return 'PID\tStatus\tLabel\n-\t78\tcom.gsd.daemon\n';
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+    assert.equal(result.pid, null);
+    assert.equal(result.lastExitStatus, 78);
+  });
+
+  it('returns not-registered when launchctl list fails', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      throw new Error('Could not find service "com.gsd.daemon" in domain for port');
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, false);
+    assert.equal(result.pid, null);
+    assert.equal(result.lastExitStatus, null);
+  });
+
+  it('returns structured result with all fields', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return 'PID\tStatus\tLabel\n5678\t0\tcom.gsd.daemon\n';
+    };
+
+    const result = status(mockRun);
+    assert.ok('registered' in result);
+    assert.ok('pid' in result);
+    assert.ok('lastExitStatus' in result);
+  });
+
+  it('parses JSON-style dict output (newer macOS)', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return `{
+\t"StandardOutPath" = "/Users/me/.gsd/daemon-stdout.log";
+\t"LimitLoadToSessionType" = "Aqua";
+\t"StandardErrorPath" = "/Users/me/.gsd/daemon-stderr.log";
+\t"Label" = "com.gsd.daemon";
+\t"OnDemand" = true;
+\t"LastExitStatus" = 0;
+\t"PID" = 23802;
+\t"Program" = "/usr/local/bin/node";
+};`;
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+    assert.equal(result.pid, 23802);
+    assert.equal(result.lastExitStatus, 0);
+  });
+
+  it('parses JSON-style dict output when daemon stopped (no PID key)', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return `{
+\t"Label" = "com.gsd.daemon";
+\t"LastExitStatus" = 1;
+\t"OnDemand" = true;
+};`;
+    };
+
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+    assert.equal(result.pid, null);
+    assert.equal(result.lastExitStatus, 1);
+  });
+
+  it('handles unexpected output format gracefully', () => {
+    const mockRun: RunCommandFn = (_cmd: string) => {
+      return 'some unexpected output without the label';
+    };
+
+    // Should not throw — should return registered:true but with null fields
+    // since the command succeeded (label was found) but output didn't match
+    const result = status(mockRun);
+    assert.equal(result.registered, true);
+  });
+});

package/packages/daemon/src/launchd.ts

@@ -0,0 +1,242 @@
+import { writeFileSync, unlinkSync, existsSync, chmodSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { dirname } from 'node:path';
+
+// --------------- types ---------------
+
+export interface PlistOptions {
+  /** Absolute path to the Node.js binary */
+  nodePath: string;
+  /** Absolute path to the daemon script (cli.js) */
+  scriptPath: string;
+  /** Absolute path to the config file */
+  configPath: string;
+  /** Directory to use as WorkingDirectory in the plist (defaults to homedir) */
+  workingDirectory?: string;
+  /** Override stdout log path */
+  stdoutPath?: string;
+  /** Override stderr log path */
+  stderrPath?: string;
+}
+
+export interface LaunchdStatus {
+  /** Whether the daemon is registered with launchd */
+  registered: boolean;
+  /** PID if currently running, null otherwise */
+  pid: number | null;
+  /** Last exit status code, null if never exited or not available */
+  lastExitStatus: number | null;
+}
+
+export type RunCommandFn = (cmd: string) => string;
+
+// --------------- constants ---------------
+
+const LABEL = 'com.gsd.daemon';
+const PLIST_FILENAME = `${LABEL}.plist`;
+
+// --------------- helpers ---------------
+
+/** Escape special XML characters in a string. */
+export function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/** Return the canonical plist path under ~/Library/LaunchAgents/. */
+export function getPlistPath(): string {
+  return resolve(homedir(), 'Library', 'LaunchAgents', PLIST_FILENAME);
+}
+
+/**
+ * Build the NVM-aware PATH string.
+ * Includes the directory containing the Node binary so that launchd can find node
+ * even when launched outside a shell session (where NVM isn't sourced).
+ */
+function buildEnvPath(nodePath: string): string {
+  const nodeBinDir = dirname(nodePath);
+  // Keep system essentials and prepend the node binary's directory
+  return `${nodeBinDir}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`;
+}
+
+// --------------- plist generation ---------------
+
+/** Generate valid launchd plist XML for the GSD daemon. */
+export function generatePlist(opts: PlistOptions): string {
+  const home = homedir();
+  const workDir = opts.workingDirectory ?? home;
+  const stdoutPath = opts.stdoutPath ?? resolve(home, '.gsd', 'daemon-stdout.log');
+  const stderrPath = opts.stderrPath ?? resolve(home, '.gsd', 'daemon-stderr.log');
+  const envPath = buildEnvPath(opts.nodePath);
+
+  // Forward ANTHROPIC_API_KEY so the orchestrator LLM can authenticate.
+  // Captured at install time from the current process environment.
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  const anthropicKeyXml = anthropicKey
+    ? `\n\t\t<key>ANTHROPIC_API_KEY</key>\n\t\t<string>${escapeXml(anthropicKey)}</string>`
+    : '';
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+\t<key>Label</key>
+\t<string>${escapeXml(LABEL)}</string>
+
+\t<key>ProgramArguments</key>
+\t<array>
+\t\t<string>${escapeXml(opts.nodePath)}</string>
+\t\t<string>${escapeXml(opts.scriptPath)}</string>
+\t\t<string>--config</string>
+\t\t<string>${escapeXml(opts.configPath)}</string>
+\t</array>
+
+\t<key>KeepAlive</key>
+\t<dict>
+\t\t<key>SuccessfulExit</key>
+\t\t<false/>
+\t</dict>
+
+\t<key>RunAtLoad</key>
+\t<true/>
+
+\t<key>EnvironmentVariables</key>
+\t<dict>
+\t\t<key>PATH</key>
+\t\t<string>${escapeXml(envPath)}</string>
+\t\t<key>HOME</key>
+\t\t<string>${escapeXml(home)}</string>${anthropicKeyXml}
+\t</dict>
+
+\t<key>WorkingDirectory</key>
+\t<string>${escapeXml(workDir)}</string>
+
+\t<key>StandardOutPath</key>
+\t<string>${escapeXml(stdoutPath)}</string>
+
+\t<key>StandardErrorPath</key>
+\t<string>${escapeXml(stderrPath)}</string>
+</dict>
+</plist>
+`;
+}
+
+// --------------- install / uninstall / status ---------------
+
+/** Default runCommand using execSync. */
+function defaultRunCommand(cmd: string): string {
+  return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+}
+
+/**
+ * Install the launchd agent: write plist and load it.
+ * Idempotent — unloads first if already loaded.
+ */
+export function install(
+  opts: PlistOptions,
+  runCommand: RunCommandFn = defaultRunCommand,
+): void {
+  const plistPath = getPlistPath();
+  const xml = generatePlist(opts);
+
+  // Unload first if already present (ignore errors)
+  if (existsSync(plistPath)) {
+    try {
+      runCommand(`launchctl unload ${plistPath}`);
+    } catch {
+      // already unloaded — fine
+    }
+  }
+
+  writeFileSync(plistPath, xml, 'utf-8');
+  chmodSync(plistPath, 0o644);
+
+  runCommand(`launchctl load ${plistPath}`);
+
+  // Verify it loaded
+  try {
+    runCommand(`launchctl list ${LABEL}`);
+  } catch {
+    throw new Error(
+      `Plist was written to ${plistPath} and launchctl load succeeded, but launchctl list ${LABEL} failed. The agent may not have started.`,
+    );
+  }
+}
+
+/**
+ * Uninstall the launchd agent: unload and remove plist.
+ * Graceful — does not throw if already uninstalled.
+ */
+export function uninstall(runCommand: RunCommandFn = defaultRunCommand): void {
+  const plistPath = getPlistPath();
+
+  if (existsSync(plistPath)) {
+    try {
+      runCommand(`launchctl unload ${plistPath}`);
+    } catch {
+      // already unloaded — that's fine
+    }
+    unlinkSync(plistPath);
+  }
+  // If plist doesn't exist, nothing to do — already uninstalled
+}
+
+/**
+ * Query launchd for the daemon's status.
+ * Returns structured information about registration, PID, and last exit code.
+ *
+ * Handles two launchctl output formats:
+ * 1. Tabular: "PID\tStatus\tLabel" (older macOS)
+ * 2. JSON-style dict: `"PID" = 1234;` / `"LastExitStatus" = 0;` (newer macOS)
+ */
+export function status(runCommand: RunCommandFn = defaultRunCommand): LaunchdStatus {
+  try {
+    const output = runCommand(`launchctl list ${LABEL}`);
+
+    // --- Try tabular format first ---
+    const lines = output.trim().split('\n');
+    for (const line of lines) {
+      const parts = line.trim().split(/\t+/);
+      if (parts.length >= 3 && parts[2] === LABEL) {
+        const pidStr = parts[0];
+        const statusStr = parts[1];
+
+        const pid = pidStr === '-' ? null : parseInt(pidStr, 10);
+        const lastExitStatus = statusStr != null ? parseInt(statusStr, 10) : null;
+
+        return {
+          registered: true,
+          pid: Number.isNaN(pid!) ? null : pid,
+          lastExitStatus: Number.isNaN(lastExitStatus!) ? null : lastExitStatus,
+        };
+      }
+    }
+
+    // --- Try JSON-style dict format ---
+    // Matches: "PID" = 1234;  or  "LastExitStatus" = 0;
+    const pidMatch = output.match(/"PID"\s*=\s*(\d+)\s*;/);
+    const exitMatch = output.match(/"LastExitStatus"\s*=\s*(\d+)\s*;/);
+
+    if (pidMatch || exitMatch) {
+      const pid = pidMatch ? parseInt(pidMatch[1], 10) : null;
+      const lastExitStatus = exitMatch ? parseInt(exitMatch[1], 10) : null;
+      return {
+        registered: true,
+        pid: Number.isNaN(pid!) ? null : pid,
+        lastExitStatus: Number.isNaN(lastExitStatus!) ? null : lastExitStatus,
+      };
+    }
+
+    // Label resolved (no error) but no parseable output — still registered
+    return { registered: true, pid: null, lastExitStatus: null };
+  } catch {
+    // launchctl list exits non-zero when the label isn't found
+    return { registered: false, pid: null, lastExitStatus: null };
+  }
+}

package/packages/daemon/src/message-batcher.test.ts

@@ -65,7 +65,7 @@ describe('MessageBatcher', () => {
       await batcher.destroy();
     });
 
-    it('combines embeds into a single send call', async () => {
+    it('skips embeds for batched messages (only content)', async () => {
       const { fn, calls } = createSend();
       const batcher = new MessageBatcher(fn, undefined, { maxBatchSize: 2, flushIntervalMs: 60_000 });
 
@@ -74,7 +74,7 @@ describe('MessageBatcher', () => {
       await new Promise((r) => setTimeout(r, 10));
 
       assert.equal(calls.length, 1);
-      assert.equal(calls[0].embeds.length, 2);
+      assert.equal(calls[0].embeds.length, 0, 'batched sends skip embeds to avoid duplication');
       assert.equal(calls[0].content, 'a\nb');
 
       await batcher.destroy();

package/packages/daemon/src/message-batcher.ts

@@ -162,6 +162,10 @@ export class MessageBatcher {
   /**
    * Build a SendPayload from a batch of FormattedEvents and invoke the send callback.
    * Catches and logs errors — never throws.
+   *
+   * For batched messages (2+ events), we send content-only to avoid duplication
+   * between content text and embed descriptions, and to stay under Discord's
+   * 10-embed limit. Single-event sends include the embed for rich formatting.
    */
   private async doSend(batch: FormattedEvent[]): Promise<void> {
     if (batch.length === 0) return;
@@ -169,10 +173,12 @@ export class MessageBatcher {
     // Combine content lines
     const content = batch.map((e) => e.content).join('\n');
 
-    // Collect all embeds (Discord allows up to 10 per message)
+    // For single events, include the embed for rich formatting.
+    // For batches, skip embeds — the content lines are self-descriptive and
+    // embeds would duplicate the information + risk hitting Discord's 10-embed cap.
     const embeds: unknown[] = [];
-    for (const e of batch) {
-      if (e.embed) embeds.push(e.embed);
+    if (batch.length === 1 && batch[0].embed) {
+      embeds.push(batch[0].embed);
     }
 
     // Collect all component rows (only from the last event with components —

package/packages/daemon/src/orchestrator.test.ts

@@ -201,6 +201,7 @@ function makeMessage(overrides: Partial<{
       send: async (content: string) => {
         sentMessages.push(content);
       },
+      sendTyping: async () => {},
     },
     sentMessages,
   };