@agentshouse/skills 0.1.0-c408aca84f8d3 → 0.1.0-c4e515a7252cb

package/README.md

@@ -23,9 +23,9 @@ 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 and `EARLIER_OWNER_RULES_SHA256` the earlier texts'
-digests.
+`agentInstructions(houseRef, copies)` returns the first prompt's lines, which name no Local copy,
+`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

@@ -4,7 +4,6 @@
     "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."
-  ],
-  "copies": "House Local copies; before work run `house fetch` and rebase onto `<house-ref>`; after it commit, then `house push`:"
+    "For another Agent's help, `send_routine_request` naming one of the Room's Routine cards under `house/routines/`, or the Agent and what you ask; its mail comes back into this conversation."
+  ]
 }

package/dist/index.d.ts

@@ -16,6 +16,6 @@ export declare const GUIDE_ROOT = "index";
 export declare const GUIDE: readonly GuidePage[];
 export declare const OWNER_RULES: string;
 export declare const EARLIER_OWNER_RULES_SHA256: readonly string[];
-export declare function agentInstructions(houseRef: string, copies: readonly string[]): string[];
+export declare function agentInstructions(_houseRef: string, _copies: readonly string[]): string[];
 export declare function listSkills(): readonly Skill[];
 export declare function readSkill(name: string): readonly SkillFile[];

package/dist/index.js

@@ -4,7 +4,6 @@ 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;
@@ -34,14 +33,8 @@ export const GUIDE = readdirSync(TREE, {
 export const OWNER_RULES = GUIDE.find((page) => page.path === OWNER_RULES_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 function agentInstructions(_houseRef, _copies) {
+    return [...INSTRUCTIONS.lines];
 }
 export function listSkills() {
     return readdirSync(SET, { withFileTypes: true })

package/guide/apps/functions.md

@@ -5,7 +5,7 @@ How an App declares a function that House runs on its servers when a Trigger fir
 - **Declare.** `app.json` lists `functions`, each `{"name": "assign lead", "entry": "functions/assign.js"}` ([App manifest](reference/app-manifest)). The entry is one ES module whose default export is the function and which imports nothing, so your build bundles each function, with all it imports, into `dist/`, such as `esbuild src/assign.ts --bundle --format=esm --outfile=dist/functions/assign.js`. A publish is refused whole for an entry that is missing, imports, has no default export or is over <function-size>, for a name used twice, and for more than <release-functions> functions.
 - **Run.** A Trigger's `function` action names the App and one of its functions ([Triggers](reference/triggers)). House runs the App's latest release when the Event's turn comes, one Event of a Trigger after another, so a run reads what the run before it wrote.
 - **The event.** `export default async (event, house) => {}` receives `kind`, the condition's `on`, with `room`, `trigger`, `id`, `moment` and what matched: `path` and `reference`, a document change's `transition`, an arriving item's `item` with its `headers` and raw `body` text, a dated document's `document`, or a delivered notification's `notification`, the facts of its web document. `Date` reads `moment`. The return value is ignored, so write what you keep into the Room.
-- **The App API.** `house` is the page's App API over the Trigger's Room alone: `query(q)` ([Local Query](apps/local-query)), `saveParts(room, parts)`, `call(name, input)` for the Room acts such as `record.list` and `member.list`, and `callExternal(request)`. `query` and `callExternal` reject a refusal with its `code` for the function to catch, while `call` answers it as a result whose `kind` is `rejected` and `saveParts` as `outcome: 'refused'`, as on the page, so check what they answer. Its writes are the App's, by `App <App> (function <function>)`, fire Triggers, its own included, and count against the Room owner's Write limit.
+- **The App API.** `house` is the page's App API over the Trigger's Room alone: `query(q)` ([Local Query](apps/local-query)), `saveParts(room, parts)`, `call(name, input)` for the Room acts, each by its House act name, such as `records/read` and `rooms/members`, and `callExternal(request)`. `query` and `callExternal` reject a refusal with its `code` for the function to catch, while `call` answers it as a result whose `kind` is `rejected` and `saveParts` as `outcome: 'refused'`, as on the page, so check what they answer. Its writes are the App's, by `App <App> (function <function>)`, fire Triggers, its own included, and count against the Room owner's Write limit.
 - **Reach.** A run holds no `fetch`, timer, file, `console` or `Intl`: keep times as ISO instants, or convert a local time by its UTC offset yourself. `callExternal` takes the request `bridge.callExternal` takes and is the one way out, to an origin the release's `external_origins` lists; naming its Room, `room_ref: event.room`, carries that Room's Service key, which the function never sees, or is refused `service_key_not_found` naming the `origin`. Its calls count against the Room owner's `external_calls` limit.
 - **Never repeated.** A run that started is never run again, even when it failed after a call reached the service. Send `event.id` as the service's idempotency key where it takes one, and name what you write by what the event carries, so a second delivery of the same thing finds it.
 - **Failure and limits.** A throw settles the run `failed` with `function_failed` and its text, which `list_trigger_events` shows and House tells the Room's owner; the next Event still runs. A run ends `failed` at <function-time>, at <function-memory> or past <function-calls> external calls: `time_cap_reached`, `memory_cap_reached` or `external_call_cap_reached`.

package/guide/reference/routine.md

@@ -2,7 +2,7 @@
 
 How a Routine document in the Private Room is written, one for each Room it serves.
 
-Routine, `/rooms/private/rooms/<room-handle>/routines/<name>.md`, serving the Room `<room-handle>` names: `description`; `input`, a text saying what to send, empty if nothing; and `agent`, the identifier of the one of your User's current Agents it starts. The body is the instruction, which never leaves the Private Room. Writing it needs your User's write in that Room. House writes its card, the description, input and Agent, at `/rooms/<room-handle>/house/routines/<name>.md`, where every member reads it, and refuses a name a card there already holds as `routine_name_taken`. A Routine a second Room needs is a copy under that Room's handle. A Routine Request's input is text the Agent reads, and House checks no shape.
+Routine, `/rooms/private/rooms/<room-handle>/routines/<name>.md`, serving the Room `<room-handle>` names: `description`; `input`, a text saying what to send, empty if nothing; and `agent`, the identifier of the one of your User's current Agents it starts. The body is the instruction, which never leaves the Private Room. Writing it needs your User's write in that Room. House writes its card, the description, input and Agent, at `/rooms/<room-handle>/house/routines/<name>.md`, where every member reads it, and refuses a name a card there already holds as `routine_name_taken`. A Routine a second Room needs is a copy under that Room's handle. Anyone who writes that Room asks it with `send_routine_request` naming the card, and may instead name the `agent` with their own words; either starts at once. A Routine Request's input is text the Agent reads, and House checks no shape. Mail your conversation sends with `send_mail` and a request it sent reaches the conversation that request started, and that conversation's mail comes back to yours.
 
 ```markdown
 ---

