@saadnvd1/agent-os 0.3.698 → 0.3.715

package/app/api/sessions/[id]/route.ts

@@ -19,6 +19,7 @@ import { statusDetector } from "@/lib/status-detector";
 import { deleteItems } from "@/lib/chat/store";
 import { clearQueue } from "@/lib/chat/queued";
 import { recordPreviousName } from "@/lib/session-names";
+import { getProject, moveSessionToProject } from "@/lib/projects";
 import { generateBranchName, getCurrentBranch, renameBranch } from "@/lib/git";
 import { runInBackground } from "@/lib/async-operations";
 import {
@@ -206,9 +207,15 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
       updates.push("system_prompt = ?");
       values.push(body.systemPrompt);
     }
-    if (body.groupPath !== undefined) {
-      updates.push("group_path = ?");
-      values.push(body.groupPath);
+
+    let clearedGroup: string | null = null;
+    if (typeof body.projectId === "string" && !existing.role) {
+      if (!getProject(body.projectId))
+        return NextResponse.json(
+          { error: "Project not found" },
+          { status: 404 }
+        );
+      clearedGroup = moveSessionToProject(id, body.projectId).clearedGroup;
     }
 
     if (updates.length > 0) {
@@ -221,7 +228,10 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
     }
 
     const session = queries.getSession(db).get(id) as Session;
-    return NextResponse.json({ session });
+    return NextResponse.json({
+      session,
+      ...(clearedGroup && { clearedGroup }),
+    });
   } catch (error) {
     console.error("Error updating session:", error);
     return NextResponse.json(

package/app/api/sessions/[id]/summarize/route.ts

@@ -1,3 +1,4 @@
+import { inheritGroup } from "@/lib/session-groups/assignSessions";
 import { effectiveAutoApprove } from "@/lib/approvals/no-approvals";
 import { routedRun } from "@/lib/models/launch";
 import { NextRequest, NextResponse } from "next/server";
@@ -305,6 +306,7 @@ export async function POST(
         session.host_id
       );
 
+      inheritGroup(session.id, newId);
       newSession = queries.getSession(db).get(newId) as Session;
       const newTmuxSession = tmuxName;
 

package/app/api/sessions/claims.test.ts

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { seedSession, seedWorkspace } from "@/lib/orchestrator/testing";
+
+const { db } = await import("@/lib/db");
+const { machineId } = await import("@/lib/claims/machine");
+const { upsertLocal, upsertRemote } = await import("@/lib/claims/store");
+const { refreshOverlapCache, resetOverlapCache } =
+  await import("@/lib/claims/overlapCache");
+const { GET } = await import("./route");
+
+const REPO = "git.example.test/team/widgets";
+
+beforeEach(() => {
+  db.prepare(`DELETE FROM work_claims`).run();
+  resetOverlapCache();
+});
+
+function localClaim(sessionId: string, files: string[]) {
+  upsertLocal(
+    { id: machineId(), name: "here" },
+    {
+      sessionId,
+      sessionName: "Tidy auth",
+      repo: REPO,
+      branch: "feature/tidy",
+      base: "main",
+      goal: "Tidy auth",
+      files,
+      filesMore: 0,
+      prUrl: null,
+    }
+  );
+}
+
+const remote = (id: string, files: string[], branch = "feature/login") =>
+  upsertRemote(machineId(), "peer-1", {
+    id,
+    origin: "box-machine",
+    origin_name: "box",
+    hops: 0,
+    source: "session",
+    session_name: "Rework login sessions",
+    repo: REPO,
+    branch,
+    base: "main",
+    goal: "Rework login sessions",
+    files,
+    files_more: 0,
+    pr_url: null,
+    ttl_s: 600,
+    age_s: 60,
+    released: null,
+  });
+
+const FILES = ["a/one.ts", "a/two.ts", "a/three.ts"];
+
+const rows = async () => {
+  const body = await (await GET()).json();
+  return body as {
+    sessions: { id: string; overlap?: Record<string, unknown> | null }[];
+    claims: { id: string; fileCount: number; files?: string[] }[];
+    claimOverlaps: { a: string; b: string; strength: string }[];
+  };
+};
+
+describe("GET /api/sessions with claims", () => {
+  it("puts a strong overlap on the session that has it, and no other", async () => {
+    const t = seedWorkspace();
+    const mine = seedSession({ projectId: t.app.id, name: "Tidy auth" });
+    const other = seedSession({ projectId: t.app.id, name: "Unrelated" });
+    localClaim(mine, FILES);
+    remote("claim-box-1", FILES);
+    refreshOverlapCache();
+    const body = await rows();
+    expect(body.sessions.find((s) => s.id === mine)?.overlap).toEqual({
+      strength: "strong",
+      machine: "box",
+      goal: "Rework login sessions",
+      shared: 3,
+      claimId: "claim-box-1",
+      mineId: `s-${mine}`,
+    });
+    expect(body.sessions.find((s) => s.id === other)?.overlap).toBeUndefined();
+  });
+
+  it("marks a small file overlap weak", async () => {
+    const t = seedWorkspace();
+    const mine = seedSession({ projectId: t.app.id, name: "Tidy auth" });
+    localClaim(mine, ["a/1.ts", "a/2.ts", "a/3.ts", "a/4.ts", "a/5.ts"]);
+    remote(
+      "claim-box-2",
+      ["a/1.ts", "a/2.ts", "b/1.ts", "b/2.ts", "b/3.ts"],
+      "feature/other"
+    );
+    refreshOverlapCache();
+    const row = (await rows()).sessions.find((s) => s.id === mine);
+    expect(row?.overlap?.strength).toBe("weak");
+  });
+
+  it("lists claims without their paths, and the overlapping pairs", async () => {
+    const t = seedWorkspace();
+    const mine = seedSession({ projectId: t.app.id, name: "Tidy auth" });
+    localClaim(mine, FILES);
+    remote("claim-box-1", FILES);
+    refreshOverlapCache();
+    const body = await rows();
+    expect(body.claims.map((c) => c.id).sort()).toEqual(
+      [`s-${mine}`, "claim-box-1"].sort()
+    );
+    expect(body.claims.every((c) => c.fileCount === 3 && !c.files)).toBe(true);
+    expect(body.claimOverlaps).toHaveLength(1);
+    expect(body.claimOverlaps[0].strength).toBe("strong");
+  });
+
+  it("serves no claims before the loop has run", async () => {
+    const t = seedWorkspace();
+    seedSession({ projectId: t.app.id, name: "Tidy auth" });
+    const body = await rows();
+    expect(body.claims).toEqual([]);
+    expect(body.sessions.every((s) => !s.overlap)).toBe(true);
+  });
+});

package/app/api/sessions/group/route.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { assignSessions } from "@/lib/session-groups";
+import { groupRoute } from "@/lib/session-groups/route";
+
+const body = z.object({
+  ids: z.array(z.string()).min(1).max(200),
+  groupId: z.string().nullable(),
+});
+
+// POST /api/sessions/group { ids, groupId | null } - the multi-select move.
+// All or none: one session of another workspace refuses the lot.
+export async function POST(request: Request) {
+  return groupRoute(request, body, (b) => ({
+    ok: true,
+    ...assignSessions(b.ids, b.groupId),
+  }));
+}

package/app/api/sessions/route.ts

@@ -1,28 +1,47 @@
 import { NextRequest, NextResponse } from "next/server";
-import { getDb, queries, type Session, type Group } from "@/lib/db";
+import { getDb, queries, type Session } from "@/lib/db";
+import { listGroups } from "@/lib/session-groups";
 import { isValidAgentType } from "@/lib/providers";
 import { clientSend } from "@/lib/chat/client-send";
 import { CHAT_ACCESS } from "@/lib/chat/events";
 import { launchSession } from "@/lib/sessions/launch";
+import { namesLine, waitBadges } from "@/lib/bus/waits/store";
+import { claimsSnapshot } from "@/lib/claims";
 import { isProjectRef } from "@/lib/tasks/project-ref";
 
-// GET /api/sessions - List all sessions and groups
+// GET /api/sessions - List the sidebar's sessions and the user's groups
 export async function GET() {
   try {
     const db = getDb();
     // Merged tasks are listed (the sidebar files them under Done). Dropped
     // tasks live in the Tasks panel, a moved one on the machine it moved to,
     // and archived sessions in the Archived view: none is in the sidebar.
-    const sessions = queries.getSidebarSessions(db).all() as Session[];
-    const groups = queries.getAllGroups(db).all() as Group[];
-
-    // Convert expanded from 0/1 to boolean
-    const formattedGroups = groups.map((g) => ({
-      ...g,
-      expanded: Boolean(g.expanded),
-    }));
-
-    return NextResponse.json({ sessions, groups: formattedGroups });
+    const badges = waitBadges();
+    const claims = claimsSnapshot();
+    const sessions = (queries.getSidebarSessions(db).all() as Session[]).map(
+      (s) => {
+        const b = badges.get(s.id);
+        const overlap = claims.bySession.get(s.id);
+        const row = overlap ? { ...s, overlap } : s;
+        return b
+          ? {
+              ...row,
+              waiting_on: b.on.length
+                ? namesLine(b.on.map((w) => w.name))
+                : null,
+              waited_by: b.by.length
+                ? namesLine(b.by.map((w) => w.name))
+                : null,
+            }
+          : row;
+      }
+    );
+    return NextResponse.json({
+      sessions,
+      sessionGroups: listGroups(),
+      claims: claims.claims,
+      claimOverlaps: claims.overlaps,
+    });
   } catch (error) {
     console.error("Error fetching sessions:", error);
     return NextResponse.json(
@@ -78,7 +97,6 @@ export async function POST(request: NextRequest) {
       name: str(body.name),
       view: body.view === "terminal" ? "terminal" : undefined,
       parentSessionId: str(body.parentSessionId),
-      groupPath: str(body.groupPath) ?? undefined,
       systemPrompt: str(body.systemPrompt),
     });
     const db = getDb();

package/app/page.tsx

@@ -34,6 +34,7 @@ if (typeof window !== "undefined") {
 import { PaneProvider, usePanes } from "@/contexts/PaneContext";
 import { Pane } from "@/components/Pane";
 import { AwayReport } from "@/components/Away/AwayReport";
+import { IncomingLinks } from "@/components/Hosts/IncomingLinkSheet";
 import type { BrowserNotifications } from "@/components/Settings/NotificationsSection";
 import { useNotifications } from "@/hooks/useNotifications";
 import { useViewport } from "@/hooks/useViewport";
@@ -121,6 +122,10 @@ const LumifyHubDialogs = dynamic(
     ),
   { ssr: false }
 );
+const ClaimsSheet = dynamic(
+  () => import("@/components/Claims/ClaimsSheet").then((m) => m.ClaimsSheet),
+  { ssr: false }
+);
 const UsageDialog = dynamic(
   () => import("@/components/Usage/UsageDialog").then((m) => m.UsageDialog),
   { ssr: false }
@@ -158,9 +163,11 @@ const AppDialogs = memo(function AppDialogs({
       <CleanupDialog />
       <LumifyHubDialogs />
       <UsageDialog />
+      <ClaimsSheet />
       <MoveDialog />
       <ShareDialog />
       <AwayReport />
+      <IncomingLinks />
       <CommandPalette />
     </>
   );

package/components/Claims/ClaimFiles.tsx

@@ -0,0 +1,38 @@
+"use client";
+
+import { cn } from "@/lib/utils";
+
+// The paths a claim touches, the ones another claim also touches marked.
+export function ClaimFiles({
+  files,
+  more,
+  shared,
+}: {
+  files: string[];
+  more: number;
+  shared: ReadonlySet<string>;
+}) {
+  return (
+    <ul className="bg-muted/40 mt-1 max-h-48 overflow-y-auto rounded-lg p-2 font-mono text-[11px] leading-5">
+      {files.map((f) => (
+        <li
+          key={f}
+          className={cn(
+            "break-all",
+            shared.has(f)
+              ? "text-amber-700 dark:text-amber-400"
+              : "text-muted-foreground"
+          )}
+        >
+          {f}
+        </li>
+      ))}
+      {more > 0 && (
+        <li className="text-muted-foreground pt-1">and {more} more</li>
+      )}
+      {files.length === 0 && more === 0 && (
+        <li className="text-muted-foreground">No changed files yet</li>
+      )}
+    </ul>
+  );
+}

package/components/Claims/ClaimRow.tsx

@@ -0,0 +1,82 @@
+"use client";
+
+import { useState } from "react";
+import { ChevronRight, ExternalLink, GitBranch } from "lucide-react";
+import { cn } from "@/lib/utils";
+import type { Claim } from "@/lib/claims/types";
+import { ClaimFiles } from "./ClaimFiles";
+import { startedText } from "./format";
+
+// One piece of claimed work: what, where, since when; its files fold open.
+export function ClaimRow({
+  claim,
+  here,
+  now,
+  shared,
+}: {
+  claim: Claim;
+  here: boolean;
+  now: number;
+  shared: ReadonlySet<string>;
+}) {
+  const [open, setOpen] = useState(false);
+  const count = claim.files.length + claim.filesMore;
+  return (
+    <li className="bg-muted/40 rounded-xl" data-claim={claim.id}>
+      <button
+        type="button"
+        onClick={() => setOpen((v) => !v)}
+        aria-expanded={open}
+        className="flex min-h-11 w-full items-start gap-2 rounded-xl p-3 text-left"
+      >
+        <ChevronRight
+          aria-hidden
+          className={cn(
+            "text-muted-foreground mt-0.5 h-4 w-4 shrink-0 transition-transform",
+            open && "rotate-90"
+          )}
+        />
+        <span className="min-w-0 flex-1">
+          <span className="block text-sm font-medium break-words">
+            {claim.goal}
+          </span>
+          <span className="text-muted-foreground mt-0.5 flex flex-wrap items-center gap-x-2 gap-y-0.5 text-xs">
+            <span>
+              {here ? `${claim.originName} (here)` : claim.originName}
+            </span>
+            {claim.branch && (
+              <span className="flex min-w-0 items-center gap-1">
+                <GitBranch aria-hidden className="h-3 w-3 shrink-0" />
+                <span className="truncate">{claim.branch}</span>
+              </span>
+            )}
+            <span>{startedText(claim, now)}</span>
+            <span>
+              {count} file{count === 1 ? "" : "s"}
+            </span>
+          </span>
+        </span>
+      </button>
+      {claim.prUrl && (
+        <a
+          href={claim.prUrl}
+          target="_blank"
+          rel="noreferrer"
+          className="text-primary flex min-h-11 items-center gap-1 px-3 pb-2 pl-9 text-xs hover:underline"
+        >
+          <ExternalLink aria-hidden className="h-3 w-3" />
+          Pull request
+        </a>
+      )}
+      {open && (
+        <div className="px-3 pb-3 pl-9">
+          <ClaimFiles
+            files={claim.files}
+            more={claim.filesMore}
+            shared={shared}
+          />
+        </div>
+      )}
+    </li>
+  );
+}

package/components/Claims/ClaimsSheet.tsx

@@ -0,0 +1,176 @@
+"use client";
+
+import { useMemo } from "react";
+import { useSnapshot } from "valtio";
+import { GitCompareArrows } from "lucide-react";
+import { StatusPill } from "@/components/ui/status-pill";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { useNow } from "@/components/Chat/useNow";
+import { useClaims } from "@/data/claims";
+import { claimsUi, claimsUiActions } from "@/stores/claimsUi";
+import { cn } from "@/lib/utils";
+import { ClaimRow } from "./ClaimRow";
+import { QUIET_MS, focusView, groupByRepo, lastHeardText } from "./format";
+
+const Skeleton = () => (
+  <div className="space-y-2" aria-label="Loading claims">
+    {[0, 1, 2].map((i) => (
+      <div key={i} className="bg-muted/40 h-16 animate-pulse rounded-xl" />
+    ))}
+  </div>
+);
+
+// Work across machines: what each linked machine's sessions are on, the
+// overlaps first, and when each machine was last heard from.
+export function ClaimsSheet() {
+  const snap = useSnapshot(claimsUi);
+  const { data, isPending, isError, dataUpdatedAt } = useClaims({
+    enabled: snap.open,
+  });
+  const tick = useNow(snap.open);
+  const now = tick + (data ? data.now - dataUpdatedAt : 0);
+  const view = useMemo(
+    () => (data ? focusView(data, snap.focus ? [...snap.focus] : null) : null),
+    [data, snap.focus]
+  );
+  const byId = useMemo(
+    () => new Map((view?.claims ?? []).map((c) => [c.id, c])),
+    [view]
+  );
+  const sharedOf = (id: string) =>
+    new Set(
+      (view?.overlaps ?? [])
+        .filter((o) => o.a === id || o.b === id)
+        .flatMap((o) => o.shared)
+    );
+  const here = data?.machine.id;
+
+  return (
+    <Dialog open={snap.open} onOpenChange={claimsUiActions.setOpen}>
+      <DialogContent className="max-h-[90vh] max-w-xl overflow-y-auto [&>*]:min-w-0">
+        <DialogHeader>
+          <DialogTitle>Work across machines</DialogTitle>
+          <DialogDescription className="sr-only">
+            What sessions on this and linked machines are working on, and where
+            the work overlaps.
+          </DialogDescription>
+        </DialogHeader>
+        {isPending && <Skeleton />}
+        {isError && (
+          <p className="text-destructive text-sm">Couldn’t load claims.</p>
+        )}
+        {data && view && (
+          <div className="space-y-4">
+            <ul className="flex flex-wrap gap-2" aria-label="Machines">
+              {data.machines.map((m) => {
+                const quiet =
+                  !m.self &&
+                  (m.lastHeardAt === null || now - m.lastHeardAt > QUIET_MS);
+                return (
+                  <li
+                    key={m.id}
+                    className="bg-muted/40 flex items-center gap-2 rounded-lg px-3 py-2 text-xs"
+                  >
+                    <span className="font-medium">{m.name}</span>
+                    <span
+                      className={cn(
+                        "text-muted-foreground",
+                        quiet && "text-amber-700 dark:text-amber-400"
+                      )}
+                    >
+                      {lastHeardText(m.lastHeardAt, now)}
+                    </span>
+                  </li>
+                );
+              })}
+            </ul>
+            {snap.focus && (
+              <button
+                type="button"
+                onClick={claimsUiActions.showAll}
+                className="text-primary min-h-11 text-sm"
+              >
+                Showing one pair. Show all work
+              </button>
+            )}
+            {view.overlaps.length > 0 && (
+              <section className="space-y-2" aria-label="Overlaps">
+                <h3 className="text-muted-foreground text-xs font-semibold tracking-wide uppercase">
+                  Overlaps
+                </h3>
+                <ul className="space-y-2">
+                  {view.overlaps.map((o) => {
+                    const a = byId.get(o.a);
+                    const b = byId.get(o.b);
+                    if (!a || !b) return null;
+                    return (
+                      <li
+                        key={`${o.a}|${o.b}`}
+                        className="bg-muted/40 flex items-start gap-2 rounded-xl p-3 text-sm"
+                      >
+                        <StatusPill
+                          tone={o.strength === "strong" ? "amber" : "muted"}
+                        >
+                          <GitCompareArrows
+                            aria-hidden
+                            className="h-2.5 w-2.5"
+                          />
+                          {o.strength}
+                        </StatusPill>
+                        <span className="min-w-0 flex-1 break-words">
+                          {a.goal} on {a.originName} and {b.goal} on{" "}
+                          {b.originName}
+                          <span className="text-muted-foreground block text-xs">
+                            {[
+                              o.kinds.join(" + "),
+                              o.shared.length
+                                ? `${o.shared.length} shared file${o.shared.length === 1 ? "" : "s"}`
+                                : null,
+                            ]
+                              .filter(Boolean)
+                              .join(" · ")}
+                          </span>
+                        </span>
+                      </li>
+                    );
+                  })}
+                </ul>
+              </section>
+            )}
+            {view.claims.length === 0 ? (
+              <p className="text-muted-foreground py-6 text-center text-sm">
+                Nothing is claimed right now. Work shows up here while a session
+                has changes in a repository.
+              </p>
+            ) : (
+              groupByRepo(view.claims).map((g) => (
+                <section key={g.repo} className="space-y-2" aria-label={g.repo}>
+                  <h3 className="text-muted-foreground truncate text-xs font-semibold">
+                    {g.repo}
+                  </h3>
+                  <ul className="space-y-2">
+                    {g.claims.map((c) => (
+                      <ClaimRow
+                        key={c.id}
+                        claim={c}
+                        here={c.origin === here}
+                        now={now}
+                        shared={sharedOf(c.id)}
+                      />
+                    ))}
+                  </ul>
+                </section>
+              ))
+            )}
+          </div>
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+}

package/components/Claims/OverlapPill.tsx

@@ -0,0 +1,31 @@
+"use client";
+
+import { GitCompareArrows } from "lucide-react";
+import { StatusPill } from "@/components/ui/status-pill";
+import type { Session } from "@/lib/db";
+import { claimsUiActions } from "@/stores/claimsUi";
+
+// "Overlaps: box" on a session row: amber when the overlap is strong, muted
+// when weak. Tapping opens the claims sheet on that pair.
+export function OverlapPill({
+  overlap,
+}: {
+  overlap: NonNullable<Session["overlap"]>;
+}) {
+  const strong = overlap.strength === "strong";
+  const files = overlap.shared
+    ? ` · ${overlap.shared} shared file${overlap.shared === 1 ? "" : "s"}`
+    : "";
+  return (
+    <StatusPill
+      tone={strong ? "amber" : "muted"}
+      data-tip={`${strong ? "Strong" : "Weak"} overlap with "${overlap.goal}" on ${overlap.machine}${files}. Tap to see both.`}
+      aria-label={`Overlaps with ${overlap.machine}`}
+      data-overlap={overlap.strength}
+      onClick={() => claimsUiActions.open([overlap.mineId, overlap.claimId])}
+    >
+      <GitCompareArrows aria-hidden className="h-2.5 w-2.5 shrink-0" />
+      <span className="truncate">Overlaps: {overlap.machine}</span>
+    </StatusPill>
+  );
+}