agent-relay-server 0.50.0 → 0.52.0

package/src/db/plans.ts

@@ -143,6 +143,17 @@ export function getPlanByTeam(teamId: string, channel?: string): Plan | null {
   return row ? rowToPlan(row) : null;
 }
 
+export function listPlansWithBoundOwner(agentId: string): Plan[] {
+  const rows = getDb().query(`
+    SELECT DISTINCT p.*
+    FROM plans p, json_each(p.nodes) node
+    WHERE json_extract(node.value, '$.statusSource') = 'bound'
+      AND json_extract(node.value, '$.ownerRef.agentId') = ?
+    ORDER BY p.updated_at DESC, p.id ASC
+  `).all(agentId) as PlanRow[];
+  return rows.map(rowToPlan);
+}
+
 export function replacePlan(input: Plan, changedBy?: string): Plan {
   const existing = getPlan(input.id);
   if (!existing) throw new ValidationError(`plan ${input.id} not found`);

package/src/db/schema.ts

@@ -104,7 +104,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
       epoch INTEGER NOT NULL DEFAULT 0,
       provider_capabilities TEXT,
       context_state TEXT,
-      meta TEXT NOT NULL DEFAULT '{}',
+      meta TEXT NOT NULL DEFAULT '{}', lifecycle TEXT NOT NULL DEFAULT 'persistent',
       spawned_by TEXT,
       team_id TEXT,
       last_seen INTEGER NOT NULL,

package/src/db/teams.ts

@@ -31,6 +31,46 @@ export interface TeamDissolveInput {
   landsClean?: boolean;
 }
 
+type OutcomeBucket = NonNullable<Team["outcomeStatus"]> | "unknown";
+
+interface TeamOutcomeRow {
+  id: string;
+  title: string | null;
+  outcome_status: Team["outcomeStatus"] | null;
+  outcome_summary: string | null;
+  composition: string | null;
+  wall_clock_ms: number | null;
+  dissolved_at: number | null;
+}
+
+export interface TeamOutcomeCompositionAggregate {
+  shape: string;
+  members: Array<{ provider: string; model: string }>;
+  count: number;
+  successCount: number;
+  successRate: number;
+  avgWallClockMs: number | null;
+}
+
+export interface TeamOutcomeRecent {
+  id: string;
+  title?: string;
+  outcome: Team["outcomeStatus"] | null;
+  outcomeSummary?: string;
+  durationMs: number | null;
+  memberCount: number;
+  dissolvedAt: number | null;
+}
+
+export interface TeamOutcomeAggregates {
+  totals: {
+    total: number;
+    byOutcomeStatus: Record<OutcomeBucket, number>;
+  };
+  compositionShapes: TeamOutcomeCompositionAggregate[];
+  recent: TeamOutcomeRecent[];
+}
+
 export function teamId(): string {
   return `team_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
 }
@@ -153,6 +193,86 @@ function compositionForMembers(members: AgentCard[]): string {
   })));
 }
 
+function compositionShape(composition: string | null): { key: string; members: Array<{ provider: string; model: string }>; memberCount: number } {
+  if (!composition) return { key: "empty", members: [], memberCount: 0 };
+  try {
+    const parsed = JSON.parse(composition) as unknown;
+    if (!Array.isArray(parsed)) return { key: "unknown/unknown", members: [{ provider: "unknown", model: "unknown" }], memberCount: 0 };
+    const seen = new Map<string, { provider: string; model: string }>();
+    for (const raw of parsed) {
+      const member = raw && typeof raw === "object" ? raw as Record<string, unknown> : {};
+      const provider = typeof member.provider === "string" && member.provider.trim() ? member.provider.trim() : "unknown";
+      const model = typeof member.model === "string" && member.model.trim() ? member.model.trim() : "unknown";
+      seen.set(`${provider}/${model}`, { provider, model });
+    }
+    const members = [...seen.values()].sort((a, b) => a.provider.localeCompare(b.provider) || a.model.localeCompare(b.model));
+    return { key: members.length ? members.map((member) => `${member.provider}/${member.model}`).join(", ") : "empty", members, memberCount: parsed.length };
+  } catch {
+    return { key: "unknown/unknown", members: [{ provider: "unknown", model: "unknown" }], memberCount: 0 };
+  }
+}
+
+export function getTeamOutcomeAggregates(input: { recentLimit?: number } = {}): TeamOutcomeAggregates {
+  const recentLimit = Math.max(1, Math.min(50, input.recentLimit ?? 12));
+  const rows = getDb().query(`
+    SELECT id, title, outcome_status, outcome_summary, composition, wall_clock_ms, dissolved_at
+    FROM teams
+    WHERE status = 'dissolved'
+    ORDER BY dissolved_at DESC, updated_at DESC, id DESC
+  `).all() as TeamOutcomeRow[];
+
+  const byOutcomeStatus: Record<OutcomeBucket, number> = { success: 0, partial: 0, failed: 0, unknown: 0 };
+  const byShape = new Map<string, {
+    members: Array<{ provider: string; model: string }>;
+    count: number;
+    successCount: number;
+    durationTotal: number;
+    durationCount: number;
+  }>();
+  const recent: TeamOutcomeRecent[] = [];
+
+  for (const row of rows) {
+    byOutcomeStatus[row.outcome_status ?? "unknown"] += 1;
+    const shape = compositionShape(row.composition);
+    const aggregate = byShape.get(shape.key) ?? { members: shape.members, count: 0, successCount: 0, durationTotal: 0, durationCount: 0 };
+    aggregate.count += 1;
+    if (row.outcome_status === "success") aggregate.successCount += 1;
+    if (row.wall_clock_ms !== null) {
+      aggregate.durationTotal += row.wall_clock_ms;
+      aggregate.durationCount += 1;
+    }
+    byShape.set(shape.key, aggregate);
+    if (recent.length < recentLimit) {
+      recent.push({
+        id: row.id,
+        ...(row.title ? { title: row.title } : {}),
+        outcome: row.outcome_status,
+        ...(row.outcome_summary ? { outcomeSummary: row.outcome_summary } : {}),
+        durationMs: row.wall_clock_ms,
+        memberCount: shape.memberCount,
+        dissolvedAt: row.dissolved_at,
+      });
+    }
+  }
+
+  const compositionShapes = [...byShape.entries()]
+    .map(([shape, aggregate]) => ({
+      shape,
+      members: aggregate.members,
+      count: aggregate.count,
+      successCount: aggregate.successCount,
+      successRate: aggregate.count === 0 ? 0 : aggregate.successCount / aggregate.count,
+      avgWallClockMs: aggregate.durationCount === 0 ? null : Math.round(aggregate.durationTotal / aggregate.durationCount),
+    }))
+    .sort((a, b) => b.count - a.count || b.successRate - a.successRate || a.shape.localeCompare(b.shape));
+
+  return {
+    totals: { total: rows.length, byOutcomeStatus },
+    compositionShapes,
+    recent,
+  };
+}
+
 export function dissolveTeam(teamId: string, input: TeamDissolveInput = {}): Team {
   const existing = getTeam(teamId);
   if (!existing) throw new ValidationError(`team ${teamId} not found`);

package/src/index.ts

@@ -10,6 +10,7 @@ import { getLifecycleManager } from "./lifecycle-manager";
 import { getCompactionWatch } from "./compaction-watch";
 import { getConfig, setConfig } from "./config-store";
 import { startConnectorStatusPoller } from "./connectors";
+import { startPlanLiveBindings } from "./services/plan-live-bindings";
 import { resolve, sep } from "path";
 import { gzipSync, brotliCompressSync, constants as zlibConstants } from "node:zlib";
 import {
@@ -73,6 +74,7 @@ function startServer(): void {
 
   assertSafeNetworkConfig(HOST);
   initDb(DB_PATH);
+  startPlanLiveBindings();
   getLifecycleManager().start();
   getCompactionWatch().start();
   reconcileRelayVersion();

package/src/maintenance.ts

@@ -62,6 +62,7 @@ import {
 import { notifySystemMessage } from "./notify";
 import { pruneExpiredTokenRecords } from "./token-db";
 import { dissolveTeamById } from "./services/team";
+import { reapTransientAgents, resetTransientTrackerForTests } from "./services/transient-agent-reaper";
 import type { Command, MaintenanceJob, MaintenanceJobRun } from "./types";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -134,9 +135,7 @@ const orphanReapEnabled = () => process.env.AGENT_RELAY_ORPHAN_REAP !== "0";
 // orchestratorId + session identity -> when we first saw it orphaned (and last reaped).
 const orphanTracker = new Map<string, { firstOrphanedAt: number; lastReapAt?: number }>();
 
-export function resetOrphanTrackerForTests(): void {
-  orphanTracker.clear();
-}
+export function resetOrphanTrackerForTests(): void { orphanTracker.clear(); resetTransientTrackerForTests(); }
 
 interface MaintenanceJobDefinition {
   id: string;
@@ -300,6 +299,7 @@ const definitions: MaintenanceJobDefinition[] = [
     runOnStart: false,
     handler: reapOrphanedSessions,
   },
+  { id: "transient-agent-reaper", title: "Transient agent reaper", description: "Cleanly shut down transient spawned agents once they are idle and any isolated branch work has landed.", intervalMs: REAP_INTERVAL_MS, runOnStart: false, handler: reapTransientAgents },
   {
     id: "team-reap",
     title: "Team lifecycle close-out",

package/src/mcp-agent-action.ts

@@ -0,0 +1,45 @@
+import { cleanEnum, cleanString } from "./validation";
+import { AgentActionTargetError, dispatchAgentAction, type AgentAction } from "./services/agent-action";
+import { authContextFromMcp } from "./services/auth-context";
+import { ShutdownAuthError, ShutdownTargetError } from "./services/shutdown-agent";
+import { McpAuthError, McpNotFoundError } from "./mcp-errors";
+
+type McpAuthLike = {
+  actor: string;
+  kind: "component" | "integration" | "server";
+  scopes?: string[];
+  component?: Parameters<typeof authContextFromMcp>[0]["component"];
+};
+
+export const AGENT_ACTION_TOOL = {
+  name: "relay_agent_action",
+  description: "Compact, clear context, or directly inject a prompt into one of your live spawned children. Gated exactly like relay_shutdown_agent: an agent caller may target only its OWN spawned children by agentId; admin tokens keep full reach.",
+  requiredScopes: ["command:shutdown"],
+  inputSchema: {
+    type: "object",
+    properties: {
+      agentId: { type: "string" },
+      action: { type: "string", enum: ["compact", "clearContext", "inject"] },
+      message: { type: "string", description: "Required when action is inject." },
+    },
+    required: ["agentId", "action"],
+    additionalProperties: false,
+  },
+};
+
+export function relayAgentAction(auth: McpAuthLike, args: Record<string, unknown>): Record<string, unknown> {
+  try {
+    const result = dispatchAgentAction({
+      agentId: cleanString(args.agentId, "agentId", { required: true, max: 240 })!,
+      action: cleanEnum(args.action, "action", ["compact", "clearContext", "inject"] as const) as AgentAction,
+      message: cleanString(args.message, "message", { max: 16_000 }),
+      requestedVia: "mcp",
+      requestedBy: auth.actor,
+    }, authContextFromMcp(auth));
+    return { ok: true, action: result.action, command: result.command };
+  } catch (e) {
+    if (e instanceof ShutdownAuthError) throw new McpAuthError(e.message);
+    if (e instanceof ShutdownTargetError || e instanceof AgentActionTargetError) throw new McpNotFoundError(e.message);
+    throw e;
+  }
+}

package/src/mcp-team-template-tools.ts

@@ -0,0 +1,133 @@
+import { APPROVAL_MODES, VALID_AGENT_LIFECYCLES, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
+import { McpAuthError } from "./mcp-errors";
+import { authContextFromMcp } from "./services/auth-context";
+import { deleteTeamTemplate, getTeamTemplate, instantiateTeamTemplate, listTeamTemplates, saveTeamTemplate } from "./services/team-templates";
+import { ValidationError } from "./db";
+
+const COMPOSITION_ENTRY_SCHEMA = {
+  type: "object",
+  properties: {
+    label: { type: "string" },
+    provider: { type: "string", enum: ["claude", "codex"] },
+    model: { type: "string" },
+    effort: { type: "string" },
+    profile: { type: "string" },
+    count: { type: "integer", minimum: 1, maximum: 50 },
+  },
+  required: ["label", "provider", "count"],
+  additionalProperties: false,
+} as const;
+
+const PLAN_SKELETON_SCHEMA = {
+  type: "object",
+  properties: {
+    nodes: { type: "array", items: { type: "object" } },
+    edges: { type: "array", items: { type: "object" } },
+  },
+  additionalProperties: false,
+} as const;
+
+export const TEAM_TEMPLATE_TOOLS = [
+  {
+    name: "relay_team_template_save",
+    description: "Create/update a reusable team template, or capture one from a dissolved team's frozen composition by passing teamId.",
+    requiredScopes: ["teams:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        slug: { type: "string" },
+        title: { type: "string" },
+        description: { type: "string" },
+        composition: { type: "array", items: COMPOSITION_ENTRY_SCHEMA },
+        brief: { type: "string" },
+        definitionOfDone: { type: "string" },
+        planSkeleton: PLAN_SKELETON_SCHEMA,
+        teamId: { type: "string", description: "Capture from this dissolved team's frozen composition snapshot instead of passing composition." },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "relay_team_template_list",
+    description: "List saved team templates.",
+    requiredScopes: ["teams:read"],
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  },
+  {
+    name: "relay_team_template_get",
+    description: "Fetch one saved team template by slug.",
+    requiredScopes: ["teams:read"],
+    inputSchema: { type: "object", properties: { slug: { type: "string" } }, required: ["slug"], additionalProperties: false },
+  },
+  {
+    name: "relay_team_template_delete",
+    description: "Delete one saved team template by slug.",
+    requiredScopes: ["teams:write"],
+    inputSchema: { type: "object", properties: { slug: { type: "string" } }, required: ["slug"], additionalProperties: false },
+  },
+  {
+    name: "relay_team_spawn_from_template",
+    description: "Instantiate a saved team template: set the caller's team brief and spawn its composition through the shared spawn service.",
+    requiredScopes: ["teams:write"],
+    inputSchema: {
+      type: "object",
+      properties: {
+        slug: { type: "string" },
+        orchestratorId: { type: "string" },
+        cwd: { type: "string" },
+        approvalMode: { type: "string", enum: APPROVAL_MODES },
+        workspaceMode: { type: "string", enum: VALID_WORKSPACE_MODES },
+        lifecycle: { type: "string", enum: VALID_AGENT_LIFECYCLES },
+        prompt: { type: "string" },
+        waitForRegistrationMs: { type: "integer", minimum: 0, maximum: 30000 },
+      },
+      required: ["slug"],
+      additionalProperties: false,
+    },
+  },
+] satisfies Array<{ name: string; description: string; requiredScopes: string[]; inputSchema: Record<string, unknown> }>;
+
+type McpAuthLike = Parameters<typeof authContextFromMcp>[0];
+
+function hasScope(auth: McpAuthLike, scope: string): boolean {
+  if (auth.scopes?.includes("*") || auth.scopes?.includes("admin:*")) return true;
+  const [category] = scope.split(":");
+  return Boolean(auth.scopes?.includes(scope) || (category && auth.scopes?.includes(`${category}:*`)));
+}
+
+function requireScope(auth: McpAuthLike, scope: string): void {
+  if (!hasScope(auth, scope)) throw new McpAuthError(`tool requires ${scope}`);
+}
+
+function slugArg(args: Record<string, unknown>): string {
+  const slug = args.slug;
+  if (typeof slug !== "string" || !slug.trim()) throw new ValidationError("slug required");
+  return slug.trim();
+}
+
+export async function relayTeamTemplateTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Promise<Record<string, unknown>> {
+  if (name === "relay_team_template_save") {
+    requireScope(auth, "teams:write");
+    return saveTeamTemplate(args, auth.actor) as unknown as Record<string, unknown>;
+  }
+  if (name === "relay_team_template_list") return { templates: listTeamTemplates() };
+  if (name === "relay_team_template_get") {
+    const template = getTeamTemplate(slugArg(args));
+    if (!template) throw new ValidationError("team template not found");
+    return { template };
+  }
+  if (name === "relay_team_template_delete") {
+    requireScope(auth, "teams:write");
+    return { slug: slugArg(args), deleted: deleteTeamTemplate(slugArg(args), auth.actor) };
+  }
+  if (name === "relay_team_spawn_from_template") {
+    requireScope(auth, "teams:write");
+    return await instantiateTeamTemplate({ ...args, slug: slugArg(args) }, authContextFromMcp(auth)) as unknown as Record<string, unknown>;
+  }
+  throw new ValidationError(`unknown tool: ${name}`);
+}
+
+export function isTeamTemplateTool(name: string): boolean {
+  return name.startsWith("relay_team_template_") || name === "relay_team_spawn_from_template";
+}

package/src/mcp-team-tools.ts

@@ -4,6 +4,7 @@ import { ValidationError } from "./db";
 import { dissolveCallerTeam, getCallerTeam, setCallerTeamBrief, TeamAuthError, TeamNotFoundError } from "./services/team";
 import { cleanString, optionalEnum } from "./validation";
 import type { Team } from "./types";
+import { TEAM_TEMPLATE_TOOLS, isTeamTemplateTool, relayTeamTemplateTool } from "./mcp-team-template-tools";
 
 const OUTCOME_STATUSES = ["success", "partial", "failed"] as const;
 
@@ -46,6 +47,7 @@ export const TEAM_TOOLS = [
       additionalProperties: false,
     },
   },
+  ...TEAM_TEMPLATE_TOOLS,
 ] satisfies Array<{ name: string; description: string; requiredScopes: string[]; inputSchema: Record<string, unknown> }>;
 
 type McpAuthLike = Parameters<typeof authContextFromMcp>[0];
@@ -56,7 +58,8 @@ function mapTeamError(error: unknown): never {
   throw error;
 }
 
-export function relayTeamTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Record<string, unknown> {
+export async function relayTeamTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Promise<Record<string, unknown>> {
+  if (isTeamTemplateTool(name)) return await relayTeamTemplateTool(auth, name, args);
   const ctx = authContextFromMcp(auth);
   try {
     if (name === "relay_team_get") {

package/src/mcp.ts

@@ -49,21 +49,17 @@ import { ServiceAuthError } from "./services/errors";
 import { PLAN_TOOLS, relayPlanTool } from "./mcp-plan-tools";
 import { TEAM_TOOLS, relayTeamTool } from "./mcp-team-tools";
 import { BLACKBOARD_TOOLS, relayBlackboardTool } from "./mcp-blackboard-tools";
-import type { ActivityKind, ArtifactKind, ArtifactSensitivity, AttachmentRef, Command, SendMessageInput, Message, SpawnApprovalMode, SpawnProvider, WorkspaceAutoMergePolicy, WorkspaceMergeStrategy, WorkspaceMode, WorkspaceRecord } from "./types";
+import { AGENT_ACTION_TOOL, relayAgentAction } from "./mcp-agent-action";
+import type { ActivityKind, AgentLifecycle, ArtifactKind, ArtifactSensitivity, AttachmentRef, Command, SendMessageInput, Message, SpawnApprovalMode, SpawnProvider, WorkspaceAutoMergePolicy, WorkspaceMergeStrategy, WorkspaceMode, WorkspaceRecord } from "./types";
 import { LAND_STRATEGIES, applyWorkspaceAction, waitForWorkspaceStatus, type WorkspaceAction } from "./workspace-actions";
 import { AUTO_MERGE_POLICIES } from "./workspace-merge";
 import { describeWorkspacePhase, landReceipt, readyContract, worktreeMcpInstructions } from "./workspace-phase";
 import { type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { errMessage, isRecord, stringValue, SPAWN_PROVIDERS, APPROVAL_MODES, VALID_EFFORTS, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
+import { errMessage, isRecord, stringValue, SPAWN_PROVIDERS, APPROVAL_MODES, VALID_AGENT_LIFECYCLES, VALID_EFFORTS, VALID_WORKSPACE_MODES } from "agent-relay-sdk";
 
 type JsonRpcId = string | number | null;
 
-type JsonRpcRequest = {
-  jsonrpc?: "2.0";
-  id?: JsonRpcId;
-  method?: string;
-  params?: unknown;
-};
+type JsonRpcRequest = { jsonrpc?: "2.0"; id?: JsonRpcId; method?: string; params?: unknown };
 
 type McpAuthContext = {
   actor: string;
@@ -92,8 +88,6 @@ const VALID_ARTIFACT_KINDS = ["image", "audio", "video", "document", "archive",
 const VALID_ARTIFACT_SENSITIVITIES = ["public", "normal", "sensitive", "secret"] as const;
 const VALID_ARTIFACT_ROLES = ["media", "patch", "report", "log", "output", "input"] as const;
 const VALID_ARTIFACT_ENTITY_TYPES = ["message", "task", "recipeRun", "recipeStep", "channelEvent"] as const;
-
-
 const TOOLS: ToolDefinition[] = [
   {
     name: "relay_send_message",
@@ -320,6 +314,7 @@ const TOOLS: ToolDefinition[] = [
         providerArgs: { type: "array", items: { type: "string" } },
         policyName: { type: "string" },
         spawnRequestId: { type: "string" },
+        lifecycle: { type: "string", enum: VALID_AGENT_LIFECYCLES, description: "Lifecycle mode. `persistent` keeps the agent until explicitly stopped. `transient` lets Relay auto-shutdown the child after it is idle and, for isolated workers, after its branch has landed. Default: persistent." },
         workspaceMode: { type: "string", enum: VALID_WORKSPACE_MODES, description: "Git workspace for the worker. `isolated` = its own worktree on an `agent/session-*` branch off main that auto-lands when ready (delegate a unit of work, get a branch worker). `shared` = edits your live checkout (a sidecar). `inherit` = let the orchestrator decide. DEFAULT for agent-initiated spawns is `isolated` so a delegated worker lands to main instead of editing your tree; pass `shared`/`inherit` to override." },
         waitForRegistrationMs: { type: "integer", minimum: 0, maximum: 30000, description: "How long to wait for the spawned agent to register before returning, so the response carries its resolved agent id (default 8000; 0 = return immediately with just spawnRequestId)." },
       },
@@ -355,6 +350,7 @@ const TOOLS: ToolDefinition[] = [
       additionalProperties: false,
     },
   },
+  AGENT_ACTION_TOOL,
   {
     name: "relay_workspace_status",
     description: "Get your isolated workspace's lifecycle status (active/ready/conflict/review_requested/merged/...). With wait:true this BLOCKS until the status changes — use it after relay_workspace_ready to wait for the auto-merge to land your branch on main (status leaves 'ready' → merged/recycled-to-active with a fresh rebased branch) or to surface a conflict/review_requested the steward couldn't auto-resolve. Defaults to the workspace you own; pass workspaceId to target another.",
@@ -566,6 +562,7 @@ async function callTool(auth: McpAuthContext, params: unknown): Promise<Record<s
     else if (name === "relay_spawn_agent") result = await relaySpawnAgent(auth, args);
     else if (name === "relay_spawn_targets") result = relaySpawnTargets(auth);
     else if (name === "relay_shutdown_agent") result = relayShutdownAgent(auth, args);
+    else if (name === "relay_agent_action") result = relayAgentAction(auth, args);
     else if (name === "relay_workspace_status") result = await relayWorkspaceStatus(auth, args);
     else if (name === "relay_workspace_list") result = relayWorkspaceList(auth, args);
     else if (name === "relay_workspace_ready") result = relayWorkspaceMutation(auth, "ready", args);
@@ -573,7 +570,7 @@ async function callTool(auth: McpAuthContext, params: unknown): Promise<Record<s
     else if (name === "relay_workspace_claim") result = relayWorkspaceMutation(auth, "claim", args);
     else if (name === "relay_workspace_release") result = relayWorkspaceMutation(auth, "release-claim", args);
     else if (name === "relay_workspace_land") result = relayWorkspaceMutation(auth, "merge", args);
-    else if (name.startsWith("relay_team_")) result = relayTeamTool(auth, name, args);
+    else if (name.startsWith("relay_team_")) result = await relayTeamTool(auth, name, args);
     else if (name.startsWith("relay_plan_")) result = relayPlanTool(auth, name, args);
     else if (name.startsWith("relay_blackboard_")) result = relayBlackboardTool(auth, name, args);
     else throw new ValidationError(`unknown tool: ${name}`);
@@ -866,6 +863,7 @@ async function relaySpawnAgent(auth: McpAuthContext, args: Record<string, unknow
     effort: optionalEnum(args.effort, "effort", VALID_EFFORTS) as ProviderEffort | undefined,
     approvalMode: optionalEnum(args.approvalMode, "approvalMode", APPROVAL_MODES) as SpawnApprovalMode | undefined,
     workspaceMode: optionalEnum(args.workspaceMode, "workspaceMode", VALID_WORKSPACE_MODES) as WorkspaceMode | undefined,
+    lifecycle: (optionalEnum(args.lifecycle, "lifecycle", VALID_AGENT_LIFECYCLES) as AgentLifecycle | undefined) ?? "persistent",
     label: optionalString(args.label, "label", 120),
     policyName: optionalString(args.policyName, "policyName", 120),
     profile: optionalString(args.profile, "profile", 120),

package/src/routes/index.ts

@@ -31,8 +31,9 @@ import { getBlackboardEntryRoute, getBlackboardRoute } from "./blackboard";
 import { getRecipeByName, getRecipeInstanceArtifacts, getRecipeInstanceById, getRecipeInstances, getRecipes, postRecipeInstanceArtifacts, postRecipeStart, postRecipeStop } from "./recipes";
 import { getStewardConfigRoute, getWorkspaceConfigRoute, putStewardConfigRoute, putWorkspaceConfigRoute } from "./steward";
 import { getTaskById, getTaskEvents, getTasks, patchTaskStatus, postClaimTask, postRenewTaskClaim } from "./tasks";
-import { getMyTeamRoute, getTeamsRoute, postMyTeamDissolveRoute, putMyTeamBriefRoute } from "./teams";
+import { getMyTeamRoute, getTeamOutcomesRoute, getTeamsRoute, postMyTeamDissolveRoute, putMyTeamBriefRoute } from "./teams";
 import { postTeamDissolveByIdRoute } from "./teams";
+import { deleteTeamTemplateRoute, getTeamTemplateRoute, getTeamTemplatesRoute, postTeamTemplateRoute, putTeamTemplateRoute } from "./team-templates";
 import { postMcp } from "../mcp";
 import { postOrchestratorBootstrap, postOrchestratorBootstrapExchange } from "./orchestrator-bootstrap";
 
@@ -139,10 +140,16 @@ const routes: Route[] = [
 
   route("POST", "/api/system/broadcast", postSystemBroadcast),
   route("GET", "/api/teams", getTeamsRoute),
+  route("GET", "/api/teams/outcomes", getTeamOutcomesRoute),
   route("GET", "/api/teams/me", getMyTeamRoute),
   route("PUT", "/api/teams/me/brief", putMyTeamBriefRoute),
   route("POST", "/api/teams/me/dissolve", postMyTeamDissolveRoute),
   route("POST", "/api/teams/:id/dissolve", postTeamDissolveByIdRoute),
+  route("GET", "/api/team-templates", getTeamTemplatesRoute),
+  route("POST", "/api/team-templates", postTeamTemplateRoute),
+  route("GET", "/api/team-templates/:slug", getTeamTemplateRoute),
+  route("PUT", "/api/team-templates/:slug", putTeamTemplateRoute),
+  route("DELETE", "/api/team-templates/:slug", deleteTeamTemplateRoute),
   route("GET", "/api/recipes", getRecipes),
   route("POST", "/api/recipes/start", postRecipeStart),
   route("GET", "/api/recipes/instances", getRecipeInstances),

package/src/routes/team-templates.ts

@@ -0,0 +1,65 @@
+import { authContextFromRequest } from "../services/auth-context";
+import { deleteTeamTemplate, getTeamTemplate, listTeamTemplates, saveTeamTemplate } from "../services/team-templates";
+import { cleanString } from "../validation";
+import { authorizeRoute, error, json, parseBody, type Handler } from "./_shared";
+
+function updatedBy(req: Request): string {
+  return authContextFromRequest(req).actor.id;
+}
+
+function routeError(err: unknown): Response {
+  if (err instanceof Error) return error(err.message);
+  return error("team template route failed");
+}
+
+function slugParam(params: Record<string, string | undefined>): string {
+  return cleanString(params.slug, "slug", { required: true, max: 120 })!;
+}
+
+export const getTeamTemplatesRoute: Handler = (req) => {
+  const denied = authorizeRoute(req, { scope: "system:admin" });
+  if (denied) return denied;
+  return json({ templates: listTeamTemplates() });
+};
+
+export const getTeamTemplateRoute: Handler = (req, params) => {
+  const denied = authorizeRoute(req, { scope: "system:admin" });
+  if (denied) return denied;
+  try {
+    const template = getTeamTemplate(slugParam(params));
+    return template ? json(template) : error("team template not found", 404);
+  } catch (err) {
+    return routeError(err);
+  }
+};
+
+export const postTeamTemplateRoute: Handler = async (req) => {
+  const denied = authorizeRoute(req, { scope: "system:admin" });
+  if (denied) return denied;
+  const parsed = await parseBody<Record<string, unknown>>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  try {
+    return json(saveTeamTemplate(parsed.body ?? {}, updatedBy(req)), 201);
+  } catch (err) {
+    return routeError(err);
+  }
+};
+
+export const putTeamTemplateRoute: Handler = async (req, params) => {
+  const denied = authorizeRoute(req, { scope: "system:admin" });
+  if (denied) return denied;
+  const parsed = await parseBody<Record<string, unknown>>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  try {
+    return json(saveTeamTemplate({ ...(parsed.body ?? {}), slug: slugParam(params) }, updatedBy(req)));
+  } catch (err) {
+    return routeError(err);
+  }
+};
+
+export const deleteTeamTemplateRoute: Handler = (req, params) => {
+  const denied = authorizeRoute(req, { scope: "system:admin" });
+  if (denied) return denied;
+  const slug = slugParam(params);
+  return json({ slug, deleted: deleteTeamTemplate(slug, updatedBy(req)) });
+};

package/src/routes/teams.ts

@@ -1,9 +1,9 @@
 import { McpAuthError, McpNotFoundError } from "../mcp-errors";
 import { authContextFromRequest } from "../services/auth-context";
-import { getTeam, listAllTeams, ValidationError } from "../db";
+import { getTeam, getTeamOutcomeAggregates, listAllTeams, ValidationError } from "../db";
 import { dissolveCallerTeam, dissolveTeamById, getCallerTeam, setCallerTeamBrief, TeamAuthError, TeamNotFoundError, type TeamDissolveServiceInput } from "../services/team";
 import { cleanString, optionalEnum } from "../validation";
-import { authorizeRoute, error, json, parseBody, type Handler } from "./_shared";
+import { authorizeRoute, error, json, parseBody, parseQueryInt, type Handler } from "./_shared";
 import type { Team } from "../types";
 
 const OUTCOME_STATUSES = ["success", "partial", "failed"] as const;
@@ -50,6 +50,18 @@ export const getTeamsRoute: Handler = (req) => {
   }
 };
 
+export const getTeamOutcomesRoute: Handler = (req) => {
+  const denied = authorizeRoute(req, { scope: "system:admin" });
+  if (denied) return denied;
+  try {
+    const recentLimit = parseQueryInt(new URL(req.url).searchParams.get("recentLimit"), { min: 1, max: 50, clamp: true }) ?? undefined;
+    if (Number.isNaN(recentLimit)) return error("invalid recentLimit", 400);
+    return json(getTeamOutcomeAggregates({ recentLimit }));
+  } catch (err) {
+    return routeError(err);
+  }
+};
+
 export const putMyTeamBriefRoute: Handler = async (req) => {
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);