@notis_ai/cli 0.2.0-beta.179.1 → 0.2.0-beta.1792022492092.1

package/dist/base-skills/notis-apps/references/views.md

@@ -0,0 +1,145 @@
+# View authoring
+
+A view is the presentation of a Space. A record opens in a view; its database has
+one main view. Words in links describe the destination, while IDs choose it.
+Get links from write results or `LOCAL_NOTIS_FIND_VIEWS`, not by joining labels.
+
+## Start from the collection scaffold
+
+```bash
+notis spaces init "Notes" ./notes --database-key notes --path notes
+notis spaces build ./notes --space collection
+```
+
+`init` is local only. For an existing Space, pull its exact ID instead. Keep its
+lock and local source key; one build/deploy changes that selected Space only.
+A container has children but no page; page-only params/shows/memory belong on views.
+
+## A complete view declaration
+
+The linked `notes` resource below must already resolve to this installation's
+native database. Descriptions explain what a person or agent can do here.
+
+```ts
+import { defineSpace } from '@notis/sdk/config';
+
+export default defineSpace({
+  specVersion: 2,
+  name: 'Notes',
+  path: 'notes',
+  description: 'Browse notes and open one with its files.',
+  readableContext: 'The note parameter opens one note. The list shows all notes available through this Space.',
+  entry: './view.tsx',
+  resources: { notes: { kind: 'database', key: 'notes' } },
+  collection: { database: 'notes', titleProperty: 'title' },
+  params: {
+    note: { type: 'record', database: 'notes', main: true,
+      description: 'The note to open beside the list.' },
+  },
+  shows: { notes: { database: 'notes', where: {}, open: 'note' } },
+  memory: { markdown: true, attachments: true, screenshot: false, snapshots: [] },
+  actions: {
+    read: {
+      tool: 'LOCAL_NOTIS_DATABASE_QUERY',
+      inputs: { type: 'object', additionalProperties: false,
+        required: ['request'], properties: { request: {
+          type: 'object', additionalProperties: false,
+          required: ['filter', 'page_size', 'include_content'],
+          properties: {
+            filter: { type: 'object', additionalProperties: false,
+              required: ['field', 'op', 'value'], properties: {
+                field: { type: 'object', additionalProperties: false,
+                  required: ['column'], properties: { column: { const: 'record_key' } } },
+                op: { const: 'equals' }, value: { type: 'string', format: 'uuid' },
+              } },
+            page_size: { const: 1 }, include_content: { const: true },
+          },
+        } } },
+      arguments: { database_id: { $asset: 'notes' }, request: { $input: 'request' } },
+    },
+  },
+});
+```
+
+Use `useViewParams<typeof definition>()`, `useShown('notes')`, and
+`<DocumentPage recordKey={params.note}>` (the whole note page; use `DocumentEditor` only to embed a body
+inside a layout of your own; if `spaces build` reports no `DocumentPage` export, your CLI predates it: use
+`useNotisRuntime().ui?.DocumentPage` with a `DocumentEditor` fallback, see the SDK reference). Keep hooks unconditional; conditional
+record/list branches can be separate components. The SDK reference covers the
+components and exact navigation helpers. The saved `read` action is deliberately
+constrained to one native record for body/Site reads; `shows.notes` owns the
+Editor’s collection list. Keep both tied to the same declared resource.
+
+## Params and declared lists
+
+- Param types: `record`, `enum`, `text`, `number`, `date`, `boolean`. Each needs a
+  description. Enum values and defaults are typed; a required param has no default.
+- Record params name a declared database and have no default record. `main: true`
+  claims that database's main view. `slugProperty` is a title/number property used
+  for readable link text, not record identity.
+- `path` is descriptive lowercase words, up to four slash-separated segments;
+  do not put IDs, credentials or reserved product routes in it.
+- `shows` for native data is `{database, where, open?}`. `where` is the native filter
+  grammar and is what `useShown` executes, not commentary beside a different query.
+  `open` names a record param over the same database.
+- A project-scoped task list can use
+  `{field: {property: 'Project'}, op: 'contains', value: '{project}'}` with a declared
+  project record param. `{project.Status}` reads a property of that authorized record.
+- For connected-service content use `{about, services?}` and declared actions.
+  This descriptive form is not a native executable list; use `useAction` for reads.
+- Preserve the application's real semantics and option names. For the existing
+  Tasks migration, Inbox is **Project empty OR Status equals Inbox**. Keep imported
+  rows, statuses and creation defaults; add the Inbox option only if absent. Its
+  native filter is `{or: [{field: {property: 'Project'}, op: 'is_empty'},
+  {field: {property: 'Status'}, op: 'equals', value: 'Inbox'}]}`. Other applications
+  must use their own inspected schema rather than copying these labels blindly.
+
+## Create a database in the same release
+
+Replace an existing database reference with:
+
+```ts
+resources: {
+  notes: { kind: 'database', create: {
+    name: 'Notes',
+    schema: {
+      schema_version: 1, value_encoding_version: 1, coercion_version: 1,
+      title_property_id: 'title', property_order: ['title'],
+      properties: { title: { id: 'title', name: 'Name', kind: 'title',
+        storage_family: 'textish', description: '', order: 0, config: {} } },
+    },
+  } },
+},
+```
+
+The same view declares a record param over `notes` with `main: true`. Promotion
+creates the database, link, main view, optional fictional `starterRows` and source
+atomically; a later failure leaves none of them behind. Verification does not create
+it. `create` is creation-only: later schema edits use native database tools;
+`spaces pull` refreshes the declaration from the live schema.
+
+The separate native schema-tool creation route requires `links.add` and
+`main_view: {space_id, param}` in that linked Space. Until the Space next deploys
+that main param, record links open the Space and writes return `view_warning`.
+Inspect current tools for exact argument shapes; do not repeatedly insert rows
+because a pending main view cannot yet open one.
+
+## Rendering and memory
+
+Choose [memory](memory.md) deliberately. `chrome: 'hidden'` is for full-screen
+presentations; ordinary collection views keep Portal chrome.
+A Space whose published view hides chrome starts hidden from each person's sidebar;
+it stays reachable by link and search. Each person can turn on **Show hidden Spaces**
+in the sidebar's Spaces menu, then choose **Show in sidebar** in that Space's menu.
+Skill review Spaces stay out of the sidebar, even with **Show hidden Spaces** on:
+people open them from the Skill page's **Changes** list. A review a person already
+chose to show stays in their sidebar until they hide it.
+Optional `markdown: './markdown.ts'` names a module exporting a pure function of
+`{params, shown}`. Its output must represent this view, not make hidden writes.
+Use `<RenderChartData>` with the chart's actual rows so rendered Markdown contains
+precise labels and values as well as its image.
+
+Add synthetic action/list/body/record fixtures, then build and verify. Verification
+and live rendering share the read-only renderer; fixture success does not prove
+live permissions or data. After an authorized deploy, render the returned view link
+with `notis views render` and inspect both the Markdown and full-height screenshot.

