@rebasepro/cli 0.23.0 → 0.24.1-canary.g56af4a4

package/dist/commands/dev.d.ts

@@ -1,3 +1,4 @@
+import { type AppAddress, type RebaseProjectManifest } from "@rebasepro/types";
 import { type PreparedDatabase } from "../dev-db/prepare.js";
 /**
  * The line the watcher prints when it is about to run the entry again.
@@ -29,6 +30,21 @@ import { type PreparedDatabase } from "../dev-db/prepare.js";
  * Exported so `dev-crash-marker.test.ts` can hold the running tsx to it.
  */
 export declare const WATCHER_RESTART_MARKER: RegExp;
+/**
+ * Calls `onLine` with each line a child process writes to `stream`.
+ *
+ * A pipe hands over whatever has been written so far, so one line can arrive
+ * in two chunks. Split chunk by chunk, "Server running at http://localhost:3001"
+ * could read as two fragments that neither matched, and `rebase dev` then
+ * never announced the backend or started the admin panel. So the piece after
+ * the last newline is held for the next chunk, decoded as UTF-8 across chunk
+ * boundaries. A held piece is handed over at the end of the stream, or after
+ * `idleFlushMs` with nothing more written, so a prompt or a progress line
+ * still shows when it is written.
+ *
+ * Exported for its test.
+ */
+export declare function forEachOutputLine(stream: NodeJS.ReadableStream | null | undefined, onLine: (line: string) => void, idleFlushMs?: number): void;
 /**
  * The corrected banner line, when the backend says it moved port.
  *
@@ -65,15 +81,50 @@ export declare function portMovedNotice(line: string): {
  *
  * @param projectRoot   Absolute path the relative entries are resolved against.
  * @param paths         The `REBASE_DEV_*` map from {@link devRuntimeEnv}.
- * @param includeConfig Whether `config/` is watched here. It is only when
- *                      auto-generation is off; with `--generate` a dedicated
- *                      watcher already regenerates the schema and SDK, and tsx
- *                      restarts on the files that produces.
  */
 export declare function devWatchIncludes(projectRoot: string, paths: {
     REBASE_DEV_FUNCTIONS?: string;
     REBASE_DEV_CRONS?: string;
-}, includeConfig: boolean): string[];
+}): string[];
+/**
+ * The file dev writes to restart the backend, or `null` when tsx would not see it.
+ *
+ * Outside the project, so nothing appears in the developer's tree, and keyed by
+ * the project so two `rebase dev`s never restart each other. tsx ignores every
+ * path with a dot-named segment (its built-in `**\/.*\/**`), so a trigger under
+ * `.rebase/` — or under a TMPDIR inside a dot directory — would never fire; in
+ * that case there is no trigger and {@link devWatchArgs} leaves the
+ * collections to tsx, as before.
+ */
+export declare function devRestartTrigger(projectRoot: string): string | null;
+/**
+ * The `tsx watch` argument list for the backend (unquoted).
+ *
+ * One save of a collection file must restart the backend once. The runtime
+ * `import()`s the collections, so tsx tracks them as dependencies and used to
+ * restart the moment a file was saved — before dev had regenerated
+ * `schema.generated.ts`. That boot warned "schema.generated.ts no longer
+ * describes the database … Run `rebase schema generate`", telling the reader to
+ * run what dev was running at that moment, and the regeneration then rewrote
+ * the file and restarted the backend a second time. So tsx is told to leave the
+ * collections directory alone (`--exclude` wins over its dependency tracking),
+ * and dev restarts the backend itself, once, after the regeneration — through
+ * `restartTrigger`, which tsx watches.
+ *
+ * Every included directory also gets tsx's own default ignores, made absolute.
+ * tsx resolves those defaults (`**\/node_modules/**`, `**\/.*`, …) against its
+ * cwd, which is `backend/`, so they never reached `config/`, a sibling: chokidar
+ * walked `config/node_modules` — following symlinks — before tsx spawned the
+ * backend at all, and kept every file in it watched. In the monorepo's example
+ * app that was 17 s before the first backend line and 1,400 open files, and any
+ * install (or another checkout's Vite build writing `.vite-temp` deep inside
+ * that tree) restarted the backend. A `.DS_Store` or an editor swap file in
+ * `config/` restarted it too.
+ */
+export declare function devWatchArgs(projectRoot: string, paths: {
+    REBASE_DEV_FUNCTIONS?: string;
+    REBASE_DEV_CRONS?: string;
+}, entryTarget: string, restartTrigger: string | null): string[];
 /** Well-known filename the backend writes its actual port to. */
 export declare const DEV_PORT_FILENAME = ".rebase-dev-port";
 /**
@@ -138,6 +189,53 @@ export declare function resolveStartPort(projectRoot: string, explicitPort?: num
  * Exported for its test.
  */
 export declare function databaseEndpoint(url: string | null | undefined): string | null;
