agent-relay-server 0.120.1 → 0.120.3

package/src/services/git-process.ts

@@ -0,0 +1,61 @@
+export const LAND_GIT_TIMEOUT_MS = 2_000;
+
+export interface GitProcessResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  timedOut: boolean;
+}
+
+export async function runGit(args: string[], timeoutMs = LAND_GIT_TIMEOUT_MS): Promise<GitProcessResult> {
+  const proc = Bun.spawn(["git", ...args], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const stdoutPromise = streamText(proc.stdout);
+  const stderrPromise = streamText(proc.stderr);
+  const timedOut = await waitForExitOrTimeout(proc, timeoutMs);
+  const [stdout, stderr] = timedOut
+    ? await Promise.all([settleText(stdoutPromise), settleText(stderrPromise)])
+    : await Promise.all([stdoutPromise, stderrPromise]);
+  return { stdout, stderr, exitCode: proc.exitCode ?? 1, timedOut };
+}
+
+async function streamText(stream: ReadableStream<Uint8Array> | null): Promise<string> {
+  if (!stream) return "";
+  try {
+    return await new Response(stream).text();
+  } catch {
+    return "";
+  }
+}
+
+async function settleText(promise: Promise<string>): Promise<string> {
+  return Promise.race([promise, new Promise<string>((resolve) => setTimeout(() => resolve(""), 25))]);
+}
+
+async function waitForExitOrTimeout(proc: Bun.Subprocess<"ignore", "pipe", "pipe">, timeoutMs: number | undefined): Promise<boolean> {
+  if (!timeoutMs || timeoutMs <= 0) {
+    await proc.exited;
+    return false;
+  }
+  let timedOut = false;
+  let kill: ReturnType<typeof setTimeout> | undefined;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    try { proc.kill("SIGTERM"); } catch {}
+    kill = setTimeout(() => {
+      try { proc.kill("SIGKILL"); } catch {}
+    }, 1_000);
+    kill.unref?.();
+  }, timeoutMs);
+  timeout.unref?.();
+  try {
+    await proc.exited;
+  } finally {
+    clearTimeout(timeout);
+    if (kill) clearTimeout(kill);
+  }
+  return timedOut;
+}

package/src/services/git-remote.ts

@@ -3,6 +3,9 @@
 // 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.
