@adaptic/maestro 1.1.8 → 1.4.1

package/scripts/daemon/lib/session-router.test.mjs

@@ -0,0 +1,295 @@
+/**
+ * session-router.test.mjs — node:test coverage for the session router.
+ *
+ * No real subprocess spawns, no real disk writes outside os.tmpdir().
+ * Each test creates its own registry path under tmpdir and cleans up.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { promises as fsp } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import { routingKey, createRouter } from "./session-router.mjs";
+
+function tmpRegistryPath(suffix = "") {
+  const name = `session-router-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${suffix}.json`;
+  return join(tmpdir(), name);
+}
+
+async function safeUnlink(path) {
+  try {
+    await fsp.unlink(path);
+  } catch {
+    /* ignore */
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 1. routingKey — one assertion per row of memo §4.2.
+// ---------------------------------------------------------------------------
+
+test("routingKey — slack threaded message", () => {
+  const k = routingKey({
+    source: "slack",
+    channel: "C0123ABC",
+    thread_ts: "1777283277.000100",
+  });
+  assert.equal(k, "slack:C0123ABC:1777283277.000100");
+});
+
+test("routingKey — slack DM (no thread)", () => {
+  const k = routingKey({
+    source: "slack",
+    channel: "D099N1JGKRQ",
+  });
+  assert.equal(k, "slack:D099N1JGKRQ");
+});
+
+test("routingKey — slack channel non-DM (no thread)", () => {
+  const k = routingKey({
+    source: "slack",
+    channel: "C0123ABC",
+    ts: "1777283277.000200",
+  });
+  assert.equal(k, "slack:C0123ABC:1777283277.000200");
+});
+
+test("routingKey — gmail", () => {
+  const k = routingKey({ source: "gmail", thread_id: "1818abc" });
+  assert.equal(k, "gmail:1818abc");
+});
+
+test("routingKey — calendar", () => {
+  const k = routingKey({ source: "calendar", event_id: "evt_42" });
+  assert.equal(k, "calendar:evt_42");
+});
+
+test("routingKey — internal queue item", () => {
+  const k = routingKey({ source: "internal", id: "ar-20260427-001" });
+  assert.equal(k, "internal:ar-20260427-001");
+});
+
+test("routingKey — backlog with topic_slug", () => {
+  const k = routingKey({
+    source: "backlog",
+    topic_slug: "session-router-step2",
+    id: "as-20260427-x",
+  });
+  assert.equal(k, "backlog:session-router-step2");
+});
+
+test("routingKey — backlog without topic_slug falls back to internal:<id>", () => {
+  const k = routingKey({ source: "backlog", id: "as-20260427-fallback" });
+  assert.equal(k, "internal:as-20260427-fallback");
+});
+
+// ---------------------------------------------------------------------------
+// 2. route() — missing key returns EPHEMERAL.
+// ---------------------------------------------------------------------------
+
+test("route — missing key returns EPHEMERAL", async (t) => {
+  const path = tmpRegistryPath("-missing");
+  t.after(() => safeUnlink(path));
+  const router = await createRouter({ registryPath: path });
+  const decision = router.route("slack:CNEVERSEEN:0");
+  assert.deepEqual(decision, { decision: "EPHEMERAL", resumeId: null });
+});
+
+// ---------------------------------------------------------------------------
+// 3. route() — past-TTL entry returns EPHEMERAL_REPLACE.
+// ---------------------------------------------------------------------------
+
+test("route — past-TTL entry returns EPHEMERAL_REPLACE", async (t) => {
+  const path = tmpRegistryPath("-ttl");
+  t.after(() => safeUnlink(path));
+  let clock = 1_000_000_000_000;
+  const router = await createRouter({
+    registryPath: path,
+    ttlSeconds: 60,
+    now: () => clock,
+  });
+  await router.touch("slack:DAAA:1", { claudeSessionId: "cli-1", model: "sonnet" });
+  // Advance clock past TTL.
+  clock += 61 * 1000;
+  const decision = router.route("slack:DAAA:1");
+  assert.equal(decision.decision, "EPHEMERAL_REPLACE");
+  assert.equal(decision.resumeId, null);
+});
+
+// ---------------------------------------------------------------------------
+// 4. route() — live, fresh, exit_code 0 returns RESUME with the stored id.
+// ---------------------------------------------------------------------------
+
+test("route — live fresh entry returns RESUME with stored claude_session_id", async (t) => {
+  const path = tmpRegistryPath("-resume");
+  t.after(() => safeUnlink(path));
+  let clock = 2_000_000_000_000;
+  const router = await createRouter({
+    registryPath: path,
+    ttlSeconds: 600,
+    now: () => clock,
+  });
+  await router.touch("slack:DRESUME:1", {
+    claudeSessionId: "cli-resume-xyz",
+    model: "sonnet",
+  });
+  clock += 30_000; // 30s — well within TTL.
+  const decision = router.route("slack:DRESUME:1");
+  assert.equal(decision.decision, "RESUME");
+  assert.equal(decision.resumeId, "cli-resume-xyz");
+});
+
+// ---------------------------------------------------------------------------
+// 5. route() — non-zero last_exit_code returns EPHEMERAL_REPLACE.
+// ---------------------------------------------------------------------------
+
+test("route — non-zero last_exit_code returns EPHEMERAL_REPLACE", async (t) => {
+  const path = tmpRegistryPath("-exitcode");
+  t.after(() => safeUnlink(path));
+  let clock = 3_000_000_000_000;
+  const router = await createRouter({
+    registryPath: path,
+    ttlSeconds: 600,
+    now: () => clock,
+  });
+  await router.touch("slack:DEXIT:1", {
+    claudeSessionId: "cli-exit",
+    model: "sonnet",
+  });
+  await router.recordExit("slack:DEXIT:1", 1);
+  clock += 5_000;
+  const decision = router.route("slack:DEXIT:1");
+  assert.equal(decision.decision, "EPHEMERAL_REPLACE");
+  assert.equal(decision.resumeId, null);
+});
+
+// ---------------------------------------------------------------------------
+// 6. touch() — LRU cap enforced; oldest entry evicted on overflow.
+// ---------------------------------------------------------------------------
+
+test("touch — LRU cap evicts oldest when at capacity", async (t) => {
+  const path = tmpRegistryPath("-lru");
+  t.after(() => safeUnlink(path));
+  let clock = 4_000_000_000_000;
+  const router = await createRouter({
+    registryPath: path,
+    ttlSeconds: 3600,
+    maxLiveSessions: 3,
+    now: () => clock,
+  });
+  for (let i = 1; i <= 3; i++) {
+    await router.touch(`slack:DLRU${i}`, {
+      claudeSessionId: `cli-${i}`,
+      model: "sonnet",
+    });
+    clock += 1000;
+  }
+  // At cap. Add a fourth.
+  await router.touch("slack:DLRU4", {
+    claudeSessionId: "cli-4",
+    model: "sonnet",
+  });
+  const snap = router._readForTests();
+  assert.equal(snap.lru.length, 3, "lru should still hold 3 keys");
+  assert.ok(!("slack:DLRU1" in snap.sessions), "oldest (DLRU1) evicted");
+  assert.ok("slack:DLRU2" in snap.sessions);
+  assert.ok("slack:DLRU3" in snap.sessions);
+  assert.ok("slack:DLRU4" in snap.sessions);
+});
+
+// ---------------------------------------------------------------------------
+// 7. recordExit() — non-zero code flips status to "killed".
+// ---------------------------------------------------------------------------
+
+test("recordExit — non-zero code flips status to killed", async (t) => {
+  const path = tmpRegistryPath("-killed");
+  t.after(() => safeUnlink(path));
+  const router = await createRouter({ registryPath: path });
+  await router.touch("slack:DKILL:1", {
+    claudeSessionId: "cli-kill",
+    model: "sonnet",
+  });
+  await router.recordExit("slack:DKILL:1", 137);
+  const snap = router._readForTests();
+  assert.equal(snap.sessions["slack:DKILL:1"].status, "killed");
+  assert.equal(snap.sessions["slack:DKILL:1"].last_exit_code, 137);
+});
+
+// ---------------------------------------------------------------------------
+// 8. evictExpired() — removes only stale entries, returns count.
+// ---------------------------------------------------------------------------
+
+test("evictExpired — removes only stale entries and returns count", async (t) => {
+  const path = tmpRegistryPath("-evict");
+  t.after(() => safeUnlink(path));
+  let clock = 5_000_000_000_000;
+  const router = await createRouter({
+    registryPath: path,
+    ttlSeconds: 60,
+    now: () => clock,
+  });
+  await router.touch("slack:DEVICT:OLD", {
+    claudeSessionId: "cli-old",
+    model: "sonnet",
+  });
+  // Advance past TTL.
+  clock += 120_000;
+  await router.touch("slack:DEVICT:NEW", {
+    claudeSessionId: "cli-new",
+    model: "sonnet",
+  });
+  // Now: OLD is stale (last_used_at = clock - 120s, ttl = 60s),
+  //      NEW is fresh.
+  const evicted = await router.evictExpired();
+  assert.equal(evicted, 1, "one entry should have been evicted");
+  const snap = router._readForTests();
+  assert.ok(!("slack:DEVICT:OLD" in snap.sessions));
+  assert.ok("slack:DEVICT:NEW" in snap.sessions);
+});
+
+// ---------------------------------------------------------------------------
+// 9. Registry round-trip — touch two keys, re-create router, state restored.
+// ---------------------------------------------------------------------------
+
+test("registry round-trip — second router instance reads persisted state", async (t) => {
+  const path = tmpRegistryPath("-roundtrip");
+  t.after(() => safeUnlink(path));
+  let clock = 6_000_000_000_000;
+
+  const r1 = await createRouter({
+    registryPath: path,
+    ttlSeconds: 3600,
+    now: () => clock,
+  });
+  await r1.touch("gmail:thread-A", {
+    claudeSessionId: "cli-A",
+    model: "sonnet",
+  });
+  clock += 1000;
+  await r1.touch("gmail:thread-B", {
+    claudeSessionId: "cli-B",
+    model: "opus",
+  });
+
+  // Fresh router instance against the same path.
+  const r2 = await createRouter({
+    registryPath: path,
+    ttlSeconds: 3600,
+    now: () => clock,
+  });
+  const snap = r2._readForTests();
+  assert.equal(Object.keys(snap.sessions).length, 2);
+  assert.equal(snap.sessions["gmail:thread-A"].claude_session_id, "cli-A");
+  assert.equal(snap.sessions["gmail:thread-B"].claude_session_id, "cli-B");
+  assert.equal(snap.sessions["gmail:thread-B"].model, "opus");
+  // Both keys present in the LRU array.
+  assert.ok(snap.lru.includes("gmail:thread-A"));
+  assert.ok(snap.lru.includes("gmail:thread-B"));
+
+  // route() should return RESUME for the persisted entry.
+  const dec = r2.route("gmail:thread-A");
+  assert.equal(dec.decision, "RESUME");
+  assert.equal(dec.resumeId, "cli-A");
+});

