@saadnvd1/agent-os 0.3.547 → 0.3.548

package/app/api/bus/archive/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from "next/server";
+import { resolveSession } from "@/lib/bus";
+import { getDoneTarget } from "@/lib/done";
+import { archiveChecked } from "@/lib/done/archive";
+import { inScope, scopeOf } from "@/lib/done/bulk";
+
+// `aos archive <session>`, from inside a session: reaches only the caller's
+// workspace (or its project when it has none).
+export async function POST(request: NextRequest) {
+  try {
+    const { from = null, session } = await request.json();
+    if (typeof from !== "string" || !from)
+      throw new Error("aos archive runs from inside an AgentOS session");
+    const caller = getDoneTarget(from);
+    const scope = scopeOf(caller);
+    const target = resolveSession(String(session ?? ""));
+    if (!inScope(scope, target))
+      throw new Error(
+        `${target.name} isn't in ${caller.name}'s ${"workspaceId" in scope ? "workspace" : "project"}; aos archive reaches only those`
+      );
+    await archiveChecked(target.id);
+    return NextResponse.json({ summary: `Archived: ${target.name}.` });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/app/api/sessions/[id]/archive/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from "next/server";
+import { archiveChecked } from "@/lib/done/archive";
+
+// POST /api/sessions/:id/archive - put a session away, out of the sidebar.
+// 409 with the reason when refused.
+export async function POST(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const session = await archiveChecked((await params).id);
+    return NextResponse.json({ session });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/components/SessionList/SessionRowMenu.tsx

@@ -31,7 +31,8 @@ import { selectionActions } from "@/stores/sessionSelection";
 import { schedulesUiActions } from "@/stores/schedulesUi";
 import { recipesUiActions } from "@/stores/recipesUi";
 import { rowGroup } from "@/lib/recipes/chip";
-import { useDoneAction } from "./useDoneAction";
+import { finishActions } from "@/lib/sidebar/row-actions";
+import { useArchiveAction, useDoneAction } from "./useDoneAction";
 import { useShelfActions } from "./useShelfActions";
 import { SNOOZE_PRESETS, snoozePreset, wakeLabel } from "@/lib/sidebar/snooze";
 import type { SidebarRow } from "@/lib/sidebar/shelves";
@@ -84,6 +85,37 @@ function BlockedItem({ kind, icon: Icon, label, why }: BlockedProps) {
   );
 }
 
+// Done and Archive, as the session's kind allows.
+function FinishItems({
+  session,
+  plain,
+  Item,
+}: {
+  session: Session;
+  plain: boolean;
+  Item: (typeof PARTS)[keyof typeof PARTS]["Item"];
+}) {
+  const markDone = useDoneAction();
+  const archive = useArchiveAction();
+  const actions = finishActions(session, plain);
+  return (
+    <>
+      {actions.includes("done") && (
+        <Item onClick={() => markDone(session)}>
+          <CircleCheck className={icon} />
+          Done
+        </Item>
+      )}
+      {actions.includes("archive") && (
+        <Item onClick={() => archive(session)}>
+          <Archive className={icon} />
+          Archive
+        </Item>
+      )}
+    </>
+  );
+}
+
 // The row's ⋯ menu (and right-click menu): everything a session can do.
 export function SessionRowMenu({
   session,
@@ -98,7 +130,6 @@ export function SessionRowMenu({
   onRename: () => void;
 }) {
   const ctx = useRowContext();
-  const markDone = useDoneAction();
   const shelf = useShelfActions();
   const plain = !!row && !row.task && !session.task_status;
   const { Item, Separator, Sub, SubTrigger, SubContent } = PARTS[kind];
@@ -342,14 +373,7 @@ export function SessionRowMenu({
                 Mark done
               </Item>
             ))}
-          <Item onClick={() => markDone(session)}>
-            {plain ? (
-              <Archive className={icon} />
-            ) : (
-              <CircleCheck className={icon} />
-            )}
-            {plain ? "Archive" : "Done"}
-          </Item>
+          <FinishItems session={session} plain={plain} Item={Item} />
           <Item
             onClick={() => ctx.onDelete(session.id)}
             className="text-red-500 focus:text-red-500"

package/components/SessionList/useDoneAction.ts

@@ -1,12 +1,17 @@
 import { toast } from "sonner";
 import type { Session } from "@/lib/db";
-import { useDoneSession, useUnarchiveSession } from "@/data/done";
+import {
+  useArchiveSession,
+  useDoneSession,
+  useUnarchiveSession,
+} from "@/data/done";
+import { useSettleSession } from "@/data/sessions/shelf";
 
 // Done from a session's menu: an open PR merges through the gates, so that
 // one asks first; the rest can be undone from the toast.
 export function useDoneAction() {
   const done = useDoneSession();
-  const unarchive = useUnarchiveSession();
+  const settle = useSettleSession();
   return (session: Session) => {
     const merges =
       session.task_status === "running" && session.pr_status === "open";
@@ -21,17 +26,19 @@ export function useDoneAction() {
       merges ? `Merging ${session.name}…` : `Finishing ${session.name}…`
     );
     done.mutate(session.id, {
-      // Undo only puts the entry back: offered only when that's all done did.
+      // Undo only reopens the entry: offered only when that's all done did.
       onSuccess: (outcome) =>
         toast.success(outcome.text, {
           id,
           duration: 8000,
           ...(!outcome.merged &&
+            !session.task_status &&
             outcome.worktree.action !== "removed" &&
             outcome.worktree.action !== "gone" && {
               action: {
                 label: "Undo",
-                onClick: () => unarchive.mutate(session.id),
+                onClick: () =>
+                  settle.mutate({ id: session.id, settled: false }),
               },
             }),
         }),
@@ -39,3 +46,20 @@ export function useDoneAction() {
     });
   };
 }
+
+// Archive from a session's menu: puts it away; Unarchive brings it back.
+export function useArchiveAction() {
+  const archive = useArchiveSession();
+  const unarchive = useUnarchiveSession();
+  return (session: Session) =>
+    archive.mutate(session.id, {
+      onSuccess: () =>
+        toast.success(`Archived ${session.name}`, {
+          action: {
+            label: "Undo",
+            onClick: () => unarchive.mutate(session.id),
+          },
+        }),
+      onError: (e) => toast.error(e.message, { duration: 12000 }),
+    });
+}

package/data/done/index.ts

@@ -46,6 +46,12 @@ export function useDoneSession() {
   );
 }
 
+export function useArchiveSession() {
+  return useDoneMutation(async (id: string) =>
+    json(await post(`/api/sessions/${id}/archive`))
+  );
+}
+
 export function useDoneIdle() {
   return useDoneMutation(async (workspaceId: string) =>
     json<BulkResult>(await post("/api/sessions/done-idle", { workspaceId }))

package/lib/done/archive.ts

@@ -2,7 +2,9 @@
 // orchestrator's view, but kept with their history and chat items.
 
 import fs from "fs";
-import { db, type Session } from "../db";
+import { db, queries, type Session } from "../db";
+import { statusOf } from "../orchestrator/facts";
+import { peerSessionLink } from "../hosts/peer-actions";
 
 export interface ArchivedView {
   id: string;
@@ -73,3 +75,27 @@ export function listArchived(workspaceId?: string): ArchivedView[] {
     archivedAt: s.archived_at!,
   }));
 }
+
+// Puts a session away on purpose. Nothing is merged or stopped here: an
+// agent still working, a task with an open PR and an orchestrator stay.
+export async function archiveChecked(id: string): Promise<Session> {
+  const s = queries.getSession(db).get(id) as Session | undefined;
+  if (!s) throw new Error("Session not found");
+  if (s.archived_at) throw new Error(`${s.name} is already archived`);
+  if (s.role === "orchestrator")
+    throw new Error(
+      `${s.name} is a workspace's orchestrator; it can't be archived`
+    );
+  if (peerSessionLink(s))
+    throw new Error(`${s.name} runs on another machine: archive it there`);
+  if (s.task_status === "running" && s.pr_status === "open")
+    throw new Error(
+      `${s.name} has an open PR: Done it first, which merges it through the gates`
+    );
+  if ((await statusOf(s)).status === "running")
+    throw new Error(
+      `${s.name} is still working: wait for it, or stop it first`
+    );
+  archiveSession(s.id);
+  return queries.getSession(db).get(id) as Session;
+}

package/lib/done/auto-archive.ts

@@ -0,0 +1,67 @@
+// Done holds finished work; a session that has sat there for
+// ARCHIVE_AFTER_MS with no activity is put away by itself. Never a pinned
+// session, an orchestrator, one that needs input or is working, or one with
+// an open PR. Mirrors the sidebar's Done placement (lib/sidebar/shelves).
+
+import { db, type Session } from "../db";
+import { fromSqliteTime } from "../session-meta";
+import { statusOf } from "../orchestrator/facts";
+import { statusDetector } from "../status-detector";
+import { activeMs, ARCHIVE_AFTER_MS, snoozedUntil } from "../sidebar/shelves";
+import { archiveSession } from "./archive";
+
+export const AUTO_ARCHIVE_EVERY_MS = 60 * 60_000;
+
+const ms = (t: string | null | undefined) =>
+  t ? fromSqliteTime(t).getTime() : 0;
+
+// When a Done row last changed: its last activity, or when it was marked.
+function sinceMs(s: Session, now: number): number {
+  return Math.max(
+    activeMs(s, now),
+    ms(s.settled_at),
+    s.task_status ? ms(s.updated_at) : 0
+  );
+}
+
+// A task is in Done once finished; a plain session that has been quiet this
+// long has long since settled.
+const inDone = (s: Session) =>
+  !s.task_status ||
+  ["merged", "dropped", "done", "moved"].includes(s.task_status);
+
+export async function archiveStaleDone(now = Date.now()): Promise<string[]> {
+  const rows = db
+    .prepare(
+      `SELECT * FROM sessions
+       WHERE archived_at IS NULL AND pinned = 0 AND role IS NULL
+         AND peer_mirror = 0 AND quick_of IS NULL
+         AND (pr_status IS NULL OR pr_status != 'open')`
+    )
+    .all() as Session[];
+  const stale = rows.filter(
+    (s) =>
+      now - sinceMs(s, now) >= ARCHIVE_AFTER_MS &&
+      !snoozedUntil(s, now) &&
+      inDone(s)
+  );
+  if (!stale.length) return [];
+  await statusDetector.refreshCache();
+  const archived: string[] = [];
+  for (const s of stale) {
+    const { status, needsInput } = await statusOf(s);
+    if (needsInput || (status !== "idle" && status !== "dead")) continue;
+    archiveSession(s.id);
+    archived.push(s.id);
+  }
+  return archived;
+}
+
+export function startAutoArchive(): void {
+  const run = () =>
+    archiveStaleDone().catch((error) =>
+      console.error("Archiving stale Done sessions failed:", error)
+    );
+  void run();
+  setInterval(run, AUTO_ARCHIVE_EVERY_MS);
+}

package/lib/done/bulk.ts

@@ -1,6 +1,6 @@
 /**
- * Clean-up: done for every idle or stopped session in a project or a
- * workspace, each judged on its own. It never merges: a session with an
+ * Clean-up: done, then archived, for every idle or stopped session in a
+ * project or a workspace, each judged on its own. It never merges: a session with an
  * open PR is listed for its own done, which merges through the gates.
  * The preview says what will happen to each before anything does.
  */
@@ -11,6 +11,7 @@ import { workspaceProjects } from "../orchestrator/brief";
 import { statusOf } from "../orchestrator/facts";
 import { statusDetector } from "../status-detector";
 import { doneSession, type DoneOptions, type DoneOutcome } from "./index";
+import { archiveSession } from "./archive";
 import { planDone, planLine } from "./plan";
 
 export type DoneScope = { workspaceId: string } | { projectId: string };
@@ -105,7 +106,7 @@ export async function previewIdle(
       action: plan.action,
       removesWorktree:
         plan.action === "cleanup" && plan.worktree.action === "remove",
-      line: planLine(plan),
+      line: planLine(plan, true),
     });
   }
   return rows;
@@ -144,7 +145,10 @@ export async function doneIdle(
         result.mergeable.push({ id: s.id, name: s.name, pr: plan.pr.number });
         continue;
       }
-      result.done.push(await doneSession(s.id, { ...opts, noMerge: true }));
+      const outcome = await doneSession(s.id, { ...opts, noMerge: true });
+      // A clean-up is a deliberate sweep: it puts the sessions away.
+      archiveSession(s.id);
+      result.done.push({ ...outcome, text: `${outcome.text} Archived.` });
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
       result.refused.push({ id: s.id, name: s.name, reason });

package/lib/done/index.ts

@@ -4,7 +4,8 @@
  * gates at the judged head (refused, naming the gate, otherwise); one
  * already merged, or a session with no PR, just cleans up. Cleanup stops
  * the agent, removes the worktree only when nothing in it would be lost,
- * and archives the session. What it will do is decided first (plan.ts).
+ * and marks the session finished so it sits on the Done shelf (archiving is
+ * its own action, archive.ts). What it will do is decided first (plan.ts).
  */
 
 import { db, queries, type Session } from "../db";
@@ -17,6 +18,7 @@ import { judge, mergeJudged } from "../orchestrator/signoff";
 import { isPaused } from "../orchestrator/pause";
 import { plain } from "../orchestrator/overview";
 import { archiveSession } from "./archive";
+import { settleSession } from "../sidebar/shelf-state";
 import { demoMode } from "../security/demo";
 import { planDone } from "./plan";
 import { deleteMergedRemote } from "./remote";
@@ -187,7 +189,7 @@ export async function doneSession(
     await stopAgent(s);
     worktree = await settleWorktree(s, plan.merged);
   }
-  archiveSession(s.id);
+  settleSession(s.id);
   const head = merged ?? `Done: ${s.name}.`;
   const extra = notes.length ? `, ${notes.join(", ")}` : "";
   return {
@@ -195,6 +197,6 @@ export async function doneSession(
     name: s.name,
     merged,
     worktree,
-    text: `${head} Agent stopped, ${worktreeLine(worktree)}${extra}; archived.`,
+    text: `${head} Agent stopped, ${worktreeLine(worktree)}${extra}.`,
   };
 }

package/lib/done/plan.ts

@@ -92,7 +92,7 @@ export async function planDone(
 ): Promise<DonePlan> {
   if (s.role === "orchestrator")
     return refuse(`${s.name} is a workspace's orchestrator; it can't be done`);
-  if (s.archived_at) return refuse(`${s.name} is already done`);
+  if (s.archived_at) return refuse(`${s.name} is already archived`);
   if (callerId && callerId === s.id)
     return refuse("A session can't mark itself done");
   if ((await statusOf(s)).status === "running")
@@ -104,7 +104,7 @@ export async function planDone(
 }
 
 // One line for the preview: what done will do with it.
-export function planLine(p: DonePlan): string {
+export function planLine(p: DonePlan, archives = false): string {
   if (p.action === "refuse") return p.reason;
   if (p.action === "merge")
     return `has an open PR #${p.pr.number}: Done it on its own to merge it through the gates`;
@@ -117,5 +117,5 @@ export function planLine(p: DonePlan): string {
         : w.action === "gone"
           ? `its worktree is ${w.why}`
           : "no worktree";
-  return `stop it, ${tree}, archive it`;
+  return `stop it, ${tree}, ${archives ? "archive it" : "mark it done"}`;
 }

package/lib/orchestrator/act.ts

@@ -32,6 +32,7 @@ import { getStack, previewStack, startStack } from "../stacks";
 import { treeOrder } from "../stacks/tree";
 import type { StackItemView } from "../stacks/types";
 import { doneSession } from "../done";
+import { archiveChecked } from "../done/archive";
 import { amendBrief, amendmentsOf } from "./amendments";
 import type { Session } from "../db";
 import { approvePlanNow } from "../models/plan-step";
@@ -291,7 +292,7 @@ export async function drop(
 }
 
 // Finished work: merged through the gates if its PR is open, then
-// stopped, cleaned up and archived (lib/done).
+// stopped and cleaned up, then left on the Done shelf (lib/done).
 export async function done(workspaceId: string, ref: string): Promise<string> {
   const s = findWorkspaceSession(workspaceId, ref);
   const out = await doneSession(s.id, { by: "orchestrator" });
@@ -299,6 +300,17 @@ export async function done(workspaceId: string, ref: string): Promise<string> {
   return out.text;
 }
 
+// Puts a session away, out of the sidebar; nothing else changes.
+export async function archive(
+  workspaceId: string,
+  ref: string
+): Promise<string> {
+  const s = findWorkspaceSession(workspaceId, ref);
+  await archiveChecked(s.id);
+  addNote(workspaceId, `Archived: ${s.name}.`);
+  return `Archived ${s.name}: out of the sidebar, in Archived.`;
+}
+
 // Stops the agent and keeps everything else: a chat's turn is interrupted,
 // a terminal's tmux session ends. Its worktree and branch stay.
 export async function stop(workspaceId: string, ref: string): Promise<string> {

package/lib/orchestrator/brief.ts

@@ -129,7 +129,8 @@ Acting:
 - \`${TOOL_NAMES.move}\` (task, machine): carry a running task to a linked machine (heavy test or build work), or back with machine "here". It keeps its branch, conversation and plan, and everything you do with a task works the same there: its events come to you, read, send, stop, done and drop reach it, and the gates judge its PR at its head. The machine it lands on holds it for you and can't merge it. It runs in the background; an event says when it lands. Refused while paused, and for a task waiting on Saad.
 - \`${TOOL_NAMES.drop}\` (task, reason): close a task's PR and remove its worktree (on whichever machine holds it).
 - \`${TOOL_NAMES.stop}\` (session): stop a session's agent, keeping its work.
-- \`${TOOL_NAMES.done}\` (session): finish a session whose work is complete. A task with an open PR merges through the same gates as sign_off first (refused naming the gate otherwise); then the agent stops, the worktree goes only if nothing in it would be lost, and the session is archived out of view. Not a rejection: use drop for that.
+- \`${TOOL_NAMES.done}\` (session): finish a session whose work is complete. A task with an open PR merges through the same gates as sign_off first (refused naming the gate otherwise); then the agent stops, the worktree goes only if nothing in it would be lost, and the session lands on the sidebar's Done shelf (it is not archived). Not a rejection: use drop for that.
+- \`${TOOL_NAMES.archive}\` (session): put a session away, out of the sidebar, when Saad asks. Nothing is merged or cleaned up; refused while it works or has an open PR.
 - \`${TOOL_NAMES.add_project}\` (path, name?): make a git repository on this machine a project of this workspace, or move the project already at that path in when it's in no workspace. Use it rather than sending Saad steps. It refuses a folder that isn't a git repository or holds secrets, and a project another workspace has: moving that is Saad's call, so ask_saad.
 - \`${TOOL_NAMES.note}\` (text): a line in this workspace's decision log, shown in your chat. Note each decision that matters, with why.
 - \`${TOOL_NAMES.rule_add}\` (text): keep a standing rule for this workspace, in your brief on every start. Saad sees and edits them in Settings → Workspaces.

package/lib/orchestrator/serve.ts

@@ -3,6 +3,7 @@ import { workspaceTask } from "./targets";
 import { getWorkspace } from "../workspaces";
 import {
   approveTaskPlan,
+  archive,
   done,
   drop,
   moveTaskTo,
@@ -190,6 +191,8 @@ export async function runTool(
       return stop(w, p(tool, raw).session);
     case "done":
       return done(w, p(tool, raw).session);
+    case "archive":
+      return archive(w, p(tool, raw).session);
     case "add_project": {
       const a = p(tool, raw);
       return addProject(w, a.path, a.name);

package/lib/orchestrator/shell-guard.ts

@@ -211,13 +211,14 @@ const PULL_MERGE = /(^|\/)pulls\/[^/?\s]+\/merge\/?(\?|$)/;
 
 const MERGE_MSG = `Refused: a PR merges only through the gates: ${T.sign_off} (or ${T.arm}) for a task's or an external PR, ${T.land} for a stack. Nothing merges, closes or retargets a PR from the shell.`;
 
-// aos move, done, stop and drop reach a session by name, past the tools'
+// aos move, done, archive, stop and drop reach a session by name, past the tools'
 // Pause check and logging; the tools do the same work.
 function aosRefusal(args: string[]): string | null {
   const [sub] = positionals(args);
   const tool: Record<string, string> = {
     move: T.move,
     done: T.done,
+    archive: T.archive,
     stop: T.stop,
   };
   if (sub && tool[sub])

package/lib/orchestrator/tool-names.ts

@@ -28,6 +28,7 @@ export const TOOL_NAMES = {
   move: name("move"),
   stop: name("stop"),
   done: name("done"),
+  archive: name("archive"),
   add_project: name("add_project"),
   note: name("note"),
   question: name("question"),

package/lib/orchestrator/tool-schemas.ts

@@ -235,6 +235,7 @@ export const TOOL_SHAPES = {
   },
   stop: { session },
   done: { session },
+  archive: { session },
   add_project: {
     path: z
       .string()

package/lib/orchestrator/tools.ts

@@ -82,7 +82,9 @@ const DESCRIPTIONS: Record<ToolName, string> = {
   drop: "Reject a task: close its PR and remove its worktree. A task still waiting in the queue is removed by its id. Logged with the reason.",
   move: 'Carry a running task to a linked machine, or back with "here": for heavy test or build work. It keeps its branch, conversation and plan; the gates, events, read, send, stop, done and drop work the same wherever it runs, and the machine it lands on can\'t merge it. Takes a few minutes and runs in the background; an event says when it lands. Refused while paused, for a task waiting on Saad (an escalation or open ask), and for card and stacked tasks.',
   stop: "Stop a session's agent mid-turn, even while it's thinking, keeping its conversation, worktree and branch; your next message runs as its next turn.",
-  done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it's archived. Not a rejection.",
+  done: "Finish a session whose work is complete: a task's open PR merges through the sign-off gates first (refused naming the failing gate), then its agent stops, its worktree is removed if nothing would be lost, and it lands on the sidebar's Done shelf; it no longer archives (use archive for that). Not a rejection.",
+  archive:
+    "Put a finished session away, out of the sidebar (it stays in Archived, and Saad can unarchive it). Nothing is merged or cleaned up: refused while the session is working or has an open PR; done first for finished work.",
   add_project:
     "Make a git repository on this machine a project of this workspace, by its absolute path, or move the project already at that path into this workspace when it's in no workspace. Says its default branch, detected from git. Refuses a folder that isn't a git repository or that holds secrets, and a project another workspace has.",
   note: "Add a line to this workspace's decision log; it shows in your chat.",

package/lib/sidebar/row-actions.ts

@@ -0,0 +1,15 @@
+import type { Session } from "@/lib/db/types";
+
+// What a row's ⋯ menu offers to finish it: Done (merge through the gates,
+// stop, leave it on the Done shelf) for a task, Archive (put it away) for
+// every session but an orchestrator. A plain session is finished with Mark
+// done, so it only gets Archive here.
+export type FinishAction = "done" | "archive";
+
+export function finishActions(
+  session: Pick<Session, "role" | "task_status">,
+  plain: boolean
+): FinishAction[] {
+  if (session.role === "orchestrator") return [];
+  return plain ? ["archive"] : ["done", "archive"];
+}

package/lib/sidebar/shelves.ts

@@ -26,6 +26,8 @@ export const NEED_LABEL: Record<SessionNeed, string> = {
 
 // A plain session quiet this long has settled by itself.
 export const SETTLE_AFTER_MS = 3 * 24 * 3600_000;
+// A session that has sat in Done this long is archived by the server.
+export const ARCHIVE_AFTER_MS = 30 * 24 * 3600_000;
 
 export const DONE_FIRST_PAGE = 10;
 export const DONE_PAGE = 25;

package/package.json

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

package/server.ts

@@ -14,6 +14,7 @@ import { buildId } from "./lib/build";
 import { startOrchestratorWatcher } from "./lib/orchestrator/watcher";
 import { realDeps, schedulesEnabled, startScheduler } from "./lib/schedules";
 import { startSettling } from "./lib/recipes";
+import { startAutoArchive } from "./lib/done/auto-archive";
 import { startUsageRollup, usageRollupEnabled } from "./lib/usage/nightly";
 import { resumePhoneOutbox } from "./lib/notify";
 import { resumePushOutbox } from "./lib/notify/push";
@@ -413,6 +414,8 @@ app.prepare().then(async () => {
   // Schedules tick here, once a minute, and nowhere else.
   if (schedulesEnabled(process.env)) startScheduler(realDeps);
   startSettling();
+  // Sessions that sat in Done for 30 days are archived.
+  startAutoArchive();
   resumePhoneOutbox();
   resumePushOutbox();
   // The usage ledger's daily rollup and its ratchet alerts.