+/**
+ * What the start banner needs to know about a project's static apps.
+ *
+ * `rebase dev` runs one frontend: Vite in `frontend/`, at the root of its own
+ * localhost port, whatever path or hostname the manifest declares for it. So an
+ * app's local address and its deployed one are different things, and for an app
+ * with a hostname of its own they share nothing at all — appending its address
+ * to the local URL would print `http://localhost:5173https://admin.example.com`.
+ */
+export interface DevStaticShape {
+    declaresStaticApp: boolean;
+    /** The declared app whose `root` is the `frontend/` that `rebase dev` runs, if one is. */
+    served?: {
+        appName: string;
+        address: AppAddress;
+    };
+    /** Where the CMS is, when an app declares one. */
+    cms?: {
+        appName: string;
+        /** Always a path. */
+        path: string;
+        /** The serving app's hostname, when its `path` names one. */
+        host?: string;
+        /** Whether the app serving it is the one `rebase dev` runs, so it has a local address. */
+        servedLocally: boolean;
+    };
+}
+/**
+ * Read {@link DevStaticShape} out of a loaded manifest. Exported for its test.
+ *
+ * Which declared app is running is decided by its `root` being `frontend/`,
+ * because that directory is what `startFrontend` launches and nothing else is.
+ * When no declared app has that root, which app serves the CMS cannot be told,
+ * and it is read as the frontend that does run — what the banner has always
+ * assumed, and right for every project `rebase init` scaffolds.
+ */
+export declare function devStaticShape(manifest: RebaseProjectManifest, projectRoot: string, frontendDir: string | null): DevStaticShape;
+/**
+ * The banner's lines for a project with a frontend. Exported for its test.
+ *
+ * Every address is printed whole, once: the local one Vite answers on, and —
+ * for an app with a hostname — the https URL it answers on once deployed, on a
+ * line of its own beneath it. A CMS in an app `rebase dev` does not run gets its
+ * deployed address and a note saying so, rather than a localhost URL that the
+ * running frontend's SPA fallback would answer with the wrong app.
+ */
+export declare function appBannerLines(frontendUrl: string, api: string, shape: DevStaticShape): Array<[string, string]>;
 /**
  * The `↳ Database =` line: which database, why it was chosen, and where it is.
  *
@@ -206,7 +304,6 @@ export declare const DEV_FLAGS: {
     readonly "--backend-only": BooleanConstructor;
     readonly "--frontend-only": BooleanConstructor;
     readonly "--port": NumberConstructor;
-    readonly "--generate": BooleanConstructor;
     /**
      * Point this run at a database of your own, ahead of everything else.
      *
@@ -220,9 +317,23 @@ export declare const DEV_FLAGS: {
     readonly "-b": "--backend-only";
     readonly "-f": "--frontend-only";
     readonly "-P": "--port";
-    readonly "-g": "--generate";
     readonly "--no-db": BooleanConstructor;
 };
+/** What {@link ensureGeneratedSchema} did at startup. */
+export type SchemaGeneration = "generated" | "skipped" | "failed";
+/**
+ * Whether dev must still run the driver's `schema stale --fix` before the
+ * backend boots.
+ *
+ * Not after a regeneration that succeeded: that wrote `schema.generated.ts`
+ * from these collections with this driver, moments earlier, and `stale`
+ * compares the file against the same generator — it can only answer "nothing
+ * stale", and it cost a driver process (~0.6 s) on every start. The repair it
+ * exists for, a library upgrade that changed what the generator derives, is
+ * exactly what the regeneration already did. When generation was skipped or
+ * failed, the preflight is the remaining safety net and still runs.
+ */
+export declare function needsStaleSchemaPreflight(generation: SchemaGeneration): boolean;
 /**
  * One variable's value out of `.env` text, or undefined when it has none.
  *
@@ -251,4 +362,67 @@ export declare function readEnvValue(envText: string, key: string): string | und
  * it is invisible in any assertion about the push's *outcome*.
  */
 export declare function schemaPushArgv(databaseUrl: string | undefined): string[];
