@saadnvd1/agent-os 0.3.606 → 0.3.608

package/app/api/busy/route.ts

@@ -8,5 +8,6 @@ export async function GET(request: NextRequest) {
   const refused = requireLocalTrust(request);
   if (refused) return refused;
   const work = inFlight();
-  return NextResponse.json({ ...work, busy: work.reviews + work.setups > 0 });
+  const busy = work.reviews + work.setups + work.simulatorStarts > 0;
+  return NextResponse.json({ ...work, busy });
 }

package/app/api/updates/route.test.ts

@@ -15,7 +15,9 @@ vi.mock("@/lib/updates/check", async (orig) => ({
   cachedCheck: () => check,
   checkForUpdate: async () => ({ result: refreshed ?? check, throttled }),
 }));
-vi.mock("@/lib/busy", () => ({ inFlight: () => ({ reviews: 0, setups: 0 }) }));
+vi.mock("@/lib/busy", () => ({
+  inFlight: () => ({ reviews: 0, setups: 0, simulatorStarts: 0 }),
+}));
 vi.mock("@/lib/status/collect", () => ({
   collectStatuses: async () => ({
     statuses: {

package/components/Chat/ContextMeter.tsx

@@ -13,7 +13,7 @@ import { cn } from "@/lib/utils";
 import { chatMeta, chatMetaActions } from "@/stores/chatMeta";
 
 const LEVEL_COLOR = {
-  ok: "text-primary",
+  ok: "text-foreground/40",
   warn: "text-amber-500",
   high: "text-destructive",
 } as const;
@@ -94,7 +94,7 @@ export function ContextMeter({
               className={cn(
                 "h-full rounded-full",
                 level === "ok"
-                  ? "bg-primary"
+                  ? "bg-foreground/40"
                   : level === "warn"
                     ? "bg-amber-500"
                     : "bg-destructive"

package/components/PrStageBadge.tsx

@@ -13,12 +13,12 @@ import {
 import { cn } from "@/lib/utils";
 
 const TONE: Record<PrStageName, string> = {
-  merged: "bg-purple-500/15 text-purple-700 dark:text-purple-400",
+  merged: "bg-green-500/15 text-green-700 dark:text-green-400",
   conflicts: "bg-amber-500/15 text-amber-700 dark:text-amber-400",
   "ci-failed": "bg-red-500/15 text-red-700 dark:text-red-400",
-  "ci-running": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
-  "ci-settling": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
-  "review-running": "bg-blue-500/15 text-blue-700 dark:text-blue-400",
+  "ci-running": "bg-foreground/[0.06] text-muted-foreground",
+  "ci-settling": "bg-foreground/[0.06] text-muted-foreground",
+  "review-running": "bg-foreground/[0.06] text-muted-foreground",
   "review-blocked": "bg-red-500/15 text-red-700 dark:text-red-400",
   waiting: "bg-amber-500/15 text-amber-700 dark:text-amber-400",
   armed: "bg-green-500/15 text-green-700 dark:text-green-400",

package/components/SessionList/LiveLine.tsx

@@ -15,21 +15,17 @@ export interface LiveInput {
 
 // A status badge's pill; the failed need is red text alone.
 const PILL: Record<LiveTone, string> = {
-  blue: "bg-blue-500/15",
   amber: "bg-amber-500/15",
   red: "bg-red-500/15",
   green: "bg-green-500/15",
-  purple: "bg-purple-500/15",
   primary: "bg-primary/15",
   muted: "bg-muted",
 };
 
 const TONE: Record<LiveTone, string> = {
-  blue: "text-blue-700 dark:text-blue-400",
   amber: "text-amber-700 dark:text-amber-400",
   red: "text-red-700 dark:text-red-400",
   green: "text-green-700 dark:text-green-400",
-  purple: "text-purple-700 dark:text-purple-400",
   primary: "text-primary",
   muted: "text-muted-foreground",
 };

package/components/Stacks/StatusChip.tsx

@@ -1,52 +1,28 @@
-import type { StackItemView, StackStatus } from "@/lib/stacks/types";
+import { GitPullRequest, Loader2 } from "lucide-react";
 import { cn } from "@/lib/utils";
-
-type Status = StackItemView["status"] | StackStatus;
-
-const amber = "bg-amber-500/15 text-amber-700 dark:text-amber-300";
-const green = "bg-emerald-500/15 text-emerald-700 dark:text-emerald-300";
-const muted = "bg-foreground/[0.06] text-muted-foreground";
-const purple = "bg-primary/15 text-primary";
-const red = "bg-destructive/15 text-destructive";
-
-const CHIP: Record<Status, { label: string; tone: string }> = {
-  planned: { label: "Planned", tone: muted },
-  held: { label: "Held", tone: amber },
-  starting: { label: "Starting", tone: purple },
-  running: { label: "Working", tone: purple },
-  pr: { label: "PR open", tone: purple },
-  merged: { label: "Merged", tone: green },
-  failed: { label: "Failed", tone: red },
-  dropped: { label: "Dropped", tone: muted },
-  done: { label: "Done", tone: green },
-  excluded: { label: "Left out", tone: muted },
-  paused: { label: "Paused", tone: amber },
-  landing: { label: "Landing", tone: purple },
-  landed: { label: "Landed", tone: green },
-};
+import { chipFor, type ChipStatus } from "./status-chip";
 
 export function StatusChip({
   status,
   attention,
   stack,
 }: {
-  status: Status;
+  status: ChipStatus;
   attention?: boolean;
-  // A whole stack: "running" reads as Running, not Working.
   stack?: boolean;
 }) {
-  const chip = attention
-    ? { label: "Needs you", tone: amber }
-    : stack && status === "running"
-      ? { label: "Running", tone: purple }
-      : CHIP[status];
+  const chip = chipFor(status, { attention, stack });
   return (
     <span
       className={cn(
-        "inline-flex shrink-0 items-center rounded-full px-2 py-0.5 text-[11px] font-medium",
+        "inline-flex shrink-0 items-center gap-1 rounded-full px-2 py-0.5 text-[11px] font-medium",
         chip.tone
       )}
     >
+      {chip.icon === "spinner" && (
+        <Loader2 className="h-3 w-3 animate-spin" aria-hidden />
+      )}
+      {chip.icon === "pr" && <GitPullRequest className="h-3 w-3" aria-hidden />}
       {chip.label}
     </span>
   );

package/components/Stacks/status-chip.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { CHIP, chipFor, type ChipStatus } from "./status-chip";
+
+const coloured = (tone: string) => /amber|emerald|destructive/.test(tone);
+
+describe("status chip colour", () => {
+  it.each(["starting", "running", "pr", "landing"] as ChipStatus[])(
+    "%s is neutral with an icon",
+    (s) => {
+      expect(coloured(CHIP[s].tone)).toBe(false);
+      expect(CHIP[s].tone).not.toContain("primary");
+      expect(CHIP[s].icon).not.toBeNull();
+    }
+  );
+
+  it.each(["merged", "done", "landed"] as ChipStatus[])("%s is green", (s) =>
+    expect(CHIP[s].tone).toContain("emerald")
+  );
+  it("failed is red", () => expect(CHIP.failed.tone).toContain("destructive"));
+  it.each(["held", "paused"] as ChipStatus[])("%s is amber", (s) =>
+    expect(CHIP[s].tone).toContain("amber")
+  );
+
+  it("needs-you overrides status with amber", () => {
+    const c = chipFor("running", { attention: true });
+    expect(c.label).toBe("Needs you");
+    expect(c.tone).toContain("amber");
+  });
+
+  it("a running stack reads Running, neutral", () => {
+    const c = chipFor("running", { stack: true });
+    expect(c.label).toBe("Running");
+    expect(coloured(c.tone)).toBe(false);
+  });
+
+  it("no status uses the accent", () => {
+    for (const c of Object.values(CHIP))
+      expect(c.tone).not.toContain("primary");
+  });
+});

package/components/Stacks/status-chip.ts

@@ -0,0 +1,44 @@
+import type { StackItemView, StackStatus } from "@/lib/stacks/types";
+
+export type ChipStatus = StackItemView["status"] | StackStatus;
+export type ChipIcon = "spinner" | "pr" | null;
+
+// Colour means "look at this": amber needs you, red failed, green final.
+// Everything still moving on its own is neutral, and an icon carries the meaning.
+const amber = "bg-amber-500/15 text-amber-700 dark:text-amber-300";
+const green = "bg-emerald-500/15 text-emerald-700 dark:text-emerald-300";
+const muted = "bg-foreground/[0.06] text-muted-foreground";
+const red = "bg-destructive/15 text-destructive";
+
+interface Chip {
+  label: string;
+  tone: string;
+  icon: ChipIcon;
+}
+
+export const CHIP: Record<ChipStatus, Chip> = {
+  planned: { label: "Planned", tone: muted, icon: null },
+  held: { label: "Held", tone: amber, icon: null },
+  starting: { label: "Starting", tone: muted, icon: "spinner" },
+  running: { label: "Working", tone: muted, icon: "spinner" },
+  pr: { label: "PR open", tone: muted, icon: "pr" },
+  merged: { label: "Merged", tone: green, icon: null },
+  failed: { label: "Failed", tone: red, icon: null },
+  dropped: { label: "Dropped", tone: muted, icon: null },
+  done: { label: "Done", tone: green, icon: null },
+  excluded: { label: "Left out", tone: muted, icon: null },
+  paused: { label: "Paused", tone: amber, icon: null },
+  landing: { label: "Landing", tone: muted, icon: "spinner" },
+  landed: { label: "Landed", tone: green, icon: null },
+};
+
+export function chipFor(
+  status: ChipStatus,
+  opts: { attention?: boolean; stack?: boolean } = {}
+): Chip {
+  if (opts.attention) return { label: "Needs you", tone: amber, icon: null };
+  // A whole stack: "running" reads as Running, not Working.
+  if (opts.stack && status === "running")
+    return { label: "Running", tone: muted, icon: "spinner" };
+  return CHIP[status];
+}

package/lib/busy.ts

@@ -1,9 +1,14 @@
 import { db } from "./db";
+import { runningStarts } from "./simulator";
 
-// What a restart would cut off and have to start over: reviews and task
-// setups run in the server. (Chat turns run in their own workers and
+// What a restart would cut off and have to start over: reviews, task
+// setups and simulator starts run in the server. (Chat turns run in their own workers and
 // outlive it.) Older than half an hour is stuck, not in flight.
-export function inFlight(): { reviews: number; setups: number } {
+export function inFlight(): {
+  reviews: number;
+  setups: number;
+  simulatorStarts: number;
+} {
   const count = (sql: string) => (db.prepare(sql).get() as { n: number }).n;
   return {
     reviews: count(
@@ -16,5 +21,6 @@ export function inFlight(): { reviews: number; setups: number } {
        WHERE setup_status = 'running' AND archived_at IS NULL
          AND created_at > datetime('now', '-30 minutes')`
     ),
+    simulatorStarts: runningStarts(),
   };
 }

package/lib/recipes/status-labels.ts

@@ -8,8 +8,8 @@ export const RUN_STATUS_LABELS: Record<
   { label: string; tone: Tone }
 > = {
   queued: { label: "Queued", tone: "muted" },
-  starting: { label: "Starting", tone: "primary" },
-  running: { label: "Running", tone: "primary" },
+  starting: { label: "Starting", tone: "muted" },
+  running: { label: "Running", tone: "muted" },
   succeeded: { label: "Succeeded", tone: "success" },
   failed: { label: "Failed", tone: "destructive" },
   blocked: { label: "Needs you", tone: "warning" },

package/lib/resurrect/index.ts

@@ -29,7 +29,7 @@ import {
   transcriptPath,
   writeTranscript,
 } from "../tasks/transcript";
-import { buildTaskBrief } from "../tasks/brief";
+import { buildTaskBrief, declaredTest } from "../tasks/brief";
 import { syncTaskCardInBackground } from "../lumifyhub/task-cards";
 import { allocatePorts } from "../ports";
 import { loadProjectConfig, portBases } from "../project-config";
@@ -416,6 +416,7 @@ async function relaunch(s: Session, cwd: string): Promise<void> {
       ? buildTaskBrief({
           branch: s.branch_name,
           baseBranch: s.base_branch ?? "main",
+          test: declaredTest(cwd),
         })
       : undefined,
   });

package/lib/sidebar/live-status.ts

@@ -6,14 +6,7 @@ import {
 } from "../tasks/pr-stage";
 import type { StatusBadge } from "./row-badge";
 
-export type LiveTone =
-  | "blue"
-  | "amber"
-  | "red"
-  | "green"
-  | "purple"
-  | "primary"
-  | "muted";
+export type LiveTone = "amber" | "red" | "green" | "primary" | "muted";
 
 export interface LivePart {
   text: string;
@@ -31,17 +24,17 @@ export const BADGE_TONE: Record<StatusBadge["kind"], LiveTone> = {
   failed: "red",
   stalled: "amber",
   starting: "muted",
-  planning: "blue",
+  planning: "muted",
   "plan-ready": "primary",
 };
 
 export const PR_STAGE_TONE: Record<PrStageName, LiveTone> = {
-  merged: "purple",
+  merged: "green",
   conflicts: "amber",
   "ci-failed": "red",
-  "ci-running": "blue",
-  "ci-settling": "blue",
-  "review-running": "blue",
+  "ci-running": "muted",
+  "ci-settling": "muted",
+  "review-running": "muted",
   "review-blocked": "red",
   waiting: "amber",
   armed: "green",
@@ -58,7 +51,7 @@ export function liveParts(input: {
 }): LivePart[] {
   const parts: LivePart[] = [];
   if (input.compacting)
-    parts.push({ text: "Compacting", tone: "blue", busy: true });
+    parts.push({ text: "Compacting", tone: "muted", busy: true });
   const b = input.badge;
   if (b)
     parts.push({

package/lib/simulator/index.ts

@@ -144,6 +144,11 @@ const tail = (file: string, lines = 15) => {
 // simulator can stop it.
 const starts = new Map<string, ChildProcess>();
 
+// Simulator starts running now, for lib/busy: a restart kills them.
+export function runningStarts(): number {
+  return starts.size;
+}
+
 // The whole group: the project's build and Metro are children of the shell.
 export function killGroup(child: ChildProcess, signal: NodeJS.Signals) {
   try {
@@ -153,7 +158,7 @@ export function killGroup(child: ChildProcess, signal: NodeJS.Signals) {
   }
 }
 
-function runStart(
+export function runStart(
   sessionId: string,
   command: string,
   cwd: string,

package/lib/tasks/brief.ts

@@ -1,3 +1,5 @@
+import { loadProjectConfig } from "../project-config";
+
 // A task stacked on another task's unmerged branch.
 export interface StackedOn {
   // The parent's PR number, when it has one.
@@ -19,17 +21,30 @@ function stackedLines(baseBranch: string, stack: StackedOn): string {
 - Never merge or rebase onto the default branch yourself. When the parent merges, AgentOS rebases your branch and retargets your PR, then tells you; re-run your checks when it does. AgentOS reviews your PR itself; a review of your head still counts for the head its restack left, and a push after that gets a new one.${also}`;
 }
 
+// The project's declared test command, read from the checkout the task runs in.
+export function declaredTest(cwd: string): string | undefined {
+  return loadProjectConfig(cwd).config.test || undefined;
+}
+
+function checksLine(test?: string): string {
+  return test
+    ? `Run exactly this to check your work: \`${test}\`. CI runs the full suite on your pull request, so don't run it locally.`
+    : "Run the project's own checks (typecheck, tests, lint) when they exist and keep them passing.";
+}
+
 // The system brief every task agent runs under. It finishes by opening a PR
 // and stopping: merging is the human's sign-off, never the agent's.
 export function buildTaskBrief(opts: {
   branch: string;
   baseBranch: string;
   stack?: StackedOn;
+  // The project's `test` from agentos.json, when it declares one.
+  test?: string;
 }): string {
   return `You are running as an AgentOS background task, alone, in an isolated git worktree.
 
 - Branch: ${opts.branch} (based on ${opts.baseBranch}). Stay in this directory and on this branch.
-- Do the task fully. Run the project's own checks (typecheck, tests, lint) when they exist and keep them passing.
+- Do the task fully. ${checksLine(opts.test)}
 - When the work is done, commit with a conventional commit message, run \`git push -u origin ${opts.branch}\` and open a pull request against ${opts.baseBranch} with \`gh pr create\`, using a clear title and a short body that says what changed and how you verified it. Then stop and wait.
 - You don't need to review it yourself: AgentOS runs an independent review of the PR's exact head commit before it can merge, and the orchestrator sends you any blocking findings to fix. For a risky change you may still run \`/do-code-review\` (or \`/code-review\`) before the PR.
 - Never merge the pull request, never push to ${opts.baseBranch}, and never delete branches or worktrees. A human reviews and merges.${opts.stack ? stackedLines(opts.baseBranch, opts.stack) : ""}

package/lib/tasks/import.ts

@@ -23,7 +23,7 @@ import { resolveModelForAgent } from "../model-catalog";
 import { providerFor } from "../models/resolve";
 import { preparePlanDir, PLAN_FILE } from "../models/plan-step";
 import { carryTaskState } from "./move-carry";
-import { buildTaskBrief } from "./brief";
+import { buildTaskBrief, declaredTest } from "./brief";
 import { expandHome } from "./session";
 import { ensureProject } from "./project-ref";
 import { checkoutBranchWorktree } from "./branch-worktree";
@@ -136,7 +136,11 @@ async function arrive(
     ? bundle.model
     : resolveModelForAgent("claude", bundle.model || project.default_model);
   const baseBranch = bundle.baseBranch ?? "main";
-  const brief = buildTaskBrief({ branch: bundle.branch, baseBranch });
+  const brief = buildTaskBrief({
+    branch: bundle.branch,
+    baseBranch,
+    test: declaredTest(worktreePath),
+  });
   // Checked and written with no await between, so two can't both pass.
   db.transaction(() => {
     refuseBusyBranch(project.id, bundle.branch);

package/lib/tasks/index.ts

@@ -33,7 +33,7 @@ import { agentLabel } from "../agent-options";
 import { supportsChat } from "../chat/capabilities";
 import { AGENT_DEFAULT_MODEL } from "../providers/registry";
 import { statusDetector } from "../status-detector";
-import { buildTaskBrief, type StackedOn } from "./brief";
+import { buildTaskBrief, declaredTest, type StackedOn } from "./brief";
 import {
   attachTaskCard,
   inBackground,
@@ -354,6 +354,7 @@ async function startTask(
         branch: wt.branchName,
         baseBranch,
         stack: opts.base?.stack,
+        test: declaredTest(wt.worktreePath),
       }),
       naming.source,
       view,

package/lib/tasks/move.ts

@@ -13,7 +13,7 @@ import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { endTmuxSession } from "../tmux/end";
 import { launchClaude } from "../agents/launch";
-import { buildTaskBrief } from "./brief";
+import { buildTaskBrief, declaredTest } from "./brief";
 import { git as runGit } from "../git-exec";
 import { getTaskSession, isoUTC } from "./session";
 import { projectRef } from "./project-ref";
@@ -308,6 +308,7 @@ async function relaunch(session: Session, note?: string): Promise<void> {
       ? buildTaskBrief({
           branch: session.branch_name,
           baseBranch: session.base_branch ?? "main",
+          test: declaredTest(session.working_directory),
         })
       : undefined,
   });

package/package.json

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

package/scripts/autodeploy

@@ -4,6 +4,11 @@
 # background. Chat turns live in workers and outlive the restart; reviews
 # and task setups don't, so the restart waits up to 10 minutes for them.
 #   sm add agentos-autodeploy "scripts/autodeploy" --cron "* * * * *"
+# Restarts are spaced AGENTOS_MIN_GAP seconds apart (10 minutes; 0 turns it
+# off): a head that lands inside the gap waits and is deployed, whatever it
+# has become by then, when the gap ends. A commit message with [deploy-now]
+# (in any commit the deploy would take) skips the gap. Each hold logs one line:
+#   HELD <sha> <seconds> left in the restart gap (since <last restart sha>)
 # Another machine (a server) runs it with AGENTOS_PUBLISH=0: deploy
 # only, and its own AGENTOS_RESTART. Only one machine publishes to npm.
 set -euo pipefail
@@ -44,6 +49,28 @@ if [ "$head" != "$deployed" ] && [ "$settle" -gt 0 ] &&
   exit 0
 fi
 
+# Restarts kill simulator starts and reviews in flight, so they are spaced
+# apart. The head isn't recorded as deployed while it waits, so it (or a
+# newer one) goes out as soon as the gap is over; nothing is dropped.
+gap="${AGENTOS_MIN_GAP:-600}"
+if [ "$head" != "$deployed" ] && [ "$gap" -gt 0 ]; then
+  last=$(cat "$state/restarted" 2>/dev/null || echo 0)
+  left=$(( last + gap - $(date +%s) ))
+  if [ "$left" -gt 0 ]; then
+    msgs=$(git log --format=%B "${deployed:+$deployed..}$head" 2>/dev/null || git log -1 --format=%B "$head")
+    if printf '%s' "$msgs" | grep -qF '[deploy-now]'; then
+      log "Restart gap skipped for ${head:0:7}: [deploy-now]"
+    else
+      # Once per head, not once per minute, so the log counts holds.
+      if [ "$(cat "$state/held" 2>/dev/null)" != "$head" ]; then
+        echo "$head" > "$state/held"
+        log "HELD ${head:0:7} ${left}s left in the ${gap}s restart gap"
+      fi
+      exit 0
+    fi
+  fi
+fi
+
 # A deploy that can't land says so once per commit, rather than retrying
 # quietly every minute (uncommitted edits in this checkout block the pull).
 alert() {
@@ -70,6 +97,7 @@ if [ "$head" != "$deployed" ]; then
   fi
   # The pull takes what landed while it waited, too.
   git rev-parse HEAD > "$state/deployed"
+  date +%s > "$state/restarted"
 fi
 
 # Publishing waits minutes for npm to serve a version, so it runs on its own

package/scripts/autodeploy.test.ts

@@ -0,0 +1,106 @@
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { describe, expect, it } from "vitest";
+
+// Runs the real scripts/autodeploy in a scratch clone with a stub redeploy
+// (a pull) and wait-quiet, against a scratch origin and HOME.
+const script = path.resolve(__dirname, "autodeploy");
+const sh = (cwd: string, ...args: string[]) =>
+  execFileSync("git", args, { cwd, encoding: "utf-8" }).trim();
+
+function setup() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "aos-autodeploy-"));
+  const origin = path.join(root, "origin.git");
+  const work = path.join(root, "work");
+  const clone = path.join(root, "live");
+  const home = path.join(root, "home");
+  fs.mkdirSync(home);
+  sh(root, "init", "-q", "--bare", "-b", "main", origin);
+  sh(root, "clone", "-q", origin, work);
+  fs.mkdirSync(path.join(work, "scripts"));
+  fs.copyFileSync(script, path.join(work, "scripts/autodeploy"));
+  fs.writeFileSync(path.join(work, "scripts/wait-quiet"), "#!/bin/sh\n");
+  fs.writeFileSync(
+    path.join(work, "scripts/redeploy"),
+    "#!/bin/sh\ngit pull -q origin main && echo x >> ../restarts\n"
+  );
+  fs.chmodSync(path.join(work, "scripts/autodeploy"), 0o755);
+  fs.chmodSync(path.join(work, "scripts/wait-quiet"), 0o755);
+  fs.chmodSync(path.join(work, "scripts/redeploy"), 0o755);
+  const commit = (msg: string) => {
+    fs.appendFileSync(path.join(work, "f"), msg + "\n");
+    sh(work, "add", "-A");
+    sh(work, "-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qm", msg);
+    sh(work, "push", "-q", "origin", "main");
+    return sh(work, "rev-parse", "HEAD");
+  };
+  commit("first");
+  sh(root, "clone", "-q", origin, clone);
+  const state = path.join(home, ".agent-os/autodeploy");
+  const run = () =>
+    execFileSync(path.join(clone, "scripts/autodeploy"), [], {
+      cwd: clone,
+      encoding: "utf-8",
+      env: {
+        ...process.env,
+        HOME: home,
+        AGENTOS_PUBLISH: "0",
+        AGENTOS_SETTLE: "0",
+        AGENTOS_RESTART: "true",
+      },
+    });
+  const restarts = () => {
+    try {
+      return (
+        fs.readFileSync(path.join(root, "restarts"), "utf-8").split("\n")
+          .length - 1
+      );
+    } catch {
+      return 0;
+    }
+  };
+  const deployed = () =>
+    fs.readFileSync(path.join(state, "deployed"), "utf-8").trim();
+  return { commit, run, restarts, deployed, state };
+}
+
+describe("autodeploy restart gap", () => {
+  it("holds a second deploy inside the gap, then deploys the newest head once it ends", () => {
+    const t = setup();
+    const a = t.commit("a");
+    expect(t.run()).toContain("Deploying");
+    expect(t.deployed()).toBe(a);
+    expect(t.restarts()).toBe(1);
+
+    t.commit("b");
+    const c = t.commit("c");
+    const held = t.run();
+    expect(held).toMatch(/HELD [0-9a-f]{7} \d+s left in the 600s restart gap/);
+    expect(t.deployed()).toBe(a);
+    expect(t.restarts()).toBe(1);
+    // Still waiting a minute later: no second log line for the same head.
+    expect(t.run()).toBe("");
+
+    // The gap ends: the head that was waiting goes out, once.
+    fs.writeFileSync(
+      path.join(t.state, "restarted"),
+      `${Math.floor(Date.now() / 1000) - 601}\n`
+    );
+    expect(t.run()).toContain("Deploying");
+    expect(t.deployed()).toBe(c);
+    expect(t.restarts()).toBe(2);
+    expect(t.run()).toBe("");
+  });
+
+  it("skips the gap for a [deploy-now] commit", () => {
+    const t = setup();
+    t.commit("a");
+    t.run();
+    const urgent = t.commit("fix: login loop [deploy-now]");
+    expect(t.run()).toContain("[deploy-now]");
+    expect(t.deployed()).toBe(urgent);
+    expect(t.restarts()).toBe(2);
+  });
+});

package/scripts/wait-quiet

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Waits until the AgentOS server on $PORT has nothing in flight that a
-# restart would cut off (reviews, task setups: GET /api/busy), for at most
+# restart would cut off (reviews, task setups, simulator starts: GET /api/busy), for at most
 # AGENTOS_QUIET_WAIT seconds; then returns, so a deploy always lands. A
 # server that doesn't answer (down, or a build without /api/busy) is quiet.
 set -uo pipefail