@saadnvd1/agent-os 0.3.660 → 0.3.664

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

package/lib/sessions/leftovers.ts

@@ -0,0 +1,61 @@
+/**
+ * What a task leaves outside its checkout, released when it ends (merge,
+ * drop, done, move, delete): its dev server, its private database and what
+ * the project derived from it, and its temp folder. The worktree itself is
+ * removed by the caller, which knows whether anything in it would be lost.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { stopDevServer } from "../dev-instance/stopDevServer";
+import { dropSessionDatabase } from "../project-config/database";
+
+export const SESSION_TMP_PREFIX = "agentos-s-";
+
+// The whole id: a shortened one could name two sessions' folders alike.
+export const tmpName = (sessionId: string) => sessionId.replace(/[^\w-]/g, "");
+
+export const sessionTmpDir = (sessionId: string) =>
+  path.join(os.tmpdir(), `${SESSION_TMP_PREFIX}${tmpName(sessionId)}`);
+
+export interface LeftoverDeps {
+  stopDev: (worktree: string) => Promise<unknown>;
+  dropDatabase: (sessionId: string) => Promise<void>;
+  removeDir: (dir: string) => Promise<void>;
+}
+
+const realDeps: LeftoverDeps = {
+  stopDev: (worktree) => stopDevServer(worktree),
+  dropDatabase: dropSessionDatabase,
+  removeDir: (dir) => fs.promises.rm(dir, { recursive: true, force: true }),
+};
+
+/**
+ * Never throws and never waits on a step that can't be reached: each is
+ * tried on its own. Callers read the session row first and don't await this.
+ */
+export async function releaseSessionLeftovers(
+  session: { id: string; worktree_path?: string | null },
+  deps: Partial<LeftoverDeps> = {}
+): Promise<void> {
+  const d = { ...realDeps, ...deps };
+  const steps: Array<[string, () => Promise<unknown>]> = [
+    // First: its row is read before the caller deletes it.
+    ["database", () => d.dropDatabase(session.id)],
+    [
+      "dev server",
+      async () => {
+        if (session.worktree_path) await d.stopDev(session.worktree_path);
+      },
+    ],
+    ["temp folder", () => d.removeDir(sessionTmpDir(session.id))],
+  ];
+  for (const [what, step] of steps) {
+    try {
+      await step();
+    } catch (error) {
+      console.error(`[leftovers] ${what} for ${session.id}:`, error);
+    }
+  }
+}

package/lib/simulator/agent-device.ts

@@ -5,9 +5,9 @@
  * here, so it can only drive its own simulator.
  */
 
+import { agentosHome } from "../agentos-home";
 import { execFile } from "child_process";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import { promisify } from "util";
 
@@ -15,7 +15,7 @@ const execFileAsync = promisify(execFile);
 
 export const AGENT_DEVICE_VERSION = "0.21.27";
 
-const root = () => path.join(os.homedir(), ".agent-os");
+const root = () => agentosHome();
 export const toolDir = () =>
   path.join(root(), "tools", `agent-device-${AGENT_DEVICE_VERSION}`);
 export const toolBin = () =>

package/lib/tasks/finish.ts

@@ -34,7 +34,7 @@ import {
   prFor,
   projectPathFor,
 } from "./session";
-import { dropSessionDatabase } from "../project-config/database";
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { captureMergedTask } from "../session-logs";
 import { sessionEnded } from "../experiments/hooks";
 import { snapshotWorktree } from "../resurrect/snapshot";
