@hagicode/cli 0.1.0-dev.47.1.f8624d4 → 0.1.0-dev.49.1.aa038f5

package/dist/cli.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./chunks/main-CAH7GrRu.js");s.runCli().then(e=>{e!==0&&(process.exitCode=e)}).catch(e=>{const n=e instanceof Error?e.stack??e.message:String(e);process.stderr.write(`${n}
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./chunks/main-D5eiMFz8.js");s.runCli().then(e=>{e!==0&&(process.exitCode=e)}).catch(e=>{const n=e instanceof Error?e.stack??e.message:String(e);process.stderr.write(`${n}
 `),process.exitCode=s.EXIT_CODES.UNKNOWN});

package/dist/main.js

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./chunks/main-CAH7GrRu.js");exports.createCliApp=e.createCliApp;exports.runCli=e.runCli;
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./chunks/main-D5eiMFz8.js");exports.createCliApp=e.createCliApp;exports.runCli=e.runCli;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hagicode/cli",
-  "version": "0.1.0-dev.47.1.f8624d4",
+  "version": "0.1.0-dev.49.1.aa038f5",
   "description": "HagiCode CLI for project, proposal, vault, chat, and AutoTask management.",
   "homepage": "https://github.com/HagiCode-org/cli#readme",
   "bugs": {

package/resources/saga/.gitignore

@@ -1 +1 @@
-*/runtime/
+**/runtime/

package/resources/saga/manifest.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
   "files": {
-    ".gitignore": "49f38d5fe88ca07cdf13680b2d4f8a8f55d9b871e88192ad25db08e5ec1476fa",
+    ".gitignore": "b43c8b58f191b9e0a0b54b6938c0aa4685d70b8f4ae2294c83a9ad6e728b7c0a",
     "prompts/acceptance.md": "11ca06794d0ec19e87d1a4e883a67014563e9750b9fa62a8bedd43a69d52ca65",
     "prompts/amend.md": "be621d1221a85656851548aee1e9e9d78480288bd856baf1bdbf50cb3317f49b",
     "prompts/goal.md": "a545b01c9f6010df661f02cf62ef9bcae527ccf329f304ea82ffdda239b118df",
     "prompts/plan.md": "bcc4c0509f2971083775db2b3678f41c55f16e69deba2d994d3ed636f314d917",
     "prompts/research.md": "2504283ea845440c7909ff1da20bfb70f846d55ca16565740168848cfb8060b1",
-    "prompts/run.md": "1193fbc45645b513bbd6e1017513b62a53286d1d60fd00df479cff15de7c785b"
+    "prompts/run.md": "aaf8a667c163afea0796a8c80d5760ee689923a76b0c7f1855e55405d9b0b5d0"
   }
 }

package/resources/saga/prompts/run.md

@@ -8,11 +8,13 @@ You are the orchestrator. You dispatch work and keep the record. You do not plan
 1. **Freeze.** `hagi saga freeze <saga> --path <root> --token <token>`. If it refuses (open questions, open amendments, a changed contract), run `hagi saga set-status <saga> --state paused --note "<reason>" --path <root> --token <token>`, stop and report the reasons. Do not edit contract files and do not decide open questions. A first freeze writes revision 1. After an amendment was merged it writes the next revision, chained to the previous one, and reopens the items whose acceptance command changed.
 2. **Check before every item and at every heartbeat.** `hagi saga assert-owner <saga> --path <root> --token <token>` before each dispatch, then `hagi saga check <saga> --phase run --path <root>`. If a check fails, pause the same way and report. An open amendment also means: pause.
 3. **Work one item at a time** (`hagi saga items <saga> --path <root>` lists them with their commands), unless the goal allows parallel items. For each item:
+   - Create each Worker with `hagi saga session create --saga <saga> --path <root> --title "<ITEM> <role>" --role <role> --master <your session id> --item <ITEM>`, where `<role>` is `implementation` or `verification`. This command takes the token from `SAGA_EXECUTION_TOKEN`, set to the token that `claim` printed, and refuses `--token`. It creates the chat session with its Saga metadata and records it in `sessions.md`. Then give the Worker its instructions below.
    - An implementation worker writes code and tests only. Give it the goal, the item, the scope and the safety rules, the project root and its report path.
    - A separate verification worker runs the item's command from `acceptance.md` in the project root, writes the output to `<root>/.hagicode/sagas/<saga>/runtime/evidence/<ITEM>.log`, and writes `<root>/.hagicode/sagas/<saga>/runtime/reports/<ITEM>.md` with the line `Status: PASS` (or `状态: PASS`) only if the exit code is 0. It changes no files.
    - Only `hagi saga tick <saga> <ITEM> --path <root> --token <token>` ticks an item. It refuses without a PASS report and an evidence file.
 4. **On a failed verification, classify it.** An environment fault (missing module, port in use, quota) does not count. A real failure counts: give a tuning worker the failure log path, then verify again. After 3 real failures run `hagi saga block <saga> <ITEM> "<reason>" --path <root> --token <token>` and move on.
 5. **After a revision reopened items,** also re-verify any item whose command is the full regression: its own command did not change, so it was not reopened.
-6. **Keep the record.** Append a line to `<root>/.hagicode/sagas/<saga>/runtime/orchestrator-log.md` after every dispatch, verification and tick. Append every session you create to `<root>/.hagicode/sagas/<saga>/runtime/sessions.md`. Run `hagi saga set-status <saga> --state running --note "<heartbeat>" --path <root> --token <token>` at every heartbeat, and `hagi saga status <saga> --path <root> --json` to read the projection at the end.
-7. **Never leave a command hanging.** Every shell command must end on its own: never read from standard input, and give waits a limit. If something does not answer, report it instead of waiting forever.
-8. **Stop** when every item is ticked or blocked, when a pause condition appears, or when the human's run options say so. Write the terminal snapshot first (`set-status --state done` only when every active item is verified, otherwise `paused` with the reason), then, once every worker has stopped, `hagi saga release <saga> --path <root> --token <token> --workers-settled`. Do not archive and do not commit. Report the revision, every item with its state and evidence path, the blocked items with reasons, the sessions you created, and the next step for a human.
+6. **Keep the record.** Append a line to `<root>/.hagicode/sagas/<saga>/runtime/orchestrator-log.md` after every dispatch, verification and tick. `hagi saga session create` records each Worker session it creates in `<root>/.hagicode/sagas/<saga>/runtime/sessions.md`, so do not append those sessions to that file by hand. Run `hagi saga set-status <saga> --state running --note "<heartbeat>" --path <root> --token <token>` at every heartbeat, and `hagi saga status <saga> --path <root> --json` to read the projection at the end.
+7. **Archive each settled item's sessions.** Once an item is ticked or blocked and its workers have stopped, archive the worker sessions you created for it: `hagi chat archive --session-id <session id> --json`. Take the IDs from `<root>/.hagicode/sagas/<saga>/runtime/sessions.md`. Archive only sessions you created in this run: never your own orchestrator session, a session that is still running, a session you did not create, or the Saga itself (`hagi saga archive` is not part of a run). Archiving leaves the reports, evidence and `sessions.md` record in `runtime/` untouched. Log each archived ID in `orchestrator-log.md`. If an archive call fails, log the error and go on: do not retry in a loop and do not pause for it.
+8. **Never leave a command hanging.** Every shell command must end on its own: never read from standard input, and give waits a limit. If something does not answer, report it instead of waiting forever.
+9. **Stop** when every item is ticked or blocked, when a pause condition appears, or when the human's run options say so. Write the terminal snapshot first (`set-status --state done` only when every active item is verified, otherwise `paused` with the reason). Once every worker has stopped, archive any remaining worker sessions as in step 7, then run `hagi saga release <saga> --path <root> --token <token> --workers-settled`. Never archive the Saga itself and do not commit. Report the revision, every item with its state and evidence path, the blocked items with reasons, the sessions you created and which of them you archived, and the next step for a human.

package/skills/hagi/SKILL.md

@@ -12,7 +12,7 @@ Use this skill when the user asks to:
 - enable or disable a built-in skill
 - run or verify the `hagi` CLI
 - run, explain, or verify local `saga init`, `saga new`, `saga list`, `saga status`, or `saga items` operations
-- run, explain, or verify local Saga ownership, checks, and writes: `claim`, `assert-owner`, `release`, `freeze`, `check`, `tick`, `block`, `set-status`, `amend`, `archive`
+- run, explain, or verify local Saga ownership, checks, and writes: `claim`, `assert-owner`, `release`, `freeze`, `check`, `tick`, `block`, `set-status`, `amend`, `archive`, and `session create` (Saga Worker chat sessions)
 - explain or execute `project`, `proposal`, `chat`, `hagitask`, `vault`, `plan`, `skills`, or `saga` commands
 - explain the OpenSpec workflow behind `proposal` commands, which stage each command starts, or how to follow a run until it settles
 - take turns on a shared resource (a game server, a test environment) with other agents through `hagi agent lock`
@@ -40,7 +40,7 @@ Use this skill when the user asks to:
 5. Source-tree development in `repos/cli` -> read [`references/local-development.md`](references/local-development.md)
 6. Post-change validation -> read [`references/validation.md`](references/validation.md)
 7. The user's own data, inside a HagiCode session -> read [`references/session-data.md`](references/session-data.md)
-8. Local Saga initialization, creation, list, status, item queries, ownership, checks, freeze, ticks, status writes, amendments, or archive -> read [`references/saga.md`](references/saga.md)
+8. Local Saga initialization, creation, list, status, item queries, ownership, checks, freeze, ticks, status writes, amendments, archive, or creating and recording Saga Worker sessions (`session create`) -> read [`references/saga.md`](references/saga.md)
 9. A shared resource that other agents also use, or any `hagi agent lock` command -> read [`references/resource-lock.md`](references/resource-lock.md)
 
 When `hagi` is loaded as a built-in skill inside a HagiCode session, read item 7 first for any question about the user's own data or skills, before the other references.
@@ -89,7 +89,7 @@ The current top-level command families are:
 - `agent`
 - `saga`
 
-`hagi saga` provides `init`, `new`, `list`, `status`, and `items`, plus the write and check commands `claim`, `assert-owner`, `release`, `freeze`, `check`, `tick`, `block`, `set-status`, `amend`, and `archive`; mutating commands take `--token` or `SAGA_EXECUTION_TOKEN`. With `--path`, these operate on host-local files without reading backend configuration or calling the API; `--project-id` resolves a project through the backend. See [`references/saga.md`](references/saga.md) for initialization, creation, offline behavior, and read-only query guarantees.
+`hagi saga` provides `init`, `new`, `list`, `status`, and `items`, plus the write and check commands `claim`, `assert-owner`, `release`, `freeze`, `check`, `tick`, `block`, `set-status`, `amend`, and `archive`, and `session create`, which creates a Saga Worker chat session and records it. Mutating commands take `--token` or `SAGA_EXECUTION_TOKEN`; `session create` takes only `SAGA_EXECUTION_TOKEN`. With `--path`, these operate on host-local files without reading backend configuration or calling the API, except `session create`, which calls the backend to find the registered project; `--project-id` resolves a project through the backend. Creating a Worker changes state, so run `session create` only when the user or a Saga run explicitly asks for it. See [`references/saga.md`](references/saga.md) for initialization, creation, offline behavior, and read-only query guarantees.
 
 `project repositories --id <project-id>` is read-only. It lists one project's repositories with each path relative to the project root (for example `repos/cli`). Those paths are the values a proposal's `Repository scope` names; see [`references/proposal-flow.md`](references/proposal-flow.md#repository-scope).
 
@@ -122,6 +122,6 @@ Each family also reads one session by id. `proposal get` and `hagitask get` read
 - [`references/openspec-workflow.md`](references/openspec-workflow.md) - the OpenSpec stage each proposal command starts, stage boundaries, who drives each step, and the monitoring rule
 - [`references/super-commit.md`](references/super-commit.md) - Super Commit: starting it by prompt id, its options, result reading and the explicit-request rule
 - [`references/resource-lock.md`](references/resource-lock.md) - the shared resource lock: numbers, owner, exit codes, the watcher protocol, the seven agent rules and requisition
-- [`references/saga.md`](references/saga.md) - local initialization, creation, ownership, checks, Saga writes, and read-only queries
+- [`references/saga.md`](references/saga.md) - local initialization, creation, ownership, checks, Saga writes, Saga Worker sessions (`session create`), and read-only queries
 - [`references/local-development.md`](references/local-development.md) - maintainer-only development, build, and repository internals
 - [`references/validation.md`](references/validation.md) - targeted verification after documentation or code changes

package/skills/hagi/references/cli-usage.md

@@ -56,7 +56,7 @@ Example:
 hagi --base-url https://api.example.com --token "$HAGI_TOKEN" project list --json
 ```
 
