agent-relay-server 0.20.0 → 0.22.0

package/src/db.ts

@@ -74,6 +74,7 @@ import type {
   WorkspaceStatus,
 } from "./types";
 import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "./config";
+import { matchAgents } from "./agent-ref";
 
 let db: Database;
 const CONTEXT_SNAPSHOT_DEBOUNCE_MS = 60_000;
@@ -210,6 +211,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
       provider_capabilities TEXT,
       context_state TEXT,
       meta TEXT NOT NULL DEFAULT '{}',
+      spawned_by TEXT,
       last_seen INTEGER NOT NULL,
       created_at INTEGER NOT NULL
     );
@@ -1047,6 +1049,9 @@ export function initDb(path: string = "agent-relay.db"): Database {
   if (!agentColNames.includes("context_state")) {
     db.run("ALTER TABLE agents ADD COLUMN context_state TEXT");
   }
+  if (!agentColNames.includes("spawned_by")) {
+    db.run("ALTER TABLE agents ADD COLUMN spawned_by TEXT");
+  }
   db.run(`
     CREATE TABLE IF NOT EXISTS context_snapshots (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1245,6 +1250,7 @@ function rowToAgent(row: any): AgentCard {
     providerCapabilities: parseJson<ProviderCapabilities | undefined>(row.provider_capabilities, undefined),
     context: parseJson<ContextState | undefined>(row.context_state, undefined),
     meta: parseJson(row.meta, {}),
+    spawnedBy: row.spawned_by ?? undefined,
     lastSeen: row.last_seen,
     createdAt: row.created_at,
   };
@@ -1747,8 +1753,8 @@ export function upsertAgent(input: RegisterAgentInput): AgentCard {
   const readyProvided = Object.prototype.hasOwnProperty.call(input, "ready");
   const instanceProvided = Boolean(input.instanceId);
   const stmt = db.query(`
-    INSERT INTO agents (id, name, kind, label, tags, machine, rig, capabilities, ready, status, instance_id, epoch, provider_capabilities, context_state, meta, last_seen, created_at)
-    VALUES ($id, $name, $kind, $label, $tags, $machine, $rig, $capabilities, $ready, $status, $instanceId, $initialEpoch, $providerCapabilities, $contextState, $meta, $now, $now)
+    INSERT INTO agents (id, name, kind, label, tags, machine, rig, capabilities, ready, status, instance_id, epoch, provider_capabilities, context_state, meta, spawned_by, last_seen, created_at)
+    VALUES ($id, $name, $kind, $label, $tags, $machine, $rig, $capabilities, $ready, $status, $instanceId, $initialEpoch, $providerCapabilities, $contextState, $meta, $spawnedBy, $now, $now)
     ON CONFLICT(id) DO UPDATE SET
       name = $name,
       kind = $kind,
@@ -1767,6 +1773,7 @@ export function upsertAgent(input: RegisterAgentInput): AgentCard {
       provider_capabilities = coalesce($providerCapabilities, agents.provider_capabilities),
       context_state = coalesce($contextState, agents.context_state),
       meta = $meta,
+      spawned_by = coalesce($spawnedBy, agents.spawned_by),
       last_seen = $now
   `);
 
@@ -1789,6 +1796,7 @@ export function upsertAgent(input: RegisterAgentInput): AgentCard {
     $providerCapabilities: input.providerCapabilities ? JSON.stringify(input.providerCapabilities) : null,
     $contextState: input.context ? JSON.stringify(input.context) : null,
     $meta: JSON.stringify(input.meta ?? {}),
+    $spawnedBy: input.spawnedBy ?? null,
     $now: now,
   });
   if (input.context) recordContextSnapshot(input.id, input.context, now);
@@ -1858,6 +1866,106 @@ export function listAgents(filter?: {
   return (db.query(sql).all(...params) as any[]).map(rowToAgent);
 }
 
+export interface AgentSearchFilter {
+  /** Substring match on label OR name (case-insensitive). */
+  label?: string;
+  /** One or more capabilities (OR within the field), via json_each(capabilities). */
+  capability?: string | string[];
+  /** One or more tags (OR within the field), via json_each(tags). */
+  tag?: string | string[];
+  /** Real model provider — providerCapabilities.model.provider (e.g. "claude", "codex"). */
+  provider?: string | string[];
+  machine?: string | string[];
+  /** provider/orchestrator/channel/etc. */
+  kind?: string | string[];
+  /** Specific status(es), the "running" shorthand (live + ready + fresh), or "all". */
+  status?: string | string[];
+  /** Exact parent agent id — backs the `spawnedBy:` / `spawnedBy:me` fleet filter (#221). */
+  spawnedBy?: string;
+}
+
+export interface AgentSearchSort {
+  sortBy?: "lastActive" | "created" | "label";
+  order?: "asc" | "desc";
+  limit?: number;
+}
+
+const AGENT_SEARCH_MAX_LIMIT = 200;
+
+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);
+}
+
+// Unified fleet search: all filters optional and AND-combined; array values OR within a
+// field. One parameterized query (no JS post-filter, no injection). Backs relay_find_agents
+// (#219) and the running-only relay_agent_status default (#218). "running" mirrors the
+// canonical liveness predicate (see db.ts delivery/steward checks + isAgentOnline).
+export function searchAgents(filter: AgentSearchFilter = {}, sort: AgentSearchSort = {}): AgentCard[] {
+  const clauses: string[] = ["1=1"];
+  const params: any[] = [];
+  const inList = (column: string, values: string[]) => {
+    clauses.push(`${column} IN (${values.map(() => "?").join(",")})`);
+    params.push(...values);
+  };
+
+  if (filter.label) {
+    clauses.push("(label LIKE ? OR name LIKE ?)");
+    params.push(`%${filter.label}%`, `%${filter.label}%`);
+  }
+  const caps = searchValues(filter.capability);
+  if (caps.length) {
+    clauses.push(`EXISTS (SELECT 1 FROM json_each(capabilities) WHERE value IN (${caps.map(() => "?").join(",")}))`);
+    params.push(...caps);
+  }
+  const tags = searchValues(filter.tag);
+  if (tags.length) {
+    clauses.push(`EXISTS (SELECT 1 FROM json_each(tags) WHERE value IN (${tags.map(() => "?").join(",")}))`);
+    params.push(...tags);
+  }
+  const providers = searchValues(filter.provider);
+  if (providers.length) {
+    clauses.push(`json_extract(provider_capabilities, '$.model.provider') IN (${providers.map(() => "?").join(",")})`);
+    params.push(...providers);
+  }
+  const machines = searchValues(filter.machine);
+  if (machines.length) inList("machine", machines);
+  const kinds = searchValues(filter.kind);
+  if (kinds.length) inList("kind", kinds);
+  if (filter.spawnedBy) {
+    clauses.push("spawned_by = ?");
+    params.push(filter.spawnedBy);
+  }
+
+  const statuses = searchValues(filter.status);
+  if (!statuses.includes("all")) {
+    if (statuses.includes("running")) {
+      clauses.push("status NOT IN ('offline', 'stale') AND ready = 1 AND last_seen > ?");
+      params.push(Date.now() - STALE_TTL_MS);
+    }
+    const explicit = statuses.filter((s) => s !== "running" && s !== "all");
+    if (explicit.length) inList("status", explicit);
+  }
+
+  const sortColumn = sort.sortBy === "created" ? "created_at" : sort.sortBy === "label" ? "label COLLATE NOCASE" : "last_seen";
+  const order = sort.order === "asc" ? "ASC" : "DESC";
+  const limit = Math.max(1, Math.min(sort.limit ?? 50, AGENT_SEARCH_MAX_LIMIT));
+  params.push(limit);
+
+  const sql = `SELECT * FROM agents WHERE ${clauses.join(" AND ")} ORDER BY ${sortColumn} ${order} LIMIT ?`;
+  return (db.query(sql).all(...params) as any[]).map(rowToAgent);
+}
+
+// Count of a parent's currently-LIVE children — the spawn quota numerator (#221). "Live"
+// mirrors the running predicate (not offline/stale, ready, fresh); a child that exits frees
+// a slot. Uncapped COUNT (unlike searchAgents' LIMIT) so the quota is exact at any fleet size.
+export function countLiveSpawnedAgents(parentId: string, now: number = Date.now()): number {
+  const row = db.query(
+    "SELECT count(*) AS n FROM agents WHERE spawned_by = ? AND status NOT IN ('offline', 'stale') AND ready = 1 AND last_seen > ?",
+  ).get(parentId, now - STALE_TTL_MS) as { n: number };
+  return row.n;
+}
+
 export function setStatus(id: string, status: AgentCard["status"], guard?: AgentSessionGuard): boolean {
   if (!validateAgentSession(id, guard).ok) return false;
   const now = Date.now();
@@ -2350,17 +2458,6 @@ export function pruneOfflineAgents(maxOfflineMs: number = DAY_MS): string[] {
   })();
 }
 
-export function findAgentsByCapability(capability: string, onlineOnly = true): AgentCard[] {
-  let sql = `SELECT * FROM agents WHERE EXISTS (SELECT 1 FROM json_each(capabilities) WHERE value = ?)`;
-  const params: any[] = [capability];
-  if (onlineOnly) {
-    sql += ` AND status != 'offline' AND last_seen > ?`;
-    params.push(Date.now() - STALE_TTL_MS);
-  }
-  sql += " ORDER BY last_seen DESC";
-  return (db.query(sql).all(...params) as any[]).map(rowToAgent);
-}
-
 export function deleteAgent(id: string): { ok: boolean; error?: string } {
   if (id === "user" || id === "system") {
     return { ok: false, error: "built-in agent cannot be deleted" };
@@ -3023,21 +3120,6 @@ function pairPeer(pair: PairSession, agentId: string): string {
   return pair.requesterId === agentId ? pair.targetId : pair.requesterId;
 }
 
-function agentMatchesPairTarget(agent: AgentCard, target: string): boolean {
-  if (target.startsWith("id:")) return agent.id === target.slice(3);
-  if (target.startsWith("label:")) return agent.label === target.slice(6);
-  if (target.startsWith("tag:")) return agent.tags.includes(target.slice(4));
-  if (target.startsWith("cap:")) return agent.capabilities.includes(target.slice(4));
-  if (target.startsWith("rig:")) return agent.rig === target.slice(4);
-  if (target.startsWith("machine:")) return agent.machine === target.slice(8);
-  return agent.id === target ||
-    agent.label === target ||
-    agent.tags.includes(target) ||
-    agent.capabilities.includes(target) ||
-    agent.rig === target ||
-    agent.name === target;
-}
-
 function resolvePairTarget(target: string, requesterId: string): {
   ok: true;
   agent: AgentCard;
@@ -3048,7 +3130,7 @@ function resolvePairTarget(target: string, requesterId: string): {
   matches?: AgentCard[];
   busy?: Array<{ agent: AgentCard; pair: PairSession }>;
 } {
-  const matches = listAgents().filter((agent) => agent.id !== requesterId && agentMatchesPairTarget(agent, target));
+  const matches = matchAgents(target, listAgents(), { excludeId: requesterId });
   if (matches.length === 0) return { ok: false, code: "not_found", error: `no agent matches ${target}` };
 
   const live = matches.filter((agent) => agent.status !== "offline" && agent.ready);

package/src/maintenance.ts

@@ -34,6 +34,7 @@ import {
 import type { WorkspaceMergePreview, WorkspaceRecord, WorkspaceStatus } from "./types";
 import { requestWorkspaceMerge } from "./workspace-merge";
 import { workspaceActiveClaim } from "./workspace-claim";
+import { TERMINAL_WORKSPACE_STATUSES } from "./workspace-phase";
 import { errMessage, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 import { getStewardConfig } from "./config-store";
 import { ensureRepoSteward } from "./steward";
@@ -86,7 +87,6 @@ const STRANDABLE_STATUSES = new Set<WorkspaceStatus>(["review_requested", "confl
 // Live statuses worth scanning. Terminal (cleaned/merged/abandoned) and
 // in-flight (cleanup_requested) states are skipped.
 const CONFLICT_SCAN_STATUSES = new Set<WorkspaceStatus>(["active", "ready", "review_requested", "merge_planned", "conflict"]);
-const TERMINAL_WORKSPACE_STATUSES = new Set<WorkspaceStatus>(["cleaned", "merged", "abandoned"]);
 // In-flight merge statuses that should reconcile to `merged` once the host
 // reports the branch's work has landed in base (squash/cherry-pick, or a merged
 // PR). Excludes active/ready: an agent still working may have landed an early
@@ -695,7 +695,10 @@ async function autoMergeCleanFastForwards(): Promise<Record<string, unknown>> {
     // base, and mergeRebaseFf rebases then aborts-to-conflict on a real replay
     // conflict, so a too-optimistic prediction degrades safely to review_requested.
     // Only a predicted conflict (true) or unknown state (undefined) goes to the steward.
-    const canLand = p.conflict === false && ahead > 0;
+    // A no-op (#230) — nothing to land (ahead=0, clean) — is also landable: the host
+    // resolves it to a terminal `merged` status, draining the queue instead of waking
+    // the steward every sweep for a workspace with no work.
+    const canLand = p.noop === true || (p.conflict === false && ahead > 0);
     if (!canLand) {
       leftForSteward.push(ws.id);
       if (stewardEnabled) {
@@ -716,8 +719,10 @@ async function autoMergeCleanFastForwards(): Promise<Record<string, unknown>> {
     createActivityEvent({
       clientId: `workspace-auto-merge-${ws.id}-${Date.now()}`,
       kind: "state",
-      title: behind > 0 ? "Workspace auto-merging (rebase)" : "Workspace auto-merging (clean fast-forward)",
-      body: `${ws.branch ?? ws.id} → ${p.baseRef ?? "base"} (${ahead} ahead${behind > 0 ? `, ${behind} behind — rebasing` : ", clean"})`,
+      title: p.noop ? "Workspace auto-resolving (no work to merge)" : behind > 0 ? "Workspace auto-merging (rebase)" : "Workspace auto-merging (clean fast-forward)",
+      body: p.noop
+        ? `${ws.branch ?? ws.id} → ${p.baseRef ?? "base"} (nothing to land — resolving to merged)`
+        : `${ws.branch ?? ws.id} → ${p.baseRef ?? "base"} (${ahead} ahead${behind > 0 ? `, ${behind} behind — rebasing` : ", clean"})`,
       meta: ws.branch ?? ws.id,
       icon: "ti-git-merge",
       view: "orchestrators",

package/src/managed-policy.ts

@@ -1,4 +1,4 @@
-import { getAgentProfile } from "./config-store";
+import { getAgentProfile, spawnGrantForProfile } from "./config-store";
 import { runnerRuntimeTokenEnv } from "./runtime-tokens";
 import { buildSpawnCommand, resolveSpawnModelParams } from "./spawn-command";
 import type { SpawnPolicy, WorkspaceMode } from "./types";
@@ -29,6 +29,7 @@ export function buildManagedSpawnParams(policy: SpawnPolicy, requestId: string,
   const providerArgs = managedPolicyProviderArgs(policy);
   const prompt = managedPolicyLaunchPrompt(policy);
   const agentProfile = policy.profile ? getAgentProfile(policy.profile)?.value : undefined;
+  const grant = spawnGrantForProfile(policy.profile);
   return buildSpawnCommand({
     provider: policy.provider,
     cwd: policy.cwd,
@@ -55,6 +56,8 @@ export function buildManagedSpawnParams(policy: SpawnPolicy, requestId: string,
       policyName: policy.name,
       spawnRequestId: requestId,
       createdBy: ctx.createdBy,
+      canSpawn: grant.canSpawn,
+      maxSpawnedAgents: grant.maxSpawnedAgents,
     }),
     requestedBy: ctx.createdBy,
     requestedAt: ctx.requestedAt ?? Date.now(),