agent-relay-server 0.62.1 → 0.62.3

package/scripts/orchestrator-spawn-smoke.ts

@@ -20,6 +20,8 @@ type Agent = {
   createdAt?: number;
 };
 
+type ApprovalMode = "open" | "guarded" | "read-only";
+
 const args = process.argv.slice(2);
 let relayUrl = process.env.AGENT_RELAY_URL || "http://127.0.0.1:4850";
 let orchestratorId = process.env.AGENT_RELAY_SMOKE_ORCHESTRATOR || "";
@@ -92,6 +94,26 @@ function findSpawnedAgent(agents: Agent[], provider: string, label: string, star
     .sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0))[0] || null;
 }
 
+function approvalModesForProvider(provider: string): ApprovalMode[] {
+  if (provider === "claude") return ["open", "guarded", "read-only"];
+  return ["guarded"];
+}
+
+function promptForCase(provider: string, approvalMode: ApprovalMode, label: string, nonce: string): { prompt?: string; nonceLabel?: string } {
+  if (provider !== "claude") return {};
+  if (approvalMode === "guarded") return {};
+  if (approvalMode === "read-only") {
+    return {
+      prompt: `Agent Relay read-only spawn smoke. As your VERY FIRST action, use the Bash tool to run exactly: agent-relay /message label:${label} "${nonce}". Then wait for shutdown — do nothing else.`,
+      nonceLabel: "Bash relay CLI",
+    };
+  }
+  return {
+    prompt: `Agent Relay spawn smoke. As your VERY FIRST action, use the agent-relay MCP tool relay_send_message to send to "label:${label}" with body exactly "${nonce}". Then wait for shutdown — do nothing else.`,
+    nonceLabel: "relay MCP tool",
+  };
+}
+
 const orchestrators = await api<Orchestrator[]>("GET", "/orchestrators");
 // Default selection prefers the orchestrator on the same host as the relay (the
 // gate runs there): a local spawn is faster and avoids cross-host teardown
@@ -123,79 +145,77 @@ for (const provider of providers) {
     continue;
   }
 
