epismo 0.20.0 → 1.0.1

package/README.md

@@ -1,104 +1,111 @@
 # Epismo CLI
 
-GitHub made code reusable.
-Hugging Face made AI models reusable.
-Epismo makes AI work reusable.
-
-Capture how you got your best results — not just the output — and share them as executable workflows that agents and humans can discover, adapt, and run across projects.
-
-## CLI Contract
-
-Epismo CLI is designed for agents first.
-
-- Success output is machine-readable JSON on `stdout`, in both interactive and non-interactive runs.
-- `stderr` carries prompts, browser-login guidance, warnings, and errors (all JSON-shaped).
-- Exit code `0` means success; any non-zero code means failure.
-- In non-interactive environments, commands that would need a prompt fail fast instead of waiting for input.
+Agent-friendly CLI for Playbooks, Cases, Tasks, Records, Suggestions, Stars, and Aliases. Successful commands print JSON to stdout; warnings and failures are JSON-shaped on stderr.
 
 ## Install
 
 Node.js 22.12 or newer is required.
 
 ```bash
-npm install -g epismo      # or run ad hoc with: npx epismo <command>
+npm install -g epismo
+# or
+npx epismo <command>
 ```
 
-## Authentication
+## Authentication and workspace selection
 
 ```bash
-epismo login                                 # opens a browser for Google, SSO, or email sign-in
-epismo login --email you@example.com         # company SSO in browser, otherwise code in terminal
-epismo logout                                # clear local credentials
-EPISMO_TOKEN=<access-token> epismo whoami    # preferred for scripts
+epismo login
+epismo login --email you@example.com
+epismo whoami
+epismo logout
 ```
 
-If `EPISMO_TOKEN` is set, the CLI uses it instead of stored credentials and resolves the workspace from the token itself (the saved default workspace is ignored).
+Commands use the workspace embedded in `EPISMO_TOKEN`, then the saved default from
+`epismo workspace use`, then personal space. A workspace-scoped CI token can be issued
+with `epismo token create --workspace-id <workspace-id>`.
 
 ## Commands
 
-Each command group maps to an Epismo resource.
-Run `epismo <command> --help` for the full flag set; the highlights:
+```text
+epismo login | logout | whoami
 
-| Command      | Purpose                                                                       |
-| ------------ | ----------------------------------------------------------------------------- |
-| `whoami`     | Show the current user, effective workspace, and accessible workspaces.        |
-| `workspace`  | List/create/update workspaces, manage members, and get billing checkout URLs. |
-| `project`    | Manage projects within a workspace and their members.                         |
-| `agent`      | Manage which AI teammates appear in the assignee roster.                      |
-| `track`      | Create, update, search, and bulk-apply task/goal project tracks.              |
-| `log`        | Append, list, and delete activity/comment logs on tracks.                     |
-| `pack`       | Create, update, fetch, search, like, rate, and delete packs.                  |
-| `suggestion` | Send and triage improvement suggestions against packs.                        |
-| `alias`      | Manage pack aliases as a top-level resource.                                  |
-| `credit`     | Check the credit balance and start credit checkout.                           |
-| `token`      | Issue workspace-scoped CLI tokens for CI/CD.                                  |
+epismo workspace list | current | use | clear | create | checkout | update
+epismo workspace member list | upsert | delete
+epismo project list | create | update
+epismo project member list | add | delete
+epismo credit balance | checkout
+epismo token create
 
-A few group-specific notes that aren't obvious from `--help`:
+epismo playbook search | create | get | acl | archive | star | unstar | starred
+epismo playbook version list | get | publish
+epismo playbook share create
+epismo alias set | list | delete
 
-- **Bulk member ops** accept comma-separated IDs and use one backend transaction. Membership does not change Stripe billing quantity.
-- **`track apply`** creates, updates, and deletes multiple tracks in one request; use a non-UUID `id` to create, and cross-references between new entries are resolved server-side.
-- **`track review`** generates a read-only detailed review for one or more completed/postponed task or goal tracks. It returns JSON with `targets` and a `review` object; it does not create or update packs automatically.
-- **`log`** entries are immutable comments/activity notes attached to a track (`kind`: `comment`, `update`, `review`, or the reserved `system`). `log list <track-reference>` reads one track, newest first by default; pass a task/goal UUID or URL containing it. Omit `<track-reference>` for an ACL-scoped activity feed across every track you can access, optionally `--author-id`-filtered either way. `--order asc|desc` and `--cursor <logId>` (the previous response's `nextCursor`) control pagination. Appending a log is free; listing costs credits like other reads. Authors outside what the caller can see (e.g. someone who has since left) come back as `"unknown"`.
+epismo case start | get | list | assign | acl | update | close | reopen
+epismo task create | list | assign | update | close | reopen
+epismo record append | list
 
-### Pack references
-
-Any command that takes a pack accepts a bare UUID, an alias (`@alias` or `@handle/alias`), a share URL, or a hub URL interchangeably.
-
-### Track references
+epismo suggestion create | get | list | update | resolve
+```
 
