@gemslibe/rbo 0.2.0 → 0.3.0

package/dist/rbo.js

@@ -204,11 +204,11 @@ async function resolveContainedCwd(projectPath, cwd) {
   if (!isPathContained(projectPath, joined)) {
     throw new Error(`cwd escapes project root: ${cwd}`);
   }
-  const { access: access4, mkdir: mkdir16 } = await import("node:fs/promises");
+  const { access: access4, mkdir: mkdir15 } = await import("node:fs/promises");
   try {
     await access4(joined);
   } catch {
-    await mkdir16(joined, { recursive: true });
+    await mkdir15(joined, { recursive: true });
   }
   await assertRealPathContained(projectPath, joined);
   return resolveRealPath(joined);
@@ -2028,7 +2028,7 @@ var init_runtime_env = __esm({
 });
 
 // ../../packages/executor/dist/windows-executor-path.js
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname as dirname3, join as join11 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -2048,7 +2048,7 @@ function describeWindowsExecutorResolution(options = {}) {
   const env = options.env ?? process.env;
   const platform3 = options.platform ?? process.platform;
   const arch2 = options.arch ?? process.arch;
-  const exists = options.existsSyncFn ?? existsSync2;
+  const exists = options.existsSyncFn ?? existsSync3;
   const moduleDir = options.moduleDir ?? dirname3(fileURLToPath(import.meta.url));
   const fromEnv = env.RBO_WINDOWS_EXECUTOR;
   if (fromEnv && exists(fromEnv)) {
@@ -4238,7 +4238,7 @@ var init_materialize = __esm({
 });
 
 // ../../packages/snapshot/dist/index.js
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var Sha256HexSchema, ContentIdSchema, SafeRelativePathSchema, SnapshotFileEntrySchema, SnapshotWorkspaceSchema, SnapshotAdditionalRootSchema, SnapshotRepoSchema, payloadBase, FullSnapshotManifestSchema, GitOverlaySnapshotManifestSchema, SnapshotManifestSchema, SnapshotInstanceSchema;
 var init_dist3 = __esm({
   "../../packages/snapshot/dist/index.js"() {
@@ -4252,88 +4252,88 @@ var init_dist3 = __esm({
     init_capture();
     init_overlay();
     init_materialize();
-    Sha256HexSchema = z6.string().regex(/^[0-9a-f]{64}$/i);
-    ContentIdSchema = z6.string().regex(/^sha256:[0-9a-f]{64}$/i);
-    SafeRelativePathSchema = z6.string().min(1).refine((value) => isSafeRelativePath(value), {
+    Sha256HexSchema = z7.string().regex(/^[0-9a-f]{64}$/i);
+    ContentIdSchema = z7.string().regex(/^sha256:[0-9a-f]{64}$/i);
+    SafeRelativePathSchema = z7.string().min(1).refine((value) => isSafeRelativePath(value), {
       message: "must be a relative path without '..', absolute, or UNC segments"
     });
-    SnapshotFileEntrySchema = z6.discriminatedUnion("type", [
-      z6.object({
-        path: z6.string().min(1),
-        type: z6.literal("file"),
-        mode: z6.enum(["100644", "100755"]),
-        size: z6.number().int().nonnegative(),
+    SnapshotFileEntrySchema = z7.discriminatedUnion("type", [
+      z7.object({
+        path: z7.string().min(1),
+        type: z7.literal("file"),
+        mode: z7.enum(["100644", "100755"]),
+        size: z7.number().int().nonnegative(),
         sha256: Sha256HexSchema
       }),
-      z6.object({
-        path: z6.string().min(1),
-        type: z6.literal("symlink"),
-        mode: z6.literal("120000"),
-        target: z6.string().min(1)
+      z7.object({
+        path: z7.string().min(1),
+        type: z7.literal("symlink"),
+        mode: z7.literal("120000"),
+        target: z7.string().min(1)
       })
     ]);
-    SnapshotWorkspaceSchema = z6.object({
+    SnapshotWorkspaceSchema = z7.object({
       main_mount: SafeRelativePathSchema,
-      cwd: z6.string().min(1).refine((value) => isSafeRelativePath(value, { allowDot: true }), {
+      cwd: z7.string().min(1).refine((value) => isSafeRelativePath(value, { allowDot: true }), {
         message: "must be a relative path without '..', absolute, or UNC segments"
       })
     });
-    SnapshotAdditionalRootSchema = z6.object({
-      id: z6.string().min(1),
+    SnapshotAdditionalRootSchema = z7.object({
+      id: z7.string().min(1),
       mount: SafeRelativePathSchema,
-      file_count: z6.number().int().nonnegative(),
-      total_size: z6.number().int().nonnegative(),
+      file_count: z7.number().int().nonnegative(),
+      total_size: z7.number().int().nonnegative(),
       tree_sha256: Sha256HexSchema,
-      mode: z6.enum(["read_only", "read_write"]).default("read_only")
-    });
-    SnapshotRepoSchema = z6.object({
-      canonical_id: z6.string().min(1),
-      url: z6.string().min(1),
-      branch: z6.string().nullable(),
-      base_commit: z6.string().min(1),
-      head_is_pushed: z6.boolean(),
+      mode: z7.enum(["read_only", "read_write"]).default("read_only")
+    });
+    SnapshotRepoSchema = z7.object({
+      canonical_id: z7.string().min(1),
+      url: z7.string().min(1),
+      branch: z7.string().nullable(),
+      base_commit: z7.string().min(1),
+      head_is_pushed: z7.boolean(),
       /** Optional; Controller derives from branch when absent (§10.6). */
-      fetch_refs: z6.array(z6.string().min(1)).optional()
+      fetch_refs: z7.array(z7.string().min(1)).optional()
     });
     payloadBase = {
-      format: z6.literal("tar"),
-      compression: z6.literal("zstd"),
+      format: z7.literal("tar"),
+      compression: z7.literal("zstd"),
       sha256: Sha256HexSchema,
-      size: z6.number().int().nonnegative()
+      size: z7.number().int().nonnegative()
     };
-    FullSnapshotManifestSchema = z6.object({
-      schema_version: z6.literal(1),
+    FullSnapshotManifestSchema = z7.object({
+      schema_version: z7.literal(1),
       content_id: ContentIdSchema,
       repo: SnapshotRepoSchema.partial({ base_commit: true }).optional(),
       workspace: SnapshotWorkspaceSchema,
-      source: z6.object({
-        files: z6.array(SnapshotFileEntrySchema),
-        empty_directories: z6.array(z6.string()).default([])
+      source: z7.object({
+        files: z7.array(SnapshotFileEntrySchema),
+        empty_directories: z7.array(z7.string()).default([])
       }),
-      additional_roots: z6.array(SnapshotAdditionalRootSchema).default([]),
-      payload: z6.object({ mode: z6.literal("full"), ...payloadBase })
+      additional_roots: z7.array(SnapshotAdditionalRootSchema).default([]),
+      payload: z7.object({ mode: z7.literal("full"), ...payloadBase })
     }).strict();
-    GitOverlaySnapshotManifestSchema = z6.object({
-      schema_version: z6.literal(1),
+    GitOverlaySnapshotManifestSchema = z7.object({
+      schema_version: z7.literal(1),
       content_id: ContentIdSchema,
       repo: SnapshotRepoSchema,
       workspace: SnapshotWorkspaceSchema,
-      overlay: z6.object({
-        files: z6.array(SnapshotFileEntrySchema),
-        deletions: z6.array(z6.string()),
-        empty_directories: z6.array(z6.string()).default([])
+      overlay: z7.object({
+        files: z7.array(SnapshotFileEntrySchema),
+        deletions: z7.array(z7.string()),
+        empty_directories: z7.array(z7.string()).default([])
       }),
-      additional_roots: z6.array(SnapshotAdditionalRootSchema).default([]),
-      payload: z6.object({ mode: z6.literal("git_overlay"), ...payloadBase })
+      additional_roots: z7.array(SnapshotAdditionalRootSchema).default([]),
+      payload: z7.object({ mode: z7.literal("git_overlay"), ...payloadBase })
     }).strict();
-    SnapshotManifestSchema = z6.union([
+    SnapshotManifestSchema = z7.union([
       FullSnapshotManifestSchema,
       GitOverlaySnapshotManifestSchema
     ]);
-    SnapshotInstanceSchema = z6.object({
-      snapshot_id: z6.string().min(1),
+    SnapshotInstanceSchema = z7.object({
+      snapshot_id: z7.string().min(1),
       content_id: ContentIdSchema,
-      captured_at: z6.string().min(1)
+      captured_at: z7.string().min(1)
     });
   }
 });
@@ -4723,21 +4723,48 @@ var init_dist4 = __esm({
 });
 
 // ../controller/dist/config.js
-import { mkdirSync as mkdirSync5 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join25 } from "node:path";
+import { z as z8 } from "zod";
 function parseCsv2(raw) {
   if (!raw?.trim()) {
     return [];
   }
   return raw.split(",").map((part) => part.trim()).filter(Boolean);
 }
-function parseGitAllowlist2(overrides) {
-  if (overrides) {
-    return overrides;
+function envSet2(key, env = process.env) {
+  return env[key] !== void 0;
+}
+function parseEnvNumber2(key, raw) {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    throw new Error(`Invalid ${key}=${JSON.stringify(raw)}: expected a finite number`);
+  }
+  return n;
+}
+function parseEnvInt2(key, raw) {
+  const n = parseEnvNumber2(key, raw);
+  if (!Number.isInteger(n)) {
+    throw new Error(`Invalid ${key}=${JSON.stringify(raw)}: expected an integer`);
+  }
+  return n;
+}
+function assertAbsoluteAllowlistPaths(paths, label) {
+  return paths.map((path, index) => {
+    const parsed = AbsoluteAllowlistPathSchema.safeParse(path);
+    if (!parsed.success) {
+      throw new Error(`Invalid ${label}[${index}]=${JSON.stringify(path)}: must be a non-empty absolute path`);
+    }
+    return parsed.data;
+  });
+}
+function parseGitAllowlistFromEnv2(env = process.env) {
+  if (!envSet2("RBO_GIT_ALLOWLIST_SCHEMES", env) && !envSet2("RBO_GIT_ALLOWLIST_HOSTS", env) && !envSet2("RBO_GIT_ALLOWLIST_PREFIXES", env)) {
+    return void 0;
   }
-  const schemes = parseCsv2(process.env.RBO_GIT_ALLOWLIST_SCHEMES);
-  const hosts = parseCsv2(process.env.RBO_GIT_ALLOWLIST_HOSTS);
-  const prefixesRaw = process.env.RBO_GIT_ALLOWLIST_PREFIXES?.trim();
+  const schemes = parseCsv2(env.RBO_GIT_ALLOWLIST_SCHEMES);
+  const hosts = parseCsv2(env.RBO_GIT_ALLOWLIST_HOSTS);
+  const prefixesRaw = env.RBO_GIT_ALLOWLIST_PREFIXES?.trim();
   let repository_prefixes;
   if (prefixesRaw) {
     try {
@@ -4756,34 +4783,124 @@ function parseGitAllowlist2(overrides) {
     ...repository_prefixes ? { repository_prefixes } : {}
   };
 }
+function mergeGitAllowlist2(file, fromEnv, override) {
+  if (override) {
+    return override;
+  }
+  if (fromEnv) {
+    return fromEnv;
+  }
+  if (file) {
+    return {
+      schemes: file.schemes && file.schemes.length > 0 ? file.schemes : [...DEFAULT_GIT_ALLOWLIST_SCHEMES2],
+      hosts: file.hosts && file.hosts.length > 0 ? file.hosts : [...DEFAULT_GIT_ALLOWLIST_HOSTS2],
+      ...file.repository_prefixes ? { repository_prefixes: file.repository_prefixes } : {}
+    };
+  }
+  return {
+    schemes: [...DEFAULT_GIT_ALLOWLIST_SCHEMES2],
+    hosts: [...DEFAULT_GIT_ALLOWLIST_HOSTS2]
+  };
+}
+function defaultControllerConfigFile() {
+  return {
+    mcp_host: "127.0.0.1",
+    mcp_port: 7410,
+    agent_plane_port: 7411,
+    controller_public_host: "127.0.0.1",
+    data_plane_base_url: null,
+    allowed_project_roots: [],
+    allowed_artifact_destinations: [],
+    git_allowlist: {
+      schemes: [...DEFAULT_GIT_ALLOWLIST_SCHEMES2],
+      hosts: [...DEFAULT_GIT_ALLOWLIST_HOSTS2]
+    },
+    local_max_concurrent_jobs: 1,
+    disconnect_grace_seconds: 60,
+    orphan_timeout_seconds: 300,
+    reconcile_deadline_seconds: 120,
+    allow_local_fallback: true,
+    max_git_bundle_bytes: DEFAULT_MAX_GIT_BUNDLE_BYTES,
+    local_fallback_max_host_cpu_percent: 80
+  };
+}
+function resolveControllerConfigPath(dataDir) {
+  return join25(dataDir, CONTROLLER_CONFIG_FILENAME);
+}
+function readControllerConfigFile(configPath) {
+  if (!existsSync8(configPath)) {
+    return void 0;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync7(configPath, "utf8"));
+  } catch (error) {
+    throw new Error(`Invalid controller config JSON at ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const parsed = ControllerConfigFileSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`Invalid controller config at ${configPath}: ${parsed.error.message}`);
+  }
+  return parsed.data;
+}
+function writeDefaultControllerConfigFile(dataDir, options = {}) {
+  mkdirSync5(dataDir, { recursive: true });
+  const path = resolveControllerConfigPath(dataDir);
+  if (existsSync8(path) && !options.force) {
+    return { path, written: false };
+  }
+  const body = `${JSON.stringify(defaultControllerConfigFile(), null, 2)}
+`;
+  writeFileSync5(path, body, "utf8");
+  return { path, written: true };
+}
 function loadControllerConfig(overrides = {}) {
-  const dataDir = overrides.dataDir ?? resolveControllerDataDir();
+  const { configPath: configPathOption, ...fieldOverrides } = overrides;
+  const dataDir = fieldOverrides.dataDir ?? resolveControllerDataDir();
+  const configPath = configPathOption === void 0 ? resolveControllerConfigPath(dataDir) : configPathOption;
+  const file = configPath === null ? void 0 : readControllerConfigFile(configPath);
+  const mcpHost = fieldOverrides.mcpHost ?? (envSet2("RBO_MCP_HOST") ? process.env.RBO_MCP_HOST : void 0) ?? file?.mcp_host ?? "127.0.0.1";
+  const mcpPort = fieldOverrides.mcpPort ?? (envSet2("RBO_MCP_PORT") ? parseEnvInt2("RBO_MCP_PORT", process.env.RBO_MCP_PORT) : void 0) ?? file?.mcp_port ?? 7410;
+  const agentPlanePort = fieldOverrides.agentPlanePort ?? (envSet2("RBO_AGENT_PORT") ? parseEnvInt2("RBO_AGENT_PORT", process.env.RBO_AGENT_PORT) : void 0) ?? file?.agent_plane_port ?? 7411;
+  const controllerPublicHost = fieldOverrides.controllerPublicHost ?? (envSet2("RBO_CONTROLLER_PUBLIC_HOST") ? process.env.RBO_CONTROLLER_PUBLIC_HOST : void 0) ?? file?.controller_public_host ?? "127.0.0.1";
+  let dataPlaneBaseUrl = fieldOverrides.dataPlaneBaseUrl;
+  if (dataPlaneBaseUrl === void 0) {
+    if (envSet2("RBO_DATA_PLANE_BASE_URL")) {
+      dataPlaneBaseUrl = process.env.RBO_DATA_PLANE_BASE_URL;
+    } else if (file?.data_plane_base_url !== void 0) {
+      dataPlaneBaseUrl = file.data_plane_base_url ?? void 0;
+    }
+  }
+  const allowedProjectRoots = assertAbsoluteAllowlistPaths(fieldOverrides.allowedProjectRoots ?? (envSet2("RBO_ALLOWED_PROJECT_ROOTS") ? parseCsv2(process.env.RBO_ALLOWED_PROJECT_ROOTS) : void 0) ?? file?.allowed_project_roots ?? [], "allowed_project_roots");
+  const allowedArtifactDestinations = assertAbsoluteAllowlistPaths(fieldOverrides.allowedArtifactDestinations ?? (envSet2("RBO_ALLOWED_ARTIFACT_DESTINATIONS") ? parseCsv2(process.env.RBO_ALLOWED_ARTIFACT_DESTINATIONS) : void 0) ?? file?.allowed_artifact_destinations ?? [], "allowed_artifact_destinations");
+  const allowLocalFallback = fieldOverrides.allowLocalFallback ?? (envSet2("RBO_ALLOW_LOCAL_FALLBACK") ? process.env.RBO_ALLOW_LOCAL_FALLBACK !== "false" : void 0) ?? file?.allow_local_fallback ?? true;
+  const maxHostCpuBusyFraction = fieldOverrides.maxHostCpuBusyFraction ?? (envSet2("RBO_LOCAL_FALLBACK_MAX_HOST_CPU_PERCENT") ? parseEnvNumber2("RBO_LOCAL_FALLBACK_MAX_HOST_CPU_PERCENT", process.env.RBO_LOCAL_FALLBACK_MAX_HOST_CPU_PERCENT) / 100 : void 0) ?? (file?.local_fallback_max_host_cpu_percent !== void 0 ? file.local_fallback_max_host_cpu_percent / 100 : void 0) ?? 0.8;
   return {
-    mcpHost: overrides.mcpHost ?? process.env.RBO_MCP_HOST ?? "127.0.0.1",
-    mcpPort: overrides.mcpPort ?? Number(process.env.RBO_MCP_PORT ?? 7410),
-    agentPlanePort: overrides.agentPlanePort ?? Number(process.env.RBO_AGENT_PORT ?? 7411),
-    controllerPublicHost: overrides.controllerPublicHost ?? process.env.RBO_CONTROLLER_PUBLIC_HOST ?? "127.0.0.1",
-    dataPlaneBaseUrl: overrides.dataPlaneBaseUrl ?? process.env.RBO_DATA_PLANE_BASE_URL,
+    mcpHost,
+    mcpPort,
+    agentPlanePort,
+    controllerPublicHost,
+    dataPlaneBaseUrl,
     dataDir,
-    databasePath: overrides.databasePath ?? join25(dataDir, "controller.db"),
-    allowedProjectRoots: overrides.allowedProjectRoots ?? parseCsv2(process.env.RBO_ALLOWED_PROJECT_ROOTS),
-    allowedArtifactDestinations: overrides.allowedArtifactDestinations ?? parseCsv2(process.env.RBO_ALLOWED_ARTIFACT_DESTINATIONS),
-    gitAllowlist: parseGitAllowlist2(overrides.gitAllowlist),
+    databasePath: fieldOverrides.databasePath ?? join25(dataDir, "controller.db"),
+    allowedProjectRoots,
+    allowedArtifactDestinations,
+    gitAllowlist: mergeGitAllowlist2(file?.git_allowlist, parseGitAllowlistFromEnv2(), fieldOverrides.gitAllowlist),
     localExecutor: {
-      maxConcurrentJobs: overrides.localExecutor?.maxConcurrentJobs ?? Number(process.env.RBO_LOCAL_MAX_CONCURRENT_JOBS ?? 1)
+      maxConcurrentJobs: fieldOverrides.localExecutor?.maxConcurrentJobs ?? (envSet2("RBO_LOCAL_MAX_CONCURRENT_JOBS") ? parseEnvInt2("RBO_LOCAL_MAX_CONCURRENT_JOBS", process.env.RBO_LOCAL_MAX_CONCURRENT_JOBS) : void 0) ?? file?.local_max_concurrent_jobs ?? 1
     },
-    disconnectGraceSeconds: overrides.disconnectGraceSeconds ?? Number(process.env.RBO_DISCONNECT_GRACE_SECONDS ?? 60),
-    orphanTimeoutSeconds: overrides.orphanTimeoutSeconds ?? Number(process.env.RBO_ORPHAN_TIMEOUT_SECONDS ?? 300),
-    reconcileDeadlineSeconds: overrides.reconcileDeadlineSeconds ?? Number(process.env.RBO_RECONCILE_DEADLINE_SECONDS ?? 120),
-    allowLocalFallback: overrides.allowLocalFallback ?? process.env.RBO_ALLOW_LOCAL_FALLBACK !== "false",
-    maxGitBundleBytes: overrides.maxGitBundleBytes ?? Number(process.env.RBO_MAX_GIT_BUNDLE_BYTES ?? DEFAULT_MAX_GIT_BUNDLE_BYTES),
-    maxHostCpuBusyFraction: overrides.maxHostCpuBusyFraction ?? Number(process.env.RBO_LOCAL_FALLBACK_MAX_HOST_CPU_PERCENT ?? 80) / 100
+    disconnectGraceSeconds: fieldOverrides.disconnectGraceSeconds ?? (envSet2("RBO_DISCONNECT_GRACE_SECONDS") ? parseEnvInt2("RBO_DISCONNECT_GRACE_SECONDS", process.env.RBO_DISCONNECT_GRACE_SECONDS) : void 0) ?? file?.disconnect_grace_seconds ?? 60,
+    orphanTimeoutSeconds: fieldOverrides.orphanTimeoutSeconds ?? (envSet2("RBO_ORPHAN_TIMEOUT_SECONDS") ? parseEnvInt2("RBO_ORPHAN_TIMEOUT_SECONDS", process.env.RBO_ORPHAN_TIMEOUT_SECONDS) : void 0) ?? file?.orphan_timeout_seconds ?? 300,
+    reconcileDeadlineSeconds: fieldOverrides.reconcileDeadlineSeconds ?? (envSet2("RBO_RECONCILE_DEADLINE_SECONDS") ? parseEnvInt2("RBO_RECONCILE_DEADLINE_SECONDS", process.env.RBO_RECONCILE_DEADLINE_SECONDS) : void 0) ?? file?.reconcile_deadline_seconds ?? 120,
+    allowLocalFallback,
+    maxGitBundleBytes: fieldOverrides.maxGitBundleBytes ?? (envSet2("RBO_MAX_GIT_BUNDLE_BYTES") ? parseEnvInt2("RBO_MAX_GIT_BUNDLE_BYTES", process.env.RBO_MAX_GIT_BUNDLE_BYTES) : void 0) ?? file?.max_git_bundle_bytes ?? DEFAULT_MAX_GIT_BUNDLE_BYTES,
+    maxHostCpuBusyFraction
   };
 }
 function ensureDataDir(config) {
   mkdirSync5(config.dataDir, { recursive: true });
 }
-var DEFAULT_MAX_GIT_BUNDLE_BYTES, DEFAULT_GIT_ALLOWLIST_SCHEMES2, DEFAULT_GIT_ALLOWLIST_HOSTS2;
+var DEFAULT_MAX_GIT_BUNDLE_BYTES, DEFAULT_GIT_ALLOWLIST_SCHEMES2, DEFAULT_GIT_ALLOWLIST_HOSTS2, CONTROLLER_CONFIG_FILENAME, GitAllowlistFileSchema2, AbsoluteAllowlistPathSchema, ControllerConfigFileSchema;
 var init_config = __esm({
   "../controller/dist/config.js"() {
     "use strict";
@@ -4791,6 +4908,32 @@ var init_config = __esm({
     DEFAULT_MAX_GIT_BUNDLE_BYTES = 512 * 1024 * 1024;
     DEFAULT_GIT_ALLOWLIST_SCHEMES2 = ["https", "ssh"];
     DEFAULT_GIT_ALLOWLIST_HOSTS2 = ["github.com"];
+    CONTROLLER_CONFIG_FILENAME = "controller.json";
+    GitAllowlistFileSchema2 = z8.object({
+      schemes: z8.array(z8.string().min(1)).optional(),
+      hosts: z8.array(z8.string().min(1)).optional(),
+      repository_prefixes: z8.array(z8.string().min(1)).optional()
+    });
+    AbsoluteAllowlistPathSchema = z8.string().refine((value) => value.length > 0 && value === value.trim() && isAbsolute2(value), {
+      message: 'must be a non-empty absolute path (relative paths, ".", and whitespace are rejected)'
+    });
+    ControllerConfigFileSchema = z8.object({
+      mcp_host: z8.string().min(1).optional(),
+      mcp_port: z8.number().int().positive().optional(),
+      agent_plane_port: z8.number().int().positive().optional(),
+      controller_public_host: z8.string().min(1).optional(),
+      data_plane_base_url: z8.string().min(1).nullable().optional(),
+      allowed_project_roots: z8.array(AbsoluteAllowlistPathSchema).optional(),
+      allowed_artifact_destinations: z8.array(AbsoluteAllowlistPathSchema).optional(),
+      git_allowlist: GitAllowlistFileSchema2.optional(),
+      local_max_concurrent_jobs: z8.number().int().positive().optional(),
+      disconnect_grace_seconds: z8.number().int().nonnegative().optional(),
+      orphan_timeout_seconds: z8.number().int().nonnegative().optional(),
+      reconcile_deadline_seconds: z8.number().int().nonnegative().optional(),
+      allow_local_fallback: z8.boolean().optional(),
+      max_git_bundle_bytes: z8.number().int().positive().optional(),
+      local_fallback_max_host_cpu_percent: z8.number().min(0).max(100).optional()
+    }).strict();
   }
 });
 
@@ -5028,7 +5171,7 @@ var init_database = __esm({
 });
 
 // ../controller/dist/execution/artifacts.js
-import { appendFile as appendFile3, mkdir as mkdir12, writeFile as writeFile12 } from "node:fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir11, writeFile as writeFile11 } from "node:fs/promises";
 import { join as join26 } from "node:path";
 async function persistCollectedArtifacts(input) {
   const results = [];
@@ -5073,7 +5216,7 @@ async function materializeArtifactToDestination(input) {
   if (!allowed) {
     throw new Error("Destination path is outside allowed artifact destinations");
   }
-  const { access: access4, readFile: readFile20, rename: rename6 } = await import("node:fs/promises");
+  const { access: access4, readFile: readFile19, rename: rename6 } = await import("node:fs/promises");
   try {
     await access4(input.destinationPath);
     if (!input.overwrite) {
@@ -5084,20 +5227,20 @@ async function materializeArtifactToDestination(input) {
       throw error;
     }
   }
-  const content = await readFile20(row.path);
+  const content = await readFile19(row.path);
   if (sha256(content) !== row.sha256) {
     throw new Error("Stored artifact hash mismatch");
   }
   const tempPath = `${input.destinationPath}.rbo.tmp`;
-  await writeFile12(tempPath, content);
-  const writtenHash = sha256(await readFile20(tempPath));
+  await writeFile11(tempPath, content);
+  const writtenHash = sha256(await readFile19(tempPath));
   if (writtenHash !== row.sha256) {
     throw new Error("Temporary artifact hash mismatch");
   }
   await rename6(tempPath, input.destinationPath);
   if (input.dataDir) {
     const auditDir = join26(input.dataDir, "audit");
-    await mkdir12(auditDir, { recursive: true });
+    await mkdir11(auditDir, { recursive: true });
     const auditLine = JSON.stringify({
       type: "artifact_materialize",
       created_at: nowIso(),
@@ -5284,7 +5427,7 @@ var init_lifecycle = __esm({
 });
 
 // ../controller/dist/execution/runner.js
-import { mkdir as mkdir13, readFile as readFile15, rm as rm10, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile14, rm as rm10, writeFile as writeFile12 } from "node:fs/promises";
 import { dirname as dirname7, join as join27 } from "node:path";
 function getLocalRunningJobsCount() {
   return admissionActive;
@@ -5410,9 +5553,9 @@ async function runLocalJob(ctx, jobId) {
   const persistentLogs = attemptLogDir(ctx.dataDir, attempt.id);
   const controlDir = attemptControlDir(ctx.dataDir, attempt.id);
   const artifactsDir = attemptArtifactsDir(ctx.dataDir, attempt.id);
-  await mkdir13(artifactsDir, { recursive: true });
-  await mkdir13(persistentLogs, { recursive: true });
-  await mkdir13(controlDir, { recursive: true });
+  await mkdir12(artifactsDir, { recursive: true });
+  await mkdir12(persistentLogs, { recursive: true });
+  await mkdir12(controlDir, { recursive: true });
   let timedOut = false;
   let cancelled = false;
   let durationComplete = false;
@@ -5433,7 +5576,7 @@ async function runLocalJob(ctx, jobId) {
     if (!snapshotRow?.payload_path) {
       throw new RboError("internal", "Job is missing snapshot payload");
     }
-    const manifest = JSON.parse(await readFile15(snapshotRow.manifest_path, "utf8"));
+    const manifest = JSON.parse(await readFile14(snapshotRow.manifest_path, "utf8"));
     const materialized = await materializeFullSnapshot({
       manifest,
       archivePath: snapshotRow.payload_path,
@@ -5451,7 +5594,7 @@ async function runLocalJob(ctx, jobId) {
     });
     const warningsPath = join27(dirname7(snapshotRow.manifest_path), "secret-warnings.json");
     try {
-      const warnings = JSON.parse(await readFile15(warningsPath, "utf8"));
+      const warnings = JSON.parse(await readFile14(warningsPath, "utf8"));
       for (const warning of warnings) {
         await emitJobEvent(ctx, logs, {
           type: "secret_warning",
@@ -5698,9 +5841,9 @@ async function captureAndPersistSnapshot(ctx, jobId, request) {
     contentStorageDir: storageDir
   });
   const manifestPath = join27(storageDir, "manifest.json");
-  await writeFile13(manifestPath, JSON.stringify(captured.manifest, null, 2));
-  await writeFile13(join27(storageDir, "secret-warnings.json"), JSON.stringify(captured.secretWarnings));
-  await writeFile13(join27(storageDir, "git-source-requirements.json"), JSON.stringify(captured.gitSourceRequirements));
+  await writeFile12(manifestPath, JSON.stringify(captured.manifest, null, 2));
+  await writeFile12(join27(storageDir, "secret-warnings.json"), JSON.stringify(captured.secretWarnings));
+  await writeFile12(join27(storageDir, "git-source-requirements.json"), JSON.stringify(captured.gitSourceRequirements));
   persistSnapshot(ctx.db, {
     snapshotId: captured.instance.snapshot_id,
     contentId: captured.manifest.content_id,
@@ -5746,7 +5889,7 @@ function mergeGitSourceToolRequirements(request, gitSourceRequirements) {
 }
 async function readGitSourceRequirements(dataDir, jobId) {
   try {
-    const raw = await readFile15(join27(dataDir, "snapshots", jobId, "git-source-requirements.json"), "utf8");
+    const raw = await readFile14(join27(dataDir, "snapshots", jobId, "git-source-requirements.json"), "utf8");
     const parsed = JSON.parse(raw);
     return {
       submodules: parsed.submodules === true,
@@ -5838,7 +5981,7 @@ var init_data_tokens = __esm({
 // ../controller/dist/http/data-plane.js
 import { createHash as createHash7 } from "node:crypto";
 import { createReadStream as createReadStream2, createWriteStream as createWriteStream2 } from "node:fs";
-import { access as access3, mkdir as mkdir14, readFile as readFile16, rename as rename5, rm as rm11, stat as stat8 } from "node:fs/promises";
+import { access as access3, mkdir as mkdir13, readFile as readFile15, rename as rename5, rm as rm11, stat as stat8 } from "node:fs/promises";
 import { dirname as dirname8, join as join28 } from "node:path";
 function artifactUploadStreamLimit(declaredSizeBytes, globalCapBytes = DEFAULT_ARTIFACT_CAP_BYTES) {
   return Math.min(globalCapBytes, declaredSizeBytes);
@@ -5868,7 +6011,7 @@ async function filterMissingArtifacts(dataDir, attemptId, artifacts) {
   for (const art of artifacts) {
     const destPath = join28(artifactsDir, art.logical_name);
     try {
-      const buf = await readFile16(destPath);
+      const buf = await readFile15(destPath);
       const hash = createHash7("sha256").update(buf).digest("hex");
       if (hash === art.sha256 && buf.length === art.size_bytes) {
         continue;
@@ -5988,7 +6131,7 @@ async function handleDataPlaneRequest(req, res, options) {
       const transferStats = await stat8(transferSnapshot);
       payloadPath = transferSnapshot;
       sizeBytes = transferStats.size;
-      const transferData = await readFile16(transferSnapshot);
+      const transferData = await readFile15(transferSnapshot);
       sha2562 = createHash7("sha256").update(transferData).digest("hex");
     } catch {
     }
@@ -6087,8 +6230,8 @@ async function handleDataPlaneRequest(req, res, options) {
       return true;
     }
     const partPath = join28(artifactsDir, `.upload-${createHash7("sha256").update(logicalName).digest("hex").slice(0, 16)}.part`);
-    await mkdir14(dirname8(destPath), { recursive: true });
-    await mkdir14(artifactsDir, { recursive: true });
+    await mkdir13(dirname8(destPath), { recursive: true });
+    await mkdir13(artifactsDir, { recursive: true });
     const hasher = createHash7("sha256");
     const writeStream = createWriteStream2(partPath);
     let sizeCounter = 0;
@@ -6297,7 +6440,7 @@ async function handleDataPlaneRequest(req, res, options) {
     }
     const bundlePath = join28(attemptTransferDir(options.dataDir, attemptId), "bundle.gitbundle");
     try {
-      const data = await readFile16(bundlePath);
+      const data = await readFile15(bundlePath);
       const sha2562 = createHash7("sha256").update(data).digest("hex");
       res.writeHead(200, {
         "content-type": "application/octet-stream",
@@ -6696,8 +6839,8 @@ var init_coordinator = __esm({
 // ../controller/dist/execution/remote-execution.js
 import { execFile as execFile8 } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
-import { readFileSync as readFileSync6 } from "node:fs";
-import { mkdir as mkdir15, readFile as readFile17, rm as rm12, stat as stat9, writeFile as writeFile14 } from "node:fs/promises";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { mkdir as mkdir14, readFile as readFile16, rm as rm12, stat as stat9, writeFile as writeFile13 } from "node:fs/promises";
 import { dirname as dirname9, join as join29 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 function snapshotManifestMode(manifest) {
@@ -6804,7 +6947,7 @@ function failAttemptPrepare(opts, attemptId, jobId, category, message) {
   });
 }
 async function createGitBundle(projectRoot, baseCommit, bundlePath, maxBytes = DEFAULT_MAX_GIT_BUNDLE_BYTES) {
-  await mkdir15(dirname9(bundlePath), { recursive: true });
+  await mkdir14(dirname9(bundlePath), { recursive: true });
   const { stdout: head } = await execFileAsync8("git", ["rev-parse", "HEAD"], {
     cwd: projectRoot,
     windowsHide: true
@@ -6833,7 +6976,7 @@ async function createGitBundle(projectRoot, baseCommit, bundlePath, maxBytes = D
     await rm12(bundlePath, { force: true });
     throw new GitBundleSizeExceededError(sizeBytes, maxBytes);
   }
-  const data = await readFile17(bundlePath);
+  const data = await readFile16(bundlePath);
   return {
     sizeBytes: data.length,
     sha256: createHash8("sha256").update(data).digest("hex")
@@ -6849,9 +6992,9 @@ async function ensureFullFallbackArchive(opts, attemptId, jobId) {
   const manifestPath = join29(transferDir, "snapshot.manifest.json");
   try {
     const existing = await stat9(archivePath);
-    const data = await readFile17(archivePath);
+    const data = await readFile16(archivePath);
     const sha2562 = createHash8("sha256").update(data).digest("hex");
-    const manifestRaw = await readFile17(manifestPath, "utf8");
+    const manifestRaw = await readFile16(manifestPath, "utf8");
     const manifest = JSON.parse(manifestRaw);
     if (manifest.payload?.sha256 === sha2562 && manifest.payload?.size === existing.size) {
       return {
@@ -6863,7 +7006,7 @@ async function ensureFullFallbackArchive(opts, attemptId, jobId) {
     }
   } catch {
   }
-  await mkdir15(transferDir, { recursive: true });
+  await mkdir14(transferDir, { recursive: true });
   const captured = await captureFullSnapshot({
     projectRoot: request.source.project_root,
     allowedProjectRoots: opts.allowedProjectRoots ?? [request.source.project_root],
@@ -6876,8 +7019,8 @@ async function ensureFullFallbackArchive(opts, attemptId, jobId) {
     additionalRoots: request.source.additional_roots,
     contentStorageDir: transferDir
   });
-  await writeFile14(archivePath, await readFile17(captured.archivePath));
-  await writeFile14(manifestPath, JSON.stringify(captured.manifest, null, 2));
+  await writeFile13(archivePath, await readFile16(captured.archivePath));
+  await writeFile13(manifestPath, JSON.stringify(captured.manifest, null, 2));
   return {
     archivePath,
     sizeBytes: captured.manifest.payload.size,
@@ -7023,7 +7166,7 @@ function handleRemoteLeaseAccept(opts, agentId, payload) {
   let manifest;
   if (snapshotRow.manifest_path) {
     try {
-      manifest = JSON.parse(readFileSync6(snapshotRow.manifest_path, "utf8"));
+      manifest = JSON.parse(readFileSync8(snapshotRow.manifest_path, "utf8"));
     } catch {
     }
   }
@@ -7050,7 +7193,7 @@ async function handleRemoteSourceNeed(opts, agentId, payload) {
     }
     let manifest;
     try {
-      manifest = JSON.parse(readFileSync6(snapshotRow.manifest_path, "utf8"));
+      manifest = JSON.parse(readFileSync8(snapshotRow.manifest_path, "utf8"));
     } catch {
       failAttemptPrepare(opts, attempt.id, attempt.job_id, "materialization", "Cannot create bundle: manifest unreadable");
       return;
@@ -7097,7 +7240,7 @@ async function handleRemoteSourceNeed(opts, agentId, payload) {
     }
     let manifest;
     try {
-      manifest = JSON.parse(readFileSync6(snapshotRow.manifest_path, "utf8"));
+      manifest = JSON.parse(readFileSync8(snapshotRow.manifest_path, "utf8"));
     } catch {
       manifest = void 0;
     }
@@ -7714,7 +7857,7 @@ function selectAgentForJob(agents, request, options = {}) {
   const busyAgentRunningJobs = [];
   for (const candidate of agents) {
     const caps = candidate.capabilities;
-    const effectiveCapacity = Math.min(caps.execution.max_jobs, 1);
+    const effectiveCapacity = caps.execution.max_jobs;
     if (effectiveCapacity <= 0 || candidate.activeJobsCount >= effectiveCapacity) {
       if (effectiveCapacity > 0) {
         busyAgentRunningJobs.push(candidate.activeJobsCount);
@@ -8303,22 +8446,18 @@ var init_submit = __esm({
 
 // src/main.ts
 init_dist();
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile18 } from "node:fs/promises";
 
 // src/commands/agent.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { mkdir as mkdir11, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
+import { existsSync as existsSync7 } from "node:fs";
 import { join as join24 } from "node:path";
 
-// ../agent/dist/run.js
+// ../agent/dist/config.js
+init_dist2();
 init_dist();
-
-// ../agent/dist/capabilities/probe.js
-import { execFile as execFile2 } from "node:child_process";
-import { readFile as readFile5, readdir as readdir5, statfs } from "node:fs/promises";
-import { arch, cpus as cpus2, freemem, hostname, loadavg, platform as platform2, release, totalmem } from "node:os";
-import { join as join8 } from "node:path";
-import { promisify as promisify2 } from "node:util";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join7 } from "node:path";
+import { z as z6 } from "zod";
 
 // ../agent/dist/build-cache/index.js
 import { access, readdir as readdir3 } from "node:fs/promises";
@@ -9021,12 +9160,6 @@ function resolveBuildCachesDir(stateDir) {
   return join5(stateDir, "build-caches");
 }
 
-// ../agent/dist/config.js
-init_dist2();
-init_dist();
-import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname2, join as join7 } from "node:path";
-
 // ../agent/dist/repos/mirror.js
 init_dist();
 import { execFile } from "node:child_process";
@@ -9383,19 +9516,77 @@ var DEFAULT_LOG_SPOOL_MAX_BYTES = 536870912;
 var DEFAULT_LOG_SEND_QUEUE_MAX = 64;
 var DEFAULT_GIT_ALLOWLIST_SCHEMES = ["https", "ssh"];
 var DEFAULT_GIT_ALLOWLIST_HOSTS = ["github.com"];
+var AGENT_CONFIG_FILENAME = "agent.json";
+var AGENT_CONFIG_SCHEMA_VERSION = 1;
+var RiskLevelSchema2 = z6.enum(["safe", "normal", "destructive", "hardware"]);
+var GitAllowlistFileSchema = z6.object({
+  schemes: z6.array(z6.string().min(1)).optional(),
+  hosts: z6.array(z6.string().min(1)).optional(),
+  repository_prefixes: z6.array(z6.string().min(1)).optional()
+});
+var RepoCacheFileSchema = z6.object({
+  max_size_gb: z6.number().positive().optional(),
+  min_free_disk_gb: z6.number().nonnegative().optional(),
+  retention_days: z6.number().nonnegative().optional()
+});
+var BuildCacheFileSchema = z6.object({
+  enabled_kinds: z6.array(BuildCacheKindSchema).optional(),
+  max_size_gb: z6.number().positive().optional(),
+  min_free_disk_gb: z6.number().nonnegative().optional(),
+  retention_days: z6.number().nonnegative().optional(),
+  allow_read_risk_levels: z6.array(RiskLevelSchema2).optional(),
+  allow_write_risk_levels: z6.array(RiskLevelSchema2).optional()
+});
+var AgentConfigFileSchema = z6.object({
+  schema_version: z6.number().int().positive().optional(),
+  initialized_at: z6.string().min(1).optional(),
+  controller_url: z6.string().optional(),
+  controller_fingerprint: z6.string().optional(),
+  display_name: z6.string().min(1).optional(),
+  max_jobs: z6.number().int().positive().optional(),
+  repo_cache_dir: z6.string().min(1).nullable().optional(),
+  secret_map: z6.record(z6.string()).nullable().optional(),
+  git_allowlist: GitAllowlistFileSchema.optional(),
+  repo_cache: RepoCacheFileSchema.optional(),
+  build_cache: BuildCacheFileSchema.optional(),
+  log_spool_max_bytes: z6.number().int().positive().optional(),
+  log_send_queue_max: z6.number().int().positive().optional(),
+  disconnect_grace_seconds: z6.number().int().nonnegative().optional(),
+  orphan_timeout_seconds: z6.number().int().nonnegative().optional(),
+  reconcile_deadline_seconds: z6.number().int().nonnegative().optional(),
+  disk_min_free_bytes: z6.number().int().nonnegative().nullable().optional(),
+  configured_priority: z6.number().nullable().optional()
+}).strict();
 function parseCsv(raw) {
   if (!raw?.trim()) {
     return [];
   }
   return raw.split(",").map((part) => part.trim()).filter(Boolean);
 }
-function parseGitAllowlist(overrides) {
-  if (overrides) {
-    return overrides;
+function envSet(key, env = process.env) {
+  return env[key] !== void 0;
+}
+function parseEnvNumber(key, raw) {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    throw new Error(`Invalid ${key}=${JSON.stringify(raw)}: expected a finite number`);
+  }
+  return n;
+}
+function parseEnvInt(key, raw) {
+  const n = parseEnvNumber(key, raw);
+  if (!Number.isInteger(n)) {
+    throw new Error(`Invalid ${key}=${JSON.stringify(raw)}: expected an integer`);
+  }
+  return n;
+}
+function parseGitAllowlistFromEnv(env = process.env) {
+  if (!envSet("RBO_GIT_ALLOWLIST_SCHEMES", env) && !envSet("RBO_GIT_ALLOWLIST_HOSTS", env) && !envSet("RBO_GIT_ALLOWLIST_PREFIXES", env)) {
+    return void 0;
   }
-  const schemes = parseCsv(process.env.RBO_GIT_ALLOWLIST_SCHEMES);
-  const hosts = parseCsv(process.env.RBO_GIT_ALLOWLIST_HOSTS);
-  const prefixesRaw = process.env.RBO_GIT_ALLOWLIST_PREFIXES?.trim();
+  const schemes = parseCsv(env.RBO_GIT_ALLOWLIST_SCHEMES);
+  const hosts = parseCsv(env.RBO_GIT_ALLOWLIST_HOSTS);
+  const prefixesRaw = env.RBO_GIT_ALLOWLIST_PREFIXES?.trim();
   let repository_prefixes;
   if (prefixesRaw) {
     try {
@@ -9414,17 +9605,23 @@ function parseGitAllowlist(overrides) {
     ...repository_prefixes ? { repository_prefixes } : {}
   };
 }
-function parseRepoCache(overrides) {
-  if (overrides) {
-    return overrides;
+function mergeGitAllowlist(file, fromEnv, override) {
+  if (override) {
+    return override;
+  }
+  if (fromEnv) {
+    return fromEnv;
+  }
+  if (file) {
+    return {
+      schemes: file.schemes && file.schemes.length > 0 ? file.schemes : [...DEFAULT_GIT_ALLOWLIST_SCHEMES],
+      hosts: file.hosts && file.hosts.length > 0 ? file.hosts : [...DEFAULT_GIT_ALLOWLIST_HOSTS],
+      ...file.repository_prefixes ? { repository_prefixes: file.repository_prefixes } : {}
+    };
   }
-  const maxSize = Number(process.env.RBO_REPO_CACHE_MAX_SIZE_GB ?? DEFAULT_REPO_CACHE_CONFIG.max_size_gb);
-  const minFree = Number(process.env.RBO_REPO_CACHE_MIN_FREE_DISK_GB ?? DEFAULT_REPO_CACHE_CONFIG.min_free_disk_gb);
-  const retention = Number(process.env.RBO_REPO_CACHE_RETENTION_DAYS ?? DEFAULT_REPO_CACHE_CONFIG.retention_days);
   return {
-    max_size_gb: maxSize,
-    min_free_disk_gb: minFree,
-    retention_days: retention
+    schemes: [...DEFAULT_GIT_ALLOWLIST_SCHEMES],
+    hosts: [...DEFAULT_GIT_ALLOWLIST_HOSTS]
   };
 }
 function parseBuildCacheKinds(raw) {
@@ -9455,23 +9652,30 @@ function parseRiskLevels(raw) {
   }
   return levels;
 }
-function parseBuildCache(overrides) {
-  if (overrides) {
-    return overrides;
+function mergeRepoCache(file, override) {
+  if (override) {
+    return override;
+  }
+  const maxSize = envSet("RBO_REPO_CACHE_MAX_SIZE_GB") ? parseEnvNumber("RBO_REPO_CACHE_MAX_SIZE_GB", process.env.RBO_REPO_CACHE_MAX_SIZE_GB) : file?.max_size_gb ?? DEFAULT_REPO_CACHE_CONFIG.max_size_gb;
+  const minFree = envSet("RBO_REPO_CACHE_MIN_FREE_DISK_GB") ? parseEnvNumber("RBO_REPO_CACHE_MIN_FREE_DISK_GB", process.env.RBO_REPO_CACHE_MIN_FREE_DISK_GB) : file?.min_free_disk_gb ?? DEFAULT_REPO_CACHE_CONFIG.min_free_disk_gb;
+  const retention = envSet("RBO_REPO_CACHE_RETENTION_DAYS") ? parseEnvNumber("RBO_REPO_CACHE_RETENTION_DAYS", process.env.RBO_REPO_CACHE_RETENTION_DAYS) : file?.retention_days ?? DEFAULT_REPO_CACHE_CONFIG.retention_days;
+  return {
+    max_size_gb: maxSize,
+    min_free_disk_gb: minFree,
+    retention_days: retention
+  };
+}
+function mergeBuildCache(file, override) {
+  if (override) {
+    return override;
   }
   return {
-    enabledKinds: parseBuildCacheKinds(process.env.RBO_BUILD_CACHE_ENABLED_KINDS) ?? [
-      ...DEFAULT_BUILD_CACHE_CONFIG.enabledKinds
-    ],
-    maxSizeGb: Number(process.env.RBO_BUILD_CACHE_MAX_SIZE_GB ?? DEFAULT_BUILD_CACHE_CONFIG.maxSizeGb),
-    minFreeDiskGb: Number(process.env.RBO_BUILD_CACHE_MIN_FREE_DISK_GB ?? DEFAULT_BUILD_CACHE_CONFIG.minFreeDiskGb),
-    retentionDays: Number(process.env.RBO_BUILD_CACHE_RETENTION_DAYS ?? DEFAULT_BUILD_CACHE_CONFIG.retentionDays),
-    allowReadRiskLevels: parseRiskLevels(process.env.RBO_BUILD_CACHE_ALLOW_READ_RISKS) ?? [
-      ...DEFAULT_BUILD_CACHE_CONFIG.allowReadRiskLevels
-    ],
-    allowWriteRiskLevels: parseRiskLevels(process.env.RBO_BUILD_CACHE_ALLOW_WRITE_RISKS) ?? [
-      ...DEFAULT_BUILD_CACHE_CONFIG.allowWriteRiskLevels
-    ]
+    enabledKinds: (envSet("RBO_BUILD_CACHE_ENABLED_KINDS") ? parseBuildCacheKinds(process.env.RBO_BUILD_CACHE_ENABLED_KINDS) : void 0) ?? file?.enabled_kinds ?? [...DEFAULT_BUILD_CACHE_CONFIG.enabledKinds],
+    maxSizeGb: envSet("RBO_BUILD_CACHE_MAX_SIZE_GB") ? parseEnvNumber("RBO_BUILD_CACHE_MAX_SIZE_GB", process.env.RBO_BUILD_CACHE_MAX_SIZE_GB) : file?.max_size_gb ?? DEFAULT_BUILD_CACHE_CONFIG.maxSizeGb,
+    minFreeDiskGb: envSet("RBO_BUILD_CACHE_MIN_FREE_DISK_GB") ? parseEnvNumber("RBO_BUILD_CACHE_MIN_FREE_DISK_GB", process.env.RBO_BUILD_CACHE_MIN_FREE_DISK_GB) : file?.min_free_disk_gb ?? DEFAULT_BUILD_CACHE_CONFIG.minFreeDiskGb,
+    retentionDays: envSet("RBO_BUILD_CACHE_RETENTION_DAYS") ? parseEnvNumber("RBO_BUILD_CACHE_RETENTION_DAYS", process.env.RBO_BUILD_CACHE_RETENTION_DAYS) : file?.retention_days ?? DEFAULT_BUILD_CACHE_CONFIG.retentionDays,
+    allowReadRiskLevels: (envSet("RBO_BUILD_CACHE_ALLOW_READ_RISKS") ? parseRiskLevels(process.env.RBO_BUILD_CACHE_ALLOW_READ_RISKS) : void 0) ?? file?.allow_read_risk_levels ?? [...DEFAULT_BUILD_CACHE_CONFIG.allowReadRiskLevels],
+    allowWriteRiskLevels: (envSet("RBO_BUILD_CACHE_ALLOW_WRITE_RISKS") ? parseRiskLevels(process.env.RBO_BUILD_CACHE_ALLOW_WRITE_RISKS) : void 0) ?? file?.allow_write_risk_levels ?? [...DEFAULT_BUILD_CACHE_CONFIG.allowWriteRiskLevels]
   };
 }
 function parseSecretMap(raw) {
@@ -9495,50 +9699,157 @@ function parseSecretMap(raw) {
     throw new Error(`Invalid RBO_SECRET_MAP: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
+function defaultAgentConfigFile(options = {}) {
+  return {
+    schema_version: AGENT_CONFIG_SCHEMA_VERSION,
+    initialized_at: options.initializedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    controller_url: "",
+    controller_fingerprint: "",
+    display_name: "rbo-agent",
+    max_jobs: 1,
+    repo_cache_dir: null,
+    secret_map: null,
+    git_allowlist: {
+      schemes: [...DEFAULT_GIT_ALLOWLIST_SCHEMES],
+      hosts: [...DEFAULT_GIT_ALLOWLIST_HOSTS]
+    },
+    repo_cache: {
+      max_size_gb: DEFAULT_REPO_CACHE_CONFIG.max_size_gb,
+      min_free_disk_gb: DEFAULT_REPO_CACHE_CONFIG.min_free_disk_gb,
+      retention_days: DEFAULT_REPO_CACHE_CONFIG.retention_days
+    },
+    build_cache: {
+      enabled_kinds: [...DEFAULT_BUILD_CACHE_CONFIG.enabledKinds],
+      max_size_gb: DEFAULT_BUILD_CACHE_CONFIG.maxSizeGb,
+      min_free_disk_gb: DEFAULT_BUILD_CACHE_CONFIG.minFreeDiskGb,
+      retention_days: DEFAULT_BUILD_CACHE_CONFIG.retentionDays,
+      allow_read_risk_levels: [...DEFAULT_BUILD_CACHE_CONFIG.allowReadRiskLevels],
+      allow_write_risk_levels: [...DEFAULT_BUILD_CACHE_CONFIG.allowWriteRiskLevels]
+    },
+    log_spool_max_bytes: DEFAULT_LOG_SPOOL_MAX_BYTES,
+    log_send_queue_max: DEFAULT_LOG_SEND_QUEUE_MAX,
+    disconnect_grace_seconds: 60,
+    orphan_timeout_seconds: 300,
+    reconcile_deadline_seconds: 120,
+    disk_min_free_bytes: null,
+    configured_priority: null
+  };
+}
+function resolveAgentConfigPath(stateDir) {
+  return join7(stateDir, AGENT_CONFIG_FILENAME);
+}
+function readAgentConfigFile(configPath) {
+  if (!existsSync2(configPath)) {
+    return void 0;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync3(configPath, "utf8"));
+  } catch (error) {
+    throw new Error(`Invalid agent config JSON at ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const parsed = AgentConfigFileSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`Invalid agent config at ${configPath}: ${parsed.error.message}`);
+  }
+  return parsed.data;
+}
+function writeDefaultAgentConfigFile(stateDir, options = {}) {
+  mkdirSync2(stateDir, { recursive: true });
+  const path = resolveAgentConfigPath(stateDir);
+  if (existsSync2(path) && !options.force) {
+    let initialized_at2 = (/* @__PURE__ */ new Date(0)).toISOString();
+    let schema_version = AGENT_CONFIG_SCHEMA_VERSION;
+    try {
+      const existing = readAgentConfigFile(path);
+      initialized_at2 = existing?.initialized_at ?? initialized_at2;
+      schema_version = existing?.schema_version ?? schema_version;
+    } catch {
+    }
+    return {
+      path,
+      written: false,
+      initialized_at: initialized_at2,
+      schema_version
+    };
+  }
+  const initialized_at = options.initializedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const body = `${JSON.stringify(defaultAgentConfigFile({ initializedAt: initialized_at }), null, 2)}
+`;
+  writeFileSync2(path, body, "utf8");
+  return {
+    path,
+    written: true,
+    initialized_at,
+    schema_version: AGENT_CONFIG_SCHEMA_VERSION
+  };
+}
 function loadAgentConfig(overrides = {}) {
-  const controllerUrl = overrides.controllerUrl ?? process.env.RBO_CONTROLLER_URL;
-  const controllerFingerprint = overrides.controllerFingerprint ?? process.env.RBO_CONTROLLER_FINGERPRINT;
+  const { configPath: configPathOption, ...fieldOverrides } = overrides;
+  const stateDir = fieldOverrides.stateDir ?? resolveAgentStateDir();
+  const configPath = configPathOption === void 0 ? resolveAgentConfigPath(stateDir) : configPathOption;
+  const file = configPath === null ? void 0 : readAgentConfigFile(configPath);
+  const controllerUrl = fieldOverrides.controllerUrl ?? (envSet("RBO_CONTROLLER_URL") ? process.env.RBO_CONTROLLER_URL : void 0) ?? (file?.controller_url?.trim() ? file.controller_url.trim() : void 0);
+  const controllerFingerprint = fieldOverrides.controllerFingerprint ?? (envSet("RBO_CONTROLLER_FINGERPRINT") ? process.env.RBO_CONTROLLER_FINGERPRINT : void 0) ?? (file?.controller_fingerprint?.trim() ? file.controller_fingerprint.trim() : void 0);
   if (!controllerUrl) {
-    throw new Error("RBO_CONTROLLER_URL is required (wss://<host>:7411/agent)");
+    throw new Error("controller_url is required \u2014 set it in agent.json (or RBO_CONTROLLER_URL=wss://<host>:7411/agent)");
   }
   if (!controllerFingerprint) {
-    throw new Error("RBO_CONTROLLER_FINGERPRINT is required \u2014 run `rbo controller fingerprint` on the Controller and copy the value here");
+    throw new Error("controller_fingerprint is required \u2014 set it in agent.json (or RBO_CONTROLLER_FINGERPRINT from `rbo controller fingerprint`)");
+  }
+  const repoCache = mergeRepoCache(file?.repo_cache, fieldOverrides.repoCache);
+  let secretMap = fieldOverrides.secretMap;
+  if (secretMap === void 0) {
+    if (envSet("RBO_SECRET_MAP")) {
+      secretMap = parseSecretMap(process.env.RBO_SECRET_MAP);
+    } else if (file?.secret_map !== void 0) {
+      secretMap = file.secret_map ?? void 0;
+    }
+  }
+  let repoCacheDir = fieldOverrides.repoCacheDir;
+  if (repoCacheDir === void 0) {
+    if (envSet("RBO_REPO_CACHE_DIR") && process.env.RBO_REPO_CACHE_DIR?.trim()) {
+      repoCacheDir = process.env.RBO_REPO_CACHE_DIR.trim();
+    } else if (file?.repo_cache_dir) {
+      repoCacheDir = file.repo_cache_dir;
+    }
+  }
+  let configuredPriority = fieldOverrides.configuredPriority;
+  if (configuredPriority === void 0) {
+    if (envSet("RBO_CONFIGURED_PRIORITY")) {
+      configuredPriority = parseEnvNumber("RBO_CONFIGURED_PRIORITY", process.env.RBO_CONFIGURED_PRIORITY);
+    } else if (file?.configured_priority !== void 0 && file.configured_priority !== null) {
+      configuredPriority = file.configured_priority;
+    }
+  }
+  let diskMinFreeBytes = fieldOverrides.diskMinFreeBytes;
+  if (diskMinFreeBytes === void 0) {
+    if (envSet("RBO_DISK_MIN_FREE_BYTES")) {
+      diskMinFreeBytes = parseEnvInt("RBO_DISK_MIN_FREE_BYTES", process.env.RBO_DISK_MIN_FREE_BYTES);
+    } else if (file?.disk_min_free_bytes !== void 0 && file.disk_min_free_bytes !== null) {
+      diskMinFreeBytes = file.disk_min_free_bytes;
+    } else {
+      diskMinFreeBytes = Math.max(DEFAULT_DISK_MIN_FREE_BYTES, Math.floor(repoCache.min_free_disk_gb * 1024 ** 3));
+    }
   }
   return {
     controllerUrl,
     controllerFingerprint,
-    displayName: overrides.displayName ?? process.env.RBO_AGENT_NAME ?? "rbo-agent",
-    maxJobs: overrides.maxJobs ?? Number(process.env.RBO_MAX_JOBS ?? 1),
-    stateDir: overrides.stateDir ?? resolveAgentStateDir(),
-    repoCacheDir: overrides.repoCacheDir ?? (process.env.RBO_REPO_CACHE_DIR?.trim() ? process.env.RBO_REPO_CACHE_DIR.trim() : void 0),
-    secretMap: overrides.secretMap ?? parseSecretMap(process.env.RBO_SECRET_MAP),
-    gitAllowlist: parseGitAllowlist(overrides.gitAllowlist),
-    repoCache: parseRepoCache(overrides.repoCache),
-    buildCache: parseBuildCache(overrides.buildCache),
-    logSpoolMaxBytes: overrides.logSpoolMaxBytes ?? Number(process.env.RBO_LOG_SPOOL_MAX_BYTES ?? DEFAULT_LOG_SPOOL_MAX_BYTES),
-    logSendQueueMax: overrides.logSendQueueMax ?? Number(process.env.RBO_LOG_SEND_QUEUE_MAX ?? DEFAULT_LOG_SEND_QUEUE_MAX),
-    disconnectGraceSeconds: overrides.disconnectGraceSeconds ?? Number(process.env.RBO_DISCONNECT_GRACE_SECONDS ?? 60),
-    orphanTimeoutSeconds: overrides.orphanTimeoutSeconds ?? Number(process.env.RBO_ORPHAN_TIMEOUT_SECONDS ?? 300),
-    reconcileDeadlineSeconds: overrides.reconcileDeadlineSeconds ?? Number(process.env.RBO_RECONCILE_DEADLINE_SECONDS ?? 120),
-    diskMinFreeBytes: (() => {
-      if (overrides.diskMinFreeBytes !== void 0) {
-        return overrides.diskMinFreeBytes;
-      }
-      if (process.env.RBO_DISK_MIN_FREE_BYTES) {
-        return Number(process.env.RBO_DISK_MIN_FREE_BYTES);
-      }
-      const repoCache = parseRepoCache(overrides.repoCache);
-      return Math.max(DEFAULT_DISK_MIN_FREE_BYTES, Math.floor(repoCache.min_free_disk_gb * 1024 ** 3));
-    })(),
-    configuredPriority: (() => {
-      if (overrides.configuredPriority !== void 0) {
-        return overrides.configuredPriority;
-      }
-      if (process.env.RBO_CONFIGURED_PRIORITY) {
-        return Number(process.env.RBO_CONFIGURED_PRIORITY);
-      }
-      return void 0;
-    })()
+    displayName: fieldOverrides.displayName ?? (envSet("RBO_AGENT_NAME") ? process.env.RBO_AGENT_NAME : void 0) ?? file?.display_name ?? "rbo-agent",
+    maxJobs: fieldOverrides.maxJobs ?? (envSet("RBO_MAX_JOBS") ? parseEnvInt("RBO_MAX_JOBS", process.env.RBO_MAX_JOBS) : void 0) ?? file?.max_jobs ?? 1,
+    stateDir,
+    repoCacheDir,
+    secretMap,
+    gitAllowlist: mergeGitAllowlist(file?.git_allowlist, parseGitAllowlistFromEnv(), fieldOverrides.gitAllowlist),
+    repoCache,
+    buildCache: mergeBuildCache(file?.build_cache, fieldOverrides.buildCache),
+    logSpoolMaxBytes: fieldOverrides.logSpoolMaxBytes ?? (envSet("RBO_LOG_SPOOL_MAX_BYTES") ? parseEnvInt("RBO_LOG_SPOOL_MAX_BYTES", process.env.RBO_LOG_SPOOL_MAX_BYTES) : void 0) ?? file?.log_spool_max_bytes ?? DEFAULT_LOG_SPOOL_MAX_BYTES,
+    logSendQueueMax: fieldOverrides.logSendQueueMax ?? (envSet("RBO_LOG_SEND_QUEUE_MAX") ? parseEnvInt("RBO_LOG_SEND_QUEUE_MAX", process.env.RBO_LOG_SEND_QUEUE_MAX) : void 0) ?? file?.log_send_queue_max ?? DEFAULT_LOG_SEND_QUEUE_MAX,
+    disconnectGraceSeconds: fieldOverrides.disconnectGraceSeconds ?? (envSet("RBO_DISCONNECT_GRACE_SECONDS") ? parseEnvInt("RBO_DISCONNECT_GRACE_SECONDS", process.env.RBO_DISCONNECT_GRACE_SECONDS) : void 0) ?? file?.disconnect_grace_seconds ?? 60,
+    orphanTimeoutSeconds: fieldOverrides.orphanTimeoutSeconds ?? (envSet("RBO_ORPHAN_TIMEOUT_SECONDS") ? parseEnvInt("RBO_ORPHAN_TIMEOUT_SECONDS", process.env.RBO_ORPHAN_TIMEOUT_SECONDS) : void 0) ?? file?.orphan_timeout_seconds ?? 300,
+    reconcileDeadlineSeconds: fieldOverrides.reconcileDeadlineSeconds ?? (envSet("RBO_RECONCILE_DEADLINE_SECONDS") ? parseEnvInt("RBO_RECONCILE_DEADLINE_SECONDS", process.env.RBO_RECONCILE_DEADLINE_SECONDS) : void 0) ?? file?.reconcile_deadline_seconds ?? 120,
+    diskMinFreeBytes,
+    configuredPriority
   };
 }
 function resolveRepoCacheRoot(config) {
@@ -9554,7 +9865,15 @@ function ensureStateDir(config) {
   mkdirSync2(config.stateDir, { recursive: true });
 }
 
+// ../agent/dist/run.js
+init_dist();
+
 // ../agent/dist/capabilities/probe.js
+import { execFile as execFile2 } from "node:child_process";
+import { readFile as readFile5, readdir as readdir5, statfs } from "node:fs/promises";
+import { arch, cpus as cpus2, freemem, hostname, loadavg, platform as platform2, release, totalmem } from "node:os";
+import { join as join8 } from "node:path";
+import { promisify as promisify2 } from "node:util";
 var execFileAsync2 = promisify2(execFile2);
 function osFamily() {
   const p = platform2();
@@ -9704,7 +10023,7 @@ async function probeCapabilities(input) {
 // ../agent/dist/connection/client.js
 init_dist2();
 init_dist();
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { hostname as hostname2 } from "node:os";
 import { join as join22 } from "node:path";
 import WebSocket from "ws";
@@ -9808,7 +10127,7 @@ init_dist4();
 init_dist();
 init_dist3();
 import { createHash as createHash6 } from "node:crypto";
-import { createReadStream, existsSync as existsSync3 } from "node:fs";
+import { createReadStream, existsSync as existsSync4 } from "node:fs";
 import { copyFile, mkdir as mkdir9, readFile as readFile13, rename as rename4, rm as rm9, stat as stat7 } from "node:fs/promises";
 import { request as httpsRequest } from "node:https";
 import { join as join21 } from "node:path";
@@ -9911,7 +10230,7 @@ var SpoolSender = class {
 
 // ../agent/dist/recovery/attempt-metadata.js
 init_dist();
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { readdir as readdir10, rm as rm6 } from "node:fs/promises";
 import { dirname as dirname5, join as join18 } from "node:path";
 function attemptMetadataDir(stateDir, attemptId) {
@@ -9929,14 +10248,14 @@ function writeAttemptMetadata(stateDir, meta) {
     ...meta,
     updated_at: meta.updated_at || (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync2(tmp, `${JSON.stringify(payload, null, 2)}
+  writeFileSync3(tmp, `${JSON.stringify(payload, null, 2)}
 `, { encoding: "utf8", mode: 384 });
   renameSync(tmp, target);
 }
 function readAttemptMetadata(stateDir, attemptId) {
   const path = attemptMetadataPath(stateDir, attemptId);
   try {
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync4(path, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -10084,8 +10403,8 @@ async function applyDiskPressureCleanup(options) {
       for (const name of entries) {
         const metaPath = join19(reposDir, name, "metadata.json");
         try {
-          const { readFile: readFile20 } = await import("node:fs/promises");
-          const raw = await readFile20(metaPath, "utf8");
+          const { readFile: readFile19 } = await import("node:fs/promises");
+          const raw = await readFile19(metaPath, "utf8");
           const meta = JSON.parse(raw);
           if ((meta.active_worktree_count ?? 0) > 0) {
             continue;
@@ -11067,7 +11386,7 @@ var AgentJobExecutor = class {
     const currentProfiles = this.config.toolchainProfiles ?? [];
     for (const profile of offer.selected_toolchain_profiles ?? []) {
       const activationPath = profile.activation.path;
-      if (activationPath && !existsSync3(activationPath)) {
+      if (activationPath && !existsSync4(activationPath)) {
         this.failTerminal(run.attempt_id, run.lease_id, run.lease_epoch, "toolchain_changed", `Selected toolchain path missing: ${activationPath}`);
         await rm9(attemptDir, { recursive: true, force: true }).catch(() => void 0);
         this.clearAttempt();
@@ -11839,8 +12158,8 @@ var AgentConnection = class {
     return join22(this.options.stateDir, "agent-state.json");
   }
   loadState() {
-    if (existsSync4(this.statePath())) {
-      return JSON.parse(readFileSync4(this.statePath(), "utf8"));
+    if (existsSync5(this.statePath())) {
+      return JSON.parse(readFileSync5(this.statePath(), "utf8"));
     }
     const pair = generateDeviceKeyPair();
     const state = {
@@ -11852,7 +12171,7 @@ var AgentConnection = class {
   }
   saveState(state) {
     mkdirSync4(this.options.stateDir, { recursive: true });
-    writeFileSync3(this.statePath(), JSON.stringify(state), { mode: 384 });
+    writeFileSync4(this.statePath(), JSON.stringify(state), { mode: 384 });
   }
   hasStoredCredential() {
     const state = this.loadState();
@@ -12329,7 +12648,7 @@ init_dist();
 
 // src/commands/daemon.ts
 import { spawn as nodeSpawn } from "node:child_process";
-import { existsSync as existsSync5, openSync, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync6, openSync, readFileSync as readFileSync6 } from "node:fs";
 import { mkdir as mkdir10, writeFile as writeFile10 } from "node:fs/promises";
 import { dirname as dirname6, join as join23 } from "node:path";
 function stripDaemonFlag(args) {
@@ -12360,10 +12679,10 @@ function isProcessAlive(pid) {
   }
 }
 function assertNoLivePid(pidFile, label) {
-  if (!existsSync5(pidFile)) {
+  if (!existsSync6(pidFile)) {
     return;
   }
-  const raw = readFileSync5(pidFile, "utf8").trim();
+  const raw = readFileSync6(pidFile, "utf8").trim();
   const pid = Number.parseInt(raw, 10);
   if (isProcessAlive(pid)) {
     throw new Error(
@@ -12407,36 +12726,21 @@ async function spawnDetachedDaemon(options) {
 }
 
 // src/commands/agent.ts
-var AGENT_MARKER = "agent.json";
-var AGENT_SCHEMA_VERSION = 1;
 function isAgentInitialized(stateDir) {
-  return existsSync6(join24(stateDir, AGENT_MARKER));
+  return existsSync7(join24(stateDir, AGENT_CONFIG_FILENAME));
 }
-async function readAgentMarker(stateDir) {
-  const markerPath = join24(stateDir, AGENT_MARKER);
-  if (!existsSync6(markerPath)) {
-    return void 0;
-  }
-  const marker = JSON.parse(await readFile14(markerPath, "utf8"));
+async function runAgentInit(options = {}) {
+  const stateDir = options.stateDir ?? resolveAgentStateDir();
+  const result = writeDefaultAgentConfigFile(stateDir, { force: options.force });
   return {
     stateDir,
-    initialized_at: marker.initialized_at,
-    schema_version: marker.schema_version
+    initialized_at: result.initialized_at,
+    schema_version: result.schema_version,
+    configPath: result.path,
+    configWritten: result.written,
+    ...result.written ? {} : { hint: "agent.json already exists; pass --force to rewrite defaults" }
   };
 }
-async function runAgentInit(options = {}) {
-  const stateDir = options.stateDir ?? resolveAgentStateDir();
-  await mkdir11(stateDir, { recursive: true });
-  const existing = await readAgentMarker(stateDir);
-  if (existing) {
-    return existing;
-  }
-  const initialized_at = (/* @__PURE__ */ new Date()).toISOString();
-  const marker = { initialized_at, schema_version: AGENT_SCHEMA_VERSION };
-  await writeFile11(join24(stateDir, AGENT_MARKER), `${JSON.stringify(marker, null, 2)}
-`, "utf8");
-  return { stateDir, ...marker };
-}
 function assertAgentInitialized(stateDir) {
   if (!isAgentInitialized(stateDir)) {
     throw new Error("Agent is not initialized. Run `rbo agent init` first.");
@@ -12476,8 +12780,24 @@ async function postAdmin(baseUrl, action, body) {
   }
   return json;
 }
-function listAgentsRemote(baseUrl) {
-  return postAdmin(baseUrl, "agents/list", {});
+async function listAgentsRemote(baseUrl) {
+  const [agentsResult, pairingResult] = await Promise.all([
+    postAdmin(baseUrl, "agents/list", {}),
+    postAdmin(baseUrl, "pairing/list", {
+      state: "pending"
+    })
+  ]);
+  return {
+    agents: agentsResult.agents,
+    pending_pairings: pairingResult.requests.map((row) => ({
+      id: row.id,
+      display_name: row.display_name,
+      hostname: row.hostname,
+      state: row.state,
+      one_time_code: row.one_time_code,
+      expires_at: row.expires_at
+    }))
+  };
 }
 function approveAgentRemote(baseUrl, pairingRequestId) {
   return postAdmin(baseUrl, "pairing/approve", { pairing_request_id: pairingRequestId });
@@ -12490,8 +12810,9 @@ function probeAgentRemote(baseUrl, agentId) {
 }
 
 // src/commands/controller.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { readFile as readFile18 } from "node:fs/promises";
+init_config();
+import { existsSync as existsSync9 } from "node:fs";
+import { readFile as readFile17 } from "node:fs/promises";
 import { join as join32 } from "node:path";
 
 // ../controller/dist/run.js
@@ -12509,7 +12830,7 @@ init_dist4();
 init_dist2();
 init_dist();
 import { join as join31 } from "node:path";
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 
 // ../controller/dist/agents/probe.js
 function requestAgentProbe(connectedAgents, agentId) {
@@ -12597,7 +12918,7 @@ function validateToolInput(name, args) {
   if (!def) {
     throw RboError.validation(`Unknown tool '${name}'`);
   }
-  const parsed = z7.object(def.inputShape).safeParse(args ?? {});
+  const parsed = z9.object(def.inputShape).safeParse(args ?? {});
   if (!parsed.success) {
     throw RboError.validation(`Invalid input for tool '${name}'`, {
       issues: parsed.error.issues.map((issue) => ({
@@ -12745,7 +13066,7 @@ function revokeAgent(db, agentId) {
   }
 }
 function updateAgentCapabilities(db, agentId, report) {
-  db.prepare("UPDATE agents SET capabilities_json = ?, hostname = ?, last_seen_at = ? WHERE id = ?").run(JSON.stringify(report), report.hostname, nowIso(), agentId);
+  db.prepare("UPDATE agents SET capabilities_json = ?, hostname = ?, max_jobs = ?, last_seen_at = ? WHERE id = ?").run(JSON.stringify(report), report.hostname, report.execution.max_jobs, nowIso(), agentId);
 }
 function patchAgentCpuLoad(db, agentId, cpuLoad) {
   const row = db.prepare("SELECT capabilities_json FROM agents WHERE id = ?").get(agentId);
@@ -12829,11 +13150,20 @@ function getPairingRequest(db, id) {
   const row = db.prepare("SELECT * FROM pairing_requests WHERE id = ?").get(id);
   return row ?? null;
 }
+function expireStalePairingRequests(db) {
+  const now = nowIso();
+  const result = db.prepare(`UPDATE pairing_requests
+       SET state = 'expired', resolved_at = COALESCE(resolved_at, ?)
+       WHERE state IN ('pending', 'approved') AND expires_at <= ?`).run(now, now);
+  return result.changes;
+}
 function listPairingRequests(db, state) {
+  expireStalePairingRequests(db);
   const rows = state ? db.prepare("SELECT * FROM pairing_requests WHERE state = ? ORDER BY created_at").all(state) : db.prepare("SELECT * FROM pairing_requests ORDER BY created_at").all();
   return rows;
 }
 function createPairingRequest(db, input) {
+  expireStalePairingRequests(db);
   const thumbprint = publicKeyThumbprint(input.devicePublicKeyPem);
   const existing = db.prepare("SELECT * FROM pairing_requests WHERE device_thumbprint = ? AND state IN ('pending', 'approved') AND expires_at > ?").get(thumbprint, nowIso());
   if (existing) {
@@ -13609,7 +13939,13 @@ async function runController(overrides = {}) {
 init_dist();
 async function runControllerInit(options) {
   const identity = await ensureControllerIdentity(options.dataDir);
-  return { controllerId: identity.controllerId, fingerprint: identity.fingerprint };
+  const config = writeDefaultControllerConfigFile(options.dataDir, { force: options.force });
+  return {
+    controllerId: identity.controllerId,
+    fingerprint: identity.fingerprint,
+    configPath: config.path,
+    configWritten: config.written
+  };
 }
 async function runControllerFingerprint(options) {
   const identity = await ensureControllerIdentity(options.dataDir);
@@ -13618,10 +13954,10 @@ async function runControllerFingerprint(options) {
 async function readExistingControllerId(dataDir) {
   const certPath = join32(dataDir, "security", "controller-cert.pem");
   const metaPath = join32(dataDir, "security", "controller.json");
-  if (!existsSync7(certPath) || !existsSync7(metaPath)) {
+  if (!existsSync9(certPath) || !existsSync9(metaPath)) {
     return void 0;
   }
-  const meta = JSON.parse(await readFile18(metaPath, "utf8"));
+  const meta = JSON.parse(await readFile17(metaPath, "utf8"));
   return meta.controller_id;
 }
 async function isControllerInitialized(dataDir) {
@@ -13665,11 +14001,25 @@ async function runControllerRestore(options) {
 // src/commands/doctor.ts
 init_dist4();
 import { execFile as execFile9 } from "node:child_process";
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join33 } from "node:path";
-import { promisify as promisify9 } from "node:util";
+import { promisify as promisify9, styleText } from "node:util";
 var execFileAsync9 = promisify9(execFile9);
 var REQUIRED_NODE_ENGINES = { major: 22, minor: 14 };
+function doctorStatusTag(check) {
+  if (!check.ok) return "FAIL";
+  if (check.warn) return "WARN";
+  return "OK  ";
+}
+function formatDoctorCheckLine(check, options = {}) {
+  const tag = doctorStatusTag(check);
+  const colorName = !check.ok ? "red" : check.warn ? "yellow" : "green";
+  const styledTag = options.color === false ? tag : styleText(colorName, tag, {
+    stream: options.stream ?? process.stdout,
+    validateStream: options.color !== true
+  });
+  return `${styledTag} ${check.name}: ${check.detail}`;
+}
 async function checkGit() {
   try {
     const { stdout } = await execFileAsync9("git", ["--version"]);
@@ -13682,7 +14032,7 @@ function checkDataDirWritable(dataDir) {
   try {
     mkdirSync6(dataDir, { recursive: true });
     const probe = join33(dataDir, ".rbo-doctor-probe");
-    writeFileSync4(probe, "ok");
+    writeFileSync6(probe, "ok");
     return { name: "data_dir_writable", ok: true, detail: dataDir };
   } catch (error) {
     return { name: "data_dir_writable", ok: false, detail: String(error) };
@@ -13777,6 +14127,18 @@ async function runDoctor(options) {
 }
 
 // src/commands/flags.ts
+function parseForceFlag(args) {
+  const rest = [];
+  let force = false;
+  for (const arg of args) {
+    if (arg === "--force") {
+      force = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { force, rest };
+}
 function parseDataDirFlag(args) {
   const rest = [];
   let dataDir;
@@ -13849,6 +14211,7 @@ function cancelJobRemote(baseUrl, jobId, reason) {
 }
 
 // src/commands/service.ts
+init_dist();
 import { execFile as execFile10 } from "node:child_process";
 import { promisify as promisify10 } from "node:util";
 var execFileAsync10 = promisify10(execFile10);
@@ -13881,14 +14244,21 @@ var defaultCommandRunner = {
 var SERVICE_NAME = "RBOAgent";
 var LAUNCHD_LABEL = "com.rbo.agent";
 var SYSTEMD_UNIT = "rbo-agent";
-function renderServiceInstallPlan(platform3, executablePath = "C:/Program Files/RBO/rbo-agent.exe") {
+function renderAgentServiceCommand(options = {}) {
+  const nodePath = options.nodePath ?? process.execPath;
+  const rboScriptPath = options.rboScriptPath ?? process.argv[1] ?? "rbo.js";
+  const stateDir = options.stateDir ?? resolveAgentStateDir();
+  return `"${nodePath}" "${rboScriptPath}" agent start --state-dir "${stateDir}"`;
+}
+function renderServiceInstallPlan(platform3, options = {}) {
+  const binPath = renderAgentServiceCommand(options);
   switch (platform3) {
     case "win32":
       return {
         kind: "windows_service",
         serviceName: SERVICE_NAME,
         commands: [
-          `sc.exe create ${SERVICE_NAME} binPath= "${executablePath}" start= auto`,
+          `sc.exe create ${SERVICE_NAME} binPath= ${JSON.stringify(binPath)} start= auto`,
           `sc.exe description ${SERVICE_NAME} "Remote Build Orchestrator Agent"`,
           `sc.exe start ${SERVICE_NAME}`
         ]
@@ -13898,6 +14268,7 @@ function renderServiceInstallPlan(platform3, executablePath = "C:/Program Files/
         kind: "launchd",
         serviceName: LAUNCHD_LABEL,
         commands: [
+          `# Write /Library/LaunchDaemons/${LAUNCHD_LABEL}.plist with ProgramArguments: ${binPath}`,
           `launchctl load -w /Library/LaunchDaemons/${LAUNCHD_LABEL}.plist`,
           `launchctl start ${LAUNCHD_LABEL}`
         ]
@@ -13907,6 +14278,7 @@ function renderServiceInstallPlan(platform3, executablePath = "C:/Program Files/
         kind: "systemd",
         serviceName: SYSTEMD_UNIT,
         commands: [
+          `# Write /etc/systemd/system/${SYSTEMD_UNIT}.service with ExecStart=${binPath}`,
           "systemctl daemon-reload",
           `systemctl enable ${SYSTEMD_UNIT}`,
           `systemctl start ${SYSTEMD_UNIT}`
@@ -14009,10 +14381,10 @@ function renderServiceStopPlan(platform3) {
       };
   }
 }
-function renderServiceActionPlan(platform3, action, executablePath) {
+function renderServiceActionPlan(platform3, action, options) {
   switch (action) {
     case "install":
-      return renderServiceInstallPlan(platform3, executablePath);
+      return renderServiceInstallPlan(platform3, options);
     case "uninstall":
       return renderServiceUninstallPlan(platform3);
     case "status":
@@ -14027,7 +14399,11 @@ function hasExecuteFlag(args) {
   return args.includes("--execute");
 }
 function formatDryRunPlan(action, plan) {
-  const lines = [`# ${action} (dry run \u2014 pass --execute to run these commands)`];
+  const lines = [
+    `# ${action} (dry run \u2014 pass --execute to run these commands)`,
+    "# Prefer `rbo agent start --daemon` for day-to-day use; OS service install is best-effort",
+    "# and expects node + bundled rbo.js (not a Program Files rbo-agent.exe)."
+  ];
   for (const command of plan.commands) {
     lines.push(command);
   }
@@ -14036,6 +14412,10 @@ function formatDryRunPlan(action, plan) {
 async function executeServicePlan(plan, runner = defaultCommandRunner) {
   const results = [];
   for (const command of plan.commands) {
+    if (command.trimStart().startsWith("#")) {
+      results.push({ command, stdout: "", stderr: "skipped comment", code: 0 });
+      continue;
+    }
     const { stdout, stderr, code } = await runner.run(command);
     results.push({ command, stdout, stderr, code });
     if (code !== 0) {
@@ -14067,7 +14447,8 @@ async function main() {
       const dataDir = flagDataDir ?? resolveControllerDataDir();
       const sub = controllerArgs[0];
       if (sub === "init") {
-        const result = await runControllerInit({ dataDir });
+        const { force } = parseForceFlag(controllerArgs.slice(1));
+        const result = await runControllerInit({ dataDir, force });
         console.log(JSON.stringify(result, null, 2));
         return;
       }
@@ -14106,7 +14487,7 @@ async function main() {
     }
     case "agents": {
       const result = await listAgentsRemote(controllerUrl);
-      console.log(JSON.stringify(result.agents, null, 2));
+      console.log(JSON.stringify(result, null, 2));
       return;
     }
     case "agent": {
@@ -14135,7 +14516,8 @@ async function main() {
         return;
       }
       if (sub === "init") {
-        const result = await runAgentInit({ stateDir });
+        const { force } = parseForceFlag(agentArgs.slice(1));
+        const result = await runAgentInit({ stateDir, force });
         console.log(JSON.stringify(result, null, 2));
         return;
       }
@@ -14178,8 +14560,7 @@ async function main() {
       const dataDir = flagDataDir ?? resolveControllerDataDir();
       const report = await runDoctor({ dataDir, controllerUrl });
       for (const check of report.checks) {
-        const tag = !check.ok ? "FAIL" : check.warn ? "WARN" : "OK  ";
-        console.log(`${tag} ${check.name}: ${check.detail}`);
+        console.log(formatDoctorCheckLine(check));
       }
       process.exitCode = report.ok ? 0 : 1;
       return;
@@ -14189,7 +14570,7 @@ async function main() {
       if (!requestPath) {
         throw new Error("Usage: rbo submit <job-request.json>");
       }
-      const request = JSON.parse(await readFile19(requestPath, "utf8"));
+      const request = JSON.parse(await readFile18(requestPath, "utf8"));
       const result = await submitJobRemote(controllerUrl, request);
       console.log(JSON.stringify(result, null, 2));
       return;