+/**
+ * Start-up's independent halves, overlapped rather than run one after another.
+ *
+ * `rebase dev` used to regenerate the schema and the SDK, then derive the
+ * resource graph (every collection evaluated again, in this process), then
+ * start the managed database and wait for it — about a second when it was not
+ * already running — and only then spawn the backend. None of the three reads
+ * what another writes: the generators read `config/` and write
+ * `backend/src/schema.generated.ts` and `generated/sdk/`; the derivation reads
+ * `config/resources.ts` and the collections; the database needs neither, and
+ * `schema generate` never connects to one. So `database` starts first and is
+ * collected last.
+ *
+ * `preflight` is the exception, and the reason this is not one `Promise.all`:
+ * on the `--docker` path it pushes the schema the generators have just written,
+ * so it still runs after them.
+ *
+ * A database that fails to start is reported where it always was — after the
+ * generators' and the preflight's output — rather than ahead of it, and it is
+ * never an unhandled rejection while they run.
+ *
+ * Exported for its test.
+ */
+export declare function overlapDevStartup<T>(steps: {
+    generate: () => Promise<SchemaGeneration>;
+    preflight: () => Promise<void>;
+    /** Resolve and, for the managed database, start it. `null` when this run starts none. */
+    database: (() => Promise<T>) | null;
+}): Promise<{
+    schemaGeneration: SchemaGeneration;
+    database: T | null;
+}>;
+/**
+ * Whether the admin panel can start beside the backend instead of after it.
+ *
+ * Vite has to be told the backend's URL when it starts (`VITE_API_URL`), and
+ * the backend's port is only certain once it has bound — so the admin panel
+ * used to wait for "Server running at", and the time to it was the backend's
+ * whole boot plus Vite's start. It can start beside the backend whenever the
+ * port the backend will bind is known in advance:
+ *
+ * - **named with `--port`**: the server binds it or refuses to start, never
+ *   walks past it (`REBASE_DEV_PORT_EXPLICIT`), and `pinnedPortRefusal` has
+ *   already checked that nothing answers there;
+ * - **free, and the port the backend tries first**: the server tries the port
+ *   its last run landed on before the one it is given (`.rebase-dev-port`), so
+ *   a remembered port must be this one — the "kept from the last run" rung —
+ *   or absent, which it is after every clean exit, and the derived port is
+ *   then the one tried. A port something already answers on would make the
+ *   backend move, so that case keeps the old order.
+ *
+ * Nothing here can rule out another process taking the port in the second the
+ * backend boots, so `devCommand` still compares the announced port with the
+ * one Vite was given and restarts the admin panel when they differ.
+ *
+ * Exported for its test.
+ */
+export declare function frontendCanStartWithBackend(options: {
+    projectRoot: string;
+    port: number;
+    pinned: boolean;
+    probe?: (host: string, port: number) => Promise<boolean>;
+}): Promise<boolean>;
 export declare function devCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/doctor.d.ts

@@ -57,4 +57,9 @@ export declare const DOCTOR_FLAGS: {
     readonly "--sdk": StringConstructor;
     readonly "-k": "--sdk";
 };
+/**
+ * The line handed to the driver, every path on it resolved from where the
+ * command was run — the driver runs in `backend/`. See `utils/path-flags.ts`.
+ */
+export declare function doctorDriverArgs(rawArgs: string[], cwd: string): string[];
 export declare function doctorCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/generate_sdk.d.ts