package/scripts/daemon/prompt-builder.mjs

@@ -102,10 +102,31 @@ const ACTION_INSTRUCTIONS = {
   respond: `ACTION: Respond to this message.
 - Read the message carefully and understand the request
 - Check for any relevant context in thread history
-- Draft and send a response using the appropriate MCP tool (Slack or Gmail)
+- Draft the substantive response directly — do NOT re-acknowledge if a holding message was already sent
+
+READING / CONTEXT (MCP tools are fine here):
+- Use MCP Slack for reading: \`mcp__claude_ai_Slack__slack_search_messages\`, \`slack_conversations_history\`, \`slack_users_info\`, etc.
+- Use MCP Gmail for reading: \`mcp__claude_ai_Gmail__gmail_search\`, \`gmail_read_email\`, etc.
+- Use MCP Google Calendar for scheduling lookups and event reads
+- These are authorised by the user session and are the preferred way to gather context before composing a reply
+
+SENDING (CLI scripts only — MCP writes will be blocked by pre-tool hooks):
+- Slack send: \`./scripts/slack-send.sh "<channel_id>" "<message_text>" --responding_to "<inbound_message_ts>"\`
+  - Add \`--thread_ts "<thread_ts>"\` if replying inside an existing thread
+  - The channel_id is in the inbox item as \`channel_id\` (starts with C, D, or G)
+  - Always pass \`--responding_to\` with the inbound message ts so dedup works
+- Gmail send: \`python3 scripts/send-email-threaded.py "<to>" "<subject>" "<body>" --reply-to-subject "<original_subject>"\`
+  - Use \`--attachment <path>\` to include files
+  - The \`From\` header and HTML signature are injected automatically
+- SMS send: \`./scripts/send-sms.sh --to "<e164_number>" --body "<text>"\`
+- WhatsApp send: \`./scripts/send-whatsapp.sh --to "whatsapp:<e164_number>" --body "<text>"\`
+
+Why split read vs write: MCP tools are ideal for reading because they have full API coverage and the session is already authorised. But writes must go through the CLI scripts so the outbound message carries the agent's own User OAuth Token (xoxp-) and appears as the agent's Slack identity — not tagged as "Sent using @Claude". The pre-tool-use hook \`scripts/hooks/block-mcp-slack-send.sh\` will reject any attempt to call \`slack_send_message\` / \`slack_schedule_message\` / \`slack_send_message_draft\` and remind you to use the CLI. Gmail write hooks behave the same way.
+
 - Match the tone and urgency of the sender
 - If the sender is CEO, prioritise speed and directness
-- If you need to share documents, upload to Google Drive or send as PDF — NEVER reference local file paths`,
+- If you need to share documents, upload to Google Drive or send as PDF — NEVER reference local file paths
+- Verify the send succeeded by checking the script's exit code and stdout before considering the task complete`,
 
   draft: `ACTION: Draft a response or document — do NOT send it yet.
 - Read the message and understand what is being requested
@@ -353,6 +374,23 @@ export async function buildPrompt(item, classResult, options = {}) {
   parts.push(preamble);
   parts.push("");
 
+  // 1a. Holding message warning — TOP OF PROMPT so Claude sees it before action instructions.
+  // This is the most critical instruction in the prompt: prevents double-replies.
+  // We repeat it at section 7a as well, immediately before the action block.
+  if (holdingMessage) {
+    parts.push("===== STOP — READ THIS FIRST =====");
+    parts.push(`A HOLDING MESSAGE has ALREADY been sent to the sender by the daemon. The exact text was:`);
+    parts.push(`  "${holdingMessage}"`);
+    parts.push("");
+    parts.push("Your job is to deliver the FULL substantive response or complete the actual work — NOT to acknowledge again.");
+    parts.push("- Do NOT start your reply with 'Got it', 'On it', 'Looking into this', 'Will get back to you', 'Thanks for reaching out', or any similar acknowledgment phrase.");
+    parts.push("- Do NOT echo what the user asked — they already received the holding note confirming receipt.");
+    parts.push("- Open with the actual answer, the actual draft, or the actual finding. Be direct.");
+    parts.push("- If after investigation you still cannot deliver a substantive response and need more time, send a SECOND-LEVEL UPDATE (specific blocker, ETA, what you need from the user) — never a generic 'still looking into it'.");
+    parts.push("===== END WARNING =====");
+    parts.push("");
+  }
+
   // 2. Session context
   parts.push(`Date: ${date}`);
   parts.push(`Classification: priority=${classResult.priority}, action=${action}, category=${classResult.category || "unclassified"}`);
@@ -392,6 +430,12 @@ export async function buildPrompt(item, classResult, options = {}) {
   }
 
   // 5. Action instructions
+  // If a holding message was already sent, prepend a second reminder so the
+  // action block is unambiguous about not re-acknowledging.
+  if (holdingMessage) {
+    parts.push("REMINDER: A holding message was already sent (see top of prompt). The action below describes WHAT to do — but you must NOT begin your reply with another acknowledgment. Open with substance.");
+    parts.push("");
+  }
   parts.push(actionBlock);
   parts.push("");
 
@@ -402,22 +446,18 @@ export async function buildPrompt(item, classResult, options = {}) {
     parts.push("");
   }
 
-  // 7. Backlog-specific: queue update instructions
+  // 7. Backlog-specific: queue update instructions (with history dedup — ib-20260405-001)
   if (type === "backlog" && queueItem) {
     parts.push(`When this task is complete:
 - Update the queue item status to "resolved" in the appropriate state/queues/ file
-- Add a history entry with timestamp, action taken, and by: sophie-daemon
+- HISTORY DEDUP RULE (CRITICAL): Before appending a history entry, read the item's existing history and check the LAST entry. If the last entry has substantially the same action text (same status, same priority, same blocked_by, same conclusion — e.g. "confirmed no changes", "still open", "re-verified"), do NOT append a new history entry. Instead, ONLY update the last_updated timestamp on the queue item. Only append a new history entry when something actually changed (status changed, new information, blocker resolved, action taken that differs from the last entry).
+- When you DO add a new history entry, include: timestamp, action taken, and by: sophie-daemon
 - If the task cannot be completed, set status to "blocked" and record what is blocking it`);
     parts.push("");
   }
 
-  // 8. Holding message context (if one was already sent)
-  if (holdingMessage) {
-    parts.push(`IMPORTANT: A holding message has ALREADY been sent to the sender. Do NOT send another acknowledgment. The message sent was:`);
-    parts.push(`"${holdingMessage}"`);
-    parts.push(`Now deliver the actual substantive response or complete the requested work. The sender is expecting the real answer, not another "I'm looking into it."`);
-    parts.push("");
-  }
+  // 8. (Holding message warning is now at the TOP of the prompt — see section 1a.
+  //     A second reminder is injected before the action block in section 5.)
 
   // 9. Audit instruction
   parts.push(`Log all actions taken to logs/audit/${date}-actions.jsonl as a JSON line with: timestamp, action_type, target, result, session context.`);