@saadnvd1/agent-os 0.3.700 → 0.3.715

package/lib/claims/notifyOverlaps.ts

@@ -0,0 +1,101 @@
+// Each sync: tells a local session about a strong overlap it is in. An
+// overlap must hold on two syncs in a row, and is told again only when the
+// shared set grows. Both machines run this for their own sessions, so
+// nothing is sent across machines. Never pauses or stops anything.
+
+import { getDb } from "../db";
+import { sendMessage } from "../bus";
+import { machineId } from "./machine";
+import { sessionOverlaps, type SessionOverlap } from "./mine";
+import { sessionMessage } from "./overlapText";
+import { liveClaims } from "./store";
+
+export const HOLD_SYNCS = 2;
+// A told pair that has not overlapped for this long is forgotten.
+const FORGET_MS = 60 * 60_000;
+
+export type Tell = (sessionId: string, body: string) => Promise<void>;
+
+export const tellSession: Tell = async (sessionId, body) => {
+  await sendMessage({
+    fromId: null,
+    to: sessionId,
+    body,
+    fromLabel: "AgentOS",
+    origin: { kind: "system", label: "Overlap", body },
+  });
+};
+
+interface Notice {
+  pair_key: string;
+  hits: number;
+  shared: string;
+  told_at: number | null;
+  seen_at: number;
+}
+
+const parse = (raw: string): string[] => {
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+};
+
+export async function notifyOverlaps(
+  tell: Tell = tellSession,
+  now = Date.now()
+): Promise<number> {
+  const db = getDb();
+  const byPair = new Map<string, SessionOverlap[]>();
+  for (const o of sessionOverlaps(machineId(), liveClaims({ now })))
+    byPair.set(o.pairKey, [...(byPair.get(o.pairKey) ?? []), o]);
+  const get = db.prepare(`SELECT * FROM claim_notices WHERE pair_key = ?`);
+  const save = db.prepare(
+    `INSERT INTO claim_notices (pair_key, hits, shared, told_at, seen_at)
+     VALUES (@key, @hits, @shared, @told, @now)
+     ON CONFLICT(pair_key) DO UPDATE SET hits = @hits, shared = @shared,
+       told_at = @told, seen_at = @now`
+  );
+  let told = 0;
+  for (const [key, sides] of byPair) {
+    const row = get.get(key) as Notice | undefined;
+    const hits = (row?.hits ?? 0) + 1;
+    const shared = sides[0].shared;
+    const known = new Set(parse(row?.shared ?? "[]"));
+    const grew = !!row?.told_at && shared.some((f) => !known.has(f));
+    const due = hits >= HOLD_SYNCS && (!row?.told_at || grew);
+    let delivered = false;
+    if (due)
+      for (const side of sides)
+        try {
+          await tell(side.sessionId, sessionMessage(side));
+          delivered = true;
+        } catch {
+          // Left untold when nobody got it: the next sync tries again.
+        }
+    if (delivered) told++;
+    save.run({
+      key,
+      hits,
+      shared: delivered ? JSON.stringify(shared) : (row?.shared ?? "[]"),
+      told: delivered ? now : (row?.told_at ?? null),
+      now,
+    });
+  }
+  // Consecutive means consecutive: a pair that dropped out starts again.
+  const rows = db.prepare(`SELECT * FROM claim_notices`).all() as Notice[];
+  for (const r of rows) {
+    if (byPair.has(r.pair_key)) continue;
+    if (!r.told_at || now - r.seen_at > FORGET_MS)
+      db.prepare(`DELETE FROM claim_notices WHERE pair_key = ?`).run(
+        r.pair_key
+      );
+    else if (r.hits)
+      db.prepare(`UPDATE claim_notices SET hits = 0 WHERE pair_key = ?`).run(
+        r.pair_key
+      );
+  }
+  return told;
+}

package/lib/claims/onMerged.ts

