@notis_ai/cli 0.2.0-beta.48.1 → 0.2.0-beta.76.1

package/README.md

@@ -207,8 +207,8 @@ Describe a generic tool by name.
 When to use: Use this when you know the tool name and want its parameter schema before execution.
 
 Examples:
-- `npx --package @notis_ai/cli@latest -- notis tools describe composio-gmail-default-send_email`
-- `npx --package @notis_ai/cli@latest -- notis tools describe notis-default-query`
+- `npx --package @notis_ai/cli@latest -- notis tools describe composio-gmail-send_email`
+- `npx --package @notis_ai/cli@latest -- notis tools describe LOCAL_NOTIS_DATABASE_QUERY`
 
 ### `npx --package @notis_ai/cli@latest -- notis tools exec <tool-name>`
 
@@ -223,13 +223,13 @@ Options:
 - `--dry-run` — Validate arguments against the tool schema without executing.
 
 Examples:
-- `npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --arguments '{"database_slug":"tasks","query":{}}'`
-- `npx --package @notis_ai/cli@latest -- notis tools exec notis-default-get_database --arguments '{"database_slug":"tasks"}'`
-- `npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --get-schema`
-- `npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --dry-run --arguments '{"database_slug":"tasks","query":{}}'`
-- `npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --arguments @query.json`
-- `npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --arguments - < query.json`
-- `npx --package @notis_ai/cli@latest -- notis tools exec composio-dropbox-default-upload_file --arguments '{"path":"/target/in/dropbox.pdf"}' --file content=./Invoice.pdf`
+- `npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments '{"database_slug":"tasks","query":{}}'`
+- `npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --arguments '{"database_slug":"tasks"}'`
+- `npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --get-schema`
+- `npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --dry-run --arguments '{"database_slug":"tasks","query":{}}'`
+- `npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments @query.json`
+- `npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments - < query.json`
+- `npx --package @notis_ai/cli@latest -- notis tools exec composio-dropbox-upload_file --arguments '{"path":"/target/in/dropbox.pdf"}' --file content=./Invoice.pdf`
 
 ### `npx --package @notis_ai/cli@latest -- notis tools exec-parallel <calls>`
 
@@ -241,7 +241,7 @@ Options:
 - `--file <argument-path=local-path>` — Unsupported for exec-parallel; use tools exec for file uploads.
 
 Examples:
-- `npx --package @notis_ai/cli@latest -- notis tools exec-parallel '[{"tool_name":"notis-default-query","arguments":{"database_slug":"tasks","query":{}}},{"tool_name":"notis-default-list_databases","arguments":{}}]'`
+- `npx --package @notis_ai/cli@latest -- notis tools exec-parallel '[{"tool_name":"LOCAL_NOTIS_DATABASE_QUERY","arguments":{"database_slug":"tasks","query":{}}},{"tool_name":"LOCAL_NOTIS_DATABASE_LIST_DATABASES","arguments":{}}]'`
 
 ### `npx --package @notis_ai/cli@latest -- notis tools link <toolkit>`
 

package/config/notis_app_boundary_rules.json

@@ -0,0 +1,50 @@
+{
+  "javascript": [
+    {
+      "pattern": "window\\.__NOTIS_RUNTIME__",
+      "message": "window.__NOTIS_RUNTIME__ is forbidden; rely on the portal-injected NotisProvider runtime."
+    },
+    {
+      "pattern": "document\\.(?:body|head|documentElement)\\b",
+      "message": "document.body, document.head, and document.documentElement are forbidden; apps must stay inside the app surface."
+    },
+    {
+      "pattern": "document\\.(?:querySelector|querySelectorAll|getElementById|getElementsByClassName|getElementsByTagName)\\s*\\(\\s*(['\"`])[^\\n]*\\[data-notis-",
+      "message": "querying portal-owned [data-notis-*] hooks is forbidden."
+    },
+    {
+      "pattern": "createPortal\\s*\\(",
+      "message": "React portals are unsupported in Notis apps until a shadow-safe overlay contract exists."
+    },
+    {
+      "pattern": "@radix-ui/react-portal",
+      "message": "@radix-ui/react-portal is unsupported in Notis apps until a shadow-safe overlay contract exists."
+    },
+    {
+      "pattern": "PortalPrimitive",
+      "message": "Radix portal primitives are unsupported in Notis apps until a shadow-safe overlay contract exists."
+    }
+  ],
+  "css": [
+    {
+      "pattern": ":root\\b",
+      "message": ":root selectors are forbidden; styles must stay inside the app surface."
+    },
+    {
+      "pattern": "(^|[\\s,>+~])html(?=[\\s.#[:{>+~,]|$)",
+      "message": "html selectors are forbidden; styles must stay inside the app surface."
+    },
+    {
+      "pattern": "(^|[\\s,>+~])body(?=[\\s.#[:{>+~,]|$)",
+      "message": "body selectors are forbidden; styles must stay inside the app surface."
+    },
+    {
+      "pattern": "\\[data-notis-(?!app-root\\b)[^\\]]*\\]",
+      "message": "portal-owned [data-notis-*] selectors are forbidden. Use [data-notis-app-root] only for the app surface itself."
+    },
+    {
+      "pattern": "\\[data-sidebar(?:=[^\\]]+)?\\]",
+      "message": "portal sidebar selectors are forbidden."
+    }
+  ]
+}

package/dist/scaffolds/notis-database/app/page.tsx

@@ -224,13 +224,13 @@ type ActiveTab = 'properties' | 'relations' | 'documents';
 
 export default function CatalogPage() {
   const listDatabases = useTool<ListDatabasesArgs, ListDatabasesResult>(
-    'notis-default-list_databases',
+    'LOCAL_NOTIS_DATABASE_LIST_DATABASES',
   );
   const getDatabase = useTool<GetDatabaseArgs, GetDatabaseResult>(
-    'notis-default-get_database',
+    'LOCAL_NOTIS_DATABASE_GET_DATABASE',
   );
   const queryDatabase = useTool<QueryDatabaseArgs, QueryDatabaseResult>(
-    'notis-default-query',
+    'LOCAL_NOTIS_DATABASE_QUERY',
   );
 
   const [rows, setRows] = useState<DatabaseCatalogRow[]>([]);

package/dist/scaffolds/notis-database/notis.config.ts

@@ -20,8 +20,8 @@ export default defineNotisApp({
     },
   ],
   tools: [
-    'notis-default-list_databases',
-    'notis-default-get_database',
-    'notis-default-query',
+    'LOCAL_NOTIS_DATABASE_LIST_DATABASES',
+    'LOCAL_NOTIS_DATABASE_GET_DATABASE',
+    'LOCAL_NOTIS_DATABASE_QUERY',
   ],
 });