package/dist/base-skills/notis-cli/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: notis-cli
-description: Use when agents should work through the Notis CLI, especially to develop Notis apps locally or to access Notis, Composio, or MCP tools they do not currently have loaded directly.
+description: Use when agents should work through the Notis CLI, especially to develop Notis Spaces locally or to access Notis, Composio, or MCP tools they do not currently have loaded directly.
 mcp_resource: true
-mcp_tool_patterns: []
-mcp_references: ["references/app-delivery.md", "references/tool-examples.md", "references/native-databases.md", "references/troubleshooting.md"]
+mcp_tool_patterns: ["LOCAL_NOTIS_GET_INTELLIGENCE_POLICY"]
+mcp_references: ["references/app-delivery.md", "references/tool-examples.md", "references/native-databases.md", "references/troubleshooting.md", "references/intelligence.md"]
 ---
 
 # Notis CLI Skill
@@ -12,13 +12,13 @@ Use this skill when the user wants work done through the Notis CLI.
 
 This skill covers two main CLI workflows:
 
-1. Developing Notis apps locally.
+1. Developing Notis Spaces (views, their source and linked Skills) locally.
 2. Accessing Notis, Composio, and MCP tools through the CLI.
 ## When to use this skill
 
 Activate this skill when:
 
-- the user wants to init, develop, build, verify, link, pull, or deploy a Notis app through the CLI
+- the user wants to init, pull, build, verify, preview, deploy or promote a Notis Space through the CLI
 - the current agent does not have the tool it needs in its direct tool list
 - the user wants direct MCP access through Notis
 - the user wants to use an integration-backed capability through Notis rather than a first-class local tool
