@agentshouse/kit 0.1.0-alpha.4 → 0.1.0-alpha.41

package/bootstrap.json

@@ -0,0 +1,28 @@
+{
+  "schemaVersion": 1,
+  "version": "0.1.0-alpha.41",
+  "hosts": {
+    "linux": {
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.41/connect-linux.sh)",
+      "asset": {
+        "name": "connect-linux.sh",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.41/connect-linux.sh"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "posix"
+      }
+    },
+    "windows": {
+      "command": "& ([scriptblock]::Create((irm https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.41/connect-windows.ps1)))",
+      "asset": {
+        "name": "connect-windows.ps1",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.41/connect-windows.ps1"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "powershell"
+      }
+    }
+  }
+}

package/docs/configuration.md

@@ -0,0 +1,104 @@
+# Configuration
+
+`kit.json` in Kit home is the one configuration file. Every section below is
+required; a file that omits one is refused.
+
+```json
+{
+  "availability": "continuous",
+  "execution_authority": "allow",
+  "migrators": [],
+  "instances": [
+    {
+      "id": "acme",
+      "preset": "custom",
+      "services": [
+        {
+          "service": "notes",
+          "source_ref": "src_acme_notes",
+          "rooms": ["work-room"],
+          "backfill": { "days": 30 },
+          "connector": {
+            "command": ["/usr/local/bin/acme-export", "--ndjson"],
+            "timeout_ms": 120000,
+            "environment": { "ACME_REGION": "eu" },
+            "secrets": {
+              "ACME_TOKEN": { "environment": "ACME_TOKEN_SOURCE" },
+              "ACME_KEY": { "file": "/run/secrets/acme-key" }
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "clients": [
+    {
+      "kind": "claude-code",
+      "settings": "/home/ada/.claude/settings.json"
+    }
+  ],
+  "host": null,
+  "skills": true
+}
+```
+
+- `availability`: `"continuous"` for a computer that stays online,
+  `"intermittent"` for a laptop.
+- `execution_authority`: `"allow"` or `"refuse"`, this computer's answer to
+  every permission request an agent makes.
+- `instances`: your own sources, each with a `custom` connector (below).
+- `clients`: agent clients outside Kit whose settings get House's session-start
+  hook. `claude-code` is the one supported kind; declare `[]` for none.
+- `migrators`: `[]` unless you run a migrator.
+- `host`: `null` unless this computer reports its capacity to House.
+- `skills`: `true` accepts the Skill set, `false` declines it. The connect
+  command sets it.
+
+Agents and agent CLIs are chosen in House, not here. Send your changes to
+House with:
+
+```sh
+kit apply
+```
+
+## Secrets
+
+Never write a secret into `kit.json`. Under `secrets`, name an environment
+variable (`{ "environment": "NAME" }`) or a file (`{ "file": "/path" }`); Kit
+passes its value to the connector only.
+
+## Custom connectors
+
+A connector is your own command. Kit runs it without a shell, with only `PATH`,
+`environment` and the resolved secrets, and never gives it a House credential.
+It must finish within `timeout_ms` (at most 120000).
+
+Kit writes one request line to its standard input:
+
+```json
+{ "contract": "2026-08-22", "instance": "acme", "cursor": null, "limit": 100 }
+```
+
+The command prints NDJSON: `item` lines, then at most one `cursor` line.
+`cursor` in the next request is the last one it printed.
+
+```
+{"type":"item","namespace":"acme/notes","native_object_id":"note-91","native_version":"7","observed_at":"2026-08-20T09:15:00.000Z","body":"the note","author":"ada","url":"https://acme.example/notes/91","attachments":[{"url":"https://acme.example/files/1","name":"plan.pdf"}]}
+{"type":"cursor","cursor":"page-2"}
+```
+
+`namespace`, `native_object_id`, `observed_at` and `body` are required. An
+attachment is a `url`, or a local `file` with its exact `path`, `bytes`,
+`sha256` and optional `media_type`. A malformed line, a non-zero exit or a
+timeout rejects the whole run and nothing is delivered.
+
+`backfill` bounds the first capture: `{ "days": 30 }`, `{ "count": 500 }` or
+`{ "all": true }`.
+
+```sh
+kit source capture acme          # capture every service of an instance now
+kit source capture acme notes    # one service
+kit source status acme           # health, cursor, gaps and unsaved files
+kit source retry-files acme      # save files a capture could not save
+kit source reset acme notes      # start again from the backfill boundary
+```