-Any command that takes an existing track accepts a task/goal UUID or a URL containing that UUID. Tracks do not have aliases.
+The Playbook, Case, Task, Record, Suggestion, Star, and Alias operations are also
+available through MCP. MCP names mirror the CLI resource/verb hierarchy in snake_case;
+for example, `epismo_playbook_version_list` maps to `epismo playbook version list`.
 
-### Access scope
+Run `epismo <command> --help` for flags and positional arguments.
 
-`track` and `pack` writes share one access model: `scope` is `{ "type": "personal" }` or `{ "type": "projects", "ids": [...] }` (required on create; omit on update to preserve existing access), with an optional `sharedWith`.
-The matching CLI flags are `--personal`, `--projects <id...>`, and `--share-with <userIdOrEmail...>`.
-Search uses the same selectors additively; omit them to use the default scope for the current context.
+## Structured input
 
-## Workspace Selection
+Commands that accept payloads support:
 
-There is no per-command `--workspace-id` flag — every command resolves a workspace, in this order:
+```bash
+epismo playbook create --input @playbook.json
+epismo record append <case-id> --input @record.json
+epismo suggestion create --input - < suggestion.json
+```
 
-1. The workspace embedded in `EPISMO_TOKEN` (issued via `epismo token create --workspace-id`).
-2. The saved default from `epismo workspace use` (interactive sessions).
-3. Personal space, when nothing else is configured.
+`--input` accepts an inline JSON object, `@file`, or `-` for stdin. Explicit flags
+override fields from `--input`. Complex Playbook Definitions and close-time Record
+arrays are best supplied through files.
 
-For CI/CD, issue a scoped token once and export it:
+`--input` always carries the whole request payload, so `epismo case start` takes the
+Case's own input object through `--case-input` instead:
 
 ```bash
-epismo token create --workspace-id <workspace-id>
-export EPISMO_TOKEN=<accessToken>     # all commands now use that workspace
+epismo case start --version-id <version-id> --acl <account-id> \
+  --case-input '{"companyName":"Acme"}'
 ```
 
-## Input / Output
+Mutation commands accept `--idempotency-key <uuid>`. When omitted, the CLI generates
+a UUID automatically. Reuse an explicit key when retrying a command whose first result
+was uncertain; reusing one with different arguments is rejected.
+
+Every mutation of an existing Case or Task requires `--lock-version`, taken from the
+most recent object returned by the API: `case assign | acl | update | close | reopen`
+and `task assign | update | close | reopen`. After a conflict, re-read the object and
+decide again rather than resending with a bumped number. Updates are partial: Case
+currently supports `title`, while Task supports `title` and `instructions`.
+
+`epismo record list` is a cross-Case activity feed constrained by current Case ACLs.
+Use `--case-id`, `--task-id`, `--created-by`, `--kinds`, `--origins`, or `--acl` to
+narrow it; these filters never grant access. Results default to newest first, and
+`--order asc` walks a timeline forward.
+
+## Playbook references
 
-- `--input <json>`, `--input @file.json`, or `--input -` (stdin) supply structured input; explicit flags override fields from `--input`, and enum-like flags are validated locally.
-- Success is JSON on `stdout`; errors and warnings are JSON on `stderr`:
+The CLI's REST commands currently use UUIDs for Playbook path arguments. Aliases are
+managed with `epismo alias`; MCP exposes the same alias set/list/delete operations and
+also accepts `pb:alias` and `pb:handle/alias` in `epismo_playbook_get`.
+
+## Output contract
+
+- Success: JSON on stdout and exit code `0`.
+- Failure: JSON on stderr and a non-zero exit code.
+- Non-interactive commands fail instead of waiting for an unavailable prompt.
 
 ```json
-{ "error": { "code": "NOT_FOUND", "message": "...", "retryable": false, "hint": "..." } }
+{ "error": { "code": "NOT_FOUND", "message": "...", "retryable": false } }
 ```
 