+import { runGit } from "./git-process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 
 /**
  * `owner/repo` out of any git remote URL form: `git@github.com:owner/repo.git`,
@@ -18,18 +21,14 @@ export function parseOwnerRepoFromRemote(url: string | undefined): string | unde
 let remoteRepoCache: Map<string, string | undefined> | undefined;
 let remoteUrlCache: Map<string, string | undefined> | undefined;
 
-export function remoteUrlFromGitRemote(repoRoot: string | undefined): string | undefined {
+export async function remoteUrlFromGitRemoteAsync(repoRoot: string | undefined): Promise<string | undefined> {
   if (!repoRoot) return undefined;
   if (!remoteUrlCache) remoteUrlCache = new Map();
   if (remoteUrlCache.has(repoRoot)) return remoteUrlCache.get(repoRoot);
   let url: string | undefined;
   try {
-    const proc = Bun.spawnSync(["git", "-C", repoRoot, "remote", "get-url", "origin"], {
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "ignore",
-    });
-    if (proc.exitCode === 0) url = Buffer.from(proc.stdout).toString("utf8").trim() || undefined;
+    const { stdout, exitCode } = await runGit(["-C", repoRoot, "remote", "get-url", "origin"]);
+    if (exitCode === 0) url = stdout.trim() || undefined;
   } catch {
     url = undefined;
   }
@@ -37,6 +36,24 @@ export function remoteUrlFromGitRemote(repoRoot: string | undefined): string | u
   return url;
 }
 
+export function remoteUrlFromGitRemote(repoRoot: string | undefined): string | undefined {
+  if (!repoRoot) return undefined;
+  if (!remoteUrlCache) remoteUrlCache = new Map();
+  if (remoteUrlCache.has(repoRoot)) return remoteUrlCache.get(repoRoot);
+  const url = remoteUrlFromGitConfig(repoRoot);
+  remoteUrlCache.set(repoRoot, url);
+  return url;
+}
+
+export async function repoFromGitRemoteAsync(repoRoot: string | undefined): Promise<string | undefined> {
+  if (!repoRoot) return undefined;
+  if (!remoteRepoCache) remoteRepoCache = new Map();
+  if (remoteRepoCache.has(repoRoot)) return remoteRepoCache.get(repoRoot);
+  const repo = parseOwnerRepoFromRemote(await remoteUrlFromGitRemoteAsync(repoRoot));
+  remoteRepoCache.set(repoRoot, repo);
+  return repo;
+}
+
 /**
  * `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
@@ -55,3 +72,66 @@ export function __resetRemoteRepoCacheForTests(): void {
   remoteRepoCache = undefined;
   remoteUrlCache = undefined;
 }
+
+function remoteUrlFromGitConfig(repoRoot: string): string | undefined {
+  const gitDir = findGitDir(repoRoot);
+  if (!gitDir) return undefined;
+  return originUrlFromConfig(join(gitDir, "config")) ?? originUrlFromConfig(join(commonGitDir(gitDir) ?? gitDir, "config"));
+}
+
+function findGitDir(start: string): string | undefined {
+  let dir = resolve(start);
+  while (true) {
+    const marker = join(dir, ".git");
+    try {
+      const stat = statSync(marker);
+      if (stat.isDirectory()) return marker;
+      if (stat.isFile()) return gitDirFromFile(marker, dir);
+    } catch {}
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+function gitDirFromFile(marker: string, worktreeRoot: string): string | undefined {
+  try {
+    const content = readFileSync(marker, "utf8").trim();
+    const match = content.match(/^gitdir:\s*(.+)$/i);
+    if (!match?.[1]) return undefined;
+    return isAbsolute(match[1]) ? match[1] : resolve(worktreeRoot, match[1]);
+  } catch {
+    return undefined;
+  }
+}
+
+function commonGitDir(gitDir: string): string | undefined {
+  const commonDirFile = join(gitDir, "commondir");
+  if (!existsSync(commonDirFile)) return undefined;
+  try {
+    const common = readFileSync(commonDirFile, "utf8").trim();
+    if (!common) return undefined;
+    return isAbsolute(common) ? common : resolve(gitDir, common);
+  } catch {
+    return undefined;
+  }
+}
+
+function originUrlFromConfig(configPath: string): string | undefined {
+  let inOrigin = false;
+  try {
+    for (const line of readFileSync(configPath, "utf8").split(/\r?\n/)) {
+      const section = line.match(/^\s*\[(.+)]\s*$/);
+      if (section) {
+        inOrigin = /^remote\s+"origin"$/.test(section[1]!.trim());
+        continue;
+      }
+      if (!inOrigin) continue;
+      const url = line.match(/^\s*url\s*=\s*(.+?)\s*$/);
+      if (url?.[1]) return url[1].trim() || undefined;
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}

package/src/services/issue-lifecycle.ts

@@ -13,7 +13,7 @@ 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";
+import { parseOwnerRepoFromRemote, repoFromGitRemote, repoFromGitRemoteAsync, __resetRemoteRepoCacheForTests } from "./git-remote";
 export { parseOwnerRepoFromRemote, repoFromGitRemote, __resetRemoteRepoCacheForTests };
 import type { IssueTrackerAdapter, IssueTrackerIssueSummary } from "../issue-tracker";
 import { recordAndEmitIssueActivity } from "./issue-activity";
@@ -90,8 +90,8 @@ function logFailure(opts: IssueLifecycleOptions, message: string): void {
  * from its own git remote so a single relay serving many repos closes the RIGHT repo's issue;
  * env (`AGENT_RELAY_DEFAULT_ISSUE_REPO`/`GITHUB_REPOSITORY`) is an override/fallback.
  */
