@astrosheep/keiyaku 2.9.13 → 4.0.0

package/README.md

@@ -1,136 +1,16 @@
-# Keiyaku
+# Keiyaku v4
 
-契約 — a contract.
+Keiyaku v4 is a clean implementation of an agent-facing contract workflow.
 
-Keiyaku is an AI-first CLI: its user is a coding agent. Not a human writing
-specs for an agent to implement — an agent delegating to other agents,
-running the whole loop itself: writing the terms, calling the worker,
-supervising the run, settling the outcome.
+The first milestone is intentionally narrow: a Git-backed facts kernel with
+per-contract append-only journals, Git-tree evidence, atomic path-set CAS,
+and tests that prove clone and garbage-collection durability.
 
-That is why it is a contract system rather than a spec system. A spec relies
-on someone with judgment reading it charitably; here both the worker and the
-judge are models, and a model honors what you wrote, not what you meant. So
-terms are binding, the worker — an akuma (悪魔, demon) — runs on an isolated
-branch, gates and a reviewer judge the diff against the criteria alone, and
-settlement is mechanical: the change lands on main with a commit-hash
-receipt, or the branch is deleted. No human needs to be in the loop for any
-step; nothing depends on anyone eyeballing anything.
+No v3 runtime code is wired into this repository.
 