package/docs/google.md

@@ -0,0 +1,33 @@
+# Google sources
+
+You add Gmail, Calendar and Drive sources in the House App: an account name you
+choose, the service, the Rooms it goes to, and how much history the first
+capture takes. Nothing is configured on this computer.
+
+Each service captures, read-only:
+
+- Gmail: every message except Spam and Trash.
+- Calendar: the account's primary calendar.
+- Drive: the files the account owns.
+
+## Signing in
+
+Kit ships no Google OAuth client. Each account signs in with your own:
+
+1. In your Google Cloud project, create an OAuth client of type **Desktop app**
+   and enable the API of each service you use.
+2. When House asks, enter the client id and secret on its page.
+3. Approve Google's consent. Google then sends the browser to a
+   `http://127.0.0.1:<port>/` address that does not load; copy that whole
+   address and paste it into the House page.
+
+Kit then captures each signed-in source every 15 minutes.
+
+```sh
+kit source capture work          # capture every source of the account now
+kit source capture work gmail    # one service
+kit source status work
+```
+
+If `kit source status` reports `api_disabled`, enable the API it names in your
+Google Cloud project.

package/docs/linux.md

@@ -0,0 +1,77 @@
+# Linux
+
+Run the Linux command from the [README](../README.md#connect-a-computer) in a
+terminal. It needs `bash`, `curl` and Docker Engine.
+
+## Docker Engine
+
+- A Docker Engine that already answers is used as it is, on any distribution.
+- On Ubuntu 22.04, 24.04 or 26.04 LTS, anything missing is installed from
+  Docker's own apt repository through `sudo`, which asks for your password.
+  The command starts the `docker` service and adds you to the `docker` group.
+- Ubuntu packages that conflict with Docker's (`docker.io`, `docker-compose`,
+  `docker-compose-v2`, `docker-doc`, `docker-buildx`, `podman-docker`,
+  `containerd`, `runc`) are not removed for you: remove them and run again.
+- On any other distribution, install Docker Engine first.
+
+A new `docker` group membership applies from your next sign-in. If a later run
+says so, sign out and back in, then run the command again.
+
+## What it creates
+
+- `~/.house-kit`: Kit home, with your credential and `kit.json`.
+- `~/AgentsHouse`: your workspace, mounted in the container as
+  `/agents/house`. Pass `--workspace /absolute/path` to use another directory.
+
+Both are readable only by you. The credential is never printed.
+
+## Updating
+
+Run a newer release's command. While an Agent session is still running, the
+update names it and leaves Kit as it is; run the command again once it ends.
+Your credential, Kit home and workspace are kept.
+
+## Pushing a working copy
+
+From a directory under your workspace, such as a Room copy under
+`working-copies/rooms/`, run:
+
+```sh
+bash <(curl -fsSL …/connect-linux.sh) house git push --owner
+```
+
+## A House on this computer
+
+`--house http://127.0.0.1:<port>` or `--house http://localhost:<port>` runs Kit
+on the host network so it can reach a House served on this computer.
+
+## An Always-on server that hosts containers
+
+An Always-on Ubuntu server that will run persistent container Environments
+connects natively instead of in a container. Run the command with `--linux`:
+
+```sh
+bash <(curl -fsSL …/connect-linux.sh) --linux
+```
+
+It needs Ubuntu 26.04 LTS on `amd64`; any other host is refused. Every other
+computer takes the ordinary command. It sets up:
+
+- Docker Engine, as above, and `git` and `tmux` from Ubuntu's apt repository.
+- `/opt/house-kit`: House Kit and the Node.js it runs on, copied from the
+  release's image and owned by root.
+- `~/.house-kit`: Kit home, readable only by you.
+- `/agents/house`: your Agents' workspace, readable only by you.
+- `house-kit.service`: the systemd service that runs Kit as you and starts it
+  with the server.
+
+The server connects as a continuous Environment. Put `--linux` before `kit` or
+`house` to run a Kit command, as in
+`bash <(curl -fsSL …/connect-linux.sh) --linux kit apply`, and run a newer
+release's command with `--linux` to update it, as above.
+
+The same run updates the container Environments the server hosts to that
+release. A running one waits, and is named, until its own Agent sessions end;
+run the command again then. A stopped one is updated and stays stopped. Each
+keeps its files, sign-ins and CPU, memory and disk limits; only what was
+installed outside its workspace and Kit home is not kept.

