@ryanfw/prompt-orchestration-pipeline 1.3.3 → 1.3.4

package/src/core/__tests__/config.test.ts

@@ -1,56 +1,8 @@
 import { describe, test, expect, afterEach } from "bun:test";
-import { defaultConfig, resetConfig, loadConfig, getConfig, getConfigValue, getPipelineConfig, getOrchestratorConfig } from "../config";
-import type { AppConfig } from "../config";
-import { mkdtemp, writeFile, mkdir, rm } from "node:fs/promises";
+import { readFileSync, readdirSync, statSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-
-// Tests for validateConfig behavior are covered indirectly through loadConfig tests.
-// Direct tests for edge cases:
-
-describe("config environment overrides", () => {
-  const originalEnv = { ...process.env };
-  afterEach(() => {
-    process.env = { ...originalEnv };
-    resetConfig();
-  });
-
-  test("PO_SHUTDOWN_TIMEOUT overrides orchestrator.shutdownTimeout", async () => {
-    // Tested via loadConfig in step 7
-  });
-});
-
-describe("loadConfig", () => {
-  afterEach(() => {
-    resetConfig();
-  });
-
-  test("throws when PO_ROOT is not set", async () => {
-    const origRoot = process.env.PO_ROOT;
-    delete process.env.PO_ROOT;
-    try {
-      await expect(loadConfig()).rejects.toThrow("PO_ROOT is required");
-    } finally {
-      if (origRoot) process.env.PO_ROOT = origRoot;
-    }
-  });
-
-  test("loads config from file and merges with defaults", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "config-test-"));
-    const configDir = join(dir, "pipeline-config", "test");
-    const tasksDir = join(configDir, "tasks");
-    await mkdir(tasksDir, { recursive: true });
-    await writeFile(join(configDir, "pipeline.json"), JSON.stringify({ name: "test", tasks: ["t1"] }));
-    await writeFile(join(dir, "pipeline-config", "registry.json"), JSON.stringify({
-      pipelines: { test: { configDir, tasksDir } }
-    }));
-    process.env.PO_ROOT = dir;
-    const config = await loadConfig();
-    expect(config.paths.root).toBe(dir);
-    expect(config.pipelines.test).toBeDefined();
-    await rm(dir, { recursive: true });
-  });
-});
+import { defaultConfig, resetConfig, getConfig, getConfigValue, getPipelineConfig, getOrchestratorConfig } from "../config";
 
 describe("defaultConfig", () => {
   afterEach(() => {
@@ -62,7 +14,6 @@ describe("defaultConfig", () => {
     expect(defaultConfig.taskRunner).toBeDefined();
     expect(defaultConfig.llm).toBeDefined();
     expect(defaultConfig.ui).toBeDefined();
-    expect(defaultConfig.paths).toBeDefined();
     expect(defaultConfig.validation).toBeDefined();
     expect(defaultConfig.logging).toBeDefined();
   });
@@ -82,54 +33,6 @@ describe("defaultConfig", () => {
   });
 });
 
-describe("validateConfig (via loadConfig)", () => {
-  afterEach(() => {
-    resetConfig();
-  });
-
-  test("throws when taskRunner.maxAttempts is 0", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "config-test-"));
-    const configDir = join(dir, "pipeline-config", "test");
-    const tasksDir = join(configDir, "tasks");
-    await mkdir(tasksDir, { recursive: true });
-    await writeFile(join(configDir, "pipeline.json"), JSON.stringify({ name: "test", tasks: ["t1"] }));
-    await writeFile(join(dir, "pipeline-config", "registry.json"), JSON.stringify({
-      pipelines: { test: { configDir, tasksDir } }
-    }));
-    const overrideFile = join(dir, "config.json");
-    await writeFile(overrideFile, JSON.stringify({ taskRunner: { maxAttempts: 0 } }));
-    const origRoot = process.env.PO_ROOT;
-    process.env.PO_ROOT = dir;
-    try {
-      await expect(loadConfig({ configPath: overrideFile })).rejects.toThrow("taskRunner.maxAttempts must be an integer >= 1");
-    } finally {
-      if (origRoot) process.env.PO_ROOT = origRoot; else delete process.env.PO_ROOT;
-      await rm(dir, { recursive: true });
-    }
-  });
-
-  test("throws when taskRunner.maxAttempts is non-integer", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "config-test-"));
-    const configDir = join(dir, "pipeline-config", "test");
-    const tasksDir = join(configDir, "tasks");
-    await mkdir(tasksDir, { recursive: true });
-    await writeFile(join(configDir, "pipeline.json"), JSON.stringify({ name: "test", tasks: ["t1"] }));
-    await writeFile(join(dir, "pipeline-config", "registry.json"), JSON.stringify({
-      pipelines: { test: { configDir, tasksDir } }
-    }));
-    const overrideFile = join(dir, "config.json");
-    await writeFile(overrideFile, JSON.stringify({ taskRunner: { maxAttempts: 2.5 } }));
-    const origRoot = process.env.PO_ROOT;
-    process.env.PO_ROOT = dir;
-    try {
-      await expect(loadConfig({ configPath: overrideFile })).rejects.toThrow("taskRunner.maxAttempts must be an integer >= 1");
-    } finally {
-      if (origRoot) process.env.PO_ROOT = origRoot; else delete process.env.PO_ROOT;
-      await rm(dir, { recursive: true });
-    }
-  });
-});
-
 describe("PO_TASK_MAX_ATTEMPTS env override", () => {
   afterEach(() => {
     delete process.env.PO_TASK_MAX_ATTEMPTS;
@@ -139,7 +42,7 @@ describe("PO_TASK_MAX_ATTEMPTS env override", () => {
   test("getConfig reads PO_TASK_MAX_ATTEMPTS into taskRunner.maxAttempts", () => {
     process.env.PO_TASK_MAX_ATTEMPTS = "5";
     resetConfig();
-    const config: AppConfig = getConfig();
+    const config = getConfig();
     expect(config.taskRunner.maxAttempts).toBe(5);
   });
 
@@ -165,32 +68,32 @@ describe("PO_MAX_RUNNING_JOBS env override", () => {
   test("getConfig reads PO_MAX_RUNNING_JOBS into orchestrator.maxConcurrentJobs", () => {
     process.env.PO_MAX_RUNNING_JOBS = "7";
     resetConfig();
-    const config: AppConfig = getConfig();
+    const config = getConfig();
     expect(config.orchestrator.maxConcurrentJobs).toBe(7);
   });
 
   test("getConfig rejects PO_MAX_RUNNING_JOBS=0", () => {
     process.env.PO_MAX_RUNNING_JOBS = "0";
     resetConfig();
-    expect(() => getConfig()).toThrow("orchestrator.maxConcurrentJobs");
+    expect(() => getConfig()).toThrow(/PO_MAX_RUNNING_JOBS/);
   });
 
   test("getConfig rejects negative PO_MAX_RUNNING_JOBS", () => {
     process.env.PO_MAX_RUNNING_JOBS = "-1";
     resetConfig();
-    expect(() => getConfig()).toThrow("orchestrator.maxConcurrentJobs");
+    expect(() => getConfig()).toThrow(/PO_MAX_RUNNING_JOBS/);
   });
 
   test("getConfig rejects non-integer PO_MAX_RUNNING_JOBS", () => {
     process.env.PO_MAX_RUNNING_JOBS = "1.5";
     resetConfig();
-    expect(() => getConfig()).toThrow("orchestrator.maxConcurrentJobs");
+    expect(() => getConfig()).toThrow(/PO_MAX_RUNNING_JOBS/);
   });
 
   test("getConfig rejects non-numeric PO_MAX_RUNNING_JOBS", () => {
     process.env.PO_MAX_RUNNING_JOBS = "abc";
     resetConfig();
-    expect(() => getConfig()).toThrow("orchestrator.maxConcurrentJobs");
+    expect(() => getConfig()).toThrow(/PO_MAX_RUNNING_JOBS/);
   });
 });
 
@@ -214,13 +117,49 @@ describe("PO_STALE_RUNNING_GRACE_MS env override", () => {
   test("getOrchestratorConfig rejects non-positive PO_STALE_RUNNING_GRACE_MS", () => {
     process.env.PO_STALE_RUNNING_GRACE_MS = "-1";
     resetConfig();
-    expect(() => getOrchestratorConfig()).toThrow("orchestrator.staleRunningGraceMs");
+    expect(() => getOrchestratorConfig()).toThrow(/PO_STALE_RUNNING_GRACE_MS/);
   });
 
   test("getOrchestratorConfig rejects non-integer PO_STALE_RUNNING_GRACE_MS", () => {
     process.env.PO_STALE_RUNNING_GRACE_MS = "1.5";
     resetConfig();
-    expect(() => getOrchestratorConfig()).toThrow("orchestrator.staleRunningGraceMs");
+    expect(() => getOrchestratorConfig()).toThrow(/PO_STALE_RUNNING_GRACE_MS/);
+  });
+});
+
+describe("PO_STALE_LEASE_TIMEOUT_MS env override", () => {
+  afterEach(() => {
+    delete process.env.PO_STALE_LEASE_TIMEOUT_MS;
+    resetConfig();
+  });
+
+  test("getOrchestratorConfig defaults staleLeaseTimeoutMs to 30000", () => {
+    resetConfig();
+    expect(getOrchestratorConfig().staleLeaseTimeoutMs).toBe(30000);
+  });
+
+  test("getOrchestratorConfig reads PO_STALE_LEASE_TIMEOUT_MS into orchestrator.staleLeaseTimeoutMs", () => {
+    process.env.PO_STALE_LEASE_TIMEOUT_MS = "60000";
+    resetConfig();
+    expect(getOrchestratorConfig().staleLeaseTimeoutMs).toBe(60000);
+  });
+
+  test("getOrchestratorConfig rejects PO_STALE_LEASE_TIMEOUT_MS=0", () => {
+    process.env.PO_STALE_LEASE_TIMEOUT_MS = "0";
+    resetConfig();
+    expect(() => getOrchestratorConfig()).toThrow(/PO_STALE_LEASE_TIMEOUT_MS/);
+  });
+
+  test("getOrchestratorConfig rejects negative PO_STALE_LEASE_TIMEOUT_MS", () => {
+    process.env.PO_STALE_LEASE_TIMEOUT_MS = "-1";
+    resetConfig();
+    expect(() => getOrchestratorConfig()).toThrow(/PO_STALE_LEASE_TIMEOUT_MS/);
+  });
+
+  test("getOrchestratorConfig rejects non-integer PO_STALE_LEASE_TIMEOUT_MS", () => {
+    process.env.PO_STALE_LEASE_TIMEOUT_MS = "1.5";
+    resetConfig();
+    expect(() => getOrchestratorConfig()).toThrow(/PO_STALE_LEASE_TIMEOUT_MS/);
   });
 });
 
@@ -236,6 +175,85 @@ describe("getConfig", () => {
   });
 });
 
+describe("getConfig immutability", () => {
+  afterEach(() => {
+    resetConfig();
+  });
+
+  test("returns the same frozen reference on repeat calls", () => {
+    const a = getConfig();
+    const b = getConfig();
+    expect(a).toBe(b);
+    expect(Object.isFrozen(a)).toBe(true);
+  });
+
+  test("top-level mutation throws at runtime", () => {
+    const c = getConfig();
+    expect(() => {
+      (c as unknown as { ui: { port: number } }).ui.port = 99;
+    }).toThrow();
+  });
+
+  test("nested mutation throws at runtime", () => {
+    const c = getConfig();
+    expect(() => {
+      (c as unknown as { orchestrator: { shutdownTimeout: number } }).orchestrator.shutdownTimeout = 99;
+    }).toThrow();
+  });
+
+  test("deeper nested mutation throws at runtime", () => {
+    const c = getConfig();
+    expect(() => {
+      (c as unknown as { logging: { level: string } }).logging.level = "debug";
+    }).toThrow();
+  });
+
+  test("array element objects are frozen at runtime", () => {
+    const mutableDefault = defaultConfig as unknown as {
+      arrayProbe?: { items: Array<{ value: number }> };
+    };
+    mutableDefault.arrayProbe = { items: [{ value: 1 }] };
+    try {
+      resetConfig();
+      const c = getConfig() as unknown as { arrayProbe: { items: Array<{ value: number }> } };
+      const first = c.arrayProbe.items[0];
+      expect(first).toBeDefined();
+      expect(Object.isFrozen(first)).toBe(true);
+      expect(() => {
+        first!.value = 2;
+      }).toThrow();
+    } finally {
+      delete mutableDefault.arrayProbe;
+      resetConfig();
+    }
+  });
+});
+
+describe("getConfig validation", () => {
+  afterEach(() => {
+    resetConfig();
+  });
+
+  test("throws before caching when maxRefinementAttempts < 1", () => {
+    const original = defaultConfig.taskRunner.maxRefinementAttempts;
+    defaultConfig.taskRunner.maxRefinementAttempts = 0;
+    try {
+      resetConfig();
+      expect(() => getConfig()).toThrow(/maxRefinementAttempts/);
+      resetConfig();
+      expect(() => getConfig()).toThrow(/maxRefinementAttempts/);
+    } finally {
+      defaultConfig.taskRunner.maxRefinementAttempts = original;
+      resetConfig();
+    }
+  });
+
+  test("passes validation through getConfig with unmodified defaults", () => {
+    resetConfig();
+    expect(() => getConfig()).not.toThrow();
+  });
+});
+
 describe("resetConfig", () => {
   test("clears cached config", () => {
     const config1 = getConfig();
@@ -270,3 +288,395 @@ describe("getPipelineConfig", () => {
     expect(() => getPipelineConfig("nonexistent-slug")).toThrow("not found in registry");
   });
 });
+
+describe("pipeline registry hydration via shared module", () => {
+  let tmpDir: string;
+  const prevPoRoot = process.env["PO_ROOT"];
+
+  afterEach(() => {
+    if (prevPoRoot === undefined) delete process.env["PO_ROOT"];
+    else process.env["PO_ROOT"] = prevPoRoot;
+    resetConfig();
+    if (tmpDir) rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("getConfig hydrates config.pipelines from a canonical v1 registry", () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "pop-cfg-hydrate-"));
+    const registryDir = join(tmpDir, "pipeline-config");
+    mkdirSync(registryDir, { recursive: true });
+    writeFileSync(
+      join(registryDir, "registry.json"),
+      JSON.stringify({
+        version: 1,
+        pipelines: { "demo-pipe": { name: "Demo", description: "demo pipeline" } },
+      }),
+    );
+
+    process.env["PO_ROOT"] = tmpDir;
+    resetConfig();
+    const cfg = getConfig();
+
+    const entry = cfg.pipelines["demo-pipe"];
+    expect(entry).toBeDefined();
+    expect(entry!.configDir).toBe(join(tmpDir, "pipeline-config", "demo-pipe"));
+    expect(entry!.tasksDir).toBe(join(tmpDir, "pipeline-config", "demo-pipe", "tasks"));
+  });
+
+  test("getPipelineConfig(slug, root) resolves via the shared module", () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "pop-cfg-resolve-"));
+    const slugDir = join(tmpDir, "pipeline-config", "my-slug");
+    const tasksDir = join(slugDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(slugDir, "pipeline.json"), JSON.stringify({ name: "my-slug" }));
+    writeFileSync(
+      join(tmpDir, "pipeline-config", "registry.json"),
+      JSON.stringify({
+        version: 1,
+        pipelines: { "my-slug": { name: "My Slug", description: "scaffolded" } },
+      }),
+    );
+
+    const result = getPipelineConfig("my-slug", tmpDir);
+
+    expect(result.pipelineJsonPath).toBe(join(slugDir, "pipeline.json"));
+    expect(result.tasksDir).toBe(tasksDir);
+  });
+
+  test("getPipelineConfig(slug, root) throws for unknown slug", () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "pop-cfg-unknown-"));
+    mkdirSync(join(tmpDir, "pipeline-config"), { recursive: true });
+    writeFileSync(
+      join(tmpDir, "pipeline-config", "registry.json"),
+      JSON.stringify({ version: 1, pipelines: {} }),
+    );
+
+    expect(() => getPipelineConfig("missing", tmpDir)).toThrow(
+      "Pipeline 'missing' not found in registry",
+    );
+  });
+});
+
+describe("PORT env override", () => {
+  afterEach(() => {
+    delete process.env.PORT;
+    resetConfig();
+  });
+
+  test("getConfig reads PORT into ui.port", () => {
+    process.env.PORT = "4500";
+    resetConfig();
+    expect(getConfig().ui.port).toBe(4500);
+  });
+
+  test("getConfig rejects PORT=foo", () => {
+    process.env.PORT = "foo";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PORT/);
+  });
+
+  test("getConfig rejects PORT=empty string", () => {
+    process.env.PORT = "";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PORT/);
+  });
+
+  test("getConfig rejects PORT=0", () => {
+    process.env.PORT = "0";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PORT/);
+  });
+
+  test("getConfig rejects PORT=70000", () => {
+    process.env.PORT = "70000";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PORT/);
+  });
+
+  test("PORT=0 error message names PORT, not ui.port", () => {
+    process.env.PORT = "0";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/^PORT must be between/);
+  });
+});
+
+describe("PO_UI_PORT env override", () => {
+  afterEach(() => {
+    delete process.env.PO_UI_PORT;
+    resetConfig();
+  });
+
+  test("getConfig reads PO_UI_PORT into ui.port", () => {
+    process.env.PO_UI_PORT = "4501";
+    resetConfig();
+    expect(getConfig().ui.port).toBe(4501);
+  });
+
+  test("getConfig rejects PO_UI_PORT=foo", () => {
+    process.env.PO_UI_PORT = "foo";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_UI_PORT/);
+  });
+
+  test("getConfig rejects PO_UI_PORT=empty string", () => {
+    process.env.PO_UI_PORT = "";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_UI_PORT/);
+  });
+
+  test("getConfig rejects PO_UI_PORT=70000", () => {
+    process.env.PO_UI_PORT = "70000";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_UI_PORT/);
+  });
+
+  test("getConfig rejects PO_UI_PORT=1.5", () => {
+    process.env.PO_UI_PORT = "1.5";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_UI_PORT/);
+  });
+});
+
+describe("PO_INTERNAL_LLM_* env override", () => {
+  afterEach(() => {
+    delete process.env.PO_INTERNAL_LLM_PROVIDER;
+    delete process.env.PO_INTERNAL_LLM_MODEL;
+    delete process.env.PO_MAX_CONCURRENCY;
+    resetConfig();
+  });
+
+  test("defaultConfig exposes internalProvider/internalModel defaults", () => {
+    expect(defaultConfig.llm.internalProvider).toBe("deepseek");
+    expect(defaultConfig.llm.internalModel).toBe("deepseek-v4-flash");
+  });
+
+  test("getConfig defaults to deepseek / deepseek-v4-flash when env is unset", () => {
+    resetConfig();
+    const config = getConfig();
+    expect(config.llm.internalProvider).toBe("deepseek");
+    expect(config.llm.internalModel).toBe("deepseek-v4-flash");
+  });
+
+  test("getConfig reads PO_INTERNAL_LLM_PROVIDER into llm.internalProvider", () => {
+    process.env.PO_INTERNAL_LLM_PROVIDER = "zai";
+    resetConfig();
+    expect(getConfig().llm.internalProvider).toBe("zai");
+  });
+
+  test("getConfig reads PO_INTERNAL_LLM_MODEL into llm.internalModel", () => {
+    process.env.PO_INTERNAL_LLM_MODEL = "foo:bar";
+    resetConfig();
+    expect(getConfig().llm.internalModel).toBe("foo:bar");
+  });
+
+  test("getConfig rejects empty PO_INTERNAL_LLM_PROVIDER", () => {
+    process.env.PO_INTERNAL_LLM_PROVIDER = "";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_INTERNAL_LLM_PROVIDER/);
+  });
+
+  test("getConfig rejects empty PO_INTERNAL_LLM_MODEL", () => {
+    process.env.PO_INTERNAL_LLM_MODEL = "";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_INTERNAL_LLM_MODEL/);
+  });
+
+  test("internal overrides do not clobber maxConcurrency", () => {
+    process.env.PO_INTERNAL_LLM_PROVIDER = "zai";
+    process.env.PO_INTERNAL_LLM_MODEL = "zai:glm-4";
+    process.env.PO_MAX_CONCURRENCY = "9";
+    resetConfig();
+    const config = getConfig();
+    expect(config.llm.internalProvider).toBe("zai");
+    expect(config.llm.internalModel).toBe("zai:glm-4");
+    expect(config.llm.maxConcurrency).toBe(9);
+  });
+});
+
+describe("PO_MAX_CONCURRENCY env override", () => {
+  afterEach(() => {
+    delete process.env.PO_MAX_CONCURRENCY;
+    resetConfig();
+  });
+
+  test("getConfig reads PO_MAX_CONCURRENCY into llm.maxConcurrency", () => {
+    process.env.PO_MAX_CONCURRENCY = "7";
+    resetConfig();
+    expect(getConfig().llm.maxConcurrency).toBe(7);
+  });
+
+  test("getConfig rejects PO_MAX_CONCURRENCY=foo", () => {
+    process.env.PO_MAX_CONCURRENCY = "foo";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_MAX_CONCURRENCY/);
+  });
+
+  test("getConfig rejects PO_MAX_CONCURRENCY=empty string", () => {
+    process.env.PO_MAX_CONCURRENCY = "";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_MAX_CONCURRENCY/);
+  });
+
+  test("getConfig rejects PO_MAX_CONCURRENCY=0", () => {
+    process.env.PO_MAX_CONCURRENCY = "0";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_MAX_CONCURRENCY/);
+  });
+
+  test("getConfig rejects PO_MAX_CONCURRENCY=1.5", () => {
+    process.env.PO_MAX_CONCURRENCY = "1.5";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_MAX_CONCURRENCY/);
+  });
+});
+
+describe("PO_SHUTDOWN_TIMEOUT env override", () => {
+  afterEach(() => {
+    delete process.env.PO_SHUTDOWN_TIMEOUT;
+    resetConfig();
+  });
+
+  test("getConfig reads PO_SHUTDOWN_TIMEOUT=0 (boundary)", () => {
+    process.env.PO_SHUTDOWN_TIMEOUT = "0";
+    resetConfig();
+    expect(getConfig().orchestrator.shutdownTimeout).toBe(0);
+  });
+
+  test("getConfig reads PO_SHUTDOWN_TIMEOUT=5000", () => {
+    process.env.PO_SHUTDOWN_TIMEOUT = "5000";
+    resetConfig();
+    expect(getConfig().orchestrator.shutdownTimeout).toBe(5000);
+  });
+
+  test("getConfig rejects PO_SHUTDOWN_TIMEOUT=foo", () => {
+    process.env.PO_SHUTDOWN_TIMEOUT = "foo";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_SHUTDOWN_TIMEOUT/);
+  });
+
+  test("getConfig rejects PO_SHUTDOWN_TIMEOUT=empty string", () => {
+    process.env.PO_SHUTDOWN_TIMEOUT = "";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_SHUTDOWN_TIMEOUT/);
+  });
+
+  test("getConfig rejects PO_SHUTDOWN_TIMEOUT=-1 (min=0)", () => {
+    process.env.PO_SHUTDOWN_TIMEOUT = "-1";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_SHUTDOWN_TIMEOUT/);
+  });
+});
+
+describe("empty-string numeric env vars", () => {
+  const VARS = [
+    "PO_TASK_MAX_ATTEMPTS",
+    "PO_MAX_RUNNING_JOBS",
+    "PO_STALE_RUNNING_GRACE_MS",
+    "PO_STALE_LEASE_TIMEOUT_MS",
+  ] as const;
+
+  afterEach(() => {
+    for (const name of VARS) delete process.env[name];
+    resetConfig();
+  });
+
+  for (const name of VARS) {
+    test(`rejects empty ${name}`, () => {
+      process.env[name] = "";
+      resetConfig();
+      expect(() => getConfig()).toThrow(new RegExp(name));
+    });
+  }
+});
+
+describe("PO_LOG_LEVEL env override", () => {
+  afterEach(() => {
+    delete process.env.PO_LOG_LEVEL;
+    resetConfig();
+  });
+
+  test("getConfig reads PO_LOG_LEVEL=debug", () => {
+    process.env.PO_LOG_LEVEL = "debug";
+    resetConfig();
+    expect(getConfig().logging.level).toBe("debug");
+  });
+
+  test("getConfig reads PO_LOG_LEVEL=warn", () => {
+    process.env.PO_LOG_LEVEL = "warn";
+    resetConfig();
+    expect(getConfig().logging.level).toBe("warn");
+  });
+
+  test("getConfig rejects PO_LOG_LEVEL=loud", () => {
+    process.env.PO_LOG_LEVEL = "loud";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_LOG_LEVEL/);
+  });
+
+  test("getConfig rejects PO_LOG_LEVEL=empty string", () => {
+    process.env.PO_LOG_LEVEL = "";
+    resetConfig();
+    expect(() => getConfig()).toThrow(/PO_LOG_LEVEL/);
+  });
+
+  test("getConfig uses default level when PO_LOG_LEVEL is unset", () => {
+    resetConfig();
+    expect(getConfig().logging.level).toBe("info");
+  });
+});
+
+describe("default fallbacks for unset numeric env vars", () => {
+  afterEach(() => {
+    delete process.env.PO_MAX_CONCURRENCY;
+    delete process.env.PO_SHUTDOWN_TIMEOUT;
+    resetConfig();
+  });
+
+  test("unset PO_MAX_CONCURRENCY falls back to defaultConfig.llm.maxConcurrency", () => {
+    resetConfig();
+    expect(getConfig().llm.maxConcurrency).toBe(defaultConfig.llm.maxConcurrency);
+  });
+
+  test("unset PO_SHUTDOWN_TIMEOUT falls back to defaultConfig.orchestrator.shutdownTimeout", () => {
+    resetConfig();
+    expect(getConfig().orchestrator.shutdownTimeout).toBe(defaultConfig.orchestrator.shutdownTimeout);
+  });
+});
+
+describe("source deletion scan", () => {
+  const SRC_ROOT = join(import.meta.dir, "..", "..");
+  const DELETED_TOKENS = [
+    "loadConfig",
+    "LoadConfigOptions",
+    "PathsConfig",
+    "AppConfig.paths",
+  ] as const;
+
+  function walkTs(dir: string): string[] {
+    const out: string[] = [];
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry);
+      if (statSync(full).isDirectory()) {
+        out.push(...walkTs(full));
+        continue;
+      }
+      if (/\.tsx?$/.test(entry)) out.push(full);
+    }
+    return out;
+  }
+
+  test("no src/ file references deleted config symbols", () => {
+    const files = walkTs(SRC_ROOT).filter((f) => !f.includes("/__tests__/"));
+    const offending: Array<{ file: string; token: string }> = [];
+    for (const file of files) {
+      const content = readFileSync(file, "utf8");
+      for (const token of DELETED_TOKENS) {
+        if (content.includes(token)) offending.push({ file, token });
+      }
+    }
+    if (offending.length > 0) {
+      const lines = offending.map((o) => `  ${o.file}: ${o.token}`).join("\n");
+      throw new Error(`Deleted config symbols still referenced under src/:\n${lines}`);
+    }
+    expect(offending).toHaveLength(0);
+  });
+});