agent-relay-server 0.120.1 → 0.120.2

package/src/routes/tasks.ts

@@ -29,6 +29,15 @@ function taskDetailOr404(id: number) {
   return detail ? json(detail) : error("deliverable task not found", 404);
 }
 
+function requireTaskMutationAuth(req: Request, id: number): Response | null {
+  if (!getTaskEntity(id)) return error("deliverable task not found", 404);
+  if (isFullReachRequest(req)) return null;
+  const component = getComponentAuth(req);
+  const agentId = component ? agentIdFromComponent(component) : undefined;
+  if (!isTaskReadAuthorized(id, agentId, component?.scope ?? [])) return error("forbidden", 403);
+  return null;
+}
+
 function normalizeTaskStatusInput(body: unknown): TaskStatusInput {
   if (!isRecord(body)) throw new ValidationError("JSON object body required");
   const status = optionalEnum(body.status, "status", VALID_TASK_STATUSES);
@@ -173,6 +182,8 @@ export const getTaskHistoryRoute: Handler = (req, params) => {
 export const patchTaskEntity: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const body = parsed.body;
@@ -200,6 +211,8 @@ export const patchTaskEntity: Handler = async (req, params) => {
 export const postTaskEntityStatus: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const body = parsed.body;
@@ -220,6 +233,8 @@ export const postTaskEntityStatus: Handler = async (req, params) => {
 export const postTaskEntityStage: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const body = parsed.body;
@@ -240,6 +255,8 @@ export const postTaskEntityStage: Handler = async (req, params) => {
 export const postTaskEntityGate: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const body = parsed.body;
@@ -261,6 +278,8 @@ export const postTaskEntityGate: Handler = async (req, params) => {
 export const postTaskDependency: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<{ dependsOnTaskId?: number }>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const dep = parseId(String(parsed.body?.dependsOnTaskId));
@@ -276,6 +295,8 @@ export const postTaskDependency: Handler = async (req, params) => {
 export const deleteTaskDependency: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<{ dependsOnTaskId?: number }>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const dep = parseId(String(parsed.body?.dependsOnTaskId));
@@ -287,6 +308,8 @@ export const deleteTaskDependency: Handler = async (req, params) => {
 export const postTaskRef: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const body = parsed.body;
@@ -308,6 +331,8 @@ export const postTaskRef: Handler = async (req, params) => {
 export const deleteTaskRef: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const body = parsed.body;
@@ -328,6 +353,8 @@ export const deleteTaskRef: Handler = async (req, params) => {
 export const postTaskAssign: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const body = parsed.body;
@@ -345,6 +372,8 @@ export const postTaskAssign: Handler = async (req, params) => {
 export const postTaskComment: Handler = async (req, params) => {
   const id = parseId(params.id);
   if (id === null) return error("invalid task id");
+  const forbidden = requireTaskMutationAuth(req, id);
+  if (forbidden) return forbidden;
   const parsed = await parseBody<Record<string, unknown>>(req);
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const body = parsed.body;

package/src/routes/workspaces.ts

@@ -16,6 +16,7 @@ import { workspaceActiveClaim } from "../workspace-claim";
 import { resolveCoordinatorAgentId } from "../steward-identity";
 import { relayToken } from "../config";
 import { workspaceOwnerOrchestrator } from "../workspace-host";
+import { refreshWorkspaceGitState } from "../workspace-probe";
 
 export const getWorkspaces: Handler = (req) => {
   try {
@@ -423,7 +424,7 @@ export const postWorkspaceAction: Handler = async (req, params) => {
   if (!parsed.ok) return error(parsed.error, parsed.status);
   try {
     if (!isRecord(parsed.body)) return error("body required");
-    const workspace = getWorkspace(params.id!);
+    let workspace = getWorkspace(params.id!);
     if (!workspace) return error("workspace not found", 404);
     const action = optionalEnum(parsed.body.action, "action", WORKSPACE_ACTIONS);
     if (!action) return error("action required", 400);
@@ -464,7 +465,13 @@ export const postWorkspaceAction: Handler = async (req, params) => {
     // Everything else delegates to the shared core (one home, shared with the
     // relay_workspace_* MCP tools); the core self-audits and returns any command to
     // emit, mirroring requestWorkspaceMerge's "caller emits" contract.
-    const result = applyWorkspaceAction(workspace, {
+    if (action === "ready" || action === "request-review") {
+      await refreshWorkspaceGitState(workspace);
+      const refreshed = getWorkspace(workspace.id);
+      if (refreshed) workspace = refreshed;
+    }
+
+    const result = await applyWorkspaceAction(workspace, {
       action,
       agentId,
       detail: cleanString(parsed.body.detail, "detail", { max: 4000 }),

package/src/runtime-tokens.ts

@@ -82,6 +82,8 @@ export function issueOrchestratorRuntimeToken(input: {
       cwdPrefixes: [input.baseDir],
       logsRead: true,
       terminalAttach: true,
+      terminalRead: true,
+      terminalWrite: true,
     },
     createdBy: input.createdBy ?? "runtime",
   });
@@ -190,6 +192,8 @@ export function issueInteractiveRunnerRuntimeToken(input: {
       agents: [agentId],
       cwdPrefixes: [input.cwd],
       terminalAttach: false,
+      terminalRead: false,
+      terminalWrite: false,
       logsRead: false,
       canDelegate: false,
     },

package/src/security.ts

@@ -104,6 +104,9 @@ type AuthorizationResource = {
   spawnRequestId?: string;
   integrationName?: string;
   terminalAttach?: boolean;
+  terminalRead?: boolean;
+  terminalWrite?: boolean;
+  terminalOwner?: boolean;
   logsRead?: boolean;
 };
 
@@ -147,7 +150,7 @@ export function isRequestAuthorizedFor(req: Request, check: AuthorizationCheck):
 }
 
 export function isComponentAuthorizedFor(auth: ComponentToken, check: AuthorizationCheck): boolean {
-  return hasComponentScope(auth, check.scope) && constraintsAllow(auth.constraints, check.resource);
+  return hasComponentScope(auth, check.scope) && constraintsAllow(auth, check.resource);
 }
 
 export function requiredScopeFor(method: string, pathname: string): string | null {
@@ -160,7 +163,8 @@ export function requiredScopeFor(method: string, pathname: string): string | nul
   if (pathname === "/api/orchestrators/bootstrap/exchange") return "token:write";
   if (pathname === "/api/orchestrators/bootstrap") return "token:write";
   if (pathname.match(/^\/api\/orchestrators\/[^/]+\/logs\//)) return "logs:read";
-  if (pathname.match(/^\/api\/orchestrators\/[^/]+\/terminal\//)) return "terminal:attach";
+  if (pathname.match(/^\/api\/orchestrators\/[^/]+\/terminal\/[^/]+\/input$/)) return "terminal:write";
+  if (pathname.match(/^\/api\/orchestrators\/[^/]+\/terminal\//)) return "terminal:read";
   const settingScope = requiredSettingsScopeFor(method, pathname);
   if (settingScope !== undefined) return settingScope;
   if (pathname.startsWith("/api/artifacts")) {
@@ -259,7 +263,8 @@ export function requiredComponentScopeFor(method: string, pathname: string): str
   if (pathname === "/api/events") return "message:read";
   if (pathname === "/api/mcp") return "mcp:use";
   if (pathname.match(/^\/api\/orchestrators\/[^/]+\/logs\//)) return "logs:read";
-  if (pathname.match(/^\/api\/orchestrators\/[^/]+\/terminal\//)) return "terminal:attach";
+  if (pathname.match(/^\/api\/orchestrators\/[^/]+\/terminal\/[^/]+\/input$/)) return "terminal:write";
+  if (pathname.match(/^\/api\/orchestrators\/[^/]+\/terminal\//)) return "terminal:read";
   const settingScope = requiredSettingsScopeFor(method, pathname);
   if (settingScope !== undefined) return settingScope ?? "system:admin";
   if (pathname.startsWith("/api/commands")) {
@@ -519,10 +524,12 @@ export function resolveTeamLineage(constraints: TokenConstraints | undefined): s
   return constraints?.teamId;
 }
 
-function constraintsAllow(constraints: TokenConstraints | undefined, resource: AuthorizationResource | undefined): boolean {
-  if (!constraints || !resource) return true;
+function constraintsAllow(auth: ComponentToken, resource: AuthorizationResource | undefined): boolean {
+  const constraints = auth.constraints;
+  if (!resource) return true;
+  if (!constraints) return resource.terminalOwner ? terminalOwnerAllowed(auth, undefined, resource) : true;
   const hasConstraints = Object.keys(constraints).length > 0;
-  if (!hasConstraints) return true;
+  if (!hasConstraints && !resource.terminalOwner) return true;
   if (resource.agentId && !listAllows(constraints.agents, resource.agentId)) return false;
   if (resource.policyName && !listAllows(constraints.policies, resource.policyName)) return false;
   if (resource.channel && !listAllows(constraints.channels, resource.channel)) return false;
@@ -533,10 +540,27 @@ function constraintsAllow(constraints: TokenConstraints | undefined, resource: A
   if (resource.cwd && !cwdAllows(constraints, resource.cwd)) return false;
   if (resource.target && !targetAllows(constraints, resource.target)) return false;
   if (resource.terminalAttach && constraints.terminalAttach !== true) return false;
+  if (resource.terminalRead && constraints.terminalRead !== true) return false;
+  if (resource.terminalWrite && constraints.terminalWrite !== true) return false;
   if (resource.logsRead && constraints.logsRead !== true) return false;
+  if (resource.terminalOwner && !terminalOwnerAllowed(auth, constraints, resource)) return false;
   return true;
 }
 
+function terminalOwnerAllowed(auth: ComponentToken, constraints: TokenConstraints | undefined, resource: AuthorizationResource): boolean {
+  if (hasScope(auth.scope, "system:admin")) return true;
+  if (auth.role === "orchestrator") {
+    return !resource.orchestratorId || listAllows(constraints?.orchestrators, resource.orchestratorId);
+  }
+  if (!constraints) return false;
+  if (resource.agentId && constraints.agents?.includes(resource.agentId)) return true;
+  if (resource.policyName && constraints.policies?.includes(resource.policyName)) return true;
+  if (resource.spawnRequestId && constraints.spawnRequestIds?.includes(resource.spawnRequestId)) return true;
+  if (resource.agentId && constraints.targets?.some((target) => target === resource.agentId || target === `agent:${resource.agentId}`)) return true;
+  if (resource.policyName && constraints.targets?.includes(`policy:${resource.policyName}`)) return true;
+  return false;
+}
+
 function targetAllows(constraints: TokenConstraints, target: string): boolean {
   const hasTargetConstraints = Boolean(constraints.targets?.length || constraints.policies?.length || constraints.agents?.length);
   if (constraints.targets?.includes(target)) return true;
@@ -564,7 +588,7 @@ function isTokenConstraints(value: unknown): value is TokenConstraints {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const record = value as Record<string, unknown>;
   for (const [key, item] of Object.entries(record)) {
-    if (["terminalAttach", "logsRead", "canDelegate"].includes(key)) {
+    if (["terminalAttach", "terminalRead", "terminalWrite", "logsRead", "canDelegate"].includes(key)) {
       if (typeof item !== "boolean") return false;
     } else if (key === "cwd" || key === "spawnedBy" || key === "teamId" || key === "projectId" || key === "profile" || key === "tenantId") {
       if (typeof item !== "string") return false;

package/src/server.ts

@@ -15,6 +15,7 @@ import { startPlanLiveBindings } from "./services/plan-live-bindings";
 import { startRelayScheduler } from "./services/scheduler";
 import { recordWorkspaceIssueActivity } from "./services/spawn-issue-activity";
 import { onWorkspaceCreate } from "./db";
+import { isTerminalSessionRequestAuthorized } from "./terminal-authz";
 import { resolve, sep } from "path";
 import { gzipSync, brotliCompressSync, constants as zlibConstants } from "node:zlib";
 import {
@@ -35,7 +36,6 @@ import {
   isAuthorized,
   isScopedRequestAuthorized,
   isOriginAllowed,
-  isRequestAuthorizedFor,
   unauthorized,
 } from "./security";
 import { startMaintenanceScheduler } from "./maintenance";
@@ -93,20 +93,7 @@ export function startServer(): void {
     hostname: HOST,
     idleTimeout: IDLE_TIMEOUT_SECONDS,
     fetch: createFetchHandler({ publicDir: process.env.PUBLIC_DIR, logRequests: LOG_REQUESTS }),
-    websocket: {
-      open(ws) {
-        if (ws.data?.kind === "terminal-proxy") return openTerminalProxy(ws as TerminalProxySocket);
-        return busHandleOpen(ws as any);
-      },
-      message(ws, data) {
-        if (ws.data?.kind === "terminal-proxy") return sendTerminalProxyFrame(ws as TerminalProxySocket, data);
-        return busHandleMessage(ws as any, data);
-      },
-      close(ws) {
-        if (ws.data?.kind === "terminal-proxy") return closeTerminalProxy(ws as TerminalProxySocket);
-        return busHandleClose(ws as any);
-      },
-    },
+    websocket: createWebSocketHandlers(),
   });
 
   console.log(`agent-relay ${VERSION} running on http://${HOST}:${PORT}`);
@@ -117,6 +104,7 @@ interface TerminalProxySocketData {
   upstreamUrl: string;
   upstreamToken?: string;
   upstream?: WebSocket;
+  writeAuthorized: boolean;
   pending: Array<string | Buffer>;
 }
 
@@ -128,6 +116,23 @@ type RelaySocketData = {
 
 type TerminalProxySocket = ServerWebSocket<TerminalProxySocketData>;
 
+export function createWebSocketHandlers() {
+  return {
+    open(ws: ServerWebSocket<RelaySocketData>) {
+      if (ws.data?.kind === "terminal-proxy") return openTerminalProxy(ws as TerminalProxySocket);
+      return busHandleOpen(ws as any);
+    },
+    message(ws: ServerWebSocket<RelaySocketData>, data: string | Buffer) {
+      if (ws.data?.kind === "terminal-proxy") return sendTerminalProxyFrame(ws as TerminalProxySocket, data);
+      return busHandleMessage(ws as any, data);
+    },
+    close(ws: ServerWebSocket<RelaySocketData>) {
+      if (ws.data?.kind === "terminal-proxy") return closeTerminalProxy(ws as TerminalProxySocket);
+      return busHandleClose(ws as any);
+    },
+  };
+}
+
 function emitAutomationDispatches(results: AutomationDispatchResult[]): void {
   for (const result of results) {
     if (result.command) emitAutomationCommand(result.command);
@@ -195,6 +200,10 @@ function openTerminalProxy(ws: TerminalProxySocket): void {
 }
 
 function sendTerminalProxyFrame(ws: TerminalProxySocket, data: string | Buffer): void {
+  if (!ws.data.writeAuthorized && isTerminalWriteFrame(data)) {
+    ws.send(JSON.stringify({ type: "error", error: "terminal write forbidden" }));
+    return;
+  }
   const upstream = ws.data.upstream;
   if (!upstream || upstream.readyState === WebSocket.CONNECTING) {
     ws.data.pending.push(data);
@@ -204,10 +213,22 @@ function sendTerminalProxyFrame(ws: TerminalProxySocket, data: string | Buffer):
   upstream.send(data);
 }
 
+function isTerminalWriteFrame(data: string | Buffer): boolean {
+  let payload: unknown;
+  try {
+    payload = JSON.parse(typeof data === "string" ? data : data.toString("utf8"));
+  } catch {
+    return false;
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+  const frame = payload as Record<string, unknown>;
+  return frame.type === "input" || (frame.type === "interactive" && frame.interactive === true);
+}
+
 function closeTerminalProxy(ws: TerminalProxySocket): void {
   const upstream = ws.data.upstream;
   ws.data.pending = [];
-  if (upstream && upstream.readyState === WebSocket.OPEN) upstream.close();
+  if (upstream && upstream.readyState !== WebSocket.CLOSED) upstream.close();
 }
 
 export function createFetchHandler(
@@ -235,9 +256,10 @@ export function createFetchHandler(
       if (!isAuthorized(req)) return unauthorized(req);
       const orchestratorId = decodeURIComponent(terminalStreamMatch[1]!);
       const session = decodeURIComponent(terminalStreamMatch[2]!);
-      if (!isRequestAuthorizedFor(req, { scope: "terminal:attach", resource: { orchestratorId, terminalAttach: true } })) {
+      if (!isTerminalSessionRequestAuthorized(req, orchestratorId, session, "read")) {
         return forbidden(req);
       }
+      const writeAuthorized = isTerminalSessionRequestAuthorized(req, orchestratorId, session, "write");
       const orch = getOrchestrator(orchestratorId);
       if (!orch) return Response.json({ error: "orchestrator not found" }, { status: 404 });
       if (!orch.apiUrl) return Response.json({ error: "orchestrator does not expose an API" }, { status: 422 });
@@ -248,7 +270,7 @@ export function createFetchHandler(
       // access/proxy logs (#149). The orchestrator accepts both, but headers are safer.
       const token = relayToken();
       const upgraded = server.upgrade(req, {
-        data: { kind: "terminal-proxy", upstreamUrl: upstream.toString(), upstreamToken: token, pending: [] },
+        data: { kind: "terminal-proxy", upstreamUrl: upstream.toString(), upstreamToken: token, writeAuthorized, pending: [] },
       });
       if (!upgraded) return new Response("WebSocket upgrade failed", { status: 400 });
       return undefined;

package/src/services/git-remote.ts

@@ -18,6 +18,26 @@ export function parseOwnerRepoFromRemote(url: string | undefined): string | unde
 let remoteRepoCache: Map<string, string | undefined> | undefined;
 let remoteUrlCache: Map<string, string | undefined> | 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.spawn(["git", "-C", repoRoot, "remote", "get-url", "origin"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+    if (exitCode === 0) url = stdout.trim() || undefined;
+  } catch {
+    url = undefined;
+  }
+  remoteUrlCache.set(repoRoot, url);
+  return url;
+}
+
 export function remoteUrlFromGitRemote(repoRoot: string | undefined): string | undefined {
   if (!repoRoot) return undefined;
   if (!remoteUrlCache) remoteUrlCache = new Map();
@@ -37,6 +57,15 @@ export function remoteUrlFromGitRemote(repoRoot: string | undefined): string | u
   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

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

@@ -100,20 +100,21 @@ 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}`], {
+    const proc = Bun.spawn(["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 Promise.all([new Response(proc.stdout).text(), proc.exited]);
+    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 +455,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;