-Saga commands using `--path` accept these flags but do not read backend configuration or contact the backend.
+Saga commands using `--path` accept these flags but do not read backend configuration or contact the backend, except `saga session create`, which calls the backend to find the registered project.
 
 ## Environment variables
 
@@ -83,7 +83,7 @@ The file is `$XDG_CONFIG_HOME/hagi/config.json`, or `~/.config/hagi/config.json`
 Base URL precedence, highest first: `--base-url`, then `HAGI_API_BASE_URL`, then `baseUrl` in the config file.
 There is no default. When none of the three is set, a backend operation exits with code `2` and names all three sources.
 The local Saga selector `--path` is the exception: it does not read this file, so malformed, unreachable, or absent backend
-settings do not affect that local operation.
+settings do not affect that local operation. The one exception is `saga session create`, which calls the backend even with `--path`.
 
 ## Command overview
 
@@ -92,7 +92,7 @@ hagi
 |-- project   list | repositories | create | update | delete
 |   `-- monospecs show | init | set | validate | reload | clone | remove-checkout
 |-- proposal  list | create | optimize-description | generate | annotate | execute | archive | status | complete | send | get | messages
-|-- saga      init | new | list | status | items | claim | assert-owner | release | freeze | check | tick | block | set-status | amend | archive
+|-- saga      init | new | list | status | items | claim | assert-owner | release | freeze | check | tick | block | set-status | amend | archive | session create
 |-- vault     list | create | update | delete
 |   `-- files list | preview
 |-- chat      list | create | archive | delete | send
