@saadnvd1/agent-os 0.3.768 → 0.3.775

package/lib/away/deploy.ts

@@ -8,6 +8,7 @@
  */
 
 import fs from "fs";
+import path from "path";
 import type { ProjectConfig } from "../project-config";
 import { gitFetch, isAncestor } from "../git-exec";
 import { expandHome } from "../tasks/session";
@@ -19,14 +20,22 @@ export type DeployConfig = NonNullable<ProjectConfig["deploy"]>;
 export type DeployVerdict =
   | { state: "ok"; detail: string }
   | { state: "failed"; detail: string }
-  | { state: "pending" }
+  | { state: "pending"; detail?: string }
   | { state: "unchecked"; detail: string };
 
 export const DEPLOY_WITHIN_MIN = 30;
 // After the deploy lands, the server gets this long to answer healthy.
 export const HEALTH_GRACE_MS = 3 * 60 * 1000;
 
+// scripts/autodeploy holds a new head AGENTOS_MIN_GAP seconds after the last
+// restart (`restarted`, next to `deployed`), so a merge isn't late until the
+// gap is over plus this margin.
+export const GAP_MARGIN_MS = 10 * 60 * 1000;
+const DEFAULT_GAP_S = 3600;
+
 export interface DeployDeps {
+  // When the deploy last restarted the server, in ms; null when unknown.
+  restartedAt: (file: string) => number | null;
   // The commit a state file names, or null when there's no such file.
   readSha: (file: string) => { sha: string; at: number } | null;
   // Whether `sha` is in the history of `tip` (fetching it if need be);
@@ -89,7 +98,22 @@ async function health(
   }
 }
 
