@notis_ai/cli 0.2.0-beta.41.1 → 0.2.0-beta.57.1

package/README.md

@@ -179,9 +179,9 @@ Examples:
 
 ### `npx --package @notis_ai/cli@latest -- notis tools toolkits`
 
-List toolkit namespaces available to the active user.
+List toolkit namespaces and connection statuses available to the active user.
 
-When to use: Use this before searching or executing generic tools.
+When to use: Use this to inspect connection state before searching or executing generic tools.
 
 Examples:
 - `npx --package @notis_ai/cli@latest -- notis tools toolkits`
@@ -194,11 +194,11 @@ Search across toolkit namespaces using natural language.
 When to use: Use this when you need a generic capability that does not have a first-class CLI command.
 
 Options:
-- `--toolkits <csv-or-json>` — Optional subset of toolkit ids to search.
+- `--known-fields <text>` — Optional known field hints, such as channel_name:general or user_email:a@example.com.
 
 Examples:
 - `npx --package @notis_ai/cli@latest -- notis tools search "send an email"`
-- `npx --package @notis_ai/cli@latest -- notis tools search "update framer page" --toolkits mcp-framer`
+- `npx --package @notis_ai/cli@latest -- notis tools search "post on LinkedIn" --known-fields "platform:linkedin"`
 
 ### `npx --package @notis_ai/cli@latest -- notis tools describe <tool-name>`
 
@@ -206,12 +206,9 @@ Describe a generic tool by name.
 
 When to use: Use this when you know the tool name and want its parameter schema before execution.
 
-Options:
-- `--toolkits <csv-or-json>` — Optional subset of toolkit ids to search.
-
 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 --toolkits notis-default`
+- `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>`
 
@@ -224,16 +221,15 @@ Options:
 - `--file <argument-path=local-path>` — Upload a local file into a file-uploadable tool argument. Repeatable.
 - `--get-schema` — Display the tool parameter schema without executing.
 - `--dry-run` — Validate arguments against the tool schema without executing.
-- `--toolkits <csv-or-json>` — Optional toolkit namespace(s) to use when resolving the tool.
 
 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>`
 
