@saadnvd1/agent-os 0.3.581 → 0.3.584

package/components/Chat/BackgroundTasks.tsx

@@ -13,7 +13,7 @@ import {
   X,
 } from "lucide-react";
 import type { ChatItem } from "@/lib/chat/events";
-import { outputTail } from "@/lib/chat/background";
+import { outputLines, taskLife, type TaskOutput } from "@/lib/chat/background";
 import { formatElapsed } from "@/lib/chat/elapsed";
 import { cn } from "@/lib/utils";
 import { useNow } from "./useNow";
@@ -59,7 +59,7 @@ function TaskRow({
 }: {
   task: Task;
   now: number;
-  output: string | null | undefined;
+  output: TaskOutput | undefined;
   // Follows its output for the line under its name.
   tail: boolean;
   // Brought here from the call it came from.
@@ -77,7 +77,7 @@ function TaskRow({
   useEffect(() => {
     const el = outputRef.current;
     if (el) el.scrollTop = el.scrollHeight;
-  }, [output]);
+  }, [output?.text]);
 
   useEffect(() => {
     if (!highlight) return;
@@ -95,8 +95,12 @@ function TaskRow({
   }, [open, tail, running, taskId, onLoadOutput]);
 
   const took = formatElapsed((task.endedAt ?? now) - task.createdAt);
-  const line =
-    running && !open ? (outputTail(output) ?? task.lastToolName) : null;
+  const life = taskLife(task, output, now);
+  const text = output?.text;
+  const lines = outputLines(text);
+  const idle = formatElapsed(
+    Math.max(0, now - (output?.updatedAt ?? task.createdAt))
+  );
   return (
     <div
       ref={rowRef}
@@ -137,10 +141,52 @@ function TaskRow({
           </button>
         )}
       </div>
-      {line && (
-        <p className="text-muted-foreground truncate pr-2 pb-1.5 pl-9 font-mono text-[11px]">
-          {line}
-        </p>
+      {!open && (
+        <div className="space-y-0.5 pr-2 pb-1.5 pl-9">
+          {life.state === "exited" && (
+            <p
+              className={cn(
+                "font-mono text-[11px]",
+                life.failed ? "text-destructive" : "text-muted-foreground"
+              )}
+            >
+              {life.code === null ? task.status : `exited ${life.code}`}
+            </p>
+          )}
+          {lines.length > 0 ? (
+            <pre className="text-muted-foreground max-h-[4.5rem] overflow-hidden font-mono text-[11px] leading-[1.15rem]">
+              {lines.map((l, i) => (
+                <span key={i} className="block truncate">
+                  {l}
+                </span>
+              ))}
+            </pre>
+          ) : (
+            running && (
+              <p className="text-muted-foreground truncate font-mono text-[11px]">
+                {task.taskType && /monitor|watch/.test(task.taskType)
+                  ? "watching"
+                  : "running"}
+                : {task.summary || task.description}
+              </p>
+            )
+          )}
+          {running && (
+            <p
+              className={cn(
+                "text-[11px] tabular-nums",
+                life.state === "quiet"
+                  ? "text-amber-600 dark:text-amber-400"
+                  : "text-muted-foreground"
+              )}
+            >
+              {life.state === "quiet" ? "Quiet · " : ""}
+              {output?.updatedAt
+                ? `last output ${idle} ago`
+                : `no output in ${idle}`}
+            </p>
+          )}
+        </div>
       )}
       {open && (
         <div className="space-y-1 pb-2 pl-7">
@@ -149,12 +195,12 @@ function TaskRow({
           )}
           {output === undefined ? (
             <p className="text-muted-foreground text-xs">Loading output…</p>
-          ) : output ? (
+          ) : text ? (
             <pre
               ref={outputRef}
               className="bg-foreground/[0.04] max-h-56 overflow-auto rounded-lg px-2 py-1.5 font-mono text-[11px] whitespace-pre-wrap"
             >
-              {output}
+              {text}
             </pre>
           ) : (
             <p className="text-muted-foreground text-xs">
@@ -179,7 +225,7 @@ export function BackgroundTasks({
   items: ChatItem[];
   // A task to open the tray on, from the call that became it.
   reveal?: { taskId: string; at: number } | null;
-  outputs: Record<string, string | null>;
+  outputs: Record<string, TaskOutput>;
   onStop: (taskId: string) => void;
   onLoadOutput: (taskId: string) => void;
 }) {

package/components/views/DesktopAppActions.tsx

@@ -14,6 +14,8 @@ import { NotificationsMenu } from "@/components/NotificationsMenu";
 import type { ViewProps } from "./types";
 import { newDraft } from "@/stores/drafts";
 import { paletteActions } from "@/stores/palette";
+import { useClock } from "@/hooks/useMinuteTick";
+import { inBell } from "@/lib/sidebar/shelves";
 import { DRAFT_KEYS } from "@/lib/drafts";
 
 // Labels collapse to icons when the pane bar carrying these is narrow
@@ -70,6 +72,7 @@ export function DesktopAppActions({
   notificationSettings,
   attachToSession,
 }: AppActionsProps) {
+  const now = useClock();
   return (
     <div
       className="flex shrink-0 items-center gap-0.5"
@@ -95,7 +98,7 @@ export function DesktopAppActions({
       <NotificationsMenu
         settings={notificationSettings}
         waitingSessions={sessions
-          .filter((s) => sessionStatuses[s.id]?.status === "waiting")
+          .filter((s) => inBell(s, sessionStatuses[s.id], now))
           .map((s) => ({ id: s.id, name: s.name }))}
         onSelectSession={(id) => {
           const session = sessions.find((s) => s.id === id);

package/data/chat/useChat.ts

@@ -22,7 +22,7 @@ import type {
 } from "@/lib/chat/events";
 import type { SearchResult } from "@/lib/chat/find";
 import { addBody, touchBody } from "@/lib/chat/bodyCache";
-import { backgroundFailure } from "@/lib/chat/background";
+import { backgroundFailure, type TaskOutput } from "@/lib/chat/background";
 
 // The index of the item with `id`, searched from the end: what changes is
 // almost always the latest.
@@ -164,7 +164,7 @@ export function useChat(
   const searchRequests = useRef(
     new Map<string, (result: SearchResult) => void>()
   );
-  const [taskOutputs, setTaskOutputs] = useState<Record<string, string | null>>(
+  const [taskOutputs, setTaskOutputs] = useState<Record<string, TaskOutput>>(
     {}
   );
   const [canBackground, setCanBackground] = useState(false);
@@ -278,7 +278,10 @@ export function useChat(
           );
           if (message) toast(message, { duration: 2500 });
         } else if (m.type === "task_output") {
-          setTaskOutputs((prev) => ({ ...prev, [m.taskId]: m.text }));
+          setTaskOutputs((prev) => ({
+            ...prev,
+            [m.taskId]: { text: m.text, updatedAt: m.updatedAt },
+          }));
         } else if (m.type === "undo_preview") {
           setUndoPreview({ from: m.from, preview: m.preview });
         } else if (m.type === "undone") {

package/lib/chat/background.ts

@@ -75,3 +75,57 @@ export function outputTail(text: string | null | undefined): string | null {
   }
   return null;
 }
+
+// A running task that has printed nothing for this long is marked quiet.
+export const QUIET_AFTER_MS = 5 * 60 * 1000;
+const TAIL_LINES = 4;
+
+// What the server reads of a task's output file: the end of it, and when it
+// last changed.
+export interface TaskOutput {
+  text: string | null;
+  updatedAt: number | null;
+}
+
+// The last few lines that say anything, oldest first.
+export function outputLines(
+  text: string | null | undefined,
+  max = TAIL_LINES
+): string[] {
+  const lines = (text?.split("\n") ?? []).map((l) => l.trimEnd());
+  return lines.filter((l) => l.trim()).slice(-max);
+}
+
+// "... failed with exit code 65" from the agent's note on a finished task.
+export function exitCode(summary: string | undefined): number | null {
+  const m =
+    summary &&
+    /exit(?:ed)?(?: with)?(?: status| code)?\s*:?\s*(-?\d+)/i.exec(summary);
+  return m ? Number(m[1]) : null;
+}
+
+export type TaskLife =
+  | { state: "active" }
+  | { state: "quiet"; idleMs: number }
+  | { state: "exited"; code: number | null; failed: boolean };
+
+// Whether a task is progressing, has gone quiet, or has ended. Idle time
+// counts from its last output, or from its start when it has printed nothing.
+export function taskLife(
+  task: Pick<Task, "status" | "createdAt" | "summary">,
+  output: TaskOutput | null | undefined,
+  now: number
+): TaskLife {
+  if (task.status !== "running") {
+    const code = exitCode(task.summary);
+    return {
+      state: "exited",
+      code: code ?? (task.status === "completed" ? 0 : null),
+      failed: task.status === "failed" || (code !== null && code !== 0),
+    };
+  }
+  const idleMs = Math.max(0, now - (output?.updatedAt ?? task.createdAt));
+  return idleMs >= QUIET_AFTER_MS
+    ? { state: "quiet", idleMs }
+    : { state: "active" };
+}

package/lib/chat/events.ts

@@ -369,7 +369,12 @@ export type ChatServerMessage =
     }
   | { type: "context"; context: ChatContext | null }
   | { type: "undo_preview"; from: string; preview: UndoPreview }
-  | { type: "task_output"; taskId: string; text: string | null }
+  | {
+      type: "task_output";
+      taskId: string;
+      text: string | null;
+      updatedAt: number | null;
+    }
   | {
       type: "background_result";
       toolUseId?: string;

package/lib/chat/runner.ts

@@ -63,6 +63,7 @@ import { holdsQueue, settingUp } from "../sessions/setup-progress";
 import { firstMessageId, launchPending } from "../tasks/launch-gate";
 import type { ChatItem, FileSuggestion } from "./events";
 import { taskOutputTail } from "./task-output";
+import type { TaskOutput } from "./background";
 import { cutOffSessions, cutOffTurn, RESUME_NOTE } from "./interrupted";
 import { queueEvent } from "../orchestrator/events";
 import { restoreActivity, track } from "./activity";
@@ -881,7 +882,7 @@ export async function backgroundChatTask(
 export function chatTaskOutput(
   sessionId: string,
   taskId: string
-): string | null {
+): TaskOutput | null {
   const task = itemsOfKind(sessionId, "task").find((i) => i.taskId === taskId);
   if (task?.kind !== "task") return null;
   return taskOutputTail(taskId, task.outputFile);

package/lib/chat/socket.ts

@@ -196,7 +196,10 @@ function onChatMessage(
     reply({
       type: "task_output",
       taskId: msg.taskId,
-      text: chatTaskOutput(sessionId, msg.taskId),
+      ...(chatTaskOutput(sessionId, msg.taskId) ?? {
+        text: null,
+        updatedAt: null,
+      }),
     });
   else if (msg.type === "history" && Number.isFinite(msg.before))
     reply({

package/lib/chat/task-output.ts

@@ -2,6 +2,8 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 
+import type { TaskOutput } from "./background";
+
 const TAIL_BYTES = 6000;
 const found = new Map<string, string>();
 
@@ -48,19 +50,22 @@ function walk(dir: string, name: string, depth: number): string | null {
 export function taskOutputTail(
   taskId: string,
   knownFile?: string
-): string | null {
+): TaskOutput | null {
   const file =
     knownFile && fs.existsSync(knownFile) ? knownFile : findOutputFile(taskId);
   if (!file) return null;
   try {
-    const { size } = fs.statSync(file);
+    const { size, mtimeMs } = fs.statSync(file);
     const fd = fs.openSync(file, "r");
     try {
       const start = Math.max(0, size - TAIL_BYTES);
       const buf = Buffer.alloc(size - start);
       fs.readSync(fd, buf, 0, buf.length, start);
       const text = buf.toString("utf8");
-      return start > 0 ? text.slice(text.indexOf("\n") + 1) : text;
+      return {
+        text: start > 0 ? text.slice(text.indexOf("\n") + 1) : text,
+        updatedAt: mtimeMs,
+      };
     } finally {
       fs.closeSync(fd);
     }

package/lib/needs-you.ts

@@ -33,7 +33,12 @@ function latestChatItem(sessionId: string): ChatItem | null {
 // is routine for it.
 export function needsYou(
   session: Pick<Session, "id" | "view" | "updated_at" | "last_seen_at"> &
-    Partial<Pick<Session, "role" | "workspace_id" | "task_status">>,
+    Partial<
+      Pick<
+        Session,
+        "role" | "workspace_id" | "task_status" | "settled_at" | "archived_at"
+      >
+    >,
   chatState: ChatState | null
 ): boolean {
   const seen = sqliteMs(session.last_seen_at);
@@ -43,7 +48,16 @@ export function needsYou(
     if (chatState === "waiting") return true;
     if (session.role === "orchestrator")
       return openAskCount(session.workspace_id) > 0;
+    if (session.archived_at) return false;
     const latest = latestChatItem(session.id);
+    // Put on the Done shelf after its last turn: that turn is history, not
+    // news. (settled_at has second precision.)
+    if (
+      latest &&
+      session.settled_at &&
+      latest.createdAt <= sqliteMs(session.settled_at) + 1000
+    )
+      return false;
     return latest?.kind === "turn_end" && latest.createdAt > seen;
   }
   // A terminal session's updated_at moves when it starts waiting.

package/lib/recipes/settle.ts

@@ -7,6 +7,7 @@ import { db, queries, type Session } from "../db";
 import { finalMessage, usageRows } from "../session-logs/gather";
 import { chatStateNow } from "../chat/runner";
 import { doneSession } from "../done";
+import { notifyStatusChanged } from "../status/hub";
 import { blockedReason } from "../tasks/state";
 import { runClaude, type ClaudeRunner } from "../orchestrator/claude-cli";
 import { releasePieces } from "../plans/release";
@@ -406,23 +407,35 @@ async function settleOne(
   } else idleSince.delete(run.id);
 }
 
-// After a run settles: a finished session run is marked Done so the sidebar
-// doesn't pile up; a task run is left to its gates. Idle alerts for it are
-// silenced because the settle event already told the orchestrator.
+// After a run settles: a session run that reported its result (ok or failed)
+// is marked Done so the sidebar and the bell don't pile up; a task run is left
+// to its gates. A run that ended without a result line, was blocked or timed
+// out may be a real question, so it stays open. The settle event already told
+// the orchestrator.
+export function finishesSession(
+  row: { status: RunStatus; summary_source: string | null },
+  recipe: Pick<Recipe, "kind" | "auto_done">
+): boolean {
+  if (recipe.kind !== "session" || !recipe.auto_done) return false;
+  if (row.status === "succeeded") return true;
+  return row.status === "failed" && row.summary_source === "line";
+}
+
 async function afterSettle(run: Live): Promise<void> {
   const row = db
-    .prepare(`SELECT status FROM recipe_runs WHERE id = ?`)
-    .get(run.id) as { status: RunStatus } | undefined;
-  if (!row || run.recipe.kind !== "session" || !run.session_id) return;
-  if (row.status === "succeeded" && run.recipe.auto_done) {
-    try {
-      await doneSession(run.session_id, { by: "direct", noMerge: true });
-    } catch (error) {
-      console.warn(
-        "[recipes] couldn't mark done:",
-        error instanceof Error ? error.message : error
-      );
-    }
+    .prepare(`SELECT status, summary_source FROM recipe_runs WHERE id = ?`)
+    .get(run.id) as
+    | { status: RunStatus; summary_source: string | null }
+    | undefined;
+  if (!row || !run.session_id || !finishesSession(row, run.recipe)) return;
+  try {
+    await doneSession(run.session_id, { by: "direct", noMerge: true });
+    notifyStatusChanged();
+  } catch (error) {
+    console.warn(
+      `[recipes] couldn't mark run #${run.seq} (${run.session_id}) done:`,
+      error instanceof Error ? error.message : error
+    );
   }
 }
 

package/lib/sidebar/shelves.ts

@@ -198,6 +198,17 @@ export function settledHow(
   return now - active >= SETTLE_AFTER_MS ? "auto" : null;
 }
 
+// Whether the bell lists a session: waiting on you, and not put away. Like
+// the shelves, a live need wins over Done.
+export function inBell(
+  session: Parameters<typeof settledHow>[0] & Pick<Session, "archived_at">,
+  status: RowStatus | undefined,
+  now: number
+): boolean {
+  if (status?.status !== "waiting" || session.archived_at) return false;
+  return !!status.need || !settledHow(session, now);
+}
+
 // Woken by its timer and not opened since.
 function wokeUnread(
   session: Parameters<typeof activeMs>[0] & Pick<Session, "last_seen_at">,

package/lib/tasks/queue.ts

@@ -189,7 +189,10 @@ const workspaceOf = (projectId: string) =>
 // gives its slot back until it resumes. A quick change
 // runs no agent, so it holds none. Without a
 // workspace, the project is the scope.
-function runningIn(scope: { workspaceId: string | null; projectId: string }) {
+function runningIn(
+  scope: { workspaceId: string | null; projectId: string },
+  forSlots = false
+) {
   const where = scope.workspaceId
     ? `p.workspace_id = @ws`
     : `p.id = @project AND p.workspace_id IS NULL`;
@@ -199,6 +202,7 @@ function runningIn(scope: { workspaceId: string | null; projectId: string }) {
         `SELECT s.id FROM sessions s JOIN projects p ON p.id = s.project_id
          WHERE ${where} AND s.archived_at IS NULL AND s.quick_of IS NULL
            AND (s.pause_state IS NULL OR s.pause_state != 'paused')
+           ${forSlots ? `AND NOT (COALESCE(s.plan_only, 0) = 1 AND COALESCE(s.plan_phase, '') != 'implementing')` : ""}
            AND s.task_status IN (${IN_FLIGHT.map((s) => `'${s}'`).join(", ")})`
       )
       .all({ ws: scope.workspaceId, project: scope.projectId }) as {
@@ -214,7 +218,8 @@ function startingIn(workspaceId: string): number {
       db
         .prepare(
           `SELECT COUNT(*) AS n FROM task_queue q JOIN projects p ON p.id = q.project_id
-         WHERE q.status = 'starting' AND p.workspace_id = ?`
+         WHERE q.status = 'starting' AND p.workspace_id = ?
+           AND q.plan_only IS NULL`
         )
         .get(workspaceId) as { n: number }
     ).n
@@ -315,7 +320,8 @@ const waitingIn = (workspaceId: string) =>
       .prepare(
         `SELECT COUNT(*) AS n FROM task_queue q JOIN projects p ON p.id = q.project_id
          WHERE q.status = 'queued' AND p.workspace_id = ?
-           AND q.after_task IS NULL AND q.after_any IS NULL`
+           AND q.after_task IS NULL AND q.after_any IS NULL
+           AND q.plan_only IS NULL`
       )
       .get(workspaceId) as { n: number }
   ).n;
@@ -344,9 +350,10 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
   } else if (after)
     afterTask = resolveAfter(after, req.originWorkspaceId ?? workspaceId).id;
   const full =
+    !req.planOnly &&
     limit !== null &&
     !!workspaceId &&
-    (runningIn({ workspaceId, projectId: project.id }).length +
+    (runningIn({ workspaceId, projectId: project.id }, true).length +
       startingIn(workspaceId) >=
       limit ||
       waitingIn(workspaceId) > 0);
@@ -360,6 +367,7 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
   const loaded =
     !waits &&
     !full &&
+    !req.planOnly &&
     !!req.originWorkspaceId &&
     loadHeldStart(project.id, req.prompt, setting);
   if (!waits && !full && !loaded) return null;
@@ -523,9 +531,10 @@ export const queuedView = (id: string) =>
 
 // Why an automatic start has to wait, or null. A start now by a person
 // isn't held.
-function autoHold(workspaceId: string | null): Hold | null {
+function autoHold(workspaceId: string | null, planOnly = false): Hold | null {
   if (workspaceId && isPaused(workspaceId))
     return { code: "orch_paused", text: "Waiting: the orchestrator is paused" };
+  if (planOnly) return null;
   const window = brakesEnabled() ? windowRefusal(readUsage()) : null;
   return window ? { code: "window", text: `Waiting: ${window}` } : null;
 }
@@ -609,7 +618,7 @@ async function startRow(
     return "failed";
   }
   if (!opts.force) {
-    const held = autoHold(workspaceId);
+    const held = autoHold(workspaceId, !!r.plan_only);
     if (held) {
       if (r.note !== held.text)
         patch(r.id, { note: held.text, wait_code: held.code });
@@ -621,7 +630,8 @@ async function startRow(
     if (
       workspaceId &&
       limit !== null &&
-      runningIn({ workspaceId, projectId: r.project_id }).length +
+      !r.plan_only &&
+      runningIn({ workspaceId, projectId: r.project_id }, true).length +
         startingIn(workspaceId) >=
         limit
     )
@@ -643,7 +653,7 @@ async function startRow(
   }
   if (!claimed) return "held";
   const placed = opts.placement ?? null;
-  if (!opts.force)
+  if (!opts.force && !r.plan_only)
     recordAutoStart(placed?.hostId ?? LOCAL, !!opts.heavy, Date.now());
   // A linked machine's start never sees this machine's held messages: they
   // go with the brief it is sent.
@@ -747,7 +757,7 @@ function groupFor(
   const scope = { workspaceId, projectId };
   return {
     inFlight:
-      runningIn(scope).length +
+      runningIn(scope, true).length +
       (workspaceId ? (reserved.get(workspaceId) ?? 0) : 0) +
       startingRows,
     limit: limitOf(workspaceId) ?? Number.POSITIVE_INFINITY,
@@ -814,8 +824,9 @@ function candidateOf(
       heavy: heavyNeeds(needs),
       needsUnmet: !remote && !meetsNeeds(needs, machineCapabilities()),
       remote,
+      planOnly: !!r.plan_only,
       before,
-      auto: autoHold(r.workspace_id),
+      auto: autoHold(r.workspace_id, !!r.plan_only),
       any,
     },
   };

package/lib/tasks/schedule.ts

@@ -82,6 +82,9 @@ export interface Candidate {
   needsUnmet: boolean;
   // Starts on another machine: this one's load doesn't matter to it.
   remote: boolean;
+  // A plan-only task before approval: it reads code and writes one file, so
+  // load, spacing and the slot limit don't apply. Pause and `after` still do.
+  planOnly?: boolean;
   // `after X` hold, from the caller (it needs the database).
   before: Hold | null;
   // Orchestrator Pause and the usage window, which hold after `after`.
@@ -127,11 +130,12 @@ const seconds = (ms: number) => Math.max(1, Math.ceil(ms / 1000));
 
 // The machine holds, in order. Null: it may start here now.
 export function machineHold(
-  c: Pick<Candidate, "heavy" | "needsUnmet" | "remote" | "priority">,
+  c: Pick<Candidate, "heavy" | "needsUnmet" | "remote" | "priority"> &
+    Partial<Pick<Candidate, "planOnly">>,
   m: MachineView,
   now: number
 ): Hold | null {
-  if (c.remote) return null;
+  if (c.remote || c.planOnly) return null;
   if (c.needsUnmet) return { code: "needs", text: `Waiting: needs a Mac` };
   if (!m.enabled) return null;
   if (m.reading)
@@ -226,7 +230,7 @@ export function planStarts(
         priority: c.priority,
       });
       if (hold) return void plan.explain.set(c.id, view(hold));
-      if (inFlight >= group.limit)
+      if (!c.planOnly && inFlight >= group.limit)
         return void plan.explain.set(
           c.id,
           view({
@@ -240,8 +244,8 @@ export function planStarts(
         if (free) used.add(free);
         plan.consume.set(c.id, free);
       }
-      inFlight += 1;
-      if (!c.remote) {
+      if (!c.planOnly) inFlight += 1;
+      if (!c.remote && !c.planOnly) {
         m.lastAutoStartAt = now;
         if (c.heavy) {
           m.lastHeavyStartAt = now;

package/package.json

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