@@ -62,7 +62,7 @@ async function cleanup(
   const keepRemoteBranch = opts.keepRemoteBranch ?? false;
   await endSessionAgent(session);
   // Never waited on: the row is read now, and Postgres can't hold this up.
-  void dropSessionDatabase(session.id);
+  void releaseSessionLeftovers(session);
   if (session.worktree_path && opts.merged) {
     const fate = await settleWorktree(session, opts.merged).catch(() => null);
     if (fate?.action === "kept")

package/lib/tasks/import.ts

@@ -5,6 +5,7 @@
  * again returns the task it made the first time.
  */
 
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -13,10 +14,7 @@ import { db, queries, type Session } from "../db";
 import { setupWorktree } from "../env-setup";
 import { allocatePorts } from "../ports";
 import { loadProjectConfig, portBases } from "../project-config";
-import {
-  dropSessionDatabase,
-  ensureSessionDatabase,
-} from "../project-config/database";
+import { ensureSessionDatabase } from "../project-config/database";
 import { runInBackground } from "../async-operations";
 import { launchClaude } from "../agents/launch";
 import { resolveModelForAgent } from "../model-catalog";
@@ -238,7 +236,7 @@ async function arrive(
   } catch (err) {
     // Nothing runs here, so the source may resume it: leave no row behind,
     // and no database (the drop reads the row before it goes).
-    void dropSessionDatabase(id);
+    void releaseSessionLeftovers({ id });
     if (bundle.chat) {
       stopChat(id);
       dropChat(id);

package/lib/tasks/move.ts

@@ -26,7 +26,7 @@ import {
 } from "./move-bundle";
 import { stepProgress } from "./move-progress";
 import { PLAN_FILE } from "../models/plan-step";
-import { dropSessionDatabase } from "../project-config/database";
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { releaseChat } from "../chat/runner";
 import { collectWhileMoving } from "../chat/hold";
 import { packChat, stopChatForMove } from "./move-chat";
@@ -258,7 +258,7 @@ export function markMoved(id: string, to: string): void {
     { task_status: ["running", "moving"] }
   );
   // It goes on there with a copy of its own.
-  if (moved) void dropSessionDatabase(id);
+  if (moved) void releaseSessionLeftovers({ id });
 }
 
 /**

package/lib/tasks/moved-away.ts

@@ -5,6 +5,7 @@
  * no commit a remote lacks). The row stays, archived, as history.
  */
 
+import { releaseSessionLeftovers } from "../sessions/leftovers";
 import { db, type Session } from "../db";
 import { endSessionAgent } from "../sessions/end";
 import { releasePorts } from "../ports";
@@ -28,6 +29,7 @@ export async function cleanUpMovedAway(id: string): Promise<WorktreeFate> {
       path: s.worktree_path ?? "",
     })
   );
+  void releaseSessionLeftovers(s);
   archiveSession(id);
   if (fate.action === "kept")
     console.warn(

package/lib/tasks/state.ts

@@ -137,6 +137,10 @@ const UNFINISHED = [
 const outcome = (c: RollupEntry) =>
   (c.conclusion || c.state || c.status || "").toUpperCase();
 
+// A skipped or neutral run is settled and says nothing about a rerun, so it
+// never makes a check look unsettled.
+const counts = (c: RollupEntry) => !["SKIPPED", "NEUTRAL"].includes(outcome(c));
+
 // Job names repeat across workflows, and a status context can share a check
 // run's name, so a check is its kind, workflow and name together.
 const checkKey = (c: RollupEntry) => {
@@ -198,7 +202,7 @@ const groupByCheck = <T extends RollupEntry>(rollup: T[]) => {
 // rollup can't tell one attempt from the next.
 function shownAttempts(rollup: RollupEntry[]): Map<string, number | null> {
   const shown = new Map<string, number | null>();
-  for (const c of rollup) {
+  for (const c of rollup.filter(counts)) {
     const run = actionsRunOf(c);
     if (!run) continue;
     const key = `${run.repo}#${run.id}`;
@@ -226,7 +230,7 @@ export function rerunsToLookUp(
     string,
     { repo: string; id: string; attempt: string | null }
   >();
-  for (const group of groupByCheck(rollup).values()) {
+  for (const group of groupByCheck(rollup.filter(counts)).values()) {
     if (group.length < 2) continue;
     for (const c of group) {
       const run = actionsRunOf(c);
@@ -259,7 +263,7 @@ export function settleReruns<T extends RollupEntry>(
   const shown = shownAttempts(rollup);
   const drop = new Set<RollupEntry>();
   const unsettled: RollupEntry[] = [];
-  for (const group of groupByCheck(rollup).values()) {
+  for (const group of groupByCheck(rollup.filter(counts)).values()) {
     if (group.length < 2) continue;
     const located = group.map((c) => ({ c, run: actionsRunOf(c) }));
     // Not all GitHub Actions: nothing says which run is stale, so all count.

package/lib/tasks/ui-brief.ts

@@ -80,6 +80,6 @@ If your diff changes what a user sees, run the app and look at every changed scr
 - Log in and go to pages by URL, from the login, pages and map under "Running this project" when they are there. Exploring the UI to find a page is the most expensive thing a session does.
 - One snapshot to find a uid, then act. Verify with a screenshot of the one element or a small \`evaluate_script\` returning the one value you need, not another full snapshot.
 - Verify the thing that would be wrong, not the thing that is easy to see: a page that rendered proves it rendered. Fix anything visibly off (gaps, clipping, overlap, horizontal scroll, stray bands, misalignment; measure rects with \`evaluate_script\` and report numbers) and read the console for errors.
-- Save screenshots of the final changed screens with \`filePath\` under \`${SCREENSHOT_DIR}/\`, after \`mkdir -p ${SCREENSHOT_DIR} && printf '*\\n' > .agentos/.gitignore\`. That folder is inside the browser's allowed root and git ignores it; a path in /tmp is refused.
-- Add a **Browser check** section to the PR body: the pages and widths you checked, what you fixed, and the screenshot file names. If you didn't check (no visible change, or no browser), say why in one line.`;
+- Save screenshots of the final changed screens with \`filePath\` under \`${SCREENSHOT_DIR}/\`, after \`mkdir -p ${SCREENSHOT_DIR} && printf '*\\n' > .agentos/.gitignore\`. That folder is inside the browser's allowed root and git ignores it; a path in /tmp is refused. AgentOS keeps these files after the worktree is removed.
+- Add a **Browser check** section to the PR body: the pages and widths you checked, what you fixed, and the screenshot file names (names only, never a worktree path: the worktree is removed when the task ends). If you didn't check (no visible change, or no browser), say why in one line.`;
 }

package/lib/tmux/exec.ts

@@ -1,5 +1,6 @@
 import { execFile } from "child_process";
 import { promisify } from "util";
+import { sessionBaseEnv } from "../agents/server-env";
 
 const execFileAsync = promisify(execFile);
 
@@ -9,6 +10,7 @@ export async function tmux(args: string[], timeout = 10_000): Promise<string> {
   const { stdout } = await execFileAsync("tmux", args, {
     timeout,
     maxBuffer: 8 << 20,
+    env: sessionBaseEnv(),
   });
   return stdout;
 }
@@ -24,7 +26,7 @@ export async function pasteText(
     const child = execFile(
       "tmux",
       ["load-buffer", "-b", buffer, "-"],
-      { timeout: 10_000 },
+      { timeout: 10_000, env: sessionBaseEnv() },
       (err) => (err ? reject(err) : resolve())
     );
     // tmux gone before it read everything is a failed paste, not a crash.

package/lib/worktree-deps/fastcopy.ts

@@ -5,9 +5,9 @@
  * none works, and the caller installs or copies plainly instead.
  */
 
+import { agentosHome } from "../agentos-home";
 import { execFile } from "child_process";
 import * as fs from "fs";
-import * as os from "os";
 import * as path from "path";
 import { promisify } from "util";
 import type { CopyMode } from "./spare";
@@ -18,7 +18,7 @@ export type FastMode = Exclude<CopyMode, "copy">;
 
 // Where hardlinked dependencies are kept: one real copy per lockfile, so a
 // write through a link can only ever reach this, never the main checkout.
-export const STORE_ROOT = path.join(os.homedir(), ".agent-os", "deps-store");
+export const STORE_ROOT = agentosHome("deps-store");
 
 // Files tools rewrite in place. A hardlink would carry the write back into
 // the store, so these are real copies in every worktree.

package/lib/worktree-deps/spare.ts

@@ -8,13 +8,13 @@
  * one made before the dependencies changed is never taken, and is pruned.
  */
 
+import { agentosHome } from "../agentos-home";
 import { createHash } from "crypto";
 import { spawn } from "child_process";
 import * as fs from "fs";
-import * as os from "os";
 import * as path from "path";
 
-export const SPARE_ROOT = path.join(os.homedir(), ".agent-os", "spare");
+export const SPARE_ROOT = agentosHome("spare");
 
 // A half-built spare left by a restart is removed after this long.
 const BUILDING_TTL_MS = 30 * 60 * 1000;