phoebe-agent 0.0.0 → 0.1.0

package/templates/container/compose.yml

@@ -1,41 +1,61 @@
 # Phoebe compose file — scaffolded by `phoebe init`, consumer-owned.
 #
-# Base configuration: builds the runtime image, mounts the three named volumes
-# the engine expects (`/data/repo`, `/data/worktrees`, `/data/state`), and
-# runs the CLI once with `--run-once`. For the persistent daemon topology,
-# stack the daemon overlay:
+# One long-lived container. Its main process is `phoebe boot` (pinned into the
+# image's ENTRYPOINT), which materializes the engine named by `engine` in
+# phoebe.config.ts, runs it, and keeps supervising it for the life of the
+# container — so this file describes a daemon, not a one-shot:
 #
-#   docker compose -f compose.yml -f compose.daemon.yml up -d
+#   docker compose up -d          # run it
+#   docker compose logs -f        # watch it
+#   docker compose stop           # SIGTERM → the engine drains, finishing its
+#                                 # current work unit and starting no new one
 #
-# The image ships a pinned {{CLI_BIN}} — bump PHOEBE_VERSION here (not in the
-# Dockerfile) to upgrade the engine.
+# For a scoped, non-daemon invocation, pass engine flags — the image's `CMD []`
+# means anything here is forwarded straight through `boot` to the engine:
+#
+#   docker compose run --rm phoebe --dry-run --run-once   # selection preview
+#   docker compose run --rm phoebe --run-once             # work exactly one unit
+#
+# To upgrade the engine, edit `engine.ref` in phoebe.config.ts — `boot` notices
+# within a poll interval and relaunches at the next work-unit boundary. No
+# rebuild and no restart; rebuild only when this image's toolchain changes.
 
 services:
   phoebe:
     build:
       context: .
       args:
-        PHOEBE_VERSION: "${PHOEBE_VERSION:-latest}"
         PHOEBE_INSTALL_COMMAND: "{{INSTALL_COMMAND}}"
-    image: phoebe-runtime:${PHOEBE_VERSION:-latest}
-    command: ["--run-once"]
+    image: phoebe-runtime:latest
+    restart: unless-stopped
     environment:
-      PHOEBE_VERSION: "${PHOEBE_VERSION:-latest}"
-      # Secrets — populate via `.env` (see `.env.example`).
+      # Secrets — populate via `.env` (see `.env.example`). GH_TOKEN also
+      # authenticates the engine checkout when `engine.source` is "github".
       GH_TOKEN: "${GH_TOKEN:?GH_TOKEN is required}"
       ANTHROPIC_API_KEY: "${ANTHROPIC_API_KEY:-}"
       CURSOR_API_KEY: "${CURSOR_API_KEY:-}"
       OPENAI_KEY: "${OPENAI_KEY:-}"
+      # Where `boot` keeps engine checkouts. Pointed at a named volume below so
+      # a restart fetches into an existing clone instead of cloning again.
+      PHOEBE_ENGINE_DIR: /data/engine
       # Optional runtime toggles.
       PHOEBE_AGENT: "${PHOEBE_AGENT:-}"
       PHOEBE_MODEL: "${PHOEBE_MODEL:-}"
       PHOEBE_POLL_INTERVAL_MS: "${PHOEBE_POLL_INTERVAL_MS:-}"
+      PHOEBE_RECONCILE_INTERVAL_MS: "${PHOEBE_RECONCILE_INTERVAL_MS:-}"
     volumes:
       - phoebe-repo:/data/repo
       - phoebe-worktrees:/data/worktrees
       - phoebe-state:/data/state
+      - phoebe-engine:/data/engine
       # Consumer config + prompt overrides live in-repo; mount them read-only
-      # so a `docker compose restart` picks up edits without a rebuild.
+      # so `boot` can re-read the config without a rebuild.
+      #
+      # Caveat worth knowing: a single-file bind mount pins the host *inode*, so
+      # a save that writes a new file and renames it over the old one — most
+      # editors' atomic save, and what `git pull` does — is invisible in here,
+      # and `boot`'s config watch will never fire for it. Either edit in place,
+      # or follow the write with `docker compose up -d --force-recreate`.
       - ../phoebe.config.ts:/etc/phoebe/phoebe.config.ts:ro
       - ../prompts:/etc/phoebe/prompts:ro
     working_dir: /etc/phoebe