+function restartedAt(file: string): number | null {
+  try {
+    const s = Number(fs.readFileSync(expandHome(file), "utf-8").trim());
+    return Number.isFinite(s) && s > 0 ? s * 1000 : null;
+  } catch {
+    return null;
+  }
+}
+
+const gapMs = () => {
+  const s = Number(process.env.AGENTOS_MIN_GAP ?? DEFAULT_GAP_S);
+  return (Number.isFinite(s) && s >= 0 ? s : DEFAULT_GAP_S) * 1000;
+};
+
 export const DEFAULT_DEPS: DeployDeps = {
+  restartedAt,
   readSha,
   contains,
   health,
@@ -159,8 +183,21 @@ async function judge(
       state: "failed",
       detail: `the deploy of ${failed.sha.slice(0, 7)} (which has ${short}) failed; see the deploy's log`,
     };
+  // The state files sit together; `restarted` is beside `deployed`.
+  const restarted = deps.restartedAt(
+    path.join(path.dirname(config.deployed), "restarted")
+  );
+  const gapEnd = restarted === null ? 0 : restarted + gapMs();
+  if (gapEnd > input.now)
+    return {
+      state: "pending",
+      detail: `deploy waiting: restart gap, ~${Math.ceil((gapEnd - input.now) / 60000)} min left`,
+    };
   const within = (config.within_minutes ?? DEPLOY_WITHIN_MIN) * 60 * 1000;
-  if (input.now - input.mergedAt >= within)
+  if (
+    input.now - input.mergedAt >= within &&
+    input.now >= gapEnd + GAP_MARGIN_MS
+  )
     return {
       state: "failed",
       detail: `${short} not deployed ${Math.round(within / 60000)} minutes after the merge`,

package/lib/palette/registry.ts

@@ -3,6 +3,36 @@
  * take them back the same way, so the palette itself knows no feature.
  */
 
+export type PaletteTab =
+  "all" | "sessions" | "commands" | "settings" | "conversations";
+
+export const PALETTE_TABS: { id: PaletteTab; label: string }[] = [
+  { id: "all", label: "All" },
+  { id: "sessions", label: "Sessions" },
+  { id: "commands", label: "Commands" },
+  { id: "settings", label: "Settings" },
+  { id: "conversations", label: "Conversations" },
+];
+
+// Which tab each heading's commands are found under; a heading not listed is
+// a command. A command can name its own tab instead.
+const GROUP_TAB: Record<string, PaletteTab> = {
+  Sessions: "sessions",
+  Settings: "settings",
+  Conversations: "conversations",
+};
+
+// Headings whose commands act on the focused session.
+const SESSION_GROUPS = new Set(["Chat", "Task"]);
+
+export function tabOf(c: PaletteCommand): PaletteTab {
+  return c.tab ?? GROUP_TAB[c.group] ?? "commands";
+}
+
+export function actsOnFocusedSession(c: PaletteCommand): boolean {
+  return SESSION_GROUPS.has(c.group);
+}
+
 export interface PaletteCommand {
   id: string;
   title: string;
@@ -14,6 +44,10 @@ export interface PaletteCommand {
   hint?: string;
   // A line under the title (what a conversation hit said).
   detail?: string;
+  // Overrides the tab its group maps to.
+  tab?: PaletteTab;
+  // A session that is working or waiting on the user.
+  status?: "running" | "waiting";
   // Running it leaves the palette open (it changes the palette itself).
   keepOpen?: boolean;
   icon?: unknown;
@@ -84,25 +118,45 @@ export function fuzzyScore(query: string, text: string): number | null {
   return score;
 }
 
-// The commands a query finds, best first; all of them, in order, for none.
-export function matchCommands(
+export interface Scored {
+  c: PaletteCommand;
+  score: number;
+}
+
+// The commands a query finds, best first, with their scores. `boost` (0 to 1,
+// e.g. how much it's used) scales a match up by at most half: it can break a
+// close call, never rescue a non-match or outrank a far better match. With no
+// query the boost alone orders them, registry order breaking ties.
+export function scoreCommands(
   commands: PaletteCommand[],
-  query: string
-): PaletteCommand[] {
-  if (!query.trim()) return commands;
+  query: string,
+  boost: (c: PaletteCommand) => number = () => 0
+): Scored[] {
+  const empty = !query.trim();
   return commands
     .map((c, i) => {
-      const scores = [c.title, ...(c.keywords ?? []), c.group].map(
-        (text, j) => {
-          const s = fuzzyScore(query, text);
-          // A title match counts most.
-          return s === null ? null : j === 0 ? s * 1.5 : s;
-        }
-      );
-      const best = Math.max(...scores.map((s) => s ?? -Infinity));
-      return { c, i, best };
+      let base = 0;
+      if (!empty) {
+        const scores = [c.title, ...(c.keywords ?? []), c.group].map(
+          (text, j) => {
+            const s = fuzzyScore(query, text);
+            // A title match counts most.
+            return s === null ? null : j === 0 ? s * 1.5 : s;
+          }
+        );
+        base = Math.max(...scores.map((s) => s ?? -Infinity));
+      }
+      const b = boost(c);
+      return { c, i, base, score: empty ? b : base + Math.abs(base) * 0.5 * b };
     })
-    .filter((m) => m.best > -Infinity)
-    .sort((a, b) => b.best - a.best || a.i - b.i)
-    .map((m) => m.c);
+    .filter((m) => m.base > -Infinity)
+    .sort((a, b) => b.score - a.score || a.i - b.i)
+    .map(({ c, score }) => ({ c, score }));
+}
+
+export function matchCommands(
+  commands: PaletteCommand[],
+  query: string
+): PaletteCommand[] {
+  return scoreCommands(commands, query).map((m) => m.c);
 }

package/lib/palette/sections.ts

@@ -0,0 +1,143 @@
+import {
+  PALETTE_TABS,
+  actsOnFocusedSession,
+  scoreCommands,
+  tabOf,
+  type PaletteCommand,
+  type PaletteTab,
+} from "./registry";
+import { recentIds, usageBoost, type Usage } from "./usage";
+
+export interface Section {
+  name: string;
+  items: PaletteCommand[];
+  // The tab that lists the whole section, when this is only part of it.
+  more?: { tab: PaletteTab; count: number };
+}
+
+export const PER_TAB = 5;
+export const RECENT = 5;
+const NEEDS_YOU = 5;
+const SUGGESTED = 6;
+
+const label = (tab: PaletteTab) =>
+  PALETTE_TABS.find((t) => t.id === tab)?.label ?? tab;
+
+export const boostFor = (usage: Usage, now: number) => (c: PaletteCommand) =>
+  usageBoost(usage[c.id], now);
+
+// What a query finds in All: each tab's best few under its heading, the
+// strongest group first, with how many more its tab holds. Conversations are
+// the caller's, to put last.
+export function allSections(
+  commands: PaletteCommand[],
+  query: string,
+  usage: Usage,
+  now: number
+): Section[] {
+  const scored = scoreCommands(commands, query, boostFor(usage, now));
+  const byTab = new Map<PaletteTab, typeof scored>();
+  for (const m of scored) {
+    const tab = tabOf(m.c);
+    if (tab === "conversations") continue;
+    byTab.set(tab, [...(byTab.get(tab) ?? []), m]);
+  }
+  return [...byTab.entries()]
+    .sort((a, b) => b[1][0].score - a[1][0].score)
+    .map(([tab, ms]) => ({
+      name: label(tab),
+      items: ms.slice(0, PER_TAB).map((m) => m.c),
+      ...(ms.length > PER_TAB
+        ? { more: { tab, count: ms.length } }
+        : undefined),
+    }));
+}
+
+// One tab's commands, for a query or (ordered by use) without one.
+export function tabItems(
+  commands: PaletteCommand[],
+  tab: PaletteTab,
+  query: string,
+  usage: Usage,
+  now: number
+): PaletteCommand[] {
+  return scoreCommands(
+    commands.filter((c) => tabOf(c) === tab),
+    query,
+    boostFor(usage, now)
+  ).map((m) => m.c);
+}
+
+// The short list All opens on: the last things run, sessions that need the
+// user or are working, and what the focused session can do.
+export function emptySections(
+  commands: PaletteCommand[],
+  usage: Usage
+): Section[] {
+  const seen = new Set<string>();
+  const take = (items: PaletteCommand[], limit: number) => {
+    const out: PaletteCommand[] = [];
+    for (const c of items) {
+      if (out.length >= limit) break;
+      if (seen.has(c.id)) continue;
+      seen.add(c.id);
+      out.push(c);
+    }
+    return out;
+  };
+  // A session that needs you is listed there, not also under Recent.
+  const rank = (c: PaletteCommand) => (c.status === "waiting" ? 0 : 1);
+  const busy = take(
+    commands.filter((c) => c.status).sort((a, b) => rank(a) - rank(b)),
+    NEEDS_YOU
+  );
+  const here = take(commands.filter(actsOnFocusedSession), 5);
+  const byId = new Map(commands.map((c) => [c.id, c]));
+  const recent = take(
+    recentIds(usage, commands.length)
+      .map((id) => byId.get(id))
+      .filter((c): c is PaletteCommand => !!c),
+    RECENT
+  );
+  const sections: Section[] = [
+    { 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)
+    sections.push({
+      name: "Suggested",
+      items: take(
+        commands.filter((c) => tabOf(c) === "commands"),
+        SUGGESTED
+      ),
+    });
+  return sections.filter((s) => s.items.length);
+}
+
+// Each cut-short section ends with a row that opens its whole tab.
+export function withSeeAll(
+  sections: Section[],
+  open: (tab: PaletteTab) => void,
+  icon?: unknown
+): Section[] {
+  return sections.map((s) => {
+    const more = s.more;
+    if (!more) return s;
+    return {
+      ...s,
+      items: [
+        ...s.items,
+        {
+          id: `see-all:${more.tab}`,
+          title: `See all ${more.count} →`,
+          group: s.name,
+          icon,
+          keepOpen: true,
+          run: () => open(more.tab),
+        },
+      ],
+    };
+  });
+}

package/lib/palette/tabs.ts

@@ -0,0 +1,21 @@
+import { PALETTE_TABS, type PaletteTab } from "./registry";
+
+const PREFIXES: Record<string, PaletteTab> = {
+  ">": "commands",
+  "@": "sessions",
+};
+
+// A leading `>` or `@` on a fresh query picks a tab; null when there's none.
+export function parsePrefix(
+  text: string
+): { tab: PaletteTab; text: string } | null {
+  const tab = PREFIXES[text[0]];
+  return tab ? { tab, text: text.slice(1).trimStart() } : null;
+}
+
+// The next tab (or the one before), wrapping round.
+export function cycleTab(tab: PaletteTab, by: 1 | -1): PaletteTab {
+  const n = PALETTE_TABS.length;
+  const i = PALETTE_TABS.findIndex((t) => t.id === tab);
+  return PALETTE_TABS[(i + by + n) % n].id;
+}

package/lib/palette/usage.ts

@@ -0,0 +1,81 @@
+export interface UsageEntry {
+  count: number;
+  last: number;
+}
+export type Usage = Record<string, UsageEntry>;
+
+export const USAGE_KEY = "agentOS-palette-usage";
+export const MAX_USAGE = 200;
+const DAY = 86_400_000;
+const HALF_LIFE_DAYS = 14;
+// Uses at which the count part of the boost tops out.
+const SATURATES_AT = 20;
+
+// How strongly past use favours an item, 0 to 1: more uses count more (with
+// diminishing returns) and the whole fades by half every two weeks.
+export function usageBoost(entry: UsageEntry | undefined, now: number): number {
+  if (!entry) return 0;
+  const age = Math.max(0, now - entry.last) / DAY;
+  const weight = Math.min(
+    1,
+    Math.log2(1 + entry.count) / Math.log2(1 + SATURATES_AT)
+  );
+  return weight * Math.pow(0.5, age / HALF_LIFE_DAYS);
+}
+
+// The usage with one more run of `id`, keeping the MAX_USAGE items that
+// matter most right now.
+export function recordUse(usage: Usage, id: string, now: number): Usage {
+  const next: Usage = {
+    ...usage,
+    [id]: { count: (usage[id]?.count ?? 0) + 1, last: now },
+  };
+  const ids = Object.keys(next);
+  if (ids.length <= MAX_USAGE) return next;
+  const keep = ids
+    .sort((a, b) => usageBoost(next[b], now) - usageBoost(next[a], now))
+    .slice(0, MAX_USAGE);
+  return Object.fromEntries(keep.map((k) => [k, next[k]]));
+}
+
+// The ids last run most recently, newest first.
+export function recentIds(usage: Usage, limit: number): string[] {
+  return Object.entries(usage)
+    .sort((a, b) => b[1].last - a[1].last)
+    .slice(0, limit)
+    .map(([id]) => id);
+}
+
+function valid(e: unknown): e is UsageEntry {
+  const u = e as UsageEntry | null;
+  return (
+    !!u && Number.isFinite(u.count) && Number.isFinite(u.last) && u.count > 0
+  );
+}
+
+export function loadUsage(): Usage {
+  try {
+    const raw: unknown = JSON.parse(localStorage.getItem(USAGE_KEY) ?? "{}");
+    if (!raw || typeof raw !== "object") return {};
+    const usage: Usage = {};
+    for (const [id, e] of Object.entries(raw)) if (valid(e)) usage[id] = e;
+    return usage;
+  } catch {
+    return {};
+  }
+}
+
+export function saveUsage(usage: Usage): void {
+  try {
+    localStorage.setItem(USAGE_KEY, JSON.stringify(usage));
+  } catch {
+    // Private mode or a full disk: ranking just forgets.
+  }
+}
+
+// Records a run in storage and returns the new usage.
+export function noteUse(id: string, now = Date.now()): Usage {
+  const next = recordUse(loadUsage(), id, now);
+  saveUsage(next);
+  return next;
+}

package/lib/reports/evidence/build.ts

@@ -6,6 +6,7 @@ import type { TaskState } from "../../tasks/state";
 import type { DigestSignals } from "../../analyst/types";
 import { latestChecks } from "../../analyst/signals";
 import type { EvidenceRef } from "../types";
+import { sessionPath } from "../../session-url";
 
 const EXCERPT = 1500;
 const cap = (s: string, n = EXCERPT) =>
@@ -82,7 +83,7 @@ export function testEvidence(
       status: c.passed ? "pass" : "fail",
       at,
       sha: head ?? undefined,
-      href: `/?session=${sessionId}`,
+      href: sessionPath({ id: sessionId }),
     }));
 }
 
@@ -101,7 +102,7 @@ export function diffEvidence(
       label: `${m[3]} (+${m[1] === "-" ? 0 : m[1]} −${m[2] === "-" ? 0 : m[2]})`,
       status: "info",
       at,
-      href: `/?session=${sessionId}`,
+      href: sessionPath({ id: sessionId }),
     });
     if (out.length >= 40) break;
   }
@@ -174,7 +175,7 @@ export function logEvidence(log: {
     status: "pass",
     at: log.createdAt,
     excerpt: log.mergeCommit ? `Merge commit ${log.mergeCommit}` : undefined,
-    href: `/?session=${log.sessionId}`,
+    href: sessionPath({ id: log.sessionId }),
   };
 }
 

package/lib/security/demo.ts

@@ -64,6 +64,7 @@ export const STATIC_SIBLINGS = [
   "browse",
   "check",
   "clone",
+  "compare",
   "connect",
   "detect",
   "done-idle",
@@ -84,6 +85,7 @@ export const STATIC_SIBLINGS = [
   "pdf",
   "preview",
   "queue",
+  "resolve",
   "status",
 ];
 // No leading "-": an id that reaches a command line can't read as an option.
@@ -101,6 +103,7 @@ const READS = [
   "sessions/[id]/pr",
   "sessions/[id]/artifacts",
   "sessions/[id]/artifacts/[id]",
+  "sessions/[id]/artifacts/[id]/compare",
   "sessions/[id]/setup",
   "sessions/[id]/preview",
   "projects",

package/lib/session-audit/render.ts

@@ -6,6 +6,7 @@
 
 import type { PatternStat, Summary } from "./aggregate";
 import type { AuditFindings } from "./store";
+import { sessionPath } from "../session-url";
 
 export const fmt = (n: number) =>
   n >= 1e9
@@ -245,7 +246,7 @@ export function renderSummary(
         "biggest output (est.)",
       ],
       s.sessions.slice(0, 30).map((x) => [
-        `[${x.id.slice(0, 8)}](/?session=${x.id})`,
+        `[${x.id.slice(0, 8)}](${sessionPath(x)})`,
         x.kind,
         x.name.slice(0, 40),
         x.turns,

package/lib/session-logs/gather.ts

@@ -18,7 +18,7 @@ import { getWorkspace } from "../workspaces";
 import { amendmentsOf } from "../orchestrator/amendments";
 import { PLAN_FILE } from "../models/plan-step";
 import { estimateCost, rowModel } from "../usage/cost";
-import { sessionLink } from "../session-url";
+import { sessionPath } from "../session-url";
 import type { LogData, LogEvent, LogUsageRow } from "./build";
 
 const expandHome = (p: string) => p.replace(/^~/, os.homedir());
@@ -296,6 +296,6 @@ export function gatherLogData(s: Session, opts: GatherOpts = {}): LogData {
     timeline,
     usage: usageRows(s.id),
     outcome: finalMessage(s.id),
-    sessionPath: sessionLink("", s.id),
+    sessionPath: sessionPath(s),
   };
 }

package/lib/session-slug.ts

@@ -0,0 +1,29 @@
+// The readable part of a session's address (`/s/<slug>-<id8>`). Cosmetic:
+// only the short id resolves, so the slug is rebuilt from the current name
+// and a rename never breaks a link. No imports: the browser uses it too.
+
+export const SLUG_MAX = 48;
+export const SHORT_ID_LEN = 8;
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export const isUuid = (id: string): boolean => UUID.test(id);
+
+/** Lowercase ASCII words joined by `-`; `session` when nothing is left. */
+export function sessionSlug(name: string): string {
+  const words = (name ?? "")
+    .normalize("NFKD")
+    .replace(/\p{M}/gu, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  if (!words) return "session";
+  if (words.length <= SLUG_MAX) return words;
+  const cut = words.slice(0, SLUG_MAX);
+  const atWord = cut.lastIndexOf("-");
+  return (atWord > 0 ? cut.slice(0, atWord) : cut).replace(/-+$/, "");
+}
+
+/** The first group of a uuid, lowercase. */
+export const shortId = (id: string): string =>
+  id.slice(0, SHORT_ID_LEN).toLowerCase();