@skillcdn/console 0.1.24 → 0.3.0

package/docs/specs/rest.md

@@ -197,7 +197,7 @@ Writing one, for whoever may work in the project, with a session or a token, is
 
 ### `GET /api/v1/projects/<key>/decisions?open=&task=&limit=&offset=`
 
-`{ "items": [decision, ...], "more": boolean }`: the project's, the ones that wait first, newest first within each, a page at a time as the tasks are (`limit`, `offset`, `more`); `open=true` keeps only those that wait, `task=<id>` only those about one task. A decision carries its `question`, `body` (Markdown: the context it rests on), `options` (each an `id` and a `label`), `taskId` and `taskNumber` (or `null`), `raisedBy`, `run` (the `id` and `agent` of the run that raised it, when an agent asked, or `null`), `answer`: `null` while it waits, else the chosen `option`, a `note` or `null` (the rationale given with it), `by` and `at`; and `outcome`, what followed, in Markdown, or `null` until someone writes it. Context, rationale and outcome make the decision a record ([ADR-0009](../adr/0009-documents-are-pages-of-markdown-in-a-project-addressed-by-path-versioned-and-linked-both-ways.md)); a link in any of them to a document's path is kept both ways, so that the document says the decision refers to it.
+`{ "items": [decision, ...], "more": boolean }`: the project's, the ones that wait first, newest first within each, a page at a time as the tasks are (`limit`, `offset`, `more`); `open=true` keeps only those that wait, `task=<id>` only those about one task. A decision carries its `question`, `body` (Markdown: the context it rests on), `options` (each an `id` and a `label`; the last carries `own: true` when it is the person's own answer, written instead of choosing, and the options given carry no `own`), `taskId` and `taskNumber` (or `null`), `raisedBy`, `run` (the `id` and `agent` of the run that raised it, when an agent asked, or `null`), `answer`: `null` while it waits, else the chosen `option`, a `note` or `null` (the rationale given with it), `by` and `at`; and `outcome`, what followed, in Markdown, or `null` until someone writes it. Context, rationale and outcome make the decision a record ([ADR-0009](../adr/0009-documents-are-pages-of-markdown-in-a-project-addressed-by-path-versioned-and-linked-both-ways.md)); a link in any of them to a document's path is kept both ways, so that the document says the decision refers to it.
 
 ### `POST /api/v1/projects/<key>/decisions`
 
@@ -207,7 +207,7 @@ Takes `question`, `options` (two to `MAX_OPTIONS` labels), and optionally `body`
 
 One decision. With `wait=<seconds>` (`0` to `600`) the request is held while the decision waits, up to the server's own bound (50 seconds), and answers the decision as it stands then: how an agent learns the answer at once, woken through the database's own channel, without asking again and again. A decision answered already, or a wait of `0`, answers at once.
 