@@ -44,3 +64,4 @@ volumes:
   phoebe-repo:
   phoebe-worktrees:
   phoebe-state:
+  phoebe-engine:

package/templates/phoebe.config.ts

@@ -1,15 +1,39 @@
 // Phoebe consumer config — scaffolded by `phoebe init`.
 //
-// Only these five fields are required. Everything else has a shipped default
-// (see the `PhoebeUserConfig` type). Add overrides here only when you need
-// them; `phoebe-agent` upgrades pick up new defaults automatically.
+// Only the five fields at the top are required. Everything else has a shipped
+// default (see the `PhoebeUserConfig` type); add overrides here only when you
+// need them, and engine upgrades pick up new defaults automatically.
+//
+// This is a *type-only* import on purpose. The container mounts this file at
+// /etc/phoebe and `phoebe boot` imports it before the engine exists, from a
+// directory with no reachable `node_modules` — a value import of `{{CLI_BIN}}`
+// (the `defineConfig` helper) could not resolve there under ESM. A type-only
+// import is erased at runtime, so it type-checks in your editor and costs
+// nothing in the container.
 
-import { defineConfig } from "{{CLI_BIN}}";
+import type { PhoebeUserConfig } from "{{CLI_BIN}}";
 
-export default defineConfig({
+const config: PhoebeUserConfig = {
   repoSlug: "your-org/your-repo",
   repoUrl: "https://github.com/your-org/your-repo.git",
   installCommand: "{{INSTALL_COMMAND}}",
   checkCommand: "npm run check",
   testCommand: "npm test",
-});
+
+  // Which engine `phoebe boot` runs. This is the upgrade knob: edit it and the
+  // running container drains the engine and relaunches on the new code at the
+  // next work-unit boundary — no rebuild, no restart.
+  //
+  //   ref: "main"      follow the tip — every push lands here. Guarded: a
+  //                    commit that will not boot is quarantined after a few
+  //                    fast crashes and `boot` pins back to the last one that
+  //                    ran healthily, until the branch moves past it.
+  //   ref: "v1.2.3"    pin a tag (or a full SHA). Exactly this commit, always.
+  //                    No fallback — pinning means pinning.
+  //
+  // `repo` defaults to the upstream engine repo; set it to run a fork.
+  // For a checkout on your own machine, see container/compose.local.yml.
+  engine: { source: "github", ref: "main" },
+};
+
+export default config;

package/dist/phoebe.config.d.ts

@@ -1,2 +0,0 @@
-import type { PhoebeConfig } from "./src/config-schema.ts";
-export declare const config: PhoebeConfig;

package/dist/phoebe.config.js

@@ -1,43 +0,0 @@
-// All repo-specific configuration for the Phoebe engine lives here — repo slug,
-// labels, branch prefix, toolchain commands, prompts, work order, provider keys.
-// Engine code under src/ never mentions any concrete repository (enforced by
-// src/config-seam.test.ts), so pointing Phoebe at a repo is a matter of editing
-// this one file. These are the engine's shipped defaults; consumers replace the
-// repo/toolchain values with their own.
-export const config = {
-    repoSlug: "your-org/your-repo",
-    repoUrl: "https://github.com/your-org/your-repo.git",
-    defaultBranch: "main",
-    branchPrefix: "phoebe/",
-    readyLabel: "ready-for-agent",
-    prScope: "phoebe",
-    draftPrs: "skip-non-phoebe",
-    prOptOutLabel: "ready-for-human",
-    installCommand: "npm ci",
-    checkCommand: "npm run check",
-    testCommand: "npm test",
-    promptFiles: {
-        issue: "prompts/prompt.md",
-        conflict: "prompts/conflict-prompt.md",
-        checks: "prompts/checks-prompt.md",
-        reviews: "prompts/reviews-prompt.md",
-    },
-    workOrder: ["conflicts", "checks", "reviews", "issues"],
-    defaultProvider: "cursor",
-    defaultModels: {
-        cursor: "composer-2.5",
-        claude: "claude-sonnet-4-6",
-        codex: "gpt-5.4-mini",
-    },
-    providerEnv: {
-        cursor: "CURSOR_API_KEY",
-        claude: "ANTHROPIC_API_KEY",
-        codex: "OPENAI_KEY",
-    },
-    selfUpdatePaths: ["package.json", "package-lock.json"],
-    paths: {
-        repoDir: "/data/repo",
-        worktreesDir: "/data/worktrees",
-        stateDir: "/data/state",
-    },
-};

