@saadnvd1/agent-os 0.3.700 → 0.3.723

package/components/Claims/claims-ui.test.ts

@@ -0,0 +1,161 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { beforeEach, describe, expect, it } from "vitest";
+import { claimKeys } from "@/data/claims/keys";
+import { claimsUi, claimsUiActions } from "@/stores/claimsUi";
+import { ClaimFiles } from "./ClaimFiles";
+import { OverlapPill } from "./OverlapPill";
+import { StartClaimsNotice } from "./StartClaimsNotice";
+import { focusView, groupByRepo, lastHeardText, startedText } from "./format";
+import type { Claim } from "@/lib/claims/types";
+
+const overlap = {
+  strength: "strong" as const,
+  machine: "box",
+  goal: "Rework login",
+  shared: 3,
+  claimId: "r-1",
+  mineId: "s-1",
+};
+
+beforeEach(() => claimsUiActions.setOpen(false));
+
+describe("OverlapPill", () => {
+  it("reads Overlaps: <machine>, amber when strong", () => {
+    const html = renderToStaticMarkup(createElement(OverlapPill, { overlap }));
+    expect(html).toContain("Overlaps: box");
+    expect(html).toContain("text-amber-700");
+    expect(html).toContain('data-overlap="strong"');
+  });
+
+  it("is muted when weak", () => {
+    const html = renderToStaticMarkup(
+      createElement(OverlapPill, { overlap: { ...overlap, strength: "weak" } })
+    );
+    expect(html).toContain("text-muted-foreground");
+    expect(html).not.toContain("text-amber-700");
+  });
+
+  it("opens the claims sheet on that pair when tapped", () => {
+    const el = OverlapPill({ overlap }) as { props: { onClick: () => void } };
+    el.props.onClick();
+    expect(claimsUi.open).toBe(true);
+    expect([...(claimsUi.focus ?? [])]).toEqual(["s-1", "r-1"]);
+    claimsUiActions.showAll();
+    expect(claimsUi.focus).toBeNull();
+  });
+});
+
+describe("StartClaimsNotice", () => {
+  const warnings = [
+    {
+      strength: "strong" as const,
+      kinds: ["files" as const],
+      shared: ["a.ts", "b.ts"],
+      claim: {
+        id: "r-1",
+        goal: "Rework login",
+        machine: "box",
+        branch: "feature/login",
+        sessionName: null,
+      },
+    },
+  ];
+  const html = renderToStaticMarkup(
+    createElement(StartClaimsNotice, {
+      warnings,
+      busy: false,
+      onStart: () => {},
+      onDismiss: () => {},
+    })
+  );
+
+  it("names the work and offers both choices", () => {
+    expect(html).toContain("Rework login");
+    expect(html).toContain("on box");
+    expect(html).toContain("a.ts, b.ts");
+    expect(html).toContain("Start anyway");
+    expect(html).toContain("Start after it");
+  });
+
+  it("renders nothing without a warning", () => {
+    expect(
+      renderToStaticMarkup(
+        createElement(StartClaimsNotice, {
+          warnings: [],
+          busy: false,
+          onStart: () => {},
+          onDismiss: () => {},
+        })
+      )
+    ).toBe("");
+  });
+});
+
+describe("claims keys and helpers", () => {
+  it("keys the list by project", () => {
+    expect(claimKeys.list()).toEqual(["claims", "list", ""]);
+    expect(claimKeys.list("p1")).toEqual(["claims", "list", "p1"]);
+    expect(claimKeys.list("p1").slice(0, 1)).toEqual(claimKeys.all);
+  });
+
+  it("words ages and last heard", () => {
+    expect(startedText({ startedAt: 0 }, 12 * 60_000)).toBe("started 12m ago");
+    expect(startedText({ startedAt: 0 }, 5_000)).toBe("just started");
+    expect(lastHeardText(0, 6 * 60_000)).toBe("last heard 6m ago");
+    expect(lastHeardText(null, 0)).toBe("this machine");
+  });
+
+  const c = (id: string, repo: string, startedAt: number) =>
+    ({ id, repo, startedAt, files: [], filesMore: 0 }) as unknown as Claim;
+
+  it("groups by repo, oldest work first", () => {
+    const groups = groupByRepo([
+      c("a", "r2", 5),
+      c("b", "r1", 9),
+      c("c", "r2", 1),
+    ]);
+    expect(groups.map((g) => [g.repo, g.claims.map((x) => x.id)])).toEqual([
+      ["r2", ["c", "a"]],
+      ["r1", ["b"]],
+    ]);
+  });
+
+  it("narrows to one pair", () => {
+    const view = {
+      claims: [c("a", "r", 1), c("b", "r", 2), c("z", "r", 3)],
+      overlaps: [
+        {
+          a: "a",
+          b: "b",
+          kinds: ["files" as const],
+          shared: [],
+          strength: "weak" as const,
+        },
+        {
+          a: "b",
+          b: "z",
+          kinds: ["files" as const],
+          shared: [],
+          strength: "weak" as const,
+        },
+      ],
+    };
+    const f = focusView(view, ["a", "b"]);
+    expect(f.claims.map((x) => x.id)).toEqual(["a", "b"]);
+    expect(f.overlaps).toHaveLength(1);
+    expect(focusView(view, null)).toBe(view);
+  });
+
+  it("marks shared files in a claim's list", () => {
+    const html = renderToStaticMarkup(
+      createElement(ClaimFiles, {
+        files: ["a.ts", "b.ts"],
+        more: 2,
+        shared: new Set(["a.ts"]),
+      })
+    );
+    expect(html).toContain("and 2 more");
+    expect(html.match(/text-amber-700/g)).toHaveLength(1);
+  });
+});

package/components/Claims/format.ts

@@ -0,0 +1,57 @@
+import type { Claim } from "@/lib/claims/types";
+import type { ClaimsView } from "@/lib/claims/view";
+
+const span = (ms: number) => {
+  const mins = Math.floor(Math.max(0, ms) / 60_000);
+  if (mins < 1) return "under a minute";
+  if (mins < 60) return `${mins}m`;
+  if (mins < 24 * 60) return `${Math.floor(mins / 60)}h`;
+  return `${Math.floor(mins / (24 * 60))}d`;
+};
+
+/** "started 12m ago". */
+export const startedText = (c: Pick<Claim, "startedAt">, now: number) => {
+  const s = span(now - c.startedAt);
+  return s === "under a minute" ? "just started" : `started ${s} ago`;
+};
+
+/** "last heard 6m ago". */
+export const lastHeardText = (at: number | null, now: number) => {
+  if (at === null) return "this machine";
+  const s = span(now - at);
+  return s === "under a minute" ? "heard just now" : `last heard ${s} ago`;
+};
+
+/** A machine not heard from for this long is shown as quiet. */
+export const QUIET_MS = 3 * 60_000;
+
+export interface RepoGroup {
+  repo: string;
+  claims: Claim[];
+}
+
+/** Claims by repository, the repository with the oldest work first. */
+export function groupByRepo(claims: Claim[]): RepoGroup[] {
+  const byRepo = new Map<string, Claim[]>();
+  for (const c of claims)
+    byRepo.set(c.repo, [...(byRepo.get(c.repo) ?? []), c]);
+  return [...byRepo]
+    .map(([repo, list]) => ({
+      repo,
+      claims: [...list].sort((a, b) => a.startedAt - b.startedAt),
+    }))
+    .sort((a, b) => a.claims[0].startedAt - b.claims[0].startedAt);
+}
+
+/** The claims and overlaps of one pair, or everything when no pair is set. */
+export function focusView(
+  view: Pick<ClaimsView, "claims" | "overlaps">,
+  focus: string[] | null
+) {
+  if (!focus) return view;
+  const ids = new Set(focus);
+  return {
+    claims: view.claims.filter((c) => ids.has(c.id)),
+    overlaps: view.overlaps.filter((o) => ids.has(o.a) && ids.has(o.b)),
+  };
+}

package/components/Claims/index.ts

@@ -0,0 +1,3 @@
+export { ClaimsSheet } from "./ClaimsSheet";
+export { OverlapPill } from "./OverlapPill";
+export { StartClaimsNotice } from "./StartClaimsNotice";

package/components/Draft/DraftChips.tsx

@@ -21,6 +21,7 @@ import { useAgentStatusQuery } from "@/data/agents";
 import { useProjectMachinesQuery } from "@/data/projects";
 import { modelChoices, useModelsQuery } from "@/data/models";
 import type { AgentProbe } from "@/lib/agents/probe";
+import { RoleChips } from "./RoleChips";
 import { ChipHeading, ChipItem, ChipMenu, ChipToggle } from "./Chip";
 import {
   DEFAULT_PRIORITY,
@@ -168,7 +169,7 @@ export function DraftChips({
         </ChipMenu>
       )}
 
-      {!draft.openPr && (
+      {!draft.openPr && !draft.agentRole && (
         <ChipMenu icon={Bot} name="Agent" label={agentLabel(draft.agentType)}>
           {AGENT_OPTIONS.map((o) => (
             <ChipItem
@@ -189,6 +190,10 @@ export function DraftChips({
         </ChipMenu>
       )}
 
+      {!draft.openPr && local && (
+        <RoleChips draft={draft} onChange={onChange} />
+      )}
+
       {project && local && git?.isGitRepo && (
         <ChipMenu
           icon={GitBranch}

package/components/Draft/DraftPanel.tsx

@@ -14,12 +14,18 @@ import { useHostsQuery } from "@/data/hosts";
 import { useGitCheck } from "@/data/git/queries";
 import { useSelectedWorkspace } from "@/hooks/useSelectedWorkspace";
 import { useLaunchSession } from "@/data/sessions";
+import { ModelUnavailableError } from "@/data/sessions/queries";
+import { isAgentRole } from "@/lib/models/agent-roles";
 import { useCreateTask } from "@/data/tasks";
+import { useCheckStart } from "@/data/claims";
+import { StartClaimsNotice } from "@/components/Claims";
+import type { StartWarning } from "@/lib/claims/startWarning";
 import { usePanes } from "@/contexts/PaneContext";
 import { setPendingPrompt } from "@/stores/initialPrompt";
 import { draftsActions, draftsStore, newDraft } from "@/stores/drafts";
 import { DraftChips } from "./DraftChips";
 import { DraftHeading } from "./DraftHeading";
+import { ModelUnavailableDialog } from "./ModelUnavailableDialog";
 import { draftModels } from "./draftModels";
 
 // A new session before its first send: choices on top, a composer below.
@@ -53,8 +59,22 @@ export function DraftPanel({
   const launch = useLaunchSession();
   const { workspace } = useSelectedWorkspace();
   const createTask = useCreateTask();
+  const checkStart = useCheckStart();
   const [prefill, setPrefill] = useState<{ text: string; at: number }>();
-  const pending = launch.isPending || createTask.isPending;
+  // A task start that overlaps claimed work waits here for the person's choice.
+  const [held, setHeld] = useState<{
+    text: string;
+    warnings: StartWarning[];
+  } | null>(null);
+  // A role's model server that didn't answer, with what was being sent.
+  const [down, setDown] = useState<{
+    error: ModelUnavailableError;
+    text: string;
+    images: ChatImage[];
+    files: ChatFile[];
+  } | null>(null);
+  const pending =
+    launch.isPending || createTask.isPending || checkStart.isPending;
 
   if (!hydrated) return null;
   if (!draft)
@@ -67,15 +87,32 @@ export function DraftPanel({
       </div>
     );
 
-  const send = async (text: string, images: ChatImage[], files: ChatFile[]) => {
+  const send = async (
+    text: string,
+    images: ChatImage[],
+    files: ChatFile[],
+    claim?: { after?: string; onUnavailable?: "fallback" }
+  ) => {
     try {
       if (draft.openPr) {
         if (!project) throw new Error("Pick a project for a task");
         if (images.length || files.length)
           throw new Error("A task takes text only");
+        if (!claim && draft.hostId === project.host_id) {
+          const warnings = await checkStart.mutateAsync({
+            projectId: project.id,
+            prompt: text,
+          });
+          if (warnings.length) {
+            setHeld({ text, warnings });
+            return;
+          }
+        }
+        setHeld(null);
         const { session, queued } = await createTask.mutateAsync({
           projectId: project.id,
           prompt: text,
+          after: claim?.after,
           model: draft.taskModel ?? undefined,
           priority: draft.taskPriority,
           baseBranch: draft.baseBranch ?? undefined,
@@ -102,7 +139,17 @@ export function DraftPanel({
             ? draft.hostId
             : undefined,
         agentType: draft.agentType,
-        model: draft.model,
+        model: isAgentRole(draft.agentRole)
+          ? (draft.roleModel ?? "")
+          : draft.model,
+        ...(isAgentRole(draft.agentRole)
+          ? {
+              agentRole: draft.agentRole,
+              ...(claim?.onUnavailable && {
+                onUnavailable: claim.onUnavailable,
+              }),
+            }
+          : {}),
         access: draft.access,
         useWorktree: draft.useWorktree && !!git?.isGitRepo,
         baseBranch: draft.baseBranch,
@@ -126,6 +173,10 @@ export function DraftPanel({
         session.host_id
       );
     } catch (error) {
+      if (error instanceof ModelUnavailableError) {
+        setDown({ error, text, images, files });
+        return;
+      }
       setPrefill({ text, at: Date.now() });
       toast.error(error instanceof Error ? error.message : String(error));
     }
@@ -145,6 +196,42 @@ export function DraftPanel({
           git={git}
           onChange={(patch) => draftsActions.update(draft.id, patch)}
         />
+        <ModelUnavailableDialog
+          error={down?.error ?? null}
+          busy={pending}
+          onClose={() => {
+            if (down) setPrefill({ text: down.text, at: Date.now() });
+            setDown(null);
+          }}
+          onRetry={() => {
+            const d = down;
+            setDown(null);
+            if (d) void send(d.text, d.images, d.files);
+          }}
+          onFallback={() => {
+            const d = down;
+            setDown(null);
+            if (d)
+              void send(d.text, d.images, d.files, {
+                onUnavailable: "fallback",
+              });
+          }}
+          onPick={() => {
+            if (down) setPrefill({ text: down.text, at: Date.now() });
+            setDown(null);
+          }}
+        />
+        {held && (
+          <StartClaimsNotice
+            warnings={held.warnings}
+            busy={pending}
+            onStart={(after) => void send(held.text, [], [], { after })}
+            onDismiss={() => {
+              setPrefill({ text: held.text, at: Date.now() });
+              setHeld(null);
+            }}
+          />
+        )}
         <Composer
           draftKey={draftComposerKey(draft.id)}
           attachScope="draft"

package/components/Draft/ModelUnavailableDialog.tsx

@@ -0,0 +1,78 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { AGENT_ROLE_DEFS, isAgentRole } from "@/lib/models/agent-roles";
+import type { ModelUnavailableError } from "@/data/sessions/queries";
+
+// A session in a role couldn't start: its model's server isn't answering.
+// A local model never turns into a cloud one on its own: starting on the
+// role's fallback is a choice made here.
+export function ModelUnavailableDialog({
+  error,
+  busy,
+  onRetry,
+  onFallback,
+  onPick,
+  onClose,
+}: {
+  error: ModelUnavailableError | null;
+  busy: boolean;
+  onRetry: () => void;
+  onFallback: () => void;
+  onPick: () => void;
+  onClose: () => void;
+}) {
+  const role =
+    error && isAgentRole(error.role)
+      ? AGENT_ROLE_DEFS[error.role].label
+      : "role";
+  const name = (ref: string) => ref.split("/").slice(1).join("/");
+  return (
+    <Dialog open={!!error} onOpenChange={(o) => !o && onClose()}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Can&apos;t start the {role}</DialogTitle>
+          <DialogDescription>
+            {error ? `${name(error.ref)}'s server isn't answering.` : ""}
+          </DialogDescription>
+        </DialogHeader>
+        {error && (
+          <p className="bg-muted/60 text-muted-foreground rounded-lg px-3 py-2 font-mono text-xs break-words">
+            {error.message}
+          </p>
+        )}
+        <div className="flex flex-col gap-2">
+          <Button className="h-11" disabled={busy} onClick={onRetry}>
+            Retry
+          </Button>
+          {error?.fallback && (
+            <Button
+              variant="outline"
+              className="h-11"
+              disabled={busy}
+              onClick={onFallback}
+            >
+              Start on {name(error.fallback)}
+            </Button>
+          )}
+          <Button variant="outline" className="h-11" onClick={onPick}>
+            Pick another model
+          </Button>
+        </div>
+        {error?.fallback && (
+          <p className="text-muted-foreground text-xs">
+            Starting on the fallback sends your code to wherever that model
+            runs.
+          </p>
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+}

package/components/Draft/RoleChips.tsx

@@ -0,0 +1,110 @@
+"use client";
+
+import { Cpu, Users } from "lucide-react";
+import {
+  AvailabilityDot,
+  LocalityBadge,
+} from "@/components/Models/ModelBadges";
+import { useAgentRolesQuery, useModelChoices } from "@/data/models";
+import type { Draft } from "@/lib/drafts";
+import {
+  AGENT_ROLES,
+  AGENT_ROLE_DEFS,
+  isAgentRole,
+} from "@/lib/models/agent-roles";
+import { ChipItem, ChipMenu } from "./Chip";
+
+// A draft's role and the model it runs on. The role's binding gives the
+// model (Settings > Agent roles); the model chip overrides it for this
+// session. Both lists come from the server.
+export function RoleChips({
+  draft,
+  onChange,
+}: {
+  draft: Draft;
+  onChange: (patch: Partial<Draft>) => void;
+}) {
+  const roles = useAgentRolesQuery("settings");
+  const { data: choices = [] } = useModelChoices(!!draft.agentRole);
+  const role = isAgentRole(draft.agentRole) ? draft.agentRole : null;
+  const bound = roles.data?.roles.find((r) => r.id === role);
+  const override = draft.roleModel
+    ? choices.find((c) => c.ref === draft.roleModel)
+    : undefined;
+  const current = override ?? bound?.choice ?? null;
+  const modelName = (ref: string | undefined | null) =>
+    ref ? ref.split("/").slice(1).join("/") : "…";
+  return (
+    <>
+      <ChipMenu
+        icon={Users}
+        name="Role"
+        label={role ? AGENT_ROLE_DEFS[role].label : "No role"}
+      >
+        <ChipItem
+          checked={!role}
+          onSelect={() => onChange({ agentRole: null, roleModel: null })}
+          hint="A plain session on the interactive model"
+        >
+          No role
+        </ChipItem>
+        {AGENT_ROLES.map((r) => {
+          const view = roles.data?.roles.find((x) => x.id === r);
+          return (
+            <ChipItem
+              key={r}
+              checked={r === role}
+              onSelect={() =>
+                onChange({ agentRole: r, roleModel: null, openPr: false })
+              }
+              hint={`${AGENT_ROLE_DEFS[r].purpose}${view?.binding ? ` · ${modelName(view.binding.ref)}` : ""}`}
+            >
+              {AGENT_ROLE_DEFS[r].label}
+            </ChipItem>
+          );
+        })}
+      </ChipMenu>
+      {role && (
+        <ChipMenu
+          icon={Cpu}
+          name="Model"
+          label={
+            draft.roleModel
+              ? modelName(draft.roleModel)
+              : `Role model: ${modelName(bound?.binding?.ref)}`
+          }
+        >
+          <ChipItem
+            checked={!draft.roleModel}
+            onSelect={() => onChange({ roleModel: null })}
+            hint={bound?.binding ? modelName(bound.binding.ref) : undefined}
+          >
+            Role model
+          </ChipItem>
+          {choices.map((c) => (
+            <ChipItem
+              key={c.ref}
+              checked={c.ref === draft.roleModel}
+              onSelect={() => onChange({ roleModel: c.ref })}
+              hint={c.group}
+            >
+              <span className="flex items-center gap-1.5">
+                <AvailabilityDot availability={c.availability} />
+                {c.label}
+                <LocalityBadge locality={c.locality} />
+              </span>
+            </ChipItem>
+          ))}
+        </ChipMenu>
+      )}
+      {role && current?.availability.state === "down" && (
+        <span
+          role="status"
+          className="text-destructive flex h-11 items-center text-xs md:h-8"
+        >
+          {modelName(current.ref)} isn&apos;t answering
+        </span>
+      )}
+    </>
+  );
+}