-The answer takes `option` (the id of one of its options) and optionally a `note`. A decision is answered once; the answer records who gave it and when, writes a `decision.answered` event with the label of the option, and lets a run that waited go on (`status: running`), unless another decision of its still waits.
+The answer takes `option` (the id of one of its options) or `own` (the person's own answer, where none of the options is it: one line, up to `MAX_OPTION_LABEL_LENGTH`, as an option is worded; `request.invalid` with both or with neither), and optionally a `note`. An answer of the person's own becomes one more option of the decision, numbered after the ones given and marked `own: true`, and the one chosen, so that the answer names an option either way and every reader finds its label. A decision is answered once; the answer records who gave it and when, writes a `decision.answered` event with the label of the option, and lets a run that waited go on (`status: running`), unless another decision of its still waits.
 
 ### `PATCH /api/v1/projects/<key>/decisions/<id>`
 
@@ -245,19 +245,11 @@ Takes `status` (`finished`, `failed` or `abandoned`) and optionally a `summary`
 
 ### `GET /api/v1/projects/<key>/skills`
 
-The project's pack, as the SkillCDN deployment serves it at the project's address, or at the organization's (`SKILLS_ADDRESS`) when the project names none, read through `SKILLCDN_URL` ([ADR-0028](../adr/0028-the-console-reads-a-projects-pack-through-the-deployments-rest-api-with-a-pack-token-for-a-private-one.md)): `{ "address", "source", "page", "status", "items" }`. `address` is canonical, or `null` with `status: "none"` when neither names one; `source` is the deployment's origin and `page` where a person browses the address. When `ready`, `pack` names the pack as its manifest does, else its README, else the host (`name`, `description` and `language`, each or `null`), and `counts` says how many `skills` and `documents` the deployment indexed at the address; neither is there otherwise. `status` is `ready`, or why `items` is empty: `indexing` and `failed` as the deployment says of the repository, `not_found` when it does not serve the address to the console (a private pack is read with the project's pack token; without one the console asks as nobody, so a private repository is not read), `token_invalid` when the deployment refuses the pack token the project holds (expired, removed, or its maker lost the repository), `unavailable` when it could not be reached or read. An item is one skill: `name`, `description`, `directory` and `path` (of its `SKILL.md`, from the repository's root, which the routes below take), `page` (the skill at the deployment, for a person), `uri` (what an agent loads it by through its own SkillCDN connection, `skill://gh/<owner>/<repo>/<path>`, or `null`), and `translations` (the title and the description by language tag, as the repository gives them). The console keeps nothing of the skills: a public answer per address stands for a minute, then the deployment is asked again; what is read with a pack token is asked every time, and held for nobody.
+The project's pack, read by address ([ADR-0028](../adr/0028-the-console-reads-a-projects-pack-through-the-deployments-rest-api-with-a-pack-token-for-a-private-one.md), [ADR-0031](../adr/0031-the-console-reads-a-pack-as-the-skillcdn-command-does-and-a-local-one-from-a-directory.md)): at the project's address, or at the organization's (`SKILLS_ADDRESS`) when the project names none; at the SkillCDN deployment of `SKILLCDN_URL` for the address of a git host, with the pack token the project holds where the pack is private, and from the directory of `SKILLS_DIR` for a `local` address (`/local/<owner>/<name>`), read on the console's machine with the reading rules a deployment applies. `{ "address", "source", "page", "status", "refusal", "pack", "counts", "items", "mount" }`. `address` is canonical, or `null` with `status: "none"` when neither names one; `source` is the deployment's origin and `page` where a person browses the address there, both `null` for a pack read from a directory. When `ready`, `pack` names the pack as its manifest does, else its README, else the host (`name`, `description` and `language`, each or `null`), `counts` says how many `skills` and `documents` the index found, and `items` are the skills: `name`, `description`, `directory` and `path` (of its `SKILL.md`, from the repository's root, which the routes below take), `page` (the skill at the deployment, for a person, or `null`), `uri` (what an agent loads it by through its own SkillCDN connection, `skill://<host>/<owner>/<name>/<path>`, or `null`; one of a `local` pack means something on the console's machine and nowhere else), and `translations` (the title and the description by language tag, as the repository gives them). `mount` is what the address serves as the main repository's REST API answers it (`RestMount` of `@skillcdn/core`), for a program that renders what a model is given, or `null` when nothing was answered. `status` is `ready`, or why `items` is empty: `indexing` and `failed` as the pack says of itself, `not_found` when nothing is served to the console at the address (a private pack is read with the project's pack token; without one the console asks as nobody, so a private repository is not read; a `local` pack is not in the directory), `token_invalid` when the deployment refuses the pack token the project holds (expired, removed, or its maker lost the repository), `unavailable` when the pack could not be reached or read; `refusal` carries the pack's own `code` and `message` then, with `sourceUrl` and `directories` where it gave them (`null` and empty otherwise), and is `null` when the read went well. The console keeps nothing of the skills: a public answer per address stands for a minute, then the pack is asked again; what is read with a pack token is asked every time, and held for nobody.
 
-### `GET /api/v1/projects/<key>/skills/one?path=&cursor=` and `GET .../skills/file?path=&offset=&limit=`
+### `GET /api/v1/projects/<key>/skills/one?path=&cursor=`, `.../skills/file?path=&offset=&limit=`, `.../skills/browse?path=&cursor=&limit=` and `.../skills/find?query=&path=&cursor=&limit=`
 
-One skill of the pack, and a file of it, read by the console from the deployment for whoever may see the project, with the pack token where the project holds one ([ADR-0028](../adr/0028-the-console-reads-a-projects-pack-through-the-deployments-rest-api-with-a-pack-token-for-a-private-one.md)); each read is logged with who read what, never with what was read. `path` is the path from the repository's root, up to 500 characters; a query that is not one is `request.invalid`.
-
-`skills/one` is the deployment's `load_skill`, in the console's shape: `{ "address", "source", "page", "status", "skill" }`, `skill` being `null` unless `status` is `ready`, else `path`, `directory`, `name`, `description`, `rules` (the manifests that hold for the skill, from the repository's root to the nearest, each `path`, `body` and `truncated`), `body`, `included` (the files the skill includes, the same way), `files` (the paths of the skill's own files), `references` (each `path` and `status`: `available`, `blocked`, `missing` or `outside_mount`), `complete` and `nextCursor` (a page may end inside a rule or a file; the next page continues it, and the skill is whole only when `complete`), `serving` (`full`, whether the skill is served whole or described only under its license; `license`; `sourceUrl`, where it is read at its host) and `warnings`. `skills/file` is `read_repo_file`: `{ "address", "source", "status", "file", "folder" }`, `file` being the page (`path`, `content`, `offset`, `nextOffset` or `null` at the end, `totalLength`, in characters; `limit` 1 to 100,000) or `folder` what a folder holds (`path`, `entries` of `path`, `kind` and `size`, `truncated`), both `null` unless `ready`; `failed` here is a file the deployment will not carry, too large or not text.
-
-### `GET /api/v1/projects/<key>/skills/browse?path=&cursor=&limit=` and `GET .../skills/find?query=&path=&cursor=&limit=`
-
-What a folder of the pack holds, and what words find in it, read the same way: the deployment's `browse_repo` and `search_repo` in the console's shape, for whoever may see the project, with the pack token where the project holds one ([ADR-0028](../adr/0028-the-console-reads-a-projects-pack-through-the-deployments-rest-api-with-a-pack-token-for-a-private-one.md)); each read is logged with who read which folder, never with the words searched for. `path` is a folder's path from the repository's root, up to 500 characters, the mounted folder when left out; `cursor` continues one listing; a query out of bounds is `request.invalid`.
-
-`skills/browse` answers `{ "address", "source", "page", "status", "folder" }`, `folder` being `null` unless `ready`, else the folder's `path`, its `overview` (the README that introduces it: `path`, `title` and `description`, or `null`), its `entries`, each with `kind` (`skill`, `directory` or `file`), `path` (of the `SKILL.md` for a skill), `name` and `description` (or `null`), `skillCount` and `documentCount` (what a folder holds), `size` (a file's, in bytes, or `null`), `overviewPath` (a folder's README, or `null`), `license` and `describedOnly` (a skill's: whether the address only describes it under its license), and `nextCursor` (or `null` at the end; `limit` 1 to 200, 50 unless given). `skills/find` answers `{ "address", "source", "page", "status", "found" }`, `found` being `null` unless `ready`, else the `query` (1 to 500 characters, required), the `path` the search was kept to (or `null`), `items` in relevance order, a `skill` as the listing's item with the `files` of it that matched (each `path`, `title` and `summary`), `moreFiles`, `license` and `describedOnly`, or a `document` with its `path`, `title`, `summary` and `skillDirectory` (or `null`), and `nextCursor` (`limit` 1 to 25, 10 unless given). Words are matched, not meaning, in the language the pack is written in; the deployment's listing of a mount is bounded, and these two are how the rest of a large pack is reached.
+One skill of the pack, a file of it, what a folder holds and what words find, read by the console from the pack for whoever may see the project, with the pack token where the project holds one ([ADR-0028](../adr/0028-the-console-reads-a-projects-pack-through-the-deployments-rest-api-with-a-pack-token-for-a-private-one.md)), and answered as the pack answered them ([ADR-0031](../adr/0031-the-console-reads-a-pack-as-the-skillcdn-command-does-and-a-local-one-from-a-directory.md)): `{ "address", "source", "page", "status", "refusal", "read" }`, the envelope as above, and `read` the body of the matching route of the main repository's REST API, as `@skillcdn/core` spells it, or `null` unless `ready`. `skills/one` is `load_skill`: `read` is a `RestSkill`, a page of the skill's context, the rules from the repository's root to the nearest manifest, the body and the included files, which `complete` and `nextCursor` say to continue, and `commit`, the commit it was read from. `skills/file` is `read_repo_file`: `read` is a `RestFile`, a page of the file in characters (`offset`, `nextOffset`, `totalLength`; `limit` 1 to 100,000) or, when the path names a folder, its entries. `skills/browse` is `browse_repo`: `read` is a `RestBrowse`, a page of what the folder holds (`limit` 1 to 200, 50 unless given; `cursor` continues). `skills/find` is `search_repo`: `read` is a `RestFind`, a page of what the words find in relevance order (`query` 1 to 500 characters, required; `limit` 1 to 25, 10 unless given). `path` is a path from the repository's root, up to 500 characters, the mounted folder when `browse` and `find` leave it out; a query out of bounds is `request.invalid`. Each read is logged with who read what of which pack, never with what was read or the words searched for. What the pack refuses is the status with the pack's own `refusal`: a skill or a file that is not there is `not_found`, a file the pack will not carry, too large or not text, is `failed` with where it is at its source. `@skillcdn/core` reads every `read` back as the result it was made from (`skillResultOf`, `fileResultOf`, `directoryResultOf`, `browseResultOf`, `findResultOf`, at the `mountSummaryOf` of the listing's `mount`) and renders what a model is given; the command does exactly that.
 
 ### `PUT /api/v1/projects/<key>/pack-token` and `DELETE .../pack-token`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillcdn/console",