@@ -0,0 +1,85 @@
+// A winner of an overlap merged: the base moved under the session that gave
+// way. One with a PR is left to rebaseConflicting once GitHub flags a
+// conflict. One without gets a single message, and a refreshBase when it is
+// idle with nothing uncommitted (refreshBase never loses work). Nothing here
+// pauses or stops a session.
+
+import { getDb } from "../db";
+import { git } from "../git-exec";
+import { statusOf } from "../orchestrator/facts";
+import { getSessionRow } from "../schedules/store";
+import { refreshBase, type RefreshTarget } from "../tasks/refresh-base";
+import { expandHome } from "../tasks/session";
+import { machineId } from "./machine";
+import { mergedMessage } from "./overlapText";
+import { claimById } from "./store";
+import { tellSession, type Tell } from "./notifyOverlaps";
+import { winner } from "./yield";
+
+export interface MergedDeps {
+  tell: Tell;
+  idle: (sessionId: string) => Promise<boolean>;
+  clean: (dir: string) => Promise<boolean>;
+  refresh: (t: RefreshTarget) => Promise<unknown>;
+}
+
+export const realMerged: MergedDeps = {
+  tell: tellSession,
+  idle: async (id) => {
+    const s = getSessionRow(id);
+    return !!s && (await statusOf(s)).status === "idle";
+  },
+  clean: async (dir) =>
+    !(await git(dir, ["status", "--porcelain"], { timeout: 5000 })).trim(),
+  refresh: refreshBase,
+};
+
+interface Row {
+  pair_key: string;
+}
+
+export async function handleMerged(
+  deps: MergedDeps = realMerged,
+  now = Date.now()
+): Promise<number> {
+  const db = getDb();
+  const self = machineId();
+  const rows = db
+    .prepare(
+      `SELECT pair_key FROM claim_notices WHERE told_at IS NOT NULL AND merged_at IS NULL`
+    )
+    .all() as Row[];
+  const done = db.prepare(
+    `UPDATE claim_notices SET merged_at = ? WHERE pair_key = ?`
+  );
+  let handled = 0;
+  for (const { pair_key } of rows) {
+    const [a, b] = pair_key.split("|").map((id) => claimById(id));
+    if (!a || !b) continue;
+    const gone = [a, b].find((c) => c.released === "merged");
+    const mine = [a, b].find(
+      (c) => !c.released && c.origin === self && c.sessionId
+    );
+    if (!gone || !mine || winner(gone, mine) !== gone) continue;
+    try {
+      const s = getSessionRow(mine.sessionId!);
+      // A session with a PR is the rebase pipeline's.
+      if (s && !s.pr_url && s.pr_status !== "open") {
+        await deps.tell(s.id, mergedMessage(gone, s.base_branch ?? mine.base));
+        const dir = s.worktree_path ? expandHome(s.worktree_path) : null;
+        if (dir && (await deps.idle(s.id)) && (await deps.clean(dir)))
+          await deps.refresh({
+            name: s.name,
+            worktree: dir,
+            branch: s.branch_name,
+            base: s.base_branch,
+          });
+        handled++;
+      }
+      done.run(now, pair_key);
+    } catch {
+      // Tried again next sync.
+    }
+  }
+  return handled;
+}

package/lib/claims/outside.ts

@@ -0,0 +1,36 @@
+// Sessions AgentOS didn't start register a claim themselves, through
+// `aos claim` or the hook. The CLI sends what git said in its own folder.
+
+import { repoKeyOfRemote } from "../git-remote";
+import { machineId, machineName } from "./machine";
+import {
+  liveClaim,
+  newOutsideId,
+  releaseOutside,
+  upsertOutside,
+} from "./store";
+import type { Claim, OutsideBody } from "./types";
+
+const self = () => ({ id: machineId(), name: machineName() });
+
+// Null when the remote isn't one a claim can be keyed by, or the id is not
+// this machine's outside claim.
+export function registerOutside(b: OutsideBody): { claim: Claim } | null {
+  const repo = repoKeyOfRemote(b.remote);
+  if (!repo) return null;
+  const id = b.id ?? newOutsideId();
+  const prior = liveClaim(id);
+  const ok = upsertOutside(self(), {
+    id,
+    sessionName: b.name ?? null,
+    repo,
+    branch: b.branch ?? null,
+    base: b.base ?? null,
+    goal: b.goal || prior?.goal || "outside session",
+    files: b.files,
+  });
+  const claim = ok ? liveClaim(id) : null;
+  return claim ? { claim } : null;
+}
+
+export const endOutside = (id: string) => releaseOutside(machineId(), id);

