agent-relay-server 0.12.3 → 0.13.0

package/src/cli.ts

@@ -74,6 +74,7 @@ Usage:
   agent-relay /guide
   agent-relay /label [LABEL]
   agent-relay /tags [TAG ...]
+  agent-relay /introspect [--thin TEXT] [--worked-around TEXT] [--would-have-helped TEXT] [--stdin]
   agent-relay --help
 
 Pair examples:
@@ -231,6 +232,14 @@ Rules of thumb
   If you need to know who you are in Relay, run:
     agent-relay /status --json
 
+Recording session friction (optional, helps improve your standing context)
+  agent-relay /introspect --thin "..." --worked-around "..." --would-have-helped "..."
+    When a session involved real work, you can record a short 3-field note about
+    where context was thin, what tooling/instruction gaps you routed around, and
+    what would have saved the read-up. Keep each field to a sentence or two. This
+    feeds the relay's self-improvement signal so the operator can close the gaps —
+    it is not a reply and needs no message id. Skip it for trivial sessions.
+
   Use the HTTP API for integrations and debugging. For normal agent-to-agent
   communication, use the CLI commands above.
 `.trim();
@@ -322,6 +331,10 @@ export async function handleCli(args: string[]): Promise<"start" | "handled"> {
     await handleReactCommand(args.slice(1));
     return "handled";
   }
+  if (command === "introspect" || command === "/introspect") {
+    await handleIntrospectCommand(args.slice(1));
+    return "handled";
+  }
   if (command === "/status" || command === "status") {
     await handleStatusCommand(args.slice(1));
     return "handled";
@@ -1551,6 +1564,75 @@ async function handleReactCommand(args: string[]): Promise<void> {
   else console.log(`${action === "remove" ? "Reaction removed" : "Reaction sent"}: ${emoji} on #${messageId}`);
 }
 
