agent-relay-server 0.65.1 → 0.66.0

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

@@ -453,6 +453,12 @@ 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");
+  }
+
   // 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,
@@ -81,25 +83,29 @@ interface EnsureProjectInput {
   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 +115,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/maintenance/jobs.ts

@@ -33,6 +33,7 @@ import {
 } from "../sse";
 import { pruneExpiredTokenRecords } from "../token-db";
 import { reapTransientAgents } from "../services/transient-agent-reaper";
+import { reapUnregisteredSpawnCommands } from "../services/spawn-registration-watchdog";
 import { resumeRateLimitedAgents } from "../services/rate-limit-resume";
 import { MERGE_PAUSE_MAINTENANCE_JOB } from "../merge-pause-maintenance";
 import {
@@ -125,6 +126,16 @@ export const definitions: MaintenanceJobDefinition[] = [
       return { expiredCommandIds: commands.map((command) => command.id) };
     },
   },
+  {
+    id: "spawn-registration-watchdog",
+    title: "Spawn registration watchdog",
+    description: "Fail parented spawn commands whose runner process started but never registered with Relay.",
+    intervalMs: REAP_INTERVAL_MS,
+    runOnStart: true,
+    handler() {
+      return reapUnregisteredSpawnCommands();
+    },
+  },
   {
     id: "bus-agent-expiration",
     title: "Bus agent expiration",

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/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/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;
+}

package/src/services/issue-lifecycle.ts

@@ -10,6 +10,11 @@ import { getIssueRef, resolveIssueRefByExternalKey, resolveIssueRefFromString, u
 import { associateIssue } from "../db/issue-associations";
 import { resolveIssueTrackerAdapter } from "../issue-tracker";
 import { defaultIssueRepo } from "../config";
+// `repoFromGitRemote` / `parseOwnerRepoFromRemote` live in the shared ./git-remote module
+// (#533) so project auto-seed reuses the exact same logic. Re-exported so this module's
+// existing importers and tests keep their entry point.
+import { parseOwnerRepoFromRemote, repoFromGitRemote, __resetRemoteRepoCacheForTests } from "./git-remote";
+export { parseOwnerRepoFromRemote, repoFromGitRemote, __resetRemoteRepoCacheForTests };
 import type { IssueTrackerAdapter } from "../issue-tracker";
 import { recordAndEmitIssueActivity } from "./issue-activity";
 import type { IssueAssociationEntityType, IssueProvider, IssueRef, WorkspaceRecord } from "../types";
@@ -22,6 +27,7 @@ interface LandedIssueLifecycleInput {
   workspace: LifecycleWorkspace;
   mergedSha?: string;
   subject?: string;
+  commitSubjects?: string[];
   source?: string;
   /**
    * The land happened via a pull request (the squash/merge subject carries a
@@ -79,42 +85,6 @@ function logFailure(opts: IssueLifecycleOptions, message: string): void {
   else console.warn(message);
 }
 
-/**
- * `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;
-
-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;
-}
-
 /**
  * The repo a bare `#NNN` in a land's commit subject resolves against. Derived per-workspace
  * from its own git remote so a single relay serving many repos closes the RIGHT repo's issue;
@@ -146,6 +116,18 @@ function issueRefMap(refs: IssueRef[]): IssueRef[] {
   return [...out.values()];
 }
 
+function landedSubjectTexts(input: LandedIssueLifecycleInput): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const text of [...(input.commitSubjects ?? []), input.subject]) {
+    const cleaned = cleanText(text);
+    if (!cleaned || seen.has(cleaned)) continue;
+    seen.add(cleaned);
+    out.push(cleaned);
+  }
+  return out;
+}
+
 function associatedIssueRefs(workspace: LifecycleWorkspace): IssueRef[] {
   const refs: IssueRef[] = [];
   const owner = workspace.ownerAgentId ? getAgent(workspace.ownerAgentId) : null;
@@ -211,13 +193,14 @@ function resolveIssueRefsForLand(input: LandedIssueLifecycleInput): { source: La
   const associated = associatedIssueRefs(input.workspace);
   if (associated.length > 0) return { source: "association", refs: associated };
   const fallbackDefaultRepo = landDefaultRepo(input.workspace);
-  const keyworded = parseClosingIssueRefs(input.subject, fallbackDefaultRepo);
+  const subjects = landedSubjectTexts(input);
+  const keyworded = issueRefMap(subjects.flatMap((subject) => parseClosingIssueRefs(subject, fallbackDefaultRepo)));
   if (keyworded.length > 0) return { source: "commit", refs: keyworded };
   // Bare `(#NNN)` is closing intent in relay-land mode (no PR), but the SAME shape is the
   // PR number GitHub appends to a squash subject — never close that. Suppress on PR lands;
   // those rely on GitHub-native keywords + durable association instead (#482).
   if (input.prLand) return { source: "commit", refs: [] };
-  return { source: "backlink", refs: parseBacklinkIssueRefs(input.subject, fallbackDefaultRepo) };
+  return { source: "backlink", refs: issueRefMap(subjects.flatMap((subject) => parseBacklinkIssueRefs(subject, fallbackDefaultRepo))) };
 }
 
 function closeAuditComment(input: LandedIssueLifecycleInput): string {

package/src/services/project.ts

@@ -1,7 +1,8 @@
 import { statSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { addProjectRoot, ensureProject, resolveProjectForCwd, rootsForProject } from "../db";
+import { addProjectRoot, ensureProject, resolveProjectForCwd, rootsForProject, setProjectIssueRepo } from "../db";
 import { ingestClaudeMd } from "../project-ingest";
+import { repoFromGitRemote } from "./git-remote";
 import type { Project, ProjectRoot } from "../types";
 
 interface EnsureProjectRootInput {
@@ -10,6 +11,8 @@ interface EnsureProjectRootInput {
   title?: string;
   description?: string;
   tenantId?: string;
+  /** Explicit `owner/repo` override (#533); wins over the git-remote-derived default. */
+  issueRepo?: string;
 }
 
 interface EnsureProjectRootResult {
@@ -33,8 +36,19 @@ export function ensureProjectRoot(input: EnsureProjectRootInput): EnsureProjectR
     ...(input.title !== undefined ? { title: input.title } : {}),
     ...(input.description !== undefined ? { description: input.description } : {}),
     ...(input.tenantId !== undefined ? { tenantId: input.tenantId } : {}),
+    ...(input.issueRepo !== undefined ? { issueRepo: input.issueRepo } : {}),
   });
-  return { project, roots: addProjectRoot(project.id, input.rootPath) };
+  const roots = addProjectRoot(project.id, input.rootPath);
+  // Auto-derive issueRepo from the root's git remote (#533) when not explicitly provided.
+  // `onlyIfNull` ensures an explicit override (or earlier derivation) is never clobbered.
+  if (input.issueRepo === undefined && !project.issueRepo) {
+    const derived = repoFromGitRemote(input.rootPath);
+    if (derived) {
+      const updated = setProjectIssueRepo(project.id, derived, { onlyIfNull: true });
+      if (updated) return { project: updated, roots };
+    }
+  }
+  return { project, roots };
 }
 
 export function ingestProjectClaudeMd(projectId: string, authorId: string): ClaudeMdIngestResult {