@dobby.ai/dobby 0.1.0 → 0.1.2

package/dist/src/cli/commands/doctor.js

@@ -7,6 +7,33 @@ import { ensureGatewayConfigShape, setDefaultProviderIfMissingOrInvalid, } from
 import { DISCORD_CONNECTOR_CONTRIBUTION_ID } from "../shared/discord-config.js";
 import { readRawConfig, resolveConfigPath, resolveDataRootDir, writeConfigWithValidation } from "../shared/config-io.js";
 import { createLogger } from "../shared/runtime.js";
+function isPlaceholderValue(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    const normalized = value.trim().toUpperCase();
+    return normalized.includes("REPLACE_WITH_") || normalized.includes("YOUR_");
+}
+function isCredentialLikeKey(key) {
+    return /(?:token|secret|api[-_]?key|appid|appsecret)/i.test(key);
+}
+function walkPlaceholders(value, path) {
+    if (isPlaceholderValue(value)) {
+        return [{ path, value }];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => walkPlaceholders(item, `${path}[${index}]`));
+    }
+    if (!value || typeof value !== "object") {
+        return [];
+    }
+    return Object.entries(value).flatMap(([key, nested]) => walkPlaceholders(nested, `${path}.${key}`));
+}
+function lastPathSegment(path) {
+    const withoutIndexes = path.replaceAll(/\[\d+\]/g, "");
+    const segments = withoutIndexes.split(".");
+    return segments[segments.length - 1] ?? withoutIndexes;
+}
 function expandHome(value) {
     if (value === "~") {
         return homedir();
@@ -76,6 +103,15 @@ export async function runDoctorCommand(options) {
                 message: `providers.items['${instanceId}'] references missing contribution '${instance.type}'`,
             });
         }
+        for (const hit of walkPlaceholders(instance, `providers.items['${instanceId}']`)) {
+            if (hit.path.endsWith(".type")) {
+                continue;
+            }
+            issues.push({
+                level: isCredentialLikeKey(lastPathSegment(hit.path)) ? "error" : "warning",
+                message: `${hit.path} still uses placeholder value '${hit.value}'`,
+            });
+        }
     }
     for (const [instanceId, instance] of Object.entries(normalized.connectors.items)) {
         if (!availableContributionIds.has(instance.type)) {
@@ -84,6 +120,15 @@ export async function runDoctorCommand(options) {
                 message: `connectors.items['${instanceId}'] references missing contribution '${instance.type}'`,
             });
         }
+        for (const hit of walkPlaceholders(instance, `connectors.items['${instanceId}']`)) {
+            if (hit.path.endsWith(".type")) {
+                continue;
+            }
+            issues.push({
+                level: isCredentialLikeKey(lastPathSegment(hit.path)) ? "error" : "warning",
+                message: `${hit.path} still uses placeholder value '${hit.value}'`,
+            });
+        }
         if (instance.type === DISCORD_CONNECTOR_CONTRIBUTION_ID) {
             const botName = typeof instance.botName === "string" ? instance.botName.trim() : "";
             const botToken = typeof instance.botToken === "string" ? instance.botToken.trim() : "";
@@ -109,18 +154,46 @@ export async function runDoctorCommand(options) {
             });
         }
     }