package/docs/macos.md

@@ -0,0 +1,26 @@
+# macOS
+
+Run the Linux command from the [README](../README.md#connect-a-computer) in
+Terminal. It works on Apple silicon and Intel Macs, including from a terminal
+running under Rosetta.
+
+## Docker Desktop
+
+Kit on a Mac needs Docker Desktop.
+
+- A Docker Desktop that already answers is used as it is.
+- Other engines, such as Colima or OrbStack, are refused.
+- Without `/Applications/Docker.app`, the command downloads Docker Desktop for
+  your chip and installs it through `sudo`, which asks for your password.
+- The command opens Docker Desktop and waits up to five minutes while you
+  accept its terms or finish what its window asks. If it is still not ready,
+  run the command again.
+
+## Notes
+
+- A `--workspace` directory must be one Docker Desktop shares, such as one
+  under `/Users`.
+- A House on this computer (`--house http://127.0.0.1:<port>`) needs host
+  networking enabled in Docker Desktop's settings.
+
+Everything else works as on [Linux](linux.md).

package/docs/telegram.md

@@ -0,0 +1,29 @@
+# Telegram bot
+
+Kit can connect your own Telegram bot so your House conversations appear there.
+The bot token stays on this computer; House never receives it.
+
+1. Create a bot with BotFather and turn on its Threaded Mode.
+2. Send the bot one ordinary private message outside any topic, so Kit can
+   tell the bot is yours.
+3. Connect it, entering the token at the hidden prompt:
+
+   ```sh
+   kit telegram connect
+   ```
+
+4. Serve it; this keeps running until you stop it:
+
+   ```sh
+   kit telegram serve
+   ```
+
+To release the bot:
+
+```sh
+kit telegram disconnect
+```
+
+Run each command through the connect command as the
+[README](../README.md#run-a-kit-command) shows. Only one computer can serve a
+given bot.

package/docs/windows.md

@@ -0,0 +1,37 @@
+# Windows
+
+Run the Windows command from the [README](../README.md#connect-a-computer) in
+the 64-bit Windows PowerShell. It needs Windows 11 23H2 (build 22631) or later
+on `amd64`. Windows Server, Windows 10 and Windows on ARM are refused.
+
+## WSL 2 and Docker Desktop
+
+- A Docker Desktop that already runs Linux containers on WSL 2 is used as it is.
+- Without WSL, the command runs `wsl --install --no-distribution`. Approve the
+  administrator prompt, restart Windows, and run the command again. An old WSL
+  is updated the same way.
+- Without Docker Desktop, the command downloads it and installs it for your
+  account only, without administrator rights.
+- The command starts Docker Desktop and waits up to five minutes while you
+  accept its terms or finish what its window asks. If it is still not ready,
+  run the command again.
+- Windows containers, the Hyper-V engine and other Docker engines are refused.
+
+## What it creates
+
+- The Docker volume `house-kit-home`: Kit home, with your credential and
+  `kit.json`, mounted in the container as `/kit-home`. It lives on Docker
+  Desktop's own WSL 2 disk, not on your Windows drive. Docker Desktop's
+  Volumes view shows its files; double-click `kit.json` there to edit it.
+- `%USERPROFILE%\AgentsHouse`: your workspace. Pass
+  `--workspace 'D:\Agents'` to use another directory. It is restricted to your
+  Windows account, and a path containing a comma is refused.
+
+## Notes
+
+- Append `kit` and a command to run it, as on [Linux](linux.md). Each run
+  leaves its exit status in `$LASTEXITCODE`.
+- A command whose output is redirected also writes its prompts and errors there.
+- A House on this computer needs host networking enabled in Docker Desktop's
+  settings.
+- This bootstrap has not yet been run on a real Windows computer.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.41",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -9,11 +9,16 @@
   "private": false,
   "type": "module",
   "bin": {
+    "house": "src/session-bin/house",
     "kit": "bin/kit.js"
   },
+  "exports": {
+    "./bootstrap": "./bootstrap.json"
+  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.5.0",
-    "@agentshouse/mdmodel": "0.1.0-alpha.13",
+    "@agentshouse/mdmodel": "0.1.0-alpha.15",
+    "ws": "8.22.0",
     "yaml": "2.9.1",
     "zod": "4.6.5"
   },

package/src/adapter-mcp.js

@@ -1,7 +1,15 @@
-import { COMMAND_ADAPTER_INITIALIZE_TIMEOUT_MS, MCP_PROTOCOL_VERSION } from "./contract.js";
-import { bridgeCall } from "./mcp.js";
+import { readFileSync } from "node:fs";
+import {
+  COMMAND_ADAPTER_INITIALIZE_TIMEOUT_MS,
+  HOW_WE_WORK_PATH,
+  MCP_PROTOCOL_VERSION,
+  SHELL_RENDER,
+} from "./contract.js";
+import { answerText, bridgeCall, editRefusal } from "./mcp.js";
 import { KitRefusal } from "./refusal.js";
 
+const HOW_WE_WORK_TEXT = readFileSync(new URL("how-we-work.md", import.meta.url), "utf8");
+
 function readableDiscovery(discovery) {
   const identity = discovery?._meta?.["io.modelcontextprotocol/serverInfo"];
   return Array.isArray(discovery?.supportedVersions) &&
@@ -30,15 +38,87 @@ export async function commandHouseInstructions(bridge) {
   return frame.result.instructions;
 }
 
-export async function commandHouseRequest(bridge) {
-  const frame = await commandHouseReply(bridge, { method: "tools/call", params: { name: "session_get_request", arguments: {} } });
-  if (frame.error !== undefined || frame.result?.isError === true) throw new KitRefusal("kit_run_input_unreadable");
-  try {
-    const content = frame.result.content;
-    const input = JSON.parse(content.find((item) => item.type === "text").text);
-    if (typeof input !== "object" || input === null || Array.isArray(input)) throw new Error();
-    return input;
-  } catch {
-    throw new KitRefusal("kit_run_input_unreadable");
+const CUT_NOTICE = "shell: output_cut ";
+const CONTINUATION = "; continue with: ";
+const BYTE_CONTINUATION = /\| tail -c \+[1-9][0-9]*$/u;
+
+function shellAnswer(text) {
+  const lines = text.split("\n");
+  if (!lines[0].startsWith(`protocol: render=${SHELL_RENDER} `)) return null;
+  const exit = Number(lines[2].slice("exit: ".length));
+  const truncation = lines[3].slice("truncation: ".length);
+  let at = lines[5]?.startsWith("authority: ") ? 6 : 5;
+  if (exit === 0 && truncation === "none") {
+    return { exit, truncation, stderr: [], stdout: lines.slice(at).join("\n"), continuation: null };
+  }
+  const stderr = [];
+  let continuation = null;
+  while (continuation === null && lines[at]?.startsWith("stderr: ")) {
+    const line = lines[at++].slice("stderr: ".length);
+    stderr.push(line);
+    const separator = line.indexOf(CONTINUATION);
+    if (line.startsWith(CUT_NOTICE) && separator !== -1) {
+      continuation = line.slice(separator + CONTINUATION.length);
+    }
+  }
+  return { exit, truncation, stderr, stdout: lines.slice(at).join("\n"), continuation };
+}
+
+async function howWeWorkReply(bridge, command, first) {
+  const frame = await bridgeCall(bridge, {
+    method: "tools/call",
+    params: { name: "shell", arguments: { command } },
+  });
+  if (frame.error !== undefined) {
+    throw new KitRefusal("kit_how_we_work_unreadable", frame.error.message ?? null);
+  }
+  const text = answerText(frame.result);
+  if (frame.result?.isError === true) {
+    if (first && text.split(":")[0] === "room_not_found") return null;
+    throw new KitRefusal("kit_how_we_work_unreadable", text);
+  }
+  const reply = shellAnswer(text);
+  if (reply === null) throw new KitRefusal("kit_how_we_work_unreadable", text);
+  if (reply.exit !== 0) {
+    if (first && reply.stderr.length === 1 && reply.stderr[0].split(" ")[1] === "path_not_found") return null;
+    throw new KitRefusal("kit_how_we_work_unreadable", reply.stderr.join("\n"));
+  }
+  if (reply.truncation !== "none" && reply.continuation === null) {
+    throw new KitRefusal("kit_how_we_work_unreadable", reply.stderr.join("\n"));
+  }
+  return reply;
+}
+
+export async function commandHouseHowWeWork(bridge) {
+  let document = "";
+  let command = `cat ${HOW_WE_WORK_PATH}`;
+  let first = true;
+  while (command !== null) {
+    const reply = await howWeWorkReply(bridge, command, first);
+    if (reply === null) return "";
+    document += reply.stdout;
+    command = reply.continuation;
+    if (command !== null && !BYTE_CONTINUATION.test(command)) document += "\n";
+    first = false;
+  }
+  return document;
+}
+
+export async function commandHouseCreateHowWeWork(bridge) {
+  const frame = await bridgeCall(bridge, {
+    method: "tools/call",
+    params: {
+      name: "edit",
+      arguments: { changes: [{ op: "create", path: HOW_WE_WORK_PATH, content: HOW_WE_WORK_TEXT }] },
+    },
+  });
+  if (frame.error !== undefined) {
+    throw new KitRefusal("kit_how_we_work_unwritable", frame.error.message ?? null);
   }
+  if (frame.result?.isError !== true) return true;
+  const text = answerText(frame.result);
+  const { code, conflicts } = editRefusal(text);
+  if (code === "room_not_found" || code === "operation_denied") return false;
+  if (code === "edit_conflict" && conflicts?.some((conflict) => conflict.code === "path_exists")) return true;
+  throw new KitRefusal("kit_how_we_work_unwritable", text);
 }

package/src/agents.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { readFile, rm } from "node:fs/promises";
+import { readFile, readdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
@@ -11,6 +11,7 @@ import {
 } from "./adapter.js";
 import { inheritedEnvironment } from "./command.js";
 import {
+  ADAPTER_KINDS,
   AGENT_HOME,
   AGENT_INSTALL_TIMEOUT_MS,
   AGENT_RELEASES_HOME,
@@ -261,6 +262,60 @@ export async function updateDeclaredAgents(options, configuration, dependencies
   return updated;
 }
 
+export async function removeUndeclaredAgents(directory, wanted, keep = false) {
+  const home = join(directory, AGENT_HOME);
+  let entries;
+  try {
+    entries = await readdir(home, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const retained = [];
+  for (const entry of entries) {
+    if (!wanted.includes(entry.name)) {
+      if (keep && ADAPTER_KINDS.includes(entry.name)) retained.push(entry.name);
+      else await rm(join(home, entry.name), { recursive: true, force: true });
+    }
+  }
+  return retained;
+}
+
+export async function reconcileAgentKinds(
+  options,
+  session,
+  configuration,
+  dependencies = {},
+  signal = session.signal,
+  state = {},
+) {
+  const selected = { ...configuration, agents: await desiredAgents(session, signal) };
+  state.onDesired?.(selected.agents);
+  const newlyWanted = selected.agents.filter((kind) => !state.lastDesired?.includes(kind));
+  const retained = await removeUndeclaredAgents(options.directory, selected.agents, state.busy);
+  const pointerKinds = state.busy
+    ? (
+        await Promise.all(
+          newlyWanted.map(async (kind) =>
+            (await readAgentState(options.directory, kind)).release === null ? kind : null,
+          ),
+        )
+      ).filter((kind) => kind !== null)
+    : newlyWanted;
+  const updated = await updateDeclaredAgents(
+    { directory: options.directory, at: dependencies.now?.(), forced: state.forced },
+    { ...selected, agents: state.pointer ? pointerKinds : selected.agents },
+    dependencies,
+  );
+  const readiness = await agentReadiness(
+    { directory: options.directory },
+    { ...selected, agents: [...selected.agents, ...retained] },
+    dependencies,
+  );
+  await reportAgentCapabilities(session, readiness.agents, signal);
+  return { selected, updated, reported: readiness.agents, refused: readiness.refused, retained };
+}
+
 export async function agentSignedIn(directory, kind, dependencies = {}) {
   const contract = compiledContract(kind);
   const state = await readAgentState(directory, kind);
@@ -341,15 +396,15 @@ export async function updateAgents(options, dependencies = {}) {
   return maintainControl(
     session,
     async (signal) => {
-      const selected = { ...configuration, agents: await desiredAgents(session, signal) };
-      const updated = await updateDeclaredAgents(
-        { directory: options.directory, at: dependencies.now?.(), forced: true },
-        selected,
+      const result = await reconcileAgentKinds(
+        options,
+        session,
+        configuration,
         dependencies,
+        signal,
+        { forced: true },
       );
-      const { agents } = await agentReadiness(options, selected, dependencies);
-      await reportAgentCapabilities(session, agents, signal);
-      return { updated, reported: agents };
+      return { updated: result.updated, reported: result.reported };
     },
     options.signal,
   );

package/src/binding.js

@@ -1,5 +1,6 @@
 import { readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
+import { finalPlan, planSnapshot } from "./plan.js";
 import { KitRefusal } from "./refusal.js";
 import { readNote, writeNote } from "./state.js";
 import { reportedNote, retainedReport } from "./terminal.js";
@@ -15,6 +16,18 @@ function bindingPath(directory, tmux) {
   return join(bindingDirectory(directory), `${tmux}.json`);
 }
 
+function stoppedNote(stopped) {
+  if (stopped === null || stopped === undefined) return null;
+  return {
+    turn_completed: stopped.turnCompleted,
+    capacity_exhausted: stopped.capacityExhausted,
+    provider_refused: stopped.providerRefused,
+    continuable: stopped.continuable,
+    failure: stopped.failure,
+    text_accepted: stopped.textAccepted,
+  };
+}
+
 export async function writeBinding(directory, binding) {
   const reported = binding.reported ?? null;
   await writeNote(bindingPath(directory, binding.tmux), {
@@ -29,7 +42,9 @@ export async function writeBinding(directory, binding) {
     sealed: binding.sealed === null || binding.sealed === undefined
       ? null
       : { operation: binding.sealed.operation, blocks: binding.sealed.blocks },
+    stopped: stoppedNote(binding.stopped),
     reported: reported === null ? null : reportedNote(reported),
+    plan: binding.plan ?? null,
   });
 }
 
@@ -45,6 +60,37 @@ function retainedSeal(stored) {
   return { operation: stored.operation, blocks: stored.blocks };
 }
 
+function retainedPlan(stored) {
+  if (stored === null || stored === undefined) return null;
+  const plan = finalPlan(planSnapshot(stored));
+  return plan === null || JSON.stringify(plan) !== JSON.stringify(stored) ? undefined : plan;
+}
+
+function retainedFailure(stored) {
+  if (stored === null) return null;
+  if (typeof stored !== "object" || Array.isArray(stored)) return undefined;
+  if (typeof stored.code !== "string" || stored.code.length === 0) return undefined;
+  if (stored.detail !== null && typeof stored.detail !== "string") return undefined;
+  return { code: stored.code, detail: stored.detail };
+}
+
+function retainedStop(stored) {
+  if (stored === null || stored === undefined) return null;
+  if (typeof stored !== "object" || Array.isArray(stored)) return undefined;
+  const flags = ["turn_completed", "capacity_exhausted", "provider_refused", "continuable", "text_accepted"];
+  if (flags.some((flag) => typeof stored[flag] !== "boolean")) return undefined;
+  const failure = retainedFailure(stored.failure);
+  if (failure === undefined) return undefined;
+  return {
+    turnCompleted: stored.turn_completed,
+    capacityExhausted: stored.capacity_exhausted,
+    providerRefused: stored.provider_refused,
+    continuable: stored.continuable,
+    failure,
+    textAccepted: stored.text_accepted,
+  };
+}
+
 function completeBinding(directory, stored) {
   if (typeof stored !== "object" || stored === null || Array.isArray(stored)) return null;
   const named = [stored.run, stored.session, stored.tmux, stored.socket, stored.nonce];
@@ -54,8 +100,12 @@ function completeBinding(directory, stored) {
   if (stored.owner_stop !== null && typeof stored.owner_stop !== "string") return null;
   const sealed = retainedSeal(stored.sealed);
   if (sealed === undefined) return null;
+  const stopped = retainedStop(stored.stopped);
+  if (stopped === undefined) return null;
   const reported = retainedReport(stored.reported);
   if (reported === undefined) return null;
+  const plan = retainedPlan(stored.plan);
+  if (plan === undefined) return null;
   return {
     run: stored.run,
     session: stored.session,
@@ -65,7 +115,9 @@ function completeBinding(directory, stored) {
     conversation: stored.conversation === true,
     ownerStop: stored.owner_stop,
     sealed,
+    stopped,
     reported,
+    plan,
   };
 }