@saadnvd1/agent-os 0.3.799 → 0.3.807

package/hooks/useSessionUrl.ts

@@ -10,6 +10,8 @@ import {
   type SessionRef,
 } from "@/lib/session-url";
 import { usePanes } from "@/contexts/PaneContext";
+import { navHistoryActions } from "@/stores/navHistory";
+import { chatPositionsActions } from "@/stores/chatPositions";
 
 interface Options {
   sessions: Session[];
@@ -59,6 +61,9 @@ export function useSessionUrl({
     };
   });
 
+  const nameOf = (id: string | null) =>
+    (id && latest.current.sessions.find((s) => s.id === id)?.name) || "Chat";
+
   // Made on first use, outside render.
   const syncRef = useRef<SessionUrlSync | null>(null);
   const getSync = useCallback(() => {
@@ -79,8 +84,13 @@ export function useSessionUrl({
     syncRef.current = new SessionUrlSync(
       {
         href: () => window.location.href,
-        push: (href) => window.history.pushState(null, "", href),
-        replace: (href) => window.history.replaceState(null, "", href),
+        push: (href, id) => navHistoryActions.push(href, id, nameOf(id)),
+        replace: (href, id) => navHistoryActions.replace(href, id, nameOf(id)),
+        settle: (id) => {
+          const entry = navHistoryActions.currentState();
+          if (entry?.sessionId !== id)
+            navHistoryActions.replace(window.location.href, id, nameOf(id));
+        },
       },
       {
         find: (ref) => pickSession(ref, latest.current.sessions)?.id ?? null,
@@ -119,8 +129,10 @@ export function useSessionUrl({
   // A rename (by hand, or the title a first turn gives it) moves the slug.
   const focusedName = sessions.find((s) => s.id === focusedId)?.name ?? null;
   useEffect(() => {
-    if (focusedName !== null) getSync().renamed();
-  }, [getSync, focusedName]);
+    if (focusedName === null) return;
+    getSync().renamed();
+    if (focusedId) navHistoryActions.rename(focusedId, focusedName);
+  }, [getSync, focusedName, focusedId]);
 
   const ready = hydrated && loaded;
   useEffect(() => {
@@ -128,7 +140,13 @@ export function useSessionUrl({
   }, [getSync, ready]);
 
   useEffect(() => {
-    const onPop = () => void getSync().popstate();
+    const onPop = () => {
+      // Back or forward onto an entry: it remembers where the reader was.
+      const entry = navHistoryActions.popped();
+      if (entry?.sessionId && entry.pos)
+        chatPositionsActions.setTarget(entry.sessionId, entry.pos);
+      void getSync().popstate();
+    };
     window.addEventListener("popstate", onPop);
     return () => window.removeEventListener("popstate", onPop);
   }, [getSync]);

package/lib/bus/index.ts

@@ -39,6 +39,7 @@ import {
 } from "./waits/store";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
 import { groupNames } from "../session-groups/store";
+import { sessionWorkspace } from "../schedules/store";
 
 export * from "./format";
 export {
@@ -103,6 +104,7 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
   const sessions = liveSessions();
   const named = candidates(sessions);
   const caller = sessionById(callerId);
+  const callerWorkspace = caller ? sessionWorkspace(caller) : null;
   const orchestrator = heldOrchestrator(caller);
   const badges = waitBadges();
   const groups = groupNames();
@@ -127,9 +129,9 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
           groups.has(s.session_group_id) && {
             group: groups.get(s.session_group_id),
           }),
-        ...(caller?.workspace_id &&
+        ...(callerWorkspace &&
           s.role === "orchestrator" &&
-          s.workspace_id === caller.workspace_id && { yours: true }),
+          s.workspace_id === callerWorkspace && { yours: true }),
       };
     })
   );

package/lib/bus/role-alias.ts

@@ -6,6 +6,7 @@
  */
 
 import type { Session } from "../db";
+import { sessionWorkspace } from "../models/resolve";
 
 type RoleSession = Pick<
   Session,
@@ -56,9 +57,10 @@ export function resolveRoleAlias<T extends RoleSession>(
         error: `"@${role}" matches ${found.length} sessions: ${found.map(label).join(", ")}. Use the name or the id`,
       };
   }
-  if (role === "supervisor" && caller?.workspace_id) {
+  const workspace = caller ? sessionWorkspace(caller) : null;
+  if (role === "supervisor" && workspace) {
     const orchestrator = others.find(
-      (s) => s.role === "orchestrator" && s.workspace_id === caller.workspace_id
+      (s) => s.role === "orchestrator" && s.workspace_id === workspace
     );
     if (orchestrator) return { ok: true, session: orchestrator };
   }

package/lib/bus/targets.ts

@@ -73,7 +73,8 @@ function ownOrchestrator(
   callerId?: string | null
 ): Session | undefined {
   if (!/^(my )?orchestrator$/i.test(ref.trim())) return undefined;
-  const workspace = sessionById(callerId)?.workspace_id;
+  const caller = sessionById(callerId);
+  const workspace = caller ? sessionWorkspace(caller) : null;
   if (!workspace) return undefined;
   return sessions.find(
     (s) => s.role === "orchestrator" && s.workspace_id === workspace

package/lib/chat/escape.ts

@@ -37,13 +37,16 @@ export function escapeInterrupts(
 }
 
 // What Esc does in a chat: set the composer's suggestion aside, stop the
-// turn, or nothing (something on top takes it, or it isn't a bare Esc).
+// turn, or, with nothing else to do, leave the composer so the bare-key
+// shortcuts (g i) work; nothing when something on top takes it or it isn't
+// a bare Esc.
 export function escapeAction(
   e: EscapeKey,
   running: boolean,
   overlayOpen: boolean,
-  ghostShown: boolean
-): "dismiss" | "interrupt" | null {
+  ghostShown: boolean,
+  inComposer = false
+): "dismiss" | "interrupt" | "blur" | null {
   const bare =
     e.key === "Escape" &&
     !e.repeat &&
@@ -51,5 +54,6 @@ export function escapeAction(
     !(e.metaKey || e.ctrlKey || e.altKey || e.shiftKey);
   if (!bare || overlayOpen) return null;
   if (ghostShown) return "dismiss";
-  return running ? "interrupt" : null;
+  if (running) return "interrupt";
+  return inComposer ? "blur" : null;
 }

package/lib/chat-views/body.ts

@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { readCapped } from "../security/read-capped";
+import type { ChatViewInput } from "./types";
+
+const MAX_BODY_BYTES = 2048;
+
+const position = z.object({
+  itemId: z.string().min(1).max(200).nullable(),
+  offsetPx: z.number().int().min(-100000).max(100000),
+  atEnd: z.boolean(),
+  // False keeps `viewed_at` as it was: the reader left with newer items below
+  // them that they haven't seen.
+  advance: z.boolean().optional(),
+});
+const body = z.union([position, z.object({ viewed: z.literal(true) })]);
+
+/** The PUT body: a position to save, `null` for "opened just now", or the
+ * response that refuses it. */
+export async function readViewBody(
+  request: Request
+): Promise<{ input: ChatViewInput | null } | NextResponse> {
+  const raw = await readCapped(request, MAX_BODY_BYTES);
+  if (raw === null)
+    return NextResponse.json({ error: "Too large" }, { status: 413 });
+  let json: unknown = null;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    // Not JSON: refused below.
+  }
+  const parsed = body.safeParse(json);
+  if (!parsed.success)
+    return NextResponse.json({ error: "Bad request" }, { status: 400 });
+  return {
+    input:
+      "viewed" in parsed.data
+        ? null
+        : { ...parsed.data, advance: parsed.data.advance !== false },
+  };
+}

package/lib/chat-views/store.ts

@@ -0,0 +1,67 @@
+import { db } from "../db";
+import { MAX_VIEWS, type ChatView, type ChatViewInput } from "./types";
+
+interface Row {
+  session_id: string;
+  item_id: string | null;
+  offset_px: number;
+  at_end: number;
+  viewed_at: number;
+}
+
+const toView = (r: Row): ChatView => ({
+  sessionId: r.session_id,
+  itemId: r.item_id,
+  offsetPx: r.offset_px,
+  atEnd: r.at_end === 1,
+  viewedAt: r.viewed_at,
+});
+
+/** The most recently viewed chats first. */
+export function listChatViews(limit = MAX_VIEWS): ChatView[] {
+  return (
+    db
+      .prepare(`SELECT * FROM chat_views ORDER BY viewed_at DESC LIMIT ?`)
+      .all(limit) as Row[]
+  ).map(toView);
+}
+
+/** Saves where the reader is. Without a position it only marks the chat as
+ * viewed now (opening it), keeping what was saved. */
+export function saveChatView(
+  sessionId: string,
+  input: ChatViewInput | null,
+  now = Date.now()
+): ChatView {
+  if (input) {
+    db.prepare(
+      `INSERT INTO chat_views (session_id, item_id, offset_px, at_end, viewed_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(session_id) DO UPDATE SET item_id = excluded.item_id,
+         offset_px = excluded.offset_px, at_end = excluded.at_end,
+         viewed_at = CASE WHEN ? = 1 THEN excluded.viewed_at
+                          ELSE chat_views.viewed_at END`
+    ).run(
+      sessionId,
+      input.itemId,
+      input.offsetPx,
+      input.atEnd ? 1 : 0,
+      now,
+      input.advance ? 1 : 0
+    );
+  } else {
+    db.prepare(
+      `INSERT INTO chat_views (session_id, viewed_at) VALUES (?, ?)
+       ON CONFLICT(session_id) DO UPDATE SET viewed_at = excluded.viewed_at`
+    ).run(sessionId, now);
+  }
+  return toView(
+    db
+      .prepare(`SELECT * FROM chat_views WHERE session_id = ?`)
+      .get(sessionId) as Row
+  );
+}
+
+export function deleteChatView(sessionId: string): void {
+  db.prepare(`DELETE FROM chat_views WHERE session_id = ?`).run(sessionId);
+}

package/lib/chat-views/types.ts

@@ -0,0 +1,20 @@
+/** Where a chat was last being read: the first row in view, how far down it
+ * sat, and whether the reader was following the latest output. */
+export interface ChatView {
+  sessionId: string;
+  itemId: string | null;
+  offsetPx: number;
+  atEnd: boolean;
+  /** Epoch ms of the last time the reader had this chat open. */
+  viewedAt: number;
+}
+
+export interface ChatViewInput {
+  itemId: string | null;
+  offsetPx: number;
+  atEnd: boolean;
+  /** Whether this counts as having seen everything up to now. */
+  advance: boolean;
+}
+
+export const MAX_VIEWS = 500;

package/lib/db/migrations/20261031T1500_chat_views.ts

@@ -0,0 +1,30 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261031T1500_chat_views",
+  up: (db) => {
+    // Where each chat was last being read, for the person, on any device. No
+    // FK to sessions, like chat_bookmarks; a trigger drops a deleted chat's row.
+    // viewed_at is epoch milliseconds, the unit chat items carry.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS chat_views (
+        session_id TEXT PRIMARY KEY,
+        item_id TEXT,
+        offset_px INTEGER NOT NULL DEFAULT 0,
+        at_end INTEGER NOT NULL DEFAULT 1,
+        viewed_at INTEGER NOT NULL
+      )
+    `);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_chat_views_viewed
+         ON chat_views(viewed_at DESC)`
+    );
+    db.exec(`
+      CREATE TRIGGER IF NOT EXISTS chat_views_session_deleted
+      AFTER DELETE ON sessions
+      BEGIN
+        DELETE FROM chat_views WHERE session_id = OLD.id;
+      END
+    `);
+  },
+} satisfies Migration;

package/lib/keybindings/focus.ts

@@ -27,3 +27,20 @@ export function fieldOwnsKey(target: EventTarget | null): boolean {
   if (el.isContentEditable) return (el.textContent ?? "").trim().length > 0;
   return false;
 }
+
+// Whether a bare letter is free for the app: nothing is being typed into, no
+// terminal or dialog holds the key, and no menu is open.
+export function isFreeTarget(target: EventTarget | null): boolean {
+  const el = target as HTMLElement | null;
+  if (!el || typeof el.closest !== "function") return true;
+  if (el.closest(".xterm")) return false;
+  if (el.closest('[role="dialog"],[role="menu"],[role="listbox"]'))
+    return false;
+  const tag = el.tagName;
+  if (tag === "TEXTAREA" || tag === "SELECT") return false;
+  if (tag === "INPUT") return NON_TEXT.has((el as HTMLInputElement).type);
+  return !(
+    el.isContentEditable ||
+    el.closest('[contenteditable]:not([contenteditable="false"])')
+  );
+}

package/lib/keybindings/keymap.ts

@@ -0,0 +1,120 @@
+// Every shortcut the app has, in one table: the keys that act on it, the
+// shortcuts panel and the palette hints all read this. A `keys` string with
+// a space is a sequence (press g, then i); without one it is a chord.
+
+export type KeyGroup = "Go to" | "Chats" | "General" | "Browser";
+
+export interface KeyEntry {
+  id: string;
+  keys: string;
+  label: string;
+  group: KeyGroup;
+  // A bare key or sequence: only while nothing is being typed, and off with
+  // the single-key switch.
+  single?: boolean;
+  // The browser acts on it, not the app: listed so it can be found.
+  browser?: boolean;
+}
+
+export const KEYMAP: KeyEntry[] = [
+  { id: "go.inbox", keys: "g i", label: "Inbox", group: "Go to", single: true },
+  {
+    id: "go.bookmarks",
+    keys: "g b",
+    label: "Bookmarks",
+    group: "Go to",
+    single: true,
+  },
+  {
+    id: "go.messages",
+    keys: "g m",
+    label: "Messages",
+    group: "Go to",
+    single: true,
+  },
+  {
+    id: "go.settings",
+    keys: "g s",
+    label: "Settings",
+    group: "Go to",
+    single: true,
+  },
+  {
+    id: "chat.previous",
+    keys: "g p",
+    label: "Previous chat (flip back and forth)",
+    group: "Chats",
+    single: true,
+  },
+  {
+    id: "chat.open",
+    keys: "o c",
+    label: "Open a chat",
+    group: "Chats",
+    single: true,
+  },
+  {
+    id: "chat.new",
+    keys: "c",
+    label: "New chat",
+    group: "Chats",
+    single: true,
+  },
+  { id: "switcher.open", keys: "mod+p", label: "Switch chat", group: "Chats" },
+  {
+    id: "session.previous",
+    keys: "mod+up",
+    label: "Chat above in the sidebar",
+    group: "Chats",
+  },
+  {
+    id: "session.next",
+    keys: "mod+down",
+    label: "Chat below in the sidebar",
+    group: "Chats",
+  },
+  {
+    id: "palette.open",
+    keys: "mod+k",
+    label: "Command palette",
+    group: "General",
+  },
+  {
+    id: "help.open",
+    keys: "?",
+    label: "Keyboard shortcuts",
+    group: "General",
+    single: true,
+  },
+  {
+    id: "history.back",
+    keys: "mod+[",
+    label: "Back to the chat you came from",
+    group: "Browser",
+    browser: true,
+  },
+  {
+    id: "history.forward",
+    keys: "mod+]",
+    label: "Forward",
+    group: "Browser",
+    browser: true,
+  },
+];
+
+export const keysOf = (id: string): string => {
+  const e = KEYMAP.find((k) => k.id === id);
+  if (!e) throw new Error(`No shortcut "${id}"`);
+  return e.keys;
+};
+
+export const isSequence = (keys: string) => keys.includes(" ");
+
+/** The table's entries a search finds, in table order; no search finds all. */
+export function searchKeymap(query: string): KeyEntry[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return KEYMAP;
+  return KEYMAP.filter((k) =>
+    `${k.label} ${k.keys} ${k.group}`.toLowerCase().includes(q)
+  );
+}

package/lib/keybindings/sequence.ts

@@ -0,0 +1,64 @@
+// Two-key sequences (g then i). The matcher is fed every plain key press; it
+// says whether the key started a sequence, finished one, or is nobody's.
+
+export const SEQUENCE_MS = 1500;
+
+/**
+ * The key a bare shortcut sees, or null. The hints print letters in
+ * capitals, so Shift+G counts as g; other shifted keys are nobody's but "?".
+ */
+export function plainKey(key: string, shift: boolean): string | null {
+  if (key === "?" || /^[a-z]$/i.test(key)) return key.toLowerCase();
+  return shift ? null : key;
+}
+
+export type SequenceStep =
+  | { kind: "none" }
+  | { kind: "pending"; first: string }
+  | { kind: "match"; id: string };
+
+export class SequenceMatcher {
+  private first: string | null = null;
+  private at = 0;
+  private starts: Set<string>;
+  private pairs: Map<string, string>;
+
+  /** `sequences` maps "g i" to the id it runs. */
+  constructor(
+    sequences: Record<string, string>,
+    private now: () => number = Date.now
+  ) {
+    this.pairs = new Map(
+      Object.entries(sequences).map(([k, id]) => [k.toLowerCase(), id])
+    );
+    this.starts = new Set([...this.pairs.keys()].map((k) => k.split(" ")[0]));
+  }
+
+  /** A key was pressed with no modifier but maybe shift. */
+  feed(key: string): SequenceStep {
+    const k = key.toLowerCase();
+    if (this.first !== null && this.now() - this.at <= SEQUENCE_MS) {
+      const id = this.pairs.get(`${this.first} ${k}`);
+      this.first = null;
+      if (id) return { kind: "match", id };
+    }
+    this.first = null;
+    if (this.starts.has(k)) {
+      this.first = k;
+      this.at = this.now();
+      return { kind: "pending", first: k };
+    }
+    return { kind: "none" };
+  }
+
+  /** Whether the first key of a sequence is waiting for its second. */
+  pending(): string | null {
+    return this.first !== null && this.now() - this.at <= SEQUENCE_MS
+      ? this.first
+      : null;
+  }
+
+  reset(): void {
+    this.first = null;
+  }
+}

package/lib/live/service.ts

@@ -259,7 +259,7 @@ export async function changeCode(
   id: string,
   next: { generate: true } | { code: string } | null
 ): Promise<void> {
-  const rt = runtimeFor(id);
+  runtimeFor(id);
   let code: string | null = null;
   if (next && "code" in next) {
     const why = codeRefusal(next.code);

package/lib/nav/history-mirror.ts

@@ -0,0 +1,59 @@
+/**
+ * What the page remembers of the history entries it made, for the menu behind
+ * the back button: the browser won't list its own history. Entries are keyed
+ * by the `index` also kept in each entry's state, so a reload or a back
+ * button still finds its place.
+ */
+export interface MirrorEntry {
+  index: number;
+  sessionId: string;
+  name: string;
+}
+
+export interface Mirror {
+  entries: MirrorEntry[];
+  current: number;
+}
+
+export const MAX_MIRROR = 100;
+
+export const emptyMirror = (): Mirror => ({ entries: [], current: -1 });
+
+/** Standing on an entry that is new (a push) or known (replace or reload):
+ * a push drops the forward entries, as the browser does. */
+export function visit(
+  m: Mirror,
+  entry: MirrorEntry,
+  how: "push" | "replace"
+): Mirror {
+  const kept =
+    how === "push"
+      ? m.entries.filter((e) => e.index < entry.index)
+      : m.entries.filter((e) => e.index !== entry.index);
+  const entries = [...kept, entry]
+    .sort((a, b) => a.index - b.index)
+    .slice(-MAX_MIRROR);
+  return { entries, current: entry.index };
+}
+
+/** Back or forward landed on the entry with this index. */
+export const moveTo = (m: Mirror, index: number): Mirror =>
+  m.entries.some((e) => e.index === index) ? { ...m, current: index } : m;
+
+export const earlier = (m: Mirror): MirrorEntry[] =>
+  m.entries.filter((e) => e.index < m.current).reverse();
+
+export const later = (m: Mirror): MirrorEntry[] =>
+  m.entries.filter((e) => e.index > m.current);
+
+/** A renamed chat reads under its new name in the menu. */
+export const renameIn = (
+  m: Mirror,
+  sessionId: string,
+  name: string
+): Mirror => ({
+  ...m,
+  entries: m.entries.map((e) =>
+    e.sessionId === sessionId ? { ...e, name } : e
+  ),
+});