@saadnvd1/agent-os 0.3.715 → 0.3.723

package/lib/session-artifacts/collect.ts

@@ -32,6 +32,7 @@ import {
   type ItemRow,
   type RunRow,
 } from "./derive";
+import { agentosSignature, fromAgentosDirs, fromKept } from "./agentos-files";
 import { keepFiles, readManifest, relInside, sessionKeptDir } from "./keep";
 
 export const MAX_FILES = 500;
@@ -160,6 +161,16 @@ async function build(session: Session): Promise<Entry[]> {
   }
 
   const manifest = worktree && !worktreeThere ? readManifest(session.id) : null;
+  if (worktree) {
+    const known = new Set(candidates.map((c) => c.key));
+    candidates.push(
+      ...(worktreeThere
+        ? fromAgentosDirs(worktree, known)
+        : manifest
+          ? fromKept(worktree, manifest.kept, sqliteMs(manifest.at), known)
+          : [])
+    );
+  }
   if (worktree) {
     const planFile = path.join(worktree, PLAN_FILE);
     const named = candidates.some((c) => c.key === `file:${planFile}`);
@@ -255,6 +266,9 @@ interface Cached {
 }
 const cache = new Map<string, Cached>();
 
+const isLocalWorktree = (s: Session) =>
+  !!s.worktree_path && (!s.host_id || s.host_id === "local");
+
 function signature(session: Session): string {
   const row = db
     .prepare(`SELECT max(seq) AS seq FROM chat_items WHERE session_id = ?`)
@@ -265,6 +279,9 @@ function signature(session: Session): string {
     session.pr_number,
     session.worktree_path,
     session.updated_at,
+    isLocalWorktree(session)
+      ? agentosSignature(expand(session.worktree_path!))
+      : "",
   ].join("|");
 }
 

package/lib/sessions/crew.ts

@@ -0,0 +1,72 @@
+/**
+ * A crew: the sessions started in roles that work together. Its id is the
+ * session that began it, so a crew needs no table of its own.
+ */
+
+import { db } from "../db";
+import type { AgentRole } from "../models/agent-roles";
+
+const crewOf = (id: string | null | undefined): string | null =>
+  id
+    ? ((
+        db.prepare(`SELECT crew_id FROM session_rows WHERE id = ?`).get(id) as
+          { crew_id: string | null } | undefined
+      )?.crew_id ?? null)
+    : null;
+
+// Puts a session in a role and a crew: the one named, else its starter's (or
+// its calling session's), else a new one it begins.
+export function joinCrew(
+  id: string,
+  role: AgentRole,
+  from: {
+    crewId?: string | null;
+    startedBy?: string | null;
+    parent?: string | null;
+  }
+): string {
+  const crew =
+    from.crewId || crewOf(from.startedBy) || crewOf(from.parent) || id;
+  db.prepare(
+    `UPDATE sessions SET agent_role = ?, crew_id = ? WHERE id = ?`
+  ).run(role, crew, id);
+  return crew;
+}
+
+export interface CrewMember {
+  id: string;
+  name: string;
+  agentRole: string | null;
+  model: string | null;
+  modelProvider: string | null;
+  agentType: string;
+  taskStatus: string | null;
+}
+
+export function crewMembers(crewId: string): CrewMember[] {
+  return (
+    db
+      .prepare(
+        `SELECT id, name, agent_role, model, model_provider, agent_type, task_status
+           FROM session_rows WHERE crew_id = ? AND archived_at IS NULL
+          ORDER BY created_at`
+      )
+      .all(crewId) as {
+      id: string;
+      name: string;
+      agent_role: string | null;
+      model: string | null;
+      model_provider: string | null;
+      agent_type: string;
+      task_status: string | null;
+    }[]
+  ).map((r) => ({
+    id: r.id,
+    name: r.name,
+    agentRole: r.agent_role,
+    model: r.model,
+    modelProvider: r.model_provider,
+    agentType: r.agent_type,
+    taskStatus: r.task_status,
+  }));
+}

package/lib/sessions/launch.ts

@@ -16,6 +16,9 @@ import { discoversModels, resolveModelForAgent } from "../model-catalog";
 import { isDiscoveredModel } from "../chat/discovered-models";
 import { parseOverride, resolveRole, setSessionModel } from "../models/resolve";
 import { ANTHROPIC } from "../models/roles";
+import { joinCrew } from "./crew";
+import { prepareRoleStart } from "../models/agent-binding";
+import { isAgentRole, roleBrief, type AgentRole } from "../models/agent-roles";
 import { getProject } from "../projects";
 import { getWorkspace } from "../workspaces";
 import { getHost, isRemoteHost } from "../hosts";
@@ -84,6 +87,13 @@ export interface LaunchInput {
   // follows the project; one in none keeps this (see inWorkspace).
   workspaceId?: string | null;
   systemPrompt?: string | null;
+  // Start it in a role: the model comes from the role's binding (or
+  // `model`), and its brief joins the instructions.
+  agentRole?: AgentRole | null;
+  // The crew it joins: the id of the session that began it.
+  crewId?: string | null;
+  // When the role's model is down, start on the role's fallback instead.
+  useFallback?: boolean;
   // The user's group it starts in (lib/session-groups).
   groupId?: string;
 }
@@ -261,7 +271,17 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
   if (scratch && projectPath === SCRATCH_DIR)
     await fs.promises.mkdir(SCRATCH_DIR, { recursive: true });
 
-  const agentType = input.agentType;
+  if (input.agentRole && (remote || !isAgentRole(input.agentRole)))
+    throw new Error("A role session runs on this machine");
+  const roleStart = input.agentRole
+    ? await prepareRoleStart(input.agentRole, {
+        workspaceId: project?.workspace_id ?? home,
+        projectId: project && !project.is_uncategorized ? project.id : null,
+        override: input.model?.trim() || null,
+        useFallback: input.useFallback,
+      })
+    : null;
+  const agentType: AgentType = roleStart?.agentType ?? input.agentType;
   const view =
     input.view === "terminal" || !supportsChat(agentType) || remote
       ? "terminal"
@@ -273,20 +293,30 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
   const picked = input.startedBy ? parseOverride(input.model) : null;
   if (picked && typeof picked !== "string")
     throw new Error(`model: a session takes one "provider/model"`);
-  const routed =
-    agentType === "claude" && (picked || !input.model?.trim()) && !remote
+  const routed = roleStart
+    ? roleStart.agentType === "claude"
+      ? roleStart.routed
+      : null
+    : agentType === "claude" && (picked || !input.model?.trim()) && !remote
       ? resolveRole(role, {
           workspaceId: project?.workspace_id ?? home,
           override: picked,
         })
       : null;
-  if (picked && routed && routed.provider.id !== ANTHROPIC && view !== "chat")
+  if (
+    (picked || roleStart) &&
+    routed &&
+    routed.provider.id !== ANTHROPIC &&
+    view !== "chat"
+  )
     throw new Error("Another provider's models run only as a chat");
   const interactive =
     routed && (routed.provider.id === ANTHROPIC || view === "chat")
       ? routed
       : null;
-  const wanted = input.model?.trim() || project?.default_model;
+  const wanted = roleStart
+    ? roleStart.model
+    : input.model?.trim() || project?.default_model;
   // An agent without a static list runs what it reports for this folder.
   const discovered =
     !interactive &&
@@ -295,9 +325,11 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     (await isDiscoveredModel(agentType, projectPath, wanted));
   const model = interactive
     ? interactive.model
-    : discovered && wanted
-      ? wanted
-      : resolveModelForAgent(agentType, wanted);
+    : roleStart
+      ? roleStart.model
+      : discovered && wanted
+        ? wanted
+        : resolveModelForAgent(agentType, wanted);
   const text = input.prompt?.trim() ?? "";
   const naming: Naming = text
     ? await nameFor(text, projectPath, input.name)
@@ -318,7 +350,9 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       cwd,
       input.parentSessionId ?? null,
       model,
-      input.systemPrompt ?? null,
+      [input.systemPrompt, roleBrief(input.agentRole)]
+        .filter(Boolean)
+        .join("\n\n") || null,
       "sessions",
       agentType,
       input.autoApprove || input.access === "full" ? 1 : 0,
@@ -337,6 +371,12 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     id
   );
   setHome(id, home);
+  if (input.agentRole)
+    joinCrew(id, input.agentRole, {
+      crewId: input.crewId,
+      startedBy: input.startedBy,
+      parent: input.parentSessionId,
+    });
   if (input.groupId) fileInGroup(id, input.groupId);
   if (interactive) setSessionModel(id, interactive);
   if (input.access)

package/lib/settings-url.ts

@@ -9,6 +9,7 @@ export const SETTINGS_SECTIONS = [
   "approvals",
   "workspaces",
   "models",
+  "agent-roles",
   "devices",
   "shares",
   "notifications",

package/lib/share/markdown.ts

@@ -83,13 +83,13 @@ export function htmlToMarkdown(html: string, demote = 0): string {
 }
 
 /** A fenced block whose fence is longer than any backtick run inside. */
-function fenced(text: string): string {
+export function fenced(text: string, lang = ""): string {
   const longest = Math.max(
     2,
     ...(text.match(/`+/g) ?? []).map((m) => m.length)
   );
   const fence = "`".repeat(longest + 1);
-  return `${fence}\n${text}\n${fence}`;
+  return `${fence}${lang}\n${text}\n${fence}`;
 }
 
 function itemToMarkdown(item: SnapshotItem): string {

package/lib/share/redact.ts

@@ -97,10 +97,12 @@ function sub(
 
 export function redactForShare(
   input: string,
-  ctx: ShareContext = NO_CONTEXT
+  ctx: ShareContext = NO_CONTEXT,
+  opts: { only?: Kind[] } = {}
 ): { text: string; hits: Hits } {
   const hits = noHits();
   let t = input;
+  const on = (k: Kind) => !opts.only || opts.only.includes(k);
 
   // 1. Credentials by shape.
   t = sub(t, PRIVATE_KEY_BLOCK, SECRET, hits, "secret");
@@ -143,7 +145,7 @@ export function redactForShare(
   }
 
   // 3. Home paths, and the account name before an @.
-  if (ctx.home.length > 1)
+  if (on("path") && ctx.home.length > 1)
     t = sub(
       t,
       new RegExp(escape(ctx.home) + "(?![\\w.-])", "g"),
@@ -151,8 +153,8 @@ export function redactForShare(
       hits,
       "path"
     );
-  t = sub(t, new RegExp(HOME.source, "g"), "~", hits, "path");
-  if (ctx.user.length > 2)
+  if (on("path")) t = sub(t, new RegExp(HOME.source, "g"), "~", hits, "path");
+  if (on("path") && ctx.user.length > 2)
     t = sub(
       t,
       new RegExp(`\\b${escape(ctx.user)}(?=@)`, "g"),
@@ -162,14 +164,16 @@ export function redactForShare(
     );
 
   // 4. Addresses.
-  t = sub(t, IPV4, "[ip]", hits, "ip", (m) => KEEP_IPV4.has(m));
-  t = sub(t, IPV6, "[ip]", hits, "ip", (m) => KEEP_IPV6.has(m));
+  if (on("ip")) {
+    t = sub(t, IPV4, "[ip]", hits, "ip", (m) => KEEP_IPV4.has(m));
+    t = sub(t, IPV6, "[ip]", hits, "ip", (m) => KEEP_IPV6.has(m));
+  }
 
   // 5. This machine's names, and private-network suffixes.
   const names = [...new Set(ctx.hosts.filter((h) => h.length > 2))].sort(
     (a, b) => b.length - a.length
   );
-  if (names.length)
+  if (on("host") && names.length)
     t = sub(
       t,
       new RegExp(
@@ -180,11 +184,13 @@ export function redactForShare(
       hits,
       "host"
     );
-  t = sub(t, CONNECT_HOST, "[host]", hits, "host");
-  t = sub(t, LOCAL_HOST, "[host]", hits, "host");
+  if (on("host")) {
+    t = sub(t, CONNECT_HOST, "[host]", hits, "host");
+    t = sub(t, LOCAL_HOST, "[host]", hits, "host");
+  }
 
   // 6. Email addresses.
-  t = sub(t, EMAIL, "[email]", hits, "email");
+  if (on("email")) t = sub(t, EMAIL, "[email]", hits, "email");
 
   return { text: t, hits };
 }

package/lib/share/render.tsx

@@ -60,7 +60,7 @@ const components: Components = {
   img: ({ alt }) => <span>[image{alt ? `: ${alt}` : ""}]</span>,
 };
 
-function Markdown({ text }: { text: string }) {
+export function Markdown({ text }: { text: string }) {
   return (
     <ReactMarkdown remarkPlugins={[remarkGfm]} components={components}>
       {text}

package/lib/share/snapshot.ts

@@ -44,7 +44,7 @@ export interface Snapshot {
 
 export const MAX_TOOL_INPUT = 4_000;
 export const MAX_TOOL_OUTPUT = 20_000;
-const HIDDEN_FILE = "[contents of a secret file hidden]";
+export const HIDDEN_FILE = "[contents of a secret file hidden]";
 const NO_IMAGE = "[image not shared]";
 
 const clip = (s: string, max: number) =>
@@ -55,7 +55,7 @@ const clip = (s: string, max: number) =>
 const excerptOf = (s: string) => s.replace(/\s+/g, " ").trim().slice(0, 120);
 
 // Every string in a tool's input, to see whether it names a secret file.
-function strings(v: unknown, out: string[] = []): string[] {
+export function strings(v: unknown, out: string[] = []): string[] {
   if (typeof v === "string") out.push(v);
   else if (Array.isArray(v)) v.forEach((x) => strings(x, out));
   else if (v && typeof v === "object")

package/lib/sidebar/row-menu.ts

@@ -16,6 +16,7 @@ export type RowMenuItem =
   | "open-recipe"
   | "copy-link"
   | "share"
+  | "export"
   | "fork"
   | "fresh-start"
   | "new-conversation"
@@ -121,7 +122,11 @@ export function rowMenu(input: RowMenuInput): RowMenuPlan {
       input.hasCard && "card",
       input.recipeRun && "open-recipe",
     ]),
-    ...group("share", ["copy-link", s.view === "chat" && "share"]),
+    ...group("share", [
+      "copy-link",
+      s.view === "chat" && "share",
+      s.view === "chat" && "export",
+    ]),
     ...group("restart", [
       s.agent_type === "claude" && agentRow && live && "fork",
       agentRow && live && "fresh-start",

package/lib/tasks/index.ts

@@ -67,6 +67,7 @@ import { saidSinceLastMessage } from "../chat/store";
 
 import { lastActiveOf } from "./last-active";
 import { setPlan, setTask } from "../db/session-parts";
+import { joinCrew } from "../sessions/crew";
 export * from "./state";
 export { codeReviewGate, codeReviewRefusal } from "./code-review";
 export { signOffTask, dropTask, signingOff, mergeSettled } from "./finish";
@@ -414,6 +415,11 @@ async function startTask(
       startedVia: opts.startedVia,
       startedByDevice: opts.held?.device ?? opts.startedByDevice,
     });
+    // A task is the Developer of its crew.
+    joinCrew(id, "developer", {
+      startedBy: opts.startedBy,
+      parent: opts.parentSessionId,
+    });
   } catch (error) {
     // The claim was made for a session that never existed.
     if (opts.pieceId) releaseClaim(opts.pieceId, id);

package/lib/worktree-deps/caches.ts

@@ -21,7 +21,7 @@ import { promisify } from "util";
 import { gitResult, isGitError } from "../git-exec";
 import { findNodeModules } from "./clone";
 import { fastCopyMode } from "./fastcopy";
-import { inside, realExisting } from "./paths";
+import { STAGING_SUFFIX, ignoreStaging, inside, realExisting } from "./paths";
 import { copyTree } from "./spare";
 import type { CopyMode } from "./spare";
 
@@ -234,7 +234,8 @@ export async function seedBuildCaches(opts: {
       skip(rel, "its folder in the worktree resolves outside it");
       continue;
     }
-    const partial = `${dest}.aos-partial`;
+    const partial = `${dest}${STAGING_SUFFIX}`;
+    await ignoreStaging(dir);
     await fs.promises.rm(partial, { recursive: true, force: true });
     const ok =
       (await copyTree(real, partial, mode)) &&

package/lib/worktree-deps/clone.ts

@@ -10,6 +10,7 @@ import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import { LOCKFILES } from "./install";
+import { STAGING_SUFFIX, ignoreStaging } from "./paths";
 import { STORE_ROOT, fastCopyMode, unlinkMutable } from "./fastcopy";
 import type { FastMode } from "./fastcopy";
 import {
@@ -79,7 +80,8 @@ async function cloneWhole(
   target: string,
   mode: FastMode
 ): Promise<boolean> {
-  const partial = `${target}.aos-partial`;
+  const partial = `${target}${STAGING_SUFFIX}`;
+  await ignoreStaging(path.dirname(target));
   await fs.promises.rm(partial, { recursive: true, force: true });
   const ok =
     (await copyTree(from, partial, mode)) && (await takeSpare(partial, target));

package/lib/worktree-deps/paths.ts

@@ -6,6 +6,7 @@
 
 import * as fs from "fs";
 import * as path from "path";
+import { git } from "../git-exec";
 
 export const inside = (root: string, p: string) =>
   p === root || p.startsWith(root + path.sep);
@@ -18,3 +19,28 @@ export async function realExisting(p: string): Promise<string> {
     if (path.dirname(at) === at) return at;
   }
 }
+
+export const STAGING_SUFFIX = ".aos-partial";
+
+const EXCLUDE_LINE = `*${STAGING_SUFFIX}`;
+
+// Staging dirs (`node_modules.aos-partial`) sit beside their target, where git
+// would list them as untracked work. Written once to the repo's shared
+// info/exclude, so it covers every worktree and no .gitignore is touched.
+// Best effort: outside a repository there is nothing to ignore it in.
+export async function ignoreStaging(dir: string): Promise<void> {
+  try {
+    const common = (
+      await git(dir, ["rev-parse", "--git-common-dir"], { timeout: 5000 })
+    ).trim();
+    if (!common) return;
+    const file = path.join(path.resolve(dir, common), "info", "exclude");
+    const current = await fs.promises.readFile(file, "utf8").catch(() => "");
+    if (current.split(/\r?\n/).some((l) => l.trim() === EXCLUDE_LINE)) return;
+    await fs.promises.mkdir(path.dirname(file), { recursive: true });
+    const lead = current && !current.endsWith("\n") ? "\n" : "";
+    await fs.promises.appendFile(file, `${lead}${EXCLUDE_LINE}\n`);
+  } catch {
+    // never fails a setup
+  }
+}

package/package.json

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

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";
@@ -224,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();
@@ -453,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.

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) };
+}