-## Update Checks
-
-Update checks run once per day in interactive sessions.
-Set `EPISMO_UPDATE_CHECK=0` to disable the background npm version check.
+Set `EPISMO_UPDATE_CHECK=0` to disable the daily interactive npm update check.

package/dist/cases.js

@@ -0,0 +1,25 @@
+import { requestJson, withWorkspaceQuery } from "./api.js";
+import { resolveApiUrl } from "./config.js";
+import { toObjectInput } from "./input.js";
+import { withIdempotency, withQuery } from "./playbooks.js";
+const part = (value) => encodeURIComponent(value);
+async function call(context, pathname, method = "GET", body) {
+    return requestJson(resolveApiUrl(), withWorkspaceQuery(pathname, context.workspaceId), { method, authToken: context.auth.accessToken, ...(body === undefined ? {} : { body }) });
+}
+export const caseApi = {
+    start: (c, input) => call(c, "/v1/cases", "POST", withIdempotency(input)),
+    get: (c, id) => call(c, `/v1/cases/${part(id)}`),
+    list: (c, input) => call(c, withQuery("/v1/cases", input)),
+    assign: (c, id, input) => call(c, `/v1/cases/${part(id)}/assignee`, "PATCH", withIdempotency(input)),
+    updateAcl: (c, id, input) => call(c, `/v1/cases/${part(id)}/acl`, "PATCH", withIdempotency(input)),
+    update: (c, id, input) => call(c, `/v1/cases/${part(id)}`, "PATCH", withIdempotency(input)),
+    createTask: (c, id, input) => call(c, "/v1/tasks", "POST", withIdempotency({ ...toObjectInput(input), caseId: id })),
+    listTasks: (c, input) => call(c, withQuery("/v1/tasks", input)),
+    assignTask: (c, taskId, input) => call(c, `/v1/tasks/${part(taskId)}/assignee`, "PATCH", withIdempotency(input)),
+    closeTask: (c, taskId, input) => call(c, `/v1/tasks/${part(taskId)}/close`, "POST", withIdempotency(input)),
+    reopenTask: (c, taskId, input) => call(c, `/v1/tasks/${part(taskId)}/reopen`, "POST", withIdempotency(input)),
+    updateTask: (c, taskId, input) => call(c, `/v1/tasks/${part(taskId)}`, "PATCH", withIdempotency(input)),
+    close: (c, id, input) => call(c, `/v1/cases/${part(id)}/close`, "POST", withIdempotency(input)),
+    reopen: (c, id, input) => call(c, `/v1/cases/${part(id)}/reopen`, "POST", withIdempotency(input))
+};
+//# sourceMappingURL=cases.js.map

package/dist/cases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cases.js","sourceRoot":"","sources":["../src/cases.ts"],"names":[],"mappings":"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"}

package/dist/playbook-program.js

