agent-relay-server 0.65.2 → 0.67.0

package/src/config.ts

@@ -51,6 +51,7 @@ export const STALE_TTL_MS = envPositiveInt("STALE_TTL_MS", 120_000); // 2min wit
 // registered with Relay. Keep this above the runner's own 60s registration timeout so the runner's
 // direct failure path wins first; this is the relay-side dead-man switch.
 export const SPAWN_REGISTRATION_DEADLINE_MS = envPositiveInt("AGENT_RELAY_SPAWN_REGISTRATION_DEADLINE_MS", 120_000);
+export const SPAWN_REGISTRATION_NOTIFY_MAX_AGE_MS = envPositiveInt("AGENT_RELAY_SPAWN_REGISTRATION_NOTIFY_MAX_AGE_MS", 15 * 60_000);
 // #451 — default TTL for fire-and-forget FAN-OUT messages (broadcast/tag/cap/label/team) that the
 // sender didn't bound. A stale fan-out push must not wake an agent that matches the target hours
 // later (the cold-session-woken-by-old-coordination-thread bug). Direct DMs, reply-obligations, and

package/src/context-advisory.ts

@@ -1,7 +1,11 @@
-import { getNotificationsConfig } from "./config-store";
+import { deriveContextThresholdFromWindowTokens, resolveProviderContextThreshold, type ProviderModelCatalogEntry, type ResolvedProviderContextThreshold } from "agent-relay-sdk/provider-catalog";
+import { isRecord, SPAWN_PROVIDERS } from "agent-relay-sdk";
+import { getConfig, getNotificationsConfig } from "./config-store";
+import { DEFAULT_CONTEXT_THRESHOLD_CONFIG, validateContextThresholdConfig } from "./context-threshold-config";
 import { getDb } from "./db/connection.ts";
 import { emitRelayEvent } from "./events";
 import { routeNotification } from "./notification-router";