package/dist/src/agent-env.d.ts

@@ -1,6 +0,0 @@
-import type { PhoebeConfig, ProviderName } from "./config-schema.ts";
-export declare function buildAgentEnv(opts: {
-    parentEnv: Record<string, string | undefined>;
-    provider: ProviderName;
-    providerEnv: PhoebeConfig["providerEnv"];
-}): Record<string, string>;

package/dist/src/agent-env.js

@@ -1,24 +0,0 @@
-// Explicit env allowlist for agent child processes. The agent sees PATH, HOME,
-// git identity, the GitHub token, and the *active* provider's API key — never
-// the other providers' keys, so a prompt-injected agent can't exfiltrate the
-// whole keyring.
-const BASE_ALLOWLIST = [
-    "PATH",
-    "HOME",
-    "GH_TOKEN",
-    "GIT_AUTHOR_NAME",
-    "GIT_AUTHOR_EMAIL",
-    "GIT_COMMITTER_NAME",
-    "GIT_COMMITTER_EMAIL",
-];
-export function buildAgentEnv(opts) {
-    const { parentEnv, provider, providerEnv } = opts;
-    const env = { CI: "true" };
-    for (const key of [...BASE_ALLOWLIST, providerEnv[provider]]) {
-        const value = parentEnv[key];
-        if (value !== undefined && value !== "") {
-            env[key] = value;
-        }
-    }
-    return env;
-}

package/dist/src/cli.d.ts

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-type ParsedArgs = {
-    configPath: string | undefined;
-    help: boolean;
-    forward: string[];
-};
-/**
- * Extract `--config <path>` / `--config=<path>` / `-c <path>` and `--help`/`-h`
- * from argv, forwarding everything else to `runEngine`. A minimal parser is
- * enough — the engine handles its own boolean flags (`--run-once`, `--dry-run`)
- * from the forwarded array.
- */
-export declare function parseCliArgs(argv: readonly string[]): ParsedArgs;
-export type ParsedInitArgs = {
-    targetDir: string;
-    help: boolean;
-};
-/**
- * Parse argv left after the leading `init` token has been consumed. Supports
- * an optional positional target directory (`phoebe init ./my-agent`) and
- * `--help`. Extra flags are rejected loudly so a typo like `--forcee` fails
- * fast instead of being silently ignored.
- */
-export declare function parseInitArgs(argv: readonly string[]): ParsedInitArgs;
-export {};

package/dist/src/cli.js

