@saadnvd1/agent-os 0.3.723 → 0.3.731

package/components/Tasks/TaskRow.tsx

@@ -21,6 +21,7 @@ import { cn } from "@/lib/utils";
 import { SimulatorIndicator } from "@/components/Simulator";
 import { PlanReview } from "./PlanReview";
 import { MoveTaskButton } from "./MoveTaskButton";
+import { LoopButton } from "./Loop/LoopButton";
 import { ResumeOnModel } from "./ResumeOnModel";
 import { TASK_STATE as STATE } from "./task-state-labels";
 import { formatTokens } from "@/components/Usage/format";
@@ -119,6 +120,7 @@ export function TaskRow({ task }: { task: TaskView }) {
           )}
           {!task.hostId && <SimulatorIndicator sessionId={task.id} />}
           <MoveTaskButton task={task} onError={setMoveError} />
+          {!task.hostId && <LoopButton taskId={task.id} name={task.name} />}
           {!task.hostId && <ResumeOnModel task={task} />}
           <span className="flex-1" />
           {confirmDrop ? (

package/components/Workspaces/WorkspaceModeForm.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ModeChooser } from "@/components/Report/ModeChooser";
+import { useSetWorkspaceMode, useWorkspaceMode } from "@/data/reports";
+
+// A workspace's default operating mode; a task can override it.
+export function WorkspaceModeForm({ workspaceId }: { workspaceId: string }) {
+  const { data: mode } = useWorkspaceMode(workspaceId);
+  const set = useSetWorkspaceMode(workspaceId);
+  if (!mode) return null;
+  return (
+    <div className="space-y-1.5">
+      <h4 className="text-sm font-medium">Operating mode</h4>
+      <ModeChooser
+        mode={mode}
+        onChange={(m) => set.mutate(m)}
+        disabled={set.isPending}
+        note="New tasks start in this mode; any task can change its own."
+      />
+    </div>
+  );
+}

package/components/Workspaces/WorkspaceSettings.tsx

@@ -9,6 +9,7 @@ import { McpServersForm } from "./McpServersForm";
 import { HqFolderForm } from "./HqFolderForm";
 import { ProjectTiersForm } from "./ProjectTiersForm";
 import { StallForm } from "./StallForm";
+import { WorkspaceModeForm } from "./WorkspaceModeForm";
 import { WorkspaceModelsForm } from "./WorkspaceModelsForm";
 import { AwayWindowForm } from "@/components/Away/AwayWindowForm";
 
@@ -46,6 +47,7 @@ export function WorkspaceSettings() {
             key={`${w.id}:${w.max_running_tasks ?? "off"}`}
             workspace={w}
           />
+          <WorkspaceModeForm workspaceId={w.id} />
           <RulesForm workspaceId={w.id} />
           <WorkspaceModelsForm workspaceId={w.id} />
           <McpServersForm workspace={w} />

package/components/ui/segmented.tsx

@@ -0,0 +1,55 @@
+"use client";
+
+import { cn } from "@/lib/utils";
+
+export interface SegmentedOption<T extends string> {
+  value: T;
+  label: string;
+  hint?: string;
+}
+
+/** One choice out of a few, side by side. Radio semantics, 44px targets. */
+export function Segmented<T extends string>({
+  value,
+  options,
+  onChange,
+  label,
+  disabled,
+}: {
+  value: T;
+  options: SegmentedOption<T>[];
+  onChange: (v: T) => void;
+  label: string;
+  disabled?: boolean;
+}) {
+  return (
+    <div
+      role="radiogroup"
+      aria-label={label}
+      className="bg-muted/60 grid auto-cols-fr grid-flow-col gap-1 rounded-lg p-1"
+    >
+      {options.map((o) => {
+        const on = o.value === value;
+        return (
+          <button
+            key={o.value}
+            type="button"
+            role="radio"
+            aria-checked={on}
+            title={o.hint}
+            disabled={disabled}
+            onClick={() => !on && onChange(o.value)}
+            className={cn(
+              "min-h-11 rounded-md px-2 text-sm font-medium transition-colors disabled:opacity-50",
+              on
+                ? "bg-card text-foreground shadow-sm"
+                : "text-muted-foreground hover:text-foreground"
+            )}
+          >
+            {o.label}
+          </button>
+        );
+      })}
+    </div>
+  );
+}

package/components/ui/status-pill.tsx

@@ -4,6 +4,9 @@ import { cn } from "@/lib/utils";
 const TONES = {
   amber: "bg-amber-500/15 text-amber-700 dark:text-amber-400",
   muted: "bg-muted text-muted-foreground",
+  green: "bg-green-500/15 text-green-700 dark:text-green-400",
+  primary: "bg-primary/15 text-primary",
+  red: "bg-red-500/15 text-red-700 dark:text-red-400",
 } as const;
 
 /** A small coloured pill for a status. A button when it has an onClick. */

package/contexts/PaneContext.tsx

@@ -23,11 +23,13 @@ import {
   loadPaneState,
   showDraft,
   MAX_PANES,
+  openBeside as openBesideIn,
+  type OpenSession,
 } from "@/lib/panes";
 import { useViewport } from "@/hooks/useViewport";
 
 export type ViewMode =
-  "terminal" | "files" | "git" | "workers" | "log" | "artifacts";
+  "terminal" | "files" | "git" | "workers" | "log" | "artifacts" | "report";
 
 export interface PaneViewState {
   viewMode: ViewMode;
@@ -59,6 +61,8 @@ interface PaneContextValue {
     hostId?: string
   ) => void;
   detachSession: (paneId: string) => void;
+  // Shows a session beside a pane: its pane if open, else a split or a tab.
+  openBeside: (paneId: string, open: OpenSession) => void;
   openDraft: (paneId: string, draftId: string) => void;
   getPaneData: (paneId: string) => PaneData;
   getActiveTab: (paneId: string) => TabData | null;
@@ -270,6 +274,21 @@ export function PaneProvider({ children }: { children: ReactNode }) {
     []
   );
 
+  // A phone shows one pane: the session takes this one's place.
+  const openBeside = useCallback(
+    (paneId: string, open: OpenSession) => {
+      if (isMobile)
+        attachSession(
+          paneId,
+          open.sessionId,
+          open.tmux,
+          open.hostId ?? undefined
+        );
+      else setState((prev) => openBesideIn(prev, paneId, open));
+    },
+    [isMobile, attachSession]
+  );
+
   // Detach session from active tab
   const detachSession = useCallback((paneId: string) => {
     setState((prev) => {
@@ -393,6 +412,7 @@ export function PaneProvider({ children }: { children: ReactNode }) {
         switchTab,
         attachSession,
         detachSession,
+        openBeside,
         openDraft,
         getPaneData,
         getActiveTab,

package/data/exports/queries.ts

@@ -49,3 +49,14 @@ export async function fetchExport(
     name: exportFileName(title, sel ? rangeSlug(sel) : "all", req.format),
   };
 }
+
+/** One turn as Markdown (secrets masked), and its last agent message. */
+export async function fetchTurnCopy(
+  sessionId: string,
+  startId: string
+): Promise<{ full: string; response: string }> {
+  const res = await post(`/api/sessions/${sessionId}/export/turn`, {
+    startId,
+  });
+  return res.ok ? res.json() : failure(res);
+}

package/data/loops/index.ts

@@ -0,0 +1,3 @@
+export { loopKeys } from "./keys";
+export { useTaskLoop, useLoopSummaries } from "./queries";
+export * from "./mutations";

package/data/loops/keys.ts

@@ -0,0 +1,4 @@
+export const loopKeys = {
+  all: ["loop"] as const,
+  ofTask: (taskId: string) => [...loopKeys.all, "task", taskId] as const,
+};

package/data/loops/mutations.ts

@@ -0,0 +1,68 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import type { CriterionDraft, Limits, LoopView } from "@/lib/loops/types";
+import { loopKeys } from "./keys";
+
+async function call<T>(
+  url: string,
+  method: string,
+  body?: unknown
+): Promise<T> {
+  const res = await fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || "Something went wrong");
+  return data as T;
+}
+
+const base = (taskId: string) =>
+  `/api/tasks/${encodeURIComponent(taskId)}/loop`;
+
+function useAct<I>(run: (input: I) => Promise<unknown>) {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: run,
+    onSettled: () => void client.invalidateQueries({ queryKey: loopKeys.all }),
+  });
+}
+
+export const useDraftCriteria = (taskId: string) =>
+  useMutation({
+    mutationFn: () =>
+      call<{ criteria: CriterionDraft[] }>(
+        `${base(taskId)}/draft-criteria`,
+        "POST",
+        {}
+      ).then((r) => r.criteria),
+  });
+
+export const useStartLoop = (taskId: string) =>
+  useAct((input: { criteria: CriterionDraft[]; limits: Partial<Limits> }) =>
+    call<{ view: LoopView }>(base(taskId), "POST", input)
+  );
+
+export interface LoopEdit {
+  extend?: { cycles?: number; costUsd?: number; minutes?: number };
+  addCriteria?: CriterionDraft[];
+  editCriteria?: { id: number; text: string }[];
+  removeCriteria?: number[];
+  waive?: number[];
+}
+
+export const useEditLoop = (taskId: string) =>
+  useAct((input: LoopEdit) =>
+    call<{ view: LoopView }>(base(taskId), "PATCH", input)
+  );
+
+export const useStopLoop = (taskId: string) =>
+  useAct(() => call<{ view: LoopView }>(`${base(taskId)}/stop`, "POST", {}));
+
+export const useRunLoop = (taskId: string) =>
+  useAct(() => call<{ view: LoopView }>(`${base(taskId)}/run`, "POST", {}));
+
+export const useNextInstruction = (taskId: string) =>
+  useAct((input: { action: "send" | "hold" | "skip"; instruction?: string }) =>
+    call<{ view: LoopView }>(`${base(taskId)}/next`, "POST", input)
+  );

package/data/loops/queries.ts

@@ -0,0 +1,40 @@
+import { useQuery } from "@tanstack/react-query";
+import type { LoopSummary, LoopView } from "@/lib/loops/types";
+import { usePollWhenOffline } from "../push/connection";
+import { loopKeys } from "./keys";
+
+const base = (taskId: string) =>
+  `/api/tasks/${encodeURIComponent(taskId)}/loop`;
+
+// The task's loop, or null when it has none. Pushed when the loop's tables
+// change; it polls only while the stream is down.
+export function useTaskLoop(taskId: string | undefined, enabled = true) {
+  const poll = usePollWhenOffline(10000);
+  return useQuery({
+    queryKey: loopKeys.ofTask(taskId ?? ""),
+    queryFn: async (): Promise<LoopView | null> => {
+      const res = await fetch(base(taskId!));
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) throw new Error(body.error || "Couldn't load the loop");
+      return body.view ?? null;
+    },
+    enabled: !!taskId && enabled,
+    staleTime: 3000,
+    refetchInterval: poll,
+  });
+}
+
+// The pill of every task that has had a loop lately.
+export function useLoopSummaries() {
+  const poll = usePollWhenOffline(15000);
+  return useQuery({
+    queryKey: [...loopKeys.all, "summaries"] as const,
+    queryFn: async (): Promise<Record<string, LoopSummary | null>> => {
+      const res = await fetch("/api/loops");
+      const body = await res.json().catch(() => ({}));
+      return res.ok ? (body.loops ?? {}) : {};
+    },
+    staleTime: 5000,
+    refetchInterval: poll,
+  });
+}

package/data/push/topics.ts

@@ -20,6 +20,7 @@ import { bookmarkKeys } from "../bookmarks/keys";
 import { learningCardsKeys } from "../learning-cards";
 import { claimKeys } from "../claims/keys";
 import { analystKeys } from "../analyst/keys";
+import { loopKeys } from "../loops/keys";
 
 // What each pushed topic (a table that changed, lib/db/changes.ts, or a
 // pushed view) means the browser should refetch. Only queries on screen
@@ -85,6 +86,11 @@ function keysFor(topic: string): QueryKey[] {
       return [analystKeys.all, sessionKeys.all];
     case "analyst_recommendations":
       return [analystKeys.all];
+    case "task_loops":
+      return [loopKeys.all, sessionKeys.all];
+    case "task_loop_criteria":
+    case "task_loop_cycles":
+      return [loopKeys.all];
     case "chat_bookmarks":
       return [bookmarkKeys.all];
     default:

package/data/reports/index.ts

@@ -0,0 +1,115 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type {
+  OperatingMode,
+  ReportResponse,
+  ReportSummary,
+} from "@/lib/reports/types";
+
+export const reportKeys = {
+  all: ["reports"] as const,
+  task: (id: string) => [...reportKeys.all, "task", id] as const,
+  workspace: (id: string) => [...reportKeys.all, "workspace", id] as const,
+  workspaceMode: (id: string) => [...reportKeys.all, "wmode", id] as const,
+};
+
+async function request<T>(url: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(url, init);
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data as T;
+}
+
+const json = (method: string, body: unknown): RequestInit => ({
+  method,
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify(body),
+});
+
+const GENERATING_POLL_MS = 2000;
+const IDLE_POLL_MS = 30_000;
+
+export function useTaskReport(sessionId: string) {
+  return useQuery({
+    queryKey: reportKeys.task(sessionId),
+    queryFn: () => request<ReportResponse>(`/api/tasks/${sessionId}/report`),
+    refetchInterval: (q) =>
+      q.state.data?.generating ? GENERATING_POLL_MS : IDLE_POLL_MS,
+  });
+}
+
+export function useGenerateReport(sessionId: string) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: () =>
+      request(`/api/tasks/${sessionId}/report`, json("POST", {})),
+    onSuccess: () => {
+      // The next poll sees `generating` and keeps going until it clears.
+      qc.setQueryData<ReportResponse>(reportKeys.task(sessionId), (old) =>
+        old ? { ...old, generating: true } : old
+      );
+      qc.invalidateQueries({ queryKey: reportKeys.task(sessionId) });
+    },
+  });
+}
+
+export interface DraftRef {
+  source: "report" | "analyst";
+  id: string;
+  linkId?: string;
+}
+
+export function useReportDraft(sessionId: string) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (v: DraftRef & { action: "send" | "dismiss"; text?: string }) =>
+      request<ReportResponse>(
+        `/api/tasks/${sessionId}/report/draft`,
+        json("POST", v)
+      ),
+    onSuccess: (data) => qc.setQueryData(reportKeys.task(sessionId), data),
+  });
+}
+
+export function useTaskMode(sessionId: string) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (mode: OperatingMode | null) =>
+      request(`/api/tasks/${sessionId}/mode`, json("PUT", { mode })),
+    onSuccess: () =>
+      qc.invalidateQueries({ queryKey: reportKeys.task(sessionId) }),
+  });
+}
+
+export function useWorkspaceMode(workspaceId: string) {
+  return useQuery({
+    queryKey: reportKeys.workspaceMode(workspaceId),
+    queryFn: async () =>
+      (
+        await request<{ mode: OperatingMode }>(
+          `/api/workspaces/${workspaceId}/mode`
+        )
+      ).mode,
+  });
+}
+
+export function useSetWorkspaceMode(workspaceId: string) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (mode: OperatingMode) =>
+      request(`/api/workspaces/${workspaceId}/mode`, json("PUT", { mode })),
+    onSuccess: () => qc.invalidateQueries({ queryKey: reportKeys.all }),
+  });
+}
+
+export function useWorkspaceReports(workspaceId: string) {
+  return useQuery({
+    queryKey: reportKeys.workspace(workspaceId),
+    queryFn: async () =>
+      (
+        await request<{ reports: ReportSummary[] }>(
+          `/api/workspaces/${workspaceId}/reports?active=1`
+        )
+      ).reports,
+    refetchInterval: IDLE_POLL_MS,
+  });
+}

