@unbrained/pm-cli 2026.11.2 → 2026.11.4

package/dist/types.d.ts

@@ -89,6 +89,10 @@ export type GovernanceCloseValidationDefault = (typeof GOVERNANCE_CLOSE_VALIDATI
 export declare const GOVERNANCE_WORKFLOW_ENFORCEMENT_VALUES:readonly ["off","warn","strict"];
 /** Restricts governance workflow enforcement values accepted by command, SDK, and storage contracts. */
 export type GovernanceWorkflowEnforcement = (typeof GOVERNANCE_WORKFLOW_ENFORCEMENT_VALUES)[number];
+/** Supported values for starting an item whose declared blocker is still open. */
+export declare const GOVERNANCE_START_BLOCKER_ENFORCEMENT_VALUES:readonly ["off","warn","strict"];
+/** Start-with-open-blockers admission mode: refuse (`strict`, default), warn, or ignore. */
+export type GovernanceStartBlockerEnforcement = (typeof GOVERNANCE_START_BLOCKER_ENFORCEMENT_VALUES)[number];
 /** Supported create/copy near-duplicate governance modes. */
 export declare const GOVERNANCE_DUPLICATE_DETECTION_MODE_VALUES:readonly ["off","advisory","strict"];
 /** Restricts create/copy near-duplicate governance behavior. */
@@ -945,6 +949,8 @@ force_required_for_stale_lock:boolean;
 create_default_type?:string;
 /** Per-type allowed-transition enforcement mode for `pm update --status`. Read raw from settings (not preset-derived) so existing projects are unaffected when unset; defaults to "off". */
 workflow_enforcement?:GovernanceWorkflowEnforcement;
+/** Admission for moving an item with an open declared blocker into progress. Read raw (not preset-derived); unset means "strict". */
+start_blocker_enforcement?:GovernanceStartBlockerEnforcement;
 /** Create/copy near-duplicate enforcement mode. */
 duplicate_detection_mode:GovernanceDuplicateDetectionMode;
 /** Inclusive similarity floor on the zero-to-one scale. */

package/dist/types.js

@@ -1,2 +1,2 @@
-(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bc25122b-94e0-510e-bdbd-b10e3c255d68")}catch{}})();const BUILTIN_ITEM_TYPE_VALUES=["Epic","Feature","Task","Chore","Issue","Decision","Event","Reminder","Milestone","Meeting","Plan"],ITEM_TYPE_VALUES=BUILTIN_ITEM_TYPE_VALUES,STATUS_VALUES=["draft","open","in_progress","blocked","closed","canceled"],RUNTIME_STATUS_ROLE_VALUES=["draft","active","blocked","terminal","terminal_done","terminal_canceled","default_open","default_close","default_cancel"],RUNTIME_FIELD_TYPE_VALUES=["string","number","boolean","string_array","array","object"],RUNTIME_FIELD_COMMAND_VALUES=["create","update","update_many","list","search","calendar","context"],RUNTIME_UNKNOWN_FIELD_POLICY_VALUES=["allow","warn","reject"],DEPENDENCY_KIND_VALUES=["blocks","parent","child","parent_child","child_of","related","related_to","discovered_from","blocked_by","incident_from","epic","implements","recurs_from","supersedes","task","verifies"],SCOPE_VALUES=["project","global"],RISK_VALUES=["low","medium","high","critical"],ISSUE_SEVERITY_VALUES=["low","medium","high","critical"],CONFIDENCE_TEXT_VALUES=["low","medium","high"],ITEM_FORMAT_VALUES=["toon","json_markdown"],SPRINT_RELEASE_FORMAT_POLICY_VALUES=["warn","strict_error"],PARENT_REFERENCE_POLICY_VALUES=["warn","strict_error"],VALIDATE_METADATA_PROFILE_VALUES=["core","strict","custom"],GOVERNANCE_PRESET_VALUES=["minimal","default","strict","custom"],GOVERNANCE_OWNERSHIP_ENFORCEMENT_VALUES=["none","warn","strict"],GOVERNANCE_CREATE_MODE_DEFAULT_VALUES=["progressive","strict"],GOVERNANCE_CLOSE_VALIDATION_DEFAULT_VALUES=["off","warn","strict"],GOVERNANCE_WORKFLOW_ENFORCEMENT_VALUES=["off","warn","strict"],GOVERNANCE_DUPLICATE_DETECTION_MODE_VALUES=["off","advisory","strict"],VALIDATE_METADATA_REQUIRED_FIELD_VALUES=["author","acceptance_criteria","estimated_minutes","close_reason","reviewer","risk","confidence","sprint","release"],RECURRENCE_FREQUENCY_VALUES=["daily","weekly","monthly","yearly"],RECURRENCE_WEEKDAY_VALUES=["mon","tue","wed","thu","fri","sat","sun"];function weekdayOrderIndex(value){return RECURRENCE_WEEKDAY_VALUES.indexOf(value)}const PLAN_MODE_VALUES=["draft","research","review","approved","executing","paused","completed","superseded"],PLAN_STEP_STATUS_VALUES=["pending","in_progress","completed","blocked","skipped","superseded"],PLAN_HARNESS_VALUES=["codex","claude-code","cursor","generic"],PLAN_STEP_LINK_KIND_VALUES=["related","blocks","blocked_by","depends_on","discovered_from","implements","recurs_from","verifies","supersedes"],CONTEXT_DEPTH_VALUES=["brief","standard","deep","full"],CONTEXT_SECTION_VALUES=["hierarchy","activity","progress","recently_created","unparented","blockers","files","workload","staleness","tests"];export{BUILTIN_ITEM_TYPE_VALUES,CONFIDENCE_TEXT_VALUES,CONTEXT_DEPTH_VALUES,CONTEXT_SECTION_VALUES,DEPENDENCY_KIND_VALUES,GOVERNANCE_CLOSE_VALIDATION_DEFAULT_VALUES,GOVERNANCE_CREATE_MODE_DEFAULT_VALUES,GOVERNANCE_DUPLICATE_DETECTION_MODE_VALUES,GOVERNANCE_OWNERSHIP_ENFORCEMENT_VALUES,GOVERNANCE_PRESET_VALUES,GOVERNANCE_WORKFLOW_ENFORCEMENT_VALUES,ISSUE_SEVERITY_VALUES,ITEM_FORMAT_VALUES,ITEM_TYPE_VALUES,PARENT_REFERENCE_POLICY_VALUES,PLAN_HARNESS_VALUES,PLAN_MODE_VALUES,PLAN_STEP_LINK_KIND_VALUES,PLAN_STEP_STATUS_VALUES,RECURRENCE_FREQUENCY_VALUES,RECURRENCE_WEEKDAY_VALUES,RISK_VALUES,RUNTIME_FIELD_COMMAND_VALUES,RUNTIME_FIELD_TYPE_VALUES,RUNTIME_STATUS_ROLE_VALUES,RUNTIME_UNKNOWN_FIELD_POLICY_VALUES,SCOPE_VALUES,SPRINT_RELEASE_FORMAT_POLICY_VALUES,STATUS_VALUES,VALIDATE_METADATA_PROFILE_VALUES,VALIDATE_METADATA_REQUIRED_FIELD_VALUES,weekdayOrderIndex};
+(function(){try{var e=typeof window<"u"?window:typeof global<"u"?global:typeof globalThis<"u"?globalThis:typeof self<"u"?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b181d38e-7120-5d34-98d9-fd9b4619b9d9")}catch{}})();const BUILTIN_ITEM_TYPE_VALUES=["Epic","Feature","Task","Chore","Issue","Decision","Event","Reminder","Milestone","Meeting","Plan"],ITEM_TYPE_VALUES=BUILTIN_ITEM_TYPE_VALUES,STATUS_VALUES=["draft","open","in_progress","blocked","closed","canceled"],RUNTIME_STATUS_ROLE_VALUES=["draft","active","blocked","terminal","terminal_done","terminal_canceled","default_open","default_close","default_cancel"],RUNTIME_FIELD_TYPE_VALUES=["string","number","boolean","string_array","array","object"],RUNTIME_FIELD_COMMAND_VALUES=["create","update","update_many","list","search","calendar","context"],RUNTIME_UNKNOWN_FIELD_POLICY_VALUES=["allow","warn","reject"],DEPENDENCY_KIND_VALUES=["blocks","parent","child","parent_child","child_of","related","related_to","discovered_from","blocked_by","incident_from","epic","implements","recurs_from","supersedes","task","verifies"],SCOPE_VALUES=["project","global"],RISK_VALUES=["low","medium","high","critical"],ISSUE_SEVERITY_VALUES=["low","medium","high","critical"],CONFIDENCE_TEXT_VALUES=["low","medium","high"],ITEM_FORMAT_VALUES=["toon","json_markdown"],SPRINT_RELEASE_FORMAT_POLICY_VALUES=["warn","strict_error"],PARENT_REFERENCE_POLICY_VALUES=["warn","strict_error"],VALIDATE_METADATA_PROFILE_VALUES=["core","strict","custom"],GOVERNANCE_PRESET_VALUES=["minimal","default","strict","custom"],GOVERNANCE_OWNERSHIP_ENFORCEMENT_VALUES=["none","warn","strict"],GOVERNANCE_CREATE_MODE_DEFAULT_VALUES=["progressive","strict"],GOVERNANCE_CLOSE_VALIDATION_DEFAULT_VALUES=["off","warn","strict"],GOVERNANCE_WORKFLOW_ENFORCEMENT_VALUES=["off","warn","strict"],GOVERNANCE_START_BLOCKER_ENFORCEMENT_VALUES=["off","warn","strict"],GOVERNANCE_DUPLICATE_DETECTION_MODE_VALUES=["off","advisory","strict"],VALIDATE_METADATA_REQUIRED_FIELD_VALUES=["author","acceptance_criteria","estimated_minutes","close_reason","reviewer","risk","confidence","sprint","release"],RECURRENCE_FREQUENCY_VALUES=["daily","weekly","monthly","yearly"],RECURRENCE_WEEKDAY_VALUES=["mon","tue","wed","thu","fri","sat","sun"];function weekdayOrderIndex(value){return RECURRENCE_WEEKDAY_VALUES.indexOf(value)}const PLAN_MODE_VALUES=["draft","research","review","approved","executing","paused","completed","superseded"],PLAN_STEP_STATUS_VALUES=["pending","in_progress","completed","blocked","skipped","superseded"],PLAN_HARNESS_VALUES=["codex","claude-code","cursor","generic"],PLAN_STEP_LINK_KIND_VALUES=["related","blocks","blocked_by","depends_on","discovered_from","implements","recurs_from","verifies","supersedes"],CONTEXT_DEPTH_VALUES=["brief","standard","deep","full"],CONTEXT_SECTION_VALUES=["hierarchy","activity","progress","recently_created","unparented","blockers","files","workload","staleness","tests"];export{BUILTIN_ITEM_TYPE_VALUES,CONFIDENCE_TEXT_VALUES,CONTEXT_DEPTH_VALUES,CONTEXT_SECTION_VALUES,DEPENDENCY_KIND_VALUES,GOVERNANCE_CLOSE_VALIDATION_DEFAULT_VALUES,GOVERNANCE_CREATE_MODE_DEFAULT_VALUES,GOVERNANCE_DUPLICATE_DETECTION_MODE_VALUES,GOVERNANCE_OWNERSHIP_ENFORCEMENT_VALUES,GOVERNANCE_PRESET_VALUES,GOVERNANCE_START_BLOCKER_ENFORCEMENT_VALUES,GOVERNANCE_WORKFLOW_ENFORCEMENT_VALUES,ISSUE_SEVERITY_VALUES,ITEM_FORMAT_VALUES,ITEM_TYPE_VALUES,PARENT_REFERENCE_POLICY_VALUES,PLAN_HARNESS_VALUES,PLAN_MODE_VALUES,PLAN_STEP_LINK_KIND_VALUES,PLAN_STEP_STATUS_VALUES,RECURRENCE_FREQUENCY_VALUES,RECURRENCE_WEEKDAY_VALUES,RISK_VALUES,RUNTIME_FIELD_COMMAND_VALUES,RUNTIME_FIELD_TYPE_VALUES,RUNTIME_STATUS_ROLE_VALUES,RUNTIME_UNKNOWN_FIELD_POLICY_VALUES,SCOPE_VALUES,SPRINT_RELEASE_FORMAT_POLICY_VALUES,STATUS_VALUES,VALIDATE_METADATA_PROFILE_VALUES,VALIDATE_METADATA_REQUIRED_FIELD_VALUES,weekdayOrderIndex};
 //# sourceMappingURL=types.js.map

package/docs/COMMANDS.md

@@ -963,6 +963,97 @@ pm release <id>
 `--author` on claim/release flows, not a metadata update. Use `--force` only when
 explicitly overriding terminal-state or lock conflicts.
 
+Starting work respects declared blockers
+([pm-urzubi](../.agents/pm/issues/pm-urzubi.toon)). `pm update <id> --status
+in_progress`, `pm claim <id> --start`, `pm claim --next --start` and the
+`start-task` action refuse with `start_blocked_by_open_dependency` (exit 4)
+when the item moves into the start status while a `blocked_by` target is still
+open. An item already in that status is not rechecked, so `claim --start` on it
+succeeds. The check runs before any write: the
+explicit `claim <id> --start` judges it under the claim's item lock, and its
+status update judges again under its own lock. When the first check refuses,
+nothing is written. When a blocker opens between the two writes, the start
+refuses and, if it took the item from no owner, releases that claim. The release
+is fenced by assignee and claim principal, so another principal's takeover is
+never cleared; principal is pm's unit of ownership, so a concurrent reclaim by
+the same principal is indistinguishable from the original claim. If the item already had an owner, or that
+release cannot run, the claim stays and the refusal's `why` reports the partial
+completion. The
+refusal lists the open blockers in `details.open_blockers` and suggests the
+exact `pm update` that drops the edge. When no single command can do that
+safely (clearing the `blocked_by` scalar would also drop an independent
+`blocked_by` edge, or a legacy row's short id, alias kind or external locator
+would not match a removal selector; see
+[pm-4yxzvd](../.agents/pm/issues/pm-4yxzvd.toon)), it suggests inspecting the
+item instead. The check uses the effective start status, including the
+registered `in_progress` fallback when the workflow names `open`.
+A terminal blocker never blocks, and an update that removes the blocker in the
+same call is admitted. `--force` starts anyway and records
+`start_blocker_override:<id>:<blockers>`. `governance.start_blocker_enforcement`
+selects `strict` (default), `warn` (start and record
+`start_with_open_blockers:<id>:<blockers>`), or `off`. A blocker whose record
+cannot be judged (an invalid or non-UTF-8 document, an unsupported item format,
+or an ambiguous or conflicting identity) refuses under `strict` with that typed
+error. `warn` and `--force` still admit the start and record
+`start_blocker_unverifiable:<id>:<code>`. Filesystem failures and merge-conflict
+markers always propagate.
+
+### Expected revisions (`--expect-hash`)
+
+Read-decide-write agents guard a write with the revision they decided on
+([pm-gh1576](../.agents/pm/features/pm-gh1576.toon)). `pm get <id> --json`
+reports `item_hash`. The global `--expect-hash <item_hash>` flag makes every
+locked write the command makes to that item refuse with `item_revision_conflict`
+(exit 4) if the item changed since:
+
+```bash
+H=$(pm get pm-a1b2 --json | jq -r .item_hash)
+pm close pm-a1b2 "Delivered by PR 1" --expect-hash "$H"
+H1=$(pm get pm-a1b2 --json | jq -r .item_hash)
+H2=$(pm get pm-c3d4 --json | jq -r .item_hash)
+pm update-many --ids pm-a1b2,pm-c3d4 --priority 1 \
+  --expect-hash "pm-a1b2=$H1" --expect-hash "pm-c3d4=$H2"
+```
+
+A bare hash binds to the command's `<id>` argument (for `plan`, the id after
+the subcommand; `plan create` has none). `<id>=<item_hash>`
+(repeatable or comma-separated) names targets explicitly and is required for
+commands without one item argument. The refusal reports `expected_revision`,
+`current_revision`, and `details.changes_since` (the newest 10 history entries
+since the declared revision, with their top-level `fields`). The refused write
+is suppressed; writes the same command already committed (for example the
+claim of a composed `claim --start`) stay durable, and the message then says
+so ("Earlier writes by this same invocation already committed"). Read commands refuse the flag with
+`expect_hash_requires_mutation`, and an empty value (such as an unset `$H`)
+refuses with `expect_hash_invalid` instead of running unguarded. Bulk
+`update-many`/`close-many` fail only stale rows, forward and `--rollback` alike, each
+carrying `error_code`, `expected_revision`, `current_revision` and
+`details.changes_since`. When `close` auto-unblocks a guarded dependent whose revision
+moved, the close stays committed and the command refuses with that dependent's
+`item_revision_conflict` once the fan-out finishes. `side_effects` names every
+write that committed first: the close and each dependent already unblocked. `close-many` reports such a row as `closed` (`update-many` closing
+through `--status`, as `updated`), with the dependent's conflict under
+`dependent_revision_conflict`. A guarded `restore` refuses to recover
+over a live file that cannot be read as a document; an unguarded restore still
+recovers it. `deps` only reads, so it refuses the flag. History maintenance
+(`history-redact`, `history-repair` including `--salvage-tail`, `history-compact`)
+is checked under the stream lock. Its bulk forms (`history-compact --ids`,
+`history-repair --all`) carry the same typed conflict fields on refused rows. An
+item file whose embedded id differs from its physical file name (even by case on a
+case-sensitive filesystem) binds no revision: reading or declaring one refuses with
+`item_identity_conflict` until the identity is repaired. `validate --auto-fix`/`--prune-missing` refuses typed once every fix
+was attempted. When an extension parser or preflight override rewrites the
+invocation's tracker or arguments, a guarded invocation refuses with
+`expect_hash_invocation_rewritten`, since which item it writes cannot be proved.
+The same refusal covers a parser pass during final dispatch, which must also keep
+the guard admissible (adding `--background` late refuses with
+`expect_hash_background_unsupported`). Inventory commands
+(`package inventory`, `extension inventory`) never write items, so they validate
+the flag and then refuse with `expect_hash_requires_mutation`. An item the command never wrote produces the
+warning `expect_hash_unchecked:<id>:no_locked_write_reached_this_item`. MCP
+tools accept the same tokens as `expectHash`; the SDK exposes
+`withExpectedItemRevisions` (see [SDK](SDK.md#expected-item-revisions)).
+
 ## Logs
 
 ```bash

package/docs/CONFIGURATION.md

@@ -103,6 +103,7 @@ If the existing `settings.json` is valid JSON but fails schema validation (for e
 | `item_types.definitions[]`                 | custom item types and type options                                                                                                                                                                    |
 | `governance.create_default_type`           | default `--type` used by `pm create "title"` when `--type` is omitted (defaults to `Task`); must resolve to a known item type                                                                         |
 | `governance.workflow_enforcement`          | per-type transition enforcement mode for `pm update --status` (`off` default, `warn`, or `strict`)                                                                                                    |
+| `governance.start_blocker_enforcement`     | starting an item (`update --status in_progress`, `claim --start`) while a declared `blocked_by` target is open: `strict` (default; refuse unless `--force`), `warn`, or `off`                         |
 | `governance.duplicate_detection_mode`      | create/copy similarity policy: `off`, `advisory`, or `strict`; the minimal preset uses `off`, while the default and strict presets use `strict`                                                       |
 | `governance.duplicate_detection_threshold` | inclusive likely-duplicate score from `0` through `1` (default `0.8`)                                                                                                                                 |
 | `governance.duplicate_detection_limit`     | maximum matches attached to a create/copy advisory from `0` through `20` (default `3`)                                                                                                                |

package/docs/EXTENSIONS.md

@@ -306,7 +306,7 @@ Use the public SDK barrel. Do not deep-import from `src/core` or `dist/core`.
 - `api.extension` is a read-only identity (`name`, `layer`, `version`, `capabilities`, `pm_min_version?`, `pm_max_version?`, `source_package?`) for self-identifying logs and version gating without re-reading the manifest.
 - `api.registerCommand(definition)` adds package-owned commands; `read_output` opts readers into the [SDK output contract](SDK.md#minimal-command-extension).
 - `api.registerFlags(command, flags)` adds runtime command flags. A flag may declare `value_type` (canonical; the legacy `type` alias is honored only when `value_type` is absent), `list: true` to accumulate repeated/comma-joined values like core `--tags`, a `default` applied when the flag is omitted, and `value_validation: "strict"` to refuse malformed `number`/`boolean` tokens before the handler runs (the default `"coerce"` forwards the raw token). See [Flag Contracts](SDK.md#flag-contracts).
-- `api.registerItemFields(fields)` adds custom metadata fields. Agents can set declared fields with repeatable `pm create --field name=value` and `pm update <id> --field name=value`; undeclared names are rejected. `SchemaFieldDefinition.type` is the same closed union used by `pm schema add-field`: `string | number | boolean | string_array | array | object`. Unsupported values fail at compile time for TypeScript authors and at activation for JavaScript packages, with a did-you-mean hint on typos. `string_array` is the repeatable string collection; `array` and `object` require JSON containers. Active fields support `get`, `list` and `search` projections with `--fields name` or `--fields item.name`, preserving declared value types through `PmClient` and CLI reads. Disabled packages do not contribute selectors. Tracked by [pm-gh1571](../.agents/pm/issues/pm-gh1571.toon).
+- `api.registerItemFields(fields)` adds custom metadata fields. Agents can set declared fields with repeatable `pm create --field name=value` and `pm update <id> --field name=value`; undeclared names are rejected. Extension declarations are matched first; a name that no active extension declares but the project schema does (for example `gate_evidence`) is refused with `project_schema_field_requires_declared_flag`, which names a CLI flag and an SDK option that each set only that field (each is omitted when every spelling is shared with another declared field or with an option of the command itself) and, on the CLI, an executable `suggested_retry_args` that rewrites only that assignment. The guidance follows the invoking scope (a bulk `update-many` row is routed under `update_many`, not `update`), and when the same invocation already sets that field through a declared flag, alias or option, no route or retry is offered, because the retry would carry two values for one field ([pm-wftvem](https://github.com/unbraind/pm-cli/blob/main/.agents/pm/issues/pm-wftvem.toon); tracker record excluded from npm); reserved core keys keep `core_item_field_requires_dedicated_flag`. `SchemaFieldDefinition.type` is the same closed union used by `pm schema add-field`: `string | number | boolean | string_array | array | object`. Unsupported values fail at compile time for TypeScript authors and at activation for JavaScript packages, with a did-you-mean hint on typos. `string_array` is the repeatable string collection; `array` and `object` require JSON containers. Active fields support `get`, `list` and `search` projections with `--fields name` or `--fields item.name`, preserving declared value types through `PmClient` and CLI reads. Disabled packages do not contribute selectors. Tracked by [pm-gh1571](../.agents/pm/issues/pm-gh1571.toon).
 - Custom fields whose camel-case option name is already owned by a canonical MCP input remain usable through `options.<name>`, but authoring surfaces report the collision instead of allowing silent top-level shadowing. `pm schema add-field`, `pm profile lint`, and `pm package doctor` name the field, canonical `mcp_tool_input` owner, and nested recovery path. SDK authors can preflight the same rule with `resolvePmToolCustomFieldCollision`.
 - `api.registerItemTypes(types)` adds custom item types.
 - `api.registerRelationshipKinds(definitions)` adds validated graph semantics. Definitions declare direction, inverse spelling, ordering/precedence, hierarchy, cardinality, lifecycle, aliases, payload schema, compatibility version, and self-edge policy. Active definitions govern CLI, MCP, and SDK dependency mutation admission as well as workspace graph assembly; mutation aliases are stored canonically. Requires the `schema` capability and is governed by the `schema.relationshipkinds` policy surface. See [relationship mutation admission](RELATIONSHIP_GRAPH.md#contract), tracked by [pm-7dsolo](../.agents/pm/issues/pm-7dsolo.toon).
@@ -426,7 +426,7 @@ import { createExtensionTestHarness } from "@unbrained/pm-cli/sdk/testing";
 import { activateExtensionForTest } from "@unbrained/pm-cli/sdk/testing";
 ```
 
-Runtime modules use static SDK imports; installed copies receive a host SDK link. Use `createPmCliExpectedError(message, { exitCode, context })` for expected user/action failures from package commands. It creates an `Error` named `PmCliError` with a structural `exitCode`, so separately installed package code still gets expected-error handling and Sentry filtering. Commands that need to render a structured gate report and still fail CI may instead return an object with `exit_code` from `1` through `255`; optional string `code` and `remediation` fields are preserved by the host. The result is rendered normally, and the CLI exits with the declared status. Thrown plain objects also preserve bounded `code` and `remediation` fields in the host error contract.
+Runtime modules use static SDK imports; installed copies receive a host SDK link. Use `createPmCliExpectedError(message, { exitCode, context })` for expected user/action failures from package commands. It creates an `Error` named `PmCliError` with a structural `exitCode`, so separately installed package code still gets expected-error handling and Sentry filtering. Commands that need to render a structured gate report and still fail CI may instead return an object with `exit_code` from `1` through `255`; optional string `code` and `remediation` fields are preserved by the host. The result is rendered normally, and the CLI exits with the declared status. Thrown plain objects also preserve bounded `code` and `remediation` fields in the host error contract; those bounds never split a surrogate pair. Put structured, package-owned facts in `context.details` (plain JSON, at most 4,096 bytes when rendered) rather than spreading them over host fields. The host renders them in `--json`, text and MCP refusals and never sends them to telemetry or Sentry; see [Producer-owned diagnostics](SDK.md#producer-owned-diagnostics-contextdetails).
 Prefer the `define*` builders for exported registration definitions (`defineCommand`, `defineFlag`, `defineSearchProvider`, `defineAfterCommandHook`, and the matching override/import/export/hook helpers; see ADR [pm-3mph](../.agents/pm/decisions/pm-3mph.toon)). They are zero-cost identity functions that preserve object literal types and contextually type function parameters before the definitions reach `api.register*`; runtime validation remains in the loader, and behavior validation remains in `sdk/testing`.
 Packages that extend core list or search behavior should import `LIST_FILTER_EXTENSION_FLAG_DEFINITIONS`, `SEARCH_EXTENSION_FLAG_DEFINITIONS`, or `toExtensionFlagDefinitions` from `@unbrained/pm-cli/sdk/authoring` instead of copying CLI option tables. For example: `api.registerFlags("my search", SEARCH_EXTENSION_FLAG_DEFINITIONS)`.
 The adapter expands aliases into registration-ready definitions and preserves string/boolean behavior, list accumulation, repeatability, requiredness, descriptions, and value names from the canonical CLI contracts. Use `toExtensionFlagDefinitions` with another exported CLI flag contract for a narrower baseline.

package/docs/LINKED_TEST_EDITS.md

@@ -21,11 +21,44 @@ index and metadata field names in `context.linked_test_update`.
 Use `null` to clear an optional field, such as a note, path or timeout. Scope is
 required and cannot be cleared. Every entry must retain a nonblank command or path:
 replace a path-only entry's path rather than clearing its last identity.
-Unknown fields, command changes, provenance
-changes and editor-stamp overrides are refused. To change the command, remove
-and add it through the ordinary provenance-recording workflow. Editing context
-or environment controls changes the clone-local trust fingerprint, so any prior
-acknowledgment must be reviewed again.
+Unknown fields, provenance changes and editor-stamp overrides are refused with
+`linked_test_patch_fields_unsupported`, which lists the editable fields in
+`recovery.allowed_values`. Editing context or environment controls changes the
+clone-local trust fingerprint, so any prior acknowledgment must be reviewed again.
+
+A command is the entry's immutable identity, so a `command` or `cmd` key is
+refused with `linked_test_command_immutable` before anything is written. The
+refusal's `recovery.suggested_retry_args` is the supported replacement
+([pm-1rfy0y](https://github.com/unbraind/pm-cli/blob/main/.agents/pm/issues/pm-1rfy0y.toon);
+tracker record excluded from npm): one `pm test` invocation
+that removes the selected entry (by its exact command, or by its locked position
+when the entry has no unique command) and adds the new command with the entry's
+other metadata and any other fields from your patch. The replacement records
+fresh provenance in a single `tests_add` history event, leaves every other entry
+untouched, and is appended at the end of the list:
+
+```bash
+pm test <item-id> --update-index 1 --set-json '{"command":"node scripts/check-v2.mjs"}' --json
+# refused: linked_test_command_immutable; run the advertised retry, for example
+pm test <item-id> --remove 'command=node scripts/check.mjs' --add-json '{"command":"node scripts/check-v2.mjs","scope":"project","note":"Verified coverage gate"}'
+```
+
+Repeating the current command, or sending an empty one, is refused with the same
+code and a pointer to the editable fields instead of a replacement. Other fields
+in the same patch are validated before the retry is offered, so an unsupported
+key, `scope: null` or an invalid value refuses instead of being silently dropped.
+When the replacement would have the same identity (command, path, scope and
+context modes) as another entry, the add would be deduplicated away, so no retry
+is offered; the refusal names that entry's `--update-index` and the selected
+entry's `--remove-index` instead. Conflicting `command` and `cmd` values, and a
+replacement that would invoke `pm test-all`, refuse without a retry. Explicit
+`--author`, `--message` and `--force` on the refused edit are carried into the
+retry, so ownership and history attribution match the original request.
+The retry is a separate mutation: if other writers may change the item's tests
+in between, list them again before running it. An atomic replacement under one
+item lock is tracked by
+[pm-5igljl](https://github.com/unbraind/pm-cli/blob/main/.agents/pm/issues/pm-5igljl.toon)
+(tracker record excluded from npm).
 
 Exactly one selector must match the current collection under the item lock.
 Absent selectors and ambiguous command/path matches refuse the whole edit and

package/docs/SDK.md

@@ -1307,8 +1307,21 @@ atomic evidence-backed completion tracked by
 commands that must coordinate several SDK mutations. A plan supplies a stable
 transaction id plus ordered steps. Each step can inspect its durable state,
 apply an idempotent forward mutation, and append an idempotent compensation.
-The coordinator serializes transaction writers with one workspace lock and
+The coordinator serializes transaction coordinators with one workspace lock and
 persists `.agents/pm/transactions/sdk/<transaction-id>.json` after every step.
+That lock does not exclude ordinary writers ([GH-1620](https://github.com/unbraind/pm-cli/issues/1620)):
+`update`, `close`, `pm comments --add` and every other SDK, CLI or MCP mutation
+take per-item locks, so a peer can commit between a step's `inspect()` and
+`apply()`. A step that decides from what it read guards its write with an
+[expected item revision](#expected-item-revisions): in `inspect()`, take both
+the decision data and `item_hash` from one `get()`, then run the write inside
+`withExpectedItemRevisions()`. The
+write then refuses with `item_revision_conflict` instead of overwriting the
+peer's change, and the transaction compensates. The coordinator invokes
+`compensate()`, including during recovery, without an expected revision.
+Built-in item compensations detect intervening writes. A custom adapter must
+fence or reconcile its own compensation, or it can restore a stale value over a
+peer's write.
 Before invoking a pending step, it also persists that step's durable ownership
 marker. Recovery and compensation therefore distinguish mutations begun by
 this transaction from matching domain state that existed before the attempt.
@@ -1348,6 +1361,102 @@ failures and the journal keeps recovery data. Repeated compensation recognizes
 its durable marker even when a peer adds context afterward. Legacy timestamp
 receipts remain supported, with ambiguous partial effects refused.
 
+### Expected item revisions
+
+Expected-revision preconditions are tracked by
+[pm-gh1576](../.agents/pm/features/pm-gh1576.toon).
+
+Read-decide-write agents and packages guard a write with the revision their
+decision was based on. Every current `pm get` / `PmClient.get` read reports
+`item_hash`, the SHA-256 of the canonical item document and the same value as
+the item's latest history `after_hash` (a field-projected read includes it only
+when the selection names the bare `item_hash`, for example `--fields title,tags,item_hash`;
+the item-qualified `item.item_hash` still projects a custom metadata field of that name).
+`readItemRevision(id)` returns it alone. Take the hash from the same read your
+decision uses: a separate read could observe a newer revision than the data you
+decided on. Run the write inside `withExpectedItemRevisions`:
+
+```ts
+import { PmClient, isItemRevisionConflict } from "@unbrained/pm-cli/sdk";
+
+const pm = new PmClient({ pmRoot });
+// Decide from the same read that reports the revision, never from a separate one.
+const read = await pm.get(id);
+const reason = `Delivered by ${read.item.tags?.find((tag) => tag.startsWith("delivery-pr:"))}`;
+try {
+  const { result, unchecked } = await pm.withExpectedItemRevisions(
+    [{ id, itemHash: read.item_hash! }],
+    () => pm.close(id, reason),
+  );
+} catch (error) {
+  if (!isItemRevisionConflict(error)) throw error;
+  // error.context.current_revision and error.context.details.changes_since
+  // describe what changed; re-read, decide again, retry with the new hash.
+}
+```
+
+The check runs inside the locked item store, after the item lock is held and
+before that write. It therefore covers every item write the wrapped
+operation makes: lifecycle commands, annotations, linked files/docs/tests,
+dependency edits, `restore`, `delete`, history maintenance (`history-redact`,
+`history-repair`, `history-compact`, checked under the stream lock), bulk
+transactions and extension commands that mutate through the SDK. A `delete`
+advances the expectation to the item's absent (tombstone) revision, and a
+`restore` of a deleted item is judged under its own id, so a peer deletion
+between the read and the restore refuses instead of being resurrected over. A mismatch refuses that write with `item_revision_conflict`
+(exit 4); writes the operation already committed stay durable. The refusal carries `item_id`, `expected_revision`,
+`current_revision` and `details` with `changes_since`, the newest
+10 history entries after the declared revision
+(`op`, `author`, `ts`, top-level `fields`), plus `changes_since_omitted`.
+`expected_revision_recorded: false` means no history entry ever had that hash.
+After one of the operation's own writes commits, the expectation advances to
+that revision, so a multi-write composition such as `claim --start` does not
+refuse itself; an interleaved peer write still refuses the next step. The
+result lists `checked` ids and `unchecked` ids that the operation never wrote:
+an unchecked expectation proved nothing. Expectations bind to the item's embedded id, so every
+spelling that locates the item (a short id, or a case variant on a
+case-insensitive filesystem) is guarded. The scope is shared process-wide across the
+published SDK entrypoints (`/sdk`, `/sdk/core`, ...), and
+`isItemRevisionConflict` checks the refusal structurally, so mixing entrypoints
+neither drops a guard nor hides its conflict. Trackers are compared by physical
+path (`realpath`), so a symlinked spelling of the same tracker is guarded too. `PmClient.readItemRevision` and
+`PmClient.withExpectedItemRevisions` resolve targets inside the client's
+extension context, so extension item types bind exactly as `get` reads them,
+then run the operation outside it, so its own actions (extension commands
+included) activate and dispatch normally. The standalone `readItemRevision` /
+`withExpectedItemRevisions` functions use the registrations already active in
+the calling context. A deleted item with retained history binds too: its
+revision is the empty tombstone its `delete` recorded (the delete entry's
+`after_hash`), so a guarded `restore` or history maintenance of a deleted item
+can declare it. Bulk `update-many`
+and `close-many` keep their partial-success semantics: a stale row fails with
+`error_code: "item_revision_conflict"` plus its `expected_revision`,
+`current_revision` and the same `details` (`changes_since`,
+`changes_since_omitted`) a single-item refusal carries, while fresh rows
+proceed. When a peer writes while `restore` or history maintenance waits for
+its lock, a declared revision turns the generic drift refusal into this typed
+conflict. Linked-test result recording (`test --run`, `test-all` with
+`test_result_tracking` enabled) stays best-effort, except that a stale declared
+revision refuses with `item_revision_conflict` instead of a warning. A guard cannot reach a `--background` test worker,
+which runs in another process, so `test`/`test-all --background` with an
+expected revision refuses with `expect_hash_background_unsupported`. Only the CLI invocation scope reads `GlobalOptions.expectHash`;
+direct `run*` SDK calls ignore it, so guard SDK writes with the functions above
+or `runAction`/MCP `expectHash`.
+
+Transports use the same grammar. The CLI's global `--expect-hash <item_hash>`
+binds to the command's `<id>`; `--expect-hash <id>=<item_hash>` (repeatable or
+comma-separated) names targets explicitly and is required for bulk commands.
+MCP tools and `PmClient.run` accept `expectHash` (string or string array) on
+every item-writing action, at the top level or inside `options`; either
+placement is enforced. A native read action refuses the flag with
+`expect_hash_requires_mutation`, and a malformed, supplied-but-empty or `null`
+value (for example an unset shell variable) refuses with `expect_hash_invalid`
+rather than silently dropping the guard. An expectation no write reached is reported as the
+warning `expect_hash_unchecked:<id>:no_locked_write_reached_this_item`. This
+precondition guards the gap between an agent's read and its write; lease
+fencing ([pm-gh1549](../.agents/pm/issues/pm-gh1549.toon)) still guards the
+write itself against lock takeover, and the two compose.
+
 ### Schema evolution and workspace history
 
 Tracked by [pm-dijg](../.agents/pm/features/pm-dijg.toon) and
@@ -3129,6 +3238,81 @@ propagates `code` and `remediation` through the command-handler result contract.
 Invalid `exit_code` values are rejected rather than truncated or silently
 treated as success.
 
+### Producer-owned diagnostics (`context.details`)
+
+Tracked by [pm-gh1631](https://github.com/unbraind/pm-cli/blob/main/.agents/pm/issues/pm-gh1631.toon)
+(tracker record excluded from npm). Host fields such as `code`, `required` and
+`recovery` describe the refusal in the host's own vocabulary. Facts that belong
+to the package go in `context.details`, a plain JSON object the host never
+interprets:
+
+```ts
+import { createPmCliExpectedError } from "@unbrained/pm-cli/sdk/runtime";
+
+throw createPmCliExpectedError("No changelog section for 2026.11.1", {
+  exitCode: 1,
+  context: {
+    code: "release_notes_missing",
+    details: {
+      selection_report: { filters: { version: "2026.11.1" }, excluded: { status: 1 } },
+    },
+  },
+});
+```
+
+- **Shape.** Values are `null`, booleans, finite numbers, well-formed strings,
+  arrays and plain objects, nested at most `PM_CLI_ERROR_DETAILS_LIMITS.max_depth`
+  (8) containers deep. `__proto__` keys and accessor properties are refused;
+  getters are never run. `createPmCliExpectedError` throws a `TypeError` whose
+  message names only the reason (`unsupported_value`, `non_finite_number`,
+  `malformed_unicode`, `reserved_key`, `depth_limit`, `not_plain_object`); the
+  offending path is on its non-enumerable `path` property, so crash reporting
+  of that fault never carries your keys. A well-formed value is kept as a
+  detached copy, so later changes to your object do not alter a raised
+  refusal; an oversized one is replaced at construction by the host-set
+  receipt `context.details_omitted: { reason: "byte_limit", byte_limit }`, so a
+  later change cannot alter the refusal either. `isPmCliErrorDetails(value)`
+  performs the same check.
+- **Rendering.** `--json` errors carry the object as `details`, text output
+  renders it as an indented JSON `Details:` block, and MCP tool errors carry it
+  inside the forwarded context. Diagnostics are rendered whole or not at all:
+  above `PM_CLI_ERROR_DETAILS_LIMITS.max_bytes` (4,096 bytes of compact UTF-8
+  JSON), or when a separately bundled error carries a malformed shape, the
+  envelope carries `details_omitted: { reason, path?, byte_limit }` instead.
+  Admitted details that would push the pretty-printed `--json` envelope past
+  the error diagnostic budget are replaced the same way, with reason
+  `diagnostic_budget`.
+  The size is counted while walking and the walk stops at the ceiling, so
+  shared or repeated structures cannot amplify the work; `path` is capped at
+  160 bytes. The CLI and MCP read a separately bundled error's context once as
+  plain data (`snapshotPmCliErrorContext`): getters are never run, and a
+  context that cannot be inspected becomes empty. MCP admits `details` from that
+  snapshot with the same bounded walk before serializing anything, then
+  serializes the remaining host fields once (a context-level `toJSON` is
+  ignored), so no serializer can expand or replace the diagnostics; a context
+  JSON cannot encode (for example a bigint member) is forwarded as
+  `{ code, context_unserializable: true }` so the response is still written. When the text output exceeds its token ceiling, the
+  text renderer drops the explanation (`why`) first and then the `Details:`
+  block (together with the example and next-step limits). A block dropped this
+  way gets no `Details omitted:` line, only the generic notice that points to
+  `--json`, which keeps the details. Custom SDK hosts apply the
+  same bound with `projectPmCliErrorDetails(value)` (returns `{ details }`,
+  `{ details_omitted }` or `undefined`) or, for a context forwarded as-is,
+  `projectPmCliErrorContextDetails(context)`.
+- **Privacy.** Telemetry and Sentry never receive `details`. The telemetry
+  classification is built without it. A crash report carries an error
+  context only as its top-level primitive fields, read without running
+  getters or `toJSON`, so diagnostics cannot reach it under another key: this
+  applies to `error_context` and to the error-data entry, which is rebuilt
+  whole from the original exception (its own primitive fields plus the safe
+  context), because the integration serializes the error, including any
+  error-level `toJSON`, before `beforeSend`. Serialized copies whose original
+  cannot be recovered are discarded: embedded contexts in console-capture
+  data, breadcrumbs and transactions are sent as empty objects, and complete
+  serialized console `arguments` are sent as empty arrays, because an error's
+  own `toJSON` can move diagnostics out of any named slot. The custom-host
+  projections drop a context-level `toJSON` for the same reason.
+
 ## Package Runtime Imports
 
 Third-party packages should import from stable public SDK subpaths:

package/docs/agent-task-token-baseline.json

@@ -1 +1 @@
-{"version":5,"transcript_version":2,"transcript_digest":"sha256:b4b151f3d36860e73cd535d0520e9f03b4ecec4444ee81a8b868896b5b0bba47","estimator":"ceil(utf8_bytes / 4)","comparison_scope":"plan_recovery_tracker_root_canonicalized","measurement_scope":"output_before_token_accounting","published_with_release":true,"orientation":{"canonical_task_id":"orientation-context-intent","required_capabilities":["actionable_work","active_ownership","workspace_state"],"measured_winner_tokens":1051,"protocols":[{"task_id":"orientation-context-intent","command_count":1,"estimated_tokens":1051,"capabilities":["actionable_work","active_ownership","workspace_state"],"capability_evidence":{"actionable_work":[{"step_id":"context","field_path":"hierarchy"}],"active_ownership":[{"step_id":"context","field_path":"activity"}],"workspace_state":[{"step_id":"context","field_path":"summary.active_items"}]}},{"task_id":"orientation-operating-rules","command_count":4,"estimated_tokens":2067,"capabilities":["actionable_work","active_ownership","workspace_state"],"capability_evidence":{"actionable_work":[{"step_id":"open","field_path":"items"}],"active_ownership":[{"step_id":"in-progress","field_path":"items"}],"workspace_state":[{"step_id":"context","field_path":"summary.active_items"}]}},{"task_id":"orientation-contracts-next","command_count":2,"estimated_tokens":5213,"capabilities":["actionable_work","active_ownership","workspace_state"],"capability_evidence":{"actionable_work":[{"step_id":"next","field_path":"recommended.id"}],"active_ownership":[{"step_id":"next","field_path":"held_by_others"}],"workspace_state":[{"step_id":"next","field_path":"summary.in_progress"}]}}]},"tasks":[{"id":"orientation-context-intent","max_estimated_tokens":1051,"steps":[{"id":"context","max_estimated_tokens":1051,"accounting_mode":"self_reported"}]},{"id":"orientation-contracts-next","max_estimated_tokens":5213,"steps":[{"id":"contracts","max_estimated_tokens":4481,"accounting_mode":"self_reported"},{"id":"next","max_estimated_tokens":732,"accounting_mode":"self_reported"}]},{"id":"orientation-operating-rules","max_estimated_tokens":2067,"steps":[{"id":"context","max_estimated_tokens":1015,"accounting_mode":"self_reported"},{"id":"search","max_estimated_tokens":164,"accounting_mode":"self_reported"},{"id":"open","max_estimated_tokens":712,"accounting_mode":"self_reported"},{"id":"in-progress","max_estimated_tokens":176,"accounting_mode":"self_reported"}]},{"id":"context-bootstrap","max_estimated_tokens":2005,"steps":[{"id":"triage","max_estimated_tokens":619,"accounting_mode":"self_reported"},{"id":"orient","max_estimated_tokens":1015,"accounting_mode":"self_reported"},{"id":"inspect","max_estimated_tokens":371,"accounting_mode":"self_reported"}]},{"id":"closed-domain-recovery","max_estimated_tokens":630,"steps":[{"id":"refuse-intent","max_estimated_tokens":259,"accounting_mode":"self_reported"},{"id":"retry-intent","max_estimated_tokens":371,"accounting_mode":"self_reported"}]},{"id":"unknown-option-recovery","max_estimated_tokens":596,"steps":[{"id":"refuse-option","max_estimated_tokens":433,"accounting_mode":"self_reported"},{"id":"retry-option","max_estimated_tokens":163,"accounting_mode":"self_reported"}]},{"id":"lifecycle-mutation","max_estimated_tokens":873,"steps":[{"id":"create","max_estimated_tokens":20,"accounting_mode":"self_reported"},{"id":"inspect-open","max_estimated_tokens":363,"accounting_mode":"self_reported"},{"id":"close","max_estimated_tokens":92,"accounting_mode":"self_reported"},{"id":"inspect-closed","max_estimated_tokens":398,"accounting_mode":"self_reported"}]},{"id":"bulk-effect-outcomes","max_estimated_tokens":392,"steps":[{"id":"create-bulk-target","max_estimated_tokens":20,"accounting_mode":"self_reported"},{"id":"partial-effect","max_estimated_tokens":240,"accounting_mode":"self_reported"},{"id":"no-effect","max_estimated_tokens":132,"accounting_mode":"self_reported"}]},{"id":"plan-execution-mutations","max_estimated_tokens":806,"steps":[{"id":"create-plan","max_estimated_tokens":21,"accounting_mode":"self_reported"},{"id":"add-step","max_estimated_tokens":254,"accounting_mode":"self_reported"},{"id":"complete-step","max_estimated_tokens":253,"accounting_mode":"self_reported"},{"id":"inspect-plan","max_estimated_tokens":278,"accounting_mode":"self_reported"}]}],"composite_max_estimated_tokens":13633}
+{"version":5,"transcript_version":2,"transcript_digest":"sha256:b4b151f3d36860e73cd535d0520e9f03b4ecec4444ee81a8b868896b5b0bba47","estimator":"ceil(utf8_bytes / 4)","comparison_scope":"plan_recovery_tracker_root_canonicalized","measurement_scope":"output_before_token_accounting","published_with_release":true,"orientation":{"canonical_task_id":"orientation-context-intent","required_capabilities":["actionable_work","active_ownership","workspace_state"],"measured_winner_tokens":1051,"protocols":[{"task_id":"orientation-context-intent","command_count":1,"estimated_tokens":1051,"capabilities":["actionable_work","active_ownership","workspace_state"],"capability_evidence":{"actionable_work":[{"step_id":"context","field_path":"hierarchy"}],"active_ownership":[{"step_id":"context","field_path":"activity"}],"workspace_state":[{"step_id":"context","field_path":"summary.active_items"}]}},{"task_id":"orientation-operating-rules","command_count":4,"estimated_tokens":2067,"capabilities":["actionable_work","active_ownership","workspace_state"],"capability_evidence":{"actionable_work":[{"step_id":"open","field_path":"items"}],"active_ownership":[{"step_id":"in-progress","field_path":"items"}],"workspace_state":[{"step_id":"context","field_path":"summary.active_items"}]}},{"task_id":"orientation-contracts-next","command_count":2,"estimated_tokens":5213,"capabilities":["actionable_work","active_ownership","workspace_state"],"capability_evidence":{"actionable_work":[{"step_id":"next","field_path":"recommended.id"}],"active_ownership":[{"step_id":"next","field_path":"held_by_others"}],"workspace_state":[{"step_id":"next","field_path":"summary.in_progress"}]}}]},"tasks":[{"id":"orientation-context-intent","max_estimated_tokens":1051,"steps":[{"id":"context","max_estimated_tokens":1051,"accounting_mode":"self_reported"}]},{"id":"orientation-contracts-next","max_estimated_tokens":5213,"steps":[{"id":"contracts","max_estimated_tokens":4481,"accounting_mode":"self_reported"},{"id":"next","max_estimated_tokens":732,"accounting_mode":"self_reported"}]},{"id":"orientation-operating-rules","max_estimated_tokens":2067,"steps":[{"id":"context","max_estimated_tokens":1015,"accounting_mode":"self_reported"},{"id":"search","max_estimated_tokens":164,"accounting_mode":"self_reported"},{"id":"open","max_estimated_tokens":712,"accounting_mode":"self_reported"},{"id":"in-progress","max_estimated_tokens":176,"accounting_mode":"self_reported"}]},{"id":"context-bootstrap","max_estimated_tokens":2025,"steps":[{"id":"triage","max_estimated_tokens":619,"accounting_mode":"self_reported"},{"id":"orient","max_estimated_tokens":1015,"accounting_mode":"self_reported"},{"id":"inspect","max_estimated_tokens":391,"accounting_mode":"self_reported"}]},{"id":"closed-domain-recovery","max_estimated_tokens":650,"steps":[{"id":"refuse-intent","max_estimated_tokens":259,"accounting_mode":"self_reported"},{"id":"retry-intent","max_estimated_tokens":391,"accounting_mode":"self_reported"}]},{"id":"unknown-option-recovery","max_estimated_tokens":596,"steps":[{"id":"refuse-option","max_estimated_tokens":433,"accounting_mode":"self_reported"},{"id":"retry-option","max_estimated_tokens":163,"accounting_mode":"self_reported"}]},{"id":"lifecycle-mutation","max_estimated_tokens":915,"steps":[{"id":"create","max_estimated_tokens":20,"accounting_mode":"self_reported"},{"id":"inspect-open","max_estimated_tokens":384,"accounting_mode":"self_reported"},{"id":"close","max_estimated_tokens":92,"accounting_mode":"self_reported"},{"id":"inspect-closed","max_estimated_tokens":419,"accounting_mode":"self_reported"}]},{"id":"bulk-effect-outcomes","max_estimated_tokens":392,"steps":[{"id":"create-bulk-target","max_estimated_tokens":20,"accounting_mode":"self_reported"},{"id":"partial-effect","max_estimated_tokens":240,"accounting_mode":"self_reported"},{"id":"no-effect","max_estimated_tokens":132,"accounting_mode":"self_reported"}]},{"id":"plan-execution-mutations","max_estimated_tokens":806,"steps":[{"id":"create-plan","max_estimated_tokens":21,"accounting_mode":"self_reported"},{"id":"add-step","max_estimated_tokens":254,"accounting_mode":"self_reported"},{"id":"complete-step","max_estimated_tokens":253,"accounting_mode":"self_reported"},{"id":"inspect-plan","max_estimated_tokens":278,"accounting_mode":"self_reported"}]}],"composite_max_estimated_tokens":13715}