@@ -1,161 +0,0 @@
-#!/usr/bin/env node
-// `phoebe` bin — the packaged CLI consumers invoke via
-// `npx phoebe-agent [flags]` (or a pinned `phoebe` script). Recognises two
-// modes:
-//
-//   phoebe init [dir]   Scaffold a consumer-owned runtime (config, prompts,
-//                       .env.example, container templates, gitignore).
-//                       Skips existing files — safe to re-run.
-//   phoebe [flags]      Run the engine. Loads the consumer's
-//                       `phoebe.config.ts`, overlays `PHOEBE_*` env vars,
-//                       installs the resolved config, then hands off to main.
-//
-// This is the only supported v1 programmatic surface: there is no exported
-// `run(config)` — CLI-only. That keeps every consumer on the same load/resolve/
-// install pipeline and leaves the door open to CLI-only concerns (init/pin
-// scaffolding, log formatting) without breaking a library API.
-import { realpathSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-import { resolveConfig } from "./config-schema.js";
-import { formatInitReport, runInit } from "./init.js";
-import { applyEnvOverlay, loadUserConfig, resolveConfigPath } from "./load-config.js";
-import { setResolvedConfig } from "./resolved-config.js";
-/**
- * Extract `--config <path>` / `--config=<path>` / `-c <path>` and `--help`/`-h`
- * from argv, forwarding everything else to `runEngine`. A minimal parser is
- * enough — the engine handles its own boolean flags (`--run-once`, `--dry-run`)
- * from the forwarded array.
- */
-export function parseCliArgs(argv) {
-    const forward = [];
-    let configPath;
-    let help = false;
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        if (arg === "--help" || arg === "-h") {
-            help = true;
-            continue;
-        }
-        if (arg === "--config" || arg === "-c") {
-            const next = argv[i + 1];
-            if (next === undefined) {
-                throw new Error(`${arg} requires a path argument (e.g. --config phoebe.config.ts).`);
-            }
-            configPath = next;
-            i += 1;
-            continue;
-        }
-        if (arg !== undefined && arg.startsWith("--config=")) {
-            configPath = arg.slice("--config=".length);
-            continue;
-        }
-        if (arg !== undefined) {
-            forward.push(arg);
-        }
-    }
-    return { configPath, help, forward };
-}
-/**
- * Parse argv left after the leading `init` token has been consumed. Supports
- * an optional positional target directory (`phoebe init ./my-agent`) and
- * `--help`. Extra flags are rejected loudly so a typo like `--forcee` fails
- * fast instead of being silently ignored.
- */
-export function parseInitArgs(argv) {
-    let targetDir;
-    let help = false;
-    for (const arg of argv) {
-        if (arg === "--help" || arg === "-h") {
-            help = true;
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            throw new Error(`Unknown flag \`${arg}\` for \`phoebe init\`. See \`phoebe init --help\`.`);
-        }
-        if (targetDir !== undefined) {
-            throw new Error(`\`phoebe init\` takes at most one target directory (got \`${targetDir}\` and \`${arg}\`).`);
-        }
-        targetDir = arg;
-    }
-    return { targetDir: targetDir ?? ".", help };
-}
-const HELP_TEXT = `phoebe — AFK coding agent
-
-Usage:
-  phoebe init [dir]                Scaffold a consumer-owned runtime
-  phoebe [--config <path>] [flags] Run the engine
-
-Options (engine mode):
-  --config, -c <path>   Path to phoebe.config.ts (default: ./phoebe.config.ts)
-  --run-once            Work one unit of the first one-shot-eligible kind, then exit
-  --dry-run             Print the selected unit without executing it
-  --help, -h            Show this message
-
-Environment overlays (each replaces the corresponding config field):
-  PHOEBE_REPO_SLUG, PHOEBE_REPO_URL, PHOEBE_DEFAULT_BRANCH, PHOEBE_BRANCH_PREFIX,
-  PHOEBE_READY_LABEL, PHOEBE_PROCESSING_LABEL, PHOEBE_PR_OPT_OUT_LABEL,
-  PHOEBE_INSTALL_COMMAND, PHOEBE_CHECK_COMMAND, PHOEBE_TEST_COMMAND,
-  PHOEBE_READY_COMMAND, PHOEBE_BLOCKED_BY_PATTERN, PHOEBE_REVIEWS_SUCCESS_HEADING,
-  PHOEBE_PR_SCOPE, PHOEBE_DRAFT_PRS, PHOEBE_DEFAULT_PROVIDER
-
-Runtime toggles (read directly by the engine, not overlaid onto the config):
-  PHOEBE_AGENT           Provider name to use for this run (cursor|claude|codex)
-  PHOEBE_MODEL           Model to use for this run
-  PHOEBE_POLL_INTERVAL_MS Persistent-mode poll interval (default 300000)
-  PHOEBE_DEFAULT_BRANCH  Branch the supervisor keeps the clone on (overrides tracked branch only)
-`;
-const INIT_HELP_TEXT = `phoebe init — scaffold a consumer-owned runtime
-
-Usage:
-  phoebe init [dir]
-
-Writes into [dir] (default: current directory):
-  phoebe.config.ts             Consumer config starter (edit the five required fields)
-  prompts/                     Copies of the shipped agent prompts (edit to override)
-  .env.example                 Documented environment variables to copy to .env
-  .gitignore                   Additive — appends Phoebe entries only
-  container/Dockerfile         Runtime image (Node + git + gh + pinned phoebe-agent)
-  container/compose.yml        Base one-shot compose config
-  container/compose.daemon.yml Overlay to run Phoebe as a persistent daemon
-  container/supervisor.sh      Warm-install + engine-restart loop (chmod +x)
-
-Existing files are left untouched, so re-running is safe. To regenerate a
-scaffolded file, delete it first and re-run \`phoebe init\`.
-`;
-async function main() {
-    const args = process.argv.slice(2);
-    if (args[0] === "init") {
-        const parsed = parseInitArgs(args.slice(1));
-        if (parsed.help) {
-            process.stdout.write(INIT_HELP_TEXT);
-            return;
-        }
-        const report = runInit({ targetDir: parsed.targetDir });
-        process.stdout.write(formatInitReport(report, parsed.targetDir));
-        return;
-    }
-    const parsed = parseCliArgs(args);
-    if (parsed.help) {
-        process.stdout.write(HELP_TEXT);
-        return;
-    }
-    const configPath = resolveConfigPath(parsed.configPath, process.cwd());
-    const userConfig = await loadUserConfig(configPath);
-    const overlaid = applyEnvOverlay(userConfig, process.env);
-    setResolvedConfig(resolveConfig(overlaid));
-    // Import after the config is installed — main.ts's module-level constants
-    // read `config` at import time via the Proxy in resolved-config.ts.
-    const { runEngine } = await import("./main.js");
-    await runEngine(parsed.forward);
-}
-// Only run when invoked as the entry point — tests import `parseCliArgs` from
-// this module without triggering the whole CLI pipeline. `argv[1]` is realpath'd
-// so a bin symlink (`node_modules/.bin/phoebe -> ../phoebe-agent/dist/src/cli.js`)
-// still matches `import.meta.url`, which Node resolves through symlinks.
-if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
-    main().catch((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`[phoebe] ${message}`);
-        process.exit(1);
-    });
-}

