@saadnvd1/agent-os 0.3.833 → 0.3.839

package/components/Workspaces/WorkspaceSettings.tsx

@@ -1,17 +1,20 @@
 "use client";
 
-import { SettingToggle } from "@/components/Settings/SettingToggle";
+import { settingsUiActions } from "@/stores/settingsUi";
 import { useUpdateWorkspace, useWorkspacesQuery } from "@/data/workspaces";
-import { TaskLimitForm } from "./TaskLimitForm";
 import { RulesForm } from "./RulesForm";
-import { FreshStartForm } from "./FreshStartForm";
 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";
+import { AppWideLimits } from "@/components/Settings/AppWideLimits";
+import {
+  NumberSetting,
+  SwitchSetting,
+} from "@/components/Settings/settings-fields";
+import { SettingSection } from "@/components/Settings/SettingRow";
+import { SETTING_DEFAULTS } from "@/lib/settings/defaults";
 
 // Settings > Workspaces: each workspace's own settings.
 export function WorkspaceSettings() {
@@ -43,33 +46,67 @@ export function WorkspaceSettings() {
           className="bg-muted/40 space-y-3 rounded-lg px-3 py-3"
         >
           <h3 className="truncate text-sm font-medium">{w.name}</h3>
-          <TaskLimitForm
-            key={`${w.id}:${w.max_running_tasks ?? "off"}`}
-            workspace={w}
-          />
+          <SettingSection>
+            <NumberSetting
+              id={`task-limit-${w.id}`}
+              label="Tasks at a time"
+              help="Cap on tasks running at once. The rest wait in Queued and start in order."
+              value={w.max_running_tasks ?? 0}
+              defaultValue={0}
+              onSave={(n) =>
+                update.mutateAsync({
+                  id: w.id,
+                  maxRunningTasks: n === 0 ? null : n,
+                })
+              }
+              min={1}
+              integer
+              unit="at a time"
+              optional={{ off: 0, on: SETTING_DEFAULTS.taskLimitOn }}
+            />
+          </SettingSection>
           <WorkspaceModeForm workspaceId={w.id} />
           <RulesForm workspaceId={w.id} />
           <WorkspaceModelsForm workspaceId={w.id} />
           <McpServersForm workspace={w} />
           <HqFolderForm workspaceId={w.id} />
           <ProjectTiersForm workspaceId={w.id} />
-          <SettingToggle
-            title="Wake tasks on CI failures and reviews"
-            detail="A task's agent is messaged once when a check fails on its PR's head, with the log's tail, and when someone reviews or comments on it."
-            checked={w.wake_tasks_on_pr}
-            onChange={(on) => update.mutate({ id: w.id, wakeTasksOnPR: on })}
-          />
-          <SettingToggle
-            title="Orchestrator full access"
-            detail="Its shell and file writes aren't checked: it can push, commit, edit any repository or file on this machine, and merge a PR directly, and edit .claude files (skills, settings, hooks). Applies when its conversation next restarts. Off: the deny list, write limits, quick-change cap and merge-only-through-the-gates apply."
-            checked={w.orch_full_access}
-            onChange={(on) => update.mutate({ id: w.id, orchFullAccess: on })}
-          />
+          <SettingSection>
+            <SwitchSetting
+              id={`wake-${w.id}`}
+              label="Wake tasks on CI failures and reviews"
+              help="A task's agent is messaged once when a check fails on its PR, and when someone reviews or comments."
+              checked={w.wake_tasks_on_pr}
+              onSave={(on) =>
+                update.mutateAsync({ id: w.id, wakeTasksOnPR: on })
+              }
+            />
+            <SwitchSetting
+              id={`full-access-${w.id}`}
+              label="Orchestrator full access"
+              help="Its shell and file writes aren't checked. Applies when its conversation next restarts."
+              checked={w.orch_full_access}
+              confirm="Let this orchestrator act without approval? It can push, commit, edit any repository or file on this machine, merge a PR directly, and edit .claude files. Off: the deny list, write limits and merge-only-through-the-gates apply."
+              confirmLabel="Turn on full access"
+              onSave={(on) =>
+                update.mutateAsync({ id: w.id, orchFullAccess: on })
+              }
+            />
+          </SettingSection>
         </section>
       ))}