-function landDefaultRepo(workspace: LifecycleWorkspace): string | undefined {
-  return repoFromGitRemote(workspace.repoRoot) ?? defaultIssueRepo();
+async function landDefaultRepo(workspace: LifecycleWorkspace): Promise<string | undefined> {
+  return (await repoFromGitRemoteAsync(workspace.repoRoot)) ?? defaultIssueRepo();
 }
 
 function cleanText(value: string | undefined): string | undefined {
@@ -197,10 +197,10 @@ export function parseBacklinkIssueRefs(text: string | undefined, fallbackDefault
   return issueRefMap(refs);
 }
 
-function resolveIssueRefsForLand(input: LandedIssueLifecycleInput): { source: LandIssueRefSource; refs: IssueRef[] } {
+async function resolveIssueRefsForLand(input: LandedIssueLifecycleInput): Promise<{ source: LandIssueRefSource; refs: IssueRef[] }> {
   const associated = associatedIssueRefs(input.workspace);
   if (associated.length > 0) return { source: "association", refs: associated };
-  const fallbackDefaultRepo = landDefaultRepo(input.workspace);
+  const fallbackDefaultRepo = await landDefaultRepo(input.workspace);
   const subjects = landedSubjectTexts(input);
   const keyworded = issueRefMap(subjects.flatMap((subject) => parseClosingIssueRefs(subject, fallbackDefaultRepo)));
   if (keyworded.length > 0) return { source: "commit", refs: keyworded };
@@ -399,7 +399,7 @@ export async function handleLandedIssueLifecycle(input: LandedIssueLifecycleInpu
   skipped: string[];
 }> {
   if ((input.workspace.baseRef ?? "main") !== "main") return { source: "commit", closed: [], reopened: [], skipped: ["non-default-branch"] };
-  const resolved = resolveIssueRefsForLand(input);
+  const resolved = await resolveIssueRefsForLand(input);
   const closed: CloseIssueLifecycleResult[] = [];
   for (const ref of resolved.refs) {
     closed.push(await closeIssueRefForLand(ref, resolved.source, input, opts));

package/src/services/project.ts

@@ -2,7 +2,7 @@ import { statSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { addProjectRoot, ensureProject, resolveProjectForCwd, rootsForProject, setProjectIssueRepo } from "../db";
 import { ingestClaudeMd } from "../project-ingest";
-import { remoteUrlFromGitRemote, repoFromGitRemote } from "./git-remote";
+import { remoteUrlFromGitRemote, remoteUrlFromGitRemoteAsync, repoFromGitRemote, repoFromGitRemoteAsync } from "./git-remote";
 import type { Project, ProjectRoot } from "../types";
 
 interface EnsureProjectRootInput {
@@ -56,6 +56,26 @@ export function ensureProjectRoot(input: EnsureProjectRootInput): EnsureProjectR
   return { project, roots };
 }
 
+export async function ensureProjectRootAsync(input: EnsureProjectRootInput): Promise<EnsureProjectRootResult> {
+  const project = ensureProject({
+    slug: input.slug,
+    ...(input.title !== undefined ? { title: input.title } : {}),
+    ...(input.description !== undefined ? { description: input.description } : {}),
+    ...(input.tenantId !== undefined ? { tenantId: input.tenantId } : {}),
+    ...(input.issueRepo !== undefined ? { issueRepo: input.issueRepo } : {}),
+  });
+  const remoteUrl = input.remoteUrl ?? await remoteUrlFromGitRemoteAsync(input.rootPath);
+  const roots = addProjectRoot(project.id, input.rootPath, { remoteUrl, ref: input.ref });
+  if (input.issueRepo === undefined && !project.issueRepo) {
+    const derived = await repoFromGitRemoteAsync(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 {
   return ingestClaudeMd(projectId, authorId);
 }
@@ -112,3 +132,29 @@ export function autoSeedProjectForCwd(cwd: string, authorId: string): AutoSeedPr
     return { project, repoRoot, roots, ingestError: err instanceof Error ? err : new Error(String(err)) };
   }
 }
+
+export async function autoSeedProjectForCwdAsync(cwd: string, authorId: string): Promise<AutoSeedProjectResult | null> {
+  const existing = resolveProjectForCwd(cwd);
+  if (existing) {
+    const repoRoot = findGitRepoRoot(cwd) ?? cwd;
+    let project = existing;
+    if (!existing.issueRepo) {
+      const derived = await repoFromGitRemoteAsync(repoRoot);
+      const updated = derived ? setProjectIssueRepo(existing.id, derived, { onlyIfNull: true }) : null;
+      if (updated) project = updated;
+    }
+    return { project, repoRoot, roots: rootsForProject(existing.id) };
+  }
+
+  const repoRoot = findGitRepoRoot(cwd);
+  if (!repoRoot) return null;
+  const slug = basename(repoRoot).trim();
+  if (!slug) return null;
+
+  const { project, roots } = await ensureProjectRootAsync({ slug, rootPath: repoRoot });
+  try {
+    return { project, repoRoot, roots, ingest: ingestProjectClaudeMd(project.id, authorId) };
+  } catch (err) {
+    return { project, repoRoot, roots, ingestError: err instanceof Error ? err : new Error(String(err)) };
+  }
+}

package/src/services/send-message.ts

@@ -30,7 +30,6 @@ import {
   promoteLineageCapturedResponse,
   sendMessageWithResult,
   channelObligationAnsweredBy,
-  spawnObligationAnsweredBy,
 } from "../db";
 import { planSend, type DeliveryReceipt } from "../agent-ref";
 import { emitMessageQueued, emitNewMessage } from "../sse";
@@ -178,12 +177,11 @@ export function sendMessageService(
 ): SendMessageResult {
   const receipt = validateSendMessageAuthorization(input, ctx, opts);
   // Reply-obligation linking: some real answers are ordinary sends without replyTo/thread linkage.
-  // Channel bridge replies and spawn report-backs both have a single unambiguous open obligation case;
+  // Channel bridge replies have a single unambiguous open obligation case;
   // link those at send time so the obligation clears with one message and the Stop hook does not nag
   // the agent into a redundant `/reply`.
   if (!input.replyTo && !isMechanicalMessageKind(input.kind)) {
-    const answered = channelObligationAnsweredBy(input.from, input.to)
-      ?? spawnObligationAnsweredBy(input.from, input.to);
+    const answered = channelObligationAnsweredBy(input.from, input.to);
     if (answered !== null) input.replyTo = answered;
   }
   const suppressedParent = suppressResultsOnlyAck(input);

package/src/services/spawn-agent.ts

@@ -39,7 +39,7 @@ import type { ProjectMcpPolicy } from "../project-mcp";
 import type { ProjectSettingsPolicy } from "../project-settings";
 import type { ProjectSkillsPolicy } from "../project-skills";
 import { applyDefaultSharedMcp, type SharedMcpSpawnOverride } from "../shared-mcp";
-import { autoSeedProjectForCwd } from "./project";
+import { autoSeedProjectForCwdAsync } from "./project";
 import { hydrateTaskContext, projectTaskHydration } from "./task-context-hydration";
 import { createTaskEntity, recordTaskEntityDispatchDecision } from "./task-entity";
 import { autoSubscribeTaskCoordinator } from "./task-semantic-events";
@@ -414,7 +414,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
   // stays filterable by project.
   let callerProject = resolveProjectForCwd(resolvedCwd);
   try {
-    const seeded = autoSeedProjectForCwd(resolvedCwd, requestedBy);
+    const seeded = await autoSeedProjectForCwdAsync(resolvedCwd, requestedBy);
     callerProject = seeded?.project ?? callerProject;
     if (seeded?.ingestError) {
       console.warn(`project auto-seed failed to ingest CLAUDE.md for ${resolvedCwd}: ${seeded.ingestError.message}`);

package/src/services/task-lifecycle.ts

@@ -38,6 +38,7 @@ import { routeNotification } from "../notification-router";
 import { resolveCoordinatorAgentId } from "../steward-identity";
 import { isAgentExitDoneWhen, stageSatisfiesDoneWhen } from "./task-done-when";
 import { emitTaskSemanticNotification, type TaskSemanticTransition } from "./task-semantic-events";
+import { runGit } from "./git-process";
 import type { IssueRef, TaskDeliverableStage, TaskGateState, WorkspaceRecord } from "../types";
 import type { IssueTrackerAdapter } from "../issue-tracker";
 
@@ -100,20 +101,16 @@ export function __setDriveTaskOnLandForTests(resolver: DriveTaskResolver | undef
   driveTaskOnLandForTests = resolver;
 }
 
-function landedDiffSummary(input: LandedTaskLifecycleInput, log: LogFn): string | undefined {
+async function landedDiffSummary(input: LandedTaskLifecycleInput, log: LogFn): Promise<string | undefined> {
   if (diffSummaryResolverForTests) return diffSummaryResolverForTests(input);
   const repoRoot = input.workspace.repoRoot?.trim();
   const baseSha = input.workspace.baseSha?.trim();
   const tipSha = input.mergedSha?.trim();
   if (!repoRoot || !baseSha || !tipSha || baseSha === tipSha) return undefined;
   try {
-    const proc = Bun.spawnSync(["git", "-C", repoRoot, "diff", "--shortstat", `${baseSha}..${tipSha}`], {
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    if (proc.exitCode !== 0) return undefined;
-    const out = Buffer.from(proc.stdout).toString("utf8").trim();
+    const { stdout, exitCode } = await runGit(["-C", repoRoot, "diff", "--shortstat", `${baseSha}..${tipSha}`]);
+    if (exitCode !== 0) return undefined;
+    const out = stdout.trim();
     return out || undefined;
   } catch (error) {
     log(`task lifecycle diff summary failed for ${input.workspace.id}: ${errMessage(error)}`);
@@ -454,7 +451,7 @@ export async function handleLandedTaskLifecycle(
   const taskIds = boundTaskIdsForWorkspace(input.workspace);
   if (taskIds.length === 0) return { handled: false, reason: "no-bound-task", tasks: [] };
 
-  const diffSummary = landedDiffSummary(input, log);
+  const diffSummary = await landedDiffSummary(input, log);
   const outcomes: TaskLandOutcome[] = [];
   for (const taskId of taskIds) {
     try {

package/src/settings/registry.ts

@@ -238,10 +238,10 @@ const DISPLAY_PREFS_SCHEMA: JSONSchema = {
 // sticky-bottom intent follow them across devices instead of dying in per-browser module state.
 // The value is a MAP keyed by conversation/agent id — one user-settings row holds every
 // conversation's anchor, so this is ONE descriptor (not a per-agent descriptor explosion).
-// Each entry is a LOGICAL anchor, never a pixel scrollTop: `topKey` is the timeline entry key
-// (`msg-<id>` — a server-stable id), `offset` the within-row pixel offset, `stick` the
-// follow-the-bottom intent. `maxProperties` bounds unbounded conversation growth; the dashboard
-// store evicts oldest-touched before it can be hit.
+  // Each entry is a LOGICAL anchor, never a pixel scrollTop: `anchorMessageId` is the durable
+  // message-id anchor, `topKey` is the compatibility timeline entry key, `offset` the within-row
+  // pixel offset, `stick` the follow-the-bottom intent. `maxProperties` bounds unbounded
+  // conversation growth; the dashboard store evicts oldest-touched before it can be hit.
 const CHAT_SCROLL_SCHEMA: JSONSchema = {
   type: "object",
   maxProperties: 200,
@@ -252,6 +252,8 @@ const CHAT_SCROLL_SCHEMA: JSONSchema = {
     properties: {
       stick: { type: "boolean" },
       topKey: { type: ["string", "null"], maxLength: 200 },
+      anchorMessageId: { type: "number", minimum: 0, maximum: 10_000_000_000 },
+      anchorEndMessageId: { type: "number", minimum: 0, maximum: 10_000_000_000 },
       offset: { type: "number", minimum: 0, maximum: 10_000_000 },
     },
   },

package/src/spawn-targets.ts

@@ -277,7 +277,7 @@ function spawnQuotaWindow(
     ? Math.max(0, burnWindow.earlyWallMs) / timeToResetMs
     : null;
   const weight = burnWindow.role === "7d" ? 3 : 1;
-  const hardBackstop = providerCfg?.hardBackstopUtilization ?? 0.99;
+  const hardBackstop = providerCfg?.hardBackstopUtilization;
   // #760 — floor default is now 0 (off). The projection/pace gate (earlyFraction≈0 when the
   // recency-weighted rate projects no early wall) replaces the blunt utilization floor, which
   // used to hide a legitimate low-util-high-burst alarm. Operators may still opt back in.
@@ -289,7 +289,7 @@ function spawnQuotaWindow(
   // over-pace penalty and ≥ preferSlackAt projected headroom at reset.
   const target = providerCfg?.targetUtilization ?? DEFAULT_QUOTA_TARGET_UTILIZATION;
   const preferSlackAt = providerCfg?.preferSlackAt ?? DEFAULT_QUOTA_PREFER_SLACK_AT;
-  const blockedNow = quotaWindow.utilization >= hardBackstop;
+  const blockedNow = hardBackstop === 0 ? false : quotaWindow.utilization >= (hardBackstop ?? 0.99);
   let burnRatio = burnWindow.burnRatio;
   let projectedUtilAtReset = burnWindow.projectedUtilAtReset;
   let slack = burnWindow.slack;