package/dist/src/config-schema.d.ts

@@ -1,163 +0,0 @@
-export declare const PROVIDER_NAMES: readonly ["cursor", "claude", "codex"];
-export type ProviderName = (typeof PROVIDER_NAMES)[number];
-export type PromptFilesConfig = {
-    issue: string;
-    conflict: string;
-    checks: string;
-    reviews: string;
-};
-export type PathsConfig = {
-    /** The private clone (origin hub). */
-    repoDir: string;
-    /** Per-unit git worktrees. */
-    worktreesDir: string;
-    /** Lock, markers, logs. */
-    stateDir: string;
-};
-export type PhoebeConfig = {
-    /** GitHub `owner/repo` slug, passed to every `gh -R` call. */
-    repoSlug: string;
-    /** HTTPS clone URL for the container's private clone. */
-    repoUrl: string;
-    /** Branch PRs target and worktrees base off (usually `main`). */
-    defaultBranch: string;
-    /** Prefix for agent branches; issue branches are `<prefix>issue-<n>`. */
-    branchPrefix: string;
-    /** Label marking issues Phoebe may pick up. */
-    readyLabel: string;
-    /** Label the agent applies to an issue it has claimed and is working. */
-    processingLabel: string;
-    /** Which open PRs the conflicts/checks/reviews work-kinds scan.
-     *  "phoebe" = only branchPrefix branches. "all" = any same-repo PR. */
-    prScope: "phoebe" | "all";
-    /** Draft PR handling: "skip-non-phoebe" = drafts on non-Phoebe branches are
-     *  off-limits; "skip-all" = never touch drafts; "include" = drafts are fair game. */
-    draftPrs: "skip-non-phoebe" | "skip-all" | "include";
-    /** PRs carrying this label are excluded from the PR scan in every mode. */
-    prOptOutLabel: string;
-    /** Shell command strings — toolchains differ per repo, so these are data. */
-    installCommand: string;
-    checkCommand: string;
-    testCommand: string;
-    /** The all-in-one gate the agent runs before pushing (e.g. `npm run ready`).
-     *  Substituted into default prompts as `{{READY_COMMAND}}`. */
-    readyCommand: string;
-    /**
-     * JavaScript-compatible regex source that matches an issue-blocker reference
-     * in issue body text. Must expose the blocker issue number as capture group 1.
-     * Compiled with the `gi` flags.
-     */
-    blockedByPattern: string;
-    /**
-     * Markdown heading the reviews agent must include when it posts its summary
-     * comment. The orchestrator detects the summary by substring match on this
-     * exact string, so it must be unique enough not to collide with other
-     * comments. Substituted into the default reviews prompt as
-     * `{{REVIEWS_SUCCESS_HEADING}}`.
-     */
-    reviewsSuccessHeading: string;
-    /** Prompt template paths, relative to the package root (apps/phoebe). */
-    promptFiles: PromptFilesConfig;
-    /** Ordered work kinds, validated by the orchestrator at startup. */
-    workOrder: readonly string[];
-    defaultProvider: ProviderName;
-    defaultModels: Record<ProviderName, string>;
-    /** Env var holding each provider's API key — the only key the agent child inherits. */
-    providerEnv: Record<ProviderName, string>;
-    /**
-     * Repo paths that mean "Phoebe's own code changed" — a fetch of the default
-     * branch touching these makes the orchestrator exit for a supervisor
-     * reinstall + re-exec. Directory entries must end with `/`.
-     */
-    selfUpdatePaths: readonly string[];
-    /** Container filesystem layout (named volumes). */
-    paths: PathsConfig;
-};
-/**
- * User-facing shape of `phoebe.config.ts`. Only the five fields with no sane
- * cross-repo default are required; everything else is optional and filled from
- * `CONFIG_DEFAULTS` by `resolveConfig()`. Nested objects (`promptFiles`,
- * `paths`, `defaultModels`, `providerEnv`) are merged key-by-key, so overriding
- * one provider's model or one prompt file does not force the caller to supply
- * the rest.
- */
-export type PhoebeUserConfig = {
-    repoSlug: string;
-    repoUrl: string;
-    installCommand: string;
-    checkCommand: string;
-    testCommand: string;
-    defaultBranch?: string;
-    branchPrefix?: string;
-    readyLabel?: string;
-    processingLabel?: string;
-    prScope?: PhoebeConfig["prScope"];
-    draftPrs?: PhoebeConfig["draftPrs"];
-    prOptOutLabel?: string;
-    readyCommand?: string;
-    blockedByPattern?: string;
-    reviewsSuccessHeading?: string;
-    promptFiles?: Partial<PromptFilesConfig>;
-    workOrder?: readonly string[];
-    defaultProvider?: ProviderName;
-    defaultModels?: Partial<Record<ProviderName, string>>;
-    providerEnv?: Partial<Record<ProviderName, string>>;
-    selfUpdatePaths?: readonly string[];
-    paths?: Partial<PathsConfig>;
-};
-/**
- * Engine defaults for every optional user field. These land in the resolved
- * config whenever the consumer's `phoebe.config.ts` omits them, so a minimal
- * consumer config only has to name the repo and its three toolchain commands.
- */
-export declare const CONFIG_DEFAULTS: {
-    readonly defaultBranch: "main";
-    readonly branchPrefix: "phoebe/";
-    readonly readyLabel: "ready-for-agent";
-    readonly processingLabel: "processing";
-    readonly prScope: "phoebe";
-    readonly draftPrs: "skip-non-phoebe";
-    readonly prOptOutLabel: "ready-for-human";
-    readonly readyCommand: "npm run ready";
-    readonly blockedByPattern: string;
-    readonly reviewsSuccessHeading: "## Review feedback addressed";
-    readonly promptFiles: {
-        issue: string;
-        conflict: string;
-        checks: string;
-        reviews: string;
-    };
-    readonly workOrder: readonly string[];
-    readonly defaultProvider: ProviderName;
-    readonly defaultModels: {
-        cursor: string;
-        claude: string;
-        codex: string;
-    };
-    readonly providerEnv: {
-        cursor: string;
-        claude: string;
-        codex: string;
-    };
-    readonly selfUpdatePaths: readonly string[];
-    readonly paths: {
-        repoDir: string;
-        worktreesDir: string;
-        stateDir: string;
-    };
-};
-/**
- * Throw when a required field is missing or blank, or when `blockedByPattern`
- * is not a valid regex or fails to expose the blocker issue number as capture
- * group 1. `parseBlockedBy` reads `match[1]`, so a pattern without a capture
- * group would silently break the entire blocker-detection path — reject it up
- * front. Kept separate from `resolveConfig` so consumers or tests can validate
- * a config independent of the defaults merge.
- */
-export declare function validateUserConfig(user: PhoebeUserConfig): void;
-/**
- * Merge a user config with `CONFIG_DEFAULTS` and return the fully-populated
- * shape the engine runs against. Nested records are shallow-merged so partial
- * overrides (one prompt file, one provider's env var, etc.) work as expected.
- */
-export declare function resolveConfig(user: PhoebeUserConfig): PhoebeConfig;