@saadnvd1/agent-os 0.3.584 → 0.3.587

package/lib/tasks/finish.ts

@@ -24,7 +24,13 @@ import {
 import { mergePR } from "./merge-pr";
 import { getProject } from "../projects";
 import { canSignOff } from "./state";
-import { forgetPR, getTaskSession, prFor, projectPathFor } from "./session";
+import {
+  forgetPR,
+  getTaskSession,
+  isAllowedBase,
+  prFor,
+  projectPathFor,
+} from "./session";
 import { dropSessionDatabase } from "../project-config/database";
 import { captureMergedTask } from "../session-logs";
 import { sessionEnded } from "../experiments/hooks";
@@ -114,7 +120,13 @@ async function finishMerge(
 // machine merged it and didn't say).
 export async function signOffTask(
   id: string,
-  opts: { wait?: boolean; head?: string; device?: string | null } = {}
+  opts: {
+    wait?: boolean;
+    head?: string;
+    device?: string | null;
+    // The base another machine judged the gates against (a forwarded merge).
+    base?: string;
+  } = {}
 ): Promise<MergeMethod | null> {
   const session = getTaskSession(id);
   if (session.task_status !== "running")
@@ -124,14 +136,24 @@ export async function signOffTask(
   if (held) throw new Error(held);
   // Its own machine checks the gates and merges.
   // That machine's settings chose the method; null if it didn't say.
-  if (isMirror(session)) return remoteTaskAction(session, "merge", opts.head);
+  if (isMirror(session))
+    return remoteTaskAction(session, "merge", opts.head, session.base_branch);
   const repo = projectPathFor(session);
   if (!repo) throw new Error("Task has no project");
   const refusal = signOffRefusal(id);
   if (refusal) throw new Error(refusal);
   // prFor follows a retarget onto the record, so compare with what the
   // checks above were judged against.
-  const judgedBase = session.base_branch;
+  // A forwarded merge was judged on the other machine against the base it
+  // recorded, which may be newer than this machine's row; only a base this
+  // task may have is taken.
+  if (
+    opts.base &&
+    opts.base !== session.base_branch &&
+    !(await isAllowedBase(session, repo, opts.base))
+  )
+    throw new Error(`${opts.base} isn't a base ${session.name} may merge into`);
+  const judgedBase = opts.base ?? session.base_branch;
   const pr = await prFor(session, true);
   const verdict = canSignOff(pr);
   if (!verdict.ok) throw new Error(verdict.reason);

package/lib/tasks/move-bundle.ts

@@ -6,6 +6,8 @@
 import { isBranchName } from "../git";
 import { CHAT_ACCESS, type ChatAccess } from "../chat/events";
 import type { ProjectRef } from "./project-ref";
+import type { MovedBookmark } from "../bookmarks/store";
+import { MAX_NOTE_CHARS, MAX_SNAPSHOT_CHARS } from "../bookmarks/types";
 import { isClaudeSessionId } from "./transcript";
 
 // A long task's conversation runs to a few MB; this is far past that.
@@ -92,11 +94,17 @@ export interface ChatBundle {
   // An undo's resume point not yet used up, and the context meter.
   resumeAt: string | null;
   context: string | null;
+  // Its bookmarks; absent from a machine that predates them.
+  bookmarks?: MovedBookmark[];
 }
 
 const isStr = (v: unknown): v is string => typeof v === "string";
 const isStrOrNull = (v: unknown) => v === null || isStr(v);
 
+const BOOKMARK_KINDS = ["user", "assistant", "tool", "turn"];
+// Far past what a person stars in one chat.
+export const MAX_MOVED_BOOKMARKS = 2000;
+
 function validateChat(c: ChatBundle): ChatBundle {
   if (!c || typeof c !== "object" || !Array.isArray(c.items))
     throw new Error("Bad chat");
@@ -119,6 +127,26 @@ function validateChat(c: ChatBundle): ChatBundle {
       throw new Error("Bad queued message");
     bytes += m.id.length + m.text.length + (m.images?.length ?? 0);
   }
+  if (c.bookmarks !== undefined && !Array.isArray(c.bookmarks))
+    throw new Error("Bad chat bookmarks");
+  if ((c.bookmarks?.length ?? 0) > MAX_MOVED_BOOKMARKS)
+    throw new Error("Too many bookmarks to move");
+  for (const b of c.bookmarks ?? []) {
+    if (
+      !b ||
+      !isStr(b.itemId) ||
+      b.itemId.length > 200 ||
+      !(b.scope === "item" || b.scope === "turn") ||
+      !BOOKMARK_KINDS.includes(b.kind) ||
+      !isStr(b.text) ||
+      b.text.length > MAX_SNAPSHOT_CHARS + 1 ||
+      !isStrOrNull(b.note) ||
+      (b.note?.length ?? 0) > MAX_NOTE_CHARS ||
+      !isStr(b.createdAt)
+    )
+      throw new Error("Bad bookmark");
+    bytes += b.itemId.length + b.text.length + (b.note?.length ?? 0);
+  }
   if (bytes > MAX_CHAT_BYTES) throw new Error("The chat is too large to move");
   if (!isStrOrNull(c.resumeAt) || !isStrOrNull(c.context))
     throw new Error("Bad chat");

package/lib/tasks/move-chat.ts

@@ -11,6 +11,7 @@ import { settle, listItems } from "../chat/store";
 import { stopChatAtTurnEnd } from "../chat/stop";
 import { rewritePaths } from "./transcript";
 import { MAX_CHAT_BYTES, type ChatBundle } from "./move-bundle";
+import { bookmarksForMove, insertMovedBookmarks } from "../bookmarks/store";
 
 // A turn this long is left to finish: the move is refused, not cut short.
 export const MOVE_TURN_WAIT_MS = 3 * 60_000;
@@ -50,6 +51,7 @@ export function packChat(session: Session): ChatBundle {
     sentBy: r.sent_by,
     createdAt: r.created_at,
   }));
+  const bookmarks = bookmarksForMove(session.id);
   const chat: ChatBundle = {
     items,
     queue,
@@ -57,10 +59,15 @@ export function packChat(session: Session): ChatBundle {
     plan: !!session.chat_plan,
     resumeAt: session.chat_resume_at,
     context: session.chat_context,
+    bookmarks,
   };
   const bytes =
     items.reduce((n, i) => n + i.id.length + i.data.length, 0) +
-    queue.reduce((n, m) => n + m.text.length + (m.images?.length ?? 0), 0);
+    queue.reduce((n, m) => n + m.text.length + (m.images?.length ?? 0), 0) +
+    bookmarks.reduce(
+      (n, b) => n + b.itemId.length + b.text.length + (b.note?.length ?? 0),
+      0
+    );
   if (bytes > MAX_CHAT_BYTES) throw new Error("The chat is too large to move");
   return chat;
 }
@@ -103,6 +110,7 @@ export function unpackChat(
       m.createdAt
     )
   );
+  insertMovedBookmarks(id, chat.bookmarks ?? []);
 }
 
 const imageCount = (images: string) => {
@@ -118,4 +126,5 @@ const imageCount = (images: string) => {
 export function dropChat(id: string): void {
   db.prepare(`DELETE FROM chat_items WHERE session_id = ?`).run(id);
   db.prepare(`DELETE FROM chat_queue WHERE session_id = ?`).run(id);
+  db.prepare(`DELETE FROM chat_bookmarks WHERE session_id = ?`).run(id);
 }

package/lib/tasks/queue.ts

@@ -312,6 +312,26 @@ export interface QueueRequest {
   priority?: Priority;
   // "mac" pins it to a Mac; "any" says it needs nothing in particular.
   machine?: "any" | "mac";
+  // Start at once, past the running-task limit, instead of queueing for a
+  // slot. Still needs the machine it needs, and an orchestrator's start
+  // still passes its brakes.
+  now?: boolean;
+}
+
+// How full the workspace's running-task limit is for this project.
+export function slotState(projectId: string): {
+  running: number;
+  limit: number | null;
+  full: boolean;
+} {
+  const workspaceId = workspaceOf(projectId);
+  const limit = limitOf(workspaceId);
+  if (!workspaceId || limit === null)
+    return { running: 0, limit: null, full: false };
+  const running =
+    runningIn({ workspaceId, projectId }, true).length +
+    startingIn(workspaceId);
+  return { running, limit, full: running >= limit };
 }
 
 const waitingIn = (workspaceId: string) =>
@@ -349,8 +369,11 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
     }
   } else if (after)
     afterTask = resolveAfter(after, req.originWorkspaceId ?? workspaceId).id;
+  if (req.now && waits)
+    throw new Error("now and after don't go together: now starts it at once");
   const full =
     !req.planOnly &&
+    !req.now &&
     limit !== null &&
     !!workspaceId &&
     (runningIn({ workspaceId, projectId: project.id }, true).length +
@@ -364,9 +387,18 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
     throw new Error(`Machine is "any" or "mac"`);
   // The orchestrator's own starts wait out a loaded machine; a person's
   // direct start goes ahead, as "start now" always has.
+  if (
+    req.now &&
+    !req.planOnly &&
+    needsUnmetHere(project.id, req.prompt, setting)
+  )
+    throw new Error(
+      `Can't start now: this task needs a Mac, and this machine isn't one. Queue it without now.`
+    );
   const loaded =
     !waits &&
     !full &&
+    !req.now &&
     !req.planOnly &&
     !!req.originWorkspaceId &&
     loadHeldStart(project.id, req.prompt, setting);
@@ -426,7 +458,8 @@ export async function startOrQueue<T>(
   const queued = queueIfNeeded(req);
   if (queued) return { queued };
   const workspaceId = workspaceOf(req.projectId);
-  if (!workspaceId) return { started: await start() };
+  // A plan-only start never holds a slot, as its queue row doesn't.
+  if (!workspaceId || req.planOnly) return { started: await start() };
   reserved.set(workspaceId, (reserved.get(workspaceId) ?? 0) + 1);
   try {
     return { started: await start() };
@@ -539,6 +572,33 @@ function autoHold(workspaceId: string | null, planOnly = false): Hold | null {
   return window ? { code: "window", text: `Waiting: ${window}` } : null;
 }
 
+const requestNeeds = (
+  projectId: string,
+  workingDirectory: string,
+  prompt: string,
+  setting: Need[] | null
+): Need[] =>
+  setting ??
+  needsOf({
+    projectId,
+    projectPath: expandHome(workingDirectory),
+    prompt,
+  }).needs;
+
+// Whether the task needs something this machine lacks (a Mac).
+function needsUnmetHere(
+  projectId: string,
+  prompt: string,
+  setting: Need[] | null
+): boolean {
+  const project = getProject(projectId);
+  if (!project || isRemoteHost(project.host_id)) return false;
+  return !meetsNeeds(
+    requestNeeds(projectId, project.working_directory, prompt, setting),
+    machineCapabilities()
+  );
+}
+
 // Whether this machine's load rules out starting a task for this project now.
 function loadHeldStart(
   projectId: string,
@@ -547,13 +607,12 @@ function loadHeldStart(
 ): boolean {
   const project = getProject(projectId);
   if (!project || isRemoteHost(project.host_id)) return false;
-  const needs =
-    setting ??
-    needsOf({
-      projectId,
-      projectPath: expandHome(project.working_directory),
-      prompt,
-    }).needs;
+  const needs = requestNeeds(
+    projectId,
+    project.working_directory,
+    prompt,
+    setting
+  );
   const hold = machineHold(
     {
       heavy: heavyNeeds(needs),
@@ -593,6 +652,8 @@ interface StartOpts {
   // Start on this linked machine instead of the project's.
   placement?: Placement | null;
   heavy?: boolean;
+  // Pass this workspace's brakes even for a row no orchestrator queued.
+  brakeAs?: string;
 }
 
 async function startRow(
@@ -683,9 +744,10 @@ async function startRow(
   try {
     // The orchestrator's queued starts pass its brakes when they start,
     // a person's "start now" included: it skips only the limit and `after`.
-    const session = origin
+    const brakeWs = origin ?? opts.brakeAs;
+    const session = brakeWs
       ? await braked(
-          origin,
+          brakeWs,
           "task",
           () => createTask(task),
           (s) => s.id,
@@ -1090,6 +1152,67 @@ export async function startQueuedNow(id: string): Promise<StartOutcome> {
   return startRow(r, { force: true });
 }
 
+export interface ForcedStart {
+  outcome: "started" | "held" | "failed";
+  // Why it is held, or what failed; empty when it started.
+  text: string;
+  // The running-task limit was full when it started.
+  wasFull: boolean;
+  running: number;
+  limit: number | null;
+  // It skipped an `after`.
+  skippedAfter: boolean;
+}
+
+// The orchestrator's start now: past the limit and `after`, never past
+// Pause, its brakes or a machine need. A held task stays queued.
+export async function startQueuedForOrchestrator(
+  workspaceId: string,
+  id: string
+): Promise<ForcedStart> {
+  const r = row(id);
+  const project = r ? getProject(r.project_id) : null;
+  if (!r || r.status !== "queued" || project?.workspace_id !== workspaceId)
+    throw new Error("That task isn't waiting in the queue");
+  const slots = slotState(r.project_id);
+  const base = {
+    wasFull: slots.full,
+    running: slots.running,
+    limit: slots.limit,
+    skippedAfter: !!(r.after_task || r.after_any),
+  };
+  const held = (text: string): ForcedStart => ({
+    ...base,
+    outcome: "held",
+    text,
+  });
+  if (isPaused(workspaceId)) return held("the orchestrator is paused by Saad");
+  if (isRemoteHost(r.host_id ?? project.host_id))
+    return held(
+      "it runs on another machine, and the orchestrator starts tasks on this one only"
+    );
+  if (
+    !meetsNeeds(
+      parseNeeds(r.machine_needs) ??
+        requestNeeds(project.id, project.working_directory, r.prompt, null),
+      machineCapabilities()
+    )
+  )
+    return held("it needs a Mac, and this machine isn't one");
+  try {
+    const outcome = await startRow(r, { force: true, brakeAs: workspaceId });
+    if (outcome === "started") return { ...base, outcome, text: "" };
+    return held("it could not be claimed just now; try again");
+  } catch (error) {
+    if (error instanceof BrakeRefused) return held(error.reason);
+    return {
+      ...base,
+      outcome: "failed",
+      text: row(id)?.error ?? String(error),
+    };
+  }
+}
+
 // A task still waiting in the line (or failed to start) by id, an id prefix
 // of 4+ characters or, when asked, its name; in one workspace.
 export function findQueued(

package/lib/tasks/remote.ts

@@ -191,7 +191,8 @@ export function setMirrorStatus(id: string, status: TaskStatus): void {
 export async function remoteTaskAction(
   session: Session,
   action: "merge" | "drop",
-  head?: string
+  head?: string,
+  base?: string | null
 ): Promise<MergeMethod | null> {
   const link = requireHostLink(session.host_id);
   // An AgentOS that predates pinned merges would ignore the head and merge
@@ -203,11 +204,28 @@ export async function remoteTaskAction(
         `${link.hostName}'s AgentOS can't pin a merge to a commit; update it first`
       );
   }
+  // base: what the gates here were judged against; the machine that merges
+  // compares the PR with it, not with a base only it recorded.
   const res = await hostApi<{ head?: string | null; method?: unknown }>(
     link,
     `/api/tasks/${encodeURIComponent(session.id)}/${action}`,
-    { body: head ? { head } : {}, timeout: 300000 }
-  );
+    {
+      body: { ...(head && { head }), ...(head && base && { base }) },
+      timeout: 300000,
+    }
+  ).catch(async (err) => {
+    if (action !== "merge" || !unknownOutcome(err)) throw err;
+    // A proxy or a dropped connection after the merge ran answers 502 with
+    // nothing from AgentOS: ask what state the task is in before failing.
+    const merged = await hostTasks(link, true)
+      .then((l) => l.tasks.find((t) => t.id === session.id)?.state === "merged")
+      .catch(() => false);
+    if (!merged)
+      throw new Error(
+        `${(err as Error).message}: couldn't confirm whether ${link.hostName} merged ${session.name}; check its PR before signing off again`
+      );
+    return { head: head ?? null, method: undefined };
+  });
   forgetHostTasks(link.hostId);
   setMirrorStatus(session.id, action === "merge" ? "merged" : "dropped");
   if (head && res.head !== head)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.584",
+  "version": "0.3.587",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/stores/bookmarksUi.ts

@@ -0,0 +1,50 @@
+import { proxy } from "valtio";
+
+// The Bookmarks views: every chat's (`open`, one workspace's or all), or one
+// chat's (`chatSessionId`); the bookmark whose note is being written; and a
+// jump waiting for its chat to be on screen.
+export const bookmarksUi = proxy<{
+  open: boolean;
+  workspaceId: string | null;
+  chatSessionId: string | null;
+  editing: string | null;
+  jump: { sessionId: string; itemId: string; at: number } | null;
+}>({
+  open: false,
+  workspaceId: null,
+  chatSessionId: null,
+  editing: null,
+  jump: null,
+});
+
+export const bookmarksUiActions = {
+  open: (workspaceId: string | null = null) => {
+    bookmarksUi.workspaceId = workspaceId;
+    bookmarksUi.open = true;
+  },
+  setOpen: (open: boolean) => {
+    bookmarksUi.open = open;
+    if (!open) bookmarksUi.editing = null;
+  },
+  openChat: (sessionId: string, editing: string | null = null) => {
+    bookmarksUi.editing = editing;
+    bookmarksUi.chatSessionId = sessionId;
+  },
+  closeChat: () => {
+    bookmarksUi.chatSessionId = null;
+    bookmarksUi.editing = null;
+  },
+  edit: (id: string | null) => {
+    bookmarksUi.editing = id;
+  },
+  jump: (sessionId: string, itemId: string) => {
+    bookmarksUi.jump = { sessionId, itemId, at: Date.now() };
+  },
+  // The chat showing it takes the jump; one taken isn't taken twice.
+  takeJump: (sessionId: string): string | null => {
+    const j = bookmarksUi.jump;
+    if (!j || j.sessionId !== sessionId) return null;
+    bookmarksUi.jump = null;
+    return j.itemId;
+  },
+};

package/styles/themes.css

@@ -28,6 +28,8 @@
     --find-match: 48 96% 53% / 0.45;
     --find-current: 25 95% 53%;
     --find-current-foreground: 0 0% 0%;
+    /* A bookmarked item's star. */
+    --bookmark: 30 90% 40%;
     --background: 240 10% 95.5%;
     --foreground: 240 12% 14%;
     --card: 0 0% 100%;
@@ -292,6 +294,7 @@
      =========================================================================== */
   .dark {
     --find-match: 48 96% 53% / 0.35;
+    --bookmark: 43 96% 56%;
     --background: 240 18% 3.5%;
     --foreground: 240 10% 93%;
     --card: 240 14% 6%;