@@ -28,7 +28,7 @@ Use the registry-resolved published npm package everywhere:
 
 - `npx --package @notis_ai/cli@latest -- notis ...`
 
-Always use this NPX command form so the agent runs the current published CLI. In hosted shells, the CLI is pre-authenticated through `NOTIS_JWT`. On a local machine the CLI holds its own OAuth grant: `notis login` authorizes one in the browser, and signing in to the Notis desktop app authorizes one automatically for that account. Either way the grant belongs to the CLI, which refreshes it without the desktop app running.
+Always use this NPX command form so the agent runs the current published CLI, with one exception: on the Notis Cloud Computer (home folder `/vercel/sandbox`) the CLI is preinstalled and kept current, so run `notis ...` there with the same arguments, and use the NPX form only if `notis` is not found. Parallel NPX runs reinstall the package and can break each other. In hosted shells, the CLI is pre-authenticated through `NOTIS_JWT`. On a local machine the CLI holds its own OAuth grant: `notis login` authorizes one in the browser, and signing in to the Notis desktop app authorizes one automatically for that account. Either way the grant belongs to the CLI, which refreshes it without the desktop app running.
 
 `@latest` is correct for every account, including beta ones. Each deployment reports which published build belongs to it, `notis login` pins that on the profile, and a later run that finds itself on the wrong build hands the invocation to the right one before doing anything. Never substitute a channel by hand: pinning `@beta` on a production profile is how a machine ends up running a build its API does not expect. `notis doctor` reports the active channel, and `NOTIS_CLI_AUTO_CHANNEL=0` turns the hand-off off for a run.
 
@@ -38,11 +38,13 @@ The CLI bundles this `notis-cli` base skill and refreshes its canonical copy und
 
 A profile is one account paired with one API endpoint. Profiles live side by side; switching between them never signs any of them out.
 
-- `npx --package @notis_ai/cli@latest -- notis profile list` — every profile on this machine, with its endpoint, user, and whether it is signed in. The active one is marked.
-- `npx --package @notis_ai/cli@latest -- notis profile use <name>` — change which account subsequent commands run as.
-- `npx --package @notis_ai/cli@latest -- notis --profile <name> <command>` — run a single command as another account without changing the active one.
-- `npx --package @notis_ai/cli@latest -- notis login --profile <name>` — add an account. The existing profiles keep their credentials.
-- `npx --package @notis_ai/cli@latest -- notis logout` — sign out of the active profile only; pass `--all-profiles` to clear every one.
+Notis Desktop signs the CLI in for every account saved in the app, one profile each. `default` keeps its name; each added account gets a profile named after its email with `@` turned into `-` (for example `flo-mindtheflo.com`), and Beta Desktop adds `-beta`. Switching accounts in Desktop never changes the active profile. Only the active profile's skills are linked into Claude Code, Codex and Cursor; every other account's skills sync into their own folder. Signing an account out of Desktop signs it out of the CLI on this computer and removes the profile and skills Desktop made for it. If that was the active profile, the CLI switches to the account Desktop opens next; with no other signed-in Desktop account it stays signed out. Profiles made with `notis login` are never removed or picked automatically.
+
+- `npx --package @notis_ai/cli@latest -- notis profile list`: every profile on this machine, with its endpoint, user, and whether it is signed in. The active one is marked.
+- `npx --package @notis_ai/cli@latest -- notis profile use <name>`: change which account subsequent commands run as, and link that account's skills into the agent folders straight away.
+- `npx --package @notis_ai/cli@latest -- notis --profile <name> <command>`: run a single command as another account without changing the active one.
+- `npx --package @notis_ai/cli@latest -- notis login --profile <name>`: add an account. The existing profiles keep their credentials.
+- `npx --package @notis_ai/cli@latest -- notis logout`: sign this computer out of the active profile only; the account stays signed in on other computers. Pass `--all-profiles` to clear every profile on this computer.
 
 Read the profile before acting on the user's data. `notis whoami` reports the account and endpoint a command will hit; if that is not the account the user meant, switch profiles rather than proceeding.
 
