@saadnvd1/agent-os 0.3.698 → 0.3.715

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,
+  },
+});