@saadnvd1/agent-os 0.3.660 → 0.3.664

package/lib/dev-instance/processInfo.ts

@@ -1,5 +1,27 @@
 import fs from "fs";
-import { execFileSync } from "child_process";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+const execFileAsync = promisify(execFile);
+
+// These run inside the server (task end, the sweep), so none may block the
+// event loop or hang: a timeout reads as "could not verify".
+export const PROBE_TIMEOUT_MS = 3000;
+
+export class ProbeTimeout extends Error {}
+
+export async function probe(cmd: string, args: string[]): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync(cmd, args, {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+    });
+    return stdout;
+  } catch (e) {
+    if ((e as { killed?: boolean }).killed) throw new ProbeTimeout(cmd);
+    throw e;
+  }
+}
 
 export function pidAlive(pid: number): boolean {
   try {
@@ -18,18 +40,18 @@ const real = (p: string): string => {
   }
 };
 
-export function processCwd(pid: number): string | null {
+export async function processCwd(pid: number): Promise<string | null> {
   try {
     if (process.platform === "linux")
       return real(fs.readlinkSync(`/proc/${pid}/cwd`));
-    const out = execFileSync(
-      "lsof",
-      ["-a", "-p", String(pid), "-d", "cwd", "-Fn"],
-      {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }
-    );
+    const out = await probe("lsof", [
+      "-a",
+      "-p",
+      String(pid),
+      "-d",
+      "cwd",
+      "-Fn",
+    ]);
     const line = out.split("\n").find((l) => l.startsWith("n"));
     return line ? real(line.slice(1)) : null;
   } catch {
@@ -38,30 +60,29 @@ export function processCwd(pid: number): string | null {
 }
 
 // Whether the process was launched as the live server: its environment
-// carries the marker, or its title is the server's.
-export function looksLive(pid: number): boolean {
+// carries the marker, or its title is the server's. A probe that times out
+// answers true: not being able to tell is a reason to leave it alone.
+export async function looksLive(pid: number): Promise<boolean> {
   try {
     if (process.platform === "linux") {
       const env = fs.readFileSync(`/proc/${pid}/environ`, "utf8").split("\0");
       if (env.includes("AGENTOS_SERVER=live")) return true;
     } else {
-      const out = execFileSync(
-        "ps",
-        ["eww", "-p", String(pid), "-o", "command="],
-        {
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "ignore"],
-        }
-      );
+      const out = await probe("ps", [
+        "eww",
+        "-p",
+        String(pid),
+        "-o",
+        "command=",
+      ]);
       if (/\bAGENTOS_SERVER=live\b/.test(out)) return true;
     }
-    const comm = execFileSync("ps", ["-p", String(pid), "-o", "comm="], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-    return comm.trim() === "agentos-server";
-  } catch {
-    return false;
+    return (
+      (await probe("ps", ["-p", String(pid), "-o", "comm="])).trim() ===
+      "agentos-server"
+    );
+  } catch (e) {
+    return e instanceof ProbeTimeout;
   }
 }
 

package/lib/dev-instance/startDevServer.ts

@@ -35,7 +35,7 @@ export async function startDevServer(opts: {
   if (
     existing &&
     pidAlive(existing.pid) &&
-    samePath(processCwd(existing.pid) ?? "", worktree)
+    samePath((await processCwd(existing.pid)) ?? "", worktree)
   )
     return { ...existing, reused: true };
 

package/lib/dev-instance/stopDevServer.ts

@@ -1,18 +1,24 @@
 import fs from "fs";
 import path from "path";
-import { execFileSync } from "child_process";
 import { readLiveRecord } from "./liveServer";
-import { pidAlive, looksLive, processCwd, samePath } from "./processInfo";
+import {
+  pidAlive,
+  looksLive,
+  processCwd,
+  samePath,
+  probe,
+  ProbeTimeout,
+} from "./processInfo";
 import { readDevRecord, recordFile } from "./startDevServer";
 
 export interface StopDeps {
   kill: (pid: number, signal: NodeJS.Signals) => void;
-  cwdOf: (pid: number) => string | null;
-  looksLive: (pid: number) => boolean;
+  cwdOf: (pid: number) => string | null | Promise<string | null>;
+  looksLive: (pid: number) => boolean | Promise<boolean>;
   livePid: () => number | null;
   alive: (pid: number) => boolean;
   sleep: (ms: number) => Promise<void>;
-  killTmux: (socket: string) => void;
+  killTmux: (socket: string) => void | Promise<void>;
 }
 
 const realDeps: StopDeps = {
@@ -22,16 +28,13 @@ const realDeps: StopDeps = {
   livePid: () => readLiveRecord()?.pid ?? null,
   alive: pidAlive,
   sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
-  killTmux: (socket) => {
-    const env = { ...process.env };
-    delete env.TMUX;
+  killTmux: async (socket) => {
     try {
-      execFileSync("tmux", ["-S", socket, "kill-server"], {
-        env,
-        stdio: "ignore",
-      });
-    } catch {
-      // No server on it.
+      await probe("env", ["-u", "TMUX", "tmux", "-S", socket, "kill-server"]);
+    } catch (e) {
+      // No server on it, or tmux did not answer in time.
+      if (e instanceof ProbeTimeout)
+        console.warn(`[dev-server] tmux on ${socket} did not answer; left`);
     }
   },
 };
@@ -59,14 +62,14 @@ export async function stopDevServer(
     ok: false,
     message: `Refusing to stop pid ${rec.pid}: ${why}. Nothing was killed.`,
   });
-  const cwd = d.cwdOf(rec.pid);
+  const cwd = await d.cwdOf(rec.pid);
   if (cwd === null || !samePath(cwd, worktree))
     return refuse(
       `its working directory (${cwd ?? "unknown"}) is not ${worktree}`
     );
   if (rec.pid === process.pid || rec.pid === process.ppid)
     return refuse("that is this command's own process");
-  if (rec.pid === d.livePid() || d.looksLive(rec.pid))
+  if (rec.pid === d.livePid() || (await d.looksLive(rec.pid)))
     return refuse("it is the live AgentOS server");
 
   const signal = (s: NodeJS.Signals) => {
@@ -89,7 +92,7 @@ export async function stopDevServer(
     `tmux-${process.getuid?.() ?? 0}`,
     "default"
   );
-  if (fs.existsSync(sock)) d.killTmux(sock);
+  if (fs.existsSync(sock)) await d.killTmux(sock);
   drop();
   return {
     ok: true,

package/lib/dev-servers.ts

@@ -1,3 +1,4 @@
+import { agentosHome } from "./agentos-home";
 import { spawn, execFile } from "child_process";
 import { promisify } from "util";
 import fs from "fs";
@@ -12,7 +13,7 @@ const run = async (file: string, args: string[], cwd?: string) =>
 // A compose service is a name, never an option or more than one word.
 const COMPOSE_SERVICE = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
 
-const LOGS_DIR = path.join(process.env.HOME || "~", ".agent-os", "logs");
+const LOGS_DIR = agentosHome("logs");
 
 // Ensure logs directory exists
 if (!fs.existsSync(LOGS_DIR)) {

package/lib/done/index.ts

@@ -28,7 +28,7 @@ import { deleteMergedRemote } from "./remote";
 import { settleWorktree, type WorktreeFate } from "./worktree";
 import { sessionMergePolicy } from "../tasks/finish";
 import { releasePorts } from "../ports";
-import { dropSessionDatabase } from "../project-config/database";
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { doneOnPeer, peerSessionLink } from "../hosts/peer-actions";
 import { hostLink } from "../hosts/remote-api";
 import { doneHeldTask, isHeldRemote } from "../tasks/contract/held-calls";
@@ -70,7 +70,7 @@ async function stopAgent(s: Session): Promise<void> {
   clearQueue(s.id);
   releasePorts(s.id);
   // Never waited on: the row is read now, and Postgres can't hold this up.
-  void dropSessionDatabase(s.id);
+  void releaseSessionLeftovers(s);
 }
 
 function worktreeLine(f: WorktreeFate): string {

package/lib/health/boots.ts

@@ -6,6 +6,9 @@
  * next boot reads it back.
  */
 
+import fs from "fs";
+import os from "os";
+import path from "path";
 import { db } from "../db";
 import { gitSync } from "../git-exec";
 import { getSetting, putSetting } from "../settings-store";
@@ -62,6 +65,7 @@ export interface BootRow {
   head: string | null;
   prev_seen_at: number | null;
   prev_bg: string | null;
+  deploy: number | null;
 }
 
 export const bootsSince = (since: number) =>
@@ -76,4 +80,37 @@ export const recentBoots = (n = 6) =>
     .prepare(`SELECT * FROM health_boots ORDER BY started_at DESC LIMIT ?`)
     .all(n) as BootRow[];
 
+export const DEPLOY_RESTART_FILE = path.join(
+  os.homedir(),
+  ".agent-os",
+  "autodeploy",
+  "restarted"
+);
+
+// When autodeploy last restarted the server (it writes epoch seconds once the
+// server is back up), or null.
+export function lastDeployRestart(file = DEPLOY_RESTART_FILE): number | null {
+  try {
+    const s = Number.parseInt(fs.readFileSync(file, "utf8").trim(), 10);
+    return Number.isFinite(s) && s > 0 ? s * 1000 : null;
+  } catch {
+    return null;
+  }
+}
+
+// Autodeploy writes its file up to the startup wait after the restart.
+const DEPLOY_LOOKBACK_MS = 15 * MIN;
+
+// Stamps the latest boot that lines up with a planned restart, so it isn't
+// counted as an unexpected one. A crash loop during a deploy keeps its extra
+// boots.
+export function markDeployBoot(restartedAt: number | null): void {
+  if (restartedAt === null) return;
+  db.prepare(
+    `UPDATE health_boots SET deploy = 1 WHERE id = (
+       SELECT id FROM health_boots WHERE started_at BETWEEN ? AND ?
+       ORDER BY started_at DESC LIMIT 1)`
+  ).run(restartedAt - DEPLOY_LOOKBACK_MS, restartedAt + MIN);
+}
+
 export const BOOT_WINDOW_MS = 24 * 60 * MIN;

package/lib/health/ci.ts

@@ -2,7 +2,7 @@
  * How long CI takes, learned from what the orchestrator already sees. Each
  * diff it reads every open PR's verdict; the first time a head is pending is
  * when its run started (to within a diff), and the first time it isn't is
- * when it settled. No extra gh call.
+ * when it settled. No extra gh call. A row lives only while its PR is open.
  */
 
 import { db } from "../db";
@@ -19,6 +19,7 @@ export function observeCi(
   now: number
 ): void {
   db.transaction(() => {
+    const open = new Set<string>();
     for (const f of facts) {
       const pr = f.task?.pr;
       const project = f.project;
@@ -31,6 +32,7 @@ export function observeCi(
         ).run(project, pr.number);
         continue;
       }
+      open.add(`${project}#${pr.number}`);
       if (pr.checks === "pending") {
         // A newer head replaces the run still pending on an older one.
         db.prepare(
@@ -50,13 +52,32 @@ export function observeCi(
         ).run(now, project, pr.number, head);
       }
     }
+    // A PR that left the facts (done, archived) can't be seen merging.
+    const rows = db
+      .prepare(
+        `SELECT project_id, pr_number FROM ci_runs
+         WHERE workspace_id = ? AND settled_at IS NULL`
+      )
+      .all(workspaceId) as { project_id: string; pr_number: number }[];
+    for (const r of rows)
+      if (!open.has(`${r.project_id}#${r.pr_number}`))
+        db.prepare(
+          `DELETE FROM ci_runs WHERE project_id = ? AND pr_number = ?
+           AND settled_at IS NULL`
+        ).run(r.project_id, r.pr_number);
   })();
 }
 
 export function pendingCi(now: number): CiFact[] {
   const rows = db
     .prepare(
-      `SELECT * FROM ci_runs WHERE settled_at IS NULL AND pending_since >= ?`
+      `SELECT r.* FROM ci_runs r
+       WHERE r.settled_at IS NULL AND r.pending_since >= ?
+         AND NOT EXISTS (
+           SELECT 1 FROM session_rows s JOIN projects p ON p.id = s.project_id
+           WHERE p.name = r.project_id AND s.pr_number = r.pr_number
+             AND (s.pr_status IN ('merged', 'closed')
+               OR s.task_status = 'merged'))`
     )
     .all(now - LOST_AFTER_MS) as {
     project_id: string;

package/lib/health/detectors.ts

@@ -90,12 +90,13 @@ export function restarts(f: HealthFacts, c: HealthConfig): Trip[] {
     (t) => f.now - t <= c.restartsWindowMinutes * MIN
   );
   if (recent.length <= c.restartsMax) return [];
+  const deploys = f.deploys.length;
   return [
     trip({
       check: "restarts",
       subject: "server",
       severity: "high",
-      line: `AgentOS restarted ${recent.length} times in the last ${c.restartsWindowMinutes} minutes.`,
+      line: `AgentOS restarted ${recent.length} times in the last ${c.restartsWindowMinutes} minutes${deploys ? ` (besides ${deploys} autodeploy ${deploys === 1 ? "restart" : "restarts"})` : ""}.`,
       detail: { boots: recent },
     }),
   ];

package/lib/health/evidence.ts

@@ -96,7 +96,7 @@ function pipelineSnapshot(f: HealthFacts): string {
   lines.push("Recent server starts:");
   for (const b of recentBoots(6))
     lines.push(
-      `- ${ago(f.now, b.started_at)}${b.head ? ` at ${b.head}` : ""}${b.prev_seen_at ? `; the previous run was last seen ${ago(f.now, b.prev_seen_at)}` : ""}`
+      `- ${ago(f.now, b.started_at)}${b.deploy ? " (autodeploy restart)" : ""}${b.head ? ` at ${b.head}` : ""}${b.prev_seen_at ? `; the previous run was last seen ${ago(f.now, b.prev_seen_at)}` : ""}`
     );
   lines.push(
     `Server errors in the last 10 minutes: ${f.errors.recent} (usual ${Math.round(f.errors.baselineMean)}).`

package/lib/health/facts.ts

@@ -144,6 +144,7 @@ function armed(): ArmedFact[] {
 }
 
 export function gatherFacts(now: number, c: HealthConfig): HealthFacts {
+  const recent = bootsSince(now - c.restartsWindowMinutes * MIN);
   return {
     now,
     machines: machines(now),
@@ -151,9 +152,8 @@ export function gatherFacts(now: number, c: HealthConfig): HealthFacts {
     bg: backgroundJobs(now, c),
     armed: armed(),
     ci: pendingCi(now),
-    boots: bootsSince(now - c.restartsWindowMinutes * MIN).map(
-      (b) => b.started_at
-    ),
+    boots: recent.filter((b) => !b.deploy).map((b) => b.started_at),
+    deploys: recent.filter((b) => b.deploy).map((b) => b.started_at),
     errors: errorRate(now),
   };
 }

package/lib/health/fixtures.ts

@@ -15,6 +15,7 @@ export const facts = (over: Partial<HealthFacts> = {}): HealthFacts => ({
   armed: [],
   ci: [],
   boots: [],
+  deploys: [],
   errors: { recent: 0, baselineMean: 0 },
   ...over,
 });

package/lib/health/tick.ts

@@ -6,7 +6,7 @@
  */
 
 import { runClaude } from "../orchestrator/claude-cli";
-import { leaveHeartbeat } from "./boots";
+import { lastDeployRestart, leaveHeartbeat, markDeployBoot } from "./boots";
 import { healthConfig, type HealthConfig } from "./config";
 import { runDetectors } from "./detectors";
 import { gatherFacts, liveBackgroundJobs } from "./facts";
@@ -134,6 +134,11 @@ export function healthTick(
   if (now - last < EVERY_MS) return [];
   last = now;
   const c = deps.config();
+  try {
+    markDeployBoot(lastDeployRestart());
+  } catch (error) {
+    console.error("[health] deploy restarts:", error);
+  }
   const facts = deps.facts(now, c);
   const found = recordTrips(runDetectors(facts, c), TICK_CHECKS, now);
   for (const row of found.closed) deliverClosed(row, now, deps.route);

package/lib/health/types.ts

@@ -105,6 +105,8 @@ export interface HealthFacts {
   ci: CiFact[];
   // Server start times inside the restart window.
   boots: number[];
+  // Autodeploy's planned restarts inside the same window.
+  deploys: number[];
   errors: { recent: number; baselineMean: number };
 }
 

package/lib/hosts/attach.ts

@@ -1,5 +1,12 @@
 import { SSH_OPTIONS, loginShellCommand, shellQuote } from "./ssh";
 import { isValidTmuxName } from "./tmux-name";
+import { SERVER_ONLY_ENV } from "../agents/server-env";
+
+// For a shared tmux server that already holds them: attach is the one path
+// that cannot prefix the pane command.
+const UNSET_GLOBAL_ENV = SERVER_ONLY_ENV.map(
+  (k) => `set-environment -gu ${k} \\;`
+).join(" ");
 
 export interface AttachSpec {
   sessionName: string;
@@ -28,7 +35,7 @@ export function buildTmuxAttachCommand(spec: AttachSpec): string {
   }
   // Commands chained after an attaching command only run once the client
   // detaches, so options go first; start-server keeps a fresh server alive.
-  const prefix = "tmux start-server \\; set -g mouse on \\;";
+  const prefix = `tmux start-server \\; set -g mouse on \\; ${UNSET_GLOBAL_ENV}`;
   if (spec.attachOnly) {
     // Quoted: zsh expands a bare "=word" to a command path.
     return `${prefix} attach-session -t ${shellQuote(`=${spec.sessionName}`)}`;

package/lib/orchestration.ts

@@ -15,6 +15,7 @@ import { resolveModelForAgent } from "./model-catalog";
 import { type AgentType, getProvider } from "./providers";
 import { statusDetector } from "./status-detector";
 import { wrapWithBanner } from "./banner";
+import { UNSET_SERVER_ENV } from "./agents/server-env";
 import { runInBackground } from "./async-operations";
 import { tmux } from "./tmux/exec";
 import { endTmuxSession } from "./tmux/end";
@@ -168,7 +169,8 @@ export async function spawnWorker(
 
   // Create tmux session with the agent and banner
   const agentCmd = `${provider.command} ${flagsStr}`;
-  const newSessionCmd = wrapWithBanner(agentCmd, provider.preamble);
+  const newSessionCmd =
+    UNSET_SERVER_ENV + wrapWithBanner(agentCmd, provider.preamble);
   try {
     await tmux(["set", "-g", "mouse", "on"]).catch(() => {});
     // The last argument is the agent's command line, which tmux runs.

package/lib/orchestrator/home.ts

@@ -5,10 +5,9 @@
  * sessions.
  */
 
+import { agentosHome } from "../agentos-home";
 import { resolveRoleOrDefault } from "../models/resolve";
 import fs from "fs";
-import os from "os";
-import path from "path";
 import { randomBytes, randomUUID, timingSafeEqual } from "crypto";
 import { db, type Session } from "../db";
 import { getWorkspace } from "../workspaces";
@@ -16,9 +15,7 @@ import { refuseRealStateUnderTest } from "../test-home-guard";
 
 // It works through tools, not in a repo: a scratch folder of its own.
 export const orchestratorDir = (workspaceId: string) =>
-  refuseRealStateUnderTest(
-    path.join(os.homedir(), ".agent-os", "orchestrators", workspaceId)
-  );
+  refuseRealStateUnderTest(agentosHome("orchestrators", workspaceId));
 
 export function getOrchestrator(workspaceId: string): Session | null {
   return (

package/lib/orchestrator/shell-guard.ts

@@ -229,6 +229,8 @@ function aosRefusal(args: string[]): string | null {
     resurrect: T.resurrect,
     stop: T.stop,
   };
+  if (sub === "sweep" && args.includes("--arm"))
+    return "Refused: `aos sweep --arm` turns on removing files and databases, which a person decides: Health, Clean-up, Turn on. `--dry-run` and `--disarm` are fine.";
   if (sub && tool[sub])
     return `Refused: \`aos ${sub}\` isn't for you; use ${tool[sub]}, which is scoped to this workspace and held by Pause.`;
   return null;

package/lib/orchestrator/write-guard.ts

@@ -12,6 +12,7 @@
  * `..` resolved the way the system will resolve it.
  */
 
+import { agentosHome } from "../agentos-home";
 import { execFile } from "child_process";
 import fs from "fs";
 import os from "os";
@@ -296,9 +297,9 @@ export async function orchestratorWriteBounds(
     memory: [...new Set([cwd, await physicalPath(cwd)])].map((c) =>
       path.join(os.homedir(), ".claude", "projects", mangleCwd(c), "memory")
     ),
-    audits: path.join(os.homedir(), ".agent-os", "audits"),
+    audits: agentosHome("audits"),
     quick: quickWorktrees(session.id),
-    state: path.join(os.homedir(), ".agent-os"),
+    state: agentosHome(),
     repos: [...repos, WORKTREES_DIR, process.cwd(), path.dirname(dbPath)],
   };
 }

package/lib/plans/features.ts

@@ -1,6 +1,7 @@
 // A plan that split into pieces: the feature, its pieces, and the one-time
 // checks that turn a plan file into rows. A one-piece plan makes none.
 
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -61,8 +62,7 @@ export interface FeaturePiece {
 const expandHome = (p: string) => p.replace(/^~/, os.homedir());
 
 export const plansDir = () =>
-  process.env.AGENTOS_PLANS_DIR ||
-  path.join(os.homedir(), ".agent-os", "plans");
+  process.env.AGENTOS_PLANS_DIR || agentosHome("plans");
 export const planPathOf = (featureId: string) =>
   path.join(plansDir(), `${featureId}.md`);
 

package/lib/pr-generation.ts

@@ -1,3 +1,4 @@
+import { sessionBaseEnv } from "./agents/server-env";
 import { routedRun } from "./models/launch";
 import { execFile } from "child_process";
 import { git as runGit } from "./git-exec";
@@ -163,7 +164,7 @@ async function claudePrint(cwd: string, prompt: string): Promise<string> {
       ["--print", "--model", routed.model],
       {
         cwd,
-        env: { ...process.env, ...routed.env },
+        env: { ...sessionBaseEnv(), ...routed.env },
         encoding: "utf-8",
         timeout: 30_000,
         killSignal: "SIGKILL",

package/lib/program-status/claude-hooks.ts

@@ -1,9 +1,9 @@
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { NO_ATTRIBUTION } from "../agents/attribution";
 
-const DIR = path.join(os.homedir(), ".agent-os");
+const DIR = agentosHome();
 const HOOK = path.join(DIR, "bin", "agentos-status");
 const SETTINGS = path.join(DIR, "claude-status-hooks.json");
 const SUBAGENT_HOOK = path.join(DIR, "bin", "agentos-subagent-model.mjs");

package/lib/program-status/tap.ts

@@ -9,9 +9,9 @@
  * Remote-host sessions are not tapped: their output never passes through
  * this machine except while attached. They keep reading the screen.
  */
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
 import net from "net";
-import os from "os";
 import path from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -50,7 +50,7 @@ const replied = new Map<string, number>();
 
 // In a directory only this user can enter: only they can write reports.
 export function tapSocketPath(port: number): string {
-  return path.join(os.homedir(), ".agent-os", "run", `osc-${port}.sock`);
+  return agentosHome("run", `osc-${port}.sock`);
 }
 
 async function foreground(name: string): Promise<string | undefined> {