-      <FreshStartForm />
-      <StallForm />
-      <AwayWindowForm />
+      <AppWideLimits />
+      <p className="text-muted-foreground text-sm">
+        Fresh starts and compaction are app-wide:{" "}
+        <button
+          type="button"
+          className="text-primary underline-offset-2 hover:underline"
+          onClick={() => settingsUiActions.show("context")}
+        >
+          open Context
+        </button>
+        .
+      </p>
     </div>
   );
 }

package/content/whats-new.json

@@ -1953,6 +1953,38 @@
       "area": "AgentOS",
       "text": "Select text in a chat reply and tap Fork to hand it to a background copy of the session; its result comes back as a card.",
       "url": "https://github.com/saadnvd1/agent-os/pull/558"
+    },
+    {
+      "id": 560,
+      "date": "2026-11-02",
+      "kind": "fixed",
+      "area": "Chat",
+      "text": "You can ask follow-up questions in a task's chat after its work has merged, with a note that changes need a new task.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/560"
+    },
+    {
+      "id": 561,
+      "date": "2026-11-02",
+      "kind": "improved",
+      "area": "AgentOS",
+      "text": "Forking from a selection is tidier: the fork pill can be dismissed while keeping your quote and text, and started forks show a one-line marker and what they're doing.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/561"
+    },
+    {
+      "id": 562,
+      "date": "2026-11-02",
+      "kind": "improved",
+      "area": "Settings",
+      "text": "Settings now save as you change them, with a clear \"Saved\" note, undo and reset, and Context settings have their own page.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/562"
+    },
+    {
+      "id": 563,
+      "date": "2026-11-02",
+      "kind": "improved",
+      "area": "Settings",
+      "text": "More settings now save as you change them, and revoking a passkey or link asks inline instead of with a browser pop-up.",
+      "url": "https://github.com/saadnvd1/agent-os/pull/563"
     }
   ]
 }

package/data/fresh-start/index.ts

