@saadnvd1/agent-os 0.3.799 → 0.3.810

package/lib/nav/history-writer.ts

@@ -0,0 +1,109 @@
+import type { Position } from "./position";
+
+/**
+ * The one place the page writes browser history. A chat switch or a bookmark
+ * pushes an entry; where the reader is in the chat goes into the CURRENT
+ * entry's state with replaceState, at most once per POSITION_EVERY_MS, so
+ * back lands on the message that was on screen without filling the history
+ * (Safari throws after 100 calls in 30 seconds, Firefox throws on a burst,
+ * Chrome drops them silently).
+ *
+ * Next patches pushState/replaceState to carry its own keys in the state it
+ * is given, so the state is always the current one with `aos` replaced.
+ */
+export interface NavState {
+  v: 1;
+  /** Counts up with every push; the menu's key for the entry. */
+  index: number;
+  sessionId: string | null;
+  pos?: Position;
+}
+
+export interface HistoryLike {
+  state: unknown;
+  pushState(state: unknown, unused: string, url?: string): void;
+  replaceState(state: unknown, unused: string, url?: string): void;
+}
+
+export const POSITION_EVERY_MS = 2000;
+// Position writes stop, navigation never does, when a burst gets this close
+// to the limits above.
+const BURST_WINDOW_MS = 30_000;
+const BURST_MAX = 50;
+
+export function navStateOf(state: unknown): NavState | null {
+  const aos = (state as { aos?: NavState } | null)?.aos;
+  return aos && aos.v === 1 && typeof aos.index === "number" ? aos : null;
+}
+
+const withNav = (state: unknown, aos: NavState) => ({
+  ...(state && typeof state === "object" ? state : {}),
+  aos,
+});
+
+export class HistoryWriter {
+  private pending: { sessionId: string; pos: Position } | null = null;
+  private lastWrite = -Infinity;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private writes: number[] = [];
+
+  constructor(private h: HistoryLike) {}
+
+  /** The state of the entry the page is on. */
+  current(): NavState | null {
+    return navStateOf(this.h.state);
+  }
+
+  /** Where the reader is now; written into the current entry, coalesced. */
+  setPosition(sessionId: string, pos: Position): void {
+    this.pending = { sessionId, pos };
+    if (this.timer) return;
+    const wait = this.lastWrite + POSITION_EVERY_MS - Date.now();
+    if (wait <= 0) this.flush();
+    else this.timer = setTimeout(() => this.flush(), wait);
+  }
+
+  /** Writes the waiting position now, if it belongs to the current entry. */
+  flush(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    const p = this.pending;
+    this.pending = null;
+    const cur = this.current();
+    if (!p || !cur || cur.sessionId !== p.sessionId) return;
+    const now = Date.now();
+    this.writes = this.writes.filter((t) => now - t < BURST_WINDOW_MS);
+    if (this.writes.length >= BURST_MAX) return;
+    this.writes.push(now);
+    this.lastWrite = now;
+    this.h.replaceState(withNav(this.h.state, { ...cur, pos: p.pos }), "");
+  }
+
+  /** A new entry for a chat. The one being left keeps its position first. */
+  push(href: string, sessionId: string | null): NavState {
+    this.flush();
+    const cur = this.current();
+    const next: NavState = {
+      v: 1,
+      index: (cur?.index ?? 0) + 1,
+      sessionId,
+    };
+    this.h.pushState(withNav(null, next), "", href);
+    return next;
+  }
+
+  /** The same entry at another address (a rename), keeping its state. A page
+   * that has none yet gets its first, index 0. */
+  replace(href: string, sessionId: string | null): NavState {
+    const cur = this.current();
+    const next: NavState = cur
+      ? { ...cur, sessionId }
+      : { v: 1, index: 0, sessionId };
+    // A different chat takes the entry over: its position was another's.
+    if (cur && cur.sessionId !== sessionId) delete next.pos;
+    if (this.pending && this.pending.sessionId !== sessionId)
+      this.pending = null;
+    this.h.replaceState(withNav(this.h.state, next), "", href);
+    return next;
+  }
+}