@@ -133,7 +135,22 @@ For hosted MCP, fetch the matching `notis://docs/notis-cli/references/<file>.md`
 with resources/read or the available Notis resource-fetch tool; the root resource
 also rewrites these links to their published URIs.
 
-- [App delivery](references/app-delivery.md)
+- [Space delivery](references/app-delivery.md)
 - [Toolkit mental model](references/tool-examples.md)
 - [Native database access](references/native-databases.md)
 - [Supporting commands](references/troubleshooting.md)
+
+## Intelligence for skills and delegated work
+
+Skills request `low`, `medium`, or `high`, never a fixed model name. Discover the
+read-only `LOCAL_NOTIS_GET_INTELLIGENCE_POLICY` tool to obtain the shared `contract`
+and current mapping
+for `notis`, `codex`, or `claude_code` and the requested `level`. Resolve model and
+reasoning effort together at the start of each job; validate the selected options
+with the executing harness. Explicit invocation overrides win. A fixed-model
+harness may inherit and disclose that the level was not applied; an automated
+launcher needing an exact selection stops before side effects if policy is unavailable.
+Repository and installed skills consume that same response; neither needs a
+checkout-relative document. Record actual execution receipts, not the level name, as model provenance. Media
+engines remain separate capabilities selected by their tools. See
+[the intelligence contract](references/intelligence.md) for cross-environment details.

package/dist/base-skills/notis-cli/references/app-delivery.md

@@ -1,18 +1,19 @@
-# App delivery
+# Space delivery
 
-Use the canonical `notis-apps` skill’s entrypoint and [release guide](../../notis-apps/references/release.md).
+Use the canonical `notis-apps` skill's entrypoint and [release guide](../../notis-apps/references/release.md).
 For hosted MCP fetch `notis://docs/notis-apps` and `notis://docs/notis-apps/references/release.md`.
 User/repository no-deploy and explicit-consent policies take precedence over default delivery.
 
-## IMPORTANT: When NOT to use tool access for app development
+## IMPORTANT: When NOT to use tool access for Space development
 
-When building or deploying a Notis app, do NOT use `npx --package @notis_ai/cli@latest -- notis tools exec` for app file operations:
+When building or deploying a Space, do NOT use `npx --package @notis_ai/cli@latest -- notis tools exec` for source operations:
 
-- Loading or saving app files -- use `npx --package @notis_ai/cli@latest -- notis apps build` and `npx --package @notis_ai/cli@latest -- notis apps deploy`
-- Linting app files -- use `npx --package @notis_ai/cli@latest -- notis apps build` which validates automatically
-- Managing app routes -- write standard Vite + React pages in `app/`, not raw JS files
+- Loading, building or publishing source -- use `notis spaces pull`, `spaces build`, `spaces verify`, `spaces preview`, `spaces deploy` and `spaces promote` as the release guide orders them
+- Validating views -- `spaces build` and `spaces verify` check declarations, fixtures and renders
+- Writing pages -- write standard Vite + React views with `@notis/sdk`, not raw JS files
 
-Database schemas are the exception: declaring a slug in `notis.config.ts` does
-not create it. Use the discovery-first native database tool workflow to
-create/update and read back each app-owned schema before deployment. Tool calls
-are also valid for testing runtime behavior after deployment.
+Database schemas have two routes: the native database tool (create with `links.add`
+and `main_view`), or a `create` declaration in Space source that the deploy applies
+atomically. Tool calls are also valid for testing runtime behavior after deployment.
+`notis apps` is the legacy App group for accounts not yet moved to Spaces; a legacy
+App cannot declare Skills.

package/dist/base-skills/notis-cli/references/intelligence.md