package/lib/agents/brief.ts

@@ -1,7 +1,7 @@
 // What every agent AgentOS starts is told about waiting; the note sent after
 // AgentOS stops a spinning background job repeats it (lib/health/spin.ts).
 export const WAIT_ADVICE =
-  "To wait for a long command, run it with run_in_background and end your turn; you're woken when it exits. Don't start a second job to poll for the first. Any wait loop must sleep on each pass and test a condition that can actually become true (pgrep for the exact process, a log line), never a fixed sleep.";
+  "To wait for a long command, run it with run_in_background and end your turn; you're woken when it exits. Don't start a second job to poll for the first. Any wait loop must sleep on each pass and test a condition that can actually become true (pgrep for the exact process, a log line), never a fixed sleep. Never wait for a port another process holds: `aos port` gives you a free one.";
 
 // What every agent AgentOS starts is told about the network it's on.
 export const BUS_BRIEF = `You are one of several coding agents running in AgentOS. Other sessions may be working on related projects at the same time, and you can talk to them with the \`aos\` command:

package/lib/analyst/forward.ts

@@ -14,7 +14,7 @@ import { AnalystError, type AnalystLink, type Recommendation } from "./types";
 // so a repeat is a no-op. It waits in the queue while a turn runs.
 export async function forwardToCoder(
   coderSessionId: string,
-  input: { text: string; id: string; label: string; fromSessionId: string }
+  input: { text: string; id: string; label: string; fromSessionId?: string }
 ): Promise<void> {
   await sendChat(coderSessionId, {
     text: input.text,

package/lib/db/changes.ts

@@ -54,6 +54,12 @@ export const TABLES_WATCHED_ANALYST = [
   "analyst_recommendations",
 ] as const;
 
+export const TABLES_WATCHED_LOOPS = [
+  "task_loops",
+  "task_loop_criteria",
+  "task_loop_cycles",
+] as const;
+
 // Every table any migration watches, for the browser's topic map to cover.
 export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_45,
@@ -67,6 +73,7 @@ export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_SESSION_GROUPS,
   ...TABLES_WATCHED_WORK_CLAIMS,
   ...TABLES_WATCHED_ANALYST,
+  ...TABLES_WATCHED_LOOPS,
 ];
 
 export function installChangeTriggers(

package/lib/db/migrations/20261021T1600_task_loops.ts

@@ -0,0 +1,81 @@
+import type { Migration } from "../migration-types";
+import { installChangeTriggers, TABLES_WATCHED_LOOPS } from "../changes";
+
+export default {
+  key: "20261021T1600_task_loops",
+  up: (db) => {
+    // The developer-analyst loop (lib/loops): one loop per run on a task, its
+    // acceptance checklist, and one row per cycle. Rows are kept for good.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS task_loops (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        workspace_id TEXT,
+        state TEXT NOT NULL DEFAULT 'running',
+        stop_reason TEXT,
+        stop_detail TEXT,
+        goal TEXT NOT NULL DEFAULT '',
+        max_cycles INTEGER NOT NULL,
+        max_cost_usd REAL NOT NULL,
+        max_minutes INTEGER NOT NULL,
+        grace_seconds INTEGER NOT NULL,
+        stall_cycles INTEGER NOT NULL,
+        repeat_cycles INTEGER NOT NULL,
+        cost_base_usd REAL NOT NULL DEFAULT 0,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER,
+        last_cycle_at INTEGER,
+        run_now INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS task_loops_live
+        ON task_loops(session_id) WHERE state = 'running';
+      CREATE INDEX IF NOT EXISTS task_loops_session
+        ON task_loops(session_id, started_at);
+      CREATE TABLE IF NOT EXISTS task_loop_criteria (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        loop_id TEXT NOT NULL,
+        position INTEGER NOT NULL,
+        text TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'user',
+        evidence_kind TEXT,
+        status TEXT NOT NULL DEFAULT 'open',
+        evidence TEXT,
+        verified INTEGER NOT NULL DEFAULT 1,
+        met_cycle INTEGER,
+        waived_by TEXT,
+        removed INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS task_loop_criteria_loop
+        ON task_loop_criteria(loop_id, position);
+      CREATE TABLE IF NOT EXISTS task_loop_cycles (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        loop_id TEXT NOT NULL,
+        n INTEGER NOT NULL,
+        trigger TEXT NOT NULL,
+        state TEXT NOT NULL DEFAULT 'claimed',
+        snapshot_sha TEXT,
+        tree TEXT,
+        changed INTEGER NOT NULL DEFAULT 1,
+        evidence TEXT,
+        log_path TEXT,
+        analysis TEXT,
+        signature TEXT,
+        score TEXT,
+        instruction TEXT,
+        instruction_sent TEXT,
+        sender TEXT,
+        delivery TEXT,
+        send_at INTEGER,
+        input TEXT,
+        cost_usd REAL NOT NULL DEFAULT 0,
+        error TEXT,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS task_loop_cycles_n
+        ON task_loop_cycles(loop_id, n);
+    `);
+    // The loop view refetches when any of them changes.
+    installChangeTriggers(db, TABLES_WATCHED_LOOPS);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261021T1800_health_reports.ts