package/lib/claims/overlap.ts

@@ -0,0 +1,87 @@
+// Whether two live claims are working on the same thing. Pure: the same two
+// claims give the same answer on every machine, which the yield rule needs.
+
+import { goalsAlike } from "./goal";
+import type { Claim, Overlap } from "./types";
+
+const NOISE =
+  /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|Gemfile\.lock|Cargo\.lock|go\.sum|poetry\.lock|uv\.lock|composer\.lock|CHANGELOG[^/]*|__snapshots__\/.*|migrations\.generated\.ts)$/i;
+
+export const isNoise = (path: string) =>
+  NOISE.test(path) || /(^|\/)__snapshots__\//.test(path);
+
+// A path this many claims touch is a shared index or router, not a signal.
+export const HUB_CLAIMS = 4;
+
+const isBase = (b: string | null, c: Claim, o: Claim) =>
+  !b ||
+  b === "HEAD" ||
+  b === "main" ||
+  b === "master" ||
+  b === c.base ||
+  b === o.base;
+
+function sameWork(a: Claim, b: Claim): boolean {
+  if (a.id === b.id) return true;
+  if (a.sessionId && a.sessionId === b.sessionId && a.origin === b.origin)
+    return true;
+  return !!a.branch && a.origin === b.origin && a.branch === b.branch;
+}
+
+export function overlapBetween(
+  a: Claim,
+  b: Claim,
+  hubs: ReadonlySet<string> = new Set()
+): Overlap | null {
+  if (a.repo !== b.repo || sameWork(a, b)) return null;
+  const kinds: Overlap["kinds"] = [];
+  let strong = false;
+
+  if (a.branch && a.branch === b.branch && !isBase(a.branch, a, b)) {
+    kinds.push("branch");
+    strong = true;
+  }
+
+  const fa = new Set(a.files.filter((f) => !isNoise(f)));
+  const fb = new Set(b.files.filter((f) => !isNoise(f)));
+  let shared = [...fa].filter((f) => fb.has(f));
+  if (shared.length && shared.every((f) => hubs.has(f))) shared = [];
+  const smaller = Math.min(fa.size, fb.size);
+  const ratio = smaller ? shared.length / smaller : 0;
+  const alike = goalsAlike(a.goal, b.goal);
+  if (shared.length && (shared.length >= 2 || ratio >= 0.3)) {
+    kinds.push("files");
+    if (shared.length >= 3 || ratio >= 0.5 || alike) strong = true;
+  }
+  if (alike) kinds.push("goal");
+  if (!kinds.length) return null;
+  return {
+    a,
+    b,
+    kinds,
+    shared: shared.sort(),
+    strength: strong ? "strong" : "weak",
+  };
+}
+
+export function findOverlaps(claims: Claim[]): Overlap[] {
+  const live = claims.filter((c) => !c.released);
+  const byRepo = new Map<string, Claim[]>();
+  for (const c of live) byRepo.set(c.repo, [...(byRepo.get(c.repo) ?? []), c]);
+  const out: Overlap[] = [];
+  for (const group of byRepo.values()) {
+    const touched = new Map<string, number>();
+    for (const c of group)
+      for (const f of new Set(c.files))
+        touched.set(f, (touched.get(f) ?? 0) + 1);
+    const hubs = new Set(
+      [...touched].filter(([, n]) => n >= HUB_CLAIMS).map(([f]) => f)
+    );
+    for (let i = 0; i < group.length; i++)
+      for (let j = i + 1; j < group.length; j++) {
+        const o = overlapBetween(group[i], group[j], hubs);
+        if (o) out.push(o);
+      }
+  }
+  return out;
+}

