@saadnvd1/agent-os 0.3.662 → 0.3.664

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/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/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> {

package/lib/project-config/database.ts

@@ -41,7 +41,7 @@ export type PgRun = (
   env: NodeJS.ProcessEnv
 ) => Promise<{ code: number; out: string }>;
 
-const pgRun: PgRun = (cmd, args, env) =>
+export const pgRun: PgRun = (cmd, args, env) =>
   new Promise((resolve) => {
     execFile(
       cmd,
@@ -66,10 +66,10 @@ const pgRun: PgRun = (cmd, args, env) =>
 // A plain database name: never a connection string (`host=…`,
 // `postgres://…`) or an option, which pg_dump would take as one.
 const DB_NAME = /^[A-Za-z0-9_][A-Za-z0-9_$.-]{0,62}$/;
-const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
+export const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
 // One socket folder: libpq reads a comma as a list of hosts to try in turn,
 // so `/nope,db.example.com` would reach the second.
-const SOCKET_DIR = /^\/[^,=\s'"\\]*$/;
+export const SOCKET_DIR = /^\/[^,=\s'"\\]*$/;
 
 // Why `declared` can't be used, or null. A socket folder is local too.
 export function refusal(declared: DatabaseDecl): string | null {
@@ -86,13 +86,22 @@ export function refusal(declared: DatabaseDecl): string | null {
   return null;
 }
 
-const MARK = (sessionId: string) => `agentos session ${sessionId}`;
+export const MARK = (sessionId: string) => `agentos session ${sessionId}`;
 const PENDING = (sessionId: string) => `${MARK(sessionId)} (copying)`;
 
+export const sessionHash = (sessionId: string) =>
+  createHash("sha256").update(sessionId).digest("hex").slice(0, 12);
+
+// The token a session's copy carries, and so does anything a project derives
+// from it (`<copy>_test`, `<from>_test_aos_<hash>`): the one convention that
+// says AgentOS's session made a database.
+const TASK_DB = /_aos_([0-9a-f]{12})(?:_[A-Za-z0-9]+)*$/;
+export const taskHashOf = (name: string): string | null =>
+  TASK_DB.exec(name)?.[1] ?? null;
+
 // `<from>_aos_<12 hex of the session id>`, within Postgres's 63 bytes.
 export function databaseName(from: string, sessionId: string): string {
-  const hash = createHash("sha256").update(sessionId).digest("hex");
-  const suffix = `_aos_${hash.slice(0, 12)}`;
+  const suffix = `_aos_${sessionHash(sessionId)}`;
   return `${from.slice(0, 63 - suffix.length)}${suffix}`;
 }
 
@@ -122,7 +131,7 @@ const oneLine = (s: string, n = 200) => {
 };
 
 // Every database on the server with its comment, or why there's no answer.
-async function listDatabases(
+export async function listDatabases(
   run: PgRun,
   env: NodeJS.ProcessEnv
 ): Promise<Map<string, string> | string> {
@@ -165,7 +174,7 @@ async function copy(
   // recognised and remade rather than left or reused half-filled.
   const created = await run(
     "createdb",
-    ["-T", "template0", target, PENDING(sessionId)],
+    ["-T", "template0", "--", target, PENDING(sessionId)],
     env
   );
   if (created.code !== 0)
@@ -175,7 +184,7 @@ async function copy(
   try {
     let step = await run(
       "pg_dump",
-      ["--no-owner", "--no-privileges", "-f", dump, from],
+      ["--no-owner", "--no-privileges", "-f", dump, "--", from],
       env
     );
     if (step.code === 0) {
@@ -191,7 +200,7 @@ async function copy(
       );
     }
     if (step.code !== 0) {
-      await run("dropdb", ["--if-exists", target], env);
+      await run("dropdb", ["--if-exists", "--", target], env);
       return `could not copy ${from} into ${target} (${oneLine(step.out, 300)}); ${target} was dropped again`;
     }
     return null;
@@ -243,7 +252,7 @@ async function makeDatabase(
     // An interrupted copy of ours: made again from the start.
     if (!record({ ...state, name: target, pending: true }))
       return { ...state, error: ENDED };
-    const dropped = await run("dropdb", ["--if-exists", target], env);
+    const dropped = await run("dropdb", ["--if-exists", "--", target], env);
     if (dropped.code !== 0)
       return {
         ...state,
@@ -399,7 +408,10 @@ async function dropDatabase(
     console.warn(`[database] ${name} left: ${listed}`);
     return;
   }
-  if (!listed.has(name)) return void forget();
+  if (!listed.has(name)) {
+    await dropDerived(sessionId, state, listed, run, env);
+    return void forget();
+  }
   const comment = listed.get(name);
   if (comment !== MARK(sessionId) && comment !== PENDING(sessionId)) {
     console.warn(`[database] ${name} left: AgentOS didn't make it`);
@@ -408,9 +420,52 @@ async function dropDatabase(
   // The session is over: a dev server left running in its worktree and
   // still connected is a straggler, ended by --force (Postgres 13+; a plain
   // drop for an older server).
-  let dropped = await run("dropdb", ["--if-exists", "--force", name], env);
+  let dropped = await run(
+    "dropdb",
+    ["--if-exists", "--force", "--", name],
+    env
+  );
   if (dropped.code !== 0)
-    dropped = await run("dropdb", ["--if-exists", name], env);
-  if (dropped.code === 0) forget();
-  else console.warn(`[database] ${name} left: ${oneLine(dropped.out)}`);
+    dropped = await run("dropdb", ["--if-exists", "--", name], env);
+  if (dropped.code === 0) {
+    await dropDerived(sessionId, state, listed, run, env);
+    forget();
+  } else console.warn(`[database] ${name} left: ${oneLine(dropped.out)}`);
+}
+
+// What the project's own tooling made from the copy (a Rails `_test`
+// database): same session token, never the declared source.
+async function dropDerived(
+  sessionId: string,
+  state: SessionDatabase,
+  listed: Map<string, string>,
+  run: PgRun,
+  env: NodeJS.ProcessEnv
+): Promise<void> {
+  const hash = sessionHash(sessionId);
+  for (const other of listed.keys()) {
+    if (other === state.from || other === state.name) continue;
+    if (taskHashOf(other) !== hash) continue;
+    // A plain drop, and not while anyone is connected: it is another
+    // task's or a person's session if the token matches by accident.
+    const busy = await run(
+      "psql",
+      [
+        "-X",
+        "-d",
+        "postgres",
+        "-tAq",
+        "-c",
+        `select count(*) from pg_stat_activity where datname = ${quoteLiteral(other)}`,
+      ],
+      env
+    );
+    if (busy.code !== 0 || Number(busy.out.trim()) > 0) {
+      console.warn(`[database] ${other} left: connected or unreadable`);
+      continue;
+    }
+    const done = await run("dropdb", ["--if-exists", "--", other], env);
+    if (done.code !== 0)
+      console.warn(`[database] ${other} left: ${oneLine(done.out)}`);
+  }
 }

package/lib/project-config/session.ts

@@ -4,7 +4,9 @@
  * an agent editing agentos.json on its branch can't change its own launch.
  */
 
+import fs from "fs";
 import os from "os";
+import { sessionTmpDir } from "../sessions/leftovers";
 import { db } from "../db";
 import { getProject } from "../projects";
 import { sessionPorts } from "../ports";
@@ -35,6 +37,21 @@ export function sessionConfig(
   return { ...loaded, ports: sessionPorts(sessionId) };
 }
 
+// A task's own temp folder, so what it leaves there is removed with it.
+// Only a session in a worktree: an orchestrator or a terminal in a checkout
+// is long-lived and keeps the system's.
+function taskTmpEnv(sessionId: string): Record<string, string> {
+  const row = db
+    .prepare(`SELECT worktree_path FROM sessions WHERE id = ?`)
+    .get(sessionId) as { worktree_path: string | null } | undefined;
+  if (!row?.worktree_path) return {};
+  const dir = sessionTmpDir(sessionId);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  // A folder left by an earlier run keeps its old mode otherwise.
+  fs.chmodSync(dir, 0o700);
+  return { TMPDIR: dir };
+}
+
 // The project's env and the session's ports. Never throws: a terminal or a
 // chat must still open when the config can't be read.
 export function sessionProjectEnv(sessionId: string): Record<string, string> {
@@ -43,6 +60,7 @@ export function sessionProjectEnv(sessionId: string): Record<string, string> {
     return {
       ...projectEnv(config, ports),
       ...(config.database ? databaseEnv(sessionDatabase(sessionId)) : {}),
+      ...taskTmpEnv(sessionId),
     };
   } catch (error) {
     console.error(`[project-config] env for ${sessionId}:`, error);

package/lib/security/tailnet-https.ts

@@ -10,10 +10,10 @@
  * address. AgentOS never runs `tailscale serve` or funnel.
  */
 
+import { agentosHome } from "../agentos-home";
 import { execFile } from "child_process";
 import fs from "fs";
 import https from "https";
-import os from "os";
 import path from "path";
 import type { IncomingMessage, ServerResponse } from "http";
 import type { Socket } from "net";
@@ -76,7 +76,7 @@ function runCert(
 /** Gets (or refreshes) the certificate; null when the tailnet can't issue one. */
 export async function tailnetCert(
   log: (line: string) => void = console.log,
-  dir = path.join(os.homedir(), ".agent-os", "tls")
+  dir = agentosHome("tls")
 ) {
   const ts = await tailscaleStatus();
   const bin = tailscaleBinary();

package/lib/session-artifacts/collect.ts

@@ -14,6 +14,7 @@ import { git } from "../git-exec";
 import { PLAN_FILE } from "../models/plan-step";
 import { listArtifacts } from "../artifacts/store";
 import { allowedRoots, within } from "./access";
+import { SCREENSHOT_DIR } from "../tasks/ui-brief";
 import {
   fromItems,
   fromPr,
@@ -293,6 +294,20 @@ export async function collectArtifacts(
 
 export const cachedCount = () => cache.size;
 
+// What the UI brief has a terminal session save, whether or not a chat tool
+// call named it: the PR names these files and the worktree is about to go.
+export function screenshotsIn(worktree: string): string[] {
+  const dir = path.join(worktree, SCREENSHOT_DIR);
+  try {
+    return fs
+      .readdirSync(dir)
+      .filter((f) => /\.(png|jpe?g|webp)$/i.test(f))
+      .map((f) => path.join(dir, f));
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Before a session's worktree is removed: copy what it made there that git
  * doesn't hold. Never throws, and never holds up the removal for long.
@@ -309,7 +324,9 @@ export async function keepSessionFiles(sessionId: string): Promise<void> {
     const files = entries
       .map((e) => e.read)
       .filter((f): f is string => !!f && !!relInside(worktree, f));
-    await keepFiles(sessionId, worktree, files);
+    await keepFiles(sessionId, worktree, [
+      ...new Set([...files, ...screenshotsIn(worktree)]),
+    ]);
   } catch (error) {
     console.error(`[session-artifacts] keeping ${sessionId}:`, error);
   } finally {

package/lib/session-artifacts/keep.ts

@@ -5,8 +5,8 @@
  * copy; the manifest records them so the view can say "in the PR".
  */
 
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { git } from "../git-exec";
 import { isSecretPath } from "../secret-paths";
@@ -23,9 +23,7 @@ export interface Manifest {
 }
 
 export function keptDir(): string {
-  return (
-    process.env.AGENTOS_KEPT_DIR || path.join(os.homedir(), ".agent-os", "kept")
-  );
+  return process.env.AGENTOS_KEPT_DIR || agentosHome("kept");
 }
 
 const safeId = (sessionId: string) => sessionId.replace(/[^\w-]/g, "_");

package/lib/session-audit/store.ts

@@ -8,8 +8,8 @@
  * one before.
  */
 
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import type { Summary } from "./aggregate";
 
@@ -19,10 +19,7 @@ export const AUDIT_NAME = /^[a-z0-9][a-z0-9-]{0,80}$/;
 export const SESSIONS_KIND = "sessions";
 
 export function auditsRoot(): string {
-  return (
-    process.env.AGENTOS_AUDITS_DIR ||
-    path.join(os.homedir(), ".agent-os", "audits")
-  );
+  return process.env.AGENTOS_AUDITS_DIR || agentosHome("audits");
 }
 
 export function auditsDir(): string {

package/lib/session-logs/folder.ts

@@ -6,8 +6,8 @@
  * can be public, and a log holds briefs and reviews.
  */
 
+import { agentosHome } from "../agentos-home";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { db } from "../db";
 import { slugify } from "../git";
@@ -17,8 +17,7 @@ import { expand, repoPaths, resolved, within } from "./paths";
 
 // AGENTOS_SESSION_LOGS_DIR moves the default (tests keep it off the real one).
 export const DEFAULT_ROOT = () =>
-  process.env.AGENTOS_SESSION_LOGS_DIR ||
-  path.join(os.homedir(), ".agent-os", "session-logs");
+  process.env.AGENTOS_SESSION_LOGS_DIR || agentosHome("session-logs");
 
 const key = (projectId: string) => `session-logs.folder.${projectId}`;
 

package/lib/sessions/launch.ts

@@ -3,10 +3,10 @@
  * then (for a worktree) the setup in the background, then the first message.
  */
 
+import { agentosHome } from "../agentos-home";
 import type { StartVia } from "../tasks/starter";
 import fs from "fs";
 import os from "os";
-import path from "path";
 import { randomUUID } from "crypto";
 import { db, queries, type Session } from "../db";
 import type { AgentType } from "../providers";
@@ -45,7 +45,7 @@ export const DEFAULT_START_VIEW: StartView = "chat";
 export const startView = (v: unknown): StartView | undefined =>
   v === "chat" || v === "terminal" ? v : undefined;
 
-export const SCRATCH_DIR = path.join(os.homedir(), ".agent-os", "scratch");
+export const SCRATCH_DIR = agentosHome("scratch");
 
 export interface LaunchInput {
   // The client's key for this start (a draft's id): it becomes the