@@ -1,8 +1,9 @@
 /**
  * CLI command: generate-sdk
  *
- * Reads collection definitions from a specified directory (default: ./config/collections),
- * generates a typed TypeScript SDK, and writes it to the output directory (default: ./generated/sdk).
+ * Reads every collection file in a directory (default: ./config/collections) —
+ * the files the backend serves, not the barrel's list — generates a typed
+ * TypeScript SDK, and writes it to the output directory (default: ./generated/sdk).
  *
  * Uses jiti for dynamic TypeScript import of collection files.
  */
@@ -21,8 +22,34 @@ interface GenerateSDKArgs {
     from?: string;
     /** Bearer token for the contract endpoint. Falls back to REBASE_SERVICE_KEY. */
     token?: string;
+    /**
+     * Also register the generated `Database` for server-side code: write the
+     * types and the `Register` augmentation into `config/generated/`. See
+     * {@link writeRegistration}.
+     */
+    register?: boolean;
+    /**
+     * The directory holding `rebase.json`, where `--register` is remembered.
+     * Found from `cwd` when not given.
+     */
+    projectRoot?: string;
     help?: boolean;
 }
+/** What `--register` writes, and what marks a project as having opted in. */
+export declare const REGISTER_FILE = "register.ts";
+/**
+ * Where `--register` writes: `generated/` beside the collections directory,
+ * which is `config/generated/` in a scaffolded project.
+ *
+ * Inside `config/` because that is the one directory both compiles of a
+ * collection file include: the backend's program (it includes
+ * `../config/**`) and the `config` package's own `tsc`. A registration
+ * there that imported `../generated/sdk/database.types` pulled a file from
+ * outside `config/` into that package's program, which TypeScript refuses
+ * (the file is not under its `rootDir`) — so the types are copied in beside
+ * the registration rather than imported from the SDK.
+ */
+export declare function registrationDir(collectionsDir: string): string;
 /**
  * The base URL to show in the printed usage example.
  *

package/dist/commands/init.d.ts

@@ -1,4 +1,5 @@
 import type { PackageManager, PMCommands } from "../utils/package-manager.js";
+import { type AgentKey } from "./skills.js";
 /**
  * Every scaffolded file that carries a `{{PLACEHOLDER}}`.
  *
@@ -42,6 +43,10 @@ export interface InitOptions {
     setupKey?: string;
     /** Control-plane URL the setup key is redeemed against. */
     cloudUrl?: string;
