@agentshouse/skills 0.1.0-ce95c9bef1e33 → 0.1.0-cf6afb1bdfcaf

package/README.md

@@ -11,10 +11,11 @@ The Skills agents.house serves its agents, and the texts its agents read.
   an App, `sites/` what a Site adds, and `skills/` agents.house's own Skills, `house-onboarding`,
   `prototype-app`, `build-app` and `wizard`, each page carrying the `name` and `description` a
   `SKILL.md` carries.
-  `routines/` holds the Routines agents.house writes into every Private Room, frontmatter and
+  `agent-functions/` holds the Agent functions agents.house writes into every Private Room, frontmatter and
   all. `owner-rules` is the Owner rules' text, and `owner-rules-earlier.json` the SHA-256 of every
   earlier text.
-- `agent-instructions.json` is the lines that open an agent's first prompt.
+- `agent-instructions.json` is the lines that open an agent's first prompt; its `routing` lines are
+  the ones agents.house's MCP server instructions carry too.
 
 ```ts
 import { OWNER_RULES, listSkills, readSkill } from '@agentshouse/skills';
@@ -23,9 +24,10 @@ for (const { name } of listSkills()) console.log(name, readSkill(name).length);
 console.log(OWNER_RULES);
 ```
 
-`agentInstructions(houseRef, copies)` returns the first prompt's lines, `GUIDE` every Guide page
-with its path, title, first line and text, `WORK_ON_TICKET` the `routines/work-on-ticket` page's
-text and `EARLIER_OWNER_RULES_SHA256` the earlier texts' digests.
+`agentInstructions()` returns the first prompt's lines, which name no Local copy, `ROUTING_INSTRUCTIONS`
+its routing lines,
+`GUIDE` every Guide page with its path, title, first line and text and
+`EARLIER_OWNER_RULES_SHA256` the earlier texts' digests.
 
 The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt
 Pocock.

package/agent-instructions.json