package/guide/reference/triggers.md

@@ -12,4 +12,4 @@ In your Private Room alone, a `function` action naming no `app` runs one of your
 
 A Trigger acts on at most <trigger-events-per-hour> Events in each UTC hour, counting the Events of every version of it but those kept skipped or failed; `list_trigger_events` shows each Event past that number `missed: "skipped"` with `code: "cap_reached"`, which starts nothing, and its creator is told once per version. A Trigger whose own actions make what it fires on stops there, so narrow its condition.
 
-A `routine` action names a Routine Access (`create_routine_access`), which runs a [Routine](reference/routine) on an Agent.
+A `routine` action starts a [Routine](reference/routine) of the Trigger's Room by its card `house/routines/<name>.md`: `{kind: "routine", card: "<name>", payload: "<input>"}`. No such card is refused `routine_not_found`; a retired Routine's Events show `routine_retired`.

package/guide/sites/build.md

@@ -10,7 +10,7 @@ Build it as [Build an App](apps/build) says, with what follows. Anything private
 - A Site is public: anyone opens it, nobody signs in, and every visitor reads its bound Rooms, which must be your User's own and never the Private Room.
 - Everything it shows lives as documents in its Room; put its demo data there, never in code.
 - A visitor's edits stay in their browser and never reach House: write them with `save` as an App does.
-- To receive messages from visitors, name an Intake Room with `set_site_intake_room` and send each with `runtime.call('submit', { content })`, online only.
+- To receive messages from visitors, name an Intake Room with `set_site_intake_room` and send each with `runtime.call('site/submission', { content })`, online only.
 - `describe_site` sets the title and description search engines show.
 - With `google_analytics_id` set by `describe_site`, House measures a visitor only after they accept. While `bridge.onStatus` reports `analytics.measures`, ask them on the Site unless `analytics.choice` holds their answer, report it with `bridge.analyticsConsent('accept')` or `bridge.analyticsConsent('decline')`, and keep a way on every page to decline later, which reloads the page unmeasured.
 - See it yourself: open its url, which needs no sign-in.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/skills",
-  "version": "0.1.0-c408aca84f8d3",
+  "version": "0.1.0-c4e515a7252cb",
   "description": "The upstream Skills agents.house serves its agents, verbatim, and the texts it writes for them: the Guide, its own Skills among the pages, and the Agent instructions",
   "license": "MIT",
   "type": "module",