-```bash
-npm install -g @astrosheep/keiyaku
-```
-
-Node ≥ 22.19, inside a git repository with a clean worktree.
-
-## One deal, end to end
-
-```bash
-# Write the terms: Title, Context, Objective, Design & Approach, Scope, Criteria.
-# The criteria are read by the letter — precision goes here, not in prompts.
-keiyaku bind - < contract.md
-
-# Put an akuma on it. It works alone in the contract's own worktree.
-keiyaku call worker-akuma --detach "fulfill the contract"
-
-# It runs for as long as it needs. You are not its babysitter —
-# but you can be:
-keiyaku wait worker-akuma/3f21ab9e --timeout 10m
-keiyaku tell worker-akuma/3f21ab9e "criteria 3 also covers the CLI output"
-keiyaku kill worker-akuma/3f21ab9e        # death is not an error state
-
-# Ask for judgment: gates run, a reviewer akuma reads the diff
-# against the criteria.
-keiyaku petition
-
-# claim  → the change lands on main, with a commit-hash receipt
-# forfeit → the branch is deleted; partial fulfillment is forfeiture
-```
-
-Every step appends to the contract's ledger. `keiyaku log` replays any deal,
-finished or dead, from its receipts.
-
-## The board
-
-`keiyaku status` is the one screen of state. Real output:
-
-```text
-kanshi ─────────────────────────────────────────────────────── 現世 b4c38cc
-
-marks ● active · … starting · ⧗ waiting · ○ ready · ‖ paused · ✓ success · × stopped · ! failed/broken · ? unknown
-
-keiyaku 2
-⧗ fridge Add task arrange for atomic existing-task reorganization   waiting on task-reorganization.01J8TEST · active 27m
-● hermitcrab Let task commands select a contract workspace                                          bound 8m
-
-task 120
-● in_progress P1 centralize-repository-ledger-test-construction   last update 14h ago
-‖ on_hold P0 windows-common-commands-must-eliminate-git-proc      last update 3d ago
-+ 108 ready · 9 blocked · 1 on hold
+## Install
 
-akuma 2/2
-running 1/1
-● worker-default/e03addad @fridge       out · running for 27m · last activity 2s ago
-recent terminal 1/1
-! worker-default/64b92f01               failed 5m ago · ran 12m · last activity 5m ago
-full roster: keiyaku status --akuma
-```
-
-The indicator grammar is shared across contracts, Akuma, and tasks; every row
-still names its exact state. `⧗` appears only with a typed wait reason, never
-because work is old or behind its target. Terminal failure is factual state; it
-does not by itself mean `needs attention` or an actionable obligation.
-Durations are measured, exit codes are real, and drift is reported as `behind
-<ref> by <count>`, never as a `renew` recommendation.
-
-## An akuma is one Markdown file
-
-Filename is the name, frontmatter picks the provider and model, the body is
-the standing instructions. That's all it takes to make one callable.
-
-```markdown
----
-provider: codex-sdk
-model: gpt-5.4
-description: Repository implementation agent
----
-Make scoped changes and run relevant tests.
-```
-
-Providers: `codex-sdk`, `codex-app-server`, `claude-agent-sdk`,
-`opencode-sdk`, `pi` — one contract can be worked by any of them, and a
-finished run leaves an artifact that `fork` can continue from, even across
-sessions.
-
-`.keiyaku/settings.json` assigns roles and gates:
-
-```json
-{
-  "default": "worker-akuma",
-  "reviewer": "review-akuma",
-  "gate": { "commands": [{ "label": "tests", "command": "npm", "args": ["test"] }] }
-}
+```sh
+npm install -g @astrosheep/keiyaku
+keiyaku --help
 ```
-
-## And the rest
-
-| | |
-| --- | --- |
-| contract | `bind` `arc` `amend` `renew` `audit` `petition` `forfeit` `log` |
-| akuma | `call` `tell` `wait` `kill` `fork` `status` `history` |
-| tasks | `task add/show/ls/log/start/stop/hold/resume/done/drop/update/doctor` |
-| system | `guide` `completion` `dump-env` |
-
-`keiyaku task` is a file-backed planning board for work that isn't worth a
-contract yet — typed dependencies, one micro-commit per change, promotion
-into a contract when it's ready.
-
-Conventions hold everywhere: a literal `-` reads stdin for long bodies,
-`--json` where structure matters, and a rejected command states the legal
-grammar instead of guessing intent. State lives in `KEIYAKU.md` (the active
-contract) and `.keiyaku/` (akuma, settings, task board, history).
-
-Full product documentation: [`docs/keiyaku-v3/`](docs/keiyaku-v3/README.md).
-
-Keiyaku is early and experimental — breaking changes are intentional.
-
-MIT.

package/build/integrations/marketplace/.agents/plugins/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "keiyaku",
+  "interface": { "displayName": "Keiyaku" },
+  "plugins": [
+    {
+      "name": "keiyaku",
+      "source": { "source": "local", "path": "./plugins/keiyaku" },
+      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
+      "category": "Productivity"
+    }
+  ]
+}

package/build/integrations/marketplace/.claude-plugin/marketplace.json

@@ -0,0 +1,5 @@
+{
+  "name": "keiyaku",
+  "owner": { "name": "Keiyaku" },
+  "plugins": [{ "name": "keiyaku", "source": "./plugins/keiyaku" }]
+}

package/build/integrations/marketplace/plugins/keiyaku/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "keiyaku",
+  "version": "0.1.0",
+  "description": "Use the Keiyaku v4 contract, task, and Akuma CLI.",
+  "author": { "name": "Keiyaku" },
+  "skills": "./skills/"
+}

package/build/integrations/marketplace/plugins/keiyaku/.codex-plugin/plugin.json

@@ -0,0 +1,18 @@
+{
+  "name": "keiyaku",
+  "version": "0.1.0",
+  "description": "Use the Keiyaku v4 contract, task, and Akuma CLI.",
+  "author": {
+    "name": "Keiyaku"
+  },
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Keiyaku",
+    "shortDescription": "Use Keiyaku in Codex.",
+    "longDescription": "Keiyaku adds the v4 agent-facing workflow CLI.",
+    "developerName": "Keiyaku",
+    "category": "Productivity",
+    "capabilities": [],
+    "defaultPrompt": "Use Keiyaku v4 to coordinate this work."
+  }
+}

package/build/integrations/marketplace/plugins/keiyaku/opencode.js

@@ -0,0 +1,16 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+const skills = ["keiyaku", "keiyaku-task", "keiyaku-workflow", "keiyaku-akuma"]
+  .map((name) => fileURLToPath(new URL(`./skills/${name}/SKILL.md`, import.meta.url)));
+
+export default {
+  id: "keiyaku-v4",
+  server: async () => ({
+    config: async (config) => {
+      const instructions = config.instructions ?? (config.instructions = []);
+      await Promise.all(skills.map((skill) => readFile(skill, "utf8")));
+      for (const skill of skills) if (!instructions.includes(skill)) instructions.push(skill);
+    },
+  }),
+};

package/build/integrations/marketplace/plugins/keiyaku/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "keiyaku-v4-harness",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./opencode.js",
+  "keywords": ["pi-package"],
+  "pi": { "skills": ["./skills"] }
+}

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: keiyaku
+description: Use the Keiyaku v4 CLI for contract delivery, task coordination, and Akuma work.
+---
+
+# Keiyaku
+
+Use `keiyaku` as an agent-facing ledger. Keep decisions with the flagship;
+read `<command> --help` before using flags.
+
+## Model
+
+- `task` is planning; see `keiyaku-task`.
+- A Contract is delivery authority; see `keiyaku-workflow`.
+- An Akuma is a callable worker; see `keiyaku-akuma`.
+
+## Quick Start
+
+```bash
+keiyaku -C <repo> task add "title"
+keiyaku -C <repo> task start <task-id>
+keiyaku -C <repo> bind -
+keiyaku -C <repo> status
+keiyaku -C <repo> deliver [<contract>|@<contract>]
+keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
+```
+
+```bash
+keiyaku -C <repo> call <akuma> [--contract <kei/...>] [--alias @name] [--workdir <path>] [--wait [--timeout <duration>] | -d | --detach] [--json] -
+keiyaku -C <repo> wait <aku/...>
+keiyaku -C <repo> tell <aku/...> -
+```
+
+Use text by default; add `--json` when a script needs structured output.

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-akuma/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: keiyaku-akuma
+description: Use when delegating work to, supervising, steering, inspecting, forking, or stopping a Keiyaku v4 Akuma.
+---
+
+# Keiyaku Akuma
+
+An Akuma is a durable callable worker projection. Its complete id is
+`aku/<archetype>/<hex8>`; keep that id for recovery.
+
+## Choose A Verb
+
+```bash
+keiyaku -C <repo> call <akuma> [--contract <kei/...>] [--alias @name] [--workdir <path>] [--wait [--timeout <duration>] | -d | --detach] [--json] -
+keiyaku -C <repo> wait <aku/...> [--timeout <duration>]
+keiyaku -C <repo> tell <aku/...> -
+keiyaku -C <repo> interrupt <aku/...> -
+keiyaku -C <repo> history <aku/...>
+keiyaku -C <repo> fork <aku/...> --at <historyId>
+keiyaku -C <repo> kill <aku/...>
+```
+
+`call` starts from an Archetype, requires a final stdin body, and waits up to
+five minutes by default. Use `-d` or `--detach` to return after birth. `tell` continues
+the same projection, including after it has answered. `fork` starts a child
+from one exact retained answered-turn coordinate and leaves the source alone.
+`interrupt` puts down the current body synchronously, then records the tell;
+it is not terminal kill. `kill` records death and returns typed physical
+evidence.
+
+## Observe
+
+```bash
+keiyaku -C <repo> status
+keiyaku -C <repo> status <aku/...>
+keiyaku -C <repo> wait <aku/...> --timeout 5m
+keiyaku -C <repo> history <aku/...> --before <index>
+keiyaku -C <repo> history <aku/...> --since <index>
+keiyaku -C <repo> history <aku/...> --last
+```
+
+Bare `status` shows the compact fleet. Exact `status <aku/...>` and `wait`
+share the public status carrier; a wait timeout returns the current snapshot,
+not a fabricated timeout state. History cursors are persistent activity
+sequences and `--before`/`--since` are exclusive. `--last` writes only the
+complete answer bytes. Use `--json` when a script needs the typed values.
+
+Read the exact command help for duration syntax and provider-specific Archetype
+configuration. Do not use old `follow`, plural wait, `--after`, or `--at`
+index forms; they are not root commands.

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-task/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: keiyaku-task
+description: "Use when planning work in a Keiyaku v4 repo: add tasks, wire dependencies, inspect readiness, and track lifecycle."
+---
+
+# Keiyaku Task
+
+Task is a directory-context planning product. It is separate from Contract
+delivery and Akuma execution. A task records intent; `start` does not execute
+it and no task command binds a Contract.
+
+## Lifecycle
+
+```text
+open -> in_progress -> done | drop
+  |          |
+  +-> on_hold <-+
+```
+
+Use `ready` for open tasks whose `needs` are terminal. `blocked` reports open
+or in-progress tasks with unresolved needs. `on_hold` appears in neither view.
+Both `done` and `drop` release dependents. `doctor` diagnoses the complete
+world and never repairs it.
+
+## Common Commands
+
+```bash
+keiyaku task add "title"
+keiyaku task add "title" --priority 1 --needs <task-id>
+keiyaku task add --namespace <ns> -
+keiyaku task show <task-id>
+keiyaku task ls
+keiyaku task ls --closed
+keiyaku task ls --all --world
+keiyaku task ready
+keiyaku task blocked
+keiyaku task tree <task-id> [--full]
+keiyaku task doctor
+```
+
+`ls`, `ready`, and `blocked` use the current namespace; add `--world` to
+observe the complete Task world. `show`, `tree`, `update`, and lifecycle
+commands require a complete TaskId and never infer namespace.
+
+## Mutations
+
+```bash
+keiyaku task start <task-id>
+keiyaku task stop <task-id>
+keiyaku task hold <task-id>
+keiyaku task resume <task-id>
+keiyaku task done <task-id>...
+keiyaku task drop <task-id>... [--note <text>]
+keiyaku task update <task-id> --title <text>
+keiyaku task namespace [<namespace>]
+```
+
+Use `--json` on any command when a script must inspect the typed result. Use
+`task compose -` for one atomic tree/graph edit; read its command help for the
+composition grammar. Relations are explicit facts: `needs` orders work,
+`parent` groups it, `supersedes` navigates replacement, and `relates` does not
+affect readiness.

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-workflow/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: keiyaku-workflow
+description: Use when authoring, binding, delivering, reviewing, amending, auditing, or abandoning a Keiyaku v4 Contract.
+---
+
+# Keiyaku Workflow
+
+A Contract is one delivery authority. Its document is ordinary input until
+`bind` admits it; the bound Contract owns its coordinates, terms, prerequisite
+snapshot, candidate, reviews, gates, and terminal decision. Task planning and
+Akuma execution remain separate products.
+
+## Lifecycle
+
+```text
+bind -> waiting | bound -> pending delivery -> claimed
+                                      \-> abandoned
+```
+
+`claimed` and `abandoned` are terminal. A prerequisite `after` list is ordered
+and immutable after `bound`; `amend` can replace terms and change prerequisites
+only before they are consumed. `deliver` tenders current worktree bytes.
+`review --satisfied` records testimony and requests placement; placement claims
+only when every declared gate is current. `review --unsatisfied` records
+judgment without claiming. `audit` observes and never places.
+
+## Bind
+
+Write one canonical Contract document to stdin and bind it:
+
+```bash
+keiyaku bind -
+keiyaku bind --target <ref> -
+keiyaku bind --here -
+keiyaku bind --after <kei/...> --gates <name> -
+```
+
+The document owns the delivery objective, design, scope, criteria, and optional
+verification declaration. Use the exact `bind --help` grammar; do not invent
+identity or timestamps. A successful receipt is the source of the complete
+Contract coordinate and any managed worktree facts.
+
+## Work And Acceptance
+
+```bash
+keiyaku status [<contract>|@<contract>]
+keiyaku amend [<contract>|@<contract>] -
+keiyaku arc [<contract>|@<contract>] -
+keiyaku deliver [<contract>|@<contract>]
+keiyaku review [<contract>|@<contract>] --satisfied
+keiyaku review [<contract>|@<contract>] --unsatisfied
+keiyaku audit [<contract>|@<contract>] [--show-diff-body]
+keiyaku reconcile [<contract>|@<contract>]
+```
+
+Use complete `kei/...` IDs or `@...` managed-worktree references. Omitted
+selectors are contextual only when the CLI reports exactly one active
+worktree contract. `amend` reads amendment operations, `arc` reads arc
+Markdown, and both require their final `-`; `deliver`, `review`, `audit`, and
+`reconcile` do not read an unselected stdin body. `review --summary <text>` is
+opaque testimony and is mutually exclusive with review stdin.
+
+## Terminal Choice
+
+`abandon [<contract>|@<contract>] [--note <text>]` writes the terminal
+abandoned fact and does not touch a target ref. There is no `petition`, `claim`,
+`forfeit`, `renew`, or `bind --task` command in v4. A successful placement
+produces the claimed terminal state; inspect the typed result and decide what
+to do next.
+
+Use default text output for routine observation. Add `--json` when a script
+needs the public result without renderer-specific text.

package/build/src/akuma/activity.d.ts

@@ -0,0 +1,66 @@
+import { type ToolCall, type ToolResult } from "./provider.js";
+import type { ActivityFact, ActivitySlice, TellFact, TurnFact } from "./heart/index.js";
+export type ActivityRow = Readonly<{
+    kind: "said";
+    sequence: number;
+    bodySequence: number;
+    at: string;
+    text: string;
+}> | Readonly<{
+    kind: "thought";
+    sequence: number;
+    bodySequence: number;
+    at: string;
+    text: string;
+}> | Readonly<{
+    kind: "tool";
+    sequence: number;
+    bodySequence: number;
+    at: string;
+    completedAt?: string;
+    durationMs?: number;
+    name: string;
+    call: ToolCall;
+    state: "running" | ToolResult;
+}> | Readonly<{
+    kind: "note";
+    sequence: number;
+    bodySequence: number;
+    at: string;
+    text: string;
+}>;
+export type PendingTell = Readonly<{
+    id: string;
+    body: string;
+    recordedAt: string;
+}>;
+export type ActivitySnapshot = Readonly<{
+    rows: readonly ActivityRow[];
+    pendingTells: readonly PendingTell[];
+    omitted: number;
+    lowestRetained: number | null;
+    highest: number | null;
+}>;
+export type ActivityHistory = Readonly<{
+    rows: readonly ActivityRow[];
+    turns: readonly TurnFact[];
+    omitted: number;
+    hasEarlier: boolean;
+    hasLater: boolean;
+    historyLost: boolean;
+    lowestRetained: number | null;
+    highest: number | null;
+}>;
+/** Fold the complete retained typed event window before any display budget. */
+export declare function foldActivity(facts: readonly ActivityFact[]): readonly ActivityRow[];
+/** Apply the one bounded recent selection after folding semantic rows. */
+export declare function selectActivitySnapshot(facts: readonly ActivityFact[], input?: Readonly<{
+    pending?: readonly TellFact[];
+    lowestRetained?: number | null;
+    highest?: number | null;
+}>): ActivitySnapshot;
+/** Project a cursor page; history never applies the recent snapshot pinning rules. */
+export declare function projectActivityHistory(slice: ActivitySlice, turns: readonly TurnFact[], input: Readonly<{
+    since?: boolean;
+    limit: number;
+}>): ActivityHistory;

package/build/src/akuma/activity.js

@@ -0,0 +1,139 @@
+import { decodeAgentEvent } from "./provider.js";
+const SETTLED_LIMIT = 8;
+const INTENT_LIMIT = 2;
+function duration(startedAt, completedAt) {
+    const start = Date.parse(startedAt);
+    const end = Date.parse(completedAt);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+        return undefined;
+    return end - start;
+}
+function toolKey(bodySequence, id) {
+    return `${bodySequence}:${id}`;
+}
+function narrationRow(fact, event) {
+    if (event.type === "assistant") {
+        return { kind: "said", sequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.at, text: event.text };
+    }
+    if (event.type === "thought" || event.type === "note") {
+        return { kind: event.type, sequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.at, text: event.text };
+    }
+    return null;
+}
+/** Fold the complete retained typed event window before any display budget. */
+export function foldActivity(facts) {
+    const rows = [];
+    const running = new Map();
+    for (const fact of facts) {
+        const event = decodeAgentEvent(fact.event);
+        const narration = narrationRow(fact, event);
+        if (narration !== null) {
+            rows.push({ settled: true, row: narration });
+            continue;
+        }
+        if (event.type !== "tool")
+            continue;
+        const key = toolKey(fact.bodySequence, event.id);
+        if (event.phase === "started") {
+            const index = rows.length;
+            rows.push({
+                settled: false,
+                row: {
+                    kind: "tool",
+                    sequence: fact.sequence,
+                    bodySequence: fact.bodySequence,
+                    at: fact.at,
+                    name: event.name,
+                    call: event.call,
+                    state: "running",
+                },
+            });
+            running.set(key, index);
+            continue;
+        }
+        const index = running.get(key);
+        if (index === undefined) {
+            rows.push({
+                settled: true,
+                row: {
+                    kind: "tool",
+                    sequence: fact.sequence,
+                    bodySequence: fact.bodySequence,
+                    at: fact.at,
+                    name: event.name,
+                    call: event.call,
+                    state: event.result,
+                },
+            });
+            continue;
+        }
+        const started = rows[index].row;
+        if (started.kind !== "tool")
+            throw new Error("Akuma activity tool fold lost its start row");
+        const elapsed = duration(started.at, fact.at);
+        rows[index] = {
+            settled: true,
+            row: {
+                kind: "tool",
+                sequence: started.sequence,
+                bodySequence: started.bodySequence,
+                at: started.at,
+                completedAt: fact.at,
+                ...(elapsed === undefined ? {} : { durationMs: elapsed }),
+                name: event.name,
+                call: event.call,
+                state: event.result,
+            },
+        };
+        running.delete(key);
+    }
+    return rows.map((entry) => entry.row);
+}
+function pendingTellFacts(tells) {
+    return tells
+        .filter((tell) => tell.state !== "consumed" && tell.state !== "voided-by-death")
+        .map((tell) => ({ id: tell.id, body: tell.body, recordedAt: tell.recordedAt }));
+}
+/** Apply the one bounded recent selection after folding semantic rows. */
+export function selectActivitySnapshot(facts, input = {}) {
+    const folded = foldActivity(facts);
+    const settled = folded.filter((row) => row.kind !== "tool" || row.state !== "running");
+    const selected = new Set(settled.slice(-SETTLED_LIMIT));
+    const intent = settled.filter((row) => row.kind === "said" || row.kind === "thought").slice(-INTENT_LIMIT);
+    for (const row of intent)
+        selected.add(row);
+    for (const row of folded) {
+        if (row.kind === "tool" && row.state === "running")
+            selected.add(row);
+    }
+    return {
+        rows: folded.filter((row) => selected.has(row)),
+        pendingTells: pendingTellFacts(input.pending ?? []),
+        omitted: settled.length - [...selected].filter((row) => row.kind !== "tool" || row.state !== "running").length,
+        lowestRetained: input.lowestRetained ?? (facts[0]?.sequence ?? null),
+        highest: input.highest ?? (facts.at(-1)?.sequence ?? null),
+    };
+}
+function visibleRows(facts, since, limit) {
+    const folded = foldActivity(facts);
+    return since ? folded.slice(0, limit) : folded.slice(-limit);
+}
+/** Project a cursor page; history never applies the recent snapshot pinning rules. */
+export function projectActivityHistory(slice, turns, input) {
+    const all = foldActivity(slice.rows);
+    const rows = visibleRows(slice.rows, input.since === true, input.limit);
+    const bodySequences = new Set(rows.map((row) => row.bodySequence));
+    return {
+        rows,
+        turns: turns.filter((turn) => bodySequences.has(turn.bodySequence)),
+        omitted: Math.max(0, all.length - rows.length),
+        hasEarlier: input.since !== true && all.length > rows.length,
+        hasLater: input.since === true && all.length > rows.length,
+        historyLost: input.since !== true
+            && all.length === rows.length
+            && slice.lowestRetained !== null
+            && slice.lowestRetained > 1,
+        lowestRetained: slice.lowestRetained,
+        highest: slice.highest,
+    };
+}