@@ -0,0 +1,393 @@
+import { Option } from "commander";
+import { parseJsonArrayOption, parseJsonObjectOption, parseStringArrayInput } from "./input.js";
+import { printJson } from "./output.js";
+import { playbookApi } from "./playbooks.js";
+import { caseApi } from "./cases.js";
+import { suggestionApi } from "./suggestions.js";
+import { recordApi } from "./records.js";
+const number = (value) => Number(value);
+function input(command) {
+    return command.option("--input <input>", "JSON object, @file, or - for stdin");
+}
+function paging(command) {
+    return command
+        .option("--page-size <number>", "results per page (1-100)", number)
+        .option("--cursor <cursor>", "cursor returned by the previous page");
+}
+function mutation(command) {
+    return input(command).option("--idempotency-key <uuid>", "retry key; generated automatically when omitted");
+}
+async function execute(deps, options, overrides, action) {
+    const payload = await deps.resolveInput(options, overrides);
+    printJson(await action(await deps.resolveContext(), payload));
+}
+function commonPage(options) {
+    return { pageSize: options.pageSize, cursor: options.cursor };
+}
+export function registerPlaybookProgram(program, deps) {
+    const playbook = program.command("playbook").description("manage reusable Playbooks");
+    paging(input(playbook.command("search").description("search readable Playbooks")))
+        .option("--query <text>", "full-text query")
+        .addOption(new Option("--category <category>").choices([
+        "productivity",
+        "programming",
+        "design",
+        "sales",
+        "marketing",
+        "operations",
+        "learning"
+    ]))
+        .option("--filter-expression <expression>", "search projection filter")
+        .option("--aggregations <json>", "JSON array of aggregation options")
+        .action(async (options) => execute(deps, options, {
+        query: options.query,
+        category: options.category,
+        ...commonPage(options),
+        filterExpression: options.filterExpression,
+        aggregationOptions: parseJsonArrayOption(options.aggregations, "--aggregations")
+    }, playbookApi.search));
+    mutation(playbook.command("create").description("create a Playbook and its first Version"))
+        .option("--owner-id <uuid>", "owner Account ID")
+        .option("--acl <principals>", "comma-separated ACL principals")
+        .option("--definition <json>", "Playbook Definition JSON object")
+        .action(async (options) => execute(deps, options, {
+        ownerId: options.ownerId,
+        acl: parseStringArrayInput(options.acl, "--acl"),
+        definition: parseJsonObjectOption(options.definition, "--definition"),
+        idempotencyKey: options.idempotencyKey
+    }, playbookApi.create));
+    playbook
+        .command("get")
+        .description("get a Playbook and its latest immutable Version")
+        .argument("<playbook-id>")
+        .action(async (id) => printJson(await playbookApi.get(await deps.resolveContext(), id)));
+    const version = playbook.command("version").description("read and publish immutable Versions");
+    paging(version.command("list").argument("<playbook-id>").description("list Versions")).action(async (id, options) => execute(deps, options, commonPage(options), (context, payload) => playbookApi.listVersions(context, id, payload)));
+    version
+        .command("get")
+        .argument("<playbook-id>")
+        .argument("<version-id>")
+        .description("get one immutable Version")
+        .action(async (playbookId, versionId) => printJson(await playbookApi.getVersion(await deps.resolveContext(), playbookId, versionId)));
+    mutation(version.command("publish").argument("<playbook-id>").description("publish a Version"))
+        .option("--base-version-id <uuid>", "current latest Version ID")
+        .option("--definition <json>", "new Playbook Definition JSON object")
+        .action(async (id, options) => execute(deps, options, {
+        baseVersionId: options.baseVersionId,
+        definition: parseJsonObjectOption(options.definition, "--definition"),
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => playbookApi.publish(context, id, payload)));
+    mutation(playbook.command("acl").argument("<playbook-id>").description("replace the ACL"))
+        .requiredOption("--acl <principals>", "comma-separated ACL principals")
+        .action(async (id, options) => execute(deps, options, {
+        acl: parseStringArrayInput(options.acl, "--acl"),
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => playbookApi.updateAcl(context, id, payload)));
+    for (const [name, description, action] of [
+        ["archive", "archive a Playbook", playbookApi.archive],
+        ["star", "star a Playbook", playbookApi.star],
+        ["unstar", "remove a Playbook star", playbookApi.unstar]
+    ]) {
+        mutation(playbook.command(name).argument("<playbook-id>").description(description)).action(async (id, options) => execute(deps, options, { idempotencyKey: options.idempotencyKey }, (context, payload) => action(context, id, payload)));
+    }
+    paging(playbook.command("starred").description("list your starred Playbooks")).action(async (options) => execute(deps, options, commonPage(options), playbookApi.listStarred));
+    const share = playbook.command("share").description("create short share URLs");
+    mutation(share.command("create").argument("<playbook-id>").description("create a share token"))
+        .option("--expires-at <timestamp>", "optional ISO-8601 expiration")
+        .action(async (id, options) => execute(deps, options, { expiresAt: options.expiresAt, idempotencyKey: options.idempotencyKey }, (context, payload) => playbookApi.createShare(context, id, payload)));
+    registerAliasProgram(program, deps);
+    registerCaseProgram(program, deps);
+    registerTaskProgram(program, deps);
+    registerRecordProgram(program, deps);
+    registerSuggestionProgram(program, deps);
+}
+function registerAliasProgram(program, deps) {
+    const alias = program.command("alias").description("manage Playbook aliases");
+    mutation(alias
+        .command("set")
+        .argument("<alias>")
+        .argument("<playbook-id>")
+        .description("point an alias at a Playbook, replacing any existing target"))
+        .requiredOption("--owner-id <uuid>", "alias namespace owner Account ID")
+        .action(async (name, playbookId, options) => execute(deps, options, {
+        ownerId: options.ownerId,
+        alias: name,
+        playbookId,
+        idempotencyKey: options.idempotencyKey
+    }, playbookApi.setAlias));
+    paging(input(alias.command("list").description("list aliases by namespace or Playbook")))
+        .option("--owner-id <uuid>", "alias namespace owner Account ID")
+        .option("--playbook-id <uuid>", "only aliases pointing at this Playbook")
+        .action(async (options) => execute(deps, options, {
+        ownerId: options.ownerId,
+        playbookId: options.playbookId,
+        ...commonPage(options)
+    }, playbookApi.listAliases));
+    mutation(alias
+        .command("delete")
+        .argument("<alias>")
+        .description("delete an alias without touching the Playbook it pointed at"))
+        .requiredOption("--owner-id <uuid>", "alias namespace owner Account ID")
+        .action(async (name, options) => execute(deps, options, { ownerId: options.ownerId, idempotencyKey: options.idempotencyKey }, (context, payload) => playbookApi.deleteAlias(context, name, payload)));
+}
+function registerCaseProgram(program, deps) {
+    const cases = program.command("case").description("start, assign, and close Cases");
+    mutation(cases.command("start").description("start a Playbook or ad-hoc Case"))
+        .option("--version-id <uuid>")
+        .option("--title <title>")
+        .option("--case-input <json>", "Case input JSON object")
+        .option("--acl <principals>", "comma-separated ACL principals")
+        .action(async (options) => execute(deps, options, {
+        versionId: options.versionId,
+        title: options.title,
+        input: parseJsonObjectOption(options.caseInput, "--case-input"),
+        acl: parseStringArrayInput(options.acl, "--acl"),
+        idempotencyKey: options.idempotencyKey
+    }, caseApi.start));
+    cases
+        .command("get")
+        .argument("<case-id>")
+        .description("get a Case with its status, ACL, and lock version")
+        .action(async (id) => printJson(await caseApi.get(await deps.resolveContext(), id)));
+    paging(input(cases.command("list").description("list readable Cases")))
+        .option("--assigned-to <uuid>", "only Cases assigned to this account")
+        .addOption(new Option("--status <status>").choices(["open", "closed"]))
+        .action(async (options) => execute(deps, options, { assignedTo: options.assignedTo, status: options.status, ...commonPage(options) }, caseApi.list));
+    mutation(cases
+        .command("assign")
+        .argument("<case-id>")
+        .description("hand overall responsibility for a Case to a user the ACL already covers"))
+        .requiredOption("--assigned-to <uuid>", "account to make responsible for the Case")
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .action(async (id, options) => execute(deps, options, {
+        assignedTo: options.assignedTo,
+        expectedLockVersion: options.lockVersion,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.assign(context, id, payload)));
+    mutation(cases
+        .command("acl")
+        .argument("<case-id>")
+        .description("replace a Case ACL; it must still cover every current assignee"))
+        .requiredOption("--acl <principals>", "comma-separated ACL principals")
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .action(async (id, options) => execute(deps, options, {
+        acl: parseStringArrayInput(options.acl, "--acl"),
+        expectedLockVersion: options.lockVersion,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.updateAcl(context, id, payload)));
+    mutation(cases.command("update").argument("<case-id>").description("update editable Case fields"))
+        .option("--title <title>")
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .action(async (id, options) => execute(deps, options, {
+        title: options.title,
+        expectedLockVersion: options.lockVersion,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.update(context, id, payload)));
+    mutation(cases
+        .command("close")
+        .argument("<case-id>")
+        .description("close a Case; completed requires no open Tasks, cancelled and abandoned close the rest"))
+        .addOption(new Option("--outcome <outcome>").choices(["completed", "cancelled", "abandoned"]))
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .option("--records <json>", "JSON array of final Records")
+        .action(async (id, options) => execute(deps, options, {
+        outcome: options.outcome,
+        expectedLockVersion: options.lockVersion,
+        records: parseJsonArrayOption(options.records, "--records"),
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.close(context, id, payload)));
+    mutation(cases
+        .command("reopen")
+        .argument("<case-id>")
+        .description("reopen a closed Case; its Tasks stay closed until reopened separately"))
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .action(async (id, options) => execute(deps, options, {
+        expectedLockVersion: options.lockVersion,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.reopen(context, id, payload)));
+}
+function registerRecordProgram(program, deps) {
+    const record = program
+        .command("record")
+        .description("append Records and browse the ACL-scoped activity feed");
+    mutation(record
+        .command("append")
+        .argument("<case-id>")
+        .description("append an immutable Record to an open Case"))
+        .option("--task-id <uuid>", "Task this Record belongs to")
+        .option("--source-step-id <id>", "four-character Step ID from the Case's pinned Version")
+        .option("--kind <kind>", "application-defined Record kind, 1-64 characters")
+        .option("--content <text>")
+        .option("--data <json>", "Record data JSON object")
+        .addOption(new Option("--origin <origin>").choices(["user", "agent"]))
+        .option("--client-name <name>")
+        .option("--client-version <version>")
+        .action(async (id, options) => execute(deps, options, {
+        taskId: options.taskId,
+        sourceStepId: options.sourceStepId,
+        kind: options.kind,
+        content: options.content,
+        data: parseJsonObjectOption(options.data, "--data"),
+        origin: options.origin,
+        clientName: options.clientName,
+        clientVersion: options.clientVersion,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => recordApi.append(context, id, payload)));
+    paging(input(record
+        .command("list")
+        .description("browse Records across every readable Case, newest first by default")))
+        .option("--case-id <uuid>")
+        .option("--task-id <uuid>")
+        .option("--created-by <uuid>")
+        .option("--kinds <kinds>", "comma-separated Record kinds")
+        .option("--origins <origins>", "comma-separated user,agent,system")
+        .option("--acl <principals>", "narrow to Cases overlapping these ACL principals")
+        .addOption(new Option("--order <order>").choices(["asc", "desc"]).default("desc"))
+        .action(async (options) => execute(deps, options, {
+        caseId: options.caseId,
+        taskId: options.taskId,
+        createdBy: options.createdBy,
+        kinds: parseStringArrayInput(options.kinds, "--kinds"),
+        origins: parseStringArrayInput(options.origins, "--origins"),
+        acl: parseStringArrayInput(options.acl, "--acl"),
+        order: options.order,
+        ...commonPage(options)
+    }, recordApi.list));
+}
+function registerTaskProgram(program, deps) {
+    const task = program.command("task").description("manage materialized Case Tasks");
+    mutation(task
+        .command("create")
+        .argument("<case-id>")
+        .description("create a work or review Task when the work needs its own owner"))
+        .addOption(new Option("--kind <kind>").choices(["work", "review"]))
+        .option("--title <title>")
+        .option("--instructions <text>")
+        .option("--source-step-id <id>", "four-character Step ID from the Case's pinned Version")
+        .option("--assigned-to <uuid>", "assignee the Case ACL already covers; required for review")
+        .option("--subject-record-id <uuid>", "Record under review; review Tasks only")
+        .action(async (id, options) => execute(deps, options, {
+        kind: options.kind,
+        title: options.title,
+        instructions: options.instructions,
+        sourceStepId: options.sourceStepId,
+        assignedTo: options.assignedTo,
+        subjectRecordId: options.subjectRecordId,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.createTask(context, id, payload)));
+    paging(input(task
+        .command("list")
+        .description("list Tasks in a Case, or your Tasks across Cases with --assigned-to")))
+        .option("--case-id <uuid>")
+        .option("--assigned-to <uuid>", "required when --case-id is omitted")
+        .addOption(new Option("--status <status>").choices(["open", "closed"]))
+        .action(async (options) => execute(deps, options, {
+        caseId: options.caseId,
+        assignedTo: options.assignedTo,
+        status: options.status,
+        ...commonPage(options)
+    }, caseApi.listTasks));
+    mutation(task
+        .command("assign")
+        .argument("<task-id>")
+        .description("assign a Task to a user the Case ACL already covers"))
+        .option("--assigned-to <uuid>", "omit in --input to clear assignment")
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .action(async (taskId, options) => execute(deps, options, {
+        assignedTo: options.assignedTo,
+        expectedLockVersion: options.lockVersion,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.assignTask(context, taskId, payload)));
+    mutation(task
+        .command("update")
+        .argument("<task-id>")
+        .description("update editable Task fields while the Task and Case are open"))
+        .option("--title <title>")
+        .option("--instructions <text>")
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .action(async (taskId, options) => execute(deps, options, {
+        title: options.title,
+        instructions: options.instructions,
+        expectedLockVersion: options.lockVersion,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.updateTask(context, taskId, payload)));
+    mutation(task
+        .command("close")
+        .argument("<task-id>")
+        .description("close a Task with an outcome, optionally appending its final Records"))
+        .requiredOption("--outcome <outcome>", "free-text result of the Task")
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .option("--records <json>", "JSON array of final Records")
+        .action(async (taskId, options) => execute(deps, options, {
+        outcome: options.outcome,
+        expectedLockVersion: options.lockVersion,
+        records: parseJsonArrayOption(options.records, "--records"),
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.closeTask(context, taskId, payload)));
+    mutation(task
+        .command("reopen")
+        .argument("<task-id>")
+        .description("reopen a closed Task while its parent Case is still open"))
+        .requiredOption("--lock-version <number>", "expected lock version", number)
+        .action(async (taskId, options) => execute(deps, options, {
+        expectedLockVersion: options.lockVersion,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => caseApi.reopenTask(context, taskId, payload)));
+}
+function registerSuggestionProgram(program, deps) {
+    const suggestion = program.command("suggestion").description("manage Playbook Suggestions");
+    mutation(suggestion
+        .command("create")
+        .description("propose a change against an immutable base Version"))
+        .option("--playbook-id <uuid>")
+        .option("--base-version-id <uuid>", "Version the proposal was written against")
+        .option("--target-step-id <id>", "four-character Step ID within the base Version")
+        .option("--title <title>")
+        .option("--content <text>")
+        .action(async (options) => execute(deps, options, {
+        playbookId: options.playbookId,
+        baseVersionId: options.baseVersionId,
+        targetStepId: options.targetStepId,
+        title: options.title,
+        content: options.content,
+        idempotencyKey: options.idempotencyKey
+    }, suggestionApi.create));
+    suggestion
+        .command("get")
+        .argument("<suggestion-id>")
+        .description("get a Suggestion and its resolution state")
+        .action(async (id) => printJson(await suggestionApi.get(await deps.resolveContext(), id)));
+    paging(input(suggestion.command("list").description("list readable Suggestions")))
+        .option("--playbook-id <uuid>")
+        .option("--author-id <uuid>")
+        .option("--statuses <statuses>", "comma-separated open,applied,declined,archived")
+        .action(async (options) => execute(deps, options, {
+        playbookId: options.playbookId,
+        authorId: options.authorId,
+        statuses: parseStringArrayInput(options.statuses, "--statuses"),
+        ...commonPage(options)
+    }, suggestionApi.list));
+    mutation(suggestion
+        .command("update")
+        .argument("<suggestion-id>")
+        .description("edit your own open Suggestion"))
+        .option("--title <title>")
+        .option("--content <text>")
+        .action(async (id, options) => execute(deps, options, {
+        title: options.title,
+        content: options.content,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => suggestionApi.update(context, id, payload)));
+    mutation(suggestion
+        .command("resolve")
+        .argument("<suggestion-id>")
+        .description("apply, decline, archive, or reopen a Suggestion"))
+        .addOption(new Option("--status <status>").choices(["open", "applied", "declined", "archived"]))
+        .option("--result-version-id <uuid>", "Version published from it; required for applied")
+        .action(async (id, options) => execute(deps, options, {
+        status: options.status,
+        resultVersionId: options.resultVersionId,
+        idempotencyKey: options.idempotencyKey
+    }, (context, payload) => suggestionApi.resolve(context, id, payload)));
+}
+//# sourceMappingURL=playbook-program.js.map