+// Insights #185: capture the agent's end-of-session self-view as a bounded, structured
+// artifact (epic #183, docs/self-improvement.md). Manual rail in v0 — the agent or
+// operator runs this; the auto-trigger is chosen later on real data. The relay drops it
+// (409) if Insights or the introspection feature is toggled off.
+const INTROSPECT_FIELD_MAX = 600;
+
+async function handleIntrospectCommand(args: string[]): Promise<void> {
+  let from = await detectAgentId();
+  let project: string | undefined;
+  let sessionId: string | undefined;
+  let thin: string | undefined;
+  let workedAround: string | undefined;
+  let wouldHaveHelped: string | undefined;
+  let stdin = false;
+  let json = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--from" && i + 1 < args.length) from = args[++i];
+    else if (arg === "--project" && i + 1 < args.length) project = args[++i];
+    else if (arg === "--session" && i + 1 < args.length) sessionId = args[++i];
+    else if (arg === "--thin" && i + 1 < args.length) thin = args[++i];
+    else if (arg === "--worked-around" && i + 1 < args.length) workedAround = args[++i];
+    else if (arg === "--would-have-helped" && i + 1 < args.length) wouldHaveHelped = args[++i];
+    else if (arg === "--stdin") stdin = true;
+    else if (arg === "--json") json = true;
+    else throw new Error(`Unknown introspect option "${arg}"`);
+  }
+
+  // --stdin reads a JSON object { thin, workedAround, wouldHaveHelped } — lets agents
+  // pipe a file without shell-quoting three multi-line fields.
+  if (stdin) {
+    const raw = (await readStdin()).trim();
+    if (!raw) throw new Error("--stdin given but no input received.");
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error('--stdin must be JSON: { "thin": "...", "workedAround": "...", "wouldHaveHelped": "..." }');
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("--stdin JSON must be an object");
+    const obj = parsed as Record<string, unknown>;
+    if (typeof obj.thin === "string") thin = obj.thin;
+    if (typeof obj.workedAround === "string") workedAround = obj.workedAround;
+    if (typeof obj.wouldHaveHelped === "string") wouldHaveHelped = obj.wouldHaveHelped;
+  }
+
+  const clip = (v: string | undefined): string => (v ?? "").trim().slice(0, INTROSPECT_FIELD_MAX);
+  const value = { thin: clip(thin), workedAround: clip(workedAround), wouldHaveHelped: clip(wouldHaveHelped) };
+  if (!value.thin && !value.workedAround && !value.wouldHaveHelped) {
+    throw new Error(
+      "Usage: agent-relay /introspect [--thin TEXT] [--worked-around TEXT] [--would-have-helped TEXT] [--stdin] [--from AGENT_ID]\n" +
+        "At least one field is required. The three fields: what context was thin, what you worked around, what would've helped.",
+    );
+  }
+  if (!from) throw new Error("Could not detect current Agent Relay ID. Pass --from AGENT_ID or set AGENT_RELAY_ID.");
+
+  const observation = await apiRequest("POST", "/api/insights/observations", {
+    sessionId: sessionId || process.env.AGENT_RELAY_PROVIDER_SESSION_ID || `manual-${from}`,
+    project: project || process.cwd(),
+    agentId: from,
+    signal: "introspection",
+    source: "agent",
+    value,
+  });
+  if (json) console.log(JSON.stringify(observation, null, 2));
+  else console.log("Introspection recorded.");
+}
+
 function parseReplyFormat(value: string): "text" | "markdown" | "markdownv2" | undefined {
   const normalized = value.trim().toLowerCase();
   if (normalized === "text" || normalized === "markdown" || normalized === "markdownv2") return normalized;

package/src/config-store.ts

@@ -5,6 +5,7 @@ import type {
   AgentProfileBase,
   ConfigEntry,
   ConfigHistoryEntry,
+  InsightsConfig,
   ManagedAgentState,
   ManagedAgentStatus,
   SpawnApprovalMode,
@@ -18,6 +19,8 @@ const SPAWN_POLICY_NAMESPACE = "spawn-policy";
 const AGENT_PROFILE_NAMESPACE = "agent-profile";
 const STEWARD_NAMESPACE = "steward";
 const STEWARD_KEY = "default";
+const INSIGHTS_NAMESPACE = "insights";
+const INSIGHTS_KEY = "default";
 const VALID_PROVIDERS = ["claude", "codex"] as const;
 const VALID_PROFILE_PROVIDERS = ["any", "claude", "codex"] as const;
 const VALID_PROFILE_BASES = ["host", "minimal", "isolated"] as const;
@@ -425,11 +428,56 @@ function validateStewardConfig(value: unknown): StewardConfig {
   return config;
 }
 
+// Insights / self-improvement module config — feature toggles for the dogfooding
+// flywheel (epic #183, docs/self-improvement.md). Passive read-only observation, so it
+// defaults on; each feature toggles independently.
+const INSIGHTS_CONFIG_DEFAULTS: InsightsConfig = {
+  enabled: true,
+  contextRatio: { enabled: true },
+  introspection: { enabled: true, minTurns: 4, minContextRemaining: 0.15 },
+};
+
+function cleanFraction(value: unknown, field: string, fallback: number): number {
+  if (value === undefined || value === null) return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    throw new ValidationError(`${field} must be a number between 0 and 1`);
+  }
+  return value;
+}
+
+function validateInsightsConfig(value: unknown): InsightsConfig {
+  if (!isRecord(value)) throw new ValidationError("insights config value must be an object");
+  const contextRatio = isRecord(value.contextRatio) ? value.contextRatio : {};
+  const introspection = isRecord(value.introspection) ? value.introspection : {};
+  return {
+    enabled: value.enabled === undefined ? INSIGHTS_CONFIG_DEFAULTS.enabled : cleanBoolean(value.enabled, "enabled"),
+    contextRatio: {
+      enabled: contextRatio.enabled === undefined
+        ? INSIGHTS_CONFIG_DEFAULTS.contextRatio.enabled
+        : cleanBoolean(contextRatio.enabled, "contextRatio.enabled"),
+    },
+    introspection: {
+      enabled: introspection.enabled === undefined
+        ? INSIGHTS_CONFIG_DEFAULTS.introspection.enabled
+        : cleanBoolean(introspection.enabled, "introspection.enabled"),
+      minTurns: introspection.minTurns === undefined || introspection.minTurns === null
+        ? INSIGHTS_CONFIG_DEFAULTS.introspection.minTurns
+        : cleanNumber(introspection.minTurns, "introspection.minTurns", { min: 0, max: 1000 }),
+      minContextRemaining: cleanFraction(
+        introspection.minContextRemaining,
+        "introspection.minContextRemaining",
+        INSIGHTS_CONFIG_DEFAULTS.introspection.minContextRemaining,
+      ),
+    },
+  };
+}
+
 function normalizeValue(namespace: string, key: string, value: unknown): unknown {
   if (value === undefined) throw new ValidationError("value required");
   if (namespace === SPAWN_POLICY_NAMESPACE) return validateSpawnPolicy(key, value);
   if (namespace === AGENT_PROFILE_NAMESPACE) return validateAgentProfile(key, value);
   if (namespace === STEWARD_NAMESPACE) return validateStewardConfig(value);
+  if (namespace === INSIGHTS_NAMESPACE) return validateInsightsConfig(value);
   if (JSON.stringify(value) === undefined) throw new ValidationError("value must be valid JSON");
   return value;
 }
@@ -543,6 +591,29 @@ export function setStewardConfig(value: unknown, updatedBy?: string): ConfigEntr
   return setConfig(STEWARD_NAMESPACE, STEWARD_KEY, value as StewardConfig, updatedBy);
 }
 