package/lib/nav/position.ts

@@ -0,0 +1,67 @@
+import type { ChatItem } from "@/lib/chat/events";
+import type { ChatView } from "@/lib/chat-views/types";
+
+/** Where a reader is in a chat: the block in view's key, how far its top is
+ * from the top of the list, and whether they follow the latest output. */
+export interface Position {
+  block: string | null;
+  offsetPx: number;
+  atEnd: boolean;
+}
+
+export interface RowRect {
+  key: string;
+  top: number;
+  bottom: number;
+}
+
+/** The first row whose bottom is below the top of the list, and how far its
+ * top sits from there (negative when it is partly scrolled off). */
+export function anchorOf(
+  listTop: number,
+  rows: RowRect[],
+  atEnd: boolean
+): Position {
+  if (atEnd) return { block: null, offsetPx: 0, atEnd: true };
+  const row = rows.find((r) => r.bottom > listTop + 1);
+  if (!row) return { block: null, offsetPx: 0, atEnd: true };
+  return {
+    block: row.key,
+    offsetPx: Math.round(row.top - listTop),
+    atEnd: false,
+  };
+}
+
+export type OpenAt =
+  | { kind: "latest" }
+  | { kind: "new"; itemId: string; hasBefore: boolean }
+  | { kind: "position"; block: string; offsetPx: number };
+
+interface OpenInput {
+  /** What the server remembers about this chat; none when never opened. */
+  view: Pick<ChatView, "itemId" | "offsetPx" | "atEnd" | "viewedAt"> | null;
+  /** The loaded items, oldest first. */
+  items: Pick<ChatItem, "id" | "createdAt">[];
+  /** Opened from a notification, Needs you or the Inbox. */
+  latest: boolean;
+}
+
+/**
+ * Where a chat opens when nothing asked for a particular message:
+ * - from a notification, Needs you or the Inbox: the latest;
+ * - with items newer than the last time it was open: the first new one;
+ * - otherwise where it was left, unless that was the end;
+ * - never opened: the latest.
+ */
+export function decideOpen({ view, items, latest }: OpenInput): OpenAt {
+  if (latest || !view) return { kind: "latest" };
+  const firstNew = items.findIndex((i) => i.createdAt > view.viewedAt);
+  if (firstNew !== -1)
+    return {
+      kind: "new",
+      itemId: items[firstNew].id,
+      hasBefore: firstNew > 0,
+    };
+  if (view.atEnd || !view.itemId) return { kind: "latest" };
+  return { kind: "position", block: view.itemId, offsetPx: view.offsetPx };
+}

package/lib/nav/recent.ts

@@ -0,0 +1,34 @@
+// Which chat was open before this one, and chats most-recently-opened first.
+// "Opened" is the chat's viewed_at, which the page stamps whenever a chat is
+// shown, so it is the same on every device.
+
+/** When each chat was last opened, by session id (epoch ms). */
+export type Opened = Record<string, number | undefined>;
+
+/** Most recently opened first; never-opened chats keep their order after. */
+export function recentFirst<T extends { id: string }>(
+  items: readonly T[],
+  opened: Opened
+): T[] {
+  return items
+    .map((item, i) => ({ item, i, at: opened[item.id] ?? -1 }))
+    .sort((a, b) => b.at - a.at || a.i - b.i)
+    .map((x) => x.item);
+}
+
+/** The chat opened just before the current one, among those still open. */
+export function previousChatId(
+  ids: readonly string[],
+  opened: Opened,
+  currentId: string | null | undefined
+): string | null {
+  let best: string | null = null;
+  let bestAt = -1;
+  for (const id of ids) {
+    const at = opened[id];
+    if (id === currentId || at === undefined || at <= bestAt) continue;
+    best = id;
+    bestAt = at;
+  }
+  return best;
+}

package/lib/orchestrator/armed.ts

@@ -30,6 +30,7 @@ import { isFast } from "../project-tier/getProjectTier";
 import { workspaceTask } from "./targets";
 import { markStatusDirty } from "../status/dirty";
 import { setPr } from "../db/session-parts";