@@ -1,10 +1,16 @@
 {
-  "lines": [
+  "opening": [
     "From House:",
-    "Work with House through the `house` CLI: run `house --help`, and `house open_guide` opens `index`, the root page of House's guides and formats.",
-    "To give the User a file, upload it with `house upload` and link it; for an App, a Site or a website, follow the Guide from `index` with `house open_guide`. Never start a server.",
-    "Optional per-Room instructions: `/rooms/private/rooms/<handle>/AGENTS.md`.",
-    "For another Agent's help, `send_routine_request`; its mail comes back into this conversation. If an Agent of your User has no Routine to call, write one in the Private Room and `create_routine_access` with your User as its only caller."
+    "Work with House through the `house` CLI, `house <tool> '<arguments as JSON>'`: `house --help` lists the Tools and `house help <tool>` names a Tool's arguments."
   ],
-  "copies": "House Local copies; before work run `house fetch` and rebase onto `<house-ref>`; after it commit, then `house push`:"
+  "routing": [
+    "Read with `shell` and `info`. Write with `files_batch`; `records_append` adds a record from one of your Sources.",
+    "For anything else, `find_command`, then `run_command`.",
+    "Optional per-Room instructions: `/rooms/private/rooms/<handle>/AGENTS.md`."
+  ],
+  "closing": [
+    "`house run_command '{\"command\":\"guide/open\"}'` opens `index`, the root page of House's guides and formats.",
+    "A file reaches the User as a Room Path written with `house upload` and linked in the answer. House serves an App, a Site or a website built by the Guide from `index` (`guide/open`), with no server of your own.",
+    "For another Agent's help, `agent-functions/send` naming one of the Room's Agent function cards under `house/agent-functions/`, or the Agent and what you ask, as its Standing answers there allow; its mail comes back into this conversation."
+  ]
 }

package/dist/index.d.ts

@@ -15,8 +15,8 @@ export interface GuidePage {
 export declare const GUIDE_ROOT = "index";
 export declare const GUIDE: readonly GuidePage[];
 export declare const OWNER_RULES: string;
-export declare const WORK_ON_TICKET: string;
 export declare const EARLIER_OWNER_RULES_SHA256: readonly string[];
-export declare function agentInstructions(houseRef: string, copies: readonly string[]): string[];
+export declare const ROUTING_INSTRUCTIONS: readonly string[];
+export declare function agentInstructions(): string[];
 export declare function listSkills(): readonly Skill[];
 export declare function readSkill(name: string): readonly SkillFile[];

package/dist/index.js

@@ -4,20 +4,20 @@ import { fileURLToPath } from 'node:url';
 const PACKAGE = fileURLToPath(new URL('..', import.meta.url));
 const SET = join(PACKAGE, 'set');
 const ENTRY = 'SKILL.md';
-const REF_PLACEHOLDER = '<house-ref>';
 const TREE = join(PACKAGE, 'guide');
 const PAGE = '.md';
 const FRONTMATTER = /^---\n[\s\S]*?\n---\n\n?/u;
 const HEADING = /^# /u;
+const LIST_ITEM = /^\s*[-*+] /u;
 export const GUIDE_ROOT = 'index';
 const OWNER_RULES_PAGE = 'owner-rules';
-const WORK_ON_TICKET_PAGE = 'routines/work-on-ticket';
 function packaged(name) {
     return readFileSync(join(PACKAGE, name), 'utf8');
 }
 function guidePage(file) {
     const text = readFileSync(join(TREE, file), 'utf8');
-    const [heading = '', , line = ''] = text.replace(FRONTMATTER, '').split('\n');
+    const [heading = '', , ...rest] = text.replace(FRONTMATTER, '').split('\n');
+    const line = rest.find((held) => held !== '' && !LIST_ITEM.test(held)) ?? '';
     return {
         path: file.slice(0, -PAGE.length).split(sep).join('/'),
         title: heading.replace(HEADING, ''),
@@ -33,17 +33,11 @@ export const GUIDE = readdirSync(TREE, {
     .map((entry) => guidePage(relative(TREE, join(entry.parentPath, entry.name))))
     .sort((left, right) => (left.path < right.path ? -1 : 1));
 export const OWNER_RULES = GUIDE.find((page) => page.path === OWNER_RULES_PAGE).text;
-export const WORK_ON_TICKET = GUIDE.find((page) => page.path === WORK_ON_TICKET_PAGE).text;
 export const EARLIER_OWNER_RULES_SHA256 = JSON.parse(packaged('owner-rules-earlier.json'));
 const INSTRUCTIONS = JSON.parse(packaged('agent-instructions.json'));
-export function agentInstructions(houseRef, copies) {
-    if (copies.length === 0)
-        return [...INSTRUCTIONS.lines];
-    return [
-        ...INSTRUCTIONS.lines,
-        INSTRUCTIONS.copies.replaceAll(REF_PLACEHOLDER, houseRef),
-        ...copies,
-    ];
+export const ROUTING_INSTRUCTIONS = INSTRUCTIONS.routing;
+export function agentInstructions() {
+    return [...INSTRUCTIONS.opening, ...INSTRUCTIONS.routing, ...INSTRUCTIONS.closing];
 }
 export function listSkills() {
     return readdirSync(SET, { withFileTypes: true })

package/guide/{routines → agent-functions}/work-on-ticket.md

@@ -1,15 +1,13 @@
----
-description: Work the Wayfinding ticket this request names, from its Question to its Answer.
-input: The ticket to work on.
----
-
 # Work on ticket
 
-The Routine an Agent runs when a person sets a Wayfinding ticket in progress with that Agent as its assignee.
+- **Description**: Work the Wayfinding ticket this request names, from its Question to its Answer.
+- **Input**: The ticket to work on.
+
+The Agent function an Agent runs when a person sets a Wayfinding ticket in progress with that Agent as its assignee.
 
 Work the one ticket this request names, then stop:
 
-1. Open the `wayfinding-ticket` the request names and set its `conversation` to this conversation.
+1. Open the `wayfinding-ticket` the request names and set its `conversation` to the id of this conversation, the one `conversations/active/list` marks `this`.
 2. Work it by its `kind`: for `research`, find out and say where you found it; for `prototype`, build the smallest thing that answers its Question; for `grilling`, ask your User until its Question is settled; for `task`, do what it asks.
-3. Write what you found or made in its Answer section and set its `status` to `done`.
+3. Write what you found or made as its Answer and set its `status` to `done`.
 4. Start no other ticket, not even one this ticket unblocks.

package/guide/apps/build.md

@@ -2,8 +2,9 @@
 
 How to build an App over your User's Rooms and publish it, one page per step.
 
-An App is a web page over your User's Rooms, for your User and whom they share it with (`create_share`). House serves the built files and gives the page the App runtime, which holds every bound Room in the browser and syncs it with House. There is no server, backend or House API of yours to call.
+An App is a web page over your User's Rooms, for your User and whom they share it with (`shares/create`). House serves the built files and gives the page the App runtime, which holds every bound Room but a Search-level one in the browser and syncs it with House. There is no server, backend or House API of yours to call.
 
+- [Design an App](apps/design)
 - [Start an App](apps/start)
 - [An App's data](apps/data)
 - [Local first](apps/local-first)

package/guide/apps/chat.md

@@ -8,16 +8,45 @@ no dependency. `const chat = await houseBridge.chat.mount(element, options)`, on
 object House hands the page as `window.houseBridge`, which `houseBridge()` of
 `@agentshouse/app-bridge` returns, draws it in `element` over the App's own client and
 resolves to a handle: `chat.update(options)` replaces its options and `chat.unmount()`
-removes it. `conversation` opens one, `null` for a
-new chat, `agent` is the Agent a new chat goes to, `showChats` adds its conversation list,
-`width` is `full` (the element), or `3/4`, `1/2` or `1/3` of the window docked at its right
-edge, whole on a narrow window, `onOpen` hears each conversation it opens as `{
-conversation, agent }`, and `onLink` takes a link without a scheme in place of the browser.
+removes it. It fills the element and lays itself out by the width it gives: the list of the
+User's Agents and their chats or one chat on a narrow element, and on a wider one the list
+beside the chat while the User shows it by its toggle, closed at first beside an open chat and
+open where none is, the conversation keeping its width where the element has room for both.
+With no chat open it shows what
+asks the User and what works now. `conversation` opens one chat, and with it `null` the Chat
+opens a new chat with `agent`, the Agent it goes to, or the list with neither. `onOpen` hears
+each chat it opens as `{ conversation, agent }`, and both `null` when the User goes back to the
+list, and `onLink` takes a link without a scheme in place of the browser.
+Or mount it as the Chat button, which takes no element:
+`const button = await houseBridge.chat.mountButton(options)` draws House's dot at the
+window's bottom-right corner, which counts what asks the User or, while nothing does, the chats
+that replied since the User opened them, and breathes while a turn runs; pressing it opens the
+Chat in a sheet above the page, and a second press hides it. With `agent` among the options
+the dot's first press opens it on a new chat with that Agent instead of a chat kept from an
+earlier visit, and later presses reopen the chat it last showed. The dot stays in view over the
+sheet, which the User moves, resizes up to the window's edges and lets fill the window, and
+whose list, closed at first, widens it to the left by the list's own width; the page under it
+never changes, so leave nothing of the page to make room for it.
+`button.open(target)` opens the sheet, on `{ conversation }` or on a new chat with
+`{ agent }`, or as it was with no target, and with `docked: true` docked at full height along
+the window's right edge; `button.hide()` hides it, keeping its chat, scroll and typed text;
+`button.update(options)` and `button.unmount()` work as for a page, with `onOpen` and
+`onLink`, though a Room document's link opens House in a new tab with that chat. To open on text written in, write it as the chat's draft through the runtime's
+`chatDraft` first, keyed `new:<agent>` for a new chat. In the sheet the input's + holds This
+page, which attaches the page's Page metadata to one message: a new chat's first message starts
+with it ticked. Mount one button per page.
+In either form the Chat draws inside its own shadow root, so no rule of the App's stylesheet
+reaches it. `chat.mount` needs an element that can hold a shadow root, such as a `div` or a
+`section`, and rejects on a `li`, a `td` or a `form`.
 Theme its own styles with CSS custom properties on the element or an ancestor:
 `--chat-background`, `--chat-surface`, `--chat-text`, `--chat-text-muted`,
 `--chat-accent`, `--chat-line`, `--chat-attention`, `--chat-danger`, `--chat-font`,
 `--chat-font-mono`, `--chat-font-size`, `--chat-radius` and `--chat-density` (a factor for
-spacing); an unset one keeps House's light or dark look. It shows conversations only where
-the release declares them; otherwise it lists no conversation and no Agent. A secret
+spacing); an unset one keeps House's light or dark look. For the Chat button, which takes no
+element, set them on the document's root element. Its dot keeps House's colours and type, and
+stays level with the sheet's input.
+It shows conversations only where the release declares them;
+otherwise it lists no conversation and no Agent. A secret
 question is never answered here; typed answers live in the Presentation State members named
-`typed:…`: leave them.
+`typed:…`, and the sheet's size, place, whether it fills the window and its open chat in
+`chat:sheet`: leave them.

package/guide/apps/client.md

@@ -18,4 +18,4 @@ and returns `{ state: 'loading' }` until the topic's first value arrives, then `
 parts)`, which saves through `saveParts` and rejects with a recorded failure.
 `saveWritten(room, roomDrafts)` saves Room Drafts the App wrote, each named with the
 revision its last write returned: one another tab wrote since is refused as `stale`, and
-nothing is saved. React-admin and Refine Apps use `@agentshouse/mdruntime-families`.
+nothing is saved.

package/guide/apps/content-safety.md

@@ -10,9 +10,12 @@ images and other resources only from origins the Provider's policy allows. An ag
 never read the authorization, load code from a Room, call the Provider directly, or rebase
 a refused Change Batch.
 
-MD UI uses semantic HTML, is fully operable from a keyboard with visible focus and
-labelled controls, and lays out from a 360 pixel wide viewport to a desktop. Its strings
-are English only, dates and numbers follow the browser locale, and content is never
-translated. Light and dark themes come from CSS custom properties, defaulting to the
+MD UI uses semantic HTML, is fully operable from a keyboard with labelled controls, styles
+no focus, removes the browser's own focus ring and takes no focus by itself, and lays out
+from a 360 pixel wide viewport to a desktop.
+Its strings are English only, dates and numbers follow the browser locale, and content is
+never translated. Light and dark themes come from CSS custom properties, defaulting to the
 browser's preference and respecting an App's override. What an agent adds carries none of
-these promises by itself. Data lives only in the App Creator's browser and the Provider.
+these promises by itself. The App keeps no data of its own anywhere: its data lives in
+its Rooms, at the Provider and on every device that holds them, and the
+App's code sends it out only to the external origins its manifest declares.

package/guide/apps/data.md

@@ -2,10 +2,14 @@
 
 How an App keeps what it shows as typed documents in the Rooms bound to it.
 
-- Design the Room schema first. Each thing the App shows is one Markdown document in a Room: its frontmatter `type` names its MD type, the rest of its frontmatter holds the fields, and long text goes in `##` sections. `schema.yaml` declares the types ([Schema](reference/schema)).
-- Keep each type in its own folder, such as `tasks/`, and read it by `pathPrefix`: a query naming `types` fails with `unknown-type` while no bound Room declares them.
+- Design the Room schema first. Each thing the App shows is one Markdown document in a Room: its frontmatter `type` names its MD type and its body writes the values: its `name` as the `#` line, each short value as a `- **Label**: value` line and long text under its own heading ([Schema](reference/schema)). `schema.yaml` declares the types ([Schema](reference/schema)).
+- Keep each type in its own folder, such as `tasks/`, and read it by `pathPrefix`. A query naming `types` fails with `unknown-type` over bound Rooms none of which declares them, and answers `{ pending }` instead while the App reaches no bound Room yet; an observed query that has already answered answers `{ pending }` while its bound Rooms refuse it, and answers again once they declare what it names.
 - Link types with `reference` fields instead of copying values; a query follows them with `hop` and `backlinks`.
-- `app.json` `room_slots` names the Rooms the App needs, each with `access` `read` or `write` and the `types` it uses ([App manifest](reference/app-manifest)). Bind Rooms with `set_app_bindings`; App code cannot bind and reaches only bound Rooms, so it opens `bridge.ceremony('/bind/<app_ref>?slot=<name>')`, the House page where your User binds Rooms, which returns to the App.
-- A bound Room must hold each slot type identically in its own `settings/schema.yaml`, beside any other types, or your User is warned. Write it with `edit` before binding; `create_room` makes a new Room.
-- Read an existing Room's `settings/schema.yaml` before inventing types. Two Apps over one schema are two interfaces over the same data, and your User's Agents read and write those documents too.
-- What no browser can do, such as acting when documents change or at a set time, is a Trigger (`create_trigger`) that notifies, starts a Routine on an Agent, or runs one of the App's [functions](apps/functions) on House's servers; what it writes reaches the App at once.
+- `app.json` `room_slots` names the Rooms the App needs, each with `access` `read` or `write` and the `types` it uses ([App manifest](reference/app-manifest)). Bind Rooms with `apps/bindings/set`; App code cannot bind and reaches only bound Rooms, so it opens `bridge.ceremony('/bind/<app_ref>?slot=<name>')`, the House page where your User binds Rooms, which returns to the App.
+- A bound Room must hold each slot type identically in its own `settings/schema.yaml`, beside any other types, or its binding warns the User who bound it, and `apps/bindings/list` names that release and slot in its `mismatch` line, to the App's owner too. Write it with `files_batch` before binding; `rooms/create` makes a new Room.
+- A slot may hold a Space instead (`apps/bindings/set` with `space_ref`): every Room of it your User holds, now and later. An App its owner puts into a Space (`apps/space/set`) uses that Space's schema instead of its own `schema.yaml`, and every member of the Space uses it, each slot holding the Space's Rooms.
+- Read an existing Room's `settings/schema.yaml` before inventing types. Two Apps over one schema are two interfaces over the same data, and your User's agents read and write those documents too.
+- House's own facts, such as your User's Rooms and the Space each is in, come from House acts: name each in `app.json` `house_acts` and call it with `runtime.call('<act>', input)`, such as `runtime.call('rooms/list', {})`. A call needs a connection, so offline show what the bound Rooms hold. A slot holding the Private Room brings its Triggers and none of the other documents House writes under its `house/`.
+- `shares/create` lets a person into Rooms and Apps: its answer's `added` is `true` when their _Who can add me_ setting admits your User, so they are in at once, and `false` when the Share waits for their Accept.
+- What no browser can do, such as acting when documents change or at a set time, is a Trigger (`triggers/create`) that notifies or runs one of the App's [functions](apps/functions) on House's servers; what it writes reaches the App at once.
+- A Trigger may also start an [Agent function](reference/agent-function) on an Agent of your User.

package/guide/apps/design-functions.md

@@ -0,0 +1,10 @@
+# Which function does what
+
+Which part of House does each kind of an App's work, and what each run costs.
+
+- **The page** reads and writes the bound Rooms on the device, offline too, and runs only while someone has it open ([Local first](apps/local-first)).
+- **An App function** runs on House's servers when a Trigger of its Room fires, with no page open and no model. It reads and writes that Room and calls the services `external_origins` lists, within <function-time> and <function-memory> a run. It does what a script can: computing, filing, copying, counting, scheduling, calling a service ([App functions](apps/functions)).
+- **An Environment function** is a script your User kept for one of their computers, which Kit runs there as them. It does work that needs that computer, its files or its logins. A Trigger of their Private Room, their Run now or `environments/functions/run` starts one; a Trigger of any other Room never does ([wizard](skills/wizard)).
+- **An Agent function** starts a conversation of one of your User's Agents, which reads, judges and writes in minutes rather than milliseconds. Every run spends your User's own provider budget, and House sets no allowance on these runs: one Trigger acts on at most <trigger-events-per-hour> Events in a UTC hour, so a Room's Triggers together can still start many. It does what needs judgment: reading a message, answering it, deciding what a document means ([Agent function](reference/agent-function)).
+- **A job that needs judgment in one step** splits: an App function does the rest, and an Agent function only that step, writing its answer into the Room, where a Trigger hands it on to the App function ([Agent function](reference/agent-function)).
+- **With no page open**, nothing of the App runs by itself: a Trigger whose action notifies someone or runs one of these starts its work ([Triggers](reference/triggers)).

package/guide/apps/design-load.md

@@ -0,0 +1,14 @@
+# Designs that load House
+
+What an App's saves, Triggers and functions cost House's servers and every device holding its Rooms.
+
+- **A save** stores the document's whole new text as a revision, tests it against every Trigger of its Room inside the write, streams the whole text to every device holding the Room and counts once against the saver's Write limit, whatever its size. A log or a state kept in one growing document costs its whole size on every change: keep one small document per thing.
+- **Saving as someone types**, or on a timer, writes each time; the Room Draft keeps what they type until they save ([Room Drafts](apps/room-drafts)).
+- **Every device** holding a Room at the Keep or Open level holds all of its text ([Access level](reference/access-level)), so records written by the thousand fill every holder's device; a file goes in as a file ([files](apps/runtime-files)), never as text in a document.
+- **A Trigger** whose change test is any edit, `changes: "text"`, acts on every save of a document it matches, while a field's change, or the default firing as a document starts to match, acts once per change that matters ([Triggers](reference/triggers)).
+- **A function's writes** fire Triggers, its own included: one whose write matches its own Trigger runs again on each run until that Trigger's <trigger-events-per-hour> Events in the hour are spent, so write what it writes so that its Trigger does not match it ([App functions](apps/functions)).
+- **A function run** reads, on every Event, every document of the types, folders and paths its query names from House's database, within <function-memory>, and one Room owner's runs take at most <function-owner-slots> slots on a server at once: name the narrowest folder or paths, or read a summary document the function keeps ([App functions](apps/functions)).
+- **One Trigger's Events** run one after another, so a busy Trigger builds a queue ([App functions](apps/functions)).
+- **An Agent function run** spends your User's provider budget each time ([Agent function](reference/agent-function)).
+- **Changing a field's `title`** relabels every document of its type in one write ([Schema](reference/schema)).
+- **A query naming no `types`, `pathPrefix` or `paths`** reads every document of its Rooms on the device: name the narrowest and select only what a screen shows ([Local Query](apps/local-query)).

package/guide/apps/design-look.md

@@ -0,0 +1,11 @@
+# An App's look
+
+What House draws around an App's page, and what the App sets for its look.
+
+- **The page is the App's own**, drawn and run by the App ([An App's page](apps/page)). Over it House draws only its wait until the page shows its place, and the dialog asking a User who does not own the App to allow a browser feature or House act the App uses for the first time.
+- **The Chat**, where the page mounts it, draws in the App's frame: the Chat button's dot in House's look, and the Chat in its own, which the `--chat-*` properties theme ([The Chat](apps/chat)).
+- **The design system's tokens**: mdui's `style.css` holds House's design tokens as CSS custom properties, light and dark: its greys, type sizes, spacing, radii and motion. An App built on them looks like House; changing them gives it a look of its own. The design system itself is not published, so mdui's tokens are how an App takes it.
+- **Light and dark**: House's screens around the page, such as its wait until the page shows its place, follow the device's light or dark setting, as `prefers-color-scheme` does.
+- **The top colour**: declare the page's top colour as `theme_colour` in `app.json`, and `theme_colour_dark` where the dark one differs ([App manifest](reference/app-manifest)). An installed App's title bar and a phone's top strip take it, and House's white or near-black ground without it. A page with its own light and dark switch calls `bridge.setTab({ scheme })` with `'light'` or `'dark'` when it shows one over the device's setting, and `null` when it follows the device, so they take that scheme's colour.
+- **The icon** is the owner's setting, never the release's: one image in the browser tab, the panel and on a home screen. It is the App cube in the App's colour until one is set, then a generated one from one to four colours or the owner's own square PNG or SVG, through `apps/tab-icon/set`; `bridge.setTab({ title, icon })` changes the open tab's title and icon until the next load.
+- **No focus mark**: House's own screens draw none, and [An App's page](apps/page) says how a page removes the browser's ring.

package/guide/apps/design-schema.md

@@ -0,0 +1,13 @@
+# Schemas that read well
+
+How an App's types make documents that read well as Markdown, to people and agents alike.
+
+A typed document writes its values as Markdown, so its schema decides how it reads; [Schema](reference/schema) holds the format.
+
+- A field named `name` is the document's `#` line, and a type with none writes documents with no title line.
+- `title` on a field is the label its line shows, and a field with none shows its key.
+- Each field takes one JSON type. A short value is one line, a yes or no a checkbox line and a `reference` a link; Markdown text (`contentMediaType: text/markdown`) and a value that may hold a line break take a heading of their own; a value of no single type is written as a fenced `json` block.
+- Rows of short values read as a table, and a list of groups that is no table takes one heading per item, named by its `name`.
+- Nest values at most five levels deep, each list's items counting as a level. A value that takes a heading goes one heading level deeper per level, from `##` to `######`, so a schema that places one deeper is refused `heading-depth`, and a deeper plain string that holds a line break is refused `malformed-value` when it is written.
+- One document is one thing, such as a task, a lead or an order: link others by `reference` rather than copying or nesting them, and keep a growing list of records as a folder of documents.
+- A type whose Room your User holds at the Search level, which the App asks through a [House query](apps/query-house), names in `indexed` the fields that query orders, totals or groups by, a list of its own top-level keys, and House keeps an index of their values. A field there holds one plain value, `null` allowed: a number, an integer, a yes or no, or a string that is a choice, a `date`, a `date-time`, a `time` or bounded by a `maxLength` of at most <indexed-text-length> characters; a list, a group, a value of no single type, Markdown text, a `reference` and a House key such as `member` or `submitted` are not. A type names at most <indexed-fields>, and House refuses a schema naming more, an unknown field or one it cannot index with the rule `indexed` and its place. Naming one changes no document and checks none again, so whoever writes the schema may change it.

package/guide/apps/design.md

@@ -0,0 +1,12 @@
+# Design an App
+
+What an App's design settles before its code, one page per question House answers.
+
+- [Which function does what](apps/design-functions): which part of House does each piece of the App's work, and what it costs.
+- [Schemas that read well](apps/design-schema): how its types make documents that people and agents read.
+- [Designs that load House](apps/design-load): what its saves, Triggers and functions cost, and the designs that cost less.
+- [An App's look](apps/design-look): what House draws around its page, and what the App sets.
+
+Keep a Room for the App where you write how it is developed: its decisions, its plan and tickets, and what its Triggers and functions do. Name that Room in the App's README, so the next agent working on the App finds it. House reads nothing there.
+
+[Example: tasks](apps/example-tasks) follows these pages.

package/guide/apps/example-function.md

@@ -2,13 +2,12 @@
 
 How a function hands each new lead to the manager on shift with the fewest leads since their shift began, records its decision and calls the CRM.
 
-A CRM posts each new lead to the Room's push address (`create_push_address`) as `{"event": "lead.created", "card": {"id": 101}}`. The Room holds three types: `staff/<key>.md` with `manager_id`, the manager's id at the CRM; `shifts/<key>.md` with `staff`, the key, and `starts` and `ends` as ISO instants; and `decisions/<card>.md` with `card`, `staff` and `decided_at`. The App's `external_origins` lists the CRM's origin, the Room holds a Service key for it, and a Trigger runs the function for each lead:
+A CRM posts each new lead to the Room's push address (`capture/push-addresses/create`) as `{"event": "lead.created", "card": {"id": 101}}`. Name where the CRM puts its event id as the address's `event_id`, when you create it or later with `capture/push-addresses/edit`, so a lead it sends again writes nothing; an address naming none takes a `webhook-id` header as the id. The Room holds three types: `staff/<key>.md` with `manager_id`, the manager's id at the CRM; `shifts/<key>.md` with `staff`, the key, and `starts` and `ends` as ISO instants; and `decisions/<card>.md` with `card`, `staff` and `decided_at`. The App's `external_origins` lists the CRM's origin, the Room holds a Service key for it, and a Trigger runs the function for each lead:
 
 ```json
 {
   "on": "items",
-  "address": "<push address>",
-  "match": { "path": "/json/event", "eq": "lead.created" }
+  "query": { "where": { "/address": "<push address>", "/json/event": "lead.created" } }
 }
 ```
 
@@ -43,7 +42,7 @@ export default async (event, house) => {
   const answer = await house.callExternal({
     url: `https://crm.example/cards/${card}`,
     method: 'PUT',
-    headers: { 'content-type': 'application/json', 'idempotency-key': event.occurrence },
+    headers: { 'content-type': 'application/json', 'idempotency-key': event.id },
     body: JSON.stringify({ status: 'assigned', manager: manager.fields.manager_id }),
     room_ref: event.room,
   });
@@ -64,4 +63,4 @@ export default async (event, house) => {
 };
 ```
 
-A lead the CRM delivers again finds its decision and calls nothing. Two leads that arrive together run one after another, so the second counts the first's decision and goes to another manager when two are tied. Each count is a query's `total`, so a long shift is never cut at a page. A failed call fails the run with the CRM's answer and tells the Room's owner; the next lead still runs.
+A lead the CRM delivers again finds its decision and calls nothing. Two leads that arrive together run one after another, so the second counts the first's decision and goes to another manager when two are tied. Each count is a query's `total`, so a long shift is never cut at a page. A failed call fails the run with the CRM's answer; the next lead still runs.

package/guide/apps/example-tasks-2.md

@@ -12,8 +12,8 @@ function taskCreation(draft: Draft) {
     : undefined;
 }
 
-function titleOf(draft: Draft): unknown {
-  return draft?.parts.fields?.title?.value ?? taskCreation(draft)?.fields.title;
+function nameOf(draft: Draft): unknown {
+  return draft?.parts.fields?.name?.value ?? taskCreation(draft)?.fields.name;
 }
 
 function el<K extends keyof HTMLElementTagNameMap>(
@@ -26,31 +26,29 @@ function el<K extends keyof HTMLElementTagNameMap>(
   return node;
 }
 
-function titleForm(
+function nameForm(
   action: string,
   room: string,
   path: () => string,
   shown: unknown,
-  parts: (title: string, held: Draft) => Parts,
-  done: (title: HTMLInputElement) => void,
+  parts: (name: string, held: Draft) => Parts,
+  done: (name: HTMLInputElement) => void,
 ) {
   let held = drafts.current().find((draft) => draft.room === room && draft.path === path()) ?? null;
-  const title = el('input', {
-    value: String(titleOf(held) ?? shown),
+  const name = el('input', {
+    value: String(nameOf(held) ?? shown),
     required: true,
-    ariaLabel: 'Title',
+    ariaLabel: 'Name',
   });
   const keep = () =>
     queued(async () => {
-      unsaved.add(title);
-      const written = await write(room, path(), held, parts(title.value, held));
-      unsaved.delete(title);
+      const written = await write(room, path(), held, parts(name.value, held));
       held = written.draft;
-      if (written.stale) title.value = String(titleOf(held) ?? shown);
+      if (written.stale) name.value = String(nameOf(held) ?? shown);
       return written.stale;
     });
-  title.oninput = () => void keep();
-  const form = el('form', {}, title, el('button', {}, action));
+  name.oninput = () => void keep();
+  const form = el('form', {}, name, el('button', {}, action));
   form.onsubmit = async (event) => {
     event.preventDefault();
     const stale = await keep();
@@ -58,16 +56,16 @@ function titleForm(
     if (stale) return void (note.textContent = 'Not saved: stale.');
     if (!(await save(room, held))) return;
     held = null;
-    done(title);
+    done(name);
   };
   return form;
 }
 
 function editForm(room: string, path: string, shown: unknown) {
-  const parts = (title: string): Parts => ({
-    fields: { title: { value: title, base: { value: shown } } },
+  const parts = (name: string): Parts => ({
+    fields: { name: { value: name, base: { value: shown } } },
   });
-  return titleForm(
+  return nameForm(
     'Save',
     room,
     () => path,
@@ -78,22 +76,22 @@ function editForm(room: string, path: string, shown: unknown) {
 }
 
 function addForm(room: string) {
-  const parts = (title: string, held: Draft): Parts => {
+  const parts = (name: string, held: Draft): Parts => {
     const kept = taskCreation(held) ?? { type: 'task', fields: { done: false }, sections: {} };
-    return { creation: { ...kept, fields: { ...kept.fields, title } } };
+    return { creation: { ...kept, fields: { ...kept.fields, name } } };
   };
   const adding = drafts
     .current()
     .find((draft) => draft.room === room && draft.path.startsWith('tasks/') && taskCreation(draft));
   let path = adding?.path ?? `tasks/${crypto.randomUUID()}.md`;
-  return titleForm(
+  return nameForm(
     'Add',
     room,
     () => path,
     '',
     parts,
-    (title) => {
-      title.value = '';
+    (name) => {
+      name.value = '';
       path = `tasks/${crypto.randomUUID()}.md`;
     },
   );

package/guide/apps/example-tasks-3.md

@@ -23,7 +23,7 @@ function draw(): void {
     note.textContent = '';
     if (room === undefined) main.replaceChildren('This App has no Room yet.');
     else if (open !== undefined)
-      main.replaceChildren(editForm(open.room, open.path, open.fields!.title), note);
+      main.replaceChildren(editForm(open.room, open.path, open.fields!.name), note);
     else main.replaceChildren(list, addForm(room.locator), note);
   }
   if (!('pending' in answer)) shown();
@@ -35,7 +35,7 @@ function draw(): void {
     const done = task.fields!.done === true;
     const box = el('input', { type: 'checkbox', checked: done, ariaLabel: 'Done' });
     box.onchange = () => void queued(() => toggle(task.room, task.path, done));
-    const link = el('a', { href: task.path }, String(task.fields!.title));
+    const link = el('a', { href: task.path }, String(task.fields!.name));
     link.onclick = (event) => {
       event.preventDefault();
       void bridge.push(`/${task.path}`);

package/guide/apps/example-tasks.md

@@ -2,17 +2,17 @@
 
 A whole tasks App over one Room, keeping every rule of the App pages; its `main.ts` goes on over two more pages.
 
-`schema.yaml`, also written into the Room's `settings/schema.yaml`:
+`schema.yaml`, also written into the Room's `settings/schema.yaml`, so a task reads as its `# Buy milk` line over a `- [ ] Done` line:
 
 ```yaml
 task:
   properties:
-    title: { type: string }
-    done: { type: boolean }
-  required: [title, done]
+    name: { type: string }
+    done: { type: boolean, title: Done }
+  required: [name, done]
 ```
 
-`app.json`, then `set_app_bindings` with slot `tasks`:
+`app.json`, then `apps/bindings/set` with slot `tasks`:
 
 ```json
 { "entry": "index.html", "room_slots": [{ "name": "tasks", "access": "write", "types": ["task"] }] }
@@ -23,51 +23,19 @@ task:
 ```ts
 import { houseBridge } from '@agentshouse/app-bridge';
 
-type Task = { top: number; field: string | null; start: number | null; end: number | null };
-
 const bridge = houseBridge();
 let shown!: () => void;
 const showing = new Promise<void>((resolve) => (shown = resolve));
 let writing: Promise<unknown> = Promise.resolve();
-const unsaved = new Set<HTMLInputElement>();
-bridge.cooperate({
-  checkpoint: () => showing,
-  async persist() {
-    await writing;
-    if ([...unsaved].some((title) => title.isConnected)) throw new Error('unsaved');
-  },
-  capture(): Task {
-    const at = document.activeElement;
-    const field = at instanceof HTMLInputElement && at.selectionStart !== null ? at : null;
-    return {
-      top: scrollY,
-      field: field?.ariaLabel ?? null,
-      start: field?.selectionStart ?? null,
-      end: field?.selectionEnd ?? null,
-    };
-  },
-  async restore(task) {
-    await showing;
-    const held = task as Task | null;
-    if (held === null) return;
-    const field = Array.from(document.querySelectorAll('input')).find(
-      (input) => held.field !== null && input.ariaLabel === held.field,
-    );
-    field?.focus({ preventScroll: true });
-    field?.setSelectionRange(held.start, held.end);
-    scrollTo(0, held.top);
-  },
-  ready: () => true,
-  settle() {},
-});
+bridge.cooperate({ placed: () => showing });
 const runtime = await bridge.runtime;
 const rooms = await runtime.observe('rooms');
 const sync = await runtime.observe('sync-status');
 const drafts = await runtime.observe('room-drafts');
 const tasks = await runtime.observe('query', {
   pathPrefix: 'tasks',
-  select: { fields: ['/title', '/done'] },
-  orderBy: [{ by: { field: '/title' } }],
+  select: { fields: ['/name', '/done'] },
+  orderBy: [{ by: { field: '/name' } }],
 });
 const main = document.querySelector('main')!;
 const list = document.createElement('div');

package/guide/apps/function-times.md

@@ -0,0 +1,10 @@
+# Times in an App function
+
+How a function reads its Room's local time and turns a date and time there into a moment and back, with no time-zone library.
+
+- **The event.** Beside `moment`, the UTC instant `Date` reads, the event carries the Room's `time_zone`, such as `Europe/Kyiv`, and the moment's `date` (`YYYY-MM-DD`) and `time` (`HH:MM:SS`) there, so the same day is the Room's day: `order.fields.delivery === event.date`.
+- **To a moment.** `await house.toMoment({ date: '2026-11-10', time: '13:00' })` answers the ISO instant of a date and an `HH:MM` or `HH:MM:SS` time in the Room's zone, `'2026-11-10T11:00:00.000Z'` in Kyiv. At daylight saving, a time the clocks skip takes the moment just after the gap, `04:00` for `03:30` on the day Kyiv's clocks jump from `03:00` to `04:00`, and a time they repeat takes its earlier moment.
+- **To the Room's time.** `await house.toLocal({ moment: event.moment })` answers the `time_zone`, `date` and `time` in the Room's zone of a date-time with its offset, written as a document's `date-time` field takes it.
+- **Each is a call to House** that counts as no external call and rejects what it refuses with its `code`: `invalid-time` for what is no date and time, or no date-time with its offset, and `unknown-room` for a `room_ref` naming any Room but the run's own.
+
+Next: [App functions](apps/functions)