@@ -0,0 +1,94 @@
+# Agent intelligence levels
+
+This is one shared contract for repository skills and account-installed skills.
+Read it from the `contract` field returned by `LOCAL_NOTIS_GET_INTELLIGENCE_POLICY`,
+directly as a native tool or through the authenticated Notis CLI. The same response
+contains current harness mappings and a `contract_revision` fingerprint. No local
+repository document is a runtime prerequisite. This bundled guide is the source
+served by that lookup, not a separate environment-specific contract.
+
+Skills request **low**, **medium**, or **high**. They never maintain model names,
+version pins, family aliases, effort tables, or price scorecards. The current
+Notis runtime policy is the source of truth, on every operating system and host.
+
+## Choosing a level
+
+| Level | Work |
+| --- | --- |
+| **low** | Bounded extraction, classification against a supplied rubric, formatting, and repetitive generation from complete inputs. |
+| **medium** | Synthesis, writing and reviewing prose from supplied evidence, and moderately complex bounded work. |
+| **high** | The skill default when unspecified: complex reasoning, investigation, coding, code review, and orchestration. |
+
+These are skill defaults, not changes to account or product defaults. The user's
+explicit instruction for this invocation wins: level, exact model, effort,
+harness, or inheritance from the current session. Preserve the scope of that
+override; never save a lasting preference unless asked. Maximum-depth requests
+are invocation overrides, not a fourth Notis level.
+
+## Resolve at execution time
+
+Discover **get current Notis intelligence policy for each harness** through the
+Notis tool catalogue. The read-only tool is `LOCAL_NOTIS_GET_INTELLIGENCE_POLICY`:
+
+```bash
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_GET_INTELLIGENCE_POLICY \
+  --arguments '{"harness":"codex","level":"low"}'
+```
+
+Omit arguments to read all levels. Harness keys are `notis`, `codex`, and
+`claude_code`. A local Mac, Windows host, cloud sandbox, or CI runner uses the
+same contract. Cursor or another host must identify its actual execution engine;
+it must not pretend to be a supported harness based on installed binaries.
+
+The projection is generated from the backend native intelligence configuration and external-harness policy. It contains no
+second mapping. Weekly policy changes therefore require no skill edits.
+
+- Resolve **both model and reasoning effort**. Level names are not effort names.
+- Resolve once per delegated job; keep its `policy_revision` and selection stable
+  through claim, generation, retry and completion. A new job gets a fresh policy.
+- Explicit user choices override the selection; validate them with the executing
+  harness. Never substitute another model, buy API capacity, or change accounts
+  because a selection is unavailable.
+- Validate the request against advertised harness capabilities. Policy is not
+  evidence of entitlement, quota, installed support or successful execution.
+- Use native `intelligence_mode` when the Notis delegation interface supports it.
+  External launchers translate the returned selection into their supported options.
+- Do not downgrade or restart the main session to enforce a skill default.
+- A single-model harness can inherit its current configuration and disclose that
+  the requested level was not applied. Unknown or unavailable mappings are not
+  permission to guess a model. Automated launchers that require an exact selection
+  stop before claiming jobs or producing side effects and explain the missing policy.
+- Before this lookup is deployed, use a current runtime-injected policy if present;
+  otherwise use the transparent inheritance behavior above. Do not copy a temporary
+  model table into skills as a rollout workaround.
+
+## Modalities, product assertions and provenance
+
+Image, speech, video, embedding and provider-research engines are capabilities,
+not interchangeable text-reasoning levels. Skills discover the current native
+capability and let its backend select the engine. External scripts requiring an
+exact provider-specific identifier must resolve current supported configuration
+or take an explicit invocation override; they must not pass `low` as an engine ID.
+
+Test specs assert behavior against the current backend configuration, rather than
+freezing last month's model names. Preserve exact comparisons: derive the expected
+identifier from the owning policy or tool configuration, then compare the receipt.
+Do not weaken a routing test to merely check that some model name exists.
+
+Persist **the actual model that ran**, not an intelligence level. Resolve before
+claiming jobs when the identifier participates in a prompt hash or lease contract.
+Verify execution readback before certifying provenance; aliases and requested
+settings are not actual-model receipts. Preserve historical evidence and existing
+records. Do not rewrite an old receipt as today's policy.
+
+## Subscription execution
+
+A level chooses intelligence, not payment authority. Use the current harness's
+sub-agents or the user's subscription CLI. The existing direct-provider approval
+boundary remains in the workspace/account provider-approval policy.
+
+For subscription CLI subprocesses, remove provider API-key/base-URL variables
+from the child environment. Preserve native subscription credentials; never log
+out or rewrite account authentication to enforce a level. Check the harness's
+execution/authentication readback. Resolve only once per job, batch bounded items
+where appropriate, and keep existing concurrency and usage limits.

