clankerbend 0.1.0 → 0.1.1

package/docs/protocol.md

@@ -1,17 +1,17 @@
-# OneWhack Protocol
+# ClankerBend Protocol
 
 Status: draft
 
-Disclaimer: OneWhack is an independent OneWill project compatible with OpenAI
+Disclaimer: ClankerBend is an independent OneWill project compatible with OpenAI
 Codex Desktop. It is not affiliated with or endorsed by OpenAI.
 
-OneWhack Protocol, short for the OneWill Extension Hacks protocol, is a
+ClankerBend Protocol, short for the OneWill ClankerBend protocol, is a
 standalone local protocol for building companion apps around Codex Desktop
-without requiring changes to Codex Desktop itself. OneWhack separates a shared
+without requiring changes to Codex Desktop itself. ClankerBend separates a shared
 local host from individual apps: the host owns the risky integration work, and
 apps consume stable transcript, annotation, navigation, and state primitives.
 
-OneWhack codifies the hack paths available today:
+ClankerBend codifies the hack paths available today:
 
 - a local host process bound to loopback
 - a browser side panel loaded from that local host
@@ -20,8 +20,8 @@ OneWhack codifies the hack paths available today:
 - `codex app-server` awareness for thread, turn, item, approval, and rollback
   data
 
-OneWhack is not a proposal for a privileged built-in Codex plugin API. If Codex later
-adds such an API, it should be able to replace the adapters underneath OneWhack, but
+ClankerBend is not a proposal for a privileged built-in Codex plugin API. If Codex later
+adds such an API, it should be able to replace the adapters underneath ClankerBend, but
 the protocol here is designed to work now with external tools.
 
 ## Normative Language
@@ -32,7 +32,7 @@ non-normative unless explicitly marked otherwise.
 
 ## Goals
 
-OneWhack should give any local app a small set of reusable primitives:
+ClankerBend should give any local app a small set of reusable primitives:
 
 1. **View**: start a local browser UI and place it in Codex Desktop's existing
    side panel.
@@ -55,32 +55,32 @@ OneWhack should give any local app a small set of reusable primitives:
 
 ## Scope
 
-OneWhack `0.1` is transcript-adjacent. It covers side panels that observe, annotate,
+ClankerBend `0.1` is transcript-adjacent. It covers side panels that observe, annotate,
 navigate, and correlate Codex Desktop transcript content. Other Desktop
 surfaces such as terminal panes, file trees, browser previews, command palette
 commands, notifications, and settings are out of scope for this version.
 
 ## Non-Goals
 
-- OneWhack does not require Codex Desktop changes.
-- OneWhack does not replace `codex app-server`.
-- OneWhack does not define a security boundary.
-- OneWhack does not grant host filesystem, shell, network, or approval authority.
-- OneWhack does not assume exact item-to-DOM mapping is always possible.
+- ClankerBend does not require Codex Desktop changes.
+- ClankerBend does not replace `codex app-server`.
+- ClankerBend does not define a security boundary.
+- ClankerBend does not grant host filesystem, shell, network, or approval authority.
+- ClankerBend does not assume exact item-to-DOM mapping is always possible.
 
 ## Architecture
 
-OneWhack describes a shared local host that can mount multiple apps.
+ClankerBend describes a shared local host that can mount multiple apps.
 
 ```text
-OneWhack app panel(s) <-> OneWhack host <-> Codex Desktop adapter <-> renderer bridge
+ClankerBend app panel(s) <-> ClankerBend host <-> Codex Desktop adapter <-> renderer bridge
                                     \
                                      -> app-server adapter
 ```
 
-### OneWhack Host
+### ClankerBend Host
 
-The OneWhack host is the trusted local process for a session. It owns the
+The ClankerBend host is the trusted local process for a session. It owns the
 loopback HTTP/SSE server, app registry, app state fanout, Desktop CDP adapter,
 renderer bridge injection, app-server adapter, lifecycle cleanup, and policy
 checks. Apps do not talk directly to CDP or app-server unless the host grants a
@@ -91,9 +91,9 @@ Vim-style transcript navigation, diagnostics, bookmarks, or review tools. Apps
 share transcript anchors, selection, app-server correlation, and side-panel
 placement through the host.
 
-### OneWhack App
+### ClankerBend App
 
-A OneWhack app is a UI and state contributor mounted by the host. It may provide
+A ClankerBend app is a UI and state contributor mounted by the host. It may provide
 a side-panel route, annotations, commands, app state entries, and action
 handlers. An app is identified by a stable `appId` and described by a manifest.
 
@@ -106,7 +106,7 @@ a future built-in plugin API, or a mock adapter.
 The Codex Desktop adapter is the implementation-specific component that launches
 or attaches to Codex Desktop with a loopback CDP port and evaluates the injected
 renderer bridge. This adapter is not the protocol. It is the current way the
-OneWhack host realizes the protocol without Codex Desktop changes.
+ClankerBend host realizes the protocol without Codex Desktop changes.
 
 ### Injected Renderer Bridge
 
@@ -119,12 +119,12 @@ single app.
 
 Connection to `codex app-server --stdio` or another app-server transport when
 available. It is used for task identity and lifecycle data, not for Desktop UI
-control. A OneWhack host may still run when app-server is unavailable, but it
+control. A ClankerBend host may still run when app-server is unavailable, but it
 must report that state explicitly.
 
 ## Transport
 
-OneWhack uses ordinary local web primitives:
+ClankerBend uses ordinary local web primitives:
 
 - HTTP JSON endpoints for commands
 - Server-Sent Events for state updates
@@ -147,7 +147,7 @@ explicitly defined as SSE. JSON endpoints must use `application/json`.
 Successful JSON responses use this envelope:
 
 ```ts
-type OneWhackResponse<T> = {
+type ClankerBendResponse<T> = {
   ok: true;
   data: T;
 };
@@ -156,7 +156,7 @@ type OneWhackResponse<T> = {
 Failed JSON responses use this envelope:
 
 ```ts