@@ -0,0 +1,38 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261021T1800_health_reports",
+  up: (db) => {
+    // Plain-English health reports (lib/reports): one row per report, the
+    // report itself as JSON, and the next-prompt draft of a task with no
+    // analyst. Rows are kept for good.
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS health_reports (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        workspace_id TEXT,
+        head TEXT,
+        trigger TEXT NOT NULL,
+        evidence_hash TEXT NOT NULL,
+        data TEXT NOT NULL,
+        model TEXT,
+        cost_usd REAL,
+        draft_text TEXT,
+        draft_status TEXT,
+        draft_decided_at TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS health_reports_session
+        ON health_reports(session_id, id);
+      -- The operating mode (manual / assisted / autonomous) of a workspace
+      -- (the default) or of one task (the override).
+      CREATE TABLE IF NOT EXISTS operating_modes (
+        scope TEXT NOT NULL,
+        scope_id TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (scope, scope_id)
+      );
+    `);
+  },
+} satisfies Migration;

package/lib/done/index.ts

@@ -33,6 +33,7 @@ import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
 import { hostLink } from "../hosts/remote-api";
 import { doneHeldTask, isHeldRemote } from "../tasks/contract/held-calls";
 import { captureMergedTask } from "../session-logs";
+import { taskEnded } from "../reports/end-hook";
 import { sessionEnded } from "../experiments/hooks";
 import { pushMerged } from "../notify/push/events";
 import { setPr, setTask } from "../db/session-parts";
@@ -119,6 +120,7 @@ function mark(s: Session, status: "merged" | "done", pr: TaskPR | null) {
   if (status === "merged") {
     pushMerged(s.id);
     void captureMergedTask(s.id, { head: pr?.head });
+    taskEnded(s.id);
   }
 }
 

package/lib/drafts.ts

@@ -33,6 +33,8 @@ export interface Draft {
   // binding picks the model; roleModel overrides it for this session.
   agentRole?: string | null;
   roleModel?: string | null;
+  // Pair it with an analyst that reviews each turn (a local chat only).
+  withAnalyst?: boolean;
   // A task's priority in the queue; unset: normal.
   taskPriority?: Priority;
   createdAt: number;

package/lib/export/markdown.ts

@@ -25,7 +25,10 @@ const quote = (s: string) =>
     .map((l) => (l ? `> ${l}` : ">"))
     .join("\n");
 
-function itemMd(i: ExportItem): string {
+export const UNAVAILABLE = "[output unavailable]";
+export const UNAVAILABLE_RUNNING = "[output unavailable: tool still running]";
+
+export function itemMd(i: ExportItem): string {
   const t = clock(i.at);
   switch (i.kind) {
     case "user": {
@@ -59,6 +62,9 @@ function itemMd(i: ExportItem): string {
         );
       if (i.diff?.patch) parts.push(fenced(i.diff.patch, "diff"));
       if (i.output) parts.push(`Output:\n\n${fenced(i.output)}`);
+      else if (i.status === "running") parts.push(UNAVAILABLE_RUNNING);
+      else if (i.status === "stopped" || i.status === "error")
+        parts.push(UNAVAILABLE);
       return parts.join("\n\n");
     }
     case "command_output":