+    if (normalized.routes.default.projectRoot && isPlaceholderValue(normalized.routes.default.projectRoot)) {
+        issues.push({
+            level: "warning",
+            message: `routes.default.projectRoot still uses placeholder value '${normalized.routes.default.projectRoot}'`,
+        });
+    }
     for (const [routeId, route] of Object.entries(normalized.routes.items)) {
+        const effectiveProjectRoot = route.projectRoot ?? normalized.routes.default.projectRoot;
+        const projectRootSource = route.projectRoot ? `routes.items['${routeId}'].projectRoot` : "routes.default.projectRoot";
+        if (!effectiveProjectRoot) {
+            issues.push({
+                level: "error",
+                message: `routes.items['${routeId}'].projectRoot is required when routes.default.projectRoot is not set`,
+            });
+            continue;
+        }
+        if (isPlaceholderValue(effectiveProjectRoot)) {
+            issues.push({
+                level: "warning",
+                message: `${projectRootSource} still uses placeholder value '${effectiveProjectRoot}'`,
+            });
+            continue;
+        }
         try {
-            const projectRootPath = resolveRouteProjectRoot(configPath, route.projectRoot);
+            const projectRootPath = resolveRouteProjectRoot(configPath, effectiveProjectRoot);
             await access(projectRootPath);
         }
         catch {
             issues.push({
                 level: "warning",
-                message: `routes.items['${routeId}'].projectRoot does not exist: ${route.projectRoot}`,
+                message: `${projectRootSource} does not exist: ${effectiveProjectRoot}`,
             });
         }
     }
+    if (normalized.bindings.default && !normalized.routes.items[normalized.bindings.default.route]) {
+        issues.push({
+            level: "error",
+            message: `bindings.default.route references unknown route '${normalized.bindings.default.route}'`,
+        });
+    }
     const seenBindingSources = new Map();
     for (const [bindingId, binding] of Object.entries(normalized.bindings.items)) {
         if (!normalized.connectors.items[binding.connector]) {
@@ -135,6 +208,12 @@ export async function runDoctorCommand(options) {
                 message: `bindings.items['${bindingId}'].route references unknown route '${binding.route}'`,
             });
         }