-  const label = `smoke-${provider}-${Date.now()}`;
-  const startedAt = Date.now();
-  // #352: for providers seeded with an initial prompt, assert the spawn prompt was actually
-  // DELIVERED and the first turn RAN — by making the prompt's first action a relay tool call
-  // (send a nonce message) and waiting for that nonce to land in the relay feed. Registration
-  // alone (the old smoke) happens via the plugin regardless of prompt delivery, so it never
-  // caught the silently-dropped spawn prompt. The nonce is the end-to-end proof.
-  const nonce = `SMOKE-NONCE-${provider}-${Date.now()}-${Math.round(Math.random() * 1e9).toString(36)}`;
-  const promptProvider = provider === "claude";
-  const prompt = `Agent Relay spawn smoke. As your VERY FIRST action, use the agent-relay MCP tool relay_send_message to send to "label:${label}" with body exactly "${nonce}". Then wait for shutdown — do nothing else.`;
-  console.log(`spawn ${provider} via ${orchestrator.id}`);
-  await api("POST", `/agents/spawn`, {
-    provider,
-    orchestratorId: orchestrator.id,
-    cwd,
-    label,
-    // Prompt-seeded providers must run UNATTENDED: under guarded mode the first-turn relay tool
-    // call would block on a dashboard approval that never comes here. Autonomous workers spawn
-    // open for the same reason. (Approval mode is orthogonal to prompt delivery, which is the
-    // regression under test.)
-    approvalMode: promptProvider ? "open" : "guarded",
-    ...(promptProvider ? { prompt } : {}),
-  });
-
-  let agent: Agent | undefined;
-  let managed: { tmuxSession: string } | undefined;
-  try {
-    agent = await waitFor(`waiting for ${provider} agent registration`, async () => {
-      const agents = await api<Agent[]>("GET", "/agents");
-      return findSpawnedAgent(agents, provider, label, startedAt);
+  for (const approvalMode of approvalModesForProvider(provider)) {
+    const label = `smoke-${provider}-${approvalMode}-${Date.now()}`;
+    const startedAt = Date.now();
+    // #352: for providers seeded with an initial prompt, assert the spawn prompt was actually
+    // DELIVERED and the first turn RAN — by making the prompt's first action send a nonce message
+    // and waiting for that nonce to land in the relay feed. Registration alone happens via the
+    // plugin regardless of prompt delivery, so it never catches silently dropped spawn prompts.
+    const nonce = `SMOKE-NONCE-${provider}-${approvalMode}-${Date.now()}-${Math.round(Math.random() * 1e9).toString(36)}`;
+    const promptCase = promptForCase(provider, approvalMode, label, nonce);
+    console.log(`spawn ${provider} ${approvalMode} via ${orchestrator.id}`);
+    await api("POST", `/agents/spawn`, {
+      provider,
+      orchestratorId: orchestrator.id,
+      cwd,
+      label,
+      approvalMode,
+      ...(promptCase.prompt ? { prompt: promptCase.prompt } : {}),
     });
-    console.log(`registered ${provider}: ${agent.id}`);
 
-    managed = await waitFor(`waiting for ${provider} managed session`, async () => {
-      const latest = (await api<Orchestrator[]>("GET", "/orchestrators")).find((orch) => orch.id === orchestrator.id);
-      return latest?.managedAgents?.find((entry) => entry.label === label || entry.tmuxSession.includes(label)) || null;
-    });
+    let agent: Agent | undefined;
+    let managed: { tmuxSession: string } | undefined;
+    try {
+      agent = await waitFor(`waiting for ${provider} ${approvalMode} agent registration`, async () => {
+        const agents = await api<Agent[]>("GET", "/agents");
+        return findSpawnedAgent(agents, provider, label, startedAt);
+      });
+      console.log(`registered ${provider} ${approvalMode}: ${agent.id}`);
 
-    // Hard-assert the seeded first turn ran and reached relay (the prompt-delivery regression guard).
-    if (promptProvider) {
-      await waitFor(`waiting for ${provider} spawn-prompt first turn (nonce relay tool call)`, async () => {
-        const feed = await api<Array<{ body?: string }>>("GET", "/messages?limit=80");
-        return feed.some((m) => (m.body || "").includes(nonce)) ? true : null;
+      managed = await waitFor(`waiting for ${provider} ${approvalMode} managed session`, async () => {
+        const latest = (await api<Orchestrator[]>("GET", "/orchestrators")).find((orch) => orch.id === orchestrator.id);
+        return latest?.managedAgents?.find((entry) => entry.label === label || entry.tmuxSession.includes(label)) || null;
       });
-      console.log(`spawn-prompt delivered + first turn called relay ${provider}: ${nonce}`);
-    }
-  } finally {
-    // Always tear down — a failed assertion (e.g. a re-introduced prompt-drop) must NOT leak a
-    // managed agent on the host running the gate. Best-effort: teardown errors don't mask the
-    // original failure.
-    if (agent) {
-      const id = agent.id;
-      await api("POST", `/agents/${encodeURIComponent(id)}/actions`, { action: "shutdown" }).catch(() => {});
-      await waitFor(`waiting for ${provider} agent cleanup`, async () => {
-        const current = await apiOptional<Agent>("GET", `/agents/${encodeURIComponent(id)}`);
-        return !current || (current.status === "offline" && current.ready === false) ? true : null;
-      }).catch(() => {});
-      await apiOptional("DELETE", `/agents/${encodeURIComponent(id)}`).catch(() => {});
-      if (managed) {
-        const tmuxSession = managed.tmuxSession;
-        await api("POST", `/orchestrators/${encodeURIComponent(orchestrator.id)}/actions`, {
-          action: "shutdown",
-          agentId: id,
-          tmuxSession,
-          reason: "smoke-cleanup",
-        }).catch(() => {});
-        await waitFor(`waiting for ${provider} managed session cleanup`, async () => {
-          const latest = (await api<Orchestrator[]>("GET", "/orchestrators")).find((orch) => orch.id === orchestrator.id);
-          const stillManaged = latest?.managedAgents?.some((entry) => entry.tmuxSession === tmuxSession || entry.agentId === id);
-          return stillManaged ? null : true;
+
+      // Hard-assert prompt-seeded cases ran and reached relay. Guarded Claude remains
+      // registration-only here: forcing a Bash/MCP first turn would intentionally block on
+      // the known unattended approval path.
+      if (promptCase.nonceLabel) {
+        await waitFor(`waiting for ${provider} ${approvalMode} spawn-prompt first turn (${promptCase.nonceLabel})`, async () => {
+          const feed = await api<Array<{ body?: string }>>("GET", "/messages?limit=80");
+          return feed.some((m) => (m.body || "").includes(nonce)) ? true : null;
+        });
+        console.log(`spawn-prompt delivered + first turn called relay ${provider} ${approvalMode}: ${nonce}`);
+      }
+    } finally {
+      // Always tear down — a failed assertion (e.g. a re-introduced prompt-drop) must NOT leak a
+      // managed agent on the host running the gate. Best-effort: teardown errors don't mask the
+      // original failure.
+      if (agent) {
+        const id = agent.id;
+        await api("POST", `/agents/${encodeURIComponent(id)}/actions`, { action: "shutdown" }).catch(() => {});
+        await waitFor(`waiting for ${provider} ${approvalMode} agent cleanup`, async () => {
+          const current = await apiOptional<Agent>("GET", `/agents/${encodeURIComponent(id)}`);
+          return !current || (current.status === "offline" && current.ready === false) ? true : null;
         }).catch(() => {});
+        await apiOptional("DELETE", `/agents/${encodeURIComponent(id)}`).catch(() => {});
+        if (managed) {
+          const tmuxSession = managed.tmuxSession;
+          await api("POST", `/orchestrators/${encodeURIComponent(orchestrator.id)}/actions`, {
+            action: "shutdown",
+            agentId: id,
+            tmuxSession,
+            reason: "smoke-cleanup",
+          }).catch(() => {});
+          await waitFor(`waiting for ${provider} ${approvalMode} managed session cleanup`, async () => {
+            const latest = (await api<Orchestrator[]>("GET", "/orchestrators")).find((orch) => orch.id === orchestrator.id);
+            const stillManaged = latest?.managedAgents?.some((entry) => entry.tmuxSession === tmuxSession || entry.agentId === id);
+            return stillManaged ? null : true;
+          }).catch(() => {});
+        }
+        console.log(`shutdown ${provider} ${approvalMode}: ${label}`);
       }
-      console.log(`shutdown ${provider}: ${label}`);
     }
   }
 }

package/src/branch-landed.ts

@@ -34,6 +34,12 @@ export interface BranchLandedInput {
    * `undefined` from older orchestrators that don't report it → message stays generic.
    */
   pushed?: boolean;
+  /**
+   * The land came in via a pull request — the subject's trailing `(#NNN)` is the PR
+   * number, not an issue. Forwarded to the issue-lifecycle hook so it doesn't mistake
+   * the PR number for an issue to close (#482).
+   */
+  prLand?: boolean;
 }
 
 /**
@@ -172,7 +178,7 @@ export function reconcileLandedWorkspace(ws: WorkspaceRecord, preview: Workspace
     metadata: { source: "server", maintenanceJobId: "workspace-conflict-scan", workspaceId: ws.id, fromStatus: ws.status, ...(sha ? { landedSha: sha } : {}) },
   });
   try {
-    notifyBranchLanded({ workspace: ws, mergedSha: sha, pushed: true });
+    notifyBranchLanded({ workspace: ws, mergedSha: sha, pushed: true, prLand: via === "pr" });
   } catch {
     // Notification is best-effort; the merged status + activity event still stand.
   }

package/src/db/delivery.ts

@@ -4,6 +4,7 @@ import { isRecord, stringValue, isMechanicalMessageKind } from "agent-relay-sdk"
 import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
 import { parseJson } from "../utils";
 import { isLiveIsolatedWorkspace } from "../workspace-phase";
+import { parseChannelRouteTarget } from "../channel-target";
 import {
   CONTRACT_REQUIREMENTS,
   contractCompatibility,
@@ -156,27 +157,76 @@ export function legacyChannelTargets(agent: AgentCard | null | undefined): strin
   return [...aliases];
 }
 
-export function matchingDeliveryAgents(target: string): AgentCard[] {
-  if (!target) return [];
-  const candidates = listAgents().filter(isDeliveryAgent);
-  if (target === "broadcast") return candidates;
-  const direct = getAgent(target);
-  if (direct) return isDeliveryAgent(direct) ? [direct] : [];
-  if (target.startsWith("tag:")) {
-    const tag = target.slice(4);
-    return candidates.filter((agent) => agent.tags.includes(tag));
+type BroadcastDeliveryContext = Pick<SendMessageInput, "from" | "channel">;
+
+function addTargetParticipants(target: string, scope: Set<string>, candidates: AgentCard[]): void {
+  const parsed = parseChannelRouteTarget(target);
+  switch (parsed.type) {
+    case "agent":
+    case "orchestrator":
+      if (candidates.some((agent) => agent.id === parsed.id)) scope.add(parsed.id);
+      return;
+    case "tag":
+      for (const agent of candidates) if (agent.tags.includes(parsed.id)) scope.add(agent.id);
+      return;
+    case "capability":
+      for (const agent of candidates) if (agent.capabilities.includes(parsed.id)) scope.add(agent.id);
+      return;
+    case "label":
+      for (const agent of candidates) if (agent.label === parsed.id) scope.add(agent.id);
+      return;
+    case "team":
+      for (const agent of candidates) if (agent.teamId === parsed.id) scope.add(agent.id);
+      return;
   }
-  if (target.startsWith("cap:")) {
-    const cap = target.slice(4);
-    return candidates.filter((agent) => agent.capabilities.includes(cap));
+}
+
+function channelParticipantAgentIds(channel: string, candidates: AgentCard[], senderId?: string): Set<string> {
+  const candidateIds = new Set(candidates.map((agent) => agent.id));
+  const scope = new Set<string>();
+  if (senderId && candidateIds.has(senderId)) scope.add(senderId);
+  const rows = getDb().query(`
+    SELECT from_agent, to_target, resolved_to_agent
+    FROM messages
+    WHERE channel = ?
+  `).all(channel) as Array<{ from_agent: string; to_target: string; resolved_to_agent?: string | null }>;
+  for (const row of rows) {
+    if (candidateIds.has(row.from_agent)) scope.add(row.from_agent);
+    if (row.resolved_to_agent && candidateIds.has(row.resolved_to_agent)) scope.add(row.resolved_to_agent);
+    addTargetParticipants(row.to_target, scope, candidates);
   }
-  if (target.startsWith("label:")) {
-    const label = target.slice(6);
-    return candidates.filter((agent) => agent.label === label);
+  return scope;
+}
+
+function scopedBroadcastCandidates(candidates: AgentCard[], context?: BroadcastDeliveryContext): AgentCard[] {
+  if (context?.channel) {
+    const scope = channelParticipantAgentIds(context.channel, candidates, context.from);
+    return candidates.filter((agent) => scope.has(agent.id));
   }
-  if (target.startsWith("team:")) {
-    const teamId = target.slice(5);
-    return candidates.filter((agent) => agent.teamId === teamId);
+  const sender = context?.from ? getAgent(context.from) : null;
+  if (sender?.teamId) return candidates.filter((agent) => agent.teamId === sender.teamId);
+  return candidates;
+}
+
+export function matchingDeliveryAgents(target: string, context?: BroadcastDeliveryContext): AgentCard[] {
+  if (!target) return [];
+  const candidates = listAgents().filter(isDeliveryAgent);
+  const parsed = parseChannelRouteTarget(target);
+  switch (parsed.type) {
+    case "broadcast":
+      return scopedBroadcastCandidates(candidates, context);
+    case "agent": {
+      const direct = getAgent(parsed.id);
+      return direct && isDeliveryAgent(direct) ? [direct] : [];
+    }
+    case "tag":
+      return candidates.filter((agent) => agent.tags.includes(parsed.id));
+    case "capability":
+      return candidates.filter((agent) => agent.capabilities.includes(parsed.id));
+    case "label":
+      return candidates.filter((agent) => agent.label === parsed.id);
+    case "team":
+      return candidates.filter((agent) => agent.teamId === parsed.id);
   }
   return [];
 }

package/src/db/message-reads.ts

@@ -159,6 +159,124 @@ export function listAgentChatHistory(query: {
   return ascending ? messages : messages.reverse();
 }
 
+function agentParticipationClauses(
+  alias: string,
+  agent: AgentCard,
+  legacyTargets: string[],
+  params: any[],
+): string[] {
+  const clauses = [
+    `${alias}.from_agent = ?`,
+    `${alias}.to_target = ?`,
+    `${alias}.resolved_to_agent = ?`,
+  ];
+  params.push(agent.id, agent.id, agent.id);
+  for (const tag of agent.tags) {
+    clauses.push(`${alias}.to_target = ?`);
+    params.push(`tag:${tag}`);
+  }
+  for (const cap of agent.capabilities) {
+    clauses.push(`${alias}.to_target = ?`);
+    params.push(`cap:${cap}`);
+  }
+  if (agent.label) {
+    clauses.push(`${alias}.to_target = ?`);
+    params.push(`label:${agent.label}`);
+  }
+  if (agent.teamId) {
+    clauses.push(`${alias}.to_target = ?`);
+    params.push(`team:${agent.teamId}`);
+  }
+  for (const target of legacyTargets) {
+    clauses.push(`${alias}.to_target = ?`);
+    params.push(target);
+  }
+  return clauses;
+}
+
+function scopedBroadcastClause(agent: AgentCard | null | undefined, legacyTargets: string[], params: any[]): string {
+  const senderGlobal = "NOT EXISTS (SELECT 1 FROM agents sender WHERE sender.id = m.from_agent AND sender.team_id IS NOT NULL)";
+  const noChannel = agent?.teamId
+    ? `(m.channel IS NULL AND (${senderGlobal} OR EXISTS (SELECT 1 FROM agents sender WHERE sender.id = m.from_agent AND sender.team_id = ?)))`
+    : `(m.channel IS NULL AND ${senderGlobal})`;
+  if (agent?.teamId) params.push(agent.teamId);
+  if (!agent) return noChannel;
+
+  const participantParams: any[] = [];
+  const participantClauses = agentParticipationClauses("cp", agent, legacyTargets, participantParams);
+  const channel = `(m.channel IS NOT NULL AND (m.from_agent = ? OR EXISTS (
+    SELECT 1 FROM messages cp
+    WHERE cp.channel = m.channel
+      AND cp.id <> m.id
+      AND (${participantClauses.join(" OR ")})
+  )))`;
+  params.push(agent.id, ...participantParams);
+  return `(${noChannel} OR ${channel})`;
+}
+
+function freshForSessionClause(agent: AgentCard | null | undefined, params: any[]): string {
+  // Same-ms registration+send can happen in tests and on fast local loops; >= preserves genuine
+  // post-registration messages while still excluding historical fan-out backlog for fresh sessions.
+  params.push(agent?.createdAt ?? Date.now());
+  return "(m.claimable = 1 OR m.created_at >= ?)";
+}
+
+function freshFanoutTargetClause(target: string, agent: AgentCard | null | undefined, params: any[]): string {
+  params.push(target);
+  return `(m.to_target = ? AND ${freshForSessionClause(agent, params)})`;
+}
+
+/**
+ * Emojis that count as an explicit acknowledgement of a message thread (#437).
+ * A reaction with one of these suppresses the reply-reminder on subsequent deliveries.
+ * Policy: thumbs-up (👍) and check-mark (✅) classes only — passing reactions like ❤️
+ * or 👀 are not settling and must never cause false suppression.
+ */
+export const ACK_REACTION_EMOJIS: readonly string[] = ["👍", "✅"];
+
+/**
+ * Annotates messages with `replyExpected: false` when this agent has already settled them
+ * via a direct/thread reply OR an ack-class reaction. Used at poll time so the runner's
+ * delivery formatting naturally drops them from the reply-reminder anchor (#437).
+ *
+ * A single batch SQL query covers all replyable messages — no per-message round-trips.
+ */
+function annotateAnsweredMessages(messages: Message[], agentId: string): Message[] {
+  const replyableIds = messages
+    .filter((m) => m.replyExpected !== false && Number.isSafeInteger(m.id) && m.id > 0)
+    .map((m) => m.id);
+  if (replyableIds.length === 0) return messages;
+
+  const idPlaceholders = replyableIds.map(() => "?").join(", ");
+  const ackPlaceholders = ACK_REACTION_EMOJIS.map(() => "?").join(", ");
+
+  const answeredRows = getDb().query(`
+    SELECT m.id FROM messages m
+    WHERE m.id IN (${idPlaceholders})
+      AND (
+        EXISTS (
+          SELECT 1 FROM messages r
+          WHERE r.from_agent = ?
+            AND (
+              r.reply_to = m.id
+              OR (m.thread_id IS NOT NULL AND r.thread_id = m.thread_id AND r.id > m.id)
+            )
+        )
+        OR EXISTS (
+          SELECT 1 FROM message_reactions mr
+          WHERE mr.message_id = m.id
+            AND mr.actor_id = ?
+            AND mr.emoji IN (${ackPlaceholders})
+            AND mr.created_at >= m.created_at
+        )
+      )
+  `).all(...replyableIds, agentId, agentId, ...ACK_REACTION_EMOJIS) as Array<{ id: number }>;
+
+  if (answeredRows.length === 0) return messages;
+  const answeredIds = new Set(answeredRows.map((r) => r.id));
+  return messages.map((m) => (answeredIds.has(m.id) ? { ...m, replyExpected: false as const } : m));
+}
+
 export function pollMessages(query: PollQuery): Message[] {
   const agent = getAgent(query.for);
   const agentTags = agent?.tags ?? [];
@@ -170,24 +288,28 @@ export function pollMessages(query: PollQuery): Message[] {
   const conditions: string[] = [];
   const params: any[] = [];
 
-  // Build target matching: direct + broadcast + tag + capability + label.
+  // Build target matching: direct + scoped broadcast + tag + capability + label.
   // Channel agents also accept legacy bare provider targets (for example
   // "telegram") so older clients keep working after canonical IDs became
   // provider:account ("telegram:default").
-  const targetClauses = ["to_target = ?", "resolved_to_agent = ?", "to_target = 'broadcast'"];
+  const targetClauses = ["to_target = ?", "resolved_to_agent = ?"];
   params.push(query.for, query.for);
+  {
+    const broadcastParams: any[] = [];
+    const broadcastScope = scopedBroadcastClause(agent, agentLegacyChannelTargets, broadcastParams);
+    const fresh = freshForSessionClause(agent, broadcastParams);
+    targetClauses.push(`(m.to_target = 'broadcast' AND ${broadcastScope} AND ${fresh})`);
+    params.push(...broadcastParams);
+  }
 
   for (const tag of agentTags) {
-    targetClauses.push("to_target = ?");
-    params.push(`tag:${tag}`);
+    targetClauses.push(freshFanoutTargetClause(`tag:${tag}`, agent, params));
   }
   for (const cap of agentCaps) {
-    targetClauses.push("to_target = ?");
-    params.push(`cap:${cap}`);
+    targetClauses.push(freshFanoutTargetClause(`cap:${cap}`, agent, params));
   }
   if (agentLabel) {
-    targetClauses.push("to_target = ?");
-    params.push(`label:${agentLabel}`);
+    targetClauses.push(freshFanoutTargetClause(`label:${agentLabel}`, agent, params));
   }
   if (agentTeamId) {
     targetClauses.push("to_target = ?");
@@ -244,7 +366,7 @@ export function pollMessages(query: PollQuery): Message[] {
   params.push(limit);
 
   const rows = timedQuery("pollMessages", () => getDb().query(sql).all(...params) as any[]);
-  return rows.map(rowToMessage);
+  return annotateAnsweredMessages(rows.map(rowToMessage), query.for);
 }
 
 export function messageRequiresReply(message: Message): boolean {

package/src/db/messages.ts

@@ -265,13 +265,13 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
     }
   }
 
-  // #451 — moderate default TTL for fire-and-forget FAN-OUT messages the sender didn't bound, so a
-  // stale broadcast/tag/cap/label/team push can't wake a late-joining agent hours later. Exempt
+  // #451/#461 — moderate default TTL for non-claimable FAN-OUT messages the sender didn't bound,
+  // so stale broadcast/tag/cap/label/team chat cannot wake a late-joining agent hours later. Exempt
   // (never auto-expire, preserving store-ahead #234): direct DMs and policy targets (single
-  // recipient), reply-obligations (replyExpected !== false), claimable work, and any message that
-  // already carried an explicit TTL — including an explicit `null` from routeNotification, whose
-  // per-type decision (e.g. a store-ahead `plan.bound_agent_exited` to `team:`) must win here.
-  if (ttlUnspecified && input.replyExpected === false && !claimable && isFanoutTarget(input.to)) {
+  // recipient), claimable work, and any message that already carried an explicit TTL — including an
+  // explicit `null` from routeNotification, whose per-type decision (e.g. a store-ahead
+  // `plan.bound_agent_exited` to `team:`) must win here.
+  if (ttlUnspecified && !claimable && isFanoutTarget(input.to)) {
     maxAgeSeconds = DEFAULT_FANOUT_TTL_SECONDS;
   }
 
@@ -480,4 +480,3 @@ export function getMessage(id: number): Message | null {
   const row = getDb().query(`${MSG_SELECT} WHERE m.id = ?`).get(id) as any;
   return row ? rowToMessage(row) : null;
 }
-

package/src/db/schema.ts

@@ -677,7 +677,8 @@ export function initDb(path: string = "agent-relay.db"): Database {
     );
     CREATE INDEX IF NOT EXISTS idx_activity_operator ON activity_events(operator_id, created_at);
     CREATE INDEX IF NOT EXISTS idx_activity_created ON activity_events(created_at);
-    CREATE INDEX IF NOT EXISTS idx_activity_agent ON activity_events(agent_id, created_at); CREATE INDEX IF NOT EXISTS idx_activity_issue ON activity_events(issue_ref_id, created_at); CREATE INDEX IF NOT EXISTS idx_activity_agent_issue ON activity_events(agent_id, issue_ref_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_activity_agent ON activity_events(agent_id, created_at);
+    -- issue_ref_id/issue_action indexes are created in applyMigrations() AFTER the ALTER — never inline here (#483: inline index over a not-yet-migrated column crashes initDb on existing DBs).
 
     CREATE TABLE IF NOT EXISTS channels (
       id TEXT PRIMARY KEY,

package/src/routes/commands.ts

@@ -250,6 +250,9 @@ export const patchCommand: Handler = async (req, params) => {
               subject: prLanded
                 ? cleanString(prLanded.subject, "params.prLanded.subject", { max: 200 })
                 : cleanString(command.result.subject, "result.subject", { max: 200 }),
+              // PR-land subjects carry a trailing `(#PR)` GitHub stamps on the squash — not an
+              // issue. Tell the lifecycle hook so it won't close the PR number as an issue (#482).
+              prLand: Boolean(prLanded),
               newBranch,
               pushed: prLanded ? true : typeof command.result.pushed === "boolean" ? command.result.pushed : undefined,
             });