agent-relay-server 0.62.2 → 0.63.0

package/src/db/activity.ts

@@ -98,7 +98,7 @@ export interface RecordIssueActivityInput {
   metadata?: Record<string, unknown>;
 }
 
-export interface IssueActivityAgentSummary {
+interface IssueActivityAgentSummary {
   agentId: string;
   agentName?: string;
   agentKind?: string;

package/src/db/agent-predicates.ts

@@ -0,0 +1,9 @@
+import type { AgentCard } from "../types";
+
+export function isDeliveryAgent(agent: AgentCard): boolean {
+  return agent.status !== "offline" &&
+    agent.id !== "user" &&
+    agent.id !== "system" &&
+    agent.kind !== "channel" &&
+    agent.meta?.kind !== "channel";
+}

package/src/db/agent-search.ts

@@ -105,9 +105,9 @@ export interface AgentSearchSort {
   limit?: number;
 }
 
-export const AGENT_SEARCH_MAX_LIMIT = 200;
+const AGENT_SEARCH_MAX_LIMIT = 200;
 
-export function searchValues(value: string | string[] | undefined): string[] {
+function searchValues(value: string | string[] | undefined): string[] {
   if (value == null) return [];
   return (Array.isArray(value) ? value : [value]).filter((v): v is string => typeof v === "string" && v.length > 0);
 }

package/src/db/agents.ts

@@ -14,13 +14,15 @@ import {
 } from "../contracts";
 import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
 import { matchAgents } from "../agent-ref";
-import { evaluatePoolBindings, expectedChannelAgentId, upsertChannelForAgent } from "./channels.ts";
+import { expectedChannelAgentId } from "./channel-identity.ts";
+import { evaluatePoolBindings, upsertChannelForAgent } from "./channels.ts";
 import { seedContinuationObjectiveFromSpawnPrompt } from "./continuations.ts";
 import { messageTaskClosed } from "./claim-sql.ts";
 import { ValidationError, getDb } from "./connection.ts";
 import { rowToAgent, rowToContextSnapshot } from "./mappers.ts";
-import { closeOpenPairsForAgent } from "./pairs.ts";
-import { TASK_SELECT, insertTaskEvent } from "./tasks.ts";
+import { closeOpenPairsForAgent } from "./pair-maintenance.ts";
+import { parseStringArray } from "./shared.ts";
+import { settleSingleTargetOnDemandTasks } from "./task-maintenance.ts";
 import { electWorkspaceStewards, electWorkspaceStewardsForAgent } from "./workspaces.ts";
 import { DEFAULT_SELF_RESUME_CONFIG } from "../self-resume-config";
 import type { TokenRevokeReason } from "../security";
@@ -89,17 +91,13 @@ import type {
 
 const CONTEXT_SNAPSHOT_DEBOUNCE_MS = 60_000;
 
-export function parseStringArray(raw: string): string[] {
-  const parsed = parseJson<unknown>(raw, []);
-  if (!Array.isArray(parsed)) return [];
-  return parsed.filter((value): value is string => typeof value === "string");
-}
+export { parseStringArray } from "./shared.ts";
 
 export function normalizeTags(tags: string[] | undefined): string[] {
   return [...new Set((tags ?? []).map((tag) => tag.trim()).filter(Boolean))];
 }
 
-export function inferAgentKind(input: Pick<RegisterAgentInput, "id" | "kind" | "tags" | "capabilities" | "meta">): AgentKind {
+function inferAgentKind(input: Pick<RegisterAgentInput, "id" | "kind" | "tags" | "capabilities" | "meta">): AgentKind {
   if (input.kind) return input.kind;
   if (input.id === "user") return "user";
   if (input.id === "system") return "system";
@@ -110,7 +108,7 @@ export function inferAgentKind(input: Pick<RegisterAgentInput, "id" | "kind" | "
   return "provider";
 }
 
-export function inferProviderTag(input: RegisterAgentInput): "claude" | "codex" | undefined {
+function inferProviderTag(input: RegisterAgentInput): "claude" | "codex" | undefined {
   if (inferAgentKind(input) !== "provider") return undefined;
   const meta = input.meta ?? {};
   const values = [
@@ -134,7 +132,7 @@ export function inferProviderTag(input: RegisterAgentInput): "claude" | "codex"
   return undefined;
 }
 
-export function tagsWithProvider(input: RegisterAgentInput): string[] {
+function tagsWithProvider(input: RegisterAgentInput): string[] {
   const tags = normalizeTags(input.tags);
   const provider = inferProviderTag(input);
   if (!provider || tags.includes(provider)) return tags;
@@ -392,14 +390,14 @@ export function listContextSnapshots(agentId: string, options: { since?: number;
   return (getDb().query(sql).all(...params) as any[]).map(rowToContextSnapshot);
 }
 
-export function pruneContextSnapshots(agentId?: string, olderThan = Date.now() - DAY_MS): number {
+function pruneContextSnapshots(agentId?: string, olderThan = Date.now() - DAY_MS): number {
   const result = agentId
     ? getDb().query("DELETE FROM context_snapshots WHERE agent_id = ? AND captured_at < ?").run(agentId, olderThan)
     : getDb().query("DELETE FROM context_snapshots WHERE captured_at < ?").run(olderThan);
   return result.changes;
 }
 
-export function recordContextSnapshot(agentId: string, context: ContextState, now: number): void {
+function recordContextSnapshot(agentId: string, context: ContextState, now: number): void {
   const latest = getDb()
     .query("SELECT captured_at FROM context_snapshots WHERE agent_id = ? ORDER BY captured_at DESC LIMIT 1")
     .get(agentId) as { captured_at: number } | undefined;
@@ -464,33 +462,7 @@ export function reapStaleAgents(ttlMs: number = STALE_TTL_MS): string[] {
   return rows.map((r: any) => r.id);
 }
 
-// On-demand automation tasks (targetMode=on_demand_agent) are bound to a single
-// ephemeral agent spawned just for that task. When that agent's claim is released —
-// clean shutdown, prune, lease expiry, or orphan-grace — the task must NOT return to
-// the claimable pool: its target is a unique `label:automation-…` that no other agent
-// will ever match, so a re-opened task lingers forever as an orphaned claim. Resolve
-// those as done instead; automation reconcile then settles the run as succeeded.
-// Run this BEFORE the generic re-open UPDATE at each release site, with the same WHERE
-// condition: it flips matching single-target tasks to 'done', which the subsequent
-// re-open (gated on status IN claimed/in_progress/blocked/orphaned) then skips.
-export function settleSingleTargetOnDemandTasks(condition: string, params: any[], now: number, reason: string): void {
-  const selectSql = `${TASK_SELECT} WHERE (${condition}) AND json_extract(metadata, '$.targetMode') = 'on_demand_agent' AND status IN ('claimed', 'in_progress', 'blocked', 'orphaned')`;
-  const rows = getDb().query(selectSql).all(...params) as any[];
-  if (rows.length === 0) return;
-  getDb().query(
-    `UPDATE tasks SET status = 'done', claim_expires_at = NULL, updated_at = ?, last_seen_at = ? WHERE (${condition}) AND json_extract(metadata, '$.targetMode') = 'on_demand_agent' AND status IN ('claimed', 'in_progress', 'blocked', 'orphaned')`
-  ).run(now, now, ...params);
-  for (const row of rows) {
-    insertTaskEvent(row.id, {
-      source: "agent-relay",
-      type: "task.auto-completed",
-      severity: row.severity,
-      title: "On-demand task auto-resolved",
-      body: `On-demand agent ${row.claimed_by ?? "(unknown)"} exited (${reason}); task resolved so it does not orphan`,
-      metadata: { agentId: row.claimed_by, reason, completedBy: "relay" },
-    }, now);
-  }
-}
+export { settleSingleTargetOnDemandTasks } from "./task-maintenance.ts";
 
 export function pruneOfflineAgents(maxOfflineMs: number = DAY_MS): string[] {
   const cutoff = Date.now() - maxOfflineMs;
@@ -578,7 +550,7 @@ export function revokeRuntimeTokensForAgent(agentId: string, now = Date.now(), r
   return rows.map((item) => item.jti);
 }
 
-export function runtimeTokenJtisFromMeta(meta: Record<string, unknown>): string[] {
+function runtimeTokenJtisFromMeta(meta: Record<string, unknown>): string[] {
   const jtis = new Set<string>();
   const auth = isRecord(meta.auth) ? meta.auth : undefined;
   const direct = typeof auth?.jti === "string" ? auth.jti : typeof meta.runtimeTokenJti === "string" ? meta.runtimeTokenJti : undefined;

package/src/db/artifacts.ts

@@ -82,28 +82,28 @@ import type {
 // --- Artifacts ---
 
 export const VALID_ARTIFACT_KINDS = new Set<ArtifactKind>(["image", "audio", "video", "document", "archive", "other"]);
-export const VALID_ARTIFACT_VISIBILITIES = new Set<ArtifactVisibility>(["private", "project", "org"]);
+const VALID_ARTIFACT_VISIBILITIES = new Set<ArtifactVisibility>(["private", "project", "org"]);
 export const VALID_ARTIFACT_SENSITIVITIES = new Set<ArtifactSensitivity>(["public", "normal", "sensitive", "secret"]);
-export const VALID_ARTIFACT_LINK_ENTITY_TYPES = new Set<ArtifactLink["entityType"]>(["message", "task", "recipeRun", "recipeStep", "channelEvent"]);
+const VALID_ARTIFACT_LINK_ENTITY_TYPES = new Set<ArtifactLink["entityType"]>(["message", "task", "recipeRun", "recipeStep", "channelEvent"]);
 export const VALID_ARTIFACT_ROLES = new Set<NonNullable<ArtifactLink["role"]>>(["media", "patch", "report", "log", "output", "input"]);
 
 export function artifactId(): string {
   return `art_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
 }
 
-export function artifactLinkId(): string {
+function artifactLinkId(): string {
   return `alink_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
 }
 
-export function normalizeArtifactKind(kind: unknown): ArtifactKind {
+function normalizeArtifactKind(kind: unknown): ArtifactKind {
   return typeof kind === "string" && VALID_ARTIFACT_KINDS.has(kind as ArtifactKind) ? kind as ArtifactKind : "other";
 }
 
-export function normalizeArtifactVisibility(visibility: unknown): ArtifactVisibility {
+function normalizeArtifactVisibility(visibility: unknown): ArtifactVisibility {
   return typeof visibility === "string" && VALID_ARTIFACT_VISIBILITIES.has(visibility as ArtifactVisibility) ? visibility as ArtifactVisibility : "project";
 }
 
-export function normalizeArtifactSensitivity(sensitivity: unknown): ArtifactSensitivity {
+function normalizeArtifactSensitivity(sensitivity: unknown): ArtifactSensitivity {
   return typeof sensitivity === "string" && VALID_ARTIFACT_SENSITIVITIES.has(sensitivity as ArtifactSensitivity) ? sensitivity as ArtifactSensitivity : "normal";
 }
 
@@ -212,7 +212,7 @@ export function deleteArtifact(id: string): boolean {
   })();
 }
 
-export function listArtifactLinks(artifactId: string): ArtifactLink[] {
+function listArtifactLinks(artifactId: string): ArtifactLink[] {
   return (getDb().query("SELECT * FROM artifact_links WHERE artifact_id = ? ORDER BY created_at ASC").all(artifactId) as any[]).map(rowToArtifactLink);
 }
 
@@ -271,7 +271,7 @@ export function artifactBlobReferenceCount(digest: string): number {
   return row.count ?? 0;
 }
 
-export function unreferencedArtifactBlobs(): ArtifactBlob[] {
+function unreferencedArtifactBlobs(): ArtifactBlob[] {
   return (getDb().query(`
     SELECT b.*
     FROM artifact_blobs b

package/src/db/channel-identity.ts

@@ -0,0 +1,38 @@
+import { stringValue } from "agent-relay-sdk";
+import type { AgentCard, RegisterAgentInput } from "../types";
+
+export function channelProviderForAgent(agent: AgentCard): string {
+  return stringValue(agent.meta?.provider) ??
+    stringValue(agent.meta?.channelType) ??
+    stringValue(agent.meta?.transport) ??
+    agent.tags.find((tag) => tag.startsWith("channel:"))?.slice("channel:".length) ??
+    "custom";
+}
+
+function channelProviderForInput(input: Pick<RegisterAgentInput, "tags" | "meta">): string {
+  return stringValue(input.meta?.provider) ??
+    stringValue(input.meta?.channelType) ??
+    stringValue(input.meta?.transport) ??
+    (input.tags ?? []).find((tag) => tag.startsWith("channel:"))?.slice("channel:".length) ??
+    "custom";
+}
+
+export function channelAccountIdForAgent(agent: AgentCard, provider: string): string {
+  const accountId = stringValue(agent.meta?.accountId);
+  if (accountId) return accountId;
+  const prefix = `${provider}:`;
+  return agent.id.startsWith(prefix) ? agent.id.slice(prefix.length) : agent.id;
+}
+
+function channelAccountIdForInput(input: Pick<RegisterAgentInput, "id" | "meta">, provider: string): string {
+  const accountId = stringValue(input.meta?.accountId);
+  if (accountId) return accountId;
+  const prefix = `${provider}:`;
+  return input.id.startsWith(prefix) ? input.id.slice(prefix.length) : input.id;
+}
+
+export function expectedChannelAgentId(input: Pick<RegisterAgentInput, "id" | "tags" | "meta">): string {
+  const provider = channelProviderForInput(input);
+  const accountId = channelAccountIdForInput(input, provider);
+  return `${provider}:${accountId}`;
+}

package/src/db/channels.ts

@@ -15,10 +15,12 @@ import {
 } from "../contracts";
 import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
 import { matchAgents } from "../agent-ref";
-import { getAgent, listAgents, parseStringArray } from "./agents.ts";
+import { isDeliveryAgent } from "./agent-predicates.ts";
+import { channelAccountIdForAgent, channelProviderForAgent, expectedChannelAgentId } from "./channel-identity.ts";
 import { ValidationError, getDb } from "./connection.ts";
-import { isDeliveryAgent } from "./delivery.ts";
-import { runningAgentForPolicy } from "./messages.ts";
+import { rowToAgent } from "./mappers.ts";
+import { runningAgentForPolicy } from "./policy-runtime.ts";
+import { parseStringArray } from "./shared.ts";
 import type {
   AgentCard,
   ActivityEvent,
@@ -82,7 +84,9 @@ import type {
   WorkspaceStatus,
 } from "../types";
 
-export function rowToChannelBinding(row: any): ChannelBinding {
+export { channelProviderForAgent, expectedChannelAgentId } from "./channel-identity.ts";
+
+function rowToChannelBinding(row: any): ChannelBinding {
   const target = row.target_type === "broadcast"
     ? { type: "broadcast" } as ChannelRouteTarget
     : { type: row.target_type, id: row.target_id } as ChannelRouteTarget;
@@ -105,7 +109,7 @@ export function rowToChannelBinding(row: any): ChannelBinding {
   return binding;
 }
 
-export function bindingTargetToLegacyTarget(target: ChannelRouteTarget): string {
+function bindingTargetToLegacyTarget(target: ChannelRouteTarget): string {
   if (target.type === "agent") return target.id;
   if (target.type === "label") return `label:${target.id}`;
   if (target.type === "team") return `team:${target.id}`;
@@ -118,7 +122,7 @@ export function bindingTargetToLegacyTarget(target: ChannelRouteTarget): string
   return "";
 }
 
-export function configuredChannelsForAgent(agent: AgentCard): string[] {
+function configuredChannelsForAgent(agent: AgentCard): string[] {
   const channels = agent.meta?.channels;
   if (!Array.isArray(channels)) return [];
   return channels
@@ -127,7 +131,7 @@ export function configuredChannelsForAgent(agent: AgentCard): string[] {
     .filter((item) => item.length > 0);
 }
 
-export function channelEntryMatches(channelId: string, entry: string): boolean {
+function channelEntryMatches(channelId: string, entry: string): boolean {
   const normalized = entry.trim();
   if (!normalized) return false;
   if (normalized === channelId) return true;
@@ -135,27 +139,36 @@ export function channelEntryMatches(channelId: string, entry: string): boolean {
   return channelId.startsWith(`${normalized}:`);
 }
 
-export function agentCanServeChannel(agent: AgentCard, channelId?: string): boolean {
+function agentCanServeChannel(agent: AgentCard, channelId?: string): boolean {
   if (!channelId) return true;
   const channels = configuredChannelsForAgent(agent);
   if (channels.length === 0) return true;
   return channels.some((entry) => channelEntryMatches(channelId, entry));
 }
 
-export function channelTargetMatches(target: ChannelRouteTarget, channelId?: string): AgentCard[] {
-  const candidates = listAgents().filter((agent) => (
+function getChannelAgent(id: string): AgentCard | null {
+  const row = getDb().query("SELECT * FROM agents WHERE id = ?").get(id) as any;
+  return row ? rowToAgent(row) : null;
+}
+
+function listChannelAgents(): AgentCard[] {
+  return (getDb().query("SELECT * FROM agents ORDER BY last_seen DESC").all() as any[]).map(rowToAgent);
+}
+
+function channelTargetMatches(target: ChannelRouteTarget, channelId?: string): AgentCard[] {
+  const candidates = listChannelAgents().filter((agent) => (
     agent.id !== "user" &&
     agent.id !== "system" &&
     agent.kind !== "channel" &&
     agent.meta?.kind !== "channel"
   ));
   if (target.type === "agent" || target.type === "orchestrator") {
-    const agent = getAgent(target.id);
+    const agent = getChannelAgent(target.id);
     return agent ? [agent] : [];
   }
   if (target.type === "policy") {
     const agentId = runningAgentForPolicy(target.id);
-    const agent = agentId ? getAgent(agentId) : null;
+    const agent = agentId ? getChannelAgent(agentId) : null;
     return agent ? [agent] : [];
   }
   const channelCandidates = candidates.filter((agent) => agentCanServeChannel(agent, channelId));
@@ -168,15 +181,15 @@ export function channelTargetMatches(target: ChannelRouteTarget, channelId?: str
   return [];
 }
 
-export function poolSelectorMatches(selector: string, candidates: AgentCard[]): AgentCard[] {
+function poolSelectorMatches(selector: string, candidates: AgentCard[]): AgentCard[] {
   if (selector.startsWith("label:")) return candidates.filter((a) => a.label === selector.slice("label:".length));
   if (selector.startsWith("tag:")) return candidates.filter((a) => a.tags.includes(selector.slice("tag:".length)));
   if (selector.startsWith("cap:")) return candidates.filter((a) => a.capabilities.includes(selector.slice("cap:".length)));
-  const agent = getAgent(selector);
+  const agent = getChannelAgent(selector);
   return agent ? [agent] : [];
 }
 
-export function channelTargetMatchSnapshot(agent: AgentCard): ChannelTargetHealth["matches"][number] {
+function channelTargetMatchSnapshot(agent: AgentCard): ChannelTargetHealth["matches"][number] {
   return {
     id: agent.id,
     name: agent.name,
@@ -189,15 +202,15 @@ export function channelTargetMatchSnapshot(agent: AgentCard): ChannelTargetHealt
   };
 }
 
-export function isHealthyChannelTarget(agent: AgentCard, now: number): boolean {
+function isHealthyChannelTarget(agent: AgentCard, now: number): boolean {
   return isDeliveryAgent(agent) && agent.ready && agent.lastSeen > now - STALE_TTL_MS;
 }
 
-export function describeTarget(target: ChannelRouteTarget): string {
+function describeTarget(target: ChannelRouteTarget): string {
   return bindingTargetToLegacyTarget(target);
 }
 
-export function channelTargetHealth(binding: ChannelBinding, now: number = Date.now()): ChannelTargetHealth {
+function channelTargetHealth(binding: ChannelBinding, now: number = Date.now()): ChannelTargetHealth {
   const target = binding.target;
   const targetLabel = describeTarget(target);
   const matches = channelTargetMatches(target, binding.channelId);
@@ -209,7 +222,7 @@ export function channelTargetHealth(binding: ChannelBinding, now: number = Date.
       if (matches.length === 0) return { status: "error", detail: `Pool ${targetLabel}: no eligible agents`, target, matches: [] };
       return { status: "error", detail: `Pool ${targetLabel}: ${healthyEligibles.length} eligible but slot unclaimed`, target, matches: snapshots };
     }
-    const holder = getAgent(binding.poolAgentId);
+    const holder = getChannelAgent(binding.poolAgentId);
     if (!holder || holder.status === "offline") {
       return { status: "error", detail: `Pool ${targetLabel}: holder ${binding.poolAgentId} is offline`, target, matches: snapshots };
     }
@@ -271,7 +284,7 @@ export function channelTargetHealth(binding: ChannelBinding, now: number = Date.
   };
 }
 
-export function rowToChannelSummary(row: any): ChannelSummary {
+function rowToChannelSummary(row: any): ChannelSummary {
   const binding = row.binding_id ? rowToChannelBinding({
     id: row.binding_id,
     channel_id: row.id,
@@ -309,44 +322,7 @@ export function rowToChannelSummary(row: any): ChannelSummary {
   };
 }
 
-
-export function channelProviderForAgent(agent: AgentCard): string {
-  return stringValue(agent.meta?.provider) ??
-    stringValue(agent.meta?.channelType) ??
-    stringValue(agent.meta?.transport) ??
-    agent.tags.find((tag) => tag.startsWith("channel:"))?.slice("channel:".length) ??
-    "custom";
-}
-
-export function channelProviderForInput(input: Pick<RegisterAgentInput, "tags" | "meta">): string {
-  return stringValue(input.meta?.provider) ??
-    stringValue(input.meta?.channelType) ??
-    stringValue(input.meta?.transport) ??
-    (input.tags ?? []).find((tag) => tag.startsWith("channel:"))?.slice("channel:".length) ??
-    "custom";
-}
-
-export function channelAccountIdForAgent(agent: AgentCard, provider: string): string {
-  const accountId = stringValue(agent.meta?.accountId);
-  if (accountId) return accountId;
-  const prefix = `${provider}:`;
-  return agent.id.startsWith(prefix) ? agent.id.slice(prefix.length) : agent.id;
-}
-
-export function channelAccountIdForInput(input: Pick<RegisterAgentInput, "id" | "meta">, provider: string): string {
-  const accountId = stringValue(input.meta?.accountId);
-  if (accountId) return accountId;
-  const prefix = `${provider}:`;
-  return input.id.startsWith(prefix) ? input.id.slice(prefix.length) : input.id;
-}
-
-export function expectedChannelAgentId(input: Pick<RegisterAgentInput, "id" | "tags" | "meta">): string {
-  const provider = channelProviderForInput(input);
-  const accountId = channelAccountIdForInput(input, provider);
-  return `${provider}:${accountId}`;
-}
-
-export function channelDirectionForAgent(agent: AgentCard): ChannelSummary["direction"] {
+function channelDirectionForAgent(agent: AgentCard): ChannelSummary["direction"] {
   const direction = stringValue(agent.meta?.direction);
   return direction === "inbound" || direction === "outbound" || direction === "bidirectional" ? direction : "bidirectional";
 }
@@ -497,7 +473,7 @@ export function upsertChannelBinding(input: {
   return rowToChannelBinding(row);
 }
 
-export interface PoolBindingChange {
+interface PoolBindingChange {
   bindingId: string;
   channelId: string;
   previousAgentId: string | null;
@@ -517,7 +493,7 @@ export function evaluatePoolBindings(now: number = Date.now()): PoolBindingChang
 
     let holderValid = false;
     if (currentAgentId) {
-      const holder = getAgent(currentAgentId);
+      const holder = getChannelAgent(currentAgentId);
       if (holder && holder.status !== "offline" && holder.ready && holder.lastSeen > now - STALE_TTL_MS && agentCanServeChannel(holder, channelId)) {
         if (currentEpoch === null || holder.epoch === currentEpoch) {
           getDb().query("UPDATE channel_bindings SET pool_claim_expires_at = ? WHERE id = ?")
@@ -534,7 +510,7 @@ export function evaluatePoolBindings(now: number = Date.now()): PoolBindingChang
     }
 
     if (!holderValid) {
-      const candidates = listAgents().filter((a) =>
+      const candidates = listChannelAgents().filter((a) =>
         a.id !== "user" && a.id !== "system" && a.kind !== "channel" && a.meta?.kind !== "channel"
       );
       const eligible = poolSelectorMatches(selector, candidates)

package/src/db/continuation-archives.ts

@@ -2,7 +2,7 @@ import { MAX_BODY_BYTES } from "../config";
 import { getContinuationEnvelope } from "./continuations.ts";
 import { getDb, ValidationError } from "./connection.ts";
 
-export interface ContinuationArchive {
+interface ContinuationArchive {
   id: number;
   ref: string;
   agentId: string;
@@ -11,7 +11,7 @@ export interface ContinuationArchive {
   createdAt: number;
 }
 
-export interface ContinuationArchiveSearchResult extends ContinuationArchive {
+interface ContinuationArchiveSearchResult extends ContinuationArchive {
   score: number | null;
   searchMode: "fts5" | "like";
 }
@@ -80,7 +80,7 @@ export function archiveContinuationSegment(input: {
   return getContinuationArchive(Number(info.lastInsertRowid))!;
 }
 
-export function getContinuationArchive(id: number): ContinuationArchive | null {
+function getContinuationArchive(id: number): ContinuationArchive | null {
   const row = getDb().query("SELECT * FROM continuation_archives WHERE id = ?").get(id) as ContinuationArchiveRow | undefined;
   return row ? rowToArchive(row) : null;
 }
@@ -115,7 +115,7 @@ export function searchContinuationArchives(input: {
   return searchContinuationArchivesLike(agentId, query, limit);
 }
 
-export function continuationArchiveSearchMode(): "fts5" | "like" {
+function continuationArchiveSearchMode(): "fts5" | "like" {
   if (process.env.AGENT_RELAY_DISABLE_CONTINUATION_ARCHIVE_FTS === "1") return "like";
   const row = getDb().query(`
     SELECT 1 FROM sqlite_master

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,
@@ -15,10 +16,11 @@ import {
 import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
 import { matchAgents } from "../agent-ref";
 import { getAgent, listAgents } from "./agents.ts";
-import { channelProviderForAgent } from "./channels.ts";
+import { isDeliveryAgent } from "./agent-predicates.ts";
+import { channelProviderForAgent } from "./channel-identity.ts";
 import { getDb } from "./connection.ts";
 import { MSG_SELECT, rowToMessage, rowToMessageDeliveryAttempt } from "./mappers.ts";
-import { getMessage } from "./messages.ts";
+import { getMessage } from "./message-queries.ts";
 import type {
   AgentCard,
   ActivityEvent,
@@ -82,7 +84,7 @@ import type {
   WorkspaceStatus,
 } from "../types";
 
-export function queueDepthLimit(target: string): number {
+function queueDepthLimit(target: string): number {
   const row = getDb().query("SELECT value FROM config WHERE namespace = 'system' AND key = 'message-queue'").get() as { value?: string } | undefined;
   const parsed = row?.value ? parseJson<Record<string, unknown>>(row.value, {}) : {};
   const perTarget = parsed?.maxDepthPerTarget;
@@ -123,13 +125,7 @@ export function enforceQueueLimit(target: string): void {
   })();
 }
 
-export function isDeliveryAgent(agent: AgentCard): boolean {
-  return agent.status !== "offline" &&
-    agent.id !== "user" &&
-    agent.id !== "system" &&
-    agent.kind !== "channel" &&
-    agent.meta?.kind !== "channel";
-}
+export { isDeliveryAgent } from "./agent-predicates.ts";
 
 export function isChannelAgentId(agentId: string): boolean {
   const agent = getAgent(agentId);
@@ -156,27 +152,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 [];
 }
@@ -192,7 +237,7 @@ export function getMessageDeliveryAttempts(messageId: number, limit = 50): Messa
   `).all(messageId, safeLimit) as any[]).map(rowToMessageDeliveryAttempt);
 }
 
-export function insertMessageDeliveryAttempt(
+function insertMessageDeliveryAttempt(
   messageId: number,
   input: {
     agentId?: string;
@@ -219,7 +264,7 @@ export function insertMessageDeliveryAttempt(
   );
 }
 
-export function setMessageDeliveryState(
+function setMessageDeliveryState(
   messageId: number,
   input: {
     status: MessageDeliveryStatus;