@skillcdn/console 0.1.22 → 0.1.24

package/docs/specs/rest.md

@@ -121,7 +121,7 @@ The rules of the board ([ADR-0023](../adr/0023-the-rules-of-a-board-are-pages-th
 
 ### `GET /api/v1/work`
 
-`{ "tasks": [{ "project": { "key", "name", "color", "symbol", "icon" }, "task" }, ...], "decisions": [{ "project", "decision" }, ...] }`: what is on the asker's plate across the projects they may see ([ADR-0019](../adr/0019-a-task-is-planned-in-days-the-board-keeps-its-moments-and-goals-and-categories-give-the-work-its-shape.md)): the open tasks assigned to them, the sooner due first and those with no day last, and the decisions that wait for a person, the longest waiting first; each with the project it belongs to, so that a page says and links it. At most `LIST_LIMIT` of each.
+`{ "tasks": [{ "project": { "key", "name", "color", "symbol", "icon" }, "task" }, ...], "closed": [{ "project", "task" }, ...], "decisions": [{ "project", "decision" }, ...] }`: what is on the asker's plate across the projects they may see ([ADR-0019](../adr/0019-a-task-is-planned-in-days-the-board-keeps-its-moments-and-goals-and-categories-give-the-work-its-shape.md)): the open tasks assigned to them, the sooner due first and those with no day last; `closed`, the tasks assigned to them that are done or dropped and not yet put away, the last closed first, so that the week on the plate's page shows them on their days as a project's calendar does; and the decisions that wait for a person, the longest waiting first; each with the project it belongs to, so that a page says and links it. A task put away is in neither list ([ADR-0030](../adr/0030-a-task-is-put-away-from-any-state.md)). At most `LIST_LIMIT` of each.
 
 ### `GET /api/v1/tokens` and `POST /api/v1/tokens`
 
@@ -141,7 +141,7 @@ An administrator's sight of everyone's agents ([ADR-0011](../adr/0011-an-agent-c
 
 ### `GET /api/v1/people/<id>/work`
 
-`{ "tasks": [{ "project", "task" }, ...] }`: what is on another person's plate, for whoever oversees them: an administrator, or an owner of a project the person is in (everyone of the workspace is in a project open to it; a private one holds those listed), signed in or through their agent. The person's open tasks, the sooner due first and those with no day last, within the projects the asker may see and no other, each with its project; the decisions are left out, since they wait for anyone. `auth.forbidden` for anyone else; `person.not_found` for an id that is nobody's.
+`{ "tasks": [{ "project", "task" }, ...], "closed": [{ "project", "task" }, ...] }`: what is on another person's plate, for whoever oversees them: an administrator, or an owner of a project the person is in (everyone of the workspace is in a project open to it; a private one holds those listed), signed in or through their agent. The person's open tasks, the sooner due first and those with no day last, and as `closed` their tasks done or dropped and not yet put away, both within the projects the asker may see and no other, each with its project; the decisions are left out, since they wait for anyone. `auth.forbidden` for anyone else; `person.not_found` for an id that is nobody's.
 
 ### Connecting an agent
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillcdn/console",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "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",

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.16"
+  version: "1.17"
 skillcdn:
   translations:
     ko:
@@ -54,7 +54,7 @@ Told which task, go to phase 2: `console take` prints the rules of the board wit
 
 ### Phase 2: Take
 
-`console take <number>`. A run begins: the task is in progress and the person's, and every report, hand-in, question and ending from here acts on this run. Taken by mistake, `console abandon` leaves it and the task stays as it was.
+`console take <number>`. A run begins, and the command says its id: the task is in progress and the person's, and every report, hand-in, question and ending from here acts on this run. With another run of the person's open in the project, which `console take` says, each of those commands names the run: `--run <id>`. Taken by mistake, `console abandon` leaves it and the task stays as it was.
 
 ### Phase 3: Work, and report at the milestones
 
@@ -78,13 +78,7 @@ After the last report, `console finish --summary "<what was done, and what is le
 
 ## Setting up, when told to
 
-A task or a person may ask for the project itself rather than work in it: a project made or changed (`console project new <key> "<name>"`, `console project edit <key>`), its mark (`console project icon <key> <file>`), its members (`console member add <login>`, `console member role`, `console member remove`), the workspace's categories (`console category new <key> "<name>"`, `console category edit`, `console category remove`), what a person is (`console person role <login> <admin|member>`), its goals (`console goal new`), and its rules (`console rules write --file <path>`, from [the example](references/project-rules.md); the workspace's with `--workspace`, for an administrator). The agent does these as its person may, an owner of the project or an administrator of the workspace ([ADR-0021](/docs/adr/0021-a-token-configures-as-its-person-does.md)); the feed names the agent beside the person on each. What the person may not, the console refuses (`auth.forbidden`): that step goes back to the person in the report, never worked around. `console people` and `console members` say who is who, by login.
-
-## The sentence a repository carries
-
-A repository whose checkouts are worked through a console says so in its agreement (AGENTS.md, or CLAUDE.md where that is the file agents read), in one sentence copied as it is and placed at the head of its workflow; a pack says it in the rules of its `SKILLCDN.md`, with `the checkout` for `this checkout`. The sentence binds the checkout to the console and says nothing of how: the command's help and this skill say how, and the repository's own agreement keeps saying how a change is committed and pushed.
-
-> **Bound to a console?** When `.skillcdn-console.json` is in this checkout, or `console whoami` names a project, work the task through that SkillCDN console (`console help` says how).
+A task or a person may ask for the project itself rather than work in it: a project made or changed, its mark, its members, the workspace's categories, what a person is, its goals, its rules. [references/setting-up.md](references/setting-up.md) says which commands do that, as the person may: an owner of the project, or an administrator of the workspace; a project's rules start from [references/project-rules.md](references/project-rules.md).
 
 ## Hard rules
 
@@ -93,9 +87,10 @@ A repository whose checkouts are worked through a console says so in its agreeme
 - The board's words are the vocabulary's own: states `idea`, `ready`, `in_progress`, `in_review`, `done` and `dropped`; priorities `low`, `normal`, `high` and `urgent`; a day is `2026-10-24`. Taking a task moves it, finishing moves it; it is not moved by hand around a run. When a task is started and when it is done, the board writes down itself: never typed.
 - The plan is the person's: a task's days, its category and its goal are changed (`console task edit`) only when the task says so or a person asks, and a goal is set or moved (`console goal new`, `console goal edit`) only when the person is an owner and said to.
 - The rules are the people's: `console rules write` only when a person asked for exactly that, and never to loosen what they ask of agents.
-- Exit codes: `0` done; `1` refused or unreachable, the reason on standard error as a code and words, which `console help <command>` names; `2` not understood; `3` a decision still waits.
+- Exit codes: `0` done; `1` refused or unreachable, the reason on standard error as a code and words, which `console help <command>` names; `2` not understood; `3` a decision still waits; `4` the command and the console do not go together, and standard error says which to update.
 - Everything sent is held to limits the console states (`console help <command>`); a refusal `request.invalid` names the field.
 
-## Terms
+## Beside this skill
 
-- **Task**: what is to be done, numbered per project, with its plan (a category, a goal, the days it starts and is due) and its moments (when it was started and done, which the board keeps). **Goal**: what the project works towards, on its roadmap, with the day it is meant to be reached by; its progress is its tasks. **Category**: a kind of work, the workspace's word for it, by key. **Run**: one agent at work on one task for one person, with its reports, what it handed in, and what it waits for. **Decision**: a question with options, which a person answers on the board. **Page**: a document of the project, Markdown at a path that does not change. **Project**: a board of its own, with its members and its skills address.
+- The sentence a repository's agreement carries to bind its checkouts to a console, and how a pack says it: [references/the-sentence.md](references/the-sentence.md).
+- The board's words, task, goal, category, run, decision, page and project, said once: [references/terms.md](references/terms.md).

package/skills/working-the-board/references/setting-up.md

@@ -0,0 +1,3 @@
+# Setting up, when told to
+
+A task or a person may ask for the project itself rather than work in it: a project made or changed (`console project new <key> "<name>"`, `console project edit <key>`), its mark (`console project icon <key> <file>`), its members (`console member add <login>`, `console member role`, `console member remove`), the workspace's categories (`console category new <key> "<name>"`, `console category edit`, `console category remove`), what a person is (`console person role <login> <admin|member>`), its goals (`console goal new`), and its rules (`console rules write --file <path>`, from [the example](project-rules.md); the workspace's with `--workspace`, for an administrator). The agent does these as its person may, an owner of the project or an administrator of the workspace ([ADR-0021](/docs/adr/0021-a-token-configures-as-its-person-does.md)); the feed names the agent beside the person on each. What the person may not, the console refuses (`auth.forbidden`): that step goes back to the person in the report, never worked around. `console people` and `console members` say who is who, by login.

package/skills/working-the-board/references/terms.md

@@ -0,0 +1,9 @@
+# Terms
+
+- **Task**: what is to be done, numbered per project, with its plan (a category, a goal, the days it starts and is due) and its moments (when it was started and done, which the board keeps).
+- **Goal**: what the project works towards, on its roadmap, with the day it is meant to be reached by; its progress is its tasks.
+- **Category**: a kind of work, the workspace's word for it, by key.
+- **Run**: one agent at work on one task for one person, with its reports, what it handed in, and what it waits for.
+- **Decision**: a question with options, which a person answers on the board.
+- **Page**: a document of the project, Markdown at a path that does not change.
+- **Project**: a board of its own, with its members and its skills address.

package/skills/working-the-board/references/the-sentence.md

@@ -0,0 +1,5 @@
+# The sentence a repository carries
+
+A repository whose checkouts are worked through a console says so in its agreement (AGENTS.md, or CLAUDE.md where that is the file agents read), in one sentence copied as it is and placed at the head of its workflow; a pack says it in the rules of its `SKILLCDN.md`, with `the checkout` for `this checkout`. The sentence binds the checkout to the console and says nothing of how: the command's help and the skill working-the-board say how, and the repository's own agreement keeps saying how a change is committed and pushed.
+
+> **Bound to a console?** When `.skillcdn-console.json` is in this checkout, or `console whoami` names a project, work the task through that SkillCDN console (`console help` says how).

package/src/cli/cli.ts

@@ -86,7 +86,7 @@ import {
   formatVersionLine,
   formatWork,
 } from "./format.js";
-import { COMMAND_HELP, helpFor, usage } from "./help.js";
+import { COMMAND_HELP, helpFor, ownSkillPath, usage } from "./help.js";
 import { describeInstall, type Install, updateCommandFor } from "./install.js";
 import type { NoticeStore } from "./notices.js";
 import { createServeHandler, DEFAULT_SERVE_PORT, type Listen } from "./serve.js";
@@ -339,11 +339,11 @@ async function currentRun(project: ProjectClient, values: Values): Promise<strin
   }
   if (items.length === 0) {
     throw failed(
-      "No run of yours is open in this project. Take a task first: console take <number>",
+      "run.none: no run of yours is open in this project. Take a task first: console take <number>; or name a run: --run <id>",
     );
   }
   throw failed(
-    `Several runs of yours are open; say which with --run <id>:\n${items.map((run) => `  ${formatRunLine(run)}`).join("\n")}`,
+    `run.ambiguous: several runs of yours are open in this project; say which with --run <id>:\n${items.map((run) => `  ${formatRunLine(run)}`).join("\n")}`,
   );
 }
 
@@ -851,14 +851,14 @@ const whoami: Command = async (args, io) => {
         ...(key === undefined
           ? []
           : [
-              "What this organization asks of agents: console rules. How the board is worked: the skill working-the-board, shipped with this command (console skills says where it is).",
+              `What this organization asks of agents: console rules. How the board is worked: the skill working-the-board, shipped with this command${io.skillsDir === undefined ? " (console skills says where it is)." : `: ${ownSkillPath(io.skillsDir)}`}`,
             ]),
         `This command is ${io.version ?? "of a version it does not know"}${io.install === undefined ? "" : `, ${describeInstall(io.install)}`}; ${consoleWords}.`,
         ...(verdict === "behind"
           ? [`A newer command exists. Update it: ${updateWords(io, me.console?.version)}`]
           : verdict === "ahead"
             ? [
-                `This command is newer than the console: what the console has not got yet is refused as not found. To match the console: ${updateWords(io, me.console?.version)}`,
+                `This command is newer than the console: it works, and what the console has not got yet is refused as not found; nothing to do until then. To match the console then: ${updateWords(io, me.console?.version)}`,
               ]
             : []),
       ].join("\n"),
@@ -1098,9 +1098,11 @@ const skill: Command = async (args, io) => {
     answer(io, session, { ...read, content }, () => formatSkillFile(read, content));
     return EXIT.ok;
   }
-  const path = theOne(
-    positionals,
-    "Say which skill: console skill <path of its SKILL.md>, or console skill --file <path> for a file of the pack",
+  const { path, pack } = skillPathOf(
+    theOne(
+      positionals,
+      "Say which skill: console skill <path of its SKILL.md>, or console skill --file <path> for a file of the pack",
+    ),
   );
   // The skill whole: its pages until complete, the rules first, as load_skill lays them out.
   const pages: RestSkillPage[] = [];
@@ -1120,11 +1122,36 @@ const skill: Command = async (args, io) => {
   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));
   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) {
@@ -1487,24 +1514,32 @@ const take: Command = async (args, io) => {
   });
   // The rules come with the run, as they read for the person: everything from here acts
   // within them (ADR-0023); the task is read again, as it stands now that it is taken.
-  const [ruling, me, taken, comments] = await Promise.all([
+  const [ruling, me, taken, comments, openRuns] = await Promise.all([
     project.rules(),
     session.client.me(),
     project.task(ref),
     project.comments(found.id),
+    project.runs({ open: true, mine: true }),
   ]);
   // Taking a task with a run open on it ends that run (ADR-0020): said when it happened.
   const tookOver =
     found.openRuns > 0
       ? " A run that was open on it is over now: the board cannot know whether its agent still ran, so taking it was deciding."
       : "";
+  // Another run of this token open in the project makes every command on a run ask which
+  // (currentRun): said here, with the id to say, before the first report runs into it.
+  const others = openRuns.items.filter((item) => item.id !== run.id);
+  const elsewhere =
+    others.length === 0
+      ? ""
+      : `\nOther runs of yours are open in this project (${others.map((item) => `#${item.taskNumber}`).join(", ")}): say which run on report, hand-in, ask, finish and fail, --run ${run.id} for this one.`;
   const rules = {
     workspace: forPerson(ruling.workspace, me.language),
     project: forPerson(ruling.project, me.language),
   };
   answer(io, session, { run, task: taken, comments: comments.items, rules }, () =>
     [
-      `Run ${run.id} began on #${found.number} ${found.title}, as "${run.agent}" for ${run.person.login}. The task is in progress and theirs.${tookOver}`,
+      `Run ${run.id} began on #${found.number} ${found.title}, as "${run.agent}" for ${run.person.login}. The task is in progress and theirs.${tookOver}${elsewhere}`,
       "",
       formatTask(taken, undefined, undefined, comments.items),
       "",
@@ -2540,7 +2575,7 @@ const COMMANDS: Readonly<Record<string, Command>> = {
 
 function help(io: CliIo, name: string | undefined): number {
   if (name === undefined) {
-    io.stdout(usage(io.version));
+    io.stdout(usage(io.version, io.skillsDir));
     return EXIT.ok;
   }
   const found = helpFor(name);
@@ -2614,7 +2649,7 @@ async function noticeVersions(io: CliIo, seen: ConsoleSeen): Promise<void> {
   io.stderr(
     verdict === "behind"
       ? `A newer command exists: the console runs ${seen.version}, this command is ${io.version}. Update it: ${updateWords(io, seen.version)}\n`
-      : `This command (${io.version}) is newer than the console (${seen.version}, which takes ${seen.range ?? "an older line"}): what the console has not got yet is refused as not found. The console's operator updates it; to match the console meanwhile: ${updateWords(io, seen.version)}\n`,
+      : `This command (${io.version}) is newer than the console (${seen.version}, which takes ${seen.range ?? "an older line"}): it works, and what the console has not got yet is refused as not found; nothing to do until then. The console's operator updates it; to match the console meanwhile: ${updateWords(io, seen.version)}\n`,
   );
   await io.notices?.save({
     command: io.version,

package/src/cli/format.ts

@@ -290,14 +290,18 @@ export function formatSkills(skills: RestSkills, ownSkills?: string): string {
   }
   if (skills.counts !== undefined) {
     lines.push(
-      `${counted(skills.counts.skills, "skill")}, ${counted(skills.counts.documents, "document")}: console skills <folder> shows what a folder holds (/ for the root), console skills --search <words> finds skills and documents by words.`,
+      `${counted(skills.counts.skills, "skill")}, ${counted(skills.counts.documents, "document")}: console skills <folder> shows what a folder holds (. for the root), console skills --search <words> finds skills and documents by words.`,
     );
   }
   if (skills.items.length === 0) {
     lines.push("No skills at this address.");
   }
+  // The path, which console skill takes, and the URI beside it, which a host's own connection takes.
   for (const skill of skills.items) {
-    lines.push(`${skill.name}  ${skill.description}`, `    ${skill.uri ?? skill.path}`);
+    lines.push(
+      `${skill.name}  ${skill.description}`,
+      `    ${skill.path}${skill.uri === null ? "" : `  ${skill.uri}`}`,
+    );
   }
   lines.push(
     "",

package/src/cli/help.ts

@@ -60,11 +60,21 @@ const COMMON_REFUSALS = [
   "network: the console could not be reached at its address",
 ];
 
+/** How a command on a run finds its run, and what it says when it cannot: the command's own refusals. */
+const RUN_CHOICE = [
+  "run.none: no run of yours is open in the project; take a task first, or name a run with --run <id>",
+  "run.ambiguous: several runs of yours are open in the project; say which with --run <id>",
+];
+
 const RUN_REFUSALS = [
+  ...RUN_CHOICE,
   "run.not_yours: the run is another person's",
   "run.over: the run has ended already",
 ];
 
+/** What every command on a run says of the run it acts on. */
+const ON_THE_RUN = "On your one open run in the project, or the one --run <id> names.";
+
 const MARKDOWN = `Markdown, up to ${MAX_BODY_LENGTH} characters`;
 
 const DOCUMENT_PATH = `a path of lowercase letters, digits and hyphens, with slashes between its folders (guides/onboarding), up to ${MAX_DOCUMENT_PATH_LENGTH} characters; it does not change once written`;
@@ -279,7 +289,7 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     synopsis:
       "The project's pack: its skills; what a folder of it holds; or what words find in it.",
     about:
-      "The project's pack, as SkillCDN serves it at the project's address, read by the console with the pack token the project holds where the pack is private (ADR-0028). Alone: the pack by name with how many skills and documents it has, and its skills, each with its description, the path of its SKILL.md, which console skill reads it by, and the URI you load it by through your own SkillCDN connection where your host has one; and where the console's own skills are on this machine. With a folder (/ for the root): what it holds, as browse_repo lays it out: its skills, its folders with how many skills and documents each holds and the README that introduces it, its files; whole, page after page. With --search: the skills and the documents the words find, in relevance order, a skill with the files of it that matched; words, not meaning, in the language the pack is written in; within the folder when one is named; 10 unless --limit says otherwise, up to 25, and a last line says when more matched. --json answers with the console's own JSON, the page of each skill included.",
+      "The project's pack, as SkillCDN serves it at the project's address, read by the console with the pack token the project holds where the pack is private (ADR-0028). Alone: the pack by name with how many skills and documents it has, and its skills, each with its description, the path of its SKILL.md, which console skill reads it by, and the URI you load it by through your own SkillCDN connection where your host has one; and where the console's own skills are on this machine. With a folder (. for the root): what it holds, as browse_repo lays it out: its skills, its folders with how many skills and documents each holds and the README that introduces it, its files; whole, page after page. With --search: the skills and the documents the words find, in relevance order, a skill with the files of it that matched; words, not meaning, in the language the pack is written in; within the folder when one is named; 10 unless --limit says otherwise, up to 25, and a last line says when more matched. --json answers with the console's own JSON, the page of each skill included.",
     limits: ["search: 1 to 500 characters; limit: 1 to 25"],
     refusals: [
       "status not_found: the pack is not served to the console; private, with no pack token on the project",
@@ -291,7 +301,7 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     synopsis:
       "One skill of the pack whole, its rules first; or with --file a file of the pack, or what a folder holds.",
     about:
-      "One skill of the project's pack, whole, as load_skill lays it out for you: the rules of the repository from its root to the nearest manifest, the skill's body, the files it includes, each under a line that names its path; then the files it has and what it refers to. Read by the console from the SkillCDN deployment, with the pack token the project holds where the pack is private, so you need no connection of your own. <path> is the path of the SKILL.md from the repository's root, as console skills lists it. --file <path> reads a file of the pack instead, whole, or what a folder holds, and takes no skill's path beside it; console skills <folder> shows a folder with more.",
+      "One skill of the project's pack, whole, as load_skill lays it out for you: the rules of the repository from its root to the nearest manifest, the skill's body, the files it includes, each under a line that names its path; then the files it has and what it refers to. Read by the console from the SkillCDN deployment, with the pack token the project holds where the pack is private, so you need no connection of your own. <path> is the path of the SKILL.md from the repository's root, as console skills lists it, or the URI it lists beside the path (skill://gh/<owner>/<repo>/<path>). --file <path> reads a file of the pack instead, whole, or what a folder holds, and takes no skill's path beside it; console skills <folder> shows a folder with more.",
     refusals: [
       "status not_found: the pack is not served to the console; private, with no pack token on the project",
       "status token_invalid: the pack token the project holds no longer works; an owner sets a new one",
@@ -325,10 +335,11 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     ],
   },
   report: {
-    usage: "report <markdown>  |  report --file <path>  |  report -",
+    usage:
+      "report <markdown> [--run <id>]  |  report --file <path> [--run <id>]  |  report - [--run <id>]",
+    overview: "report <markdown>  |  report --file <path>  |  report -",
     synopsis: "Says how the work goes, in Markdown, on the open run.",
-    about:
-      "Says how the work goes, in Markdown: what was found, what was done, what is next. With - the report is read from standard input.",
+    about: `Says how the work goes, in Markdown: what was found, what was done, what is next. With - the report is read from standard input. ${ON_THE_RUN}`,
     limits: [
       `the report: ${MARKDOWN}, not blank`,
       `at most ${MAX_REPORTS_PER_RUN} reports on one run`,
@@ -336,10 +347,10 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     refusals: [...RUN_REFUSALS, "run.too_many_reports: the run carries as many as one may"],
   },
   "hand-in": {
-    usage: "hand-in <https url | file path> [--label <words>]",
+    usage: "hand-in <https url | file path> [--label <words>] [--run <id>]",
+    overview: "hand-in <https url | file path> [--label <words>]",
     synopsis: "Hands in what was made: an https link, or a file from this machine.",
-    about:
-      "Hands in what was made: a link (a branch, a pull request, a document, a page), or a file from this machine, which the console keeps and shows on the task; a picture is shown there small and large, and a report that names it as ![words](its name) shows it where the words are.",
+    about: `Hands in what was made: a link (a branch, a pull request, a document, a page), or a file from this machine, which the console keeps and shows on the task; a picture is shown there small and large, and a report that names it as ![words](its name) shows it where the words are. ${ON_THE_RUN}`,
     limits: [
       "a link: https only",
       `a file: up to ${MAX_FILE_BYTES} bytes, not empty; it is called by its name, without the path`,
@@ -354,17 +365,18 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
   },
   ask: {
     usage:
+      'ask "<question>" --option "<label>" --option "<label>" [...] [--body <markdown>|--file <path>] [--wait <seconds>] [--run <id>]',
+    overview:
       'ask "<question>" --option "<label>" --option "<label>" [...] [--body <markdown>|--file <path>] [--wait <seconds>]',
     synopsis:
       "Raises a decision a person must make, with options, and waits a while for the answer.",
-    about:
-      "Raises a decision a person must make: the question, the options to choose from, and what they need to know. The run waits for the answer. The command waits 60 seconds for it unless --wait says otherwise, and exits with 3 if it is still to come: keep waiting with `console decision <id> --wait 100`, within what your shell gives one command. The decision's id is printed as soon as it is raised.",
+    about: `Raises a decision a person must make: the question, the options to choose from, and what they need to know. The run waits for the answer. The command waits 60 seconds for it unless --wait says otherwise, and exits with 3 if it is still to come: keep waiting with \`console decision <id> --wait 100\`, within what your shell gives one command. The decision's id is printed as soon as it is raised. ${ON_THE_RUN}`,
     limits: [
       `question: one line, up to ${MAX_QUESTION_LENGTH} characters`,
       `options: ${MIN_OPTIONS} to ${MAX_OPTIONS}, each one line up to ${MAX_OPTION_LABEL_LENGTH} characters`,
       `body: ${MARKDOWN}`,
     ],
-    refusals: ["decision.invalid_run: the run is not yours, or is over"],
+    refusals: [...RUN_CHOICE, "decision.invalid_run: the run is not yours, or is over"],
   },
   decision: {
     usage: "decision <id> [--wait <seconds>]  |  decision <id> --outcome <markdown>|--file <path>",
@@ -381,17 +393,18 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     about: `The decisions on the board, the waiting first; --open keeps only those. A page at a time: ${DEFAULT_PAGE_LIMIT} unless --limit says otherwise, from --offset on.`,
   },
   finish: {
-    usage: 'finish [--summary "<markdown>"|--file <path>]',
+    usage: 'finish [--summary "<markdown>"|--file <path>] [--run <id>]',
+    overview: 'finish [--summary "<markdown>"|--file <path>]',
     synopsis: "Ends the run: done and handed in; the task goes up for review.",
-    about:
-      "Ends the run: the work is done and handed in, and the task goes up for review. The summary says what was done and what is left; the result itself goes in a last report before, which may be much longer.",
+    about: `Ends the run: the work is done and handed in, and the task goes up for review. The summary says what was done and what is left; the result itself goes in a last report before, which may be much longer. ${ON_THE_RUN}`,
     limits: [`summary: ${`Markdown, up to ${MAX_SUMMARY_LENGTH} characters`}`],
     refusals: RUN_REFUSALS,
   },
   fail: {
-    usage: 'fail [--summary "<markdown>"|--file <path>]',
+    usage: 'fail [--summary "<markdown>"|--file <path>] [--run <id>]',
+    overview: 'fail [--summary "<markdown>"|--file <path>]',
     synopsis: "Ends the run: the work could not be done.",
-    about: "Ends the run: the work could not be done. The summary says why, and what is left.",
+    about: `Ends the run: the work could not be done. The summary says why, and what is left. ${ON_THE_RUN}`,
     limits: [`summary: Markdown, up to ${MAX_SUMMARY_LENGTH} characters`],
     refusals: RUN_REFUSALS,
   },
@@ -457,7 +470,7 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
     usage: 'write <path> [--title "<title>"] --body <markdown>|--file <path> [--base <version>]',
     synopsis: "Writes a page: a new one at a path, or a new version of the page there.",
     about:
-      "Writes a page: the first version at a new path, or a new version of the page there. A link in the body whose destination is a page's path (guides/onboarding) refers to that page, and the page says what refers to it. Without --title the page keeps its title. With --base, the write is refused if the page has moved on since that version.",
+      "Writes a page: the first version at a new path, or a new version of the page there. The title is shown above the body, on the page and by console doc, so the body does not begin with it as a heading. A link in the body whose destination is a page's path (guides/onboarding) refers to that page, and the page says what refers to it. Without --title the page keeps its title. With --base, the write is refused if the page has moved on since that version.",
     limits: [
       `path: ${DOCUMENT_PATH}`,
       `title: one line, up to ${MAX_TITLE_LENGTH} characters`,
@@ -510,13 +523,24 @@ export const COMMAND_HELP: Readonly<Record<string, CommandHelp>> = {
   },
 };
 
-/** The first lines of the usage, with the version of the command when it is known. */
-const preamble = (version: string | undefined): string =>
+/**
+ * Where the skill working-the-board is, among the console's own skills in `skillsDir`, with the
+ * separators the directory came with, so that the path reads as the machine writes paths.
+ */
+export function ownSkillPath(skillsDir: string): string {
+  const separator = skillsDir.includes("\\") ? "\\" : "/";
+  const base =
+    skillsDir.endsWith("/") || skillsDir.endsWith("\\") ? skillsDir : `${skillsDir}${separator}`;
+  return `${base}working-the-board${separator}SKILL.md`;
+}
+
+/** The first lines of the usage, with the version of the command and where its skill is, when known. */
+const preamble = (version: string | undefined, skillsDir: string | undefined): string =>
   `console${version === undefined ? "" : ` ${version}`}: the board of your organization's work with AI agents, from the command line.
 You act as the person whose token you hold; everything you send is shown to people as text.
 The rules of this organization come with the task: console take prints them; console rules reads them any time.
-How the board is worked is the skill working-the-board, installed with this command: console skills prints
-where it is; read it before the first command of a run.
+How the board is worked is the skill working-the-board, installed with this command; read it before the
+first command of a run${skillsDir === undefined ? " (console whoami says where it is)" : `:\n${ownSkillPath(skillsDir)}`}
 
 Usage: console <command> [arguments] [--json] [--url <origin>] [--project <key>]
 A command in full, every form and flag ([flags] below), the limits the console holds it to and what
@@ -532,7 +556,8 @@ with several open, say which with --run <id>. A Markdown body given as - is read
 console --version says which version of the command this is.
 
 Exit codes: 0 done; 1 the console refused, or could not be reached (the reason is on stderr);
-2 the command was not understood; 3 the decision still waits for a person.
+2 the command was not understood; 3 the decision still waits for a person; 4 the command and the
+console do not go together, and stderr says which to update and how.
 What the console refuses is printed as its code and its words. Everywhere:
 ${COMMON_REFUSALS.map((refusal) => `  ${refusal}`).join("\n")}
 
@@ -583,8 +608,8 @@ const SECTIONS: readonly { readonly title: string; readonly commands: readonly s
 ];
 
 /** The overview, as `console help` prints it: every command in a line, naming the version when it is known. */
-export function usage(version?: string): string {
-  const parts = [preamble(version)];
+export function usage(version?: string, skillsDir?: string): string {
+  const parts = [preamble(version, skillsDir)];
   for (const section of SECTIONS) {
     parts.push(`${section.title}`);
     for (const name of section.commands) {

package/src/components/work.tsx

@@ -7,14 +7,17 @@ import { TaskList } from "./task-list.js";
 import { PersonChip, Time } from "./ui.js";
 
 // What is on a person's plate (ADR-0019), across the projects they may see: the week at the
-// top, with the open tasks assigned to them on its days; below, the same tasks by when they
-// are due, and the decisions that wait for a person. Takes its data as props and nothing from
-// the network; the week shown is the address's (ADR-0010).
+// top, with the open tasks assigned to them on its days, and what of theirs was done or
+// dropped on them, as a project's calendar shows it; below, the open tasks by when they are
+// due, and the decisions that wait for a person. Takes its data as props and nothing from the
+// network; the week shown is the address's (ADR-0010).
 
 export interface WorkListProps {
   /** The tasks on the plate; and the decisions waiting on the person's own plate, left out on another's. */
   readonly work: {
     readonly tasks: RestWork["tasks"];
+    /** The person's tasks done or dropped and not yet put away: on the week, not in the lists. */
+    readonly closed?: RestWork["closed"] | undefined;
     readonly decisions?: RestWork["decisions"] | undefined;
   };
   /** The day to count from; the browser's today when left out. */
@@ -33,7 +36,8 @@ export function WorkList(props: WorkListProps) {
   const now = props.today ?? todayOf();
   const weekEnd = addDays(now, 6);
   const { tasks, decisions } = props.work;
-  const projectOf = new Map(tasks.map((item) => [item.task.id, item.project]));
+  const closed = props.work.closed ?? [];
+  const projectOf = new Map([...tasks, ...closed].map((item) => [item.task.id, item.project]));
   const hrefOf = (task: RestTask) => props.taskHref(projectOf.get(task.id)?.key ?? "", task);
   const markOf = (task: RestTask) => {
     const project = projectOf.get(task.id);
@@ -60,7 +64,7 @@ export function WorkList(props: WorkListProps) {
   return (
     <div className="sc-work">
       <Week
-        tasks={tasks.map((item) => item.task)}
+        tasks={[...tasks, ...closed].map((item) => item.task)}
         day={props.week}
         today={now}
         taskHref={hrefOf}

package/src/console.tsx

@@ -1748,9 +1748,10 @@ function PersonAgentsPage(props: {
   );
 }
 
-/** What a plate's page shows: the tasks, and the decisions waiting on the person's own. */
+/** What a plate's page shows: the tasks, open and lately closed, and the decisions waiting on the person's own. */
 interface Plate {
   readonly tasks: RestWork["tasks"];
+  readonly closed?: RestWork["closed"] | undefined;
   readonly decisions?: RestWork["decisions"] | undefined;
 }
 
@@ -1825,7 +1826,9 @@ function PlatePage(props: {
             <Spinner label={props.loading} />
           </div>
         )
-      ) : plate.tasks.length === 0 && (plate.decisions?.length ?? 0) === 0 ? (
+      ) : plate.tasks.length === 0 &&
+        (plate.closed?.length ?? 0) === 0 &&
+        (plate.decisions?.length ?? 0) === 0 ? (
         <EmptyState title={props.empty.title} body={props.empty.body} />
       ) : (
         <components.WorkList

package/src/rules.ts

@@ -23,13 +23,13 @@ export const REFERENCE_RULES = [
   "",
   "## Start here, every time",
   "",
-  "1. These rules come with the task: `console take` prints them under it, and `console rules` reads them any time. Read them before anything is made. The task says where the work is and what it links to; `console task <number>` shows a task in full, with its plan, its decisions, the runs on it and the discussion on it, without taking it. A task put away (archived) is out of the listings and the board, and opens by its number still. How the board is worked is the skill working-the-board, shipped with the command: read it before the first command of a run (`console skills` prints where it is); these rules say what this organization asks, not how the command works.",
+  "1. These rules come with the task: `console take` prints them under it, and `console rules` reads them any time. Read them before anything is made. The task says where the work is and what it links to; `console task <number>` shows a task in full, with its plan, its decisions, the runs on it and the discussion on it, without taking it. A task put away (archived) is out of the listings and the board, and opens by its number still. How the board is worked is the skill working-the-board, shipped with the command (`console whoami` prints where it is): read it, if you have not yet, before anything is made; these rules say what this organization asks, not how the command works.",
   "2. Act as the person whose token the command holds, and no further. What they may not do, the console refuses; that step goes back to them in a report, never around them.",
   '3. Work given in chat, with no task on the board yet, goes on the board before it is done: write it (`console task new "<title>" --body <markdown>`), tell the person its number, take it (`console take <number>`) and work it as any task, without asking whether to. Until the task is written, the board is only read.',
   "",
   "## The organization's skills",
   "",
-  "`console skills` lists the skills of this project's pack: each with its name, what it does, and the path of its SKILL.md; `console skills <folder>` shows what a folder of the pack holds, and `console skills --search <words>` finds its skills and documents by words. `console skill <path>` reads one whole, its rules first, as the console reads it from the SkillCDN deployment for you, a private pack with the pack token the project holds; `console skill --file <file>` reads a file of the pack. Where your host lists skills through a connection of your own to the address, the URI `skill://gh/<owner>/<repo>/<path>` is the skill there, followed until its context is complete. Either way, never fetch a skill another way. Load the skill the task names before anything is made; with none named, the one whose description fits the work. The rules those skills share arrive with each of them, from their repository's SKILLCDN.md, and hold within that work. What you read of a private pack is the project's: it stays in your work, and is not copied into a report, a page or a comment beyond what the work needs.",
+  "`console skills` lists the skills of this project's pack, each with the path of its SKILL.md, and `console skill <path>` reads one whole, its rules first, through the console, a private pack with the pack token the project holds (`console help skills` says how the pack is browsed and searched). Where your host lists skills through a connection of your own to the address, the URI `skill://gh/<owner>/<repo>/<path>` is the skill there, followed until its context is complete. Either way, never fetch a skill another way. Load the skill the task names before anything is made; with none named, the one whose description fits the work. The rules those skills share arrive with each of them, from their repository's SKILLCDN.md, and hold within that work. What you read of a private pack is the project's: it stays in your work, and is not copied into a report, a page or a comment beyond what the work needs.",
   "",
   "## Where the work lives",
   "",
@@ -45,7 +45,7 @@ export const REFERENCE_RULES = [
   "",
   "## Reports",
   "",
-  "Report at the milestones, not every step: what was found, what was done, what is next, in words for people; a problem as a problem, with what it blocks. What people read on the board, the reports, the questions and their options, the tasks and the pages, is written in {language}. A task's title says what is to be done, in plain words that stand on their own; what it refers to, a milestone, a commit, a page, goes in the body, linked where it can be. The result goes in a last report or is handed in as a link or a file, with the check that ran and its result; a check that did not run is said to be not run. A report is the run's record; a word to the task's people, an answer to what they asked in its comments, a question that is not a decision, a remark, is a comment on the task (`console comment`), and what they put in a comment is read with `console file`.",
+  "Report at the milestones, not every step: what was found, what was done, what is next, in words for people; a problem as a problem, with what it blocks. What people read on the board, the reports, the questions and their options, the tasks and the pages, is written in {language}. A task's title says what is to be done, in plain words that stand on their own; what it refers to, a milestone, a commit, a page, goes in the body, linked where it can be. The result goes in a last report or is handed in as a link or a file, with the check that ran and its result; a check that did not run is said to be not run. A report is the run's record; a word to the task's people, an answer to what they asked in its comments, a question that is not a decision, a remark, is a comment on the task, not a report.",
   "",
   "## What never happens",
   "",

package/src/schemas.ts

@@ -603,19 +603,26 @@ const projectRef = z.object({
 
 /**
  * `GET /api/v1/work`: what is on the asker's plate across the projects they may see (ADR-0019):
- * the open tasks assigned to them, and the decisions that wait for a person, each with its project.
+ * the open tasks assigned to them, and the decisions that wait for a person, each with its
+ * project; and, for the week on the plate, `closed`, the tasks assigned to them that are done
+ * or dropped and not yet put away. Left out by a console older than it.
  */
 export const restWorkSchema = z.object({
   tasks: z.array(z.object({ project: projectRef, task: restTaskSchema })),
+  closed: z.optional(z.array(z.object({ project: projectRef, task: restTaskSchema }))),
   decisions: z.array(z.object({ project: projectRef, decision: restDecisionSchema })),
 });
 export type RestWork = z.infer<typeof restWorkSchema>;
 
 /**
- * What `GET /api/v1/people/<id>/work` answers: another person's open tasks, within the projects
- * the asker may see, for whoever oversees them. No decisions, which wait for anyone.
+ * What `GET /api/v1/people/<id>/work` answers: another person's open tasks, and their closed
+ * ones for the week, within the projects the asker may see, for whoever oversees them. No
+ * decisions, which wait for anyone.
  */
-export const restPersonWorkSchema = z.object({ tasks: restWorkSchema.shape.tasks });
+export const restPersonWorkSchema = z.object({
+  tasks: restWorkSchema.shape.tasks,
+  closed: restWorkSchema.shape.closed,
+});
 export type RestPersonWork = z.infer<typeof restPersonWorkSchema>;
 
 /** What `POST /api/v1/projects/<key>/decisions` is sent: the question, its context, and the options. */