@@ -109,7 +109,8 @@ hagi
 Each command requires exactly one nonempty project selector:
 
 - `--path <directory>` resolves a local directory on the CLI host. Relative paths use the current working directory. This
-  selector does not read backend configuration or make API calls, and shared backend flags do not change its behavior.
+  selector does not read backend configuration or make API calls, except in `saga session create`, which looks up the
+  registered project through the backend. Shared backend flags do not change its behavior otherwise.
 - `--project-id <id>` reads the project list through the configured backend. Its project path must be a directory available
   on the machine running the CLI; the CLI does not execute filesystem operations remotely.
 
@@ -125,8 +126,12 @@ hagi saga items demo --path "./My Project" --json
 hagi saga claim demo --path "./My Project" --session orchestrator-1 --json
 hagi saga check demo --path "./My Project" --phase run --json
 hagi saga tick demo T1 --path "./My Project" --token "$SAGA_EXECUTION_TOKEN" --json
+hagi saga session create --saga demo --path "./My Project" --title "T1 implementation" --role implementation --master orchestrator-1 --item T1 --json
 ```
 
+`saga session create` takes its execution token from `SAGA_EXECUTION_TOKEN` only; `--token` is refused. It creates a Worker
+chat session and records it in `runtime/sessions.md`. See [`saga.md`](saga.md#worker-sessions) for its metadata, record and exit codes.
+
 For offline use, invoke an installed package or a package already present in the `npx` cache. An uncached
 `npx @hagicode/cli` command may need network access to download the package; the local `--path` operation itself does not
 need backend access.

package/skills/hagi/references/saga.md

@@ -2,6 +2,8 @@
 
 Saga files are project-local. Select exactly one project with `--path <directory>` or `--project-id <id>` for every
 Saga command. A local `--path` is resolved on the CLI host and does not read backend configuration or make API calls.
+The one exception is `session create` (see [Worker sessions](#worker-sessions)), which calls the backend even with `--path`
+to find the registered project.
 
 ## Initialize managed resources
 
@@ -20,7 +22,7 @@ installed. The command prints each file's `created`, `unchanged`, `merged`, `rep
 with code `4` if any conflicts remain. Use `--force` to replace differing managed resources with the bundled versions;
 identical resources remain untouched. Forced initialization never discards custom `.gitignore` entries.
 