+        if (isPlaceholderValue(binding.source.id)) {
+            issues.push({
+                level: "warning",
+                message: `bindings.items['${bindingId}'].source.id still uses placeholder value '${binding.source.id}'`,
+            });
+        }
         const bindingKey = `${binding.connector}:${binding.source.type}:${binding.source.id}`;
         const existingBindingId = seenBindingSources.get(bindingKey);
         if (existingBindingId) {

package/dist/src/cli/commands/extension.js

@@ -3,6 +3,7 @@ import { loadGatewayConfig } from "../../core/routing.js";
 import { ExtensionStoreManager } from "../../extension/manager.js";
 import { applyContributionTemplates, buildContributionTemplates, ensureGatewayConfigShape, listContributionIds, setDefaultProviderIfMissingOrInvalid, upsertAllowListPackage, } from "../shared/config-mutators.js";
 import { readRawConfig, requireRawConfig, resolveConfigPath, resolveDataRootDir, writeConfigWithValidation } from "../shared/config-io.js";
+import { resolveExtensionInstallSpecs } from "../shared/local-extension-specs.js";
 import { createLogger } from "../shared/runtime.js";
 /**
  * Resolves extension store directory from normalized gateway config.
@@ -25,7 +26,8 @@ export async function runExtensionInstallCommand(options) {
     const logger = createLogger();
     const rawConfig = (await readRawConfig(configPath)) ?? {};
     const manager = new ExtensionStoreManager(logger, extensionStoreDirFromRaw(configPath, rawConfig));
-    const installed = await manager.install(options.spec);
+    const [resolvedSpec] = await resolveExtensionInstallSpecs([options.spec]);
+    const installed = await manager.install(resolvedSpec ?? options.spec);
     if (!options.enable) {
         const templates = buildContributionTemplates(installed.manifest.contributions);
         if (options.json) {

package/dist/src/cli/commands/init.js

@@ -1,37 +1,13 @@
-import { cancel, confirm, intro, isCancel, multiselect, note, outro, password, select, spinner, text, } from "@clack/prompts";
+import { cancel, intro, isCancel, multiselect, outro, select, spinner, } from "@clack/prompts";
 import { ExtensionStoreManager } from "../../extension/manager.js";
 import { ensureGatewayConfigShape, upsertAllowListPackage, upsertBinding, upsertConnectorInstance, upsertProviderInstance, upsertRoute, } from "../shared/config-mutators.js";
-import { DEFAULT_DISCORD_BOT_NAME } from "../shared/discord-config.js";
-import { applyAndValidateContributionSchemas, loadContributionSchemaCatalog } from "../shared/config-schema.js";
+import { applyAndValidateContributionSchemas } from "../shared/config-schema.js";
 import { readRawConfig, resolveConfigPath, resolveDataRootDir, writeConfigWithValidation, } from "../shared/config-io.js";
 import { createInitSelectionConfig, isInitConnectorChoiceId, isInitProviderChoiceId, listInitConnectorChoices, listInitProviderChoices, } from "../shared/init-catalog.js";
-import { ensureProviderPiModelsFile } from "../shared/init-models-file.js";
+import { resolveExtensionInstallSpecs } from "../shared/local-extension-specs.js";
 import { createLogger } from "../shared/runtime.js";
-import { promptConfigFromSchema } from "../shared/schema-prompts.js";
 /**
- * Repeatedly prompts for non-empty text input and aborts cleanly on cancel.
- */
-async function promptRequiredText(params) {
-    while (true) {
-        const promptOptions = {
-            message: params.message,
-            ...(params.placeholder !== undefined ? { placeholder: params.placeholder } : {}),
-            ...(params.initialValue !== undefined ? { initialValue: params.initialValue } : {}),
-        };
-        const result = await text(promptOptions);
-        if (isCancel(result)) {
-            cancel("Initialization cancelled.");
-            throw new Error("Initialization cancelled.");
-        }
-        const value = String(result ?? "").trim();
-        if (value.length > 0) {
-            return value;
-        }
-        await note("This field is required.", "Validation");
-    }
-}
-/**
- * Collects init inputs from interactive prompts.
+ * Collects high-level starter choices only; config values are written as templates.
  */
 async function collectInitInput() {
     intro("dobby init");
@@ -61,7 +37,7 @@ async function collectInitInput() {
     let routeProviderChoiceId = providerChoiceIds[0];
     if (providerChoiceIds.length > 1) {
         const routeProviderChoiceResult = await select({
-            message: "Choose provider for the default route",
+            message: "Choose default provider",
             options: providerChoiceIds.map((providerChoiceId) => ({
                 value: providerChoiceId,
                 label: providerChoicesById.get(providerChoiceId)?.label ?? providerChoiceId,
@@ -79,101 +55,55 @@ async function collectInitInput() {
         routeProviderChoiceId = routeProviderCandidate;
     }
     const connectorChoices = listInitConnectorChoices();
-    const connectorChoiceResult = await select({
-        message: "Choose connector",
+    const connectorChoiceResult = await multiselect({
+        message: "Choose connector(s) (space to select multiple)",
         options: connectorChoices.map((item) => ({
             value: item.id,
             label: item.label,
         })),
-        initialValue: "connector.discord",
+        initialValues: ["connector.discord"],
+        required: true,
     });
     if (isCancel(connectorChoiceResult)) {
         cancel("Initialization cancelled.");
         throw new Error("Initialization cancelled.");
     }
-    const connectorChoiceId = String(connectorChoiceResult);
-    if (!isInitConnectorChoiceId(connectorChoiceId)) {
-        throw new Error(`Unsupported connector choice '${connectorChoiceId}'`);
+    const connectorChoiceIds = connectorChoiceResult.map((value) => String(value));
+    if (connectorChoiceIds.length === 0) {
+        throw new Error("At least one connector must be selected");
     }
-    const projectRoot = await promptRequiredText({
-        message: "Project root",
-        initialValue: process.cwd(),
-    });
-    const channelId = await promptRequiredText({
-        message: "Discord channel ID",
-        placeholder: "1234567890",
-    });
-    const routeIdResult = await text({
-        message: "Route ID",
-        initialValue: "main",
-    });
-    if (isCancel(routeIdResult)) {
-        cancel("Initialization cancelled.");
-        throw new Error("Initialization cancelled.");
-    }
-    const botNameResult = await text({
-        message: "Discord bot name",
-        initialValue: DEFAULT_DISCORD_BOT_NAME,
-    });
-    if (isCancel(botNameResult)) {
-        cancel("Initialization cancelled.");
-        throw new Error("Initialization cancelled.");
-    }
-    const botTokenResult = await password({
-        message: "Discord bot token",
-        mask: "*",
-        validate: (value) => (value.trim().length > 0 ? undefined : "Token is required"),
-    });
-    if (isCancel(botTokenResult)) {
-        cancel("Initialization cancelled.");
-        throw new Error("Initialization cancelled.");
-    }
-    const allowAllMessagesResult = await confirm({
-        message: "Allow all group messages (not mention-only)?",
-        initialValue: false,
-    });
-    if (isCancel(allowAllMessagesResult)) {
-        cancel("Initialization cancelled.");
-        throw new Error("Initialization cancelled.");
+    if (!connectorChoiceIds.every((connectorChoiceId) => isInitConnectorChoiceId(connectorChoiceId))) {
+        const invalidChoice = connectorChoiceIds.find((connectorChoiceId) => !isInitConnectorChoiceId(connectorChoiceId));
+        throw new Error(`Unsupported connector choice '${invalidChoice}'`);
     }
     return {
         providerChoiceIds: providerChoiceIds,
         routeProviderChoiceId,
-        connectorChoiceId,
-        projectRoot,
-        channelId,
-        routeId: String(routeIdResult ?? "").trim() || "main",
-        botName: String(botNameResult ?? "").trim() || DEFAULT_DISCORD_BOT_NAME,
-        botToken: String(botTokenResult ?? "").trim(),
-        allowAllMessages: allowAllMessagesResult === true,
+        connectorChoiceIds: connectorChoiceIds,
     };
 }
 /**
- * Executes first-time initialization: install required extensions, write config, then validate.
+ * Executes first-time initialization by installing starter extensions and writing template config.
  */
 export async function runInitCommand() {
     const configPath = resolveConfigPath();
     const existingConfig = await readRawConfig(configPath);
     if (existingConfig) {
-        throw new Error(`Config '${configPath}' already exists. Use 'dobby config edit' or 'dobby configure' to update existing values.`);
+        throw new Error(`Config '${configPath}' already exists. Edit the file directly to update existing values.`);
     }
     const input = await collectInitInput();
-    const selected = createInitSelectionConfig(input.providerChoiceIds, input.connectorChoiceId, {
-        routeId: input.routeId,
-        projectRoot: input.projectRoot,
-        allowAllMessages: input.allowAllMessages,
-        botName: input.botName,
-        botToken: input.botToken,
-        channelId: input.channelId,
+    const selected = createInitSelectionConfig(input.providerChoiceIds, input.connectorChoiceIds, {
         routeProviderChoiceId: input.routeProviderChoiceId,
+        defaultProjectRoot: process.cwd(),
     });
     const next = ensureGatewayConfigShape({});
     const rootDir = resolveDataRootDir(configPath, next);
     const manager = new ExtensionStoreManager(createLogger(), `${rootDir}/extensions`);
+    const extensionInstallSpecs = await resolveExtensionInstallSpecs(selected.extensionPackages);
     const installSpinner = spinner();
     installSpinner.start(`Installing required extensions (${selected.extensionPackages.length} packages)`);
     try {
-        const installedPackages = await manager.installMany(selected.extensionPackages);
+        const installedPackages = await manager.installMany(extensionInstallSpecs);
         for (const installed of installedPackages) {
             upsertAllowListPackage(next, installed.packageName, true);
         }
@@ -183,52 +113,12 @@ export async function runInitCommand() {
         installSpinner.stop("Extension installation failed");
         throw error;
     }
-    const catalog = await loadContributionSchemaCatalog(configPath, next);
-    const schemaByContributionId = new Map(catalog
-        .filter((item) => item.configSchema)
-        .map((item) => [item.contributionId, item.configSchema]));
-    const schemaStateByContributionId = new Map(catalog.map((item) => [item.contributionId, item.configSchema ? "with_schema" : "without_schema"]));
-    const warnedSchemaFallback = new Set();
-    const noteSchemaFallback = async (contributionId) => {
-        if (warnedSchemaFallback.has(contributionId)) {
-            const existingState = schemaStateByContributionId.get(contributionId);
-            return existingState === "without_schema" ? "without_schema" : "not_loaded";
-        }
-        warnedSchemaFallback.add(contributionId);
-        const state = schemaStateByContributionId.get(contributionId);
-        if (state === "without_schema") {
-            await note(`Contribution '${contributionId}' is loaded but does not expose configSchema. Falling back to built-in defaults/JSON.`, "Schema");
-            return "without_schema";
-        }
-        await note(`No loaded schema for contribution '${contributionId}'. The extension may be disabled or not installed.`, "Schema");
-        return "not_loaded";
-    };
-    const resolveFallbackConfig = async (kind, instanceId, contributionId, fallbackConfig) => {
-        const state = await noteSchemaFallback(contributionId);
-        if (state === "not_loaded") {
-            throw new Error(`Cannot initialize ${kind} '${instanceId}' because schema for contribution '${contributionId}' is not loaded. ` +
-                `Ensure the extension is installed and enabled, then retry.`);
-        }
-        return fallbackConfig;
-    };
     for (const provider of selected.providerInstances) {
-        const schema = schemaByContributionId.get(provider.contributionId);
-        const providerConfig = schema
-            ? await promptConfigFromSchema(schema, provider.config, {
-                title: `Provider '${provider.instanceId}' (${provider.contributionId})`,
-            })
-            : await resolveFallbackConfig("provider", provider.instanceId, provider.contributionId, provider.config);
-        upsertProviderInstance(next, provider.instanceId, provider.contributionId, providerConfig);
+        upsertProviderInstance(next, provider.instanceId, provider.contributionId, provider.config);
+    }
+    for (const connector of selected.connectorInstances) {
+        upsertConnectorInstance(next, connector.instanceId, connector.contributionId, connector.config);
     }
-    const connectorSchema = schemaByContributionId.get(selected.connectorContributionId);
-    const connectorConfig = selected.connectorContributionId === "connector.discord"
-        ? selected.connectorConfig
-        : connectorSchema
-            ? await promptConfigFromSchema(connectorSchema, selected.connectorConfig, {
-                title: `Connector '${selected.connectorInstanceId}' (${selected.connectorContributionId})`,
-            })
-            : await resolveFallbackConfig("connector", selected.connectorInstanceId, selected.connectorContributionId, selected.connectorConfig);
-    upsertConnectorInstance(next, selected.connectorInstanceId, selected.connectorContributionId, connectorConfig);
     next.providers = {
         ...next.providers,
         default: selected.providerInstanceId,
@@ -236,51 +126,31 @@ export async function runInitCommand() {
     };
     next.routes = {
         ...next.routes,
-        defaults: {
-            ...next.routes.defaults,
-            provider: selected.providerInstanceId,
+        default: {
+            ...next.routes.default,
+            ...selected.routeDefaults,
         },
     };
-    upsertRoute(next, input.routeId, {
-        ...selected.routeProfile,
-        projectRoot: input.projectRoot,
-    });
-    upsertBinding(next, selected.bindingId, selected.bindingConfig);
-    const validatedConfig = await applyAndValidateContributionSchemas(configPath, next);
-    const createdModelsFiles = [];
-    for (const provider of selected.providerInstances) {
-        if (provider.contributionId !== "provider.pi") {
-            continue;
-        }
-        const resolvedProvider = validatedConfig.providers?.items?.[provider.instanceId];
-        const { type: _type, ...providerConfig } = resolvedProvider ?? {};
-        const ensured = await ensureProviderPiModelsFile(configPath, Object.keys(providerConfig).length > 0 ? providerConfig : provider.config);
-        if (ensured.created) {
-            createdModelsFiles.push(ensured.path);
-        }
+    upsertRoute(next, selected.routeId, selected.routeProfile);
+    if (selected.defaultBinding) {
+        next.bindings = {
+            ...next.bindings,
+            default: selected.defaultBinding,
+            items: next.bindings.items,
+        };
+    }
+    for (const binding of selected.bindings) {
+        upsertBinding(next, binding.id, binding.config);
     }
+    const validatedConfig = await applyAndValidateContributionSchemas(configPath, next);
     await writeConfigWithValidation(configPath, validatedConfig, {
         validate: true,
         createBackup: false,
     });
     outro("Initialization completed.");
     console.log(`Config written: ${configPath}`);
-    if (createdModelsFiles.length > 0) {
-        console.log("Generated model files:");
-        for (const path of createdModelsFiles) {
-            console.log(`- ${path}`);
-        }
-    }
     console.log("Next steps:");
-    console.log("1. dobby start");
-    const showHint = await confirm({
-        message: "Show quick validation commands?",
-        initialValue: true,
-    });
-    if (!isCancel(showHint) && showHint) {
-        await note([
-            "dobby extension list",
-            "dobby doctor",
-        ].join("\n"), "Validation");
-    }
+    console.log("1. Edit gateway.json and replace all REPLACE_WITH_* / YOUR_* placeholders");
+    console.log("2. Run 'dobby doctor' to validate the edited config");
+    console.log("3. Run 'dobby start' when the placeholders are replaced");
 }

package/dist/src/cli/commands/topology.js

@@ -2,6 +2,13 @@ import { BUILTIN_HOST_SANDBOX_ID } from "../../core/types.js";
 import { ensureGatewayConfigShape, upsertBinding, upsertRoute, } from "../shared/config-mutators.js";
 import { DISCORD_CONNECTOR_CONTRIBUTION_ID } from "../shared/discord-config.js";
 import { requireRawConfig, resolveConfigPath, writeConfigWithValidation } from "../shared/config-io.js";
+function effectiveRouteProjectRoot(normalized, routeId) {
+    const route = normalized.routes.items[routeId];
+    if (!route) {
+        return undefined;
+    }
+    return route.projectRoot ?? normalized.routes.default.projectRoot;
+}
 function listDiscordConnectors(rawConfig) {
     const normalized = ensureGatewayConfigShape(rawConfig);
     const items = [];
@@ -36,11 +43,11 @@ function getDiscordConnectorOrThrow(rawConfig, connectorId) {
 }
 function listBindings(rawConfig, connectorFilter) {
     const normalized = ensureGatewayConfigShape(rawConfig);
-    const routes = normalized.routes.items;
-    return Object.entries(normalized.bindings.items)
+    const bindings = Object.entries(normalized.bindings.items)
         .filter(([, binding]) => !connectorFilter || binding.connector === connectorFilter)
         .map(([bindingId, binding]) => {
-        const route = routes[binding.route];
+        const route = normalized.routes.items[binding.route];
+        const projectRoot = route ? effectiveRouteProjectRoot(normalized, binding.route) : undefined;
         return {
             bindingId,
             connectorId: binding.connector,
@@ -48,14 +55,27 @@ function listBindings(rawConfig, connectorFilter) {
             sourceId: binding.source.id,
             routeId: binding.route,
             routeExists: Boolean(route),
-            ...(route ? { projectRoot: route.projectRoot } : {}),
+            ...(projectRoot ? { projectRoot } : {}),
         };
-    })
-        .sort((a, b) => a.bindingId.localeCompare(b.bindingId));
+    });
+    if (!connectorFilter && normalized.bindings.default) {
+        const projectRoot = effectiveRouteProjectRoot(normalized, normalized.bindings.default.route);
+        bindings.push({
+            bindingId: "bindings.default",
+            connectorId: "*",
+            sourceType: "direct_message",
+            sourceId: "*",
+            routeId: normalized.bindings.default.route,
+            routeExists: Boolean(normalized.routes.items[normalized.bindings.default.route]),
+            ...(projectRoot ? { projectRoot } : {}),
+        });
+    }
+    return bindings.sort((a, b) => a.bindingId.localeCompare(b.bindingId));
 }
 function buildRouteBindingCounts(rawConfig) {
+    const normalized = ensureGatewayConfigShape(rawConfig);
     const counts = new Map();
-    for (const binding of listBindings(rawConfig)) {
+    for (const binding of listBindings(normalized)) {
         counts.set(binding.routeId, (counts.get(binding.routeId) ?? 0) + 1);
     }
     return counts;
@@ -66,7 +86,7 @@ function listRoutes(rawConfig) {
     return Object.entries(normalized.routes.items)
         .map(([routeId, route]) => ({
         routeId,
-        projectRoot: route.projectRoot,
+        projectRoot: effectiveRouteProjectRoot(normalized, routeId) ?? "(unset)",
         tools: route.tools === "readonly" ? "readonly" : "full",
         mentions: route.mentions === "optional" ? "optional" : "required",
         ...(route.provider ? { provider: route.provider } : {}),
@@ -205,7 +225,7 @@ export async function runRouteSetCommand(options) {
     const normalized = ensureGatewayConfigShape(structuredClone(rawConfig));
     const existing = normalized.routes.items[options.routeId];
     const projectRoot = options.projectRoot?.trim() || existing?.projectRoot;
-    if (!projectRoot) {
+    if (!projectRoot && !normalized.routes.default.projectRoot) {
         throw new Error("--project-root is required when creating a new route");
     }
     const toolsRaw = options.tools ?? existing?.tools;
@@ -221,7 +241,7 @@ export async function runRouteSetCommand(options) {
         throw new Error(`Sandbox '${sandbox}' does not exist`);
     }
     upsertRoute(normalized, options.routeId, {
-        projectRoot,
+        ...(projectRoot ? { projectRoot } : {}),
         ...(toolsRaw ? { tools: toolsRaw } : {}),
         ...((options.mentions ?? existing?.mentions) ? { mentions: (options.mentions ?? existing?.mentions) } : {}),
         ...(provider ? { provider } : {}),
@@ -238,15 +258,19 @@ export async function runRouteRemoveCommand(options) {
     if (!normalized.routes.items[options.routeId]) {
         throw new Error(`Route '${options.routeId}' not found`);
     }
-    const bindingRefs = listBindings(normalized).filter((binding) => binding.routeId === options.routeId);
-    if (bindingRefs.length > 0 && !options.cascadeBindings) {
+    const bindingRefs = listBindings(normalized).filter((binding) => binding.routeId === options.routeId && binding.bindingId !== "bindings.default");
+    const hasDefaultBindingRef = normalized.bindings.default?.route === options.routeId;
+    if ((bindingRefs.length > 0 || hasDefaultBindingRef) && !options.cascadeBindings) {
         const refList = bindingRefs.map((binding) => binding.bindingId).join(", ");
-        throw new Error(`Route '${options.routeId}' is referenced by bindings (${refList}). Re-run with --cascade-bindings to remove these bindings automatically.`);
+        throw new Error(`Route '${options.routeId}' is referenced by bindings (${[refList, hasDefaultBindingRef ? "bindings.default" : ""].filter(Boolean).join(", ")}). Re-run with --cascade-bindings to remove these bindings automatically.`);
     }
-    if (bindingRefs.length > 0 && options.cascadeBindings) {
+    if (options.cascadeBindings) {
         for (const binding of bindingRefs) {
             delete normalized.bindings.items[binding.bindingId];
         }
+        if (hasDefaultBindingRef) {
+            delete normalized.bindings.default;
+        }
     }
     delete normalized.routes.items[options.routeId];
     await saveConfig(configPath, normalized);