-  "version": "0.1.24",
+  "version": "0.3.0",
   "description": "What a custom SkillCDN console is built from: the API client and schemas, the components, the composition of the default console, and the console command agents work the board with.",
   "license": "MIT",
   "homepage": "https://github.com/skillcdn/console#readme",
@@ -68,6 +68,7 @@
     "vitest": "^5.0.3"
   },
   "dependencies": {
+    "@skillcdn/core": "^0.3.0",
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
     "zod": "^4.6.5"

package/skills/deploying-a-console/SKILL.md

@@ -5,7 +5,7 @@ license: MIT
 compatibility: Needs a shell with Node.js 24 or newer, git, curl, jq and the AWS CLI v2, the gh command signed in or an empty repository the person made, network access to AWS, Cloudflare, GitHub and npm, an AWS account and a domain on Cloudflare the person can create a key and a token for, and a browser on any device for the few steps only a signed-in person can take. Works in any agent that can run a shell and write files; on Windows, in Git Bash with path conversion off.
 metadata:
   author: skillcdn
-  version: "1.1"
+  version: "1.2"
 skillcdn:
   translations:
     ko:
@@ -14,7 +14,7 @@ skillcdn:
 ---
 # Deploying a console for an organization
 
-What goes in: an AWS account, a domain on Cloudflare or one to buy, and the answers to a few plain questions. What comes out: the console at `https://<hostname>`, signed in by its first administrator, with a first project and an agent connected; running as containers on AWS next to a managed PostgreSQL and a bucket, reached only through Cloudflare, every secret in a parameter store; a private deployment repository whose every push rebuilds and redeploys; a budget alert; and a record, `DEPLOY.md`, of what exists and how it is run. The person never needs to know the cloud: every choice is derived from their answers, shown with its cost, and changed when they ask. The shape and why it was chosen are [ADR-0017](/docs/adr/0017-the-reference-deployment-is-the-image-on-aws-behind-cloudflare-written-as-a-skill.md); what the console asks of any platform is [deploy/README.md](/deploy/README.md).
+What goes in: an AWS account, a domain on Cloudflare or one to buy, and the answers to a few plain questions. What comes out: the console at `https://<hostname>`, signed in by its first administrator, with a first project and an agent connected; running as containers on AWS next to a managed PostgreSQL and a bucket, reached only through Cloudflare, every secret in a parameter store; a private deployment repository whose every push rebuilds and redeploys; a budget alert; and a record, `DEPLOY.md`, of what exists and how it is run. The person never needs to know the cloud: every choice is derived from their answers, shown with its cost, and changed when they ask. The shape and why it was chosen are [ADR-0017](/docs/adr/0017-the-reference-deployment-is-the-image-on-aws-behind-cloudflare-written-as-a-skill.md); what the console asks of any platform is [deploy/README.md](/deploy/README.md). For one machine, a trial, or a closed network that reaches no cloud, the smallest install of [deploy/README.md](/deploy/README.md#the-smallest-install-and-a-closed-network) is the shape, not this skill: the image next to PostgreSQL with the packs in a directory, carried in where nothing is reachable.
 
 ## How the person is involved
 

package/skills/working-the-board/SKILL.md

@@ -5,7 +5,7 @@ license: MIT
 compatibility: Needs a shell with the console command on the PATH (npm install -g @skillcdn/console, Node.js 24 or newer), signed in by a person. Nothing else; the command needs no key of its own and the agent never sees a token.
 metadata:
   author: skillcdn
-  version: "1.17"
+  version: "1.19"
 skillcdn:
   translations:
     ko:
@@ -41,7 +41,7 @@ The full contract is the [specification of the command line](/docs/specs/cli.md)
 | Input | Source |
 |---|---|
 | The task | Its number (`#7`) or its id, from what the person said. Told to pick one, `console work` lists what is on the person's plate across their projects, the sooner due first (`--person <login>` another person's, for an administrator or an owner of a project they are in), and `console tasks --state ready --mine` what is ready and theirs in this one (`--due overdue`, `--due week`, `--category <key>` and `--goal <id>` narrow it further); a task is never taken without being told which, or that any ready one may be. |
-| The work | The task's body, read with `console task <number>`: what to make, where, the milestones, what to ask; the comments on it, which are the discussion so far, printed with the task, their pictures saved with `console file <id>`; with its plan, the category, the goal it works towards (`console goal <id>` says what reaching it means, its category and the days it starts and is meant to be reached by) and the days it starts and is due, which the reports and the summary keep to. The pages it links to (`console doc <path>`) and the project's pack (`console skills` lists its skills and says how many skills and documents it has; `console skills <folder>` shows what a folder of it holds, `console skills --search <words>` what the words find in it; `console skill <path>` reads one whole through the console, its rules first, a private pack through the pack token the project holds, [ADR-0028](/docs/adr/0028-the-console-reads-a-projects-pack-through-the-deployments-rest-api-with-a-pack-token-for-a-private-one.md); `console skill --file <file>` a file of it; a host that lists skills through a connection of its own loads them by their URI) say the rest. |
+| The work | The task's body, read with `console task <number>`: what to make, where, the milestones, what to ask; the comments on it, which are the discussion so far, printed with the task, their pictures saved with `console file <id>`; with its plan, the category, the goal it works towards (`console goal <id>` says what reaching it means, its category and the days it starts and is meant to be reached by) and the days it starts and is due, which the reports and the summary keep to. The pages it links to (`console doc <path>`) and the project's pack (`console skills` says where the pack is, what a client is told of it on connect, and every skill and document; `console skills <folder>` shows what a folder of it holds, `console skills --search <words>` what the words find in it; `console skill <path>` reads one whole through the console, its rules first, as an MCP client's model is given it, a private pack through the pack token the project holds, [ADR-0028](/docs/adr/0028-the-console-reads-a-projects-pack-through-the-deployments-rest-api-with-a-pack-token-for-a-private-one.md), and a pack on the console's own machine from its directory, [ADR-0031](/docs/adr/0031-the-console-reads-a-pack-as-the-skillcdn-command-does-and-a-local-one-from-a-directory.md); `console skill --file <file>` a file of it; a host that lists skills through a connection of its own loads them by their URI, which means nothing elsewhere for a pack on the console's machine) say the rest. |
 | The rules | The workspace's, the console's own until an administrator writes the organization's, and this project's own when it has them: which skills to load first, where the work lives, the pages, what may be decided alone, how to report ([ADR-0023](/docs/adr/0023-the-rules-of-a-board-are-pages-the-workspace-and-its-projects-keep-read-first-by-every-agent.md)). `console take` prints them with the task, so they are read once, there; `console rules` reads them without taking, as when a task is still to be chosen. They hold over this skill's defaults where they differ. |
 
 ## Workflow
@@ -62,7 +62,7 @@ The work happens where it happens: in the repository, the document, the tool. At
 
 ### Phase 4: Ask when a person must decide
 
-A choice the body does not settle, a trade-off, a cost, a change of scope: `console ask "<question>" --option "<one>" --option "<another>" --body "<what they need to know>"`. The run waits for the answer; the command waits a minute and exits with `3` while it is still to come. Keep waiting with `console decision <id> --wait 100`, as often as needed, and meanwhile do only what does not depend on the answer. Act on the answer as given; what was answered is not asked again. Once acted on, `console decision <id> --outcome "<what followed>"` makes the decision read as a record.
+A choice the body does not settle, a trade-off, a cost, a change of scope: `console ask "<question>" --option "<one>" --option "<another>" --body "<what they need to know>"`. The run waits for the answer; the command waits a minute and exits with `3` while it is still to come. Keep waiting with `console decision <id> --wait 100`, as often as needed, and meanwhile do only what does not depend on the answer. Act on the answer as given, which may be the person's own words rather than one of the options, marked as theirs; what was answered is not asked again. Once acted on, `console decision <id> --outcome "<what followed>"` makes the decision read as a record.
 
 ### Phase 5: Hand in
 

package/src/api.ts

@@ -188,6 +188,7 @@ export {
   type RestMembers,
   type RestMePatch,
   type RestOrganization,
+  type RestPackRefusal,
   type RestPackTokenInput,
   type RestPeople,
   type RestPerson,
@@ -210,12 +211,9 @@ export {
   type RestRuns,
   type RestSkill,
   type RestSkillBrowse,
-  type RestSkillBrowseEntry,
   type RestSkillFile,
   type RestSkillFind,
-  type RestSkillFindItem,
   type RestSkillLoad,
-  type RestSkillPage,
   type RestSkills,
   type RestTask,
   type RestTaskCounts,
@@ -280,6 +278,7 @@ export {
   restMePatchSchema,
   restMeSchema,
   restOrganizationSchema,
+  restPackRefusalSchema,
   restPackTokenInputSchema,
   restPeopleSchema,
   restPersonPatchSchema,
@@ -300,16 +299,12 @@ export {
   restRunInputSchema,
   restRunSchema,
   restRunsSchema,
-  restSkillBrowseEntrySchema,
   restSkillBrowseSchema,
   restSkillFileSchema,
-  restSkillFindItemSchema,
   restSkillFindSchema,
   restSkillLoadSchema,
-  restSkillPageSchema,
   restSkillSchema,
   restSkillsSchema,
-  restSkillTextSchema,
   restTaskCountsSchema,
   restTaskInputSchema,
   restTaskLinkSchema,

package/src/cli/cli.ts

@@ -20,7 +20,7 @@ import {
   type RestSkillBrowse,
   type RestSkillFile,
   type RestSkillLoad,
-  type RestSkillPage,
+  type RestSkills,
   type RestTaskPatch,
 } from "../schemas.js";
 import {
@@ -75,11 +75,6 @@ import {
   formatRules,
   formatRun,
   formatRunLine,
-  formatSkillBrowse,
-  formatSkillFile,
-  formatSkillFind,
-  formatSkillLoad,
-  formatSkills,
   formatTask,
   formatTaskLine,
   formatVersion,
@@ -89,6 +84,22 @@ import {
 import { COMMAND_HELP, helpFor, ownSkillPath, usage } from "./help.js";
 import { describeInstall, type Install, updateCommandFor } from "./install.js";
 import type { NoticeStore } from "./notices.js";
+import {
+  bodyOfFile,
+  bodyOfFolder,
+  bodyOfSkill,
+  formatSkillBrowse,
+  formatSkillFile,
+  formatSkillFind,
+  formatSkillLoad,
+  formatSkills,
+  joinFile,
+  joinFolder,
+  joinSkill,
+  type PackSummary,
+  skillPathIn,
+  summaryOf,
+} from "./pack.js";
 import { createServeHandler, DEFAULT_SERVE_PORT, type Listen } from "./serve.js";
 
 // The `console` command (docs/specs/cli.md): the agent's side of the console. A thin client of
@@ -1003,10 +1014,19 @@ const MAX_SKILL_PAGES = 64;
 /** How many results a search answers at most: what the deployment allows on one page. */
 const MAX_FIND_LIMIT = 25;
 
+/** The pack of the project as the console lists it, and what its reads are rendered at; none when the pack did not answer. */
+async function packOf(
+  project: ProjectClient,
+): Promise<{ readonly listing: RestSkills; readonly summary: PackSummary | undefined }> {
+  const listing = await project.skills();
+  return { listing, summary: summaryOf(listing) };
+}
+
 const skills: Command = async (args, io) => {
   const { values, positionals } = parse(args, {
     search: { type: "string" },
     limit: { type: "string" },
+    cursor: { type: "string" },
   });
   if (positionals.length > 1) {
     throw misuse("Say one folder: console skills [<folder>] [--search <words>]");
@@ -1016,8 +1036,11 @@ const skills: Command = async (args, io) => {
   const folder = given === undefined || given === "/" || given === "." ? undefined : given;
   const words = text(values, "search");
   const limit = text(values, "limit");
-  if (words === undefined && limit !== undefined) {
-    throw misuse("--limit goes with --search: console skills --search <words> [--limit <n>]");
+  const cursor = text(values, "cursor");
+  if (words === undefined && (limit !== undefined || cursor !== undefined)) {
+    throw misuse(
+      "--limit and --cursor go with --search: console skills --search <words> [--limit <n>] [--cursor <cursor>]",
+    );
   }
   const atMost = limit === undefined ? undefined : Number(limit);
   if (
@@ -1028,37 +1051,41 @@ const skills: Command = async (args, io) => {
   }
   const session = await open(io, values);
   const project = await session.project();
+  const { listing, summary } = await packOf(project);
+  // The pack as it stands; or why it does not answer, which a folder or a search would meet too.
+  if (summary === undefined || (words === undefined && given === undefined)) {
+    answer(io, session, listing, () => formatSkills(listing, io.skillsDir));
+    return EXIT.ok;
+  }
   if (words !== undefined) {
-    // One page of what the words find; more is said, and narrowed by the agent, not fetched.
-    const found = await project.skillFind(words, { path: folder, limit: atMost });
-    answer(io, session, found, () => formatSkillFind(found));
+    // One page of what the words find; more is said, and asked for with --cursor.
+    const found = await project.skillFind(words, { path: folder, limit: atMost, cursor });
+    answer(io, session, found, () => formatSkillFind(found, summary));
     return EXIT.ok;
   }
-  if (given !== undefined) {
-    // The folder whole: its pages until the end, as the deployment lists them.
-    const folders: NonNullable<RestSkillBrowse["folder"]>[] = [];
-    let cursor: string | undefined;
-    let last: RestSkillBrowse | undefined;
-    for (let n = 0; n < MAX_SKILL_PAGES; n += 1) {
-      last = await project.skillBrowse({ path: folder, cursor });
-      if (last.status !== "ready" || last.folder === null) {
-        break;
-      }
-      folders.push(last.folder);
-      if (last.folder.nextCursor === null) {
-        break;
-      }
-      cursor = last.folder.nextCursor;
+  // The folder whole: its pages until the end, as the pack lists them.
+  const pages: RestSkillBrowse[] = [];
+  let next: string | undefined;
+  let last: RestSkillBrowse | undefined;
+  for (let n = 0; n < MAX_SKILL_PAGES; n += 1) {
+    last = await project.skillBrowse({ path: folder, cursor: next });
+    if (last.read?.status !== "ready") {
+      break;
     }
-    if (last === undefined) {
-      throw failed("The folder could not be read.");
+    pages.push(last);
+    next = last.read.nextCursor ?? undefined;
+    if (next === undefined) {
+      break;
     }
-    const browsed = last;
-    answer(io, session, { ...browsed, folders }, () => formatSkillBrowse(browsed, folders));
-    return EXIT.ok;
   }
-  const found = await project.skills();
-  answer(io, session, found, () => formatSkills(found, io.skillsDir));
+  if (last === undefined) {
+    throw failed("The folder could not be read.");
+  }
+  const browsed = last;
+  const whole = joinFolder(pages, summary);
+  answer(io, session, { ...browsed, read: whole === undefined ? null : bodyOfFolder(whole) }, () =>
+    formatSkillBrowse(browsed, whole),
+  );
   return EXIT.ok;
 };
 
@@ -1074,84 +1101,73 @@ const skill: Command = async (args, io) => {
   }
   const session = await open(io, values);
   const project = await session.project();
+  const { listing, summary } = await packOf(project);
+  if (summary === undefined) {
+    answer(io, session, listing, () => formatSkills(listing, io.skillsDir));
+    return EXIT.ok;
+  }
   if (file !== undefined) {
-    // The file whole, page after page, as the console reads it from the deployment.
-    const parts: string[] = [];
+    // The file whole, page after page, as the console reads it from the pack.
+    const pages: RestSkillFile[] = [];
     let offset: number | undefined;
     let last: RestSkillFile | undefined;
-    for (let pages = 0; pages < MAX_SKILL_PAGES; pages += 1) {
+    for (let n = 0; n < MAX_SKILL_PAGES; n += 1) {
       last = await project.skillFile(file, offset === undefined ? {} : { offset });
-      if (last.status !== "ready" || last.file === null) {
+      if (last.read === null) {
         break;
       }
-      parts.push(last.file.content);
-      if (last.file.nextOffset === null) {
+      pages.push(last);
+      if (last.read.kind !== "file" || last.read.nextOffset === null) {
         break;
       }
-      offset = last.file.nextOffset;
+      offset = last.read.nextOffset;
     }
     if (last === undefined) {
       throw failed("The file could not be read.");
     }
-    const read = last;
-    const content = parts.join("");
-    answer(io, session, { ...read, content }, () => formatSkillFile(read, content));
+    const fileRead = last;
+    const whole = joinFile(pages, summary);
+    answer(io, session, { ...fileRead, read: whole === undefined ? null : bodyOfFile(whole) }, () =>
+      formatSkillFile(fileRead, whole),
+    );
     return EXIT.ok;
   }
-  const { path, pack } = skillPathOf(
+  const wanted = skillPathIn(
     theOne(
       positionals,
       "Say which skill: console skill <path of its SKILL.md>, or console skill --file <path> for a file of the pack",
     ),
+    listing.address,
   );
+  if ("error" in wanted) {
+    throw misuse(wanted.error);
+  }
   // The skill whole: its pages until complete, the rules first, as load_skill lays them out.
-  const pages: RestSkillPage[] = [];
+  const pages: RestSkillLoad[] = [];
   let cursor: string | undefined;
   let last: RestSkillLoad | undefined;
   for (let n = 0; n < MAX_SKILL_PAGES; n += 1) {
-    last = await project.skill(path, cursor);
-    if (last.status !== "ready" || last.skill === null) {
+    last = await project.skill(wanted.path, cursor);
+    if (last.read?.status !== "ready") {
       break;
     }
-    pages.push(last.skill);
-    if (last.skill.complete || last.skill.nextCursor === null) {
+    pages.push(last);
+    cursor = last.read.skill.nextCursor ?? undefined;
+    if (last.read.skill.complete === true || cursor === undefined) {
       break;
     }
-    cursor = last.skill.nextCursor;
   }
   if (last === undefined) {
     throw failed("The skill could not be read.");
   }
-  // A URI of another pack would read this pack's skill at the same path, or nothing: said instead.
-  if (pack !== undefined && last.address !== null && last.address !== pack) {
-    throw misuse(
-      `That URI is of another pack, ${pack}; this project's pack is at ${last.address}. Say the path of the SKILL.md, or a URI console skills lists.`,
-    );
-  }
   const loaded = last;
-  answer(io, session, { ...loaded, pages }, () => formatSkillLoad(loaded, pages));
+  const whole = joinSkill(pages, summary);
+  answer(io, session, { ...loaded, read: whole === undefined ? null : bodyOfSkill(whole) }, () =>
+    formatSkillLoad(loaded, whole),
+  );
   return EXIT.ok;
 };
 
-/**
- * A skill's path as given, or taken out of the URI `console skills` lists beside it
- * (`skill://gh/<owner>/<repo>/<path>`), with the pack the URI names, for the read to check.
- */
-function skillPathOf(given: string): { readonly path: string; readonly pack?: string } {
-  const uri = /^skill:\/\/(gh\/[^/]+\/[^/]+)\/(.+)$/.exec(given);
-  const named = uri?.[1];
-  const within = uri?.[2];
-  if (named !== undefined && within !== undefined) {
-    return { path: within, pack: `/${named}` };
-  }
-  if (given.startsWith("skill://")) {
-    throw misuse(
-      `Not a skill's URI the console knows: ${given}. Say the path of its SKILL.md from the repository's root, or the URI console skills lists.`,
-    );
-  }
-  return { path: given };
-}
-
 /** A version number given as a flag, or nothing; anything else is not understood. */
 function versionOf(given: string | undefined): number | undefined {
   if (given === undefined) {