@@ -24,7 +24,7 @@ export function useUpdateFreshStart() {
     mutationFn: async (settings: Partial<RefreshSettings>) =>
       json<RefreshSettings>(
         await fetch("/api/fresh-start", {
-          method: "PUT",
+          method: "PATCH",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify(settings),
         })

package/data/workspaces/index.ts

@@ -87,6 +87,9 @@ export function useUpdateWorkspace() {
       ...updates
     }) => {
       await queryClient.cancelQueries({ queryKey: workspaceKeys.list() });
+      const previous = queryClient.getQueryData<Workspace[]>(
+        workspaceKeys.list()
+      );
       queryClient.setQueryData<Workspace[]>(workspaceKeys.list(), (prev) =>
         prev?.map((w) =>
           w.id === id
@@ -109,6 +112,12 @@ export function useUpdateWorkspace() {
             : w
         )
       );
+      return { previous };
+    },
+    // A rejected change rolls back to what the server holds.
+    onError: (_err, _vars, context) => {
+      if (context?.previous)
+        queryClient.setQueryData(workspaceKeys.list(), context.previous);
     },
     onSettled: () =>
       queryClient.invalidateQueries({ queryKey: workspaceKeys.all }),

package/hooks/useAutoSave.test.ts

@@ -0,0 +1,116 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useAutoSave, type AutoSave } from "./useAutoSave";
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let root: Root;
+let host: HTMLElement;
+afterEach(async () => {
+  await act(async () => root.unmount());
+  host.remove();
+  vi.useRealTimers();
+});
+
+// A server whose value the hook is given back as `saved`, like a query.
+async function mount(
+  save: (n: number) => Promise<unknown>,
+  notify = vi.fn(),
+  initial = 10
+) {
+  const box: { auto: AutoSave<number> } = {} as never;
+  let saved = initial;
+  const Probe = ({ value }: { value: number }) => {
+    box.auto = useAutoSave({
+      saved: value,
+      save: async (n) => {
+        await save(n);
+        saved = n;
+      },
+      notify,
+    });
+    return null;
+  };
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+  const render = () =>
+    act(async () => root.render(createElement(Probe, { value: saved })));
+  await render();
+  return { box, render, notify };
+}
+
+describe("useAutoSave", () => {
+  it("saves a new value and says Saved, then goes quiet", async () => {
+    vi.useFakeTimers();
+    const save = vi.fn().mockResolvedValue(undefined);
+    const { box, render } = await mount(save);
+    await act(async () => void (await box.auto.commit(20)));
+    await render();
+    expect(save).toHaveBeenCalledWith(20);
+    expect(box.auto.value).toBe(20);
+    expect(box.auto.status).toBe("saved");
+    await act(async () => void vi.advanceTimersByTime(2000));
+    expect(box.auto.status).toBe("idle");
+  });
+
+  it("sends nothing for the value it already has", async () => {
+    const save = vi.fn().mockResolvedValue(undefined);
+    const { box } = await mount(save);
+    await act(async () => void (await box.auto.commit(10)));
+    expect(save).not.toHaveBeenCalled();
+    expect(box.auto.status).toBe("idle");
+  });
+
+  it("shows the value while saving", async () => {
+    let finish!: () => void;
+    const save = vi.fn(() => new Promise<void>((r) => (finish = r)));
+    const { box } = await mount(save);
+    let done!: Promise<boolean>;
+    await act(async () => void (done = box.auto.commit(20)));
+    expect(box.auto.status).toBe("saving");
+    expect(box.auto.value).toBe(20);
+    await act(async () => {
+      finish();
+      await done;
+    });
+  });
+
+  it("rolls back to the saved value and tells the user when the server rejects", async () => {
+    const save = vi.fn().mockRejectedValue(new Error("Must be 50 or more"));
+    const { box, notify } = await mount(save);
+    let ok = true;
+    await act(async () => void (ok = await box.auto.commit(20)));
+    expect(ok).toBe(false);
+    expect(box.auto.value).toBe(10);
+    expect(box.auto.status).toBe("idle");
+    expect(notify).toHaveBeenCalledWith("Must be 50 or more");
+  });
+
+  it("undoes an undoable change by saving the old value back", async () => {
+    const save = vi.fn().mockResolvedValue(undefined);
+    const { box, render } = await mount(save);
+    await act(async () => void (await box.auto.commit(0, { undoable: true })));
+    await render();
+    expect(box.auto.status).toBe("undo");
+    await act(async () => void (await box.auto.undo()));
+    await render();
+    expect(save).toHaveBeenLastCalledWith(10);
+    expect(box.auto.value).toBe(10);
+    expect(box.auto.status).toBe("saved");
+  });
+
+  it("has nothing to undo after a plain change", async () => {
+    const save = vi.fn().mockResolvedValue(undefined);
+    const { box } = await mount(save);
+    await act(async () => void (await box.auto.commit(20)));
+    let ok = true;
+    await act(async () => void (ok = await box.auto.undo()));
+    expect(ok).toBe(false);
+    expect(save).toHaveBeenCalledTimes(1);
+  });
+});

package/hooks/useAutoSave.ts

@@ -0,0 +1,98 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
+
+export type SaveStatus = "idle" | "saving" | "saved" | "undo";
+
+const SAVED_MS = 1800;
+const UNDO_MS = 7000;
+
+export interface AutoSave<T> {
+  // What to show: the value in flight while saving, else the saved one. A
+  // rejected save drops the in-flight value, so this is the saved one again.
+  value: T;
+  status: SaveStatus;
+  // Commit a new value. `undoable` keeps the previous one for Undo (large or
+  // destructive changes). Resolves false when the server rejected it.
+  commit: (next: T, opts?: { undoable?: boolean }) => Promise<boolean>;
+  undo: () => Promise<boolean>;
+}
+
+/**
+ * Save a setting the moment it changes. `saved` is the server's value
+ * (the query's); `save` sends one value and throws to reject it.
+ */
+export function useAutoSave<T>({
+  saved,
+  save,
+  equals = Object.is,
+  notify = (message) => toast.error(message),
+}: {
+  saved: T;
+  save: (next: T) => Promise<unknown>;
+  equals?: (a: T, b: T) => boolean;
+  notify?: (message: string) => void;
+}): AutoSave<T> {
+  const [pending, setPending] = useState<{ value: T } | null>(null);
+  const [status, setStatus] = useState<SaveStatus>("idle");
+  const previous = useRef<{ value: T } | null>(null);
+  const timer = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+  const seq = useRef(0);
+  const latest = useRef({ saved, save, equals, notify });
+  useEffect(() => {
+    latest.current = { saved, save, equals, notify };
+  });
+  useEffect(() => () => clearTimeout(timer.current), []);
+
+  const settle = useCallback((next: SaveStatus, ms: number) => {
+    setStatus(next);
+    clearTimeout(timer.current);
+    timer.current = setTimeout(() => setStatus("idle"), ms);
+  }, []);
+
+  const run = useCallback(
+    async (next: T, undoable: boolean, before: T) => {
+      const mine = ++seq.current;
+      clearTimeout(timer.current);
+      setPending({ value: next });
+      setStatus("saving");
+      try {
+        await latest.current.save(next);
+      } catch (err) {
+        if (mine === seq.current) {
+          setPending(null);
+          setStatus("idle");
+        }
+        latest.current.notify(
+          err instanceof Error ? err.message : "Couldn't save"
+        );
+        return false;
+      }
+      if (mine !== seq.current) return true;
+      setPending(null);
+      previous.current = undoable ? { value: before } : null;
+      settle(undoable ? "undo" : "saved", undoable ? UNDO_MS : SAVED_MS);
+      return true;
+    },
+    [settle]
+  );
+
+  const commit = useCallback(
+    (next: T, opts?: { undoable?: boolean }) => {
+      const { saved: current, equals: same } = latest.current;
+      if (same(next, current)) return Promise.resolve(true);
+      return run(next, !!opts?.undoable, current);
+    },
+    [run]
+  );
+
+  const undo = useCallback(async () => {
+    const back = previous.current;
+    if (!back) return false;
+    previous.current = null;
+    return run(back.value, false, latest.current.saved);
+  }, [run]);
+
+  return { value: pending ? pending.value : saved, status, commit, undo };
+}

package/lib/away/window-limits.ts

@@ -1,6 +1,8 @@
+import { SETTING_DEFAULTS } from "../settings/defaults";
+
 // The Away window's bounds, in minutes, for the server (./activity) and
 // the Settings form alike. Client-safe: no database.
-export const DEFAULT_WINDOW_MINUTES = 60;
+export const DEFAULT_WINDOW_MINUTES = SETTING_DEFAULTS.awayWindowMinutes;
 export const MIN_WINDOW_MINUTES = 10;
 export const MAX_WINDOW_MINUTES = 24 * 60;
 

package/lib/chat/refresh.ts

@@ -6,7 +6,7 @@
  * default: its state is in the database and its brief carries it
  * (lib/orchestrator/digest). A task keeps its progress only in its
  * conversation and its branch, so for tasks it's off unless switched on.
- * App-wide, in Settings → Workspaces, with the two sizes at which chats and
+ * App-wide, in Settings → Context, with the two sizes at which chats and
  * tasks compact: mid-turn (Claude Code itself, high so a job keeps its
  * files) and between turns (lib/chat/stale, earlier, nothing in flight).
  */
@@ -15,24 +15,28 @@ import { db } from "../db";
 import { effectiveModels } from "../models/config";
 import { type ModelRole } from "../models/roles";
 import { sessionRole } from "../models/session-role";
+import { SETTING_DEFAULTS } from "../settings/defaults";
 import { MAX_REFRESH_TOKENS, MIN_REFRESH_TOKENS } from "./refresh-limits";
 
 export const ORCHESTRATOR_KEY = "orchestrator.refresh_tokens";
 export const TASK_KEY = "chat.task_refresh_tokens";
 // Named for what it first did: compact chats idle past their cache.
 export const COMPACT_KEY = "chat.stale_compact_tokens";
-export const DEFAULT_ORCHESTRATOR_TOKENS = 200_000;
-export const DEFAULT_COMPACT_TOKENS = 150_000;
+export const DEFAULT_ORCHESTRATOR_TOKENS =
+  SETTING_DEFAULTS.fresh.orchestratorTokens;
+export const DEFAULT_COMPACT_TOKENS = SETTING_DEFAULTS.fresh.compactTokens;
 // Claude Code's own mid-turn auto-compact window: high, because a summary
 // mid-job costs the agent its files and its place.
 export const AUTO_COMPACT_KEY = "chat.auto_compact_tokens";
-export const DEFAULT_AUTO_COMPACT_TOKENS = 300_000;
+export const DEFAULT_AUTO_COMPACT_TOKENS =
+  SETTING_DEFAULTS.fresh.autoCompactTokens;
 // The same window for a person's own (interactive) sessions, which run long
 // on the biggest model. 300k (DEFAULT_AUTO_COMPACT_TOKENS) was its value
 // before it had its own setting: set it back to restore that.
 export const INTERACTIVE_AUTO_COMPACT_KEY =
   "chat.interactive_auto_compact_tokens";
-export const DEFAULT_INTERACTIVE_AUTO_COMPACT_TOKENS = 300_000;
+export const DEFAULT_INTERACTIVE_AUTO_COMPACT_TOKENS =
+  SETTING_DEFAULTS.fresh.interactiveAutoCompactTokens;
 export { MIN_REFRESH_TOKENS, MAX_REFRESH_TOKENS } from "./refresh-limits";
 
 export interface RefreshSettings {
@@ -60,7 +64,7 @@ function read(key: string, fallback: number): number {
 export function refreshSettings(): RefreshSettings {
   return {
     orchestratorTokens: read(ORCHESTRATOR_KEY, DEFAULT_ORCHESTRATOR_TOKENS),
-    taskTokens: read(TASK_KEY, 0),
+    taskTokens: read(TASK_KEY, SETTING_DEFAULTS.fresh.taskTokens),
     compactTokens: read(COMPACT_KEY, DEFAULT_COMPACT_TOKENS),
     autoCompactTokens: read(AUTO_COMPACT_KEY, DEFAULT_AUTO_COMPACT_TOKENS),
     interactiveAutoCompactTokens: read(

package/lib/chat/socket.ts

@@ -32,6 +32,7 @@ import {
 import { setComposerModel } from "../models/session-model";
 import { stopChatTurn } from "./stop";
 import { clientSend } from "./client-send";
+import { startFailureMessage } from "./start-error";
 import { searchChat } from "./search";
 import { DEMO_CHAT_READS, handleDemoChat } from "./demo";
 import { titleChatFromMessage } from "../session-titles";
@@ -97,7 +98,7 @@ export function serveChatSocket(
   const fail = (err: unknown) => {
     console.error(`[chat ${sessionId}] message failed:`, err);
     if (!sessionExists(sessionId)) return gone();
-    reply(errorItem(err instanceof Error ? err.message : String(err)));
+    reply(errorItem(startFailureMessage(err)));
   };
 
   if (!sessionExists(sessionId)) return gone();
@@ -157,9 +158,12 @@ function onChatMessage(
           reply({
             type: "send_failed",
             id,
-            message: err instanceof Error ? err.message : String(err),
+            message: startFailureMessage(err),
           });
-        fail(err);
+        // A message with an id shows its failure on itself; the rest of the
+        // chat hears of it once, here.
+        if (id) console.error(`[chat ${sessionId}] send failed:`, err);
+        else fail(err);
       }
     );
     // "Session 4" is named after its first message.

package/lib/chat/stall-limits.ts

@@ -1,5 +1,7 @@
+import { SETTING_DEFAULTS } from "../settings/defaults";
+
 // The range the stall alert may take (lib/chat/stall), shared with the
 // settings form.
-export const DEFAULT_STALL_MINUTES = 8;
+export const DEFAULT_STALL_MINUTES = SETTING_DEFAULTS.stallMinutes;
 export const MIN_STALL_MINUTES = 2;
 export const MAX_STALL_MINUTES = 120;

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;