+import { effectiveProviderCatalogList } from "./provider-catalog-store";
 import type { AgentCard, Command, ContextState } from "./types";
 
 interface ContextAdvisoryInput {
@@ -10,7 +14,17 @@ interface ContextAdvisoryInput {
   percent: number;
   windowTokens: number;
   band: number;
+  stage: ContextAdvisoryStage;
+  selfCompactPercent: number;
+  warnPercent: number;
   hardBackstopPercent: number;
+  thresholdSource: string;
+}
+
+type ContextAdvisoryStage = "warn" | "self-compact";
+
+interface EffectiveContextThreshold extends ResolvedProviderContextThreshold {
+  source: "model" | "global" | "window";
 }
 
 /**
@@ -25,7 +39,11 @@ function notifyContextAdvisory(input: ContextAdvisoryInput): void {
     percent: input.percent,
     windowTokens: input.windowTokens,
     band: input.band,
+    stage: input.stage,
+    selfCompactPercent: input.selfCompactPercent,
+    warnPercent: input.warnPercent,
     hardBackstopPercent: input.hardBackstopPercent,
+    thresholdSource: input.thresholdSource,
   };
 
   emitRelayEvent({
@@ -45,19 +63,29 @@ function notifyContextAdvisory(input: ContextAdvisoryInput): void {
     scope: { agentId: input.agentId },
     recipients: [input.agentId],
     message: {
-      subject: "Context threshold reached",
-      body: `Context advisory: ${formatTokens(input.tokens)} / ${formatTokens(input.windowTokens)} tokens used (${input.percent}% of window, ${input.band}% band). Compact at a clean seam before the ${input.hardBackstopPercent}% hard backstop may request compaction.`,
+      subject: input.stage === "warn" ? "Context threshold warning" : "Context self-compact threshold reached",
+      body: contextAdvisoryBody(input),
       payload,
       replyExpected: false,
     },
   });
 }
 
-function contextAdvisoryBand(utilization: number, advisoryUtilization: number, bandSize: number): number | null {
-  if (!Number.isFinite(utilization) || utilization < advisoryUtilization) return null;
-  const percent = Math.min(100, Math.max(0, utilization * 100));
-  const step = Math.max(1, bandSize * 100);
-  return Math.min(100, Math.floor(percent / step) * step);
+function contextAdvisoryBody(input: ContextAdvisoryInput): string {
+  const usage = `${formatTokens(input.tokens)} / ${formatTokens(input.windowTokens)} tokens used (${input.percent}% of window, ${input.band}% band)`;
+  const threshold = `resolved self-compact threshold ${input.selfCompactPercent}% (${input.thresholdSource})`;
+  if (input.stage === "warn") {
+    return `Context warning: ${usage}. You are approaching the ${threshold}; if the current task is at a clean seam, prepare to call relay_compact_and_resume before continuing.`;
+  }
+  return `Context advisory: ${usage}. You are over the ${threshold}; call relay_compact_and_resume at the next clean seam between tasks or waves, not mid-edit. The ${input.hardBackstopPercent}% hard backstop may request compaction if usage keeps climbing.`;
+}
+
+function contextAdvisoryBand(utilization: number, threshold: EffectiveContextThreshold): { band: number; stage: ContextAdvisoryStage } | null {
+  if (!Number.isFinite(utilization) || utilization < threshold.warnUtilization) return null;
+  if (utilization >= threshold.selfCompactUtilization) {
+    return { band: utilizationPercent(threshold.selfCompactUtilization), stage: "self-compact" };
+  }
+  return { band: utilizationPercent(threshold.warnUtilization), stage: "warn" };
 }
 
 export function handleContextPressure(input: {
@@ -71,9 +99,9 @@ export function handleContextPressure(input: {
   if (!context || agent.status === "busy") return false;
   if (context.lifecycleState === "compacting" || context.lifecycleState === "hibernating") return false;
   if (typeof context.utilization !== "number" || !Number.isFinite(context.utilization)) return false;
-  const threshold = getNotificationsConfig().contextThreshold;
-  const band = contextAdvisoryBand(context.utilization, threshold.advisoryUtilization, threshold.bandSize);
-  if (band === null) {
+  const threshold = effectiveContextThreshold(agent);
+  const advisory = contextAdvisoryBand(context.utilization, threshold);
+  if (advisory === null) {
     if (context.lastContextAdvisoryBand !== undefined || context.lastContextAdvisoryAt !== undefined) {
       persistContextState(agent.id, clearContextAdvisory(context));
     }
@@ -83,7 +111,7 @@ export function handleContextPressure(input: {
     input.compact("context-hard-backstop");
     return true;
   }
-  if (context.lastContextAdvisoryBand === band) return false;
+  if (context.lastContextAdvisoryBand === advisory.band) return false;
   const tokens = finiteNumber(context.tokensUsed);
   const windowTokens = finiteNumber(context.tokensMax);
   if (tokens === undefined || windowTokens === undefined) return false;
@@ -92,13 +120,55 @@ export function handleContextPressure(input: {
     tokens,
     percent: Math.round(context.utilization * 100),
     windowTokens,
-    band,
-    hardBackstopPercent: Math.round(threshold.hardBackstopUtilization * 100),
+    band: advisory.band,
+    stage: advisory.stage,
+    warnPercent: utilizationPercent(threshold.warnUtilization),
+    selfCompactPercent: utilizationPercent(threshold.selfCompactUtilization),
+    hardBackstopPercent: utilizationPercent(threshold.hardBackstopUtilization),
+    thresholdSource: threshold.source,
   });
-  persistContextState(agent.id, { ...context, lastContextAdvisoryBand: band, lastContextAdvisoryAt: now() });
+  persistContextState(agent.id, { ...context, lastContextAdvisoryBand: advisory.band, lastContextAdvisoryAt: now() });
   return true;
 }
 
+function effectiveContextThreshold(agent: AgentCard): EffectiveContextThreshold {
+  const model = findAgentCatalogModel(agent);
+  const windowTokens = model?.limits?.contextWindowTokens?.value
+    ?? finiteNumber(agent.providerCapabilities?.context?.windowTokens)
+    ?? finiteNumber(agent.context?.tokensMax);
+  if (model?.contextThreshold) {
+    return { ...resolveProviderContextThreshold(model), source: "model" };
+  }
+  const global = explicitContextThresholdConfig();
+  if (global) return global;
+  return { ...deriveContextThresholdFromWindowTokens(windowTokens), source: "window" };
+}
+
+function explicitContextThresholdConfig(): EffectiveContextThreshold | undefined {
+  const entry = getConfig("notifications", "default");
+  if (!entry || !isRecord(entry.value) || !isRecord(entry.value.contextThreshold)) return undefined;
+  const global = validateContextThresholdConfig({ ...DEFAULT_CONTEXT_THRESHOLD_CONFIG, ...entry.value.contextThreshold });
+  const selfCompactUtilization = global.selfCompactUtilization ?? global.advisoryUtilization;
+  return {
+    selfCompactUtilization,
+    warnUtilization: global.warnUtilization ?? Math.max(0, roundUtilization(selfCompactUtilization - 0.1)),
+    hardBackstopUtilization: global.hardBackstopUtilization,
+    source: "global",
+  };
+}
+
+function findAgentCatalogModel(agent: AgentCard): ProviderModelCatalogEntry | undefined {
+  const runtime = agent.providerCapabilities?.model;
+  const provider = runtime?.provider;
+  if (!provider || !(SPAWN_PROVIDERS as readonly string[]).includes(provider)) return undefined;
+  const catalog = effectiveProviderCatalogList().find((entry) => entry.provider === provider);
+  if (!catalog) return undefined;
+  const ids = [runtime.alias, runtime.id, runtime.providerModel].filter((value): value is string => Boolean(value));
+  const lowerIds = new Set(ids.map((id) => id.toLowerCase()));
+  return catalog.models.find((model) => ids.includes(model.alias) || ids.includes(model.providerModel))
+    ?? catalog.models.find((model) => lowerIds.has(model.alias.toLowerCase()) || lowerIds.has(model.providerModel.toLowerCase()));
+}
+
 function clearContextAdvisory(context: ContextState): ContextState {
   const { lastContextAdvisoryBand: _band, lastContextAdvisoryAt: _at, ...rest } = context;
   return rest;
@@ -112,6 +182,14 @@ function finiteNumber(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 
+function utilizationPercent(value: number): number {
+  return Math.round(value * 100);
+}
+
+function roundUtilization(value: number): number {
+  return Math.round(value * 1000) / 1000;
+}
+
 function formatTokens(value: number): string {
   return Math.round(value).toLocaleString("en-US");
 }

package/src/context-threshold-config.ts

@@ -14,13 +14,25 @@ export function validateContextThresholdConfig(value: unknown): NotificationsCon
   const bandSize = cleanFraction(input.bandSize, "contextThreshold.bandSize", DEFAULT_CONTEXT_THRESHOLD_CONFIG.bandSize);
   if (bandSize <= 0) throw new ValidationError("contextThreshold.bandSize must be greater than 0");
   const advisoryUtilization = cleanFraction(input.advisoryUtilization, "contextThreshold.advisoryUtilization", DEFAULT_CONTEXT_THRESHOLD_CONFIG.advisoryUtilization);
+  const selfCompactUtilization = input.selfCompactUtilization === undefined || input.selfCompactUtilization === null
+    ? undefined
+    : cleanFraction(input.selfCompactUtilization, "contextThreshold.selfCompactUtilization", advisoryUtilization);
+  const warnUtilization = input.warnUtilization === undefined || input.warnUtilization === null
+    ? undefined
+    : cleanFraction(input.warnUtilization, "contextThreshold.warnUtilization", Math.max(0, (selfCompactUtilization ?? advisoryUtilization) - 0.1));
   const hardBackstopUtilization = cleanFraction(input.hardBackstopUtilization, "contextThreshold.hardBackstopUtilization", DEFAULT_CONTEXT_THRESHOLD_CONFIG.hardBackstopUtilization);
-  if (hardBackstopUtilization <= advisoryUtilization) {
-    throw new ValidationError("contextThreshold.hardBackstopUtilization must be greater than contextThreshold.advisoryUtilization");
+  const compactUtilization = selfCompactUtilization ?? advisoryUtilization;
+  if (warnUtilization !== undefined && warnUtilization >= compactUtilization) {
+    throw new ValidationError("contextThreshold.warnUtilization must be less than contextThreshold.selfCompactUtilization");
+  }
+  if (hardBackstopUtilization <= compactUtilization) {
+    throw new ValidationError("contextThreshold.hardBackstopUtilization must be greater than contextThreshold.selfCompactUtilization");
   }
   return {
     enabled: input.enabled === undefined ? DEFAULT_CONTEXT_THRESHOLD_CONFIG.enabled : cleanBoolean(input.enabled, "contextThreshold.enabled"),
     advisoryUtilization,
+    ...(selfCompactUtilization !== undefined ? { selfCompactUtilization } : {}),
+    ...(warnUtilization !== undefined ? { warnUtilization } : {}),
     hardBackstopUtilization,
     bandSize,
   };

package/src/db/migrations.ts

@@ -17,6 +17,8 @@ import { matchAgents } from "../agent-ref";
 import { getDb } from "./connection.ts";
 import { ensureContinuationArchiveSearchSchema } from "./continuation-archives.ts";
 import { normalizeReactionEmoji } from "./mappers.ts";
+import { projectRootsMissingIssueRepo, setProjectIssueRepo } from "./projects.ts";
+import { repoFromGitRemote } from "../services/git-remote.ts";
 import type {
   AgentCard,
   ActivityEvent,
@@ -108,6 +110,21 @@ function normalizeExistingMessageReactions(): void {
   migrate(rows);
 }
 
+function backfillProjectIssueRepos(): void {
+  const repaired = new Set<string>();
+  for (const row of projectRootsMissingIssueRepo()) {
+    if (repaired.has(row.projectId)) continue;
+    try {
+      const repo = repoFromGitRemote(row.rootPath);
+      if (!repo) continue;
+      setProjectIssueRepo(row.projectId, repo, { onlyIfNull: true });
+      repaired.add(row.projectId);
+    } catch {
+      // Best-effort startup repair: a missing root or unavailable git must not block Relay.
+    }
+  }
+}
+
 
 // Incremental schema migrations + one-shot backfills, applied after the base DDL
 // in initDb(). Ordering matters: each block guards on the current column/table
@@ -453,6 +470,13 @@ export function applyMigrations(): void {
     getDb().run("ALTER TABLE provider_model_overrides ADD COLUMN disabled INTEGER NOT NULL DEFAULT 0");
   }
 
+  // Migration: projects.issue_repo (#533) — per-project `owner/repo` for #NNN linkify/land-close.
+  const projectCols = (getDb().query("PRAGMA table_info(projects)").all() as any[]).map((c: any) => c.name);
+  if (!projectCols.includes("issue_repo")) {
+    getDb().run("ALTER TABLE projects ADD COLUMN issue_repo TEXT");
+  }
+  backfillProjectIssueRepos();
+
   // Migration: orchestrators.api_url
   const orchCols = getDb().query("PRAGMA table_info(orchestrators)").all() as any[];
   const orchColNames = orchCols.map((c: any) => c.name);

package/src/db/projects.ts

@@ -14,6 +14,7 @@ interface ProjectRow {
   title: string | null;
   description: string | null;
   tenant_id: string | null;
+  issue_repo: string | null;
   status: Project["status"];
   created_at: number;
   updated_at: number;
@@ -36,6 +37,7 @@ function rowToProject(row: ProjectRow): Project {
     ...(row.title ? { title: row.title } : {}),
     ...(row.description ? { description: row.description } : {}),
     ...(row.tenant_id ? { tenantId: row.tenant_id } : {}),
+    ...(row.issue_repo ? { issueRepo: row.issue_repo } : {}),
     status: row.status,
     createdAt: row.created_at,
     updatedAt: row.updated_at,
@@ -76,30 +78,44 @@ export function rootsForProject(id: string): ProjectRoot[] {
   return rows.map(rowToRoot);
 }
 
+export function projectRootsMissingIssueRepo(): Array<{ projectId: string; rootPath: string }> {
+  return getDb().query(`
+    SELECT p.id AS projectId, pr.root_path AS rootPath
+    FROM projects p
+    JOIN project_roots pr ON pr.project_id = p.id
+    WHERE p.issue_repo IS NULL OR trim(p.issue_repo) = ''
+    ORDER BY p.created_at ASC, p.id ASC, pr.root_path ASC
+  `).all() as Array<{ projectId: string; rootPath: string }>;
+}
+
 interface EnsureProjectInput {
   slug: string;
   title?: string;
   description?: string;
   tenantId?: string;
+  /** Explicit `owner/repo` override (#533); when set it wins over the git-remote-derived
+   *  default. A bare derived value is filled separately via setProjectIssueRepo(onlyIfNull). */
+  issueRepo?: string;
 }
 
 /** Get-or-create a project by slug. The create-on-first-use analog of ensureTeam;
- * updates title/description/tenant on an existing project only when provided. */
+ * updates title/description/tenant/issueRepo on an existing project only when provided. */
 export function ensureProject(input: EnsureProjectInput): Project {
   const slug = input.slug.trim();
   if (!slug) throw new ValidationError("slug required");
   const existing = getProjectBySlug(slug);
   const now = Date.now();
   if (existing) {
-    if (input.title !== undefined || input.description !== undefined || input.tenantId !== undefined) {
+    if (input.title !== undefined || input.description !== undefined || input.tenantId !== undefined || input.issueRepo !== undefined) {
       getDb().query(`
         UPDATE projects
-        SET title = ?, description = ?, tenant_id = ?, updated_at = ?
+        SET title = ?, description = ?, tenant_id = ?, issue_repo = ?, updated_at = ?
         WHERE id = ?
       `).run(
         input.title ?? existing.title ?? null,
         input.description ?? existing.description ?? null,
         input.tenantId ?? existing.tenantId ?? null,
+        input.issueRepo ?? existing.issueRepo ?? null,
         now,
         existing.id,
       );
@@ -109,12 +125,24 @@ export function ensureProject(input: EnsureProjectInput): Project {
   }
   const id = projectId();
   getDb().query(`
-    INSERT INTO projects (id, slug, title, description, tenant_id, status, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, 'active', ?, ?)
-  `).run(id, slug, input.title ?? null, input.description ?? null, input.tenantId ?? null, now, now);
+    INSERT INTO projects (id, slug, title, description, tenant_id, issue_repo, status, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?)
+  `).run(id, slug, input.title ?? null, input.description ?? null, input.tenantId ?? null, input.issueRepo ?? null, now, now);
   return getProject(id)!;
 }
 
+/** Set (or clear, with null) a project's `issueRepo` (#533). With `onlyIfNull`, a value is
+ * written only when none is set yet — the mechanism for the git-remote AUTO-DERIVE to fill
+ * a fresh project without ever clobbering an explicit override or a prior derivation. */
+export function setProjectIssueRepo(id: string, issueRepo: string | null, opts: { onlyIfNull?: boolean } = {}): Project | null {
+  const project = getProject(id);
+  if (!project) return null;
+  if (opts.onlyIfNull && project.issueRepo) return project;
+  const value = issueRepo?.trim() || null;
+  getDb().query("UPDATE projects SET issue_repo = ?, updated_at = ? WHERE id = ?").run(value, Date.now(), id);
+  return getProject(id);
+}
+
 /** Register a root path for a project (idempotent — UNIQUE(project_id, root_path)). */
 export function addProjectRoot(id: string, rootPath: string): ProjectRoot[] {
   const project = getProject(id);

package/src/db/schema.ts

@@ -207,6 +207,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
       title TEXT,
       description TEXT,
       tenant_id TEXT,
+      issue_repo TEXT,
       status TEXT NOT NULL DEFAULT 'active',
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL

package/src/mcp/tools-workspace.ts

@@ -13,14 +13,14 @@ import { optionalBoolean, optionalPositiveInt, optionalString } from "./validati
 export const WORKSPACE_TOOLS: ToolDefinition[] = [
   {
     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 your own workspace; pass workspaceId to target another.",
+    description: "Get your isolated workspace's lifecycle status (active/ready/conflict/review_requested/merged/...). With wait:true this BLOCKS until the status changes; do not use wait:true after relay_workspace_ready unless explicitly debugging. Normal branch workers mark ready, stop their turn, and are woken later by landed-success or landed-failure notifications. Defaults to your own workspace; pass workspaceId to target another.",
     requiredScopes: ["agents:read", "agent:read", "agent:write"],
     alwaysLoad: true,
     inputSchema: {
       type: "object",
       properties: {
         workspaceId: { type: "string", description: "Defaults to your own isolated workspace (resolved from your identity)." },
-        wait: { type: "boolean", description: "Block until the workspace status changes (the actionable signal), or until the timeout." },
+        wait: { type: "boolean", description: "Block until the workspace status changes (the actionable signal), or until the timeout. Do not use this after relay_workspace_ready in the normal worker flow; stop and wait for landed-success/landed-failure instead." },
         timeoutSeconds: { type: "integer", minimum: 1, maximum: 600, description: "Max seconds to wait when wait:true (default 300, max 600). Returns early on any transition." },
       },
       additionalProperties: false,
@@ -28,7 +28,7 @@ export const WORKSPACE_TOOLS: ToolDefinition[] = [
   },
   {
     name: "relay_workspace_ready",
-    description: "Signal that your branch work is finished and ready to merge back to main. This kicks off the auto-merge-back: a clean merge lands immediately; on conflict a steward agent reconciles and lands it (escalating if it can't). After this, poll relay_workspace_status with wait:true until it lands and you get a fresh rebased branch to continue on. Defaults to your own workspace.",
+    description: "Signal that your branch work is finished and ready to merge back to main. This kicks off the auto-merge-back: a clean merge lands immediately; on conflict a steward agent reconciles and lands it (escalating if it can't). After this tool returns, stop your turn and go idle; Relay wakes you later with landed-success when the merge lands and your branch refreshes, or landed-failure if landing fatally fails. Defaults to your own workspace.",
     requiredScopes: ["agent:write"],
     alwaysLoad: true,
     inputSchema: {

package/src/mcp-project-tools.ts

@@ -62,6 +62,7 @@ export const PROJECT_TOOLS = [
         title: { type: "string" },
         description: { type: "string" },
         tenantId: { type: "string" },
+        issueRepo: { type: "string", description: "Explicit owner/repo for #NNN linkify; overrides the git-remote-derived default (#533)." },
       },
       required: ["slug", "rootPath"],
       additionalProperties: false,
@@ -273,6 +274,7 @@ export function relayProjectTool(auth: McpAuthLike, name: string, args: Record<s
       title: cleanString(args.title, "title", { max: 240 }),
       description: cleanString(args.description, "description", { max: 16_000 }),
       tenantId: cleanString(args.tenantId, "tenantId", { max: 200 }),
+      issueRepo: cleanString(args.issueRepo, "issueRepo", { max: 200 }),
     });
     return { project, roots };
   }

package/src/notification-router.ts

@@ -17,6 +17,7 @@ import type { Message, MessageKind } from "./types";
  * it, so emitters are converted exactly once and the rule engine has its inputs the day it lands.
  */
 export type NotificationType =
+  | "landed-failure"
   | "branch.landed"
   | "agent.ready"
   | "agent.exited"
@@ -99,6 +100,7 @@ const MINUTES = 60 * 1000;
  * Emitters opt INTO a shorter TTL per-call for the bystander/informational cases.
  */
 export const DEFAULT_TTL_MS: Record<NotificationType, number | null> = {
+  "landed-failure": null,
   "branch.landed": null,
   "agent.ready": null,
   "agent.exited": null,

package/src/provider-catalog-store.ts

@@ -1,6 +1,7 @@
 import {
   providerCatalogList,
   type ProviderCatalogEntry,
+  type ProviderContextThreshold,
   type ProviderModelCatalogEntry,
 } from "agent-relay-sdk/provider-catalog";
 import { SPAWN_PROVIDERS } from "agent-relay-sdk";
@@ -145,6 +146,9 @@ function normalizeOverrideInput(input: ProviderModelOverrideInput): ProviderMode
   if (!input.entry.providerModel?.trim()) throw new ValidationError("provider model is required");
   if (!Array.isArray(input.entry.efforts)) throw new ValidationError("model efforts must be an array");
   const entry = cloneModelEntry({ ...input.entry, alias });
+  const contextThreshold = normalizeContextThreshold(entry.contextThreshold);
+  if (contextThreshold) entry.contextThreshold = contextThreshold;
+  else delete entry.contextThreshold;
   delete entry.disabled;
   return {
     ...input,
@@ -183,3 +187,34 @@ function cloneProviderEntry(entry: ProviderCatalogEntry): ProviderCatalogEntry {
 function cloneModelEntry(entry: ProviderModelCatalogEntry): ProviderModelCatalogEntry {
   return JSON.parse(JSON.stringify(entry)) as ProviderModelCatalogEntry;
 }
+
+function normalizeContextThreshold(value: unknown): ProviderContextThreshold | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "object" || Array.isArray(value)) throw new ValidationError("contextThreshold must be an object");
+  const input = value as Record<string, unknown>;
+  const selfCompactUtilization = cleanFraction(input.selfCompactUtilization, "contextThreshold.selfCompactUtilization");
+  const warnUtilization = input.warnUtilization === undefined || input.warnUtilization === null
+    ? undefined
+    : cleanFraction(input.warnUtilization, "contextThreshold.warnUtilization");
+  const hardBackstopUtilization = input.hardBackstopUtilization === undefined || input.hardBackstopUtilization === null
+    ? undefined
+    : cleanFraction(input.hardBackstopUtilization, "contextThreshold.hardBackstopUtilization");
+  if (warnUtilization !== undefined && warnUtilization >= selfCompactUtilization) {
+    throw new ValidationError("contextThreshold.warnUtilization must be less than contextThreshold.selfCompactUtilization");
+  }
+  if (hardBackstopUtilization !== undefined && hardBackstopUtilization <= selfCompactUtilization) {
+    throw new ValidationError("contextThreshold.hardBackstopUtilization must be greater than contextThreshold.selfCompactUtilization");
+  }
+  return {
+    selfCompactUtilization,
+    ...(warnUtilization !== undefined ? { warnUtilization } : {}),
+    ...(hardBackstopUtilization !== undefined ? { hardBackstopUtilization } : {}),
+  };
+}
+
+function cleanFraction(value: unknown, field: string): number {
+  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;
+}

package/src/routes/agents.ts

@@ -2,6 +2,7 @@
 import { VALID_AGENT_STATUSES, agentSessionStatus, auditEvent, error, json, memoryContext, memoryErrorResponse, normalizeAgentSessionGuard, parseBody, parseId, parseQueryInt, type Handler } from "./_shared";
 import { ValidationError, deleteAgent, getAgent, getAgentTimeline, heartbeat, listAgentChatHistory, listAgents, listArtifactsForEntity, listContextSnapshots, listPendingReplyObligations, markReady, searchAgents, setLabel, setStatus, setTags, validateAgentSession } from "../db";
 import { attachBranchState, attachBranchStates } from "../agent-branch-state";
+import { attachIssueRepo, attachIssueRepos } from "../agent-issue-repo";
 import { cleanStringArray } from "../validation";
 import { clearActiveMemories, memoryBroker } from "../memory-service";
 import { emitAgentRemoved, emitAgentStatus } from "../sse";
@@ -44,7 +45,7 @@ export const getAgents: Handler = (req) => {
   const tag = url.searchParams.get("tag") ?? undefined;
   const machine = url.searchParams.get("machine") ?? undefined;
   const status = url.searchParams.get("status") ?? undefined;
-  return json(attachBranchStates(listAgents({ tag, machine, status })));
+  return json(attachIssueRepos(attachBranchStates(listAgents({ tag, machine, status }))));
 };
 
 export const findAgents: Handler = (req) => {
@@ -57,7 +58,7 @@ export const findAgents: Handler = (req) => {
 
 export const getAgentById: Handler = (_req, params) => {
   const agent = getAgent(params.id!);
-  return agent ? json(attachBranchState(agent)) : error("agent not found", 404);
+  return agent ? json(attachIssueRepo(attachBranchState(agent))) : error("agent not found", 404);
 };
 
 export const getAgentReplyObligations: Handler = (_req, params) => {

package/src/routes/commands.ts

@@ -12,7 +12,7 @@ import { isRecord } from "agent-relay-sdk";
 import { authContextFromRequest } from "../services/auth-context";
 import { commandAuthorizationResource as dispatchCommandAuthorizationResource, dispatchCommand } from "../services/dispatch-command";
 import { ServiceAuthError } from "../services/errors";
-import { notifyBranchLanded } from "../branch-landed";
+import { notifyBranchLandFailed, notifyBranchLanded } from "../branch-landed";
 import { seedProviderConfigs } from "../provider-config-store";
 import { notifyAgentSpawnFailed } from "../agent-lifecycle-events";
 import { handleReviewerMergeResult } from "../reviewer-pipeline";
@@ -266,6 +266,11 @@ export const patchCommand: Handler = async (req, params) => {
             mergeCommandId: command.id,
             mergeError: command.error ?? "merge failed",
           });
+          notifyBranchLandFailed({
+            workspace: current,
+            commandId: command.id,
+            reason: command.error ?? "merge failed",
+          });
         }
       }
     }

package/src/routes/provider-config.ts

@@ -139,16 +139,43 @@ function cleanProviderModelEntry(alias: string, body: Record<string, unknown>):
     efforts,
     ...(defaultEffort ? { defaultEffort } : {}),
     ...(isRecord(source.limits) ? { limits: source.limits as ProviderModelCatalogEntry["limits"] } : {}),
+    ...(isRecord(source.contextThreshold) ? { contextThreshold: cleanProviderContextThreshold(source.contextThreshold) } : {}),
     ...(isRecord(source.capabilities) ? { capabilities: source.capabilities as unknown as ProviderModelCatalogEntry["capabilities"] } : {}),
   };
 }
 
+function cleanProviderContextThreshold(source: Record<string, unknown>): NonNullable<ProviderModelCatalogEntry["contextThreshold"]> {
+  const selfCompactUtilization = optionalFraction(source.selfCompactUtilization, "contextThreshold.selfCompactUtilization");
+  if (selfCompactUtilization === undefined) throw new ValidationError("contextThreshold.selfCompactUtilization required");
+  const warnUtilization = optionalFraction(source.warnUtilization, "contextThreshold.warnUtilization");
+  const hardBackstopUtilization = optionalFraction(source.hardBackstopUtilization, "contextThreshold.hardBackstopUtilization");
+  if (warnUtilization !== undefined && warnUtilization >= selfCompactUtilization) {
+    throw new ValidationError("contextThreshold.warnUtilization must be less than contextThreshold.selfCompactUtilization");
+  }
+  if (hardBackstopUtilization !== undefined && hardBackstopUtilization <= selfCompactUtilization) {
+    throw new ValidationError("contextThreshold.hardBackstopUtilization must be greater than contextThreshold.selfCompactUtilization");
+  }
+  return {
+    selfCompactUtilization,
+    ...(warnUtilization !== undefined ? { warnUtilization } : {}),
+    ...(hardBackstopUtilization !== undefined ? { hardBackstopUtilization } : {}),
+  };
+}
+
 function optionalBoolean(value: unknown, field: string): boolean | undefined {
   if (value === undefined || value === null) return undefined;
   if (typeof value !== "boolean") throw new ValidationError(`${field} must be a boolean`);
   return value;
 }
 
+function optionalFraction(value: unknown, field: string): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  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;
+}
+
 export const deleteCommandById: Handler = (_req, params) => {
   if (!deleteCommand(params.id!)) return error("command not found or cannot be canceled", 404);
   const command = getCommand(params.id!);

package/src/services/git-remote.ts

@@ -0,0 +1,46 @@
+// Shared git-remote → `owner/repo` resolution (#533). The SINGLE home for deriving a
+// GitHub `owner/repo` from a repo root's `origin` remote. Used by two callers that must
+// not drift: issue-lifecycle land-close (which repo a bare `#NNN` in a commit subject
+// closes) AND project auto-seed (a project's `issueRepo` for chat #NNN linkify). Promoted
+// out of issue-lifecycle.ts where it was private — see the DRY rule in CLAUDE.md.
+
+/**
+ * `owner/repo` out of any git remote URL form: `git@github.com:owner/repo.git`,
+ * `https://github.com/owner/repo.git`, `ssh://git@host/owner/repo`, trailing slash/`.git`
+ * optional. Pure — exported for tests.
+ */
+export function parseOwnerRepoFromRemote(url: string | undefined): string | undefined {
+  if (!url) return undefined;
+  const match = url.trim().match(/[:/]([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?\/?$/);
+  return match?.[1];
+}
+
+let remoteRepoCache: Map<string, string | undefined> | undefined;
+
+/**
+ * `owner/repo` from a repo root's `origin` remote, cached per root. Works from any
+ * subdirectory of the repo (`git -C` walks up). Returns undefined when the dir isn't a
+ * git repo, has no `origin`, or the URL doesn't parse.
+ */
+export function repoFromGitRemote(repoRoot: string | undefined): string | undefined {
+  if (!repoRoot) return undefined;
+  if (!remoteRepoCache) remoteRepoCache = new Map();
+  if (remoteRepoCache.has(repoRoot)) return remoteRepoCache.get(repoRoot);
+  let repo: string | undefined;
+  try {
+    const proc = Bun.spawnSync(["git", "-C", repoRoot, "remote", "get-url", "origin"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    if (proc.exitCode === 0) repo = parseOwnerRepoFromRemote(Buffer.from(proc.stdout).toString("utf8"));
+  } catch {
+    repo = undefined;
+  }
+  remoteRepoCache.set(repoRoot, repo);
+  return repo;
+}
+
+export function __resetRemoteRepoCacheForTests(): void {
+  remoteRepoCache = undefined;
+}