package/dist/base-skills/notis-cli/references/native-databases.md

@@ -5,16 +5,17 @@ Native Notis databases are accessed through the generic tool workflow, not a fir
 - `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. Every database belongs to a Notis app: creation requires the owning app's slug or id in the `app` argument (create the app first with `LOCAL_NOTIS_CREATE_APP` if needed)
+- `LOCAL_NOTIS_DATABASE_UPSERT_DATABASE` -- create or update a database schema. A new database is linked to a Space in the same call (`links.add`) and names its main view; change a database used in Spaces through protocol 1 with its exact Space binding target
+- `LOCAL_NOTIS_DATABASE_DELETE_DATABASE` -- permanently delete a database and all its rows by `database_id`. It is refused for every database a Space links (`database_linked_to_space`: move it instead; a database used only in one Space is deleted with that Space from the bin), for a legacy App database its App declares, and while another database relates to it or an automation is triggered by it; the error says what to remove first
 
-Example workflow before building an app:
+Example workflow before building a Space view:
 
 ```bash
 npx --package @notis_ai/cli@latest -- notis tools search "list Notis databases"
 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}}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --arguments '{"database_id":"<id from LIST_DATABASES>"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments '{"protocol":1,"target":{"space_id":"<space id>","binding":"<binding id>"},"input":{"mode":"rows","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.
+Most databases are used in Spaces. Such a database is read only through one of its links: `GET_DATABASE` with a bare `database_id` returns `resolved_target` (the main view's `{space_id, binding}`), and a bare-id `QUERY` answers `database_in_spaces` with every link. Reuse that exact target with `protocol: 1`. Every database lives in a Space; a `database_slug` resolves among every database you can reach, and a slug several of them share answers `database_slug_ambiguous` with each `database_id` and its Spaces.

package/dist/base-skills/notis-cli/references/tool-examples.md

@@ -32,15 +32,15 @@ npx --package @notis_ai/cli@latest -- notis tools exec composio-googlecalendar-l
 Dry-run a tool call:
 
 ```bash
-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}}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --dry-run --arguments '{"database_id":"<tasks database id>"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --dry-run --arguments '{"protocol":1,"target":{"space_id":"<space id>","binding":"<binding id>"},"input":{"mode":"rows","page_size":10}}'
 ```
 
 Execute a tool call:
 
 ```bash
-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}}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_GET_DATABASE --arguments '{"database_id":"<tasks database id>"}'
+npx --package @notis_ai/cli@latest -- notis tools exec LOCAL_NOTIS_DATABASE_QUERY --arguments '{"protocol":1,"target":{"space_id":"<space id>","binding":"<binding id>"},"input":{"mode":"rows","page_size":10}}'
 ```
 
 Connect a missing toolkit:

package/dist/base-skills/notis-query/SKILL.md

@@ -1,67 +1,41 @@
 ---
 name: notis-query
-description: Use when agents need to query native Notis databases with direct structured filters, sorts, and pagination through `LOCAL_NOTIS_DATABASE_QUERY`.
-feature_flag: store
+description: Discover native Notis databases and query their records with exact structured filters, current Space authority and view-qualified links.
+feature_flag: spaces
 mcp_resource: true
 mcp_tool_patterns: ["LOCAL_NOTIS_DATABASE_*"]
 mcp_references: ["references/database-discovery.md", "references/documents.md", "references/query.md"]
 ---
 
-# Notis Query Skill
-
-Use this skill when the user wants to search, filter, sort, or page through records in a native Notis database and the task is best handled with structured criteria instead of semantic search.
-
-This skill is the single source of truth for `LOCAL_NOTIS_DATABASE_QUERY`.
-
-## Canonical contract source
-
-For custom view runtime usage, the canonical contract is always MCP `tools/list` `inputSchema` for `LOCAL_NOTIS_DATABASE_QUERY`.
-
-- Use `notisView.listTools()` (or MCP `tools/list`) to read the live schema.
-- Use `notisView.callTool("LOCAL_NOTIS_DATABASE_QUERY", args)` (or MCP `tools/call`) with arguments that match that schema exactly.
-- If this skill text and `inputSchema` ever differ, follow `inputSchema`.
-
-This keeps query arguments aligned with the same tool definitions used by agent runtime and avoids maintaining duplicate schema formats.
-
-## When to use `LOCAL_NOTIS_DATABASE_QUERY`
-
-Use `LOCAL_NOTIS_DATABASE_QUERY` when:
-
-- you already know the target native database
-- the user wants structured filtering or sorting
-- you need predictable pagination over database rows
-- you need to find records before reading or updating a specific document
-- you need to find matching records before calling `LOCAL_NOTIS_DATABASE_GET_DOCUMENT` or a generated database upsert tool
-- the task should use direct database criteria instead of semantic memory search
-
-Do not use `LOCAL_NOTIS_DATABASE_QUERY` when:
-
-- the relevant database is unknown
-- semantic search over broad workspace context is better
-- the task points to one known document by `document_id` or portal URL
-
-Use these tools together:
-
-- `LOCAL_NOTIS_DATABASE_LIST_DATABASES` to discover available databases and confirm the slug
-- `LOCAL_NOTIS_DATABASE_GET_DATABASE` to inspect read-only schema detail, ordered properties, options, and relation targets
-- `LOCAL_NOTIS_DATABASE_QUERY` to find matching records
-- `LOCAL_NOTIS_DATABASE_GET_DOCUMENT` to inspect one specific matching document in full
-- generated database upsert tools to update or create records after you know the right document or relation IDs
-
-Follow the same workflow and use the exact canonical tool names available in the current runtime.
-
-Every database has one owning app; inspect its identity/schema before schema writes.
-Known document IDs/URLs use the document guide, not a broad query. For queries,
-use the query guide for exact filter/property/pagination rules; live inputSchema
-is authoritative. Dry-run writes and read back the resulting state.
-
-## Task guides
-
-Read only the guide needed for this task. Relative links resolve in the skill bundle.
-For hosted MCP, fetch the matching `notis://docs/notis-query/references/<file>.md` URI
-with resources/read or the available Notis resource-fetch tool; the root resource
-also rewrites these links to their published URIs.
-
-- [Native Database Workflow](references/database-discovery.md)
-- [Reading documents](references/documents.md)
-- [Supported execution mode](references/query.md)
+# Native database queries
+
+Use structured native queries for filtering, sorting, counts, aggregates and
+pagination. Use memory for semantic discovery; use view rendering for what a page
+shows. The live tool `inputSchema` is authoritative.
+
+1. Discover the database and inspect its schema, property descriptions, relation
+   targets and option IDs with `LOCAL_NOTIS_DATABASE_GET_DATABASE`.
+2. Keep its exact returned native `target`, schema revision and available operations.
+   Every database lives in a Space; failed access never falls back to another owner.
+3. Use `LOCAL_NOTIS_DATABASE_QUERY` with `protocol: 1`, that `target` and direct
+   `input`. Build filters from actual field types/options. Page until the returned
+   continuation ends; one page is not the whole database.
+4. For a known record or view link, follow [Reading records](references/documents.md)
+   instead of running broad discovery. View links come from write results or
+   `LOCAL_NOTIS_FIND_VIEWS`; sensitive or stale evidence needs a fresh render.
+5. Writes use discovered native tools with current schema/record revisions and a
+   stable request ID. Dry-run first and read back the committed state. A missing
+   view link is not a failed write and does not justify repeating it.
+
+In authored Space code use `useShown` or declared actions, not account-wide tool
+calls. Load `notis-apps` for [Space authoring](../notis-apps/references/views.md);
+its hosted reference is `notis://docs/notis-apps/references/views.md`.
+
+## Guides
+
+- [Database discovery and creation](references/database-discovery.md)
+- [Structured native query grammar](references/query.md)
+- [Reading, updating and citing records](references/documents.md)
+
+Hosted MCP exposes these references under
+`notis://docs/notis-query/references/<file>.md`; load only the relevant guide.