@@ -245,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>`
 
@@ -272,7 +268,7 @@ Examples:
 
 ### `npx --package @notis_ai/cli@latest -- notis whoami`
 
-Display the active profile, user, and available toolkits.
+Display the active profile, user, and available toolkit connection statuses.
 
 When to use: Use this to quickly confirm which account and environment a command will target.
 

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.41.1",
+  "version": "0.2.0-beta.57.1",
   "description": "Agent-first Notis CLI for apps and generic tool execution",
   "type": "module",
   "bin": {

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

@@ -130,7 +130,7 @@ This is the main escape hatch for:
    - `npx --package @notis_ai/cli@latest -- notis tools toolkits`
 2. Search for the capability you need using natural language:
    - `npx --package @notis_ai/cli@latest -- notis tools search "<query>"`
-   - optionally narrow with `--toolkits <csv-or-json>`
+   - optionally add known field hints with `--known-fields "<key:value>"`
 3. If needed, inspect the exact tool and parameter schema:
    - `npx --package @notis_ai/cli@latest -- notis tools describe <tool-name>`
    - `npx --package @notis_ai/cli@latest -- notis tools exec <tool-name> --get-schema`
@@ -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_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_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_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_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_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_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_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);
@@ -17,23 +45,6 @@ export function parseMaybeJson(value, label) {
   return parseJson(value, label);
 }
 
-export function normalizeToolkits(value) {
-  if (!value) {
-    return [];
-  }
-  if (value.startsWith('[')) {
-    const parsed = parseJson(value, 'toolkits');
-    if (!Array.isArray(parsed)) {
-      throw usageError('toolkits JSON must be an array of toolkit strings');
-    }
-    return parsed;
-  }
-  return value
-    .split(',')
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
 export function nextIdempotencyKey(globalOptions) {
   return globalOptions.idempotencyKey || randomUUID();
 }
@@ -57,28 +68,19 @@ export async function runToolCommand({
 }
 
 export async function fetchToolkits(runtime) {
-  const result = await runToolCommand({
-    runtime,
-    toolName: 'notis_find_toolkits',
-  });
-  return result.payload.toolkits || [];
-}
-
-export async function resolveSearchToolkits(runtime, rawToolkits) {
-  const toolkits = normalizeToolkits(rawToolkits);
-  if (toolkits.length) {
-    return toolkits;
-  }
-  const availableToolkits = await fetchToolkits(runtime);
-  return availableToolkits.map((entry) => entry.id);
+  const payload = await fetchToolDiscovery(runtime, 'List available toolkit namespaces and connection statuses');
+  return (payload.toolkit_connection_statuses || []).map((entry) => ({
+    id: entry.toolkit,
+    provider: typeof entry.toolkit === 'string' ? entry.toolkit.split('-', 1)[0] : undefined,
+    description: entry.description || entry.status_message || entry.toolkit,
+    has_active_connection: Boolean(entry.has_active_connection),
+    status_message: entry.status_message || '',
+    connection_details: entry.connection_details || {},
+  }));
 }
 
 export async function probeAuth(runtime) {
-  const result = await runToolCommand({
-    runtime,
-    toolName: 'notis_find_toolkits',
-  });
-  return result.payload;
+  return fetchToolDiscovery(runtime, 'List available toolkit namespaces and connection statuses');
 }
 
 export async function healthCheck(runtime) {
@@ -90,22 +92,46 @@ export async function healthCheck(runtime) {
   });
 }
 
-export async function fetchToolSchema(runtime, toolName, rawToolkits) {
-  const toolkits = normalizeToolkits(rawToolkits);
+export async function fetchToolSchema(runtime, toolName) {
   const result = await runToolCommand({
     runtime,
-    toolName: 'notis_find_tools',
+    toolName: COMPOSIO_GET_TOOL_SCHEMAS,
     arguments_: {
-      query: toolName,
-      ...(toolkits.length ? { toolkits } : {}),
+      tool_slugs: [toolName],
     },
   });
-  const tools = result.payload.tools || [];
-  const match = tools.find((t) => t.name === toolName);
-  if (!match) {
+  const payload = result.payload || {};
+  const schema = (
+    payload.tool_schemas?.[toolName] ||
+    payload.schemas?.[toolName] ||
+    payload.tools?.find?.((tool) => tool?.tool_slug === toolName || tool?.name === toolName)
+  );
+  if (!schema) {
     throw usageError(`Tool "${toolName}" not found.`);
   }
-  return match;
+  return {
+    name: toolName,
+    toolkit_id: schema.toolkit,
+    description: schema.description || '',
+    parameters: schema.input_schema || { type: 'object', properties: {} },
+    output_schema: schema.output_schema || {},
+    schema_available: Boolean(schema.hasFullSchema),
+  };
+}
+
+export async function fetchToolDiscovery(runtime, useCase, knownFields = '') {
+  const query = { use_case: useCase };
+  if (knownFields) {
+    query.known_fields = knownFields;
+  }
+  const result = await runToolCommand({
+    runtime,
+    toolName: COMPOSIO_SEARCH_TOOLS,
+    arguments_: {
+      queries: [query],
+    },
+  });
+  return result.payload || {};
 }
 
 export function validateArguments(schema, args) {

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) {
@@ -21,7 +21,7 @@ async function doctorHandler(ctx) {
   if (ctx.runtime.jwt) {
     try {
       const payload = await probeAuth(ctx.runtime);
-      checks.tool_roundtrip = Array.isArray(payload.toolkits) ? 'ok' : 'error';
+      checks.tool_roundtrip = Array.isArray(payload.toolkit_connection_statuses) ? 'ok' : 'error';
     } catch {
       checks.tool_roundtrip = 'error';
     }
@@ -68,7 +68,7 @@ function decodeJwtUserId(jwt) {
 
 async function whoamiHandler(ctx) {
   const payload = await probeAuth(ctx.runtime);
-  const toolkits = payload.toolkits || [];
+  const toolkits = payload.toolkit_connection_statuses || [];
   const userId = decodeJwtUserId(ctx.runtime.jwt);
 
   return ctx.output.emitSuccess({
@@ -78,7 +78,7 @@ async function whoamiHandler(ctx) {
       api_base: ctx.runtime.apiBase,
       user_id: userId,
       toolkit_count: toolkits.length,
-      toolkits: toolkits.map((t) => t.id),
+      toolkits: toolkits.map((t) => t.toolkit),
       cli_version: ctx.runtime.cliVersion,
     },
     humanSummary: `Logged in as ${userId || 'unknown'} via profile "${ctx.runtime.profileName}"`,
@@ -91,7 +91,7 @@ async function whoamiHandler(ctx) {
         `Version:   ${ctx.runtime.cliVersion}`,
       ].join('\n'),
     hints: [
-      { command: 'notis tools toolkits', reason: 'List available toolkit namespaces' },
+      { command: 'notis tools toolkits', reason: 'List available toolkit namespaces and connection statuses' },
       { command: 'notis doctor', reason: 'Run a full health check' },
     ],
   });
@@ -110,7 +110,7 @@ async function describeHandler(ctx) {
 export const metaCommandSpecs = [
   {
     command_path: ['whoami'],
-    summary: 'Display the active profile, user, and available toolkits.',
+    summary: 'Display the active profile, user, and available toolkit connection statuses.',
     when_to_use: 'Use this to quickly confirm which account and environment a command will target.',
     args_schema: { arguments: [], options: [] },
     examples: ['notis whoami', 'notis whoami --json'],
@@ -118,7 +118,7 @@ export const metaCommandSpecs = [
     mutates: false,
     idempotent: true,
     related_commands: ['notis doctor'],
-    backend_call: { type: 'tool', name: 'notis_find_toolkits' },
+    backend_call: { type: 'tool', name: COMPOSIO_SEARCH_TOOLS },
     handler: whoamiHandler,
   },
   {

package/src/command-specs/tools.js

@@ -3,13 +3,16 @@ 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,
-  normalizeToolkits,
-  resolveSearchToolkits,
   runToolCommand,
   validateArguments,
 } from './helpers.js';
@@ -38,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([
@@ -129,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);
@@ -142,27 +145,55 @@ async function toolsToolkitsHandler(ctx) {
     data: { toolkits },
     humanSummary: `Found ${toolkits.length} toolkits`,
     hints: [
-      { command: 'notis tools search <query>', reason: 'Search for tools in these toolkits' },
+      { command: 'notis tools search <query>', reason: 'Search canonical tools and schemas' },
     ],
-    renderHuman: () => toolkits.map((entry) => `${entry.id}  ${entry.description}`).join('\n'),
+    renderHuman: () =>
+      toolkits
+        .map((entry) => {
+          const status = entry.has_active_connection ? 'connected' : 'needs auth';
+          return `${entry.id}  ${status}  ${entry.description}`;
+        })
+        .join('\n'),
   });
 }
 
+function discoveryToolRows(payload) {
+  const schemas = payload.tool_schemas || {};
+  const statuses = new Map(
+    (payload.toolkit_connection_statuses || [])
+      .filter((entry) => entry && typeof entry.toolkit === 'string')
+      .map((entry) => [entry.toolkit, entry])
+  );
+  const seen = new Set();
+  const rows = [];
+  for (const result of payload.results || []) {
+    for (const name of [...(result.primary_tool_slugs || []), ...(result.related_tool_slugs || [])]) {
+      if (!name || seen.has(name)) continue;
+      seen.add(name);
+      const schema = schemas[name] || {};
+      const toolkit = schema.toolkit || name.split('-').slice(0, -1).join('-');
+      const status = statuses.get(toolkit);
+      rows.push({
+        name,
+        toolkit,
+        description: schema.description || '',
+        schema_available: Boolean(schemas[name]),
+        connection_status: status
+          ? (status.has_active_connection ? 'connected' : 'needs auth')
+          : 'unknown',
+      });
+    }
+  }
+  return rows;
+}
+
 async function toolsSearchHandler(ctx) {
-  const toolkits = await resolveSearchToolkits(ctx.runtime, ctx.options.toolkits);
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_find_tools',
-    arguments_: {
-      query: ctx.args.query || undefined,
-      toolkits,
-    },
-  });
-  const tools = result.payload.tools || [];
+  const payload = await fetchToolDiscovery(ctx.runtime, ctx.args.query || 'Find tools', ctx.options.knownFields || '');
+  const tools = discoveryToolRows(payload);
   const firstTool = tools[0];
   return ctx.output.emitSuccess({
     command: ctx.spec.command_path.join(' '),
-    data: { toolkits, tools },
+    data: payload,
     humanSummary: `Found ${tools.length} tools`,
     hints: firstTool
       ? [
@@ -172,53 +203,41 @@ async function toolsSearchHandler(ctx) {
       : [],
     renderHuman: () =>
       tools
-        .map((tool) => `${tool.name}\n  ${tool.toolkit_id || 'unknown toolkit'}\n  ${tool.description || 'No description'}\n`)
+        .map((tool) => `${tool.name}\n  toolkit: ${tool.toolkit || 'unknown'} (${tool.connection_status})\n  schema: ${tool.schema_available ? 'available' : 'missing'}\n  ${tool.description || 'No description'}\n`)
         .join('\n')
         .trim(),
   });
 }
 
 async function toolsDescribeHandler(ctx) {
-  const toolkits = await resolveSearchToolkits(ctx.runtime, ctx.options.toolkits);
-  const result = await runToolCommand({
-    runtime: ctx.runtime,
-    toolName: 'notis_find_tools',
-    arguments_: {
-      query: ctx.args.toolName,
-      toolkits,
-    },
-  });
-  const tools = result.payload.tools || [];
-  const match = tools.find((tool) => tool.name === ctx.args.toolName);
-  if (!match) {
-    throw usageError(`Tool ${ctx.args.toolName} was not found in the selected toolkits.`);
-  }
+  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, toolkits },
-    humanSummary: `Described tool ${ctx.args.toolName}`,
+    data: { tool: match },
+    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 toolkits = normalizeToolkits(ctx.options.toolkits);
+  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, ctx.options.toolkits);
+    const tool = await fetchToolSchema(ctx.runtime, requestedToolName);
     return ctx.output.emitSuccess({
       command: ctx.spec.command_path.join(' '),
-      data: { tool, toolkits },
-      humanSummary: `Schema for ${ctx.args.toolName}`,
+      data: { tool },
+      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),
     });
@@ -233,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, ctx.options.toolkits);
+    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, toolkits },
+        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'),
       });
@@ -250,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, toolkits },
-      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' },
       ],
     });
   }
@@ -262,11 +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,
-      ...(toolkits.length ? { toolkits } : {}),
+      tools: [{ tool_slug: requestedToolName, arguments: args }],
     },
     mutating: true,
     idempotencyKey,
@@ -276,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),
   });
@@ -297,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),
@@ -369,15 +385,15 @@ async function toolsLinkHandler(ctx) {
 export const toolsCommandSpecs = [
   {
     command_path: ['tools', 'toolkits'],
-    summary: 'List toolkit namespaces available to the active user.',
-    when_to_use: 'Use this before searching or executing generic tools.',
+    summary: 'List toolkit namespaces and connection statuses available to the active user.',
+    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 available toolkit namespaces.',
+    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_toolkits' },
+    backend_call: { type: 'tool', name: COMPOSIO_SEARCH_TOOLS },
     handler: toolsToolkitsHandler,
   },
   {
@@ -386,14 +402,14 @@ export const toolsCommandSpecs = [
     when_to_use: 'Use this when you need a generic capability that does not have a first-class CLI command.',
     args_schema: {
       arguments: [{ token: '<query>', description: 'Natural language description of the tool you need.' }],
-      options: [{ flags: '--toolkits <csv-or-json>', description: 'Optional subset of toolkit ids to search.' }],
+      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 "update framer page" --toolkits mcp-framer'],
-    output_schema: 'Returns tool matches with descriptions and parameter schemas.',
+    examples: ['notis tools search "send an email"', 'notis tools search "post on LinkedIn" --known-fields "platform:linkedin"'],
+    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,
   },
   {
@@ -402,14 +418,14 @@ export const toolsCommandSpecs = [
     when_to_use: 'Use this when you know the tool name and want its parameter schema before execution.',
     args_schema: {
       arguments: [{ token: '<tool-name>', description: 'Exact tool name to locate and describe.' }],
-      options: [{ flags: '--toolkits <csv-or-json>', description: 'Optional subset of toolkit ids to search.' }],
+      options: [],
     },
-    examples: ['notis tools describe composio-gmail-default-send_email', 'notis tools describe notis-default-query --toolkits notis-default'],
+    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,
   },
   {
@@ -423,23 +439,22 @@ export const toolsCommandSpecs = [
         { flags: '--file <argument-path=local-path>', description: 'Upload a local file into a file-uploadable tool argument. Repeatable.', collect: true },
         { flags: '--get-schema', description: 'Display the tool parameter schema without executing.' },
         { flags: '--dry-run', description: 'Validate arguments against the tool schema without executing.' },
-        { flags: '--toolkits <csv-or-json>', description: 'Optional toolkit namespace(s) to use when resolving the tool.' },
       ],
     },
     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,
   },
   {
@@ -455,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/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/src/runtime/transport.js

@@ -9,33 +9,6 @@ import {
   saveConfig,
 } from './profiles.js';
 
-const META_TOOL_NAMES = new Set([
-  'notis_find_toolkits',
-  'notis_find_tools',
-  'notis_execute_tool',
-  'notis_find_additional_tools',
-]);
-
-function canonicalizeToolName(toolName) {
-  if (typeof toolName !== 'string' || !toolName.length) {
-    return toolName;
-  }
-
-  if (META_TOOL_NAMES.has(toolName) || toolName.startsWith('notis-default-')) {
-    return toolName;
-  }
-
-  if (toolName.startsWith('notis_')) {
-    return `notis-default-${toolName.slice('notis_'.length)}`;
-  }
-
-  if (toolName.includes('_notis_')) {
-    return `notis-default-${toolName.replace(/_notis_/g, '_')}`;
-  }
-
-  return toolName;
-}
-
 function escapeMultipartHeaderValue(value) {
   return String(value ?? '')
     .replace(/"/g, '%22')
@@ -397,7 +370,7 @@ export async function callTool({
 }) {
   const requestId = idempotencyKey || (runtime.mutating ? randomUUID() : null);
   const payload = {
-    tool_name: canonicalizeToolName(toolName),
+    tool_name: toolName,
     arguments: argumentsPayload,
     idempotency_key: requestId,
     cli_context: {

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' });
  * ```
  */