-The `.gitignore` rule `*/runtime/` is merged as a separate exact line. Existing bytes, line endings, and entries are
+The `.gitignore` rule `**/runtime/` is merged as a separate exact line. Existing bytes, line endings, and entries are
 preserved; LF and CRLF files are supported, and repeated initialization does not append duplicate rules.
 
 Before writing, initialization checks that managed directories and files are not redirected, that resource targets are
@@ -83,7 +85,7 @@ unreadable existing data is reported instead of being repaired. ## Execution own
 
 `claim`, `assert-owner`, and `release` manage `runtime/execute.lock`. Every mutating command (`freeze`, `tick`, `block`,
 `set-status`, `amend`, `archive`, `release`, `assert-owner`) reads the execution token from `--token <token>` or, when
-that flag is absent, from `SAGA_EXECUTION_TOKEN`.
+that flag is absent, from `SAGA_EXECUTION_TOKEN`. The exception is `session create`, which reads only `SAGA_EXECUTION_TOKEN`.
 
 ```bash
 hagi saga claim demo --path "./My Project" --session orchestrator-1
@@ -124,6 +126,42 @@ amendment is merged into `rN+1` and no frozen item disappeared without a superse
 `runtime/history/rN/`. Every refusal (open question, unmerged amendment, plan mismatch, tampered contract, removed item)
 lists each reason, exits `1`, and writes nothing.
 
+## Worker sessions
+
+Set `SAGA_EXECUTION_TOKEN` to the token that `claim` printed, then create a Worker and record it:
+
+```bash
+hagi saga session create --saga demo --path "./My Project" --title "T1 implementation" --role implementation --master orchestrator-1 --item T1 --json
+```
+
+- The command creates one ordinary chat session in the project and appends one line to `runtime/sessions.md`. It sends
+  no message and does not archive the session; `hagi chat archive --session-id <id>` stays a separate step.
+- Required and nonblank: `--saga <id>`, `--title <title>`, `--role implementation|verification`, and `--master <session-id>`
+  (the orchestrator's own session ID). `--item <id>` is optional. `--saga` and `--item` are identifiers: a path separator
+  or a traversal segment is a usage error (code `2`). Exactly one of `--path <directory>` or `--project-id <id>` is
+  required.
+- The execution token comes only from `SAGA_EXECUTION_TOKEN`, which must be set and nonempty. `--token` is refused with
+  either selector as a usage error (code `2`), because the root `--token` is the backend bearer token and must never carry
+  the execution token. A missing token is also code `2`, and no request is sent.
+- `--path` calls the backend: the command lists the registered projects and takes the one whose real path equals the
+  root. Projects whose path is missing on this host are skipped. Zero matches, or several, is a refusal (code `1`) that
+  names the path or the matching IDs, and creates nothing. `--project-id` looks the project up directly.
+- After the project and the Saga are resolved, the owner check of `assert-owner` runs with the token. A Saga without a lock
+  still passes once a token is set. A wrong token is a refusal (code `1`), and an unknown Saga is code `24`.
+- The new session's `userMetadata` holds `saga.id` (the Saga), `saga.role` (always `worker`), `saga.worker` (the `--role`
+  value), `saga.master` (the `--master` value), and `saga.item` only when `--item` is given. The backend checks the key
+  format (`^[a-z][a-z0-9._-]{0,63}$`), at most 16 entries, and value length (1 to 512 characters). The metadata is
+  write-once and readable by everyone who can read the session, so it groups Workers and is not a security boundary. The
+  token never appears in it. Workers created before this command carry no `saga.*` metadata and are not backfilled.
+- The record is one line, `- <session-id> | <UTC time> | <role> | <item or -> | <title>`, appended after earlier content
+  in `<root>/.hagicode/sagas/<saga>/runtime/sessions.md`. The file and `runtime/` are created when missing. Whitespace in
+  the title, line breaks included, collapses to single spaces. A symbolic link or a redirected `runtime/` is refused
+  before the session is created.
+- If the append fails after the session was created, the command exits `1` and names the created session ID, in the
+  human output and as `session.sessionId` in `--json` with `ok` false.
+- `--json` success is one object: `{ "sagaId": "demo", "command": "session create", "ok": true, "session": { "sessionId": "...", "userMetadata": { ... } }, "record": "<path to sessions.md>" }`.
+- Exit codes: `0` created and recorded; `1` refused, or the record failed after creation; `2` usage error; `24` Saga not found.
+
 ## Items, amendments, and archive
 
 ```bash