package/lib/claims/overlapCache.ts

@@ -0,0 +1,86 @@
+// The overlaps of this machine's sessions, worked out once a sync tick so
+// /api/sessions needs no git and no pairwise pass per request.
+
+import { findOverlaps } from "./overlap";
+import { machineId } from "./machine";
+import { liveClaims } from "./store";
+import { overlapView, type OverlapView } from "./view";
+import type { Claim } from "./types";
+
+// A session row's pill: the strongest overlap it has.
+export interface SessionOverlap {
+  strength: "strong" | "weak";
+  machine: string;
+  goal: string;
+  shared: number;
+  // This session's own claim and the other one: the pair a pill opens.
+  claimId: string;
+  mineId: string;
+}
+
+// A claim without its paths: enough to list on a phone.
+export type ClaimSummary = Omit<Claim, "files"> & { fileCount: number };
+
+export interface ClaimsSnapshot {
+  claims: ClaimSummary[];
+  overlaps: OverlapView[];
+  bySession: Map<string, SessionOverlap>;
+}
+
+const EMPTY: ClaimsSnapshot = {
+  claims: [],
+  overlaps: [],
+  bySession: new Map(),
+};
+// server.ts (the loop) and the route bundles are separate module graphs, so
+// the snapshot lives on globalThis to be one.
+const g = globalThis as unknown as { __agentosClaimsSnapshot?: ClaimsSnapshot };
+const get = () => g.__agentosClaimsSnapshot ?? EMPTY;
+
+export const summarize = (c: Claim): ClaimSummary => {
+  const { files, ...rest } = c;
+  return { ...rest, fileCount: files.length + c.filesMore };
+};
+
+const rank = (o: SessionOverlap) =>
+  (o.strength === "strong" ? 1e6 : 0) + o.shared;
+
+export function buildSnapshot(claims: Claim[], self: string): ClaimsSnapshot {
+  const bySession = new Map<string, SessionOverlap>();
+  const overlaps = findOverlaps(claims);
+  for (const o of overlaps)
+    for (const [mine, other] of [
+      [o.a, o.b],
+      [o.b, o.a],
+    ] as const) {
+      if (mine.origin !== self || !mine.sessionId) continue;
+      const next: SessionOverlap = {
+        strength: o.strength,
+        machine: other.originName,
+        goal: other.goal,
+        shared: o.shared.length,
+        claimId: other.id,
+        mineId: mine.id,
+      };
+      const have = bySession.get(mine.sessionId);
+      if (!have || rank(next) > rank(have)) bySession.set(mine.sessionId, next);
+    }
+  return {
+    claims: claims.map(summarize),
+    overlaps: overlaps.map(overlapView),
+    bySession,
+  };
+}
+
+export function refreshOverlapCache(now = Date.now()): void {
+  try {
+    g.__agentosClaimsSnapshot = buildSnapshot(liveClaims({ now }), machineId());
+  } catch (err) {
+    console.error("[claims] overlap cache:", err);
+  }
+}
+
+export const claimsSnapshot = (): ClaimsSnapshot => get();
+export const resetOverlapCache = () => {
+  g.__agentosClaimsSnapshot = EMPTY;
+};

package/lib/claims/overlapText.ts