+import { noteAutoArmed } from "./fast-lane-state";
 
 // Judged again at least this often, for what the fingerprint can't see.
 export const ARMED_RECHECK_MS = 5 * 60 * 1000;
@@ -140,6 +141,10 @@ async function armedNow(workspaceId: string, task: Session): Promise<string> {
 export function disarm(workspaceId: string, ref: string): string {
   const task = workspaceTask(workspaceId, ref);
   setArmed(task.id, false);
+  // A fast task not yet auto-armed would be armed on the next pass; mark
+  // its PR as handled so the disarm sticks either way.
+  if (isFast(task) && task.pr_number)
+    noteAutoArmed(task.id, workspaceId, task.pr_number);
   return `Disarmed ${task.name}: it merges only through sign_off now.`;
 }
 

package/lib/palette/sections.ts

@@ -18,6 +18,8 @@ export interface Section {
 export const PER_TAB = 5;
 export const RECENT = 5;
 const NEEDS_YOU = 5;
+// The hint on the chat on show, which a switcher skips past.
+export const CURRENT = "Current";
 const SUGGESTED = 6;
 
 const label = (tab: PaletteTab) =>
@@ -61,11 +63,10 @@ export function tabItems(
   usage: Usage,
   now: number
 ): PaletteCommand[] {
-  return scoreCommands(
-    commands.filter((c) => tabOf(c) === tab),
-    query,
-    boostFor(usage, now)
-  ).map((m) => m.c);
+  const inTab = commands.filter((c) => tabOf(c) === tab);
+  // Sessions read most-recent-first (the order they were registered in).
+  if (tab === "sessions" && !query.trim()) return inTab;
+  return scoreCommands(inTab, query, boostFor(usage, now)).map((m) => m.c);
 }
 
 // The short list All opens on: the last things run, sessions that need the
@@ -99,13 +100,18 @@ export function emptySections(
       .filter((c): c is PaletteCommand => !!c),
     RECENT
   );
+  const recentChats = take(
+    commands.filter((c) => tabOf(c) === "sessions" && c.hint !== CURRENT),
+    RECENT
+  );
   const sections: Section[] = [
+    { name: "Recent chats", items: recentChats },
     { name: "Recent", items: recent },
     { name: "Needs you / running", items: busy },
     { name: "This session", items: here },
   ];
   // A first run has no history: offer the commands that start things.
-  if (recent.length + busy.length + here.length < 4)
+  if (recent.length + busy.length + here.length + recentChats.length < 4)
     sections.push({
       name: "Suggested",
       items: take(

package/lib/session-url.ts

@@ -193,8 +193,11 @@ export function locateSession(
 
 export interface SessionUrlEnv {
   href(): string;
-  push(href: string): void;
-  replace(href: string): void;
+  // The session the address names goes along, for the entry's own record.
+  push(href: string, sessionId: string | null): void;
+  replace(href: string, sessionId: string | null): void;
+  /** The address already says it: the entry still learns which session. */
+  settle?(sessionId: string | null): void;
 }
 
 export interface SessionUrlDeps {
@@ -301,9 +304,12 @@ export class SessionUrlSync {
       id ? { id, name: this.deps.nameOf(id) ?? undefined } : null
     );
     const url = new URL(href, BASE);
-    if (next === url.pathname + url.search + url.hash) return;
-    if (mode === "push") this.env.push(next);
-    else this.env.replace(next);
+    if (next === url.pathname + url.search + url.hash) {
+      this.env.settle?.(id);
+      return;
+    }
+    if (mode === "push") this.env.push(next, id);
+    else this.env.replace(next, id);
   }
 }
 

package/package.json

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

package/scripts/check

@@ -37,7 +37,7 @@ if has static; then
     out=$(mktemp -d); trap 'rm -rf "$out"' EXIT
     pids=()
     npx tsc --noEmit >"$out/typecheck" 2>&1 & pids+=($!)
-    npx eslint . --max-warnings=40 --concurrency=auto >"$out/lint" 2>&1 & pids+=($!)
+    npx eslint . --max-warnings=28 --concurrency=auto >"$out/lint" 2>&1 & pids+=($!)
     npx prettier --check . --log-level warn >"$out/format" 2>&1 & pids+=($!)
     failed=()
     names=(typecheck lint format)
@@ -51,7 +51,7 @@ if has static; then
     fi
   else
     step "typecheck"; npx tsc --noEmit
-    step "lint";      npx eslint . --max-warnings=40 --concurrency=auto
+    step "lint";      npx eslint . --max-warnings=28 --concurrency=auto
     step "format";    npx prettier --check . --log-level warn
   fi
 fi

package/stores/chatJump.ts

@@ -1,14 +1,10 @@
 import { hrefWithSession } from "@/lib/session-url";
+import { go } from "@/components/Chat/session-link";
 import { bookmarksUiActions } from "@/stores/bookmarksUi";
 
 // Opens a chat by its address, then takes it to one message (bookmarks and
 // search both end here). The chat takes the jump once it is on screen.
 export function openChatAt(sessionId: string, itemId: string): void {
-  window.history.pushState(
-    null,
-    "",
-    hrefWithSession(location.href, { id: sessionId })
-  );
-  window.dispatchEvent(new PopStateEvent("popstate"));
+  go(hrefWithSession(location.href, { id: sessionId }), sessionId);
   bookmarksUiActions.jump(sessionId, itemId);
 }

package/stores/chatPositions.ts

@@ -0,0 +1,65 @@
+import { proxy } from "valtio";
+import type { ChatView } from "@/lib/chat-views/types";
+import type { Position } from "@/lib/nav/position";
+
+// A place asked for and not taken this soon is stale.
+const TARGET_MS = 10_000;
+
+// When each chat was last opened, apart from `views` so that a reader moving
+// through a chat doesn't redraw everything that lists chats by recency.
+export const chatOpened = proxy<Record<string, number>>({});
+
+const noteOpened = (v: ChatView) => {
+  if (chatOpened[v.sessionId] !== v.viewedAt)
+    chatOpened[v.sessionId] = v.viewedAt;
+};
+
+// What the page knows of where each chat was last read (the server's copy,
+// kept current as the reader moves), a place a history entry asks a chat to
+// open at, and the chats to open at their latest message.
+export const chatPositions = proxy<{
+  views: Record<string, ChatView>;
+  loaded: boolean;
+  target: { sessionId: string; pos: Position; at: number } | null;
+  latest: string[];
+}>({ views: {}, loaded: false, target: null, latest: [] });
+
+export const chatPositionsActions = {
+  // The server's list; what this page wrote since is newer and stays.
+  hydrate: (list: ChatView[]) => {
+    for (const v of list) {
+      const mine = chatPositions.views[v.sessionId];
+      if (!mine || mine.viewedAt < v.viewedAt)
+        chatPositions.views[v.sessionId] = v;
+      noteOpened(chatPositions.views[v.sessionId]);
+    }
+    chatPositions.loaded = true;
+  },
+  // The list couldn't be had: chats open at their latest, as they used to.
+  giveUp: () => {
+    chatPositions.loaded = true;
+  },
+  record: (view: ChatView) => {
+    chatPositions.views[view.sessionId] = view;
+    noteOpened(view);
+  },
+  setTarget: (sessionId: string, pos: Position) => {
+    chatPositions.target = { sessionId, pos, at: Date.now() };
+  },
+  takeTarget: (sessionId: string): Position | null => {
+    const t = chatPositions.target;
+    if (!t || t.sessionId !== sessionId) return null;
+    chatPositions.target = null;
+    return Date.now() - t.at < TARGET_MS ? t.pos : null;
+  },
+  wantLatest: (sessionId: string) => {
+    if (!chatPositions.latest.includes(sessionId))
+      chatPositions.latest.push(sessionId);
+  },
+  takeLatest: (sessionId: string): boolean => {
+    const at = chatPositions.latest.indexOf(sessionId);
+    if (at === -1) return false;
+    chatPositions.latest.splice(at, 1);
+    return true;
+  },
+};

package/stores/navHistory.ts

@@ -0,0 +1,98 @@
+import { proxy } from "valtio";
+import { HistoryWriter, navStateOf } from "@/lib/nav/history-writer";
+import {
+  emptyMirror,
+  moveTo,
+  renameIn,
+  visit,
+  type Mirror,
+} from "@/lib/nav/history-mirror";
+import type { Position } from "@/lib/nav/position";
+
+const KEY = "agentos-nav-history";
+
+function load(): Mirror {
+  try {
+    const raw = JSON.parse(sessionStorage.getItem(KEY) ?? "null");
+    if (raw && Array.isArray(raw.entries) && typeof raw.current === "number")
+      return raw;
+  } catch {
+    // Unavailable or corrupt: start over.
+  }
+  return emptyMirror();
+}
+
+const noHistory = typeof window === "undefined";
+// Made on first use in the browser.
+let writer: HistoryWriter | null = null;
+const w = () => (writer ??= new HistoryWriter(window.history));
+
+// The entries this tab made, for the back button's menu and for knowing
+// whether there is anywhere to go. Kept in sessionStorage across a reload.
+export const navHistory = proxy<Mirror>(noHistory ? emptyMirror() : load());
+
+function set(next: Mirror) {
+  navHistory.entries = next.entries;
+  navHistory.current = next.current;
+  try {
+    sessionStorage.setItem(KEY, JSON.stringify(next));
+  } catch {
+    // The menu is lost on reload; history itself is not.
+  }
+}
+
+const snapshot = (): Mirror => ({
+  entries: navHistory.entries.map((e) => ({ ...e })),
+  current: navHistory.current,
+});
+
+export const navHistoryActions = {
+  /** A new entry for a chat switch or a bookmark. */
+  push: (href: string, sessionId: string | null, name: string) => {
+    const s = w().push(href, sessionId);
+    set(
+      visit(
+        snapshot(),
+        { index: s.index, sessionId: sessionId ?? "", name },
+        "push"
+      )
+    );
+  },
+  /** The same entry at another address, or the first sight of this one. */
+  replace: (href: string, sessionId: string | null, name: string) => {
+    const s = w().replace(href, sessionId);
+    set(
+      visit(
+        snapshot(),
+        { index: s.index, sessionId: sessionId ?? "", name },
+        "replace"
+      )
+    );
+  },
+  /** Where the reader is in the chat, for the entry they're on. */
+  setPosition: (sessionId: string, pos: Position) =>
+    w().setPosition(sessionId, pos),
+  flush: () => w().flush(),
+  /** Back or forward landed on an entry: where it was made, if known. */
+  popped: () => {
+    const s = w().current();
+    if (s) set(moveTo(snapshot(), s.index));
+    return s;
+  },
+  rename: (sessionId: string, name: string) =>
+    set(renameIn(snapshot(), sessionId, name)),
+  back: () => {
+    w().flush();
+    window.history.back();
+  },
+  forward: () => {
+    w().flush();
+    window.history.forward();
+  },
+  /** The menu's pick: any entry, by index. */
+  goTo: (index: number) => {
+    w().flush();
+    window.history.go(index - navHistory.current);
+  },
+  currentState: () => (noHistory ? null : navStateOf(window.history.state)),
+};

package/stores/shortcutsUi.ts

@@ -0,0 +1,20 @@
+import { proxy } from "valtio";
+
+// The shortcuts panel, and the first key of a sequence that is waiting for
+// its second (shown as a chip so the reader sees it was heard).
+export const shortcutsUi = proxy<{ open: boolean; pending: string | null }>({
+  open: false,
+  pending: null,
+});
+
+export const shortcutsUiActions = {
+  open: () => {
+    shortcutsUi.open = true;
+  },
+  setOpen: (open: boolean) => {
+    shortcutsUi.open = open;
+  },
+  setPending: (key: string | null) => {
+    shortcutsUi.pending = key;
+  },
+};