+    /** AI coding agents to install skills and the MCP server for. */
+    agents: AgentKey[];
+    /** Whoever reads the closing steps can answer a prompt (a TTY, not --yes). */
+    interactive?: boolean;
 }
 export interface BuildQuestionsParams {
     nameArg?: string;
@@ -105,21 +110,59 @@ export declare function printInitHelp(): void;
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
 /** The flags `rebase init` takes. */
 export declare const INIT_FLAGS: {
-    readonly "--git": BooleanConstructor;
-    readonly "--install": BooleanConstructor;
-    readonly "--no-install": BooleanConstructor;
-    readonly "--database-url": StringConstructor;
-    readonly "--introspect": BooleanConstructor;
-    readonly "--template": StringConstructor;
-    readonly "--headless": BooleanConstructor;
-    readonly "--project": StringConstructor;
-    readonly "--setup-key": StringConstructor;
-    readonly "--yes": BooleanConstructor;
-    readonly "-g": "--git";
-    readonly "-i": "--install";
-    readonly "-t": "--template";
-    readonly "-y": "--yes";
+    "--git": BooleanConstructor;
+    "--install": BooleanConstructor;
+    "--no-install": BooleanConstructor;
+    "--database-url": StringConstructor;
+    "--introspect": BooleanConstructor;
+    "--template": StringConstructor;
+    "--headless": BooleanConstructor;
+    "--project": StringConstructor;
+    "--setup-key": StringConstructor;
+    "--agent": [StringConstructor];
+    "--yes": BooleanConstructor;
+    "-a": string;
+    "-g": string;
+    "-i": string;
+    "-t": string;
+    "-y": string;
 };
+/**
+ * The closing "AI Agent Skills" lines, each command one its reader can run.
+ *
+ * `rebase skills install` with no `--agent` prompts, and refuses without a
+ * TTY — so printing it bare at the end of `rebase init --yes`, the agent and
+ * CI path, told that reader to run a command that answers "Cannot prompt".
+ * Named agents are spelled out (a refresh must not depend on detection, which
+ * never finds Copilot); otherwise a TTY reader gets the prompt, anyone else
+ * the `--agent` form.
+ */
+export declare function agentNextSteps(agents: readonly AgentKey[], interactive: boolean, pm: PMCommands): string[];
+/**
+ * What a directory may already hold for `rebase init` to scaffold into it.
+ *
+ * `git clone` of an empty repository, or `git init`, leaves exactly `.git` —
+ * and `rebase init . --yes --git` is the help's own example. Counting every
+ * entry as "not empty" refused the one directory that example is most likely
+ * to be typed in. The entries here are a repository's metadata, the files
+ * operating systems drop into any folder, and a licence: none of them is
+ * something the scaffold writes (`init.test.ts` holds the template to that),
+ * so tolerating them can never overwrite anything. Everything else is a
+ * conflict and is named, never merged into.
+ */
+export declare const SCAFFOLD_TOLERATED_ENTRIES: ReadonlySet<string>;
+/** Entries in `dir` the scaffold would overwrite or mix with — `[]` when it may proceed. */
+export declare function scaffoldDirectoryConflicts(dir: string): string[];
+/** The refusal for a directory that already holds files, with the two ways forward. */
+export declare function scaffoldConflictMessage(projectName: string, displayPath: string, conflicts: string[]): string[];
+/**
+ * `git init`, or nothing when the directory is already a repository.
+ *
+ * A cloned repository keeps its branch, its remote and its history: the
+ * scaffold is committed on top of what is there. Only a repository this
+ * function created is pointed at `main`.
+ */
+export declare function initGitRepository(targetDirectory: string): Promise<boolean>;
 /**
  * Whether `port` is free — on the wildcard address *and* on both loopback addresses.
  *

package/dist/commands/schema.d.ts

@@ -1,3 +1,9 @@
+/**
+ * The line handed to the driver, its paths resolved from where the command was
+ * run (the driver runs in `backend/`). `--schema` is left alone: on
+ * `introspect` it names a Postgres schema, not a file.
+ */
+export declare function schemaDriverArgs(rawArgs: string[], cwd: string): string[];
 export declare function schemaCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
 /** Every subcommand the family dispatches — the help table's keys. */
 export declare const SCHEMA_SUBCOMMANDS: string[];

package/dist/commands/skills.d.ts

@@ -18,14 +18,32 @@
  * A subdirectory layout has no such problem: the rule file already sits beside
  * its own assets, so `references/x.md` resolves as written and nothing is
  * loaded until it is opened.
+ *
+ * `homeMarkers` are the directories under `~` that say the assistant is
+ * installed on this machine. They answer a different question from
+ * `detectDir`: a fresh scaffold has no `.claude/` of its own, so `rebase init`
+ * asks the machine which assistants the developer has and pre-selects those.
+ *
+ * `mcp` is where the assistant reads a *project-level* MCP server list, and in
+ * which shape — see `agent-setup.ts`. `projectDir` is what `REBASE_PROJECT_DIR`
+ * is set to: `"."` where the server is spawned in the project, the editor's own
+ * workspace variable where it may not be. `null` means there is no project
+ * file to write: Windsurf reads only a user-level config, and one entry there
+ * cannot name every project on the machine.
  */
-declare const AGENTS: {
+export declare const AGENTS: {
     readonly cursor: {
         readonly label: "Cursor";
         readonly detectDir: ".cursor";
+        readonly homeMarkers: readonly [".cursor"];
         readonly targetDir: ".cursor/rules";
         readonly flatLayout: true;
         readonly indexFile: "rebase.mdc";
+        readonly mcp: {
+            readonly file: ".cursor/mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: "${workspaceFolder}";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -35,8 +53,14 @@ declare const AGENTS: {
     readonly claude: {
         readonly label: "Claude Code";
         readonly detectDir: ".claude";
+        readonly homeMarkers: readonly [".claude"];
         readonly targetDir: ".claude/skills";
         readonly flatLayout: false;
+        readonly mcp: {
+            readonly file: ".mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** Claude Code uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -46,9 +70,11 @@ declare const AGENTS: {
     readonly windsurf: {
         readonly label: "Windsurf";
         readonly detectDir: ".windsurf";
+        readonly homeMarkers: readonly [".codeium/windsurf", ".windsurf"];
         readonly targetDir: ".windsurf/rules";
         readonly flatLayout: true;
         readonly indexFile: "rebase.md";
+        readonly mcp: null;
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -58,8 +84,14 @@ declare const AGENTS: {
     readonly gemini: {
         readonly label: "Gemini CLI / Antigravity";
         readonly detectDir: ".agents";
+        readonly homeMarkers: readonly [".gemini"];
         readonly targetDir: ".agents/skills";
         readonly flatLayout: false;
+        readonly mcp: {
+            readonly file: ".gemini/settings.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** Gemini uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -69,9 +101,15 @@ declare const AGENTS: {
     readonly codex: {
         readonly label: "Codex CLI";
         readonly detectDir: ".codex";
-        readonly targetDir: ".codex/skills";
+        readonly homeMarkers: readonly [".codex"];
+        readonly targetDir: ".agents/skills";
         readonly flatLayout: false;
-        /** Codex reads AGENTS.md; the skills sit beside its own config. */
+        readonly mcp: {
+            readonly file: ".codex/config.toml";
+            readonly format: "codexToml";
+            readonly projectDir: ".";
+        };
+        /** Codex uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
             content: string;
@@ -80,9 +118,15 @@ declare const AGENTS: {
     readonly kiro: {
         readonly label: "Kiro";
         readonly detectDir: ".kiro";
+        readonly homeMarkers: readonly [".kiro"];
         readonly targetDir: ".kiro/steering";
         readonly flatLayout: true;
         readonly indexFile: "rebase.md";
+        readonly mcp: {
+            readonly file: ".kiro/settings/mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -92,9 +136,15 @@ declare const AGENTS: {
     readonly copilot: {
         readonly label: "GitHub Copilot";
         readonly detectDir: null;
+        readonly homeMarkers: readonly [];
         readonly targetDir: ".github/instructions";
         readonly flatLayout: true;
         readonly indexFile: "rebase.instructions.md";
+        readonly mcp: {
+            readonly file: ".vscode/mcp.json";
+            readonly format: "vscode";
+            readonly projectDir: "${workspaceFolder}";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -102,7 +152,11 @@ declare const AGENTS: {
         };
     };
 };
-type AgentKey = keyof typeof AGENTS;
+export type AgentKey = keyof typeof AGENTS;
+/** Narrows a string to an agent name, by the table's own keys. */
+export declare function isAgentKey(value: string): value is AgentKey;
+/** Every agent, in table order. */
+export declare const AGENT_KEYS: AgentKey[];
 export interface LoadedSkill {
     name: string;
     /** Absolute path of the skill's source directory. */
@@ -113,6 +167,13 @@ export interface LoadedSkill {
 }
 /** Read all skill directories and return their names, content and assets. */
 export declare function loadSkills(skillsDir: string): LoadedSkill[];
+/**
+ * The skills this CLI ships, from its own `@rebasepro/agent-skills`.
+ *
+ * Throws rather than exiting, so `rebase init` can report a missing bundle as a
+ * warning and still finish the scaffold.
+ */
+export declare function loadBundledSkills(): LoadedSkill[];
 /**
  * The one always-on rule a flat-layout agent gets, in place of every skill.
  *
@@ -136,11 +197,57 @@ export declare function renderSkillIndex(skills: LoadedSkill[], agentKey: AgentK
  * guessing, because the wrong guess installs 21 files and reports success.
  */
 export declare function detectAgents(projectDir: string): AgentKey[];
+/** What `detectInstalledAgents` found for one assistant. */
+export interface InstalledAgent {
+    key: AgentKey;
+    label: string;
+    /** The home directory checked, as `~/…` — the one found, else the first. */
+    marker: string | null;
+    found: boolean;
+}
+/**
+ * Which assistants are installed on this machine, from their home directories.
+ *
+ * The question `rebase init` needs answered, and one `detectAgents` cannot: a
+ * project that does not exist yet has no `.claude/` in it. What the machine has
+ * is only a default — the developer confirms it — so a false positive costs an
+ * unticked box, not 21 files nobody asked for.
+ */
+export declare function detectInstalledAgents(home?: string): InstalledAgent[];
 /** Install skills for a specific agent into the project directory. */
-export declare function installForAgent(agentKey: AgentKey, skills: LoadedSkill[], projectDir: string): {
+/**
+ * The file in each target directory that records what the installer wrote:
+ * relative path → sha256 of the bytes written. A dotfile, so no agent loads it
+ * as a rule.
+ */
+export declare const SKILLS_MANIFEST = ".rebase-skills.json";
+/** What one agent's install did. */
+export interface AgentInstallResult {
     skills: number;
     assets: number;
-};
+    /** Files left as they are because they were edited since the last install (relative to the target dir). */
+    kept: string[];
+    /** Files of skills the bundle no longer ships, removed because nobody edited them. */
+    removed: string[];
+}
+export declare function installForAgent(agentKey: AgentKey, skills: LoadedSkill[], projectDir: string, options?: {
+    force?: boolean;
+}): AgentInstallResult;
+/** What `installSkills` did for one agent. */
+export interface SkillsInstallResult extends AgentInstallResult {
+    agent: AgentKey;
+    /** An earlier agent in the same run that already wrote this directory. */
+    sharedWith?: AgentKey;
+}
+/**
+ * Install for several agents, writing each target directory once.
+ *
+ * Gemini and Codex both read `.agents/skills`; installing twice would write the
+ * same 21 files twice and report two installs of one directory.
+ */
+export declare function installSkills(agents: readonly AgentKey[], skills: LoadedSkill[], projectDir: string, options?: {
+    force?: boolean;
+}): SkillsInstallResult[];
 /** Everything the switch below dispatches, for the did-you-mean. */
 export declare const SKILLS_SUBCOMMANDS: readonly ["install"];
 export declare function skillsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
@@ -150,4 +257,16 @@ export declare function skillsCommand(subcommand: string | undefined, rawArgs: s
  * given.
  */
 export declare function parseAgentFlags(rawArgs: string[]): AgentKey[] | null;
-export {};
+/** `rebase skills install`'s whole line: the agents it names, `--mcp` and `--force`. */
+export declare function parseSkillsInstallLine(rawArgs: string[]): {
+    agents: AgentKey[] | null;
+    mcp: boolean;
+    force: boolean;
+};
+/**
+ * The agents a list of `--agent` values names, or null when it names none.
+ *
+ * Shared by `rebase skills install` and `rebase init`, so both accept the same
+ * spellings. Throws a UsageError on a name that is not an agent.
+ */
+export declare function resolveAgentNames(values: readonly string[]): AgentKey[] | null;

package/dist/commands/start.d.ts

@@ -1 +1,30 @@
+import type { RebaseBundleStatic } from "@rebasepro/types";
+/** The NODE_ENV the runtime will see, and where it comes from. */
+export interface StartNodeEnv {
+    value: string | undefined;
+    source: "shell" | ".env" | "unset";
+}
+/**
+ * What NODE_ENV the server will boot in. The shell wins — dotenv never
+ * overrides a variable that is already set — then `.env`.
+ */
+export declare function startNodeEnv(projectRoot: string): StartNodeEnv;
+/**
+ * The banner for a `rebase start` that is not a production server, or `null`.
+ *
+ * Not forced to production: the scaffold's `.env` points at a loopback
+ * database, which a production boot refuses, so forcing it would break the
+ * documented local run. What must not happen is the silence — a command the
+ * help called "(production)" booting with the first-registration window open.
+ */
+export declare function nonProductionWarning(nodeEnv: StartNodeEnv): string[] | null;
+/**
+ * What to say about the apps a bundle serves only on their own hostname.
+ *
+ * The runtime prints "Server running at http://localhost:<port>", and an app
+ * whose `path` names a hostname answers only requests carrying that `Host` —
+ * so opening the printed URL showed a 404 for an app that was running fine,
+ * and nothing said why. One line per such app, with a command that reaches it.
+ */
+export declare function hostRoutedNotice(staticApps: readonly RebaseBundleStatic[], port: string | undefined): string[];
 export declare function startCommand(rawArgs?: string[]): Promise<void>;