+/** Insights module config, merged over defaults (always returns a usable value). */
+export function getInsightsConfig(): InsightsConfig {
+  const entry = getConfig<Partial<InsightsConfig>>(INSIGHTS_NAMESPACE, INSIGHTS_KEY);
+  if (!entry) return { ...INSIGHTS_CONFIG_DEFAULTS };
+  return validateInsightsConfig({ ...INSIGHTS_CONFIG_DEFAULTS, ...entry.value });
+}
+
+export function getInsightsConfigEntry(): ConfigEntry<InsightsConfig> {
+  const entry = getConfig<InsightsConfig>(INSIGHTS_NAMESPACE, INSIGHTS_KEY);
+  return entry ?? {
+    namespace: INSIGHTS_NAMESPACE,
+    key: INSIGHTS_KEY,
+    value: { ...INSIGHTS_CONFIG_DEFAULTS },
+    version: 0,
+    updatedAt: "default",
+    updatedBy: "system",
+  };
+}
+
+export function setInsightsConfig(value: unknown, updatedBy?: string): ConfigEntry<InsightsConfig> {
+  return setConfig(INSIGHTS_NAMESPACE, INSIGHTS_KEY, value as InsightsConfig, updatedBy);
+}
+
 function builtInProfileEntry(profile: AgentProfile): ConfigEntry<AgentProfile> {
   return {
     namespace: AGENT_PROFILE_NAMESPACE,

package/src/db.ts

@@ -770,6 +770,21 @@ export function initDb(path: string = "agent-relay.db"): Database {
       last_auth_success_at INTEGER,
       last_auth_failure_at INTEGER
     );
+
+    CREATE TABLE IF NOT EXISTS insights_observations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      agent_id TEXT,
+      project TEXT NOT NULL DEFAULT 'unknown',
+      signal TEXT NOT NULL,
+      value TEXT NOT NULL DEFAULT '{}',
+      outcome TEXT,
+      source TEXT NOT NULL DEFAULT 'server',
+      created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_insights_obs_project_signal ON insights_observations(project, signal, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_insights_obs_signal ON insights_observations(signal, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_insights_obs_session ON insights_observations(session_id);
   `);
   normalizeExistingMessageReactions();
 

package/src/insights-db.ts

@@ -0,0 +1,179 @@
+// Insights — continuous self-improvement store (epic #183, docs/self-improvement.md).
+//
+// One generic table backs every signal. New instrumentation appends rows with a new
+// `signal` discriminator — never a new table — so the module grows by data, not schema.
+// Each row pairs a metric (`value`) with an optional outcome proxy (`outcome`) so an
+// efficiency number is never read without its anti-Goodhart leash. Everything is scoped
+// per-project (and rolled up globally) so the real signal can be delta-from-baseline,
+// never an absolute threshold.
+
+import { getDb, ValidationError } from "./db";
+import type { InsightObservation, InsightsStats } from "./types";
+
+interface ObservationRow {
+  id: number;
+  session_id: string;
+  agent_id: string | null;
+  project: string;
+  signal: string;
+  value: string;
+  outcome: string | null;
+  source: string;
+  created_at: number;
+}
+
+function parseJson(raw: string | null): Record<string, unknown> | undefined {
+  if (raw === null) return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as Record<string, unknown>) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function rowToObservation(row: ObservationRow): InsightObservation {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    agentId: row.agent_id ?? undefined,
+    project: row.project,
+    signal: row.signal,
+    value: parseJson(row.value) ?? {},
+    outcome: parseJson(row.outcome),
+    source: row.source === "agent" ? "agent" : "server",
+    createdAt: row.created_at,
+  };
+}
+
+export interface RecordObservationInput {
+  sessionId: string;
+  agentId?: string;
+  project?: string;
+  signal: string;
+  value: Record<string, unknown>;
+  outcome?: Record<string, unknown>;
+  source?: "server" | "agent";
+  createdAt?: number;
+}
+
+export function recordObservation(input: RecordObservationInput): InsightObservation {
+  const sessionId = (input.sessionId ?? "").trim();
+  if (!sessionId) throw new ValidationError("sessionId required");
+  const signal = (input.signal ?? "").trim();
+  if (!signal) throw new ValidationError("signal required");
+  if (signal.length > 80) throw new ValidationError("signal must be 80 characters or fewer");
+  if (!input.value || typeof input.value !== "object" || Array.isArray(input.value)) {
+    throw new ValidationError("value must be an object");
+  }
+  // Bounded by design — the artifact stays a few lines, never an essay (the format
+  // constraint is what keeps the introspection signal from becoming a tax).
+  const valueJson = JSON.stringify(input.value);
+  if (valueJson.length > 16_384) throw new ValidationError("value too large (max 16KB)");
+  const outcomeJson = input.outcome ? JSON.stringify(input.outcome) : null;
+  if (outcomeJson && outcomeJson.length > 16_384) throw new ValidationError("outcome too large (max 16KB)");
+  const project = (input.project ?? "").trim() || "unknown";
+  const source = input.source === "agent" ? "agent" : "server";
+  const now = input.createdAt ?? Date.now();
+
+  const result = getDb()
+    .prepare(
+      `INSERT INTO insights_observations (session_id, agent_id, project, signal, value, outcome, source, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      sessionId,
+      input.agentId ?? null,
+      project,
+      signal,
+      valueJson,
+      outcomeJson,
+      source,
+      now,
+    );
+  return getObservation(Number(result.lastInsertRowid))!;
+}
+
+export function getObservation(id: number): InsightObservation | null {
+  const row = getDb().prepare("SELECT * FROM insights_observations WHERE id = ?").get(id) as ObservationRow | undefined;
+  return row ? rowToObservation(row) : null;
+}
+
+export interface ListObservationsQuery {
+  project?: string;
+  signal?: string;
+  sessionId?: string;
+  limit?: number;
+}
+
+export function listObservations(query: ListObservationsQuery = {}): InsightObservation[] {
+  const clauses: string[] = [];
+  const args: (string | number)[] = [];
+  if (query.project) {
+    clauses.push("project = ?");
+    args.push(query.project);
+  }
+  if (query.signal) {
+    clauses.push("signal = ?");
+    args.push(query.signal);
+  }
+  if (query.sessionId) {
+    clauses.push("session_id = ?");
+    args.push(query.sessionId);
+  }
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const limit = Math.min(Math.max(query.limit ?? 200, 1), 1000);
+  const rows = getDb()
+    .prepare(`SELECT * FROM insights_observations ${where} ORDER BY created_at DESC, id DESC LIMIT ?`)
+    .all(...args, limit) as ObservationRow[];
+  return rows.map(rowToObservation);
+}
+
+/**
+ * Per-project rollups plus a global (project = null) rollup for each signal. Average
+ * ratio is computed over rows that carry a numeric `value.ratio` (context_ratio); other
+ * signals report null. Raw values are preserved on the rows — this is a convenience view,
+ * never the place absolute thresholds get baked in.
+ */
+export function getObservationStats(signal?: string): InsightsStats[] {
+  const signalFilter = signal ? "WHERE signal = ?" : "";
+  const args = signal ? [signal] : [];
+  const perProject = getDb()
+    .prepare(
+      `SELECT signal, project,
+              COUNT(*) AS count,
+              AVG(CAST(json_extract(value, '$.ratio') AS REAL)) AS avg_ratio,
+              MAX(created_at) AS last_at
+       FROM insights_observations
+       ${signalFilter}
+       GROUP BY signal, project
+       ORDER BY signal ASC, project ASC`,
+    )
+    .all(...args) as Array<{ signal: string; project: string; count: number; avg_ratio: number | null; last_at: number | null }>;
+
+  const global = getDb()
+    .prepare(
+      `SELECT signal,
+              COUNT(*) AS count,
+              AVG(CAST(json_extract(value, '$.ratio') AS REAL)) AS avg_ratio,
+              MAX(created_at) AS last_at
+       FROM insights_observations
+       ${signalFilter}
+       GROUP BY signal
+       ORDER BY signal ASC`,
+    )
+    .all(...args) as Array<{ signal: string; count: number; avg_ratio: number | null; last_at: number | null }>;
+
+  return [
+    ...global.map((r) => ({ signal: r.signal, project: null, count: r.count, avgRatio: r.avg_ratio, lastAt: r.last_at })),
+    ...perProject.map((r) => ({ signal: r.signal, project: r.project, count: r.count, avgRatio: r.avg_ratio, lastAt: r.last_at })),
+  ];
+}
+
+/** Distinct projects that have produced at least one observation — feeds per-project baselines. */
+export function listObservationProjects(): string[] {
+  const rows = getDb()
+    .prepare("SELECT DISTINCT project FROM insights_observations ORDER BY project ASC")
+    .all() as Array<{ project: string }>;
+  return rows.map((r) => r.project);
+}

package/src/routes.ts

@@ -106,6 +106,8 @@ import {
   getManagedAgentState,
   getSpawnPolicy,
   getStewardConfigEntry,
+  getInsightsConfigEntry,
+  setInsightsConfig,
   listAgentProfiles,
   listSpawnPolicies,
   listConfig,
@@ -116,6 +118,7 @@ import {
   updateManagedAgentState,
 } from "./config-store";
 import { createCommand, deleteCommand, getCommand, listCommands, updateCommand } from "./commands-db";
+import { recordObservation, listObservations, getObservationStats, listObservationProjects } from "./insights-db";
 import { getLifecycleManager } from "./lifecycle-manager";
 import { getCompactionWatch } from "./compaction-watch";
 import { getRecipe, listRecipes } from "./recipe-loader";
@@ -4596,6 +4599,71 @@ const putStewardConfigRoute: Handler = async (req) => {
   }
 };
 
+// --- Insights / self-improvement (epic #183, docs/self-improvement.md) ---
+
+const getInsightsConfigRoute: Handler = () => json(getInsightsConfigEntry());
+
+const putInsightsConfigRoute: Handler = async (req) => {
+  const parsed = await parseBody<unknown>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  try {
+    const value = isRecord(parsed.body) && Object.prototype.hasOwnProperty.call(parsed.body, "value")
+      ? parsed.body.value
+      : parsed.body;
+    const updatedBy = isRecord(parsed.body) ? cleanString(parsed.body.updatedBy, "updatedBy", { max: 200 }) : undefined;
+    const entry = setInsightsConfig(value, updatedBy);
+    emitConfigChanged(entry.namespace, entry.key, entry.version);
+    return json(entry, entry.version === 1 ? 201 : 200);
+  } catch (e) {
+    if (e instanceof ValidationError) return error(e.message, 400);
+    throw e;
+  }
+};
+
+const getInsightsObservationsRoute: Handler = (req) => {
+  const url = new URL(req.url);
+  const project = url.searchParams.get("project") ?? undefined;
+  const signal = url.searchParams.get("signal") ?? undefined;
+  const sessionId = url.searchParams.get("session") ?? undefined;
+  const limitRaw = url.searchParams.get("limit");
+  const limit = limitRaw ? Number(limitRaw) : undefined;
+  const observations = listObservations({ project, signal, sessionId, limit: Number.isFinite(limit) ? limit : undefined });
+  return json({
+    observations,
+    stats: getObservationStats(signal),
+    projects: listObservationProjects(),
+  });
+};
+
+const postInsightsObservationRoute: Handler = async (req) => {
+  const parsed = await parseBody<unknown>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  if (!isRecord(parsed.body)) return error("JSON object body required", 400);
+  // Master switch + per-signal toggle gate ingestion, so flipping a feature off in the
+  // dashboard actually stops data landing — not just hides it.
+  const config = getInsightsConfigEntry().value;
+  if (!config.enabled) return error("insights disabled", 409);
+  const body = parsed.body;
+  const signal = typeof body.signal === "string" ? body.signal.trim() : "";
+  if (signal === "introspection" && !config.introspection.enabled) return error("introspection disabled", 409);
+  if (signal === "context_ratio" && !config.contextRatio.enabled) return error("contextRatio disabled", 409);
+  try {
+    const observation = recordObservation({
+      sessionId: typeof body.sessionId === "string" ? body.sessionId : "",
+      agentId: typeof body.agentId === "string" ? body.agentId : undefined,
+      project: typeof body.project === "string" ? body.project : undefined,
+      signal,
+      value: isRecord(body.value) ? body.value : {},
+      outcome: isRecord(body.outcome) ? body.outcome : undefined,
+      source: body.source === "server" ? "server" : "agent",
+    });
+    return json(observation, 201);
+  } catch (e) {
+    if (e instanceof ValidationError) return error(e.message, 400);
+    throw e;
+  }
+};
+
 // --- Config routes ---
 
 function normalizeConfigPathParam(raw: string | undefined, field: string): string {
@@ -5608,6 +5676,43 @@ const putConnectorConfig: Handler = async (req, params) => {
   }
 };
 
+// Endpoints a connector daemon may expose for the dashboard to call through the
+// relay (single-origin — no CORS, no extra port exposure). Kept to a small,
+// non-mutating allowlist; the connector advertises its HTTP base via its status.
+const PROXYABLE_CONNECTOR_CALLS = new Set(["transcribe", "utterance"]);
+
+function connectorAdvertisedEndpoint(connector: NonNullable<ReturnType<typeof getConnector>>): string | null {
+  const raw = connector.state?.raw;
+  if (isRecord(raw) && typeof raw.endpoint === "string" && raw.endpoint) return raw.endpoint;
+  const cfg = connector.config;
+  if (isRecord(cfg) && typeof cfg.endpoint === "string" && cfg.endpoint) return cfg.endpoint;
+  return null;
+}
+
+const postConnectorCall: Handler = async (req, params) => {
+  const connector = getConnector(params.id!);
+  if (!connector) return error("connector not found", 404);
+  const name = params.name!;
+  if (!PROXYABLE_CONNECTOR_CALLS.has(name)) return error("unsupported connector call", 404);
+  const endpoint = connectorAdvertisedEndpoint(connector);
+  if (!endpoint) return error("connector is not running (no advertised endpoint)", 422);
+  try {
+    const body = await req.arrayBuffer();
+    const res = await fetch(`${endpoint.replace(/\/$/, "")}/${name}`, {
+      method: "POST",
+      headers: { "content-type": req.headers.get("content-type") || "application/octet-stream" },
+      body,
+      signal: AbortSignal.timeout(120_000),
+    });
+    return new Response(res.body, {
+      status: res.status,
+      headers: { "content-type": res.headers.get("content-type") || "application/json" },
+    });
+  } catch (e) {
+    return error(`failed to reach connector: ${(e as Error).message}`, 502);
+  }
+};
+
 // --- Tasks and integrations ---
 
 function reconcileIntegrationRegistry(configured: Map<string, IntegrationTokenConfig>, observedStats: Map<string, ReturnType<typeof listIntegrationTaskStats>[number]>): Map<string, ReturnType<typeof listIntegrationRegistry>[number]> {
@@ -6464,6 +6569,10 @@ const routes: Route[] = [
   route("DELETE", "/api/agent-profiles/:name", deleteAgentProfileRoute),
   route("GET", "/api/steward-config", getStewardConfigRoute),
   route("PUT", "/api/steward-config", putStewardConfigRoute),
+  route("GET", "/api/insights/config", getInsightsConfigRoute),
+  route("PUT", "/api/insights/config", putInsightsConfigRoute),
+  route("GET", "/api/insights/observations", getInsightsObservationsRoute),
+  route("POST", "/api/insights/observations", postInsightsObservationRoute),
   route("GET", "/api/config/:namespace", getConfigNamespace),
   route("GET", "/api/config/:namespace/:key/history", getConfigKeyHistory),
   route("GET", "/api/config/:namespace/:key", getConfigKey),
@@ -6520,6 +6629,7 @@ const routes: Route[] = [
   route("POST", "/api/connectors/:id/actions", postConnectorAction),
   route("GET", "/api/connectors/:id/config", getConnectorConfig),
   route("PUT", "/api/connectors/:id/config", putConnectorConfig),
+  route("POST", "/api/connectors/:id/call/:name", postConnectorCall),
 
   route("GET", "/api/channels", getChannels),
   route("POST", "/api/channels/:id/events", postChannelEvent),

package/src/sse.ts

@@ -252,8 +252,19 @@ function isInboundChannelMessage(msg: Message): boolean {
   return msg.kind === "channel.event" && direction === "inbound" && event?.type === "message.created";
 }
 
+function sessionMirrorType(msg: Message): string | undefined {
+  const session = isRecord(msg.payload?.session) ? msg.payload.session : undefined;
+  return typeof session?.type === "string" ? session.type : undefined;
+}
+
 function notificationForMessage(msg: Message): RelayNotification | undefined {
   if (msg.from === "user") return undefined;
+  // Session-mirror activity (reasoning/tool/notice) is high-frequency telemetry, not
+  // something to notify on. Only the response turn warrants a notification; interactive
+  // prompts (AskUserQuestion, permission, plan-mode) notify via providerState in
+  // notificationForAgentStatus, not here — so suppressing non-response session events
+  // doesn't silence anything the user must act on.
+  if (msg.kind === "session" && sessionMirrorType(msg) !== "response") return undefined;
   const isDirectToUser = msg.to === "user";
   const isChannelInbound = isInboundChannelMessage(msg);
   if (!isDirectToUser && !isChannelInbound) return undefined;