package/dist/scaffolds/notis-database/src/mock-runtime.ts

@@ -505,21 +505,21 @@ export function installMockRuntime(): NotisRuntime {
     },
     context: {},
     listTools: async () => [
-      { name: 'notis-default-list_databases', inputSchema: { type: 'object', properties: {} } },
-      { name: 'notis-default-get_database', inputSchema: { type: 'object', properties: {} } },
-      { name: 'notis-default-query', inputSchema: { type: 'object', properties: {} } },
+      { name: 'LOCAL_NOTIS_DATABASE_LIST_DATABASES', inputSchema: { type: 'object', properties: {} } },
+      { name: 'LOCAL_NOTIS_DATABASE_GET_DATABASE', inputSchema: { type: 'object', properties: {} } },
+      { name: 'LOCAL_NOTIS_DATABASE_QUERY', inputSchema: { type: 'object', properties: {} } },
     ],
     callTool: async <TResult = unknown>(
       name: string,
       args?: Record<string, unknown>,
     ): Promise<TResult> => {
-      if (name === 'notis-default-list_databases') {
+      if (name === 'LOCAL_NOTIS_DATABASE_LIST_DATABASES') {
         return {
           databases: SEED.map((s) => s.catalog),
           total_count: SEED.length,
         } as TResult;
       }
-      if (name === 'notis-default-get_database') {
+      if (name === 'LOCAL_NOTIS_DATABASE_GET_DATABASE') {
         const request = args ?? {};
         const id = typeof request.database_id === 'string' ? request.database_id : null;
         const slug = typeof request.database_slug === 'string' ? request.database_slug : null;
@@ -531,7 +531,7 @@ export function installMockRuntime(): NotisRuntime {
         }
         return { database: match.detail } as TResult;
       }
-      if (name === 'notis-default-query') {
+      if (name === 'LOCAL_NOTIS_DATABASE_QUERY') {
         const request = args ?? {};
         const slug = typeof request.database_slug === 'string' ? request.database_slug : null;
         const match = SEED.find((s) => slug && s.detail.slug === slug);

package/dist/scaffolds/notis-notes/app/page.tsx

@@ -358,7 +358,7 @@ function normalizeCollectionItem(value: unknown): CollectionItemContext | null {
 }
 
 function useNoteSchema(databaseSlug: string) {
-  const getDatabase = useTool<GetDatabaseArgs, GetDatabaseResult>('notis-default-get_database');
+  const getDatabase = useTool<GetDatabaseArgs, GetDatabaseResult>('LOCAL_NOTIS_DATABASE_GET_DATABASE');
   const [properties, setProperties] = useState<DatabaseProperty[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<Error | null>(null);
@@ -399,7 +399,7 @@ function useNoteSchema(databaseSlug: string) {
 }
 
 function useQueryDocuments(databaseSlug: string, options: { filter?: QueryFilter; pageSize?: number; offset?: number } = {}) {
-  const queryTool = useTool<QueryDatabaseArgs, QueryDatabaseResult>('notis-default-query');
+  const queryTool = useTool<QueryDatabaseArgs, QueryDatabaseResult>('LOCAL_NOTIS_DATABASE_QUERY');
   const [documents, setDocuments] = useState<DocumentRecord[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<Error | null>(null);
@@ -1061,7 +1061,7 @@ export default function NotesPage() {
   const { app, route, context } = useNotis();
   const navigation = useNotisNavigation();
   const { request } = useBackend();
-  const upsertNote = useTool<UpsertNoteArgs, UpsertNoteResult>('notis-default-upsert_notes');
+  const upsertNote = useTool<UpsertNoteArgs, UpsertNoteResult>('LOCAL_NOTIS_DATABASE_UPSERT_NOTES');
 
   const [activeTab, setActiveTab] = useState<TabKey>('gallery');
   const [activeDateProperty, setActiveDateProperty] = useState('');

package/dist/scaffolds/notis-notes/notis.config.ts

@@ -29,8 +29,8 @@ export default defineNotisApp({
     },
   ],
   tools: [
-    'notis-default-query',
-    'notis-default-get_database',
-    'notis-default-upsert_notes',
+    'LOCAL_NOTIS_DATABASE_QUERY',
+    'LOCAL_NOTIS_DATABASE_GET_DATABASE',
+    'LOCAL_NOTIS_DATABASE_UPSERT_NOTES',
   ],
 });

package/dist/scaffolds/notis-random/lib/notis-tools.ts

@@ -37,7 +37,7 @@ type UpsertRollResult = {
 };
 
 export function useRollDocuments(pageSize?: number) {
-  const queryRolls = useTool<QueryRollsArgs, QueryRollsResult>('notis-default-query');
+  const queryRolls = useTool<QueryRollsArgs, QueryRollsResult>('LOCAL_NOTIS_DATABASE_QUERY');
   const [documents, setDocuments] = useState<RollDocument[]>([]);
   const [error, setError] = useState<Error | null>(null);
   const [fetchKey, setFetchKey] = useState(0);
@@ -80,7 +80,7 @@ export function useRollDocuments(pageSize?: number) {
 }
 
 export function usePersistRoll() {
-  const upsertRoll = useTool<UpsertRollArgs, UpsertRollResult>('notis-default-upsert_rolls');
+  const upsertRoll = useTool<UpsertRollArgs, UpsertRollResult>('LOCAL_NOTIS_DATABASE_UPSERT_ROLLS');
 
   const persist = useCallback(
     async (roll: Roll) => {

package/dist/scaffolds/notis-random/notis.config.ts

@@ -37,7 +37,7 @@ export default defineNotisApp({
   ],
 
   tools: [
-    'notis-default-query',
-    'notis-default-upsert_rolls',
+    'LOCAL_NOTIS_DATABASE_QUERY',
+    'LOCAL_NOTIS_DATABASE_UPSERT_ROLLS',
   ],
 });

package/dist/scaffolds/notis-random/src/mock-runtime.ts

@@ -34,16 +34,16 @@ export function installMockRuntime(initialRoute: 'home' | 'history' = 'home'): N
 
     listTools: async () => [
       {
-        name: 'notis-default-query',
+        name: 'LOCAL_NOTIS_DATABASE_QUERY',
         inputSchema: { type: 'object', properties: { database_slug: { type: 'string' } } },
       },
       {
-        name: 'notis-default-upsert_rolls',
+        name: 'LOCAL_NOTIS_DATABASE_UPSERT_ROLLS',
         inputSchema: { type: 'object', properties: {} },
       },
     ],
     callTool: async <TResult = unknown>(name: string, args?: Record<string, unknown>): Promise<TResult> => {
-      if (name === 'notis-default-query') {
+      if (name === 'LOCAL_NOTIS_DATABASE_QUERY') {
         const request = args ?? {};
         const databaseSlug = typeof request.database_slug === 'string' ? request.database_slug : 'rolls';
         const query = request.query && typeof request.query === 'object'
@@ -56,7 +56,7 @@ export function installMockRuntime(initialRoute: 'home' | 'history' = 'home'): N
         return { documents: typeof pageSize === 'number' ? sliced.slice(0, pageSize) : sliced } as TResult;
       }
 
-      if (name === 'notis-default-upsert_rolls') {
+      if (name === 'LOCAL_NOTIS_DATABASE_UPSERT_ROLLS') {
         const request = args ?? {};
         const docs = STATE.rolls ?? [];
         const now = new Date().toISOString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notis_ai/cli",
-  "version": "0.2.0-beta.48.1",
+  "version": "0.2.0-beta.76.1",
   "description": "Agent-first Notis CLI for apps and generic tool execution",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "bin/",
+    "config/",
     "dist/",
     "src/",
     "skills/",

package/skills/notis-apps/SKILL.md

@@ -138,7 +138,7 @@ export default defineNotisApp({
       default: true,
     },
   ],
-  tools: ['notis-default-query', 'notis-default-upsert_tasks'],
+  tools: ['LOCAL_NOTIS_DATABASE_QUERY', 'LOCAL_NOTIS_DATABASE_UPSERT_TASKS'],
 });
 ```
 
@@ -149,7 +149,7 @@ Use SDK hooks for data and tool access:
 ```tsx
 import { useTool } from '@notis/sdk';
 
-const query = useTool('notis-default-query');
+const query = useTool('LOCAL_NOTIS_DATABASE_QUERY');
 ```
 
 Do not fetch Notis backend endpoints directly from app code unless the SDK explicitly requires it. The Portal provides authentication, runtime context, and route rendering.

package/skills/notis-cli/SKILL.md

@@ -155,7 +155,7 @@ This is the main escape hatch for:
 
 Typical toolkit namespaces include:
 
-- `notis-default` for native Notis tools
+- `notis` for native Notis tools
 - `composio-*` for Composio-backed integrations
 - `mcp-*` for MCP-backed tools
 
@@ -178,22 +178,22 @@ npx --package @notis_ai/cli@latest -- notis tools search "list today's calendar
 Inspect a tool before execution:
 
 ```bash
-npx --package @notis_ai/cli@latest -- notis tools describe composio-googlecalendar-default-list_events
-npx --package @notis_ai/cli@latest -- notis tools exec composio-googlecalendar-default-list_events --get-schema
+npx --package @notis_ai/cli@latest -- notis tools describe composio-googlecalendar-list_events
+npx --package @notis_ai/cli@latest -- notis tools exec composio-googlecalendar-list_events --get-schema
 ```
 
 Dry-run a tool call:
 
 ```bash
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --dry-run --arguments '{"database_slug":"tasks","query":{"page_size":10}}'
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-get_database --dry-run --arguments '{"database_slug":"tasks"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --dry-run --arguments '{"database_slug":"tasks"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --dry-run --arguments '{"database_id":"tasks-db-id","query":{"page_size":10}}'
 ```
 
 Execute a tool call:
 
 ```bash
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --arguments '{"database_slug":"tasks","query":{"page_size":10}}'
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-get_database --arguments '{"database_slug":"tasks"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --arguments '{"database_slug":"tasks"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments '{"database_id":"tasks-db-id","query":{"page_size":10}}'
 ```
 
 Connect a missing toolkit:
@@ -206,21 +206,23 @@ npx --package @notis_ai/cli@latest -- notis tools link github
 
 Native Notis databases are accessed through the generic tool workflow, not a first-class database command group. Use these canonical tool names:
 
-- `notis-default-list_databases` -- list databases accessible to the current profile
-- `notis-default-get_database` -- inspect read-only metadata and schema detail
-- `notis-default-query` -- query documents from a database
-- `notis-default-upsert_database` -- create or update a database schema
+- `LOCAL_NOTIS_DATABASE_LIST_DATABASES` -- list databases accessible to the current profile
+- `LOCAL_NOTIS_DATABASE_GET_DATABASE` -- inspect read-only metadata and schema detail
+- `LOCAL_NOTIS_DATABASE_QUERY` -- query documents from a database
+- `LOCAL_NOTIS_DATABASE_UPSERT_DATABASE` -- create or update a database schema
 
 Example workflow before building an app:
 
 ```bash
 npx --package @notis_ai/cli@latest -- notis tools search "list Notis databases"
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-list_databases --arguments '{}'
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-get_database --get-schema
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-get_database --arguments '{"database_slug":"social_media_calendar"}'
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --arguments '{"database_slug":"social_media_calendar","query":{"page_size":1}}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_LIST_DATABASES --arguments '{}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --get-schema
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --arguments '{"database_slug":"social_media_calendar"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments '{"database_id":"social-media-calendar-db-id","query":{"page_size":1}}'
 ```
 
+When `LOCAL_NOTIS_DATABASE_LIST_DATABASES` or `LOCAL_NOTIS_DATABASE_GET_DATABASE` returns a database ID, prefer `database_id` for `LOCAL_NOTIS_DATABASE_QUERY`; `database_slug` remains supported as a fallback.
+
 ## Supporting commands
 
 - `npx --package @notis_ai/cli@latest -- notis doctor` — verify CLI config, auth, and API reachability before relying on the CLI

package/skills/notis-query/cli.md

@@ -10,20 +10,20 @@ For CI, hosted agents, or internal scripts, pass a non-persisted token with `NOT
 
 ## Canonical database tools
 
-- `notis-default-list_databases` — list native databases.
-- `notis-default-get_database` — inspect one database schema.
-- `notis-default-query` — query native database documents.
-- `notis-default-upsert_database` — create or update database schema.
+- `LOCAL_NOTIS_DATABASE_LIST_DATABASES` — list native databases.
+- `LOCAL_NOTIS_DATABASE_GET_DATABASE` — inspect one database schema.
+- `LOCAL_NOTIS_DATABASE_QUERY` — query native database documents.
+- `LOCAL_NOTIS_DATABASE_UPSERT_DATABASE` — create or update database schema.
 
 ## Workflow
 
 ```bash
 npx --package @notis_ai/cli@latest -- notis tools search "list Notis databases"
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-list_databases --arguments '{}'
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-get_database --get-schema
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-get_database --arguments '{"database_slug":"tasks"}'
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --dry-run --arguments '{"database_slug":"tasks","query":{"page_size":10}}'
-npx --package @notis_ai/cli@latest -- notis tools exec notis-default-query --arguments '{"database_slug":"tasks","query":{"page_size":10}}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_LIST_DATABASES --arguments '{}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --get-schema
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --arguments '{"database_slug":"tasks"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --dry-run --arguments '{"database_slug":"tasks","query":{"page_size":10}}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments '{"database_slug":"tasks","query":{"page_size":10}}'
 ```
 
 ## Supporting command
@@ -37,4 +37,3 @@ When to use: Use this before relying on the CLI in automation or after changing
 Examples:
 - `npx --package @notis_ai/cli@latest -- notis doctor`
 - `npx --package @notis_ai/cli@latest -- notis doctor --json`
-

package/src/command-specs/apps.js

@@ -46,6 +46,7 @@ import {
 import { getAvailablePort } from '../runtime/ports.js';
 import { getCliMode } from '../runtime/cli-mode.js';
 import {
+  localNotisToolSlug,
   nextIdempotencyKey,
   runToolCommand,
   toolConflictToError,
@@ -54,8 +55,11 @@ import {
 const DEFAULT_DEV_PORT = 5173;
 const DEV_HEARTBEAT_INTERVAL_MS = 10_000;
 const CONFIG_FILENAMES = ['notis.config.ts', 'notis.config.js', 'notis.config.mjs'];
-const ENSURE_DEV_APP_INSTALLATION_TOOL = 'notis-default-ensure_dev_app_installation';
-const GET_APP_TOOL = 'notis-default-get_app';
+const ENSURE_DEV_APP_INSTALLATION_TOOL = 'LOCAL_NOTIS_ENSURE_DEV_APP_INSTALLATION';
+const GET_APP_TOOL = 'LOCAL_NOTIS_GET_APP';
+const LIST_APPS_TOOL = 'LOCAL_NOTIS_LIST_APPS';
+const CREATE_APP_TOOL = 'LOCAL_NOTIS_CREATE_APP';
+const SAVE_APP_FILES_TOOL = 'LOCAL_NOTIS_SAVE_APP_FILES';
 
 // ---------------------------------------------------------------------------
 // Formatters
@@ -192,9 +196,29 @@ function pickDefaultRouteSlug(manifest) {
   return firstWithSlug ? firstWithSlug.slug : null;
 }
 
-export function buildDevelopmentDesktopUrl(appHref = null) {
+const DESKTOP_DEEP_LINK_SCHEME_PATTERN = /^[a-z][a-z0-9-]*$/;
+
+export function resolveDevelopmentDesktopScheme(env = process.env) {
+  // Mirror the desktop app's own scheme resolution (electron main + forge config):
+  // local dev launches register `notis-dev`, while installed prod/beta builds claim
+  // `notis`. Hardcoding `notis` here is what made `apps dev` open the installed
+  // prod/beta app instead of the local dev app.
+  const scheme = (env.NOTIS_DESKTOP_DEEP_LINK_SCHEME || '').trim();
+  return DESKTOP_DEEP_LINK_SCHEME_PATTERN.test(scheme) ? scheme : 'notis';
+}
+
+export function buildDevelopmentDesktopUrl(appHref = null, scheme = 'notis') {
   const route = String(appHref || '/store').replace(/^\/+/, '');
-  return `notis://${route || 'store'}`;
+  const normalizedScheme = DESKTOP_DEEP_LINK_SCHEME_PATTERN.test(scheme) ? scheme : 'notis';
+  return `${normalizedScheme}://${route || 'store'}`;
+}
+
+export function shouldOpenDevelopmentTab(options = {}) {
+  // Commander stores the negatable `--no-open` flag as `options.open === false`;
+  // it never sets `options.noOpen`. Reading the non-existent `noOpen` key meant
+  // `--no-open` was silently ignored and `apps dev` always ran `open notis://…`,
+  // which macOS routes to the installed prod/beta desktop app.
+  return options.open !== false;
 }
 
 function buildAppHref({ appSlug, appId, manifest }) {
@@ -311,14 +335,14 @@ function assertHarnessResult(result, route, databaseSlugs) {
     const seen = (result.runtimeCalls || []).some(
       (call) =>
         call?.op === 'callTool' &&
-        call?.args?.name === 'notis-default-query' &&
+        localNotisToolSlug(call?.args?.name) === 'LOCAL_NOTIS_DATABASE_QUERY' &&
         call?.args?.arguments?.database_slug === databaseSlug,
     );
     if (!seen) {
       assertions.push({
         ok: false,
         code: 'missing_database_query',
-        message: `Route "${route.slug}" did not call notis-default-query for "${databaseSlug}".`,
+        message: `Route "${route.slug}" did not call LOCAL_NOTIS_DATABASE_QUERY for "${databaseSlug}".`,
         details: { databaseSlug },
       });
     }
@@ -447,7 +471,7 @@ function databaseMaterializationWarnings(apps) {
 async function assertDirectDeployAccess(runtime, appId) {
   const result = await runToolCommand({
     runtime,
-    toolName: 'notis-default-list_apps',
+    toolName: LIST_APPS_TOOL,
   });
   const apps = result.payload.apps || [];
   const hasAccess = apps.some((app) => (app.app_id || app.id) === appId);
@@ -463,7 +487,7 @@ async function assertDirectDeployAccess(runtime, appId) {
 async function appsListHandler(ctx) {
   const result = await runToolCommand({
     runtime: ctx.runtime,
-    toolName: 'notis-default-list_apps',
+    toolName: LIST_APPS_TOOL,
   });
   const apps = result.payload.apps || [];
   return ctx.output.emitSuccess({
@@ -511,7 +535,7 @@ async function appsCreateHandler(ctx) {
   const idempotencyKey = nextIdempotencyKey(ctx.globalOptions);
   const result = await runToolCommand({
     runtime: ctx.runtime,
-    toolName: 'notis-default-create_app',
+    toolName: CREATE_APP_TOOL,
     arguments_: {
       name: ctx.args.name,
       description: appConfig?.description || undefined,
@@ -634,7 +658,10 @@ async function appsDevHandler(ctx) {
       }),
     };
   });
-  const developmentTabUrl = buildDevelopmentDesktopUrl(apps[0]?.appHref);
+  const developmentTabUrl = buildDevelopmentDesktopUrl(
+    apps[0]?.appHref,
+    resolveDevelopmentDesktopScheme(),
+  );
   const warnings = databaseMaterializationWarnings(apps);
 
   const devServer = await startAppDevServer({
@@ -710,7 +737,7 @@ async function appsDevHandler(ctx) {
     ].join('\n'),
   });
 
-  if (!ctx.options.noOpen) {
+  if (shouldOpenDevelopmentTab(ctx.options)) {
     openInBrowser(developmentTabUrl);
   }
 
@@ -1073,7 +1100,7 @@ async function appsDeployHandler(ctx) {
   try {
     result = await runToolCommand({
       runtime: ctx.runtime,
-      toolName: 'notis-default-save_app_files',
+      toolName: SAVE_APP_FILES_TOOL,
       arguments_: {
         app_id: appId,
         files,
@@ -1185,7 +1212,7 @@ export const appsCommandSpecs = [
     examples: ['notis apps list', 'notis apps list --json'],
     mutates: false,
     idempotent: true,
-    backend_call: { type: 'tool', name: 'notis-default-list_apps' },
+    backend_call: { type: 'tool', name: LIST_APPS_TOOL },
     handler: appsListHandler,
   },
   {
@@ -1242,7 +1269,7 @@ export const appsCommandSpecs = [
     ],
     mutates: true,
     idempotent: false,
-    backend_call: { type: 'tool', name: 'notis-default-create_app' },
+    backend_call: { type: 'tool', name: CREATE_APP_TOOL },
     handler: appsCreateHandler,
   },
   {
@@ -1376,7 +1403,7 @@ export const appsCommandSpecs = [
     examples: ['notis apps deploy', 'notis apps deploy --skip-build', 'notis apps deploy --app-id abc123', 'notis apps deploy --direct'],
     mutates: true,
     idempotent: true,
-    backend_call: { type: 'tool', name: 'notis-default-save_app_files' },
+    backend_call: { type: 'tool', name: SAVE_APP_FILES_TOOL },
     handler: appsDeployHandler,
   },
   {

package/src/command-specs/helpers.js

@@ -2,6 +2,34 @@ import { randomUUID } from 'node:crypto';
 import { CliError, EXIT_CODES, usageError } from '../runtime/errors.js';
 import { callTool, httpRequest } from '../runtime/transport.js';
 
+export const COMPOSIO_SEARCH_TOOLS = 'COMPOSIO_SEARCH_TOOLS';
+export const COMPOSIO_GET_TOOL_SCHEMAS = 'COMPOSIO_GET_TOOL_SCHEMAS';
+export const COMPOSIO_MULTI_EXECUTE_TOOL = 'COMPOSIO_MULTI_EXECUTE_TOOL';
+
+const NOTIS_DATABASE_CORE_NAMES = new Set([
+  'query',
+  'get_database',
+  'get_document',
+  'list_databases',
+  'upsert_database',
+]);
+
+function isNotisDatabaseCoreName(coreName) {
+  // Mirrors server is_database_tool_name: canonical database ops plus generated
+  // upsert_<db> tools. Database tools live in the NOTIS_DATABASE toolkit so their
+  // public slug carries the DATABASE segment.
+  return NOTIS_DATABASE_CORE_NAMES.has(coreName) || coreName.startsWith('upsert_');
+}
+
+export function localNotisToolSlug(toolName) {
+  if (typeof toolName !== 'string' || !toolName.startsWith('notis-')) {
+    return toolName;
+  }
+  const coreName = toolName.slice('notis-'.length);
+  const prefix = isNotisDatabaseCoreName(coreName) ? 'LOCAL_NOTIS_DATABASE_' : 'LOCAL_NOTIS_';
+  return `${prefix}${coreName.replace(/-/g, '_').toUpperCase()}`;
+}
+
 export function parseJson(value, label) {
   try {
     return JSON.parse(value);
@@ -65,13 +93,19 @@ export async function healthCheck(runtime) {
 }
 
 export async function fetchToolSchema(runtime, toolName) {
-  const canonicalHints = canonicalToolHints(toolName);
-  const payload = await fetchToolDiscovery(
+  const result = await runToolCommand({
     runtime,
-    canonicalHints.useCase,
-    canonicalHints.knownFields,
+    toolName: COMPOSIO_GET_TOOL_SCHEMAS,
+    arguments_: {
+      tool_slugs: [toolName],
+    },
+  });
+  const payload = result.payload || {};
+  const schema = (
+    payload.tool_schemas?.[toolName] ||
+    payload.schemas?.[toolName] ||
+    payload.tools?.find?.((tool) => tool?.tool_slug === toolName || tool?.name === toolName)
   );
-  const schema = payload.tool_schemas?.[toolName];
   if (!schema) {
     throw usageError(`Tool "${toolName}" not found.`);
   }
@@ -85,35 +119,6 @@ export async function fetchToolSchema(runtime, toolName) {
   };
 }
 
-function canonicalToolHints(toolName) {
-  const rawName = String(toolName || '').trim();
-  const parts = rawName.split('-').filter(Boolean);
-  if (parts.length < 3) {
-    return {
-      useCase: `Describe the ${rawName} tool schema`,
-      knownFields: `tool_name:${rawName}`,
-    };
-  }
-
-  const provider = parts[0];
-  const action = parts[parts.length - 1];
-  const toolkitParts = parts.slice(1, -1);
-  const toolkit = [provider, ...toolkitParts].join('-');
-  const providerToolkit = toolkitParts[0] || '';
-  const knownFields = [
-    `tool_name:${rawName}`,
-    `provider:${provider}`,
-    `toolkit:${toolkit}`,
-    providerToolkit ? `toolkit_slug:${providerToolkit}` : null,
-    `action:${action}`,
-  ].filter(Boolean).join(' ');
-
-  return {
-    useCase: `Describe the ${action} schema for ${toolkit}`,
-    knownFields,
-  };
-}
-
 export async function fetchToolDiscovery(runtime, useCase, knownFields = '') {
   const query = { use_case: useCase };
   if (knownFields) {
@@ -121,7 +126,7 @@ export async function fetchToolDiscovery(runtime, useCase, knownFields = '') {
   }
   const result = await runToolCommand({
     runtime,
-    toolName: 'notis_find_tools',
+    toolName: COMPOSIO_SEARCH_TOOLS,
     arguments_: {
       queries: [query],
     },

package/src/command-specs/meta.js

@@ -1,4 +1,4 @@
-import { healthCheck, probeAuth } from './helpers.js';
+import { COMPOSIO_SEARCH_TOOLS, healthCheck, probeAuth } from './helpers.js';
 import { findCommandSpec, formatDescribe } from '../runtime/help.js';
 
 async function doctorHandler(ctx) {
@@ -118,7 +118,7 @@ export const metaCommandSpecs = [
     mutates: false,
     idempotent: true,
     related_commands: ['notis doctor'],
-    backend_call: { type: 'tool', name: 'notis_find_tools' },
+    backend_call: { type: 'tool', name: COMPOSIO_SEARCH_TOOLS },
     handler: whoamiHandler,
   },
   {

package/src/command-specs/tools.js

@@ -3,9 +3,13 @@ import { createHash } from 'node:crypto';
 import { basename } from 'node:path';
 import { usageError } from '../runtime/errors.js';
 import {
+  COMPOSIO_GET_TOOL_SCHEMAS,
+  COMPOSIO_MULTI_EXECUTE_TOOL,
+  COMPOSIO_SEARCH_TOOLS,
   fetchToolDiscovery,
   fetchToolkits,
   fetchToolSchema,
+  localNotisToolSlug,
   nextIdempotencyKey,
   parseJson,
   parseMaybeJson,
@@ -37,10 +41,10 @@ async function resolveJsonInput(value, label) {
 
 const LONG_RUNNING_TOOL_TIMEOUT_MS = 600000;
 const LONG_RUNNING_TOOL_NAMES = new Set([
-  'notis-default-generate_image_openai',
-  'notis-default-edit_image_openai',
-  'notis-default-generate_image_gemini',
-  'notis-default-edit_image_gemini',
+  'LOCAL_NOTIS_GENERATE_IMAGE_OPENAI',
+  'LOCAL_NOTIS_EDIT_IMAGE_OPENAI',
+  'LOCAL_NOTIS_GENERATE_IMAGE_GEMINI',
+  'LOCAL_NOTIS_EDIT_IMAGE_GEMINI',
 ]);
 
 const EXTENSION_CONTENT_TYPES = new Map([
@@ -128,7 +132,7 @@ async function parseFileBindings(rawFileOptions) {
 
 function ensureLongRunningToolTimeout(ctx, toolNames) {
   const names = Array.isArray(toolNames) ? toolNames : [toolNames];
-  if (!names.some((name) => LONG_RUNNING_TOOL_NAMES.has(name))) {
+  if (!names.some((name) => LONG_RUNNING_TOOL_NAMES.has(localNotisToolSlug(name)))) {
     return;
   }
   ctx.runtime.timeoutMs = Math.max(ctx.runtime.timeoutMs || 0, LONG_RUNNING_TOOL_TIMEOUT_MS);
@@ -206,32 +210,34 @@ async function toolsSearchHandler(ctx) {
 }
 
 async function toolsDescribeHandler(ctx) {
-  const match = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
+  const requestedToolName = localNotisToolSlug(ctx.args.toolName);
+  const match = await fetchToolSchema(ctx.runtime, requestedToolName);
 
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
     data: { tool: match },
-    humanSummary: `Described tool ${ctx.args.toolName}`,
+    humanSummary: `Described tool ${requestedToolName}`,
     hints: [
-      { command: `notis tools exec ${ctx.args.toolName} --dry-run --arguments '{}'`, reason: 'Validate arguments first' },
-      { command: `notis tools exec ${ctx.args.toolName} --arguments '{}'`, reason: 'Execute this tool' },
+      { command: `notis tools exec ${requestedToolName} --dry-run --arguments '{}'`, reason: 'Validate arguments first' },
+      { command: `notis tools exec ${requestedToolName} --arguments '{}'`, reason: 'Execute this tool' },
     ],
     renderHuman: () => JSON.stringify(match, null, 2),
   });
 }
 
 async function toolsExecHandler(ctx) {
-  ensureLongRunningToolTimeout(ctx, ctx.args.toolName);
+  const requestedToolName = localNotisToolSlug(ctx.args.toolName);
+  ensureLongRunningToolTimeout(ctx, requestedToolName);
   const fileBindings = await parseFileBindings(ctx.options.file);
 
   if (ctx.options.getSchema) {
-    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
+    const tool = await fetchToolSchema(ctx.runtime, requestedToolName);
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
       data: { tool },
-      humanSummary: `Schema for ${ctx.args.toolName}`,
+      humanSummary: `Schema for ${requestedToolName}`,
       hints: [
-        { command: `notis tools exec ${ctx.args.toolName} --dry-run --arguments '{}'`, reason: 'Validate arguments before executing' },
+        { command: `notis tools exec ${requestedToolName} --dry-run --arguments '{}'`, reason: 'Validate arguments before executing' },
       ],
       renderHuman: () => JSON.stringify(tool, null, 2),
     });
@@ -246,16 +252,16 @@ async function toolsExecHandler(ctx) {
     if (fileBindings.length) {
       throw usageError('--file is only supported when executing a tool, not with --dry-run');
     }
-    const tool = await fetchToolSchema(ctx.runtime, ctx.args.toolName);
+    const tool = await fetchToolSchema(ctx.runtime, requestedToolName);
     const errors = validateArguments(tool.parameters, args);
 
     if (errors.length) {
       return ctx.output.emitSuccess({
         command: ctx.spec.command_path.join(' '),
-        data: { valid: false, errors, tool: ctx.args.toolName },
+        data: { valid: false, errors, tool: requestedToolName },
         humanSummary: `Dry run failed: ${errors.length} validation error(s)`,
         hints: [
-          { command: `notis tools exec ${ctx.args.toolName} --get-schema`, reason: 'Review the full parameter schema' },
+          { command: `notis tools exec ${requestedToolName} --get-schema`, reason: 'Review the full parameter schema' },
         ],
         renderHuman: () => errors.map((e) => `  - ${e}`).join('\n'),
       });
@@ -263,10 +269,10 @@ async function toolsExecHandler(ctx) {
 
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
-      data: { valid: true, tool: ctx.args.toolName, arguments: args },
-      humanSummary: `Dry run passed for ${ctx.args.toolName}`,
+      data: { valid: true, tool: requestedToolName, arguments: args },
+      humanSummary: `Dry run passed for ${requestedToolName}`,
       hints: [
-        { command: `notis tools exec ${ctx.args.toolName} --arguments '${JSON.stringify(args)}'`, reason: 'Execute with these arguments' },
+        { command: `notis tools exec ${requestedToolName} --arguments '${JSON.stringify(args)}'`, reason: 'Execute with these arguments' },
       ],
     });
   }
@@ -275,10 +281,9 @@ async function toolsExecHandler(ctx) {
 
   const result = await runToolCommand({
     runtime: ctx.runtime,
-    toolName: 'notis_execute_tool',
+    toolName: COMPOSIO_MULTI_EXECUTE_TOOL,
     arguments_: {
-      tool_name: ctx.args.toolName,
-      arguments: args,
+      tools: [{ tool_slug: requestedToolName, arguments: args }],
     },
     mutating: true,
     idempotencyKey,
@@ -288,7 +293,7 @@ async function toolsExecHandler(ctx) {
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
     data: result.payload,
-    humanSummary: `Executed tool ${ctx.args.toolName}`,
+    humanSummary: `Executed tool ${requestedToolName}`,
     meta: { mutating: true, idempotency_key: idempotencyKey },
     renderHuman: () => JSON.stringify(result.payload, null, 2),
   });
@@ -309,16 +314,15 @@ async function toolsExecParallelHandler(ctx) {
       throw usageError(`calls[${i}] missing required "tool_name" string`);
     }
   }
-  ensureLongRunningToolTimeout(ctx, calls.map((call) => call.tool_name));
+  ensureLongRunningToolTimeout(ctx, calls.map((call) => localNotisToolSlug(call.tool_name)));
 
   const data = await Promise.all(
     calls.map((call) =>
       runToolCommand({
         runtime: ctx.runtime,
-        toolName: 'notis_execute_tool',
+        toolName: COMPOSIO_MULTI_EXECUTE_TOOL,
         arguments_: {
-          tool_name: call.tool_name,
-          arguments: call.arguments || {},
+          tools: [{ tool_slug: localNotisToolSlug(call.tool_name), arguments: call.arguments || {} }],
         },
         mutating: true,
         idempotencyKey: nextIdempotencyKey(ctx.globalOptions),
@@ -385,11 +389,11 @@ export const toolsCommandSpecs = [
     when_to_use: 'Use this to inspect connection state before searching or executing generic tools.',
     args_schema: { arguments: [], options: [] },
     examples: ['notis tools toolkits', 'notis tools toolkits --json'],
-    output_schema: 'Returns toolkit_connection_statuses from notis_find_tools, rendered as toolkit rows.',
+    output_schema: 'Returns toolkit_connection_statuses from COMPOSIO_SEARCH_TOOLS, rendered as toolkit rows.',
     mutates: false,
     idempotent: true,
     related_commands: ['notis tools search <query>', 'notis tools describe <tool-name>'],
-    backend_call: { type: 'tool', name: 'notis_find_tools' },
+    backend_call: { type: 'tool', name: COMPOSIO_SEARCH_TOOLS },
     handler: toolsToolkitsHandler,
   },
   {
@@ -401,11 +405,11 @@ export const toolsCommandSpecs = [
       options: [{ flags: '--known-fields <text>', key: 'knownFields', description: 'Optional known field hints, such as channel_name:general or user_email:a@example.com.' }],
     },
     examples: ['notis tools search "send an email"', 'notis tools search "post on LinkedIn" --known-fields "platform:linkedin"'],
-    output_schema: 'Returns the full notis_find_tools response. Human output renders canonical names, connection status, and schema availability.',
+    output_schema: 'Returns the full COMPOSIO_SEARCH_TOOLS response. Human output renders canonical names, connection status, and schema availability.',
     mutates: false,
     idempotent: true,
     related_commands: ['notis tools toolkits', 'notis tools exec <tool-name>'],
-    backend_call: { type: 'tool', name: 'notis_find_tools' },
+    backend_call: { type: 'tool', name: COMPOSIO_SEARCH_TOOLS },
     handler: toolsSearchHandler,
   },
   {
@@ -416,12 +420,12 @@ export const toolsCommandSpecs = [
       arguments: [{ token: '<tool-name>', description: 'Exact tool name to locate and describe.' }],
       options: [],
     },
-    examples: ['notis tools describe composio-gmail-default-send_email', 'notis tools describe notis-default-query'],
+    examples: ['notis tools describe composio-gmail-send_email', 'notis tools describe LOCAL_NOTIS_DATABASE_QUERY'],
     output_schema: 'Returns one tool descriptor with name, description, and parameters.',
     mutates: false,
     idempotent: true,
     related_commands: ['notis tools search <query>', 'notis tools exec <tool-name>'],
-    backend_call: { type: 'tool', name: 'notis_find_tools' },
+    backend_call: { type: 'tool', name: COMPOSIO_GET_TOOL_SCHEMAS },
     handler: toolsDescribeHandler,
   },
   {
@@ -438,19 +442,19 @@ export const toolsCommandSpecs = [
       ],
     },
     examples: [
-      'notis tools exec notis-default-query --arguments \'{"database_slug":"tasks","query":{}}\'',
-      'notis tools exec notis-default-get_database --arguments \'{"database_slug":"tasks"}\'',
-      'notis tools exec notis-default-query --get-schema',
-      'notis tools exec notis-default-query --dry-run --arguments \'{"database_slug":"tasks","query":{}}\'',
-      'notis tools exec notis-default-query --arguments @query.json',
-      'notis tools exec notis-default-query --arguments - < query.json',
-      'notis tools exec composio-dropbox-default-upload_file --arguments \'{"path":"/target/in/dropbox.pdf"}\' --file content=./Invoice.pdf',
+      'notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments \'{"database_slug":"tasks","query":{}}\'',
+      'notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --arguments \'{"database_slug":"tasks"}\'',
+      'notis tools exec LOCAL_NOTIS_DATABASE_QUERY --get-schema',
+      'notis tools exec LOCAL_NOTIS_DATABASE_QUERY --dry-run --arguments \'{"database_slug":"tasks","query":{}}\'',
+      'notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments @query.json',
+      'notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments - < query.json',
+      'notis tools exec composio-dropbox-upload_file --arguments \'{"path":"/target/in/dropbox.pdf"}\' --file content=./Invoice.pdf',
     ],
     output_schema: 'Returns the raw tool execution payload.',
     mutates: true,
     idempotent: true,
     related_commands: ['notis tools search <query>', 'notis tools describe <tool-name>', 'notis tools exec-parallel <calls>'],
-    backend_call: { type: 'tool', name: 'notis_execute_tool' },
+    backend_call: { type: 'tool', name: COMPOSIO_MULTI_EXECUTE_TOOL },
     handler: toolsExecHandler,
   },
   {
@@ -466,13 +470,13 @@ export const toolsCommandSpecs = [
       ],
     },
     examples: [
-      'notis tools exec-parallel \'[{"tool_name":"notis-default-query","arguments":{"database_slug":"tasks","query":{}}},{"tool_name":"notis-default-list_databases","arguments":{}}]\'',
+      'notis tools exec-parallel \'[{"tool_name":"LOCAL_NOTIS_DATABASE_QUERY","arguments":{"database_slug":"tasks","query":{}}},{"tool_name":"LOCAL_NOTIS_DATABASE_LIST_DATABASES","arguments":{}}]\'',
     ],
     output_schema: 'Returns an array of results, one per tool call.',
     mutates: true,
     idempotent: true,
     related_commands: ['notis tools exec <tool-name>', 'notis tools search <query>'],
-    backend_call: { type: 'tool', name: 'notis_execute_tool' },
+    backend_call: { type: 'tool', name: COMPOSIO_MULTI_EXECUTE_TOOL },
     handler: toolsExecParallelHandler,
   },
   {

package/src/runtime/app-boundary-validator.js

@@ -4,10 +4,30 @@ import { fileURLToPath } from 'node:url';
 
 import { usageError } from './errors.js';
 
-const RULES_PATH = resolve(
-  dirname(fileURLToPath(import.meta.url)),
-  '../../../../server/config/notis_app_boundary_rules.json',
-);
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+
+// Candidate locations for the app boundary rules, in priority order:
+//  1. The monorepo server source (always fresh during local development).
+//  2. The copy bundled into the published package at build time (see
+//     scripts/copy-boundary-rules.js + package.json "files": config/). When the
+//     CLI is installed via npm, candidate 1 escapes the package and is absent,
+//     so the bundled copy is used. This is what was missing before: the package
+//     shipped only the escaping path and crashed with ENOENT on any command.
+export const RULES_PATH_CANDIDATES = [
+  resolve(moduleDir, '../../../../server/config/notis_app_boundary_rules.json'),
+  resolve(moduleDir, '../../config/notis_app_boundary_rules.json'),
+];
+
+export function resolveRulesPath() {
+  for (const candidate of RULES_PATH_CANDIDATES) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  // Fall back to the bundled-copy path so any error message points inside the
+  // package rather than at an escaping monorepo path.
+  return RULES_PATH_CANDIDATES[RULES_PATH_CANDIDATES.length - 1];
+}
 
 const SOURCE_FILE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.css', '.scss', '.sass', '.pcss']);
 const IGNORED_SOURCE_DIRS = new Set([
@@ -21,7 +41,7 @@ const IGNORED_SOURCE_DIRS = new Set([
 ]);
 
 function loadBoundaryRules() {
-  return JSON.parse(readFileSync(RULES_PATH, 'utf-8'));
+  return JSON.parse(readFileSync(resolveRulesPath(), 'utf-8'));
 }
 
 function compileRules(entries) {

package/src/runtime/profiles.js

@@ -212,15 +212,21 @@ export function resolveRuntimeProfile(globalOptions = {}, { requireAuth = true }
     });
   }
 
+  // An explicit NOTIS_JWT is a complete credential override: use it verbatim and do
+  // NOT attempt a stored-profile dev_portal token refresh (whose refresh_token may be
+  // stale or belong to a different session). Without this, a long-lived shell with an
+  // expired profile refresh_token fails every command with invalid_grant even though
+  // the supplied NOTIS_JWT is valid.
+  const usingEnvJwt = Boolean(process.env.NOTIS_JWT);
   return {
     config,
     profileName,
     apiBase,
     jwt,
-    authMode: profile.auth_mode,
-    refreshToken: profile.refresh_token,
-    accessExpiresAt: profile.access_expires_at,
-    refreshExpiresAt: profile.refresh_expires_at,
+    authMode: usingEnvJwt ? 'jwt' : profile.auth_mode,
+    refreshToken: usingEnvJwt ? undefined : profile.refresh_token,
+    accessExpiresAt: usingEnvJwt ? undefined : profile.access_expires_at,
+    refreshExpiresAt: usingEnvJwt ? undefined : profile.refresh_expires_at,
     agentMode,
     nonInteractive,
     outputMode,

package/template/app/page.tsx

@@ -25,7 +25,7 @@ type QueryItemsResult = {
 
 export default function HomePage() {
   const { app, ready } = useNotis();
-  const queryItems = useTool<QueryItemsArgs, QueryItemsResult>('notis-default-query');
+  const queryItems = useTool<QueryItemsArgs, QueryItemsResult>('LOCAL_NOTIS_DATABASE_QUERY');
   const [documents, setDocuments] = useState<ItemDocument[]>([]);
 
   useEffect(() => {

package/template/notis.config.ts

@@ -32,6 +32,6 @@ export default defineNotisApp({
   ],
 
   tools: [
-    'notis-default-query',
+    'LOCAL_NOTIS_DATABASE_QUERY',
   ],
 });

package/template/packages/sdk/src/hooks/useTool.ts

@@ -25,7 +25,7 @@ export interface UseToolResult<
  * Call a specific Notis tool by name.
  *
  * ```tsx
- * const { call, loading } = useTool('notis-default-web_search');
+ * const { call, loading } = useTool('LOCAL_NOTIS_WEB_SEARCH');
  * const result = await call({ query: 'latest news' });
  * ```
  */