@@ -0,0 +1,36 @@
+// What a session or the orchestrator reads about an overlap. The other
+// claim's goal, machine and paths are another machine's words: fenced.
+
+import { untrusted } from "../orchestrator/untrusted";
+import type { SessionOverlap } from "./mine";
+
+const SHOWN = 5;
+
+function where(o: SessionOverlap): string {
+  const files = o.shared.slice(0, SHOWN).join(", ");
+  const more =
+    o.shared.length > SHOWN ? ` and ${o.shared.length - SHOWN} more` : "";
+  const what = o.kinds.includes("branch")
+    ? "the same branch"
+    : "the same files";
+  return `${untrusted("claim", `${o.other.goal} on ${o.other.originName}`)} is working on ${what}${files ? `: ${untrusted("claim", files)}${more}` : ""}.`;
+}
+
+// The message the local session gets, with the verdict.
+export function sessionMessage(o: SessionOverlap): string {
+  const head = `Overlap: ${where(o)}`;
+  return o.yields
+    ? `${head} The other work is closer to merging, so give way: finish your current step, commit, and don't restructure those files further. If your change depends on theirs, say so (BLOCKED: or tell the orchestrator) rather than copy it. Nothing is paused.`
+    : `${head} Yours is closer to merging, so keep going; just don't widen into those files. Nothing is paused.`;
+}
+
+export function eventLine(o: SessionOverlap, name: string): string {
+  return `${name}: overlaps ${where(o)} ${o.yields ? "It yields." : "The other yields."}`;
+}
+
+export function mergedMessage(
+  winner: { goal: string; originName: string },
+  base: string | null
+): string {
+  return `${untrusted("claim", `${winner.goal} on ${winner.originName}`)} merged, and it overlapped your work. Rebase onto origin/${base ?? "main"} at your next stopping point.`;
+}

package/lib/claims/peers.ts

@@ -0,0 +1,56 @@
+import { getDb } from "../db";
+import { hostLink, linkedHostIds, type HostLink } from "../hosts/remote-api";
+
+export function rememberPeer(
+  hostId: string,
+  machineId: string,
+  now = Date.now()
+): void {
+  getDb()
+    .prepare(
+      `INSERT INTO claim_peers (host_id, machine_id, seen_at) VALUES (?, ?, ?)
+       ON CONFLICT(host_id) DO UPDATE SET machine_id = excluded.machine_id,
+         seen_at = excluded.seen_at`
+    )
+    .run(hostId, machineId, now);
+}
+
+export function peerMachineOf(hostId: string): string | null {
+  const r = getDb()
+    .prepare(`SELECT machine_id FROM claim_peers WHERE host_id = ?`)
+    .get(hostId) as { machine_id: string } | undefined;
+  return r?.machine_id ?? null;
+}
+
+// One list per machine, best link first (token, then Connect). A Connect pin
+// that isn't active is left out: peerCall would only refuse it. Links whose
+// machine isn't known yet are each their own machine.
+export function exchangeTargets(): HostLink[][] {
+  const groups = new Map<string, HostLink[]>();
+  for (const hostId of [...linkedHostIds()].sort()) {
+    const link = hostLink(hostId);
+    if (!link) continue;
+    if (link.connect && link.connect.state !== "active") continue;
+    const key = peerMachineOf(hostId) ?? `host:${hostId}`;
+    groups.set(key, [...(groups.get(key) ?? []), link]);
+  }
+  return [...groups.values()].map((g) =>
+    [...g].sort(
+      (a, b) =>
+        Number(a.transport === "connect") - Number(b.transport === "connect")
+    )
+  );
+}
+
+// Claims that arrived through a link that has since been suspended or
+// unlinked stop counting now, not when their lifetime runs out.
+export function dropViaInactive(): number {
+  return getDb()
+    .prepare(
+      `DELETE FROM work_claims WHERE via_host IS NOT NULL
+         AND via_host NOT IN (SELECT host_id FROM host_links
+                                WHERE host_id NOT IN (SELECT id FROM hosts WHERE kind = 'connect'))
+         AND via_host NOT IN (SELECT host_id FROM peer_links WHERE state = 'active')`
+    )
+    .run().changes;
+}

package/lib/claims/startCheck.ts

