@repo-os/repoos 0.5.49 → 0.5.50

package/dist/.build-info.json

@@ -1,4 +1,4 @@
 {
-  "hash": "f5bc7080896e6462e45fb88aeecb10c9c2f675395207b58c11bc29b2b5524aa7",
-  "version": "0.5.49"
+  "hash": "f24758813ae7cee389c4a5256fd833c00e64a310a08a11ed6807f1e47cd49919",
+  "version": "0.5.50"
 }

package/dist/.build-stamp.json

@@ -1,3 +1,3 @@
 {
-  "generatedAt": "2026-09-20T04:12:23.987Z"
+  "generatedAt": "2026-09-20T14:57:13.641Z"
 }

package/dist/cli/index.js

@@ -101,7 +101,7 @@ function help() {
         cmdRow('new-doc "<desc>"', "Create a document from a description via PM agent"),
         cmdRow("index [--json]", "Rebuild the derived index cache"),
         cmdRow("gc [--yes|--dry-run]", "Collect leaked task worktrees/branches (done/absent tasks, integrate candidates)"),
-        cmdRow("serve [--port N]", "Start the local server (live API + SSE stream)"),
+        cmdRow("serve [--port N]", `Start the local server (live API + SSE stream)   ${c.dim("flags: --host, --preview-overrides, --no-preview-overrides")}`),
         cmdRow("stop [--port N]", "Stop this repo's serve process (by its own lockfile)"),
         cmdRow("service [sub]", `Manage background services ${c.dim("list|status|install|start|stop|restart|enable|disable|remove")}`),
         cmdRow("tunnel <sub>", `Publish local apps via Cloudflare Tunnel + Zero Trust ${c.dim("(setup|create|allow|deny|rename|destroy|start|install|stop|list|status)")}`),

package/dist/commands/serve.d.ts

@@ -40,6 +40,17 @@ export declare function resolveServeHost(explicitHost?: string): {
     tailscaleDetected: boolean;
     tailscaleIP?: string;
 };
+/**
+ * Whether this `repoos serve` should apply the repo's preview-only
+ * `[preview.*]` config overlay (#0464).
+ *
+ * Precedence, lowest to highest: the REPOOS_PREVIEW_CHILD=1 marker (set by
+ * PreviewManager on every managed preview child) turns it on; an explicit
+ * `--no-preview-overrides`/`--preview-overrides` flag always wins. An ordinary
+ * `repoos serve` has neither, so it resolves the base configuration unchanged.
+ * Exported for tests.
+ */
+export declare function resolvePreviewOverrides(args: readonly string[], env?: NodeJS.ProcessEnv): boolean;
 /**
  * True when this process is a managed agent (REPOOS_AGENT=1) attempting to
  * launch `repoos serve` directly, as opposed to a preview child or a reload

package/dist/commands/serve.js

@@ -79,6 +79,26 @@ export function resolveServeHost(explicitHost) {
         return { host: "0.0.0.0", tailscaleDetected: true, tailscaleIP };
     return { host: "127.0.0.1", tailscaleDetected: false };
 }
+/**
+ * Whether this `repoos serve` should apply the repo's preview-only
+ * `[preview.*]` config overlay (#0464).
+ *
+ * Precedence, lowest to highest: the REPOOS_PREVIEW_CHILD=1 marker (set by
+ * PreviewManager on every managed preview child) turns it on; an explicit
+ * `--no-preview-overrides`/`--preview-overrides` flag always wins. An ordinary
+ * `repoos serve` has neither, so it resolves the base configuration unchanged.
+ * Exported for tests.
+ */
+export function resolvePreviewOverrides(args, env = process.env) {
+    let explicit;
+    for (const arg of args) {
+        if (arg === "--preview-overrides")
+            explicit = true;
+        else if (arg === "--no-preview-overrides")
+            explicit = false;
+    }
+    return explicit ?? env.REPOOS_PREVIEW_CHILD === "1";
+}
 /**
  * True when this process is a managed agent (REPOOS_AGENT=1) attempting to
  * launch `repoos serve` directly, as opposed to a preview child or a reload
@@ -116,6 +136,12 @@ export async function cmdServe(args, opts = {}) {
         else if (args[i] === "--quiet" || args[i] === "-q")
             quiet = true;
     }
+    // Preview-only config overlay (#0464). A managed preview child
+    // (REPOOS_PREVIEW_CHILD=1, set by PreviewManager) applies the repo's
+    // `[preview.*]` overlay by default; every ordinary `repoos serve` resolves
+    // the base configuration. `--preview-overrides` forces it on (UI-test
+    // previews); `--no-preview-overrides` is the escape hatch back to base.
+    const applyPreviewOverrides = resolvePreviewOverrides(args);
     const { host, tailscaleDetected, tailscaleIP } = resolveServeHost(explicitHost);
     let handle;
     try {
@@ -124,6 +150,8 @@ export async function cmdServe(args, opts = {}) {
         handle = await startServer({
             port,
             host,
+            hostExplicit: explicitHost !== undefined,
+            previewOverrides: applyPreviewOverrides,
             reloadReplacement: process.env.REPOOS_RELOAD === "1",
         });
     }
@@ -149,6 +177,11 @@ export async function cmdServe(args, opts = {}) {
         snap.taskCount +
         c.dim(" tasks  ·  SSE stream at ") +
         c.cyan(handle.url + "/api/events"));
+    // Report an active preview-only overlay and its effective keys (#0464), so a
+    // preview that deliberately differs from the base config is never silent.
+    if (handle.previewOverrides?.length) {
+        console.log(c.yellow("  preview overrides active: ") + c.dim(handle.previewOverrides.join(", ")));
+    }
     const rt = isBun()
         ? `Bun ${process.versions.bun ?? ""}`.trim()
         : `Node ${process.versions.node}`;

package/dist/commands/ui-harness.js

@@ -18,7 +18,17 @@ export async function startPreviewServer(root) {
     // disableAuth: the smoke gate tests generic rendering (title, board,
     // buttons), not auth flows — a project with [auth] enabled must not make
     // `repoos check` itself unable to reach the dashboard.
-    const opts = { host: "127.0.0.1", port: 0, disableAuth: true };
+    //
+    // previewOverrides: this is the UI-test preview path, so it resolves the same
+    // preview-only `[preview.*]` overlay a managed preview applies (#0464). The
+    // smoke test's throwaway fixture declares no overlay, so this is normally a
+    // no-op; it matters when the harness serves a real root.
+    const opts = {
+        host: "127.0.0.1",
+        port: 0,
+        disableAuth: true,
+        previewOverrides: true,
+    };
     if (root !== undefined)
         opts.root = root;
     return startServer(opts);

package/dist/core/config.d.ts

@@ -160,7 +160,38 @@ export declare function parseDistributionConfig(parsed: Record<string, unknown>)
  * Rows without a usable `command` are dropped rather than poisoning resolution.
  */
 export declare function parsePreviewConfig(parsed: Record<string, unknown>): PreviewConfig | undefined;
-export declare function loadConfig(rootArg?: string): RepoOSConfig;
+export interface PreviewOverlay {
+    /** Overridden base config paths (dotted, e.g. `"auth.enabled"`) -> value. */
+    entries: Record<string, unknown>;
+    /** The overridden paths, sorted, for reporting. */
+    keys: string[];
+}
+/**
+ * Extract the preview-only overrides from a flat-TOML parse (#0464). A key is
+ * an overlay when it sits under `preview.` but is not one of the preview
+ * feature's own keys; the path after `preview.` is the base config key it
+ * overrides. Because `parseFlatToml` already flattens nested tables, merging is
+ * deep by construction: `[preview.auth] enabled = false` contributes only
+ * `auth.enabled`, leaving every other `[auth]` key at its base value.
+ */
+export declare function parsePreviewOverlays(parsed: Record<string, unknown>): PreviewOverlay;
+/**
+ * The preview-only override keys a repo's `repoos.toml` declares that the
+ * runtime will actually apply (supported base keys only), sorted. Fail-soft: a
+ * missing/unreadable file yields `[]`. Used by the preview manager to report
+ * the effective overrides a preview boot is applying (#0464) — the child itself
+ * warns about and drops the same unknown paths.
+ */
+export declare function readPreviewOverlayKeys(root: string): string[];
+export interface LoadConfigOptions {
+    /**
+     * Apply the repo's `[preview.*]` configuration overlay (#0464). Only the
+     * preview/UI-test preview runtime sets this; every normal command leaves it
+     * unset and resolves the base configuration unchanged.
+     */
+    previewOverrides?: boolean;
+}
+export declare function loadConfig(rootArg?: string, options?: LoadConfigOptions): RepoOSConfig;
 /** Metadata describing a single config field for the Settings UI. */
 export interface ConfigFieldMeta {
     key: string;

package/dist/core/config.js

@@ -655,7 +655,65 @@ function normalizeReadyTimeoutMs(value) {
         return undefined;
     return value;
 }
-export function loadConfig(rootArg) {
+/**
+ * The `[preview]` keys that configure *how a preview boots* — the preview
+ * feature's own settings. Any other `[preview.<path>]` table is a preview-only
+ * override of the base configuration (#0464), not a preview setting.
+ */
+const PREVIEW_FEATURE_KEYS = new Set(["command", "cwd", "readyPath", "readyTimeoutMs", "targets"]);
+/**
+ * Extract the preview-only overrides from a flat-TOML parse (#0464). A key is
+ * an overlay when it sits under `preview.` but is not one of the preview
+ * feature's own keys; the path after `preview.` is the base config key it
+ * overrides. Because `parseFlatToml` already flattens nested tables, merging is
+ * deep by construction: `[preview.auth] enabled = false` contributes only
+ * `auth.enabled`, leaving every other `[auth]` key at its base value.
+ */
+export function parsePreviewOverlays(parsed) {
+    const entries = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        if (!key.startsWith("preview."))
+            continue;
+        const path = key.slice("preview.".length);
+        const head = path.split(".")[0];
+        if (PREVIEW_FEATURE_KEYS.has(head))
+            continue;
+        if (typeof value === "object" && value !== null)
+            continue; // no table arrays
+        entries[path] = value;
+    }
+    const keys = Object.keys(entries).sort();
+    return { entries, keys };
+}
+/**
+ * True when `path` names a base configuration key RepoOS actually reads, so an
+ * overlay targeting it is meaningful. `SUPPORTED_TOML_KEYS` (the same contract
+ * the docs-drift test and `repoos doctor` use) lists the dotted leaves, so a
+ * nested override like `auth.emailProvider.type` resolves while a typo or a
+ * section name is dropped with a warning.
+ */
+function isOverridableConfigPath(path) {
+    return SUPPORTED_TOML_KEYS.includes(path);
+}
+/**
+ * The preview-only override keys a repo's `repoos.toml` declares that the
+ * runtime will actually apply (supported base keys only), sorted. Fail-soft: a
+ * missing/unreadable file yields `[]`. Used by the preview manager to report
+ * the effective overrides a preview boot is applying (#0464) — the child itself
+ * warns about and drops the same unknown paths.
+ */
+export function readPreviewOverlayKeys(root) {
+    const tomlPath = join(root, "repoos.toml");
+    if (!existsSync(tomlPath))
+        return [];
+    try {
+        return parsePreviewOverlays(parseFlatToml(readFileSync(tomlPath, "utf8"))).keys.filter(isOverridableConfigPath);
+    }
+    catch {
+        return [];
+    }
+}
+export function loadConfig(rootArg, options = {}) {
     const root = rootArg ? resolve(rootArg) : findRepoRoot();
     // Load .env before resolving [auth]/[whisper] secrets below, so every path
     // that boots a real server (repoos serve, previews, the UI smoke test)
@@ -666,6 +724,27 @@ export function loadConfig(rootArg) {
     const tomlPath = join(root, "repoos.toml");
     if (existsSync(tomlPath)) {
         const parsed = parseFlatToml(readFileSync(tomlPath, "utf8"));
+        // Preview-only overlay (#0464): re-apply the `[preview.*]` keys over the
+        // base parse before the normal field reads below, so precedence is
+        // defaults → base repoos.toml → preview overlay → explicit CLI flags. Only
+        // the preview/UI-test runtime opts in; every other caller sees the base
+        // config. An overlay path RepoOS does not read is dropped with a warning
+        // rather than silently accepted as a typo.
+        const appliedOverrides = [];
+        if (options.previewOverrides) {
+            const overlay = parsePreviewOverlays(parsed);
+            for (const [path, value] of Object.entries(overlay.entries)) {
+                if (!isOverridableConfigPath(path)) {
+                    console.warn(`[preview] ignoring unknown preview override "${path}"`);
+                    continue;
+                }
+                parsed[path] = value;
+                appliedOverrides.push(path);
+            }
+            appliedOverrides.sort();
+            if (appliedOverrides.length)
+                cfg.previewOverrides = appliedOverrides;
+        }
         const get = (k) => parsed[k] ?? parsed[`repoos.${k}`];
         if (typeof get("workDir") === "string")
             cfg.workDir = get("workDir");
@@ -1395,6 +1474,10 @@ export const SUPPORTED_TOML_KEYS = [
     "preview.targets.cwd",
     "preview.targets.readyPath",
     "preview.targets.readyTimeoutMs",
+    // Preview-only overrides (#0464): a `[preview.<base path>]` table applied
+    // only by the preview/UI-test preview runtime. auth.enabled is the headline
+    // case; any supported base key can be overridden the same way.
+    "preview.auth.enabled",
     // Checks
     "check.uiSmoke",
     "check.uiStylesheet",

package/dist/core/repoos.d.ts

@@ -1,3 +1,4 @@
+import { type LoadConfigOptions } from "./config.js";
 import { ORIGINAL_PROMPT_HEADING } from "./task.js";
 import { type CommitNewFileResult } from "./git.js";
 import { type RepoOSConfig, type RepoIndex, type Task, type Status } from "./types.js";
@@ -19,6 +20,17 @@ export interface CreateTaskInput {
      * capture is never lost, even if a later agent pass rewrites the body.
      */
     originalPrompt?: string;
+    /**
+     * Per-task PM agent assignment persisted at creation (#0461). The freeform
+     * pane's picker chooses the PM agent/model for the one-off flesh-out run;
+     * these carry that same selection into the task's frontmatter so later PM
+     * actions (reply-from-context, re-flesh-out, restart) keep it. Only values
+     * that differ from the configured PM default are set — `null` means "use the
+     * configured default", matching the PM tab's own save logic.
+     */
+    pmAgentOverride?: string | null;
+    pmCliOverride?: string | null;
+    pmModelOverride?: string | null;
 }
 export { ORIGINAL_PROMPT_HEADING };
 /**
@@ -56,6 +68,6 @@ export interface RepoOS {
     /** Surgically commit a single new file (fail-soft; never touches other files). */
     commitNewFile(absPath: string, message: string): CommitNewFileResult;
 }
-export declare function createRepoOS(root?: string): RepoOS;
+export declare function createRepoOS(root?: string, loadOptions?: LoadConfigOptions): RepoOS;
 export * from "./types.js";
 export { loadConfig, findRepoRoot } from "./config.js";

package/dist/core/repoos.js

@@ -45,8 +45,8 @@ _What should the end experience be?_
 
 _Constraints, files to touch, things NOT to do._
 `;
-export function createRepoOS(root) {
-    const config = loadConfig(root);
+export function createRepoOS(root, loadOptions = {}) {
+    const config = loadConfig(root, loadOptions);
     function freshIndex() {
         return buildIndex(config);
     }
@@ -188,9 +188,9 @@ export function createRepoOS(root) {
                 agentOverride: null,
                 cliOverride: null,
                 modelOverride: null,
-                pmAgentOverride: null,
-                pmCliOverride: null,
-                pmModelOverride: null,
+                pmAgentOverride: input.pmAgentOverride ?? null,
+                pmCliOverride: input.pmCliOverride ?? null,
+                pmModelOverride: input.pmModelOverride ?? null,
                 reviewAgentOverride: null,
                 reviewCliOverride: null,
                 reviewModelOverride: null,

package/dist/core/types.d.ts

@@ -407,6 +407,14 @@ export interface RepoOSConfig {
      * result rather than booting RepoOS's own board.
      */
     preview?: PreviewConfig;
+    /**
+     * Preview-only config overrides that were applied (task #0464), as sorted
+     * dotted base key paths (e.g. `["auth.enabled"]`). Set only when config was
+     * resolved with the preview overlay turned on — the preview/UI-test preview
+     * runtime does this; every normal command resolves the base config and leaves
+     * this undefined. Runtime information, not a `repoos.toml` field of its own.
+     */
+    previewOverrides?: string[];
     /**
      * Per-project task-worktree behavior (#0373). Omitted means defaults — in
      * particular, no `.env` is placed in any worktree.

package/dist/server/integration-orchestrator.d.ts

@@ -104,6 +104,17 @@ export declare function resetForeignWorkFiles(opts: {
  * already rejects an empty merge that actually swallowed real branch work.
  */
 export declare function isDocsOnlyChange(paths: string[], docsDir?: string): boolean;
+/**
+ * Does a merged candidate declare a dependency tree that may differ from the
+ * one already installed in main?
+ *
+ * Candidates normally symlink main's node_modules for a warm, cheap gate. A
+ * feature that adds or changes a package cannot safely use that tree: it may
+ * compile in its own worktree but fail after the merge because main has not
+ * installed the new dependency yet (#0449). Treat package manifests and every
+ * conventional JavaScript lockfile as an exact, conservative boundary.
+ */
+export declare function hasDependencyInputChange(paths: readonly string[]): boolean;
 /**
  * The useful part of a failed command's combined output. bun/npm wrap a child
  * failure with a generic trailing line (`error: script "repoos" exited with

package/dist/server/integration-orchestrator.js

@@ -7,7 +7,7 @@
  *
  * Phases track recovery: if interrupted mid-flight, retry resumes from the current phase.
  */
-import { readFileSync, existsSync, symlinkSync, readdirSync, mkdirSync, writeFileSync, } from "node:fs";
+import { readFileSync, existsSync, lstatSync, symlinkSync, unlinkSync, readdirSync, mkdirSync, writeFileSync, } from "node:fs";
 import { join, relative } from "node:path";
 import { spawn } from "node:child_process";
 import { currentBranch, runGit, worktreePathForBranch, ensureWorktree, removeWorktree, deleteBranch, pruneWorktrees, isGitRepo, commitDirtyFiles, mergeBranch, dirtyFiles, getDiff, getDiffStats, getChangedFilePaths, GitDirtyCheckError, } from "../core/git.js";
@@ -207,6 +207,26 @@ export function isDocsOnlyChange(paths, docsDir = "docs") {
     const docsPrefix = `${docsDir.replace(/\/+$/, "")}/`;
     return paths.every((p) => p.startsWith(docsPrefix) || p.endsWith(".md"));
 }
+/**
+ * Does a merged candidate declare a dependency tree that may differ from the
+ * one already installed in main?
+ *
+ * Candidates normally symlink main's node_modules for a warm, cheap gate. A
+ * feature that adds or changes a package cannot safely use that tree: it may
+ * compile in its own worktree but fail after the merge because main has not
+ * installed the new dependency yet (#0449). Treat package manifests and every
+ * conventional JavaScript lockfile as an exact, conservative boundary.
+ */
+export function hasDependencyInputChange(paths) {
+    return paths.some((path) => {
+        const filename = path.slice(path.lastIndexOf("/") + 1);
+        return (filename === "package.json" ||
+            filename === "bun.lock" ||
+            filename === "package-lock.json" ||
+            filename === "pnpm-lock.yaml" ||
+            filename === "yarn.lock");
+    });
+}
 /**
  * Resolve the repository's actual default branch name.
  * Tries (in order):
@@ -373,6 +393,54 @@ function runProcess(cmd, args, opts) {
 function commandMissing(res) {
     return res.errorCode === "ENOENT" || res.errorCode === "EACCES";
 }
+/**
+ * Turn a candidate's shared node_modules link into a private, lockfile-exact
+ * install after its merge changed package inputs. Never run this against main:
+ * doing so would mutate the shared install to match code that has not passed
+ * the gate yet.
+ */
+async function prepareCandidateDependencies(candidatePath, isCancelled) {
+    const nodeModules = join(candidatePath, "node_modules");
+    try {
+        // A normal candidate reuses main's tree through this link. Removing only
+        // the link leaves main completely untouched; the frozen install below then
+        // creates a candidate-local tree from the merged lockfile.
+        if (lstatSync(nodeModules).isSymbolicLink())
+            unlinkSync(nodeModules);
+    }
+    catch {
+        /* Missing or unreadable node_modules is fine: the install recreates it. */
+    }
+    const commands = existsSync(join(candidatePath, "bun.lock"))
+        ? [{ command: "bun", args: ["install", "--frozen-lockfile"] }]
+        : existsSync(join(candidatePath, "pnpm-lock.yaml"))
+            ? [{ command: "pnpm", args: ["install", "--frozen-lockfile"] }]
+            : existsSync(join(candidatePath, "package-lock.json"))
+                ? [{ command: "npm", args: ["ci"] }]
+                : existsSync(join(candidatePath, "yarn.lock"))
+                    ? [{ command: "yarn", args: ["install", "--frozen-lockfile"] }]
+                    : [];
+    if (commands.length === 0) {
+        return {
+            ok: false,
+            reason: "package inputs changed but no recognized lockfile is available to prepare candidate dependencies",
+        };
+    }
+    const { command, args } = commands[0];
+    const result = await runProcess(command, args, {
+        cwd: candidatePath,
+        timeout: 300_000,
+        isCancelled,
+    });
+    if (result.cancelled)
+        return { ok: false, cancelled: true };
+    if (result.status === 0)
+        return { ok: true };
+    const detail = commandMissing(result)
+        ? `${command} is not available to prepare candidate dependencies`
+        : tailLine(result.stdout, result.stderr);
+    return { ok: false, reason: `dependency install failed: ${detail}` };
+}
 /** Candidate validation and publication orchestrator for one job. */
 export class CloseOutOrchestrator {
     config;
@@ -1030,6 +1098,24 @@ export class CloseOutOrchestrator {
             this.logger?.integration(job.taskId, "info", "docs-only candidate — skipping the full build + check gate (no code/source paths changed)", { paths: changedPaths });
         }
         else {
+            // The candidate normally points at main's node_modules to avoid a cold
+            // install. That tree cannot satisfy a dependency added by this branch,
+            // however, because main has not merged its package.json/lockfile yet.
+            // Give only dependency-changing candidates their own frozen install.
+            if (changedPaths !== null && hasDependencyInputChange(changedPaths)) {
+                this.onProgress?.("build");
+                const dependencies = await prepareCandidateDependencies(wtPath, () => this.isCancelled(job.taskId));
+                if (dependencies.cancelled) {
+                    return { ok: false, cancelled: true, reason: CANCEL_REASON };
+                }
+                if (!dependencies.ok) {
+                    return {
+                        ok: false,
+                        retryable: !dependencies.reason?.startsWith("package inputs changed"),
+                        reason: dependencies.reason ?? "could not prepare candidate dependencies",
+                    };
+                }
+            }
             // Run the post-merge gate: build + check via bun/npm.
             this.onProgress?.("build");
             let buildRes = await runProcess("bun", ["run", "build"], {

package/dist/server/preview.d.ts

@@ -29,6 +29,13 @@ export interface PreviewInfo {
      * shell's whole tree down with it.
      */
     processGroup?: boolean;
+    /**
+     * Preview-only config override keys (#0464) the worktree's `repoos.toml`
+     * declares, as sorted dotted base-key paths (e.g. `["auth.enabled"]`). The
+     * child applies them because PreviewManager spawns it with
+     * REPOOS_PREVIEW_CHILD=1; empty/absent means the preview runs the base config.
+     */
+    overrides?: string[];
 }
 export interface PreviewResult {
     ok: boolean;
@@ -38,6 +45,8 @@ export interface PreviewResult {
     readyPath?: string;
     /** Which preview target ran (#0362 review) — see `PreviewInfo.label`. */
     label?: string;
+    /** Preview-only config override keys this preview applied (#0464). */
+    overrides?: string[];
     error?: string;
 }
 /** Result of a trusted server-side health/static probe of a preview URL (#0121). */

package/dist/server/preview.js

@@ -20,6 +20,7 @@ import { spawn, execFileSync } from "node:child_process";
 import { createServer as createTcpServer } from "node:net";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { readPreviewOverlayKeys } from "../core/config.js";
 import { linkInheritedEnv, worktreePathForBranch } from "../core/git.js";
 const PREVIEW_STATES = ["active", "review"];
 const HOST = "127.0.0.1";
@@ -380,6 +381,7 @@ export class PreviewManager {
                 url: existing.url,
                 readyPath: existing.readyPath,
                 label: existing.label,
+                ...(existing.overrides?.length ? { overrides: existing.overrides } : {}),
             };
         }
         // Concurrent starts for the same task (e.g. duplicate transition events)
@@ -427,6 +429,12 @@ export class PreviewManager {
         // fail-soft; on a worktree that already has it (or a repo that didn't opt
         // in) this is a no-op.
         linkInheritedEnv(this.config.root, root);
+        // Preview-only config overrides (#0464): the worktree's own `[preview.*]`
+        // keys. The child is spawned with REPOOS_PREVIEW_CHILD=1 below, so a
+        // `repoos serve` preview applies them; reporting them here makes the
+        // deliberate divergence from base config visible even though the child's
+        // console is not attached.
+        const overrides = readPreviewOverlayKeys(root);
         // Decide how to preview this task (#0362): a project-declared command
         // selected by area. A task whose area matches no configured target — or a
         // project with no `[preview]` config at all (#0370) — returns a clear
@@ -472,10 +480,12 @@ export class PreviewManager {
             label: target.label,
             ...(spawned.command ? { command: spawned.command } : {}),
             ...(spawned.processGroup ? { processGroup: true } : {}),
+            ...(overrides.length ? { overrides } : {}),
         };
         this.registry.set(task.id, info);
         this.persist();
-        this.logLifecycle("started", task.id, `target=${info.label} url=${info.url} pid=${info.pid} port=${info.port}`);
+        this.logLifecycle("started", task.id, `target=${info.label} url=${info.url} pid=${info.pid} port=${info.port}` +
+            (overrides.length ? ` overrides=${overrides.join(",")}` : ""));
         this.emit({
             type: "preview",
             id: task.id,
@@ -488,6 +498,7 @@ export class PreviewManager {
             url: info.url,
             readyPath: target.readyPath,
             label: info.label,
+            ...(overrides.length ? { overrides } : {}),
         };
     }
     /** Stop a task's preview. Idempotent: stopping nothing is a no-op success. */

package/dist/server/routes/support.d.ts

@@ -9,3 +9,15 @@ export declare const getSupportBundlePreview: RouteHandler;
  * response only contains the manifest and the local path. Nothing is uploaded.
  */
 export declare const createSupportBundle: RouteHandler;
+/**
+ * Reveal an existing support archive in the machine's file browser. The
+ * browser supplies a path, but the server only ever opens a real archive
+ * directly below this repo's own `.repoos/support/` directory.
+ */
+export declare const revealSupportBundle: RouteHandler;
+/**
+ * Generate an editable bug report or feature request from a user's notes using
+ * the configured PM agent. The report stays entirely local — nothing is uploaded.
+ * Attachments are intentionally excluded from the PM input (0463).
+ */
+export declare const generateBugReport: RouteHandler;