@@ -163,7 +201,7 @@ is replaced atomically, so a concurrent reader always sees a complete document.
 |------|---------|
 | `0` | Success. |
 | `1` | Refusal or failed check. Every reason is printed; nothing was changed. |
-| `2` | Usage error: bad selector, missing or invalid argument, or `--token` with `--project-id`. |
+| `2` | Usage error: bad selector, missing or invalid argument, or `--token` with `--project-id` (with either selector for `session create`). |
 | `4` | Init resource conflict (see above). |
 | `24` | Saga or project not found. |
 | `30` | Operation failed, including a `new` collision. |
@@ -181,7 +219,7 @@ Human output prints a one-line outcome and one line per refusal reason.
 
 Before any command writes a file under a Saga's `runtime/` directory (`claim`, `set-status`, `tick`, `block`, and a
 `freeze` that moves history), it makes sure `.hagicode/sagas/.gitignore` ignores runtime directories. An existing
-`*/runtime/` or `**/runtime/` line is kept byte for byte; otherwise `**/runtime/` is appended with the file's line endings.
+`**/runtime/` line is kept byte for byte; otherwise `**/runtime/` is appended with the file's line endings.
 If the ignore file cannot be written, the command stops before `runtime/` is created.
 
 ## Read-only projection and ownership