@@ -0,0 +1,100 @@
+// Before a task starts: who else is working on the same thing. The files it
+// will touch are guessed from the prompt (paths that exist in the repo).
+// Any failure means no overlaps: this never blocks a start.
+
+import { git } from "../git-exec";
+import { repoKey } from "../git-remote";
+import { getProject } from "../projects";
+import { untrusted } from "../orchestrator/untrusted";
+import { expandHome } from "../tasks/session";
+import { claimsShared, machineId, machineName } from "./machine";
+import { overlapBetween } from "./overlap";
+import { liveClaims } from "./store";
+import { MAX_FILES, type Claim, type Overlap } from "./types";
+
+export interface StartCheck {
+  // Overlaps of the new start (as `a`) with live claims (as `b`), strong first.
+  overlaps: Overlap[];
+}
+
+const PATH_LIKE = /[\w@.+-]+(?:\/[\w@.+-]+)*\.[A-Za-z0-9]{1,8}\b/g;
+
+async function predictedFiles(dir: string, prompt: string): Promise<string[]> {
+  const tokens = [...new Set(prompt.match(PATH_LIKE) ?? [])].slice(0, 100);
+  if (!tokens.length) return [];
+  const tracked = new Set(
+    (await git(dir, ["ls-files", "-z"], { timeout: 5000 }))
+      .split("\0")
+      .filter(Boolean)
+  );
+  return tokens.filter((t) => tracked.has(t)).slice(0, MAX_FILES);
+}
+
+export async function checkStart(opts: {
+  projectId: string;
+  name?: string;
+  prompt: string;
+  branch?: string | null;
+  now?: number;
+}): Promise<StartCheck> {
+  const none: StartCheck = { overlaps: [] };
+  try {
+    if (!claimsShared()) return none;
+    const project = getProject(opts.projectId);
+    if (!project) return none;
+    const dir = expandHome(project.working_directory);
+    const repo = await repoKey(dir);
+    if (!repo) return none;
+    const live = liveClaims({ repo, now: opts.now });
+    if (!live.length) return none;
+    const now = opts.now ?? Date.now();
+    const goal = (opts.name?.trim() || opts.prompt.split("\n")[0]).slice(
+      0,
+      120
+    );
+    const mine: Claim = {
+      id: "start",
+      origin: machineId(),
+      originName: machineName(),
+      viaMachine: null,
+      hops: 0,
+      source: "session",
+      sessionId: null,
+      sessionName: null,
+      repo,
+      branch: opts.branch ?? null,
+      base: null,
+      goal,
+      files: await predictedFiles(dir, opts.prompt).catch(() => []),
+      filesMore: 0,
+      prUrl: null,
+      startedAt: now,
+      expiresAt: now,
+      released: null,
+      updatedAt: now,
+    };
+    const overlaps = live
+      .map((c) => overlapBetween(mine, c))
+      .filter((o): o is Overlap => !!o)
+      .sort(
+        (x, y) =>
+          Number(y.strength === "strong") - Number(x.strength === "strong")
+      );
+    return { overlaps };
+  } catch (error) {
+    console.error("[claims] start check:", error);
+    return none;
+  }
+}
+
+const where = (c: Claim) =>
+  c.origin === machineId() ? "here" : `on ${c.originName}`;
+
+// "'<goal>' on box (branch x) touches a.ts, b.ts", fenced: another machine's words.
+export function overlapText(o: Overlap): string {
+  const shared = o.shared.length
+    ? ` touches ${o.shared.slice(0, 5).join(", ")}`
+    : "";
+  const branch = o.b.branch ? ` (branch ${o.b.branch})` : "";
+  return `${untrusted("claim", o.b.goal)} ${where(o.b)}${branch}${shared}`;
+}

package/lib/claims/startWarning.ts

@@ -0,0 +1,29 @@
+// An overlap of a new start with a live claim, as the start sheet shows it.
+
+import type { Overlap } from "./types";
+
+export interface StartWarning {
+  strength: Overlap["strength"];
+  kinds: Overlap["kinds"];
+  shared: string[];
+  claim: {
+    id: string;
+    goal: string;
+    machine: string;
+    branch: string | null;
+    sessionName: string | null;
+  };
+}
+
+export const startWarning = (o: Overlap): StartWarning => ({
+  strength: o.strength,
+  kinds: o.kinds,
+  shared: o.shared.slice(0, 20),
+  claim: {
+    id: o.b.id,
+    goal: o.b.goal,
+    machine: o.b.originName,
+    branch: o.b.branch,
+    sessionName: o.b.sessionName,
+  },
+});