-type OneWhackError = {
+type ClankerBendError = {
   ok: false;
   error: {
     code:
@@ -199,9 +199,9 @@ app or adapter:
 
 1. Request bodies must parse as JSON objects. Arrays, strings, numbers, and
    invalid JSON return `400` with code `bad_request`.
-2. Hosts should reject bodies larger than 1 MiB for OneWhack `0.1` JSON
+2. Hosts should reject bodies larger than 1 MiB for ClankerBend `0.1` JSON
    endpoints.
-3. `POST /onewhack/apps/:appId/actions` requires an `action` object with
+3. `POST /clankerbend/apps/:appId/actions` requires an `action` object with
    non-empty string `appId`, `actionId`, and `type` fields.
 4. `action.appId` must match the route `:appId`. A mismatch returns `400` with
    code `bad_request`.
@@ -215,7 +215,7 @@ additional validation for app-specific payloads.
 
 ### Session Token
 
-A production OneWhack host must protect JSON and SSE endpoints with an
+A production ClankerBend host must protect JSON and SSE endpoints with an
 unguessable session token. The token is passed as:
 
 ```text
@@ -236,10 +236,10 @@ An app must not bypass the host token by calling CDP or app-server directly.
 
 ### Bootstrap
 
-OneWhack `0.1` defines two token bootstrap paths:
+ClankerBend `0.1` defines two token bootstrap paths:
 
 1. **Hosted panel apps**: the host serves the app entry URL and may append the
-   token in the URL fragment as `#onewhack_token=<token>`. App JavaScript reads
+   token in the URL fragment as `#clankerbend_token=<token>`. App JavaScript reads
    the fragment, stores the token in memory, immediately removes the fragment
    with `history.replaceState`, and sends the token in the `Authorization`
    header for JSON and SSE requests.
@@ -256,23 +256,23 @@ support the bearer-token header.
 The host maintains one public state object and streams snapshots to the panel.
 
 ```ts
-type OneWhackPublicState = {
-  protocolName: "onewhack";
+type ClankerBendPublicState = {
+  protocolName: "clankerbend";
   protocolVersion: "0.1";
   sequence: number;
   generatedAt: string;
-  capabilities: OneWhackCapabilities;
+  capabilities: ClankerBendCapabilities;
   host: HostStatus;
   desktop: DesktopStatus;
   panel: PanelStatus;
   transcript: TranscriptState;
-  selection: OneWhackSelection | null;
-  selectionActions?: OneWhackSelectionAction[];
-  overlay?: OneWhackOverlay | null;
-  composer?: OneWhackComposerState;
-  apps: OneWhackAppState[];
+  selection: ClankerBendSelection | null;
+  selectionActions?: ClankerBendSelectionAction[];
+  overlay?: ClankerBendOverlay | null;
+  composer?: ClankerBendComposerState;
+  apps: ClankerBendAppState[];
   appServer: AppServerStatus;
-  lastAction?: OneWhackActionResult;
+  lastAction?: ClankerBendActionResult;
 };
 ```
 
@@ -312,15 +312,15 @@ type TranscriptScrollState = {
 The state object is intentionally denormalized so the panel can render from a
 single event payload.
 
-### `GET /onewhack/state`
+### `GET /clankerbend/state`
 
 Returns the latest public state.
 
 ```ts
-type GetStateResponse = OneWhackResponse<OneWhackPublicState>;
+type GetStateResponse = ClankerBendResponse<ClankerBendPublicState>;
 ```
 
-### `GET /onewhack/events`
+### `GET /clankerbend/events`
 
 Streams host events as SSE. The host must send a full state snapshot
 immediately after a client connects.
@@ -328,19 +328,19 @@ immediately after a client connects.
 ```text
 event: state
 id: 42
-data: {"protocolName":"onewhack","protocolVersion":"0.1","sequence":42,...}
+data: {"protocolName":"clankerbend","protocolVersion":"0.1","sequence":42,...}
 ```
 
 SSE rules:
 
-1. `id` is the decimal string form of `OneWhackPublicState.sequence`.
-2. `state` events contain a complete `OneWhackPublicState`.
-3. `app-state` events may contain one `OneWhackAppState`; clients must still be
+1. `id` is the decimal string form of `ClankerBendPublicState.sequence`.
+2. `state` events contain a complete `ClankerBendPublicState`.
+3. `app-state` events may contain one `ClankerBendAppState`; clients must still be
    able to recover from `state`.
-4. `action` events contain `OneWhackActionResult`.
+4. `action` events contain `ClankerBendActionResult`.
 5. `heartbeat` events have empty JSON object data and should be sent at least
    every 15 seconds.
-6. `error` events contain `OneWhackError["error"]`.
+6. `error` events contain `ClankerBendError["error"]`.
 7. Hosts should avoid emitting `state` when nothing semantically changed.
 8. Clients may reconnect with `Last-Event-ID`; hosts may replay missed events
    but must send a fresh `state` event even if replay is unavailable.
@@ -353,7 +353,7 @@ The host exposes negotiated capabilities in every state snapshot so apps can
 degrade cleanly.
 
 ```ts
-type OneWhackCapabilities = {
+type ClankerBendCapabilities = {
   protocolVersion: "0.1";
   host: {
     apps: boolean;
@@ -409,11 +409,11 @@ transcript operation until a future protocol version adds dynamic arbitration.
 
 ### Forward Compatibility
 
-OneWhack clients must treat minor-version protocol changes as additive.
+ClankerBend clients must treat minor-version protocol changes as additive.
 Unknown object fields, unknown capability keys, unknown app state entry fields,
 and unknown action result data must be ignored by default. Apps must gate
-optional behavior on the capabilities they read from `GET /onewhack/manifest`
-or `GET /onewhack/state`; they must not infer availability from the host name,
+optional behavior on the capabilities they read from `GET /clankerbend/manifest`
+or `GET /clankerbend/state`; they must not infer availability from the host name,
 adapter name, or Codex Desktop version alone.
 
 Hosts must keep the `ok` envelope, error envelope, endpoint names, and required
@@ -442,27 +442,27 @@ lowercase reverse-DNS-style names such as `onewill.vim-nav`.
 Apps must read host capabilities before assuming any optional feature exists.
 
 ```text
-GET /onewhack/manifest
-GET /onewhack/state
-GET /onewhack/events
+GET /clankerbend/manifest
+GET /clankerbend/state
+GET /clankerbend/events
 ```
 
-`GET /onewhack/manifest` returns host identity, protocol version, and mounted
+`GET /clankerbend/manifest` returns host identity, protocol version, and mounted
 app manifests.
 
 ```ts
-type GetManifestResponse = OneWhackResponse<OneWhackHostManifest>;
+type GetManifestResponse = ClankerBendResponse<ClankerBendHostManifest>;
 
-type OneWhackHostManifest = {
-  oneWhackVersion: "0.1";
+type ClankerBendHostManifest = {
+  clankerbendVersion: "0.1";
   hostId: string;
   hostName: string;
-  capabilities: OneWhackCapabilities;
+  capabilities: ClankerBendCapabilities;
   security?: {
     auth: "bearer" | "none";
     localDevInsecure?: boolean;
   };
-  apps: OneWhackAppManifest[];
+  apps: ClankerBendAppManifest[];
 };
 ```
 
@@ -474,32 +474,32 @@ render a degraded state rather than attempting direct CDP or app-server access.
 The host exposes mounted apps through a registry.
 
 ```text
-GET  /onewhack/apps
-GET  /onewhack/apps/:appId/manifest
-GET  /onewhack/apps/:appId/state
-GET  /onewhack/apps/:appId/actions/:actionId
-POST /onewhack/apps/:appId/actions
+GET  /clankerbend/apps
+GET  /clankerbend/apps/:appId/manifest
+GET  /clankerbend/apps/:appId/state
+GET  /clankerbend/apps/:appId/actions/:actionId
+POST /clankerbend/apps/:appId/actions
 ```
 
 The registry lets one host serve multiple apps without each app owning a
 separate CDP adapter or injected bridge.
 
 ```ts
-type GetAppsResponse = OneWhackResponse<{
-  apps: OneWhackAppSummary[];
+type GetAppsResponse = ClankerBendResponse<{
+  apps: ClankerBendAppSummary[];
 }>;
 
-type OneWhackAppSummary = {
+type ClankerBendAppSummary = {
   appId: string;
   name: string;
-  status: OneWhackAppStatus;
+  status: ClankerBendAppStatus;
   entry?: string;
 };
 
-type GetAppManifestResponse = OneWhackResponse<OneWhackAppManifest>;
-type GetAppStateResponse = OneWhackResponse<OneWhackAppState>;
+type GetAppManifestResponse = ClankerBendResponse<ClankerBendAppManifest>;
+type GetAppStateResponse = ClankerBendResponse<ClankerBendAppState>;
 
-type OneWhackAppStatus =
+type ClankerBendAppStatus =
   | "mounted"
   | "loading"
   | "ready"
@@ -507,15 +507,15 @@ type OneWhackAppStatus =
   | "disabled"
   | "error";
 
-type OneWhackAppManifest = {
-  oneWhackVersion: "0.1";
+type ClankerBendAppManifest = {
+  clankerbendVersion: "0.1";
   appId: string;
   version: string;
   name: string;
   description?: string;
   entry: string;
-  distribution?: OneWhackAppDistribution;
-  entrypoint?: OneWhackAppEntrypoint;
+  distribution?: ClankerBendAppDistribution;
+  entrypoint?: ClankerBendAppEntrypoint;
   capabilities?: {
     panel?: boolean;
     annotations?: boolean;
@@ -554,11 +554,11 @@ type OneWhackAppManifest = {
     reloadPolicy: "preserve" | "reload";
     preferredWidth?: number;
   };
-  rendererBridge?: OneWhackRendererBridgeManifest;
-  lifecycle?: OneWhackAppLifecycleManifest;
+  rendererBridge?: ClankerBendRendererBridgeManifest;
+  lifecycle?: ClankerBendAppLifecycleManifest;
 };
 
-type OneWhackAppDistribution = {
+type ClankerBendAppDistribution = {
   kind: "local" | "npm" | "tarball" | "binary";
   source?: string;
   integrity?: string;
@@ -569,7 +569,7 @@ type OneWhackAppDistribution = {
   };
 };
 
-type OneWhackAppEntrypoint = {
+type ClankerBendAppEntrypoint = {
   kind: "module" | "binary" | "static";
   module?: string;
   factory?: string;
@@ -578,7 +578,7 @@ type OneWhackAppEntrypoint = {
   publicDir?: string;
 };
 
-type OneWhackRendererBridgeManifest = {
+type ClankerBendRendererBridgeManifest = {
   script: string;
   primary?: boolean;
   provides?: (
@@ -597,7 +597,7 @@ type OneWhackRendererBridgeManifest = {
   };
 };
 
-type OneWhackAppLifecycleManifest = {
+type ClankerBendAppLifecycleManifest = {
   install?: { kind: string };
   start?: { kind: string };
   stop?: { kind: string };
@@ -613,14 +613,14 @@ approval rules.
 
 ```ts
 type PostAppActionRequest = {
-  action: OneWhackAction;
+  action: ClankerBendAction;
 };
 
-type PostAppActionResponse = OneWhackResponse<
-  OneWhackActionResult | OneWhackActionReceipt
+type PostAppActionResponse = ClankerBendResponse<
+  ClankerBendActionResult | ClankerBendActionReceipt
 >;
 
-type OneWhackAction = {
+type ClankerBendAction = {
   actionId: string;
   appId: string;
   type: string;
@@ -631,7 +631,7 @@ type OneWhackAction = {
   requestedAt: string;
 };
 
-type OneWhackActionReceipt = {
+type ClankerBendActionReceipt = {
   actionId: string;
   appId: string;
   accepted: true;
@@ -639,7 +639,7 @@ type OneWhackActionReceipt = {
   resultUrl?: string;
 };
 
-type OneWhackActionResult = {
+type ClankerBendActionResult = {
   actionId: string;
   appId: string;
   ok: boolean;
@@ -663,7 +663,7 @@ Action rules:
 7. Unavailable adapters must return `503` with code `adapter_unavailable` or
    `capability_unavailable`.
 8. When `resultUrl` is present, it must point to
-   `/onewhack/apps/:appId/actions/:actionId`.
+   `/clankerbend/apps/:appId/actions/:actionId`.
 9. App handlers must return an action result with boolean `ok`. Invalid handler
    returns must fail with `500` and code `action_failed`.
 
@@ -676,12 +676,12 @@ this document, but they must follow the same action contract.
 Hosts must retain completed action results for at least 60 seconds.
 
 ```text
-GET /onewhack/apps/:appId/actions/:actionId
+GET /clankerbend/apps/:appId/actions/:actionId
 ```
 
 ```ts
-type GetAppActionResponse = OneWhackResponse<
-  OneWhackActionResult | OneWhackActionReceipt
+type GetAppActionResponse = ClankerBendResponse<
+  ClankerBendActionResult | ClankerBendActionReceipt
 >;
 ```
 
@@ -689,24 +689,24 @@ This endpoint lets clients recover when they miss an SSE `action` event.
 
 ### App Lifecycle
 
-OneWhack `0.1` defines manifest-based app registration. A host may install apps
+ClankerBend `0.1` defines manifest-based app registration. A host may install apps
 from local manifests, npm packages, tarballs, or binary-style bundles. Download
 and update transports are implementation details, but every installed app must
-resolve to a validated `OneWhackAppManifest`.
+resolve to a validated `ClankerBendAppManifest`.
 
 The public launcher command is intentionally small:
 
 ```text
-clankerbend codex
+clankerbend
 ```
 
 App installation, enablement, update, and removal are product configuration
-concerns owned by the running OneWhack experience. The registry model remains
+concerns owned by the running ClankerBend experience. The registry model remains
 part of the host protocol, but apps should not depend on a public app-management
 CLI being present.
 
 Regardless of loading mechanism, a mounted app must appear in
-`GET /onewhack/apps`.
+`GET /clankerbend/apps`.
 
 Lifecycle rules:
 
@@ -728,7 +728,7 @@ Lifecycle rules:
 
 ### Panel Model
 
-OneWhack `0.1` assumes one Codex Desktop side panel controlled by the host. The
+ClankerBend `0.1` assumes one Codex Desktop side panel controlled by the host. The
 host may implement that side panel as:
 
 - a shared shell that routes between mounted apps, or
@@ -737,9 +737,9 @@ host may implement that side panel as:
 In either model:
 
 1. `PanelStatus.activeAppId` identifies the app currently shown when known.
-2. `POST /onewhack/panel/open` opens or focuses the host panel and may switch
+2. `POST /clankerbend/panel/open` opens or focuses the host panel and may switch
    the active panel app by `appId`.
-3. `POST /onewhack/apps/:appId/actions` may switch the active app when the
+3. `POST /clankerbend/apps/:appId/actions` may switch the active app when the
    action requires app UI.
 4. Opening an already-loaded panel must not reload the page unless the app
    manifest uses `reloadPolicy: "reload"`.
@@ -749,13 +749,13 @@ In either model:
 
 ### Launch
 
-OneWhack can launch Codex Desktop with CDP:
+ClankerBend can launch Codex Desktop with CDP:
 
 ```sh
 /Applications/Codex.app/Contents/MacOS/Codex \
   --remote-debugging-address=127.0.0.1 \
   --remote-debugging-port=<free> \
-  --user-data-dir=<test-or-onewhack-profile>
+  --user-data-dir=<test-or-clankerbend-profile>
 ```
 
 The host must not patch `/Applications/Codex.app`.
@@ -787,14 +787,14 @@ type DesktopStatus = {
 The CDP adapter initializes a single renderer runtime at:
 
 ```ts
-window.__oneWhackRuntime
+window.__clankerbendRuntime
 ```
 
 Apps register into runtime-owned app slots. The runtime is the only privileged
 renderer global; individual apps must not require their own global bridge names.
 
 ```ts
-type OneWhackRendererRuntime = {
+type ClankerBendRendererRuntime = {
   protocolVersion: string;
   hostUrl: string;
   apps: Record<string, RendererAppSlot>;
@@ -874,7 +874,7 @@ type RendererSnapshot = {
   anchors: TranscriptAnchor[];
   visibleCount: number;
   annotationCount: number;
-  selection: OneWhackSelection | null;
+  selection: ClankerBendSelection | null;
 };
 ```
 
@@ -919,11 +919,11 @@ app-server identity.
 
 ### Identity Tiers
 
-OneWhack uses separate identity tiers because exact app-server-to-DOM mapping is
+ClankerBend uses separate identity tiers because exact app-server-to-DOM mapping is
 not always available.
 
 ```ts
-type OneWhackIdentity = {
+type ClankerBendIdentity = {
   anchorId?: string;
   entryId?: string;
   markerId?: string;
@@ -1054,7 +1054,7 @@ Annotation ownership rules:
 3. Lower `priority` values render earlier; omitted priority defaults to `100`.
    Ties sort by `appId`, then `markerId`, both lexicographically.
 4. Marker clicks route to the contributing app through
-   `POST /onewhack/apps/:appId/actions`.
+   `POST /clankerbend/apps/:appId/actions`.
 5. The renderer bridge must remove stale markers for an app without removing
    markers owned by other apps.
 6. Marker identity is scoped by `(appId, markerId)`. Two apps may use the same
@@ -1069,10 +1069,10 @@ Annotation ownership rules:
 
 The panel talks only to the host server. It does not need direct CDP access.
 
-### `POST /onewhack/panel/open`
+### `POST /clankerbend/panel/open`
 
 Asks the host to open/focus the panel in Codex Desktop. The host calls
-`window.__oneWhackRuntime.getBridge(activeAppId).openPanel()` or an equivalent
+`window.__clankerbendRuntime.getBridge(activeAppId).openPanel()` or an equivalent
 app-id-scoped bridge call via CDP.
 
 ```ts
@@ -1085,10 +1085,10 @@ When `appId` is provided, the host must set `PanelStatus.activeAppId` to that
 registered app before loading the panel URL. Unknown app ids return `404`.
 
 ```ts
-type OpenPanelResponse = OneWhackResponse<PanelOpenResult>;
+type OpenPanelResponse = ClankerBendResponse<PanelOpenResult>;
 ```
 
-### `POST /onewhack/transcript/scroll`
+### `POST /clankerbend/transcript/scroll`
 
 ```json
 {
@@ -1105,10 +1105,10 @@ type ScrollToAnchorRequest = {
   block?: "start" | "center" | "end" | "nearest";
 };
 
-type ScrollToAnchorResponse = OneWhackResponse<ScrollResult>;
+type ScrollToAnchorResponse = ClankerBendResponse<ScrollResult>;
 ```
 
-### `POST /onewhack/transcript/highlight`
+### `POST /clankerbend/transcript/highlight`
 
 ```json
 {
@@ -1123,10 +1123,10 @@ type HighlightAnchorRequest = {
   durationMs?: number;
 };
 
-type HighlightAnchorResponse = OneWhackResponse<HighlightResult>;
+type HighlightAnchorResponse = ClankerBendResponse<HighlightResult>;
 ```
 
-### `POST /onewhack/selection`
+### `POST /clankerbend/selection`
 
 Updates global host selection.
 
@@ -1145,11 +1145,11 @@ Updates global host selection.
 
 ```ts
 type PostSelectionRequest = {
-  selection: OneWhackSelection;
+  selection: ClankerBendSelection;
 };
 
-type PostSelectionResponse = OneWhackResponse<{
-  selection: OneWhackSelection;
+type PostSelectionResponse = ClankerBendResponse<{
+  selection: ClankerBendSelection;
   stale?: boolean;
 }>;
 ```
@@ -1160,14 +1160,14 @@ is older than the current accepted selection. If two selections have the same
 assign a monotonically increasing `sequence` and `acceptedAt` timestamp.
 
 ```ts
-type OneWhackSelection = {
+type ClankerBendSelection = {
   selectionId: string;
   sequence?: number;
   source: "panel" | "transcript" | "adapter";
   appId?: string;
   anchorId?: string;
   quote?: string;
-  range?: OneWhackTextRange;
+  range?: ClankerBendTextRange;
   markerId?: string;
   entryId?: string;
   appServer?: {
@@ -1188,10 +1188,10 @@ older transcript click after the user selected a newer side-panel entry.
 
 Apps must not inspect Codex Desktop DOM to interpret selected text. When the
 adapter observes a transcript text selection, it normalizes that selection into
-a `OneWhackTextRange` and updates host `selection`.
+a `ClankerBendTextRange` and updates host `selection`.
 
 ```ts
-type OneWhackTextRange = {
+type ClankerBendTextRange = {
   anchorId: string;
   text: string;
   quote?: string;
@@ -1208,12 +1208,12 @@ Apps may store them for later source matching, but they must treat `anchorId`
 plus selected `text` as the only required fields.
 
 ```text
-POST /onewhack/transcript/highlight-range
+POST /clankerbend/transcript/highlight-range
 ```
 
 ```ts
 type PostHighlightRangeRequest = {
-  range: OneWhackTextRange;
+  range: ClankerBendTextRange;
   durationMs?: number;
   behavior?: "auto" | "smooth";
   block?: "start" | "center" | "end" | "nearest";
@@ -1229,7 +1229,7 @@ Apps can contribute actions for host-rendered transcript selection menus through
 app state. The host or renderer runtime owns menu placement and click routing.
 
 ```ts
-type OneWhackSelectionAction = {
+type ClankerBendSelectionAction = {
   actionId: string;
   appId: string;
   type: string;
@@ -1242,7 +1242,7 @@ type OneWhackSelectionAction = {
 ```
 
 When the user chooses a selection action, the host sends a normal
-`POST /onewhack/apps/:appId/actions` request with the current selection in the
+`POST /clankerbend/apps/:appId/actions` request with the current selection in the
 action payload or app context.
 
 ### Anchored Overlays
@@ -1251,31 +1251,31 @@ Apps can request a host-rendered overlay anchored to an anchor or text range.
 Apps provide fields and actions; the host/adapter owns DOM placement.
 
 ```text
-POST /onewhack/overlay/open
-POST /onewhack/overlay/close
+POST /clankerbend/overlay/open
+POST /clankerbend/overlay/close
 ```
 
 ```ts
-type OneWhackOverlay = {
+type ClankerBendOverlay = {
   overlayId: string;
   appId: string;
   kind: "form" | "menu" | "notice";
   title?: string;
   anchorId?: string;
-  range?: OneWhackTextRange;
-  fields?: OneWhackOverlayField[];
-  actions?: OneWhackOverlayAction[];
+  range?: ClankerBendTextRange;
+  fields?: ClankerBendOverlayField[];
+  actions?: ClankerBendOverlayAction[];
   openedAt?: string;
 };
 
-type OneWhackOverlayField = {
+type ClankerBendOverlayField = {
   fieldId: string;
   kind: "text" | "textarea" | "hidden";
   label?: string;
   value?: string;
 };
 
-type OneWhackOverlayAction = {
+type ClankerBendOverlayAction = {
   label: string;
   type: string;
   payload?: unknown;
@@ -1289,8 +1289,8 @@ host. Apps add/remove items and ask the host to serialize them into a draft; the
 adapter owns Codex composer DOM details.
 
 ```ts
-type OneWhackComposerState = {
-  contextItems: OneWhackComposerContextItem[];
+type ClankerBendComposerState = {
+  contextItems: ClankerBendComposerContextItem[];
   draft: {
     text: string;
     mode: "replace" | "append" | "prepend";
@@ -1300,13 +1300,13 @@ type OneWhackComposerState = {
   lastSubmittedAt?: string;
 };
 
-type OneWhackComposerContextItem = {
+type ClankerBendComposerContextItem = {
   itemId: string;
   appId: string;
   label: string;
   body: string;
   anchorId?: string;
-  range?: OneWhackTextRange;
+  range?: ClankerBendTextRange;
   status: "queued" | "sent" | "resolved";
   createdAt?: string;
   updatedAt?: string;
@@ -1314,10 +1314,10 @@ type OneWhackComposerContextItem = {
 ```
 
 ```text
-POST /onewhack/composer/context
-POST /onewhack/composer/context/remove
-POST /onewhack/composer/draft
-POST /onewhack/composer/submit
+POST /clankerbend/composer/context
+POST /clankerbend/composer/context/remove
+POST /clankerbend/composer/draft
+POST /clankerbend/composer/submit
 ```
 
 `/composer/draft` accepts `{ text, mode, contextItemIds }`. `/composer/submit`
@@ -1333,9 +1333,9 @@ The bridge records events in renderer globals:
 
 ```ts
 type RendererEventBuffer = {
-  selection?: OneWhackSelection;
+  selection?: ClankerBendSelection;
   panelOpen?: PanelOpenResult & { at: string };
-  hostEvents?: OneWhackRendererHostEvent[];
+  hostEvents?: ClankerBendRendererHostEvent[];
 };
 ```
 
@@ -1345,10 +1345,10 @@ chips, the renderer queues typed host events. The CDP adapter drains those
 events and invokes the same host APIs that app panels use.
 
 ```ts
-type OneWhackRendererHostEvent =
+type ClankerBendRendererHostEvent =
   | {
       kind: "selection";
-      selection: OneWhackSelection;
+      selection: ClankerBendSelection;
     }
   | {
       kind: "appAction";
@@ -1367,7 +1367,7 @@ type OneWhackRendererHostEvent =
     }
   | {
       kind: "highlightRange";
-      range: OneWhackTextRange;
+      range: ClankerBendTextRange;
     }
   | {
       kind: "highlightAnchor";
@@ -1380,25 +1380,25 @@ host HTTP endpoints directly as an optimization.
 
 ## App State
 
-OneWhack does not prescribe an app state provider. App state can come from
+ClankerBend does not prescribe an app state provider. App state can come from
 app-server, a local audit system, an MCP server, a test runner, a diagnostics
 collector, a bookmark store, an editor-navigation model, or simple DOM
 inference.
 
 ```ts
-type OneWhackAppState = {
+type ClankerBendAppState = {
   appId: string;
-  status: OneWhackAppStatus;
+  status: ClankerBendAppStatus;
   source: string;
   connected: boolean;
-  entries: OneWhackAppEntry[];
+  entries: ClankerBendAppEntry[];
   annotations?: AnchorAnnotation[];
-  commands?: OneWhackCommand[];
-  selectionActions?: OneWhackSelectionAction[];
+  commands?: ClankerBendCommand[];
+  selectionActions?: ClankerBendSelectionAction[];
   updatedAt?: string;
 };
 
-type OneWhackAppEntry = {
+type ClankerBendAppEntry = {
   entryId: string;
   appId: string;
   anchorId?: string;
@@ -1418,7 +1418,7 @@ type OneWhackAppEntry = {
   occurredAt?: string;
 };
 
-type OneWhackCommand = {
+type ClankerBendCommand = {
   commandId: string;
   appId: string;
   label: string;
@@ -1429,13 +1429,13 @@ type OneWhackCommand = {
 };
 ```
 
-Panel UIs should render `OneWhackAppEntry[]` without knowing the provider. A
+Panel UIs should render `ClankerBendAppEntry[]` without knowing the provider. A
 timeline, review list, trace viewer, bookmark list, or diagnostics stream can
 all be represented as entries bound optionally to transcript anchors.
 
 ## App-Server Adapter
 
-The app-server adapter is separate from Desktop control. OneWhack hosts are
+The app-server adapter is separate from Desktop control. ClankerBend hosts are
 app-server-aware and report app-server status even when they cannot connect.
 
 Useful app-server methods include:
@@ -1450,7 +1450,7 @@ Useful app-server methods include:
 - approval request/response methods
 - `thread/rollback`
 
-OneWhack should expose app-server data as correlation metadata, not as a replacement
+ClankerBend should expose app-server data as correlation metadata, not as a replacement
 transport.
 
 ```ts
@@ -1463,39 +1463,39 @@ type AppServerStatus = {
 ```
 
 If an app sends approval responses through app-server, that path must be
-explicit and user-driven. OneWhack must not auto-approve or auto-deny actions.
+explicit and user-driven. ClankerBend must not auto-approve or auto-deny actions.
 
 ## Minimal Endpoint Set
 
-A OneWhack host must implement these endpoints:
+A ClankerBend host must implement these endpoints:
 
 ```text
-GET  /onewhack/manifest
-GET  /onewhack/state
-GET  /onewhack/events
-GET  /onewhack/apps
-GET  /onewhack/apps/:appId/manifest
-GET  /onewhack/apps/:appId/state
-GET  /onewhack/apps/:appId/actions/:actionId
-POST /onewhack/apps/:appId/actions
-POST /onewhack/panel/open
-POST /onewhack/transcript/scroll
-POST /onewhack/transcript/highlight
-POST /onewhack/selection
+GET  /clankerbend/manifest
+GET  /clankerbend/state
+GET  /clankerbend/events
+GET  /clankerbend/apps
+GET  /clankerbend/apps/:appId/manifest
+GET  /clankerbend/apps/:appId/state
+GET  /clankerbend/apps/:appId/actions/:actionId
+POST /clankerbend/apps/:appId/actions
+POST /clankerbend/panel/open
+POST /clankerbend/transcript/scroll
+POST /clankerbend/transcript/highlight
+POST /clankerbend/selection
 ```
 
 ## Manifest
 
-OneWhack hosts and apps describe themselves with manifests. Manifests are
+ClankerBend hosts and apps describe themselves with manifests. Manifests are
 normative for the host launcher, app registry, and panel UI; Codex Desktop does
 not need to understand them. A packaged app should keep its manifest on disk,
 and a running host must expose resolved manifests through the host API.
 
 ```json
 {
-  "oneWhackVersion": "0.1",
-  "hostId": "onewill.onewhack.local",
-  "hostName": "OneWhack Host",
+  "clankerbendVersion": "0.1",
+  "hostId": "onewill.clankerbend.local",
+  "hostName": "ClankerBend Host",
   "security": {
     "auth": "bearer",
     "localDevInsecure": false
@@ -1533,7 +1533,7 @@ and a running host must expose resolved manifests through the host API.
   },
   "apps": [
     {
-      "oneWhackVersion": "0.1",
+      "clankerbendVersion": "0.1",
       "appId": "example.app",
       "version": "0.1.0",
       "name": "Example App",
@@ -1582,9 +1582,9 @@ and a running host must expose resolved manifests through the host API.
 }
 ```
 
-## Public Example: Vim Navigator App
+## Public Example: VimNav App
 
-The public reference app for OneWhack `0.1` is a Vim-style transcript navigator.
+The public reference app for ClankerBend `0.1` is VimNav, a Vim-style transcript navigator.
 Other apps should use the same host/app contract and document any app-specific
 state or action vocabulary they expose.
 
@@ -1592,10 +1592,10 @@ state or action vocabulary they expose.
 
 ```json
 {
-  "oneWhackVersion": "0.1",
+  "clankerbendVersion": "0.1",
   "appId": "onewill.vim-nav",
   "version": "0.1.0",
-  "name": "OneWill VimNav",
+  "name": "VimNav",
   "entry": "http://127.0.0.1:49152/apps/onewill.vim-nav/",
   "distribution": {
     "kind": "local",
@@ -1605,7 +1605,7 @@ state or action vocabulary they expose.
   "entrypoint": {
     "kind": "module",
     "module": "./src/vim-nav-app.js",
-    "factory": "createVimNavigatorApp",
+    "factory": "createVimNavApp",
     "publicDir": "./public"
   },
   "capabilities": {
@@ -1632,7 +1632,7 @@ state or action vocabulary they expose.
     "appServerRollback": false
   },
   "panel": {
-    "title": "Vim Nav",
+    "title": "VimNav",
     "reloadPolicy": "preserve",
     "preferredWidth": 360
   }
@@ -1738,7 +1738,7 @@ state or action vocabulary they expose.
 
 ## Security And Lifecycle
 
-OneWhack is local integration glue, not a sandbox or security boundary. The
+ClankerBend is local integration glue, not a sandbox or security boundary. The
 host still needs explicit safety rules because it can reach CDP, app-server,
 and user-visible UI.
 
@@ -1755,7 +1755,7 @@ and user-visible UI.
 App manifests declare requested permissions. The host must enforce them.
 
 ```ts
-type OneWhackAppPermissions = {
+type ClankerBendAppPermissions = {
   transcriptRead?: boolean;
   transcriptAnnotate?: boolean;
   transcriptNavigate?: boolean;
@@ -1765,7 +1765,7 @@ type OneWhackAppPermissions = {
 };
 ```
 
-For OneWhack `0.1`, an explicit `false` means the host must deny that
+For ClankerBend `0.1`, an explicit `false` means the host must deny that
 capability. Omitted permissions are interpreted by host policy, but reference
 hosts should treat omitted transcript permissions as allowed for local
 development apps. A host that denies `transcriptRead` must provide an empty
@@ -1784,7 +1784,7 @@ user-driven, and visible in app state.
 - Prefer launching through the host so CDP is enabled at process startup.
 - Attach to an already-running Desktop session only when CDP is already
   available.
-- Use a test or OneWhack profile when launching Desktop unless the user
+- Use a test or ClankerBend profile when launching Desktop unless the user
   explicitly requests their normal profile.
 - Clean up host-launched Codex and Node processes on exit.
 
@@ -1797,27 +1797,27 @@ user-driven, and visible in app state.
 
 ## Appendix: Non-Normative Reference Mapping
 
-The public Vim Navigator example maps implementation files to OneWhack terms as
+The public VimNav example maps implementation files to ClankerBend terms as
 follows:
 
-| Vim Navigator implementation | OneWhack term |
+| VimNav implementation | ClankerBend term |
 | --- | --- |
-| `onewhack/host/src/index.js` | Reusable OneWhack Host |
-| `onewhack/apps/vim-nav/server.mjs` | Host launcher registering one app |
-| `onewhack/apps/vim-nav/src/vim-nav-app.js` | Vim Navigator app manifest, state, and actions |
-| `onewhack/apps/vim-nav/public/index.html` | Hosted app panel |
-| `onewhack/apps/vim-nav/public/app.js` | App client |
-| `onewhack/apps/vim-nav/public/styles.css` | App panel styling |
-| `onewhack/host/src/codex-desktop-renderer-bridge.js` | Host-owned injected renderer bridge |
+| `clankerbend/host/src/index.js` | Reusable ClankerBend Host |
+| `clankerbend/apps/vim-nav/server.mjs` | Host launcher registering one app |
+| `clankerbend/apps/vim-nav/src/vim-nav-app.js` | VimNav app manifest, state, and actions |
+| `clankerbend/apps/vim-nav/public/index.html` | Hosted app panel |
+| `clankerbend/apps/vim-nav/public/app.js` | App client |
+| `clankerbend/apps/vim-nav/public/styles.css` | App panel styling |
+| `clankerbend/host/src/codex-desktop-renderer-bridge.js` | Host-owned injected renderer bridge |
 | CDP `Runtime.evaluate` | Desktop CDP Adapter call, not used by mock tests |
-| `window.__oneWhackRuntime.getBridge("onewill.vim-nav").snapshot()` | `RendererBridge.snapshot()` |
-| `window.__oneWhackRuntime.getBridge("onewill.vim-nav").openPanel()` | `RendererBridge.openPanel()` |
-| `window.__oneWhackRuntime.getBridge("onewill.vim-nav").scrollToAnchor(anchorId)` | `scrollToAnchor(anchorId)` |
-| `window.__oneWhackRuntime.getBridge("onewill.vim-nav").highlightAnchor(anchorId)` | `highlightAnchor(anchorId)` |
+| `window.__clankerbendRuntime.getBridge("onewill.vim-nav").snapshot()` | `RendererBridge.snapshot()` |
+| `window.__clankerbendRuntime.getBridge("onewill.vim-nav").openPanel()` | `RendererBridge.openPanel()` |
+| `window.__clankerbendRuntime.getBridge("onewill.vim-nav").scrollToAnchor(anchorId)` | `scrollToAnchor(anchorId)` |
+| `window.__clankerbendRuntime.getBridge("onewill.vim-nav").highlightAnchor(anchorId)` | `highlightAnchor(anchorId)` |
 | numbered transcript ruler pills | `AnchorAnnotation.markers` |
-| `/onewhack/apps/onewill.vim-nav/state` | App state endpoint |
-| `/onewhack/apps/onewill.vim-nav/actions` | App action endpoint |
-| `onewhack/apps/vim-nav/test-onewhack.mjs` | Fast host/app behavior e2e |
+| `/clankerbend/apps/onewill.vim-nav/state` | App state endpoint |
+| `/clankerbend/apps/onewill.vim-nav/actions` | App action endpoint |
+| `clankerbend/apps/vim-nav/test-clankerbend.mjs` | Fast host/app behavior e2e |
 
 ## Operational Rules
 
@@ -1832,7 +1832,7 @@ follows:
 
 ## Behavior Profiles
 
-OneWhack `0.1` describes behavior in four profiles. Implementations should state
+ClankerBend `0.1` describes behavior in four profiles. Implementations should state
 which profiles they support and cover those behaviors with e2e tests.
 
 ### Core Host
@@ -1841,25 +1841,25 @@ A Core Host must implement:
 
 - JSON envelope and error model.
 - Session token behavior or explicit `localDevInsecure`.
-- `GET /onewhack/manifest`.
-- `GET /onewhack/state`.
-- `GET /onewhack/events`.
-- `GET /onewhack/apps`.
-- `GET /onewhack/apps/:appId/manifest`.
-- `GET /onewhack/apps/:appId/state`.
-- `GET /onewhack/apps/:appId/actions/:actionId`.
-- `POST /onewhack/apps/:appId/actions`.
+- `GET /clankerbend/manifest`.
+- `GET /clankerbend/state`.
+- `GET /clankerbend/events`.
+- `GET /clankerbend/apps`.
+- `GET /clankerbend/apps/:appId/manifest`.
+- `GET /clankerbend/apps/:appId/state`.
+- `GET /clankerbend/apps/:appId/actions/:actionId`.
+- `POST /clankerbend/apps/:appId/actions`.
 - App lifecycle states and permission enforcement.
 
 ### Transcript Host
 
 A Transcript Host is a Core Host that also implements:
 
-- Transcript anchors in `OneWhackPublicState`.
-- `POST /onewhack/panel/open`.
-- `POST /onewhack/transcript/scroll`.
-- `POST /onewhack/transcript/highlight`.
-- `POST /onewhack/selection`.
+- Transcript anchors in `ClankerBendPublicState`.
+- `POST /clankerbend/panel/open`.
+- `POST /clankerbend/transcript/scroll`.
+- `POST /clankerbend/transcript/highlight`.
+- `POST /clankerbend/selection`.
 - Annotation ownership and merge rules.
 
 ### Codex Desktop Adapter
@@ -1873,48 +1873,48 @@ process cleanup.
 
 An App Client must:
 
-- Read `GET /onewhack/manifest` and verify required capabilities.
-- Use `GET /onewhack/apps/:appId/state` or `GET /onewhack/state` as its source
+- Read `GET /clankerbend/manifest` and verify required capabilities.
+- Use `GET /clankerbend/apps/:appId/state` or `GET /clankerbend/state` as its source
   of truth.
-- Use `POST /onewhack/apps/:appId/actions` for app commands.
-- Use `GET /onewhack/apps/:appId/actions/:actionId` to recover action results
+- Use `POST /clankerbend/apps/:appId/actions` for app commands.
+- Use `GET /clankerbend/apps/:appId/actions/:actionId` to recover action results
   when needed.
-- Treat `OneWhackError` as the only failure contract.
+- Treat `ClankerBendError` as the only failure contract.
 - Degrade cleanly when capabilities or permissions are unavailable.
 
 ## Required E2E Coverage
 
-A OneWhack `0.1` implementation should include fast e2e coverage for these
+A ClankerBend `0.1` implementation should include fast e2e coverage for these
 observable behaviors:
 
-1. `GET /onewhack/manifest` returns `ok: true`, `oneWhackVersion: "0.1"`,
+1. `GET /clankerbend/manifest` returns `ok: true`, `clankerbendVersion: "0.1"`,
    host capabilities, security posture, and app manifests.
-2. `GET /onewhack/state` returns `ok: true` with `protocolName: "onewhack"`,
+2. `GET /clankerbend/state` returns `ok: true` with `protocolName: "clankerbend"`,
    `protocolVersion: "0.1"`, numeric `sequence`, ISO `generatedAt`, host
    status, transcript state, app states, and app-server status.
-3. `GET /onewhack/events` emits an initial `state` event, monotonically
+3. `GET /clankerbend/events` emits an initial `state` event, monotonically
    increasing event ids, and `heartbeat` events.
-4. Unknown apps return `404` with `OneWhackError.error.code: "not_found"`.
+4. Unknown apps return `404` with `ClankerBendError.error.code: "not_found"`.
 5. Missing or invalid bearer tokens return `401` unless `localDevInsecure` is
    explicitly enabled.
 6. Duplicate `(appId, actionId)` submissions return the same receipt or result
    without executing twice.
 7. Async action completion is observable through both SSE `action` events and
-   `GET /onewhack/apps/:appId/actions/:actionId`.
+   `GET /clankerbend/apps/:appId/actions/:actionId`.
 8. Stale selections return the current accepted selection with `stale: true`
    and do not change host `selection`.
 9. Annotation merge order is stable by `priority`, then `appId`, then
    `markerId`.
 10. Disabling or unmounting an app removes only that app's annotations.
-11. `POST /onewhack/transcript/scroll` and
-   `POST /onewhack/transcript/highlight` return `404` for unknown anchors and do
+11. `POST /clankerbend/transcript/scroll` and
+   `POST /clankerbend/transcript/highlight` return `404` for unknown anchors and do
    not mutate selection.
 12. Opening an already-loaded panel does not reload it when
    `reloadPolicy: "preserve"`.
 
 ## Versioning
 
-OneWhack version `0.1` is the minimal hack-path protocol:
+ClankerBend version `0.1` is the minimal hack-path protocol:
 
 - local host state/event endpoints
 - host/app manifest negotiation
@@ -1931,5 +1931,5 @@ Future versions may add alternate adapters, but they should preserve the same
 host-facing concepts. Minor versions should add optional capabilities or fields
 behind capability checks. Major versions may change required fields or endpoint
 semantics, but a host must make that visible through `protocolVersion`,
-`oneWhackVersion`, and `capabilities.protocolVersion` before app actions are
+`clankerbendVersion`, and `capabilities.protocolVersion` before app actions are
 required.