package/skills/hagi/references/session-data.md

@@ -141,11 +141,13 @@ A question such as "what is in my plan" is not a request to run, enable, disable
 | `chat` | `create`, `archive`, `delete`, `send` |
 | `hagitask` | `create`, `send` |
 | `plan` | `create`, `update`, `enable`, `disable`, `delete`, `run` |
-| `saga` | `init`, `new` |
+| `saga` | `init`, `new`, `session create` |
 | `skills` | `local enable`, `local disable`, `local uninstall`, `gallery install`, `trusted upsert`, `trusted delete`, `trusted reset` |
 
 A `send` or `run` starts agent work, and `execute` and `generate` start it too. Treat those as changes of the same kind.
 
+`saga session create` creates a chat session for a Saga Worker and records it in the Saga's `runtime/sessions.md`. Creating a Worker changes state, so run it only when the user or a Saga run explicitly asks for it. It takes the execution token from `SAGA_EXECUTION_TOKEN` only, and with `--path` it calls the backend to find the project. See [`saga.md`](saga.md#worker-sessions).
+
 A `send` with Steer (`--steer`, or `HAGI_SEND_STEER` set in the calling shell) inserts its text into a running turn. The result says which happened: `steered` means a running task took it, and `queued` means no running task did, so it went out as the next message. `HAGI_SEND_STEER` belongs to the calling shell; the backend does not set it inside agent sessions.
 
 `hagitask create` with a Super Commit prompt (`--prompt-id auto-compose-commit.<locale>`) creates commits in a code repository, and with `--need-push` publishes them. Start it only when the user asked for it in this conversation, and add `--need-push` only when the user asked for a push. See [`super-commit.md`](super-commit.md).

package/skills/hagi/references/validation.md

@@ -133,6 +133,21 @@ node ./dist/cli.js proposal --help
 
 If only a specific command changed, also verify that command's help directly.
 
+## Saga Worker session command
+
+Run this when `src/commands/saga/session.ts`, the Saga runtime helpers (`project.ts`, `safeWrite.ts`, `sessionRecord.ts`),
+the run prompt or these references changed:
+
+```bash
+cd repos/cli
+pnpm exec vitest run tests/commands/saga-session-create.test.ts tests/runtime/saga/appendContained.test.ts tests/runtime/saga/project.test.ts tests/runtime/saga/sessionRecord.test.ts
+pnpm exec vitest run tests/runtime/saga/assets.test.ts tests/docs
+node ./dist/cli.js saga session create --help
+```
+
+The command test covers argument validation, token rejection, selector matching, the `saga.*` metadata, the `sessions.md`
+append and the failed-record report. The help check prints the parameters, the metadata keys and the metadata limits.
+
 ## Package publish-surface check
 
 Run this when `package.json`, publish contents, or release metadata changed. The Saga asset check and the package check