@saadnvd1/agent-os 0.3.828 → 0.3.836

package/lib/chat/start-error.ts

@@ -0,0 +1,13 @@
+// What a person reads when a chat's worker can't start. The raw error (a
+// socket ENOENT, usually) stays in the server log.
+export function startFailureMessage(error: unknown): string {
+  const raw = error instanceof Error ? error.message : String(error);
+  if (!/^The chat worker didn't start/.test(raw)) return raw;
+  const reason = /ENOENT|ECONNREFUSED/.test(raw)
+    ? "it stopped while starting"
+    : raw
+        .replace(/^The chat worker didn't start:?\s*/, "")
+        .split("\n")[0]
+        .slice(0, 120) || "it didn't answer";
+  return `Couldn't start the agent: ${reason}`;
+}

package/lib/chat/worker/cwd.ts

@@ -0,0 +1,77 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { getProject } from "../../projects";
+import type { Session } from "../../db";
+
+const expand = (p: string) => p.replace(/^~/, os.homedir());
+const isDir = (p: string) => {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+export const WORKTREE_REMOVED_NOTE =
+  "(This task's PR merged and its worktree was removed. You are now running in the project's main checkout: do not edit files or commit here. Questions are fine; if more changes are needed, say a follow-up task is required.)";
+
+// The project's own checkout, for a session whose folder is gone; null when
+// that is missing too or the session never had a project.
+function projectRoot(session: Session): string | null {
+  const project = session.project_id ? getProject(session.project_id) : null;
+  const root = project ? expand(project.working_directory) : null;
+  return root && isDir(root) ? root : null;
+}
+
+// Where a session's agent runs. A task's worktree is removed when it
+// merges, but its chat can still be asked a question: it runs in the
+// project's checkout instead.
+export function resolveChatCwd(session: Session): {
+  session: Session;
+  removedFrom: string | null;
+} {
+  const dir = expand(session.working_directory);
+  if (isDir(dir)) return { session, removedFrom: null };
+  const root = projectRoot(session);
+  if (!root) return { session, removedFrom: null };
+  return {
+    session: { ...session, working_directory: root },
+    removedFrom: dir,
+  };
+}
+
+// Claude finds a conversation under its folder's name in its config dir, so
+// a resume from a new folder needs the transcript copied there.
+export function carryClaudeTranscript(
+  from: string,
+  to: string,
+  claudeSessionId: string | null
+): void {
+  if (!claudeSessionId) return;
+  const base = path.join(
+    process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"),
+    "projects"
+  );
+  const name = (d: string) => d.replace(/[^a-zA-Z0-9]/g, "-");
+  const src = path.join(base, name(from), `${claudeSessionId}.jsonl`);
+  const dest = path.join(base, name(to), `${claudeSessionId}.jsonl`);
+  try {
+    if (!fs.existsSync(src) || fs.existsSync(dest)) return;
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+  } catch (error) {
+    console.error(
+      "Couldn't carry the transcript to the project folder:",
+      error
+    );
+  }
+}
+
+// A finished task whose worktree is gone: the sidebar's cue for the notice.
+export function worktreeRemoved(session: Session): boolean {
+  if (!session.worktree_path || !session.task_status) return false;
+  if (session.task_status === "running") return false;
+  if (session.host_id && session.host_id !== "local") return false;
+  return !isDir(expand(session.worktree_path));
+}

package/lib/chat/worker/host.ts

@@ -8,6 +8,7 @@ import os from "os";
 import { db, type Session } from "../../db";
 import { agentEnv } from "../../agents/launch";
 import { forkBrief } from "../../fork/extras";
+import { WORKTREE_REMOVED_NOTE } from "./cwd";
 import { sessionRunningBrief } from "../../project-config/session";
 import { BUS_BRIEF } from "../../agents/brief";
 import { resolveModelForAgent } from "../../model-catalog";
@@ -196,7 +197,9 @@ export class ChatHost {
     private session: Session,
     private emit: (e: WorkerEvent) => void,
     // What a session's role adds: its brief and its own tools.
-    extras: RoleExtras = {}
+    extras: RoleExtras = {},
+    // Its worktree was removed: it runs in the project's checkout.
+    private worktreeGone = false
   ) {
     this.gate = new GuestGate((note) => {
       if (!this.busy()) return;
@@ -611,7 +614,13 @@ export class ChatHost {
     if (handOver) this.stopsUpTo = this.turnsStarted;
     if (now) this.nowPending++;
     this.stopping = null;
-    const note = this.refreshedNote ?? (this.restartedNote && RESTARTED_NOTE);
+    const note =
+      [
+        this.worktreeGone && WORKTREE_REMOVED_NOTE,
+        this.refreshedNote ?? (this.restartedNote && RESTARTED_NOTE),
+      ]
+        .filter(Boolean)
+        .join("\n") || null;
     const text = agentText(note ? `${note}\n\n${m.text}` : m.text, m.files);
     if (this.refreshedNote) {
       this.refreshedNote = null;

package/lib/chat/worker/main.ts

@@ -41,9 +41,17 @@ async function main(sessionId: string) {
     console.error(`No session ${sessionId}`);
     process.exit(1);
   }
-  const session = await (
+  const routed = await (
     await import("../../models/launch")
   ).routeOrchestrator(row);
+  const { resolveChatCwd, carryClaudeTranscript } = await import("./cwd");
+  const { session, removedFrom } = resolveChatCwd(routed);
+  if (removedFrom && session.agent_type === "claude")
+    carryClaudeTranscript(
+      removedFrom,
+      session.working_directory,
+      session.claude_session_id
+    );
 
   const clients = new Set<net.Socket>();
   const emit = (e: WorkerEvent) => {
@@ -60,7 +68,8 @@ async function main(sessionId: string) {
       emit(e);
       if (e.type === "state") armIdle();
     },
-    extras
+    extras,
+    !!removedFrom
   );
   function armIdle() {
     clearTimeout(idleTimer);

package/lib/db/types.ts

@@ -87,6 +87,8 @@ export interface Session {
   // Task priority (null reads as normal) and timed pause (lib/tasks/pause.ts):
   // pausing, paused or resuming, until when (null: until resumed).
   priority?: string | null;
+  // Set only by GET /api/sessions: a finished task whose worktree is gone.
+  worktree_removed?: boolean;
   pause_state?: "pausing" | "paused" | "resuming" | null;
   paused_until?: string | null;
   pause_id?: number | null;

package/lib/fork/brief.ts

@@ -3,7 +3,7 @@
 import { FORK_LIMITS } from "./options";
 import type { ChildRow } from "./types";
 
-export const PARENT_BRIEF = `Forks: when you have independent side work, \`aos fork "<instruction>" ["<instruction>" …]\` starts that many background copies of you (up to ${FORK_LIMITS.maxPerFork}) that know what you know. It returns at once; you keep working. Their results arrive as a message when they finish, or after \`aos wait children --all|--any [--timeout 30m]\` (end your turn; you're woken with them). \`aos children\` lists them, \`aos children <n>\` shows a full result, \`aos cancel <n>|--all\` stops them. Children have your abilities and work in your checkout: tell one that has to edit code to \`--worktree\` (its own throwaway checkout). Fork only work that doesn't depend on your next step.`;
+export const PARENT_BRIEF = `Forks: when the user asks you to fork, or to do things in parallel in background copies, run \`aos fork "<instruction>" ...\` (one instruction per fork), keep working, and results arrive as a message. Also when you have independent side work, \`aos fork "<instruction>" ["<instruction>" …]\` starts that many background copies of you (up to ${FORK_LIMITS.maxPerFork}) that know what you know. It returns at once; you keep working. Their results arrive as a message when they finish, or after \`aos wait children --all|--any [--timeout 30m]\` (end your turn; you're woken with them). \`aos children\` lists them, \`aos children <n>\` shows a full result, \`aos cancel <n>|--all\` stops them. Children have your abilities and work in your checkout: tell one that has to edit code to \`--worktree\` (its own throwaway checkout). Fork only work that doesn't depend on your next step.`;
 
 export const CHILD_BRIEF = `You are a fork child: a background copy of another session, started to do one piece of work and report back. You have its abilities, not its checkout: don't change the parent's files, push, open a PR or fork. Put temp work (scripts, repros, notes) in $AOS_SCRATCH. Run builds and tests only through \`aos heavy -- <command>\`, which queues you with the other forks. To ask the parent something, \`aos send <parent> "<question>"\`; that doesn't finish you. When done, \`aos return "<result>"\` (first line: the answer in a sentence; then the detail; \`--failed\` if you couldn't do it). Your reply when you end your turn without it is used as the result, after a short wait.`;
 
@@ -41,7 +41,9 @@ const outcomeWord = (c: ChildRow) =>
     ? "failed"
     : c.outcome === "cancelled"
       ? "cancelled"
-      : "done";
+      : c.outcome === "empty"
+        ? "ended with no result"
+        : "done";
 
 // One delivery: every result in the batch, whole when short, else its
 // summary and the command that reads the rest.

package/lib/fork/deliver.ts

@@ -34,7 +34,12 @@ async function send(parentId: string, deliveryId: string, rows: ChildRow[]) {
     text,
     queue: true,
     from: "AgentOS",
-    origin: { kind: "event", label: "Forks", body },
+    origin: {
+      kind: "event",
+      label: "Forks",
+      body,
+      forks: { parent: parentId, ids: rows.map((c) => c.child_session_id) },
+    },
   });
   markDelivered(deliveryId);
 }

package/lib/fork/ledger.ts

@@ -176,6 +176,11 @@ export function summaryOf(text: string): string {
   return one.length <= max ? one : `${one.slice(0, max - 1)}…`;
 }
 
+// A result that says nothing: blank, or one bare flag (`--help`) a child took
+// for its answer. A quoted sentence that starts with dashes is still an answer.
+export const isNonAnswer = (text: string | null | undefined): boolean =>
+  !text?.trim() || /^--?[a-z][a-z-]*$/i.test(text.trim());
+
 export const capResult = (text: string): string =>
   text.length <= FORK_LIMITS.resultChars
     ? text

package/lib/fork/note.ts

@@ -0,0 +1,6 @@
+/** The one line the parent's chat keeps where forks were started. */
+
+export const FORK_NOTE_PREFIX = "fork-";
+
+export const startedText = (ns: number[], labels: string[]): string =>
+  `${ns.length === 1 ? `Fork ${ns[0]}` : `Forks ${ns.join(", ")}`} started · ${labels.join(" · ")}`;

package/lib/fork/settle.ts

@@ -22,6 +22,7 @@ import {
   updateResult,
   childrenOf,
   findChild,
+  isNonAnswer,
   markDeliveredIds,
 } from "./ledger";
 import { FORK_LIMITS } from "./options";
@@ -120,7 +121,11 @@ export async function returnChild(
   if (!row) throw new Error("Only a fork child can return a result");
   const body = text.trim();
   if (!body) throw new Error('Give the result: aos return "<result>"');
-  const outcome: ChildOutcome = failed ? "failed" : "ok";
+  const outcome: ChildOutcome = failed
+    ? "failed"
+    : isNonAnswer(body)
+      ? "empty"
+      : "ok";
   if (
     await settleAndDeliver(childId, {
       outcome,
@@ -205,10 +210,9 @@ export async function lookAtChild(row: ChildRow, now: number): Promise<void> {
   // It asked its parent something and is waiting for the answer.
   if (openWaits().some((w) => w.waiter_id === row.child_session_id)) return;
   const reply = lastReply(row.child_session_id);
-  if (!reply) return;
   await settleAndDeliver(row.child_session_id, {
-    outcome: "ok",
-    summary: summaryOf(reply),
+    outcome: isNonAnswer(reply) ? "empty" : "ok",
+    summary: reply ? summaryOf(reply) : "ended without a result",
     result: reply,
     kind: "implicit",
   });

package/lib/fork/start.ts

@@ -18,6 +18,7 @@ import { getProject } from "../projects";
 import { limitOf, runningIn, startingIn } from "../tasks/queue-rows";
 import { currentLevel, loadEnabled } from "../load/monitor";
 import { childFirstMessage } from "./brief";
+import { FORK_NOTE_PREFIX, startedText } from "./note";
 import { ForkError, forkConversation } from "./conversation";
 import {
   childrenOf,
@@ -120,7 +121,7 @@ export function startFork(req: ForkRequest): ForkStarted {
     instruction,
     worktree,
   }));
-  const noteId = `fork-${groupId}`;
+  const noteId = `${FORK_NOTE_PREFIX}${groupId}`;
   insertGroup({
     id: groupId,
     parentId: parent.id,
@@ -136,7 +137,10 @@ export function startFork(req: ForkRequest): ForkStarted {
     kind: "note" as const,
     tone: "note" as const,
     createdAt: Date.now(),
-    text: `Forked ${children.length === 1 ? "1 copy" : `${children.length} copies`}: ${children.map((c) => c.label).join(" · ")}`,
+    text: startedText(
+      children.map((c) => numberOf(parent.id, c.childId)),
+      children.map((c) => c.label)
+    ),
   };
   saveItem(parent.id, item);
   emit(parent.id, { type: "item", item });

package/lib/fork/types.ts

@@ -1,7 +1,9 @@
 export type ChildState =
   "queued" | "starting" | "running" | "needs_input" | "settled";
 
-export type ChildOutcome = "ok" | "failed" | "cancelled";
+// `empty`: it ended, but with nothing to read (blank, or a bare flag like
+// "--help"), so it isn't shown as a finished answer.
+export type ChildOutcome = "ok" | "failed" | "cancelled" | "empty";
 
 // `implicit`: the child's turn ended without `aos return`, so its final
 // answer stands in (kept apart so stats can tell them).
@@ -59,6 +61,8 @@ export interface ChildView {
   hold: string | null;
   outcome: ChildOutcome | null;
   summary: string | null;
+  // The start of its result, for the card in the parent's chat.
+  excerpt: string | null;
   resultKind: ResultKind | null;
   worktree: boolean;
   fellBack: boolean;
@@ -67,6 +71,8 @@ export interface ChildView {
   delivered: boolean;
   // A question or approval it's waiting on.
   asks: string | null;
+  // What it is doing now (its latest tool), while it runs.
+  activity: string | null;
 }
 
 export interface GroupView {

package/lib/fork/view.ts

@@ -1,5 +1,6 @@
 /** What clients and `aos children` show, and the numbers behind them. */
 
+import { lastItems } from "../chat/store";
 import { childrenOf, getGroup } from "./ledger";
 import type { ChildRow, ChildView, GroupView } from "./types";
 
@@ -13,6 +14,7 @@ export const childView = (c: ChildRow): ChildView => ({
   hold: c.hold,
   outcome: c.outcome,
   summary: c.summary,
+  excerpt: c.result ? c.result.slice(0, 600) : null,
   resultKind: c.result_kind,
   worktree: !!c.worktree,
   fellBack: !!c.fell_back,
@@ -20,8 +22,16 @@ export const childView = (c: ChildRow): ChildView => ({
   settledAt: c.settled_at,
   delivered: c.delivered_at != null,
   asks: c.state === "needs_input" ? c.hold : null,
+  activity: null,
 });
 
+// The title of the latest tool a running child used, to say what it is doing.
+const activityOf = (c: ChildRow): string | null => {
+  if (c.state !== "running") return null;
+  const tool = lastItems(c.child_session_id, 1, "tool")[0];
+  return tool && tool.kind === "tool" ? tool.title : null;
+};
+
 export function childrenView(parentId: string): {
   children: ChildView[];
   groups: GroupView[];
@@ -44,7 +54,11 @@ export function childrenView(parentId: string): {
       });
   }
   return {
-    children: rows.map((c, i) => ({ ...childView(c), n: i + 1 })),
+    children: rows.map((c, i) => ({
+      ...childView(c),
+      n: i + 1,
+      activity: activityOf(c),
+    })),
     groups,
   };
 }
@@ -61,6 +75,7 @@ export interface ForkStats {
   ok: number;
   failed: number;
   cancelled: number;
+  empty: number;
   implicit: number;
   fellBack: number;
   medianSeconds: number | null;
@@ -83,6 +98,7 @@ export function statsOf(rows: ChildRow[]): ForkStats {
     ok: done.filter((c) => c.outcome === "ok").length,
     failed: done.filter((c) => c.outcome === "failed").length,
     cancelled: done.filter((c) => c.outcome === "cancelled").length,
+    empty: done.filter((c) => c.outcome === "empty").length,
     implicit: done.filter(
       (c) => c.result_kind === "implicit" && c.outcome === "ok"
     ).length,
@@ -106,7 +122,7 @@ export function statsText(s: ForkStats): string {
   const pct = (n: number) =>
     s.settled ? `${Math.round((n / s.settled) * 100)}%` : "-";
   return [
-    `${s.children} children, ${s.settled} settled (${s.ok} ok, ${s.failed} failed, ${s.cancelled} cancelled)`,
+    `${s.children} children, ${s.settled} settled (${s.ok} ok, ${s.failed} failed, ${s.cancelled} cancelled, ${s.empty} no result)`,
     `returned without aos return: ${s.implicit} (${pct(s.implicit)}); started from a brief, not a fork: ${s.fellBack}`,
     `median time to settle: ${s.medianSeconds ?? "-"}s`,
     `tokens: ${s.tokensIn} in, ${s.tokensOut} out, ${s.cacheRead} cache read`,

package/package.json

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

package/scripts/lib/build-swap.sh

@@ -8,7 +8,7 @@
 # Sourced by scripts/redeploy; run from the repository root.
 
 # shellcheck source=generated.sh
-source scripts/lib/generated.sh
+source "$(dirname "${BASH_SOURCE[0]}")/generated.sh"
 
 LIVE=.next
 NEXT_BUILD=.next-build

package/scripts/update-e2e.test.ts

@@ -19,6 +19,8 @@ const SCRIPTS = [
   "lib/build-swap.sh",
   "lib/pnpm.sh",
   "lib/deps-swap.sh",
+  "lib/generated.sh",
+  "generated-files.txt",
   "lib/update-verify.mjs",
 ];