@saadnvd1/agent-os 0.3.605 → 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/env-setup.ts

@@ -9,6 +9,8 @@
 import * as fs from "fs";
 import * as path from "path";
 import { bringDependencies, runCommand } from "./worktree-deps";
+import { inside, realExisting } from "./worktree-deps/paths";
+import { seedBuildCaches } from "./worktree-deps/caches";
 import { loadProjectConfig, projectEnv, withPorts } from "./project-config";
 import { recordPlaced } from "./worktree-placed";
 import { databaseEnv, ensureSessionDatabase } from "./project-config/database";
@@ -79,18 +81,6 @@ export async function copyEnvFiles(
   return copied;
 }
 
-const inside = (root: string, p: string) =>
-  p === root || p.startsWith(root + path.sep);
-
-// The real path of `p`'s deepest part that exists.
-async function realExisting(p: string): Promise<string> {
-  for (let at = p; ; at = path.dirname(at)) {
-    const real = await fs.promises.realpath(at).catch(() => null);
-    if (real) return real;
-    if (path.dirname(at) === at) return at;
-  }
-}
-
 /**
  * agentos.json's `copy`: files or folders from the main checkout, each one
  * resolved (symlinks included) to a place inside it, so a project can't
@@ -272,6 +262,31 @@ export async function setupWorktree(options: {
     );
   }
 
+  // Build caches, so the first typecheck, test or build is warm. An
+  // optimisation: it never fails a setup.
+  if (config.caches?.length !== 0 && sourcePath !== worktreePath) {
+    progress?.onStage?.("deps");
+    try {
+      const seeded = await seedBuildCaches({
+        sourcePath,
+        worktreePath,
+        paths: config.caches,
+      });
+      if (seeded.seeded.length || seeded.skipped.length)
+        result.steps.push({
+          name: "Seed build caches",
+          command: "cp (build caches)",
+          success: true,
+          output: [
+            ...seeded.seeded.map((c) => `${c.rel} (${c.how})`),
+            ...seeded.skipped.map((c) => `skipped ${c.rel}: ${c.why}`),
+          ].join("\n"),
+        });
+    } catch (error) {
+      console.error("Seeding build caches failed:", error);
+    }
+  }
+
   // 4. The config's setup commands
   if (config.setup && config.setup.length > 0) {
     progress?.onStage?.("script");

package/lib/project-config/agentos.schema.json

@@ -48,6 +48,20 @@
         "pattern": "^(?![/~\\\\])(?!(.*[/\\\\])?\\.\\.([/\\\\]|$)).+$"
       }
     },
+    "caches": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "allOf": [
+          {
+            "pattern": "^(?![/~\\\\])(?!(.*[/\\\\])?\\.\\.([/\\\\]|$)).+$"
+          },
+          {
+            "pattern": "^([^*]*[/\\\\])?[^*/\\\\]*\\*?[^*/\\\\]*$"
+          }
+        ]
+      }
+    },
     "dev": {
       "type": "string",
       "minLength": 1

package/lib/project-config/schema.ts

@@ -28,6 +28,15 @@ const projectPath = z
     "must be a path inside the project (relative, no '..')"
   );
 
+// Build caches to seed into a worktree: a path inside the project, with `*`
+// allowed in the last segment (`*.tsbuildinfo`), never `.git`.
+const cachePath = projectPath
+  .regex(
+    /^([^*]*[/\\])?[^*/\\]*\*?[^*/\\]*$/,
+    "`*` is allowed in the last segment only"
+  )
+  .refine((p) => !/(^|[/\\])\.git([/\\]|$)/.test(p), "not .git");
+
 const port = z.number().int().min(1024).max(65000);
 const notes = z.union([z.string(), z.array(z.string())]);
 
@@ -120,6 +129,7 @@ const shape = {
   setup: z.array(z.string().min(1)).optional(),
   copy: z.array(projectPath).optional(),
   clone: z.array(projectPath).optional(),
+  caches: z.array(cachePath).optional(),
   dev: z.string().min(1).optional(),
   ready: ready.optional(),
   deploy: deploy.optional(),

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,
   });