@saadnvd1/agent-os 0.3.700 → 0.3.723

package/scripts/sync-cli-links.test.ts

@@ -0,0 +1,69 @@
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { describe, expect, it } from "vitest";
+import { tempDir } from "@/lib/test-temp";
+
+const script = path.resolve(__dirname, "sync-cli-links");
+
+function setup() {
+  const root = tempDir("aos-synclinks-");
+  const home = path.join(root, "home");
+  const bin = path.join(root, "bin");
+  fs.mkdirSync(home);
+  fs.mkdirSync(bin);
+  const clone = (name: string) => {
+    const dir = path.join(root, name);
+    fs.mkdirSync(path.join(dir, "bin"), { recursive: true });
+    fs.mkdirSync(path.join(dir, "scripts"), { recursive: true });
+    fs.writeFileSync(path.join(dir, "bin/aos"), "");
+    fs.writeFileSync(path.join(dir, "scripts/agent-os"), "");
+    return dir;
+  };
+  const live = clone("live");
+  const old = clone("old");
+  fs.writeFileSync(
+    path.join(home, "live-server.json"),
+    JSON.stringify({ cwd: live })
+  );
+  const run = (...args: string[]) =>
+    execFileSync(script, args, {
+      encoding: "utf-8",
+      env: { ...process.env, AOS_BIN_DIR: bin, AGENT_OS_HOME: home },
+    });
+  return { bin, home, live, old, run };
+}
+
+describe("sync-cli-links", () => {
+  it("repoints a link into another clone and logs it", () => {
+    const t = setup();
+    fs.symlinkSync(path.join(t.old, "bin/aos"), path.join(t.bin, "aos"));
+    const out = t.run();
+    expect(fs.readlinkSync(path.join(t.bin, "aos"))).toBe(
+      path.join(t.live, "bin/aos")
+    );
+    expect(out).toContain("repointed");
+    expect(out).toContain(t.old);
+    expect(t.run()).toBe("");
+  });
+
+  it("leaves absent links alone unless asked to create them", () => {
+    const t = setup();
+    t.run();
+    expect(fs.existsSync(path.join(t.bin, "aos"))).toBe(false);
+    t.run("create");
+    expect(fs.readlinkSync(path.join(t.bin, "aos"))).toBe(
+      path.join(t.live, "bin/aos")
+    );
+    expect(fs.readlinkSync(path.join(t.bin, "agent-os"))).toBe(
+      path.join(t.live, "scripts/agent-os")
+    );
+  });
+
+  it("never replaces a real file", () => {
+    const t = setup();
+    fs.writeFileSync(path.join(t.bin, "aos"), "mine");
+    t.run("create");
+    expect(fs.readFileSync(path.join(t.bin, "aos"), "utf-8")).toBe("mine");
+  });
+});

package/server.ts

@@ -6,6 +6,8 @@ import next from "next";
 import { WebSocketServer, WebSocket } from "ws";
 import { ensureBusBrief } from "./lib/agents/launch";
 import { reattachChats } from "./lib/chat/runner";
+import { setTurnEndHook } from "./lib/chat/registry";
+import { analystTurnEndHook, resumeAnalystLinks } from "./lib/analyst";
 import { serveChatSocket } from "./lib/chat/socket";
 import { startStackWatcher } from "./lib/stacks";
 import { startPauseWatcher } from "./lib/tasks/pause";
@@ -21,6 +23,7 @@ import { realDeps, schedulesEnabled, startScheduler } from "./lib/schedules";
 import { startSettling } from "./lib/recipes";
 import { startAutoArchive } from "./lib/done/auto-archive";
 import { startWorktreeSweep } from "./lib/worktree-sweep/start";
+import { startClaimsLoop } from "./lib/claims";
 import { startUsageRollup, usageRollupEnabled } from "./lib/usage/nightly";
 import { resumePhoneOutbox } from "./lib/notify";
 import { resumePushOutbox } from "./lib/notify/push";
@@ -223,6 +226,8 @@ app.prepare().then(async () => {
     const folder = sessionFolder(id);
     if (folder) refreshGitSoon(folder);
   });
+  // An analyst hears each of its coding agent's turns as they end.
+  setTurnEndHook(analystTurnEndHook);
   // Terminal sessions are watched through tmux control mode, or tapped with
   // pipe-pane where tmux is too old for it.
   const control = await startTmuxControl();
@@ -452,7 +457,11 @@ app.prepare().then(async () => {
   void sweepSims();
   setInterval(sweepSims, 5 * 60_000);
   // Chat turns that kept running through a restart.
-  void reattachChats().finally(() => startPauseWatcher());
+  void reattachChats().finally(() => {
+    startPauseWatcher();
+    // Digests a restart cut off, and turns that ended while it was down.
+    void resumeAnalystLinks();
+  });
   // Older chats get into the search index in the background, a batch at a time.
   if (process.env.AGENTOS_SEARCH_INDEX !== "off") startConversationBackfill();
   // Reviews this restart cut off run again and deliver their verdicts.
@@ -497,6 +506,8 @@ app.prepare().then(async () => {
   startAutoArchive();
   // Settled worktrees older than the setting are removed; branches stay.
   startWorktreeSweep();
+  // Who is working on what, across linked machines.
+  if (!process.env.AGENTOS_DEMO) startClaimsLoop();
   resumePhoneOutbox();
   resumePushOutbox();
   // The usage ledger's daily rollup and its ratchet alerts.

package/stores/claimsUi.ts

@@ -0,0 +1,22 @@
+import { proxy } from "valtio";
+
+// The claims sheet ("Work across machines"). `focus` narrows it to the claims
+// of one overlapping pair, from a row's pill.
+export const claimsUi = proxy<{ open: boolean; focus: string[] | null }>({
+  open: false,
+  focus: null,
+});
+
+export const claimsUiActions = {
+  open: (focus: string[] | null = null) => {
+    claimsUi.focus = focus;
+    claimsUi.open = true;
+  },
+  setOpen: (open: boolean) => {
+    claimsUi.open = open;
+    if (!open) claimsUi.focus = null;
+  },
+  showAll: () => {
+    claimsUi.focus = null;
+  },
+};

package/stores/exportUi.ts

@@ -0,0 +1,87 @@
+import { proxy } from "valtio";
+import {
+  DEFAULT_REQUEST,
+  type ExportRequest,
+  type ExportTurnInfo,
+} from "@/lib/export/view";
+
+// The export sheet, and picking turns in the chat for it. The request lives
+// here so it survives closing the sheet to select turns.
+export const exportUi = proxy<{
+  open: boolean;
+  sessionId: string | null;
+  title: string;
+  req: ExportRequest;
+  /** Open at the turn that began with this message, to the end. */
+  fromItemId: string | null;
+  /** The session's turns, as the last estimate listed them. */
+  turns: ExportTurnInfo[];
+  selecting: boolean;
+  pick: { from: number | null; to: number | null };
+}>({
+  open: false,
+  sessionId: null,
+  title: "",
+  req: { ...DEFAULT_REQUEST },
+  fromItemId: null,
+  turns: [],
+  selecting: false,
+  pick: { from: null, to: null },
+});
+
+export const exportUiActions = {
+  open(sessionId: string, title: string, fromItemId: string | null = null) {
+    if (exportUi.sessionId !== sessionId) {
+      exportUi.turns = [];
+      exportUi.req = { ...exportUi.req, range: undefined };
+    }
+    exportUi.sessionId = sessionId;
+    exportUi.title = title;
+    exportUi.fromItemId = fromItemId;
+    exportUi.open = true;
+  },
+  close() {
+    exportUi.open = false;
+    exportUi.selecting = false;
+    exportUi.fromItemId = null;
+  },
+  setRequest(patch: Partial<ExportRequest>) {
+    exportUi.req = { ...exportUi.req, ...patch };
+  },
+  /** Close the sheet and let the chat's user messages be ticked. */
+  startSelect(from: number | null = null) {
+    exportUi.open = false;
+    exportUi.selecting = true;
+    exportUi.pick = { from, to: null };
+  },
+  /** A tap on a turn: the first sets the start, the second the end. */
+  tap(n: number) {
+    const { from, to } = exportUi.pick;
+    exportUi.pick =
+      from === null || to !== null ? { from: n, to: null } : { from, to: n };
+  },
+  /** Use the ticked turns as the range and go back to the sheet. */
+  finishSelect() {
+    const { from, to } = exportUi.pick;
+    if (from !== null) {
+      const end = to ?? from;
+      exportUi.req = {
+        ...exportUi.req,
+        range: { from: Math.min(from, end), to: Math.max(from, end) },
+      };
+    }
+    exportUi.selecting = false;
+    exportUi.open = true;
+  },
+  cancelSelect() {
+    exportUi.selecting = false;
+    exportUi.open = true;
+  },
+};
+
+/** The ticked turns, ordered: null until something is ticked. */
+export function pickedRange(pick: { from: number | null; to: number | null }) {
+  if (pick.from === null) return null;
+  const end = pick.to ?? pick.from;
+  return { from: Math.min(pick.from, end), to: Math.max(pick.from, end) };
+}

package/app/api/groups/[...path]/route.ts

@@ -1,136 +0,0 @@
-import { NextResponse } from "next/server";
-import { db, queries, type Group } from "@/lib/db";
-
-// GET /api/groups/[...path] - Get a single group
-export async function GET(
-  request: Request,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  const { path: pathParts } = await params;
-  const path = pathParts.join("/");
-
-  try {
-    const group = queries.getGroup(db).get(path) as Group | undefined;
-
-    if (!group) {
-      return NextResponse.json({ error: "Group not found" }, { status: 404 });
-    }
-
-    return NextResponse.json({
-      group: { ...group, expanded: Boolean(group.expanded) },
-    });
-  } catch (error) {
-    console.error("Error fetching group:", error);
-    return NextResponse.json(
-      { error: "Failed to fetch group" },
-      { status: 500 }
-    );
-  }
-}
-
-// PATCH /api/groups/[...path] - Update group (name, expanded, order)
-export async function PATCH(
-  request: Request,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  const { path: pathParts } = await params;
-  const path = pathParts.join("/");
-
-  try {
-    const body = await request.json();
-    const { name, expanded, sort_order } = body;
-
-    // Check if group exists
-    const group = queries.getGroup(db).get(path) as Group | undefined;
-    if (!group) {
-      return NextResponse.json({ error: "Group not found" }, { status: 404 });
-    }
-
-    // Protect default group from being renamed
-    if (path === "sessions" && name !== undefined && name !== "Sessions") {
-      return NextResponse.json(
-        { error: "Cannot rename the default group" },
-        { status: 400 }
-      );
-    }
-
-    // Update name
-    if (name !== undefined) {
-      queries.updateGroupName(db).run(name, path);
-    }
-
-    // Update expanded state
-    if (expanded !== undefined) {
-      queries.updateGroupExpanded(db).run(expanded ? 1 : 0, path);
-    }
-
-    // Update sort order
-    if (sort_order !== undefined) {
-      queries.updateGroupOrder(db).run(sort_order, path);
-    }
-
-    const updatedGroup = queries.getGroup(db).get(path) as Group;
-    return NextResponse.json({
-      group: { ...updatedGroup, expanded: Boolean(updatedGroup.expanded) },
-    });
-  } catch (error) {
-    console.error("Error updating group:", error);
-    return NextResponse.json(
-      { error: "Failed to update group" },
-      { status: 500 }
-    );
-  }
-}
-
-// DELETE /api/groups/[...path] - Delete group (moves sessions to parent or default)
-export async function DELETE(
-  request: Request,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  const { path: pathParts } = await params;
-  const path = pathParts.join("/");
-
-  try {
-    // Protect default group
-    if (path === "sessions") {
-      return NextResponse.json(
-        { error: "Cannot delete the default group" },
-        { status: 400 }
-      );
-    }
-
-    // Check if group exists
-    const group = queries.getGroup(db).get(path) as Group | undefined;
-    if (!group) {
-      return NextResponse.json({ error: "Group not found" }, { status: 404 });
-    }
-
-    // Find parent group or use default
-    const pathParts2 = path.split("/");
-    pathParts2.pop();
-    const parentPath =
-      pathParts2.length > 0 ? pathParts2.join("/") : "sessions";
-
-    // Move all sessions in this group to parent
-    queries.moveSessionsToGroup(db).run(parentPath, path);
-
-    // Also move sessions from any subgroups
-    const allGroups = queries.getAllGroups(db).all() as Group[];
-    const subgroups = allGroups.filter((g) => g.path.startsWith(path + "/"));
-    for (const subgroup of subgroups) {
-      queries.moveSessionsToGroup(db).run(parentPath, subgroup.path);
-      queries.deleteGroup(db).run(subgroup.path);
-    }
-
-    // Delete the group
-    queries.deleteGroup(db).run(path);
-
-    return NextResponse.json({ success: true, movedTo: parentPath });
-  } catch (error) {
-    console.error("Error deleting group:", error);
-    return NextResponse.json(
-      { error: "Failed to delete group" },
-      { status: 500 }
-    );
-  }
-}

package/app/api/groups/route.ts

@@ -1,93 +0,0 @@
-import { NextResponse } from "next/server";
-import { db, queries, type Group } from "@/lib/db";
-
-// GET /api/groups - List all groups
-export async function GET() {
-  try {
-    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({ groups: formattedGroups });
-  } catch (error) {
-    console.error("Error fetching groups:", error);
-    return NextResponse.json(
-      { error: "Failed to fetch groups" },
-      { status: 500 }
-    );
-  }
-}
-
-// POST /api/groups - Create a new group
-export async function POST(request: Request) {
-  try {
-    const body = await request.json();
-    const { name, parentPath } = body;
-
-    if (!name || typeof name !== "string") {
-      return NextResponse.json({ error: "Name is required" }, { status: 400 });
-    }
-
-    // Sanitize name to create path
-    const sanitizedName = name
-      .toLowerCase()
-      .replace(/[^a-z0-9-]/g, "-")
-      .replace(/-+/g, "-")
-      .replace(/^-|-$/g, "");
-
-    if (!sanitizedName) {
-      return NextResponse.json(
-        { error: "Invalid group name" },
-        { status: 400 }
-      );
-    }
-
-    // Build full path
-    const path = parentPath ? `${parentPath}/${sanitizedName}` : sanitizedName;
-
-    // Check if group already exists
-    const existing = queries.getGroup(db).get(path) as Group | undefined;
-    if (existing) {
-      return NextResponse.json(
-        { error: "Group already exists", group: existing },
-        { status: 409 }
-      );
-    }
-
-    // If parent path specified, ensure parent exists
-    if (parentPath) {
-      const parent = queries.getGroup(db).get(parentPath) as Group | undefined;
-      if (!parent) {
-        return NextResponse.json(
-          { error: "Parent group does not exist" },
-          { status: 400 }
-        );
-      }
-    }
-
-    // Get max sort order for new group
-    const groups = queries.getAllGroups(db).all() as Group[];
-    const maxOrder = groups.reduce((max, g) => Math.max(max, g.sort_order), 0);
-
-    // Create the group
-    queries.createGroup(db).run(path, name, maxOrder + 1);
-
-    const newGroup = queries.getGroup(db).get(path) as Group;
-    return NextResponse.json(
-      {
-        group: { ...newGroup, expanded: Boolean(newGroup.expanded) },
-      },
-      { status: 201 }
-    );
-  } catch (error) {
-    console.error("Error creating group:", error);
-    return NextResponse.json(
-      { error: "Failed to create group" },
-      { status: 500 }
-    );
-  }
-}

package/data/groups/index.ts

@@ -1 +0,0 @@
-export { useToggleGroup, useCreateGroup, useDeleteGroup } from "./mutations";

package/data/groups/mutations.ts

@@ -1,95 +0,0 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { sessionKeys } from "../sessions/keys";
-
-export function useToggleGroup() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async ({
-      path,
-      expanded,
-    }: {
-      path: string;
-      expanded: boolean;
-    }) => {
-      const res = await fetch(`/api/groups/${encodeURIComponent(path)}`, {
-        method: "PATCH",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ expanded }),
-      });
-      if (!res.ok) throw new Error("Failed to toggle group");
-      return res.json();
-    },
-    onMutate: async ({ path, expanded }) => {
-      await queryClient.cancelQueries({ queryKey: sessionKeys.list() });
-      const previous = queryClient.getQueryData(sessionKeys.list());
-      queryClient.setQueryData(
-        sessionKeys.list(),
-        (
-          old:
-            | {
-                sessions: unknown[];
-                groups: Array<{ path: string; expanded: boolean }>;
-              }
-            | undefined
-        ) =>
-          old
-            ? {
-                ...old,
-                groups: old.groups.map((g) =>
-                  g.path === path ? { ...g, expanded } : g
-                ),
-              }
-            : old
-      );
-      return { previous };
-    },
-    onError: (_, __, context) => {
-      if (context?.previous) {
-        queryClient.setQueryData(sessionKeys.list(), context.previous);
-      }
-    },
-  });
-}
-
-export function useCreateGroup() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async ({
-      name,
-      parentPath,
-    }: {
-      name: string;
-      parentPath?: string;
-    }) => {
-      const res = await fetch("/api/groups", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ name, parentPath }),
-      });
-      if (!res.ok) throw new Error("Failed to create group");
-      return res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: sessionKeys.list() });
-    },
-  });
-}
-
-export function useDeleteGroup() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async (path: string) => {
-      const res = await fetch(`/api/groups/${encodeURIComponent(path)}`, {
-        method: "DELETE",
-      });
-      if (!res.ok) throw new Error("Failed to delete group");
-      return res.json();
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: sessionKeys.list() });
-    },
-  });
-}

package/hooks/useGroups.ts

@@ -1,37 +0,0 @@
-import { useCallback } from "react";
-import { useToggleGroup, useCreateGroup, useDeleteGroup } from "@/data/groups";
-
-export function useGroups() {
-  const toggleMutation = useToggleGroup();
-  const createMutation = useCreateGroup();
-  const deleteMutation = useDeleteGroup();
-
-  const toggleGroup = useCallback(
-    async (path: string, expanded: boolean) => {
-      await toggleMutation.mutateAsync({ path, expanded });
-    },
-    [toggleMutation]
-  );
-
-  const createGroup = useCallback(
-    async (name: string, parentPath?: string) => {
-      await createMutation.mutateAsync({ name, parentPath });
-    },
-    [createMutation]
-  );
-
-  const deleteGroup = useCallback(
-    async (path: string) => {
-      if (!confirm("Delete this group? Sessions will be moved to parent."))
-        return;
-      await deleteMutation.mutateAsync(path);
-    },
-    [deleteMutation]
-  );
-
-  return {
-    toggleGroup,
-    createGroup,
-    deleteGroup,
-  };
-}