backeer-opencode 0.8.2 → 0.10.0

package/docs/live-control.md

@@ -38,12 +38,12 @@ Alternatively, `backeer-codex` 0.3.0 configures this file and bundles the local
 adapter as a plugin MCP server. No new server is deployed. Profiles hold file
 references, never credentials; keep the token in its existing protected file.
 
-Managed tools: `list_connections`, `list_sessions`, `connect_session`,
+Managed tools include `connection_setup`, `diagnose_connection`, `list_connections`, `list_sessions`, `connect_session`,
 `session_status`, `send_instruction`, `read_events`, `wait_for_events`, and
 `disconnect_session`. Connect with an explicit connection name and existing
 session ID. Store the returned `bindingId` only in that chat and pass it to every
 subsequent bound tool. There is no global selected session. Bindings are immutable
-and each owns an independent stream/cursor; even two chats observing the same
+and each owns an independent session-filtered stream/cursor; even two chats observing the same
 session do not consume one another's output. They are local capabilities, not a
 multi-user authorization boundary.
 
@@ -55,14 +55,25 @@ Old single-connection clients remain compatible. No session creation, arbitrary
 shell execution or permission bypass is added. Changed credentials require
 disconnect/reconnect; no inline token or remote error body is exposed.
 
-Missing profiles allow startup with an empty connection list. Up to 32 profiles
-can be saved, with at most 16 active streams/lookups in one manager. Disconnect
+Missing profiles allow startup with an empty connection list. There is no imposed profile or active/pending binding quota. Disconnect
 unused bindings; remote work continues. Bindings last until this MCP process
 ends; reconnect to the same existing session after a restart. Missed history is
 not fabricated. Existing gap acknowledgement, request-ID deduplication, heartbeat,
 three-second transport reconnection and mobile disconnect/reconnect notices are
 unchanged. The manager does not create or supervise the external SSH tunnel.
 
+`connection_setup` is a read-only staged guide: choose a saved connection, or
+discover a verified candidate to save, then choose a live main session. It never
+selects a target automatically or stores a session ID. `diagnose_connection`
+accepts exactly one connection name or binding ID and returns fixed safe messages
+for a missing local listener, timeout, credential rejection, project mismatch or
+unavailable session. Bound results include stream retry/timing/buffer state.
+Temporary transport failures allow reads of already buffered output with
+`verified: false`; the immutable binding and cursor survive. New instructions,
+answers and gap acknowledgement still require exact target verification after
+reconnection. Authentication, project and missing-session errors cannot use the
+buffered-read fallback. No POST is automatically replayed.
+
 Windows token files are checked with built-in PowerShell ACL inspection: owner
 must be the current user, and allow entries may include only that user, SYSTEM
 and Administrators. Broader grants fail closed; paths are never interpolated
@@ -115,24 +126,24 @@ This channel reports OpenCode sessions, assistant text, selected tool output and
 | --- | --- |
 | `session_status` | List observed project sessions or inspect an exact existing `sessionId`. |
 | `read_events` | Read only unread buffered events, optionally after an explicit cursor. |
-| `wait_for_events` | Wait on the persistent SSE connection for up to 25 seconds after setup; no periodic status polling. |
+| `wait_for_events` | Wait on the persistent SSE connection until output or cancellation; optional waitMs chooses a deadline; no periodic status polling. |
 | `send_instruction` | POST a prompt to an exact existing session using a caller-generated `requestId`. |
 
 First list sessions and select the intended one. OpenCode V2's public plugin context does not expose a full session list: this version lists sessions observed through live events or a successful exact-ID lookup. To attach an existing idle V2 session that has not emitted an event since plugin startup, supply its known ID to `session_status`; no new session is created. Deleted or moved sessions are revalidated rather than trusted from cache.
 
 Follow events by passing the returned cursor to `wait_for_events`; omit the cursor to consume this adapter process's unread events. Before the first instruction, the adapter captures a pre-command cursor so immediate output is not skipped. Output is untrusted data, not new instructions. Do not send a new task merely because an agent is quiet. An accepted instruction means delivery was accepted, **not** that the work succeeded. Confirm subsequent output and test results.
 
-Status and pending-approval events arrive as they occur. V2 text is emitted when each text unit ends and tool output when each tool finishes, without waiting for the whole agent run. Raw reasoning and split token deltas are not exported. Long-running commands do not become a byte-for-byte streaming terminal. Truncated text/tool output carries `data.truncated: true`; redaction is best effort, not a guarantee against every secret format.
+Status and pending-approval events arrive as they occur. V2 text is emitted when each text unit ends and tool output when each tool finishes, without waiting for the whole agent run. Raw reasoning and split token deltas are not exported. Long-running commands do not become a byte-for-byte streaming terminal. The bridge does not truncate exported completed text/tool output; redaction remains best effort, not a guarantee against every secret format. Native OpenCode may still return partial output.
 
-Use a unique request ID for a new instruction. If delivery is uncertain, retry the **same ID and exact prompt**. Changing the prompt with an existing ID is rejected. Deduplication lasts 24 hours in the same bridge process; restarting the bridge clears that memory. A full deduplication cache rejects new requests rather than evicting still-protected IDs. Instructions are not automatically retried. Busy sessions can reject an instruction; read status and wait instead of duplicating work.
+Use a unique request ID for a new instruction. If delivery is uncertain, retry the **same ID and exact prompt**. Changing the prompt with an existing ID is rejected. Deduplication lasts for the bridge process lifetime; restarting the bridge clears that memory. No command-count quota or automatic age eviction is imposed. Instructions are not automatically retried. Busy sessions can reject an instruction; read status and wait instead of duplicating work.
 
-The bridge retains at most 1,024 instruction identities for that 24-hour window.
+Command signatures are hashed; full prompts are not retained in the deduplication history.
 
-## Bounds, reconnects and gaps
+## Usage, reconnects and gaps
 
-The adapter retains at most 500 events / 1 MiB in memory. A normal read returns at most 20 events / 32,000 characters; explicit bounds allow at most 100 events / 64,000 characters. Large individual events request a larger bounded read rather than silently skipping them. Bridge events may themselves be truncated and carry truncation metadata; a tool cannot reconstruct omitted text.
+No fixed count, byte or age quotas are imposed on bridge/client history, profiles, candidates, chat bindings, SSE readers, instructions, question batches/options/custom answers or output. Default reads return available output without silently clipping it. Callers may optionally select `limit`, `maxChars` or `waitMs` for a particular call; these have no application-defined maximum. Waiting without `waitMs` continues until output or cancellation. Retained history consumes memory until disposal; physical resources, native OpenCode behavior and host/protocol constraints still apply.
 
-There is **no maximum connection lifetime or agent-output idle timeout**. The bridge emits a tiny heartbeat every 15 seconds even when a task produces no output for hours. A 45-second watchdog measures missing **transport traffic**, not missing agent replies. If heartbeats disappear, the client discards the dead socket and reconnects. The 25-second MCP wait limit only ends that tool call; it leaves the underlying SSE connection running.
+There is **no maximum connection lifetime or agent-output idle timeout**. The bridge emits a tiny heartbeat every 15 seconds even when a task produces no output for hours. A 45-second watchdog measures missing **transport traffic**, not missing agent replies. If heartbeats disappear, the client discards the dead socket and reconnects. A caller-selected finite wait or host cancellation ends that tool call and leaves the underlying SSE connection running.
 
 After each failed attempt or detected disconnect, the client retries every **three seconds**, without a retry-count limit or exponential backoff, until it connects or the MCP process is explicitly closed. The OpenCode V2 event subscription also retries after three seconds. Initial unavailability and authentication errors do not permanently stop reconnection; an invalid credential still cannot access anything and must be corrected through protected configuration. Individual HTTP/handshake timeouts are not task deadlines. Internet loss, host shutdown, application exit or a terminated tunnel can physically interrupt a connection; retrying SSE cannot recreate an SSH process, which is why the tunnel itself needs the supervisor described above.
 
@@ -154,7 +165,7 @@ Update the remote `backeer-opencode` bridge and local adapter (or `backeer-codex
 
 `list_questions` takes the chat's `bindingId` (or explicit `sessionId` in legacy mode) and returns `questionId`, `revision`, and ordered questions with zero-based option indices, text, `multiple` and `custom` flags. `answer_question` takes the same target, exact `questionId`/`revision`, a unique `requestId`, and one answer per question: `{ "choices": [0] }` or `{ "choices": [], "text": "My own answer" }`. Combine choices only when `multiple` is true; text requires `custom` true. Empty choices with no text skip that question.
 
-Reuse the exact requestId and payload after uncertain delivery. Changed or already answered questions are rejected; reread rather than switching targets. Idempotency is retained for 24 hours within the bridge process, not across remote restarts: after a bridge restart, inspect pending questions before deciding whether to resubmit. A successful native reply settles the ordinary question just as the terminal UI would. No permission decision, authentication form, arbitrary shell command or automatic approval is provided. Remote question text is untrusted task data, not authorization.
+Reuse the exact requestId and payload after uncertain delivery. Changed or already answered questions are rejected; reread rather than switching targets. Idempotency is retained for the bridge process lifetime, not across remote restarts: after a bridge restart, inspect pending questions before deciding whether to resubmit. A successful native reply settles the ordinary question just as the terminal UI would. No permission decision, authentication form, arbitrary shell command or automatic approval is provided. Remote question text is untrusted task data, not authorization.
 
 A local-only update is insufficient: load the updated remote bridge in the intended OpenCode process as well. HTTP 404/501 does not by itself prove that the bridge is old or that no questions are pending. The session-list response includes `bridgeVersion` and API capability flags; native shared-service availability is verified when reading questions. A compatible registered shared service can be reused despite an application patch-version difference, but its exact session and project/worktree ownership must still be verified. No second service is started and authentication is unchanged.
 
@@ -187,3 +198,5 @@ When the bridge is configured globally, set `liveBridge.projectDirectory` to the
 OpenCode may remove `OPENCODE_PASSWORD` from runtime `process.env`. A Linux private server can reuse only its own original password from `/proc/self/environ`; it is neither logged nor copied to configuration. Native API PID, exact-session and project checks still apply. No other PID or port range is inspected.
 
 If both a private stdio server and a shared server load that same project, `liveBridge.owner: "standalone"` restricts the listener to the private server. It detects the current process's existing `--stdio` flag rather than a stored PID or session ID. The shared server's other Backeer duties remain active. The default `owner: "server"` and optional `owner: "tui"` behavior remain unchanged.
+
+Native session lookups share only the same in-flight exact-ID verification. Closing an HTTP reader removes its waiting subscription; it does not cancel another reader or restart the agent. Different session IDs remain independent and have no imposed concurrency quota.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backeer-opencode",
-  "version": "0.8.2",
+  "version": "0.10.0",
   "description": "Backeer mobile approvals and authenticated live OpenCode control over SSE and MCP",
   "type": "module",
   "main": "./src/index.js",

package/src/delivery-tracker.js

@@ -1,4 +1,4 @@
-import { rememberBounded } from "./utilities.js"
+import { remember } from "./utilities.js"
 
 export function createDeliveryTracker() {
   const states = new Map()
@@ -6,13 +6,13 @@ export function createDeliveryTracker() {
   return {
     begin(key) {
       if (states.has(key)) return false
-      rememberBounded(states, key, "publishing")
+      remember(states, key, "publishing")
       return true
     },
 
     succeed(key) {
       if (states.get(key) === "publishing") {
-        rememberBounded(states, key, "published")
+        remember(states, key, "published")
       }
     },
 
@@ -33,7 +33,7 @@ export function createCompletionTracker() {
     let state = states.get(key)
     if (!state) {
       state = { complete: false, publishing: false, revision: 0 }
-      rememberBounded(states, key, state)
+      remember(states, key, state)
     }
     return state
   }

package/src/diagnostics.js

@@ -3,7 +3,7 @@ import { statSync } from "node:fs"
 
 import { HttpError, postJsonWithRetry } from "./http.js"
 import { PLUGIN_VERSION } from "./updates.js"
-import { limit } from "./utilities.js"
+import { formatText } from "./utilities.js"
 
 const PASS = "✓"
 const FAIL = "×"
@@ -41,7 +41,7 @@ async function probeSource(config, fetchImplementation = globalThis.fetch) {
       headers: { Authorization: `Bearer ${config.token}` },
       signal: controller.signal,
     })
-    const responseBody = limit(await response.text(), 2000)
+    const responseBody = formatText(await response.text())
     if (!response.ok) {
       throw new HttpError(
         `Gateway source check failed with status ${response.status}`,
@@ -107,7 +107,7 @@ export async function buildDoctorReport(
         ? "Source authentication rejected (HTTP 401)"
         : error?.name === "AbortError"
           ? "Gateway source check timed out"
-          : `Gateway source check failed: ${limit(error?.message || error, 300)}`
+          : `Gateway source check failed: ${formatText(error?.message || error)}`
       checks.push({ ok: false, text: detail })
     }
   }

package/src/event-publishers.js

@@ -1,5 +1,5 @@
 import { postJsonWithRetry } from "./http.js"
-import { limit, stableHash } from "./utilities.js"
+import { formatText, stableHash } from "./utilities.js"
 
 const ACTION_PROTOCOL = "opencode-permission/v1"
 const QUESTION_ACTION_PROTOCOL = "opencode-question/v1"
@@ -32,11 +32,11 @@ export async function publishPermission(
       : ""
 
   const payload = [
-    { key: "Permission", value: limit(permissionType) },
-    { key: "Session", value: limit(identity.sessionID) },
-    { key: "Request ID", value: limit(identity.requestID) },
-    { key: "Patterns", value: limit(resources) },
-    { key: "Working directory", value: limit(directory) },
+    { key: "Permission", value: formatText(permissionType) },
+    { key: "Session", value: formatText(identity.sessionID) },
+    { key: "Request ID", value: formatText(identity.requestID) },
+    { key: "Patterns", value: formatText(resources) },
+    { key: "Working directory", value: formatText(directory) },
     { key: "Action protocol", value: ACTION_PROTOCOL },
     { key: "Available decisions", value: "once, always, reject" },
   ].filter((item) => item.value.length > 0)
@@ -44,10 +44,10 @@ export async function publishPermission(
   const result = await postJsonWithRetry(config, config.eventsEndpoint, {
     type: "application",
     severity: "warning",
-    title: `OpenCode permission required: ${limit(permissionType, 200)}`,
+    title: `OpenCode permission required: ${formatText(permissionType)}`,
     body: resources
-      ? `OpenCode is waiting for approval to access: ${limit(resources, 500)}`
-      : `OpenCode is waiting for approval for: ${limit(permissionType, 500)}`,
+      ? `OpenCode is waiting for approval to access: ${formatText(resources)}`
+      : `OpenCode is waiting for approval for: ${formatText(permissionType)}`,
     payload,
     externalId: identity.externalId,
     timestamp: new Date().toISOString(),
@@ -75,8 +75,8 @@ function formatQuestionOptions(options) {
 
   return options
     .map((option) => {
-      const label = limit(option?.label, 200)
-      const description = limit(option?.description, 500)
+      const label = formatText(option?.label)
+      const description = formatText(option?.description)
       if (!label) return ""
       return description ? `${label} — ${description}` : label
     })
@@ -93,7 +93,7 @@ async function resolveSessionTitle(client, directory, sessionID, reporter) {
       query: { directory },
       throwOnError: true,
     })
-    return limit((result?.data ?? result)?.title)
+    return formatText((result?.data ?? result)?.title)
   } catch (error) {
     reporter.debug("Session title unavailable", error)
     return ""
@@ -121,17 +121,17 @@ export async function publishQuestion(
   )
   const payload = [
     { key: "OpenCode session", value: sessionTitle },
-    { key: "Session", value: limit(identity.sessionID) },
-    { key: "Request ID", value: limit(identity.requestID) },
+    { key: "Session", value: formatText(identity.sessionID) },
+    { key: "Request ID", value: formatText(identity.requestID) },
     { key: "Action protocol", value: QUESTION_ACTION_PROTOCOL },
     ...questions.flatMap((question, index) => {
       const suffix = questions.length > 1 ? ` ${index + 1}` : ""
       return [
-        { key: `Question title${suffix}`, value: limit(question?.header) },
-        { key: `Question${suffix}`, value: limit(question?.question) },
+        { key: `Question title${suffix}`, value: formatText(question?.header) },
+        { key: `Question${suffix}`, value: formatText(question?.question) },
         {
           key: `Options${suffix}`,
-          value: limit(formatQuestionOptions(question?.options)),
+          value: formatText(formatQuestionOptions(question?.options)),
         },
       ]
     }),
@@ -139,12 +139,12 @@ export async function publishQuestion(
 
   const firstQuestion = questions[0]
   const actionQuestions = questions.map((question) => ({
-    header: limit(question?.header, 200),
-    question: limit(question?.question, 2000),
+    header: formatText(question?.header),
+    question: formatText(question?.question),
     options: Array.isArray(question?.options)
-      ? question.options.slice(0, 20).map((option) => ({
-          label: limit(option?.label, 200),
-          description: limit(option?.description, 500),
+      ? question.options.map((option) => ({
+          label: formatText(option?.label),
+          description: formatText(option?.description),
         })).filter((option) => option.label)
       : [],
     multiple: question?.multiple === true,
@@ -152,9 +152,9 @@ export async function publishQuestion(
   }))
   const body = questions
     .map((question) => {
-      const header = limit(question?.header, 200)
-      const text = limit(question?.question, 500)
-      const options = limit(formatQuestionOptions(question?.options), 500)
+      const header = formatText(question?.header)
+      const text = formatText(question?.question)
+      const options = formatText(formatQuestionOptions(question?.options))
       return [header, text, options ? `Options: ${options}` : ""]
         .filter(Boolean)
         .join("\n")
@@ -164,8 +164,8 @@ export async function publishQuestion(
   const result = await postJsonWithRetry(config, config.eventsEndpoint, {
     type: "application",
     severity: "info",
-    title: `OpenCode question: ${limit(firstQuestion?.header, 200) || "Question"}`,
-    body: limit(body, 2000),
+    title: `OpenCode question: ${formatText(firstQuestion?.header) || "Question"}`,
+    body: formatText(body),
     payload,
     externalId: identity.externalId,
     timestamp: new Date().toISOString(),
@@ -205,16 +205,16 @@ export async function publishTodoCompletion(
   )
   const correlation =
     typeof eventID === "string" && eventID.length > 0
-      ? limit(eventID, 200)
+      ? formatText(eventID)
       : stableHash(JSON.stringify(todos))
   const externalId = `opencode-todo:${request.sessionID}:${correlation}`
-  const visibleTodos = todos.slice(0, 20)
+  const visibleTodos = todos
   const payload = [
     { key: "OpenCode session", value: sessionTitle },
     { key: "Completed tasks", value: String(todos.length) },
     ...visibleTodos.flatMap((todo, index) => [
-      { key: `Task ${index + 1}`, value: limit(todo?.content) },
-      { key: `Priority ${index + 1}`, value: limit(todo?.priority, 100) },
+      { key: `Task ${index + 1}`, value: formatText(todo?.content) },
+      { key: `Priority ${index + 1}`, value: formatText(todo?.priority) },
     ]),
     ...(todos.length > visibleTodos.length
       ? [{ key: "Additional tasks", value: String(todos.length - visibleTodos.length) }]
@@ -222,8 +222,7 @@ export async function publishTodoCompletion(
   ].filter((item) => item.value.length > 0)
 
   const summary = todos
-    .slice(0, 5)
-    .map((todo) => limit(todo?.content, 200))
+    .map((todo) => formatText(todo?.content))
     .filter(Boolean)
     .join(" • ")
   const location = sessionTitle ? ` in ${sessionTitle}` : ""
@@ -236,7 +235,7 @@ export async function publishTodoCompletion(
     type: "application",
     severity: "info",
     title: "OpenCode todo list completed",
-    body: limit(body, 2000),
+    body: formatText(body),
     payload,
     externalId,
     timestamp: new Date().toISOString(),

package/src/feedback-session-store.js

@@ -1,6 +1,4 @@
-import { limit, rememberBounded } from "./utilities.js"
-
-const MAX_QUEUED_MESSAGES = 20
+import { formatText, remember } from "./utilities.js"
 
 export class FeedbackSessionStore {
   constructor({ send, reporter, flushDelayMs = 150 }) {
@@ -20,10 +18,9 @@ export class FeedbackSessionStore {
         blockers: new Set(),
         queue: [],
         queued: new Set(),
-        queueOverflowReported: false,
         flushTimer: undefined,
       }
-      rememberBounded(this.sessions, sessionID, state)
+      remember(this.sessions, sessionID, state)
     }
     return state
   }
@@ -64,16 +61,8 @@ export class FeedbackSessionStore {
     const key = `${sessionID}:${kind}:${message}`
     if (state.queued.has(key)) return
 
-    state.queue.push({ kind, message: limit(message, 300), key })
+    state.queue.push({ kind, message: formatText(message), key })
     state.queued.add(key)
-    if (state.queue.length > MAX_QUEUED_MESSAGES) {
-      const removed = state.queue.shift()
-      state.queued.delete(removed.key)
-      if (!state.queueOverflowReported) {
-        state.queueOverflowReported = true
-        this.reporter.warning("Conversation feedback queue full — oldest message discarded")
-      }
-    }
     this.scheduleFlush(sessionID, state)
   }
 

package/src/http.js

@@ -1,6 +1,4 @@
-import { limit } from "./utilities.js"
-
-const RETRY_DELAYS_MS = [0, 500, 1500]
+import { createBridgeSanitizer } from "./live-bridge-events.js"
 
 export class HttpError extends Error {
   constructor(message, status, responseBody = "") {
@@ -39,18 +37,18 @@ export function sleep(milliseconds, signal) {
 }
 
 export async function postJsonWithRetry(config, url, body, options = {}) {
-  const retryDelays = options.retryDelays ?? RETRY_DELAYS_MS
+  const retryDelays = options.retryDelays
+  const signal = options.signal ?? config.signal
 
-  for (let attempt = 0; attempt < retryDelays.length; attempt++) {
-    if (retryDelays[attempt] > 0) {
-      await sleep(retryDelays[attempt], options.signal)
-    }
-    if (options.signal?.aborted) throw new DOMException("Aborted", "AbortError")
+  for (let attempt = 0; retryDelays === undefined || attempt < retryDelays.length; attempt++) {
+    const retryDelay = retryDelays?.[attempt] ?? (attempt === 0 ? 0 : 3000)
+    if (retryDelay > 0) await (options.sleepImplementation ?? sleep)(retryDelay, signal)
+    if (signal?.aborted) throw new DOMException("Aborted", "AbortError")
 
     const controller = new AbortController()
     const abort = () => controller.abort()
     const timeout = setTimeout(abort, options.timeoutMs ?? 5000)
-    options.signal?.addEventListener("abort", abort, { once: true })
+    signal?.addEventListener("abort", abort, { once: true })
 
     try {
       const response = await fetch(url, {
@@ -63,23 +61,23 @@ export async function postJsonWithRetry(config, url, body, options = {}) {
         body: JSON.stringify(body),
         signal: controller.signal,
       })
-      const responseBody = limit(await response.text(), 1000)
+      const responseBody = await response.text()
 
       if (response.ok) return { status: response.status, responseBody }
-      if (!isRetryable(response.status) || attempt === retryDelays.length - 1) {
+      if (!isRetryable(response.status) || retryDelays !== undefined && attempt === retryDelays.length - 1) {
         throw new HttpError(
           `HTTP request failed with status ${response.status}`,
           response.status,
-          responseBody,
+          createBridgeSanitizer([config.token]).text(responseBody),
         )
       }
     } catch (error) {
-      if (options.signal?.aborted) throw new DOMException("Aborted", "AbortError")
+      if (signal?.aborted) throw new DOMException("Aborted", "AbortError")
       if (error instanceof HttpError) throw error
-      if (attempt === retryDelays.length - 1) throw error
+      if (retryDelays !== undefined && attempt === retryDelays.length - 1) throw error
     } finally {
       clearTimeout(timeout)
-      options.signal?.removeEventListener("abort", abort)
+      signal?.removeEventListener("abort", abort)
     }
   }
 

package/src/lifecycle-controller.js

@@ -5,7 +5,7 @@ import {
   publishSessionError,
   publishSessionRetry,
 } from "./lifecycle-publishers.js"
-import { limit, rememberBounded, stableHash } from "./utilities.js"
+import { formatText, remember, stableHash } from "./utilities.js"
 
 const QUESTION_EVENTS = new Set(["question.asked", "question.v2.asked"])
 const QUESTION_REPLY_EVENTS = new Set([
@@ -43,7 +43,7 @@ export function createLifecycleController({
         lastAssistant: undefined,
         completedMessageID: "",
       }
-      rememberBounded(sessions, sessionID, state)
+      remember(sessions, sessionID, state)
     }
     return state
   }
@@ -85,7 +85,7 @@ export function createLifecycleController({
         client,
         directory,
         sessionID,
-        messageID: limit(assistant.id, 200),
+        messageID: formatText(assistant.id),
         durationMs,
         conversation,
       }),
@@ -138,7 +138,7 @@ export function createLifecycleController({
         client,
         directory,
         sessionID,
-        correlation: limit(correlation, 200),
+        correlation: formatText(correlation),
         attempt: status.attempt,
         next: status.next,
         conversation,
@@ -199,7 +199,7 @@ export function createLifecycleController({
         const version = event.properties?.version
         if (typeof version !== "string" || !version.trim()) return
         if (publishedUpdates.has(version)) return
-        rememberBounded(publishedUpdates, version, true)
+        remember(publishedUpdates, version, true)
         dispatch(
           "OpenCode update could not be sent",
           sendUpdate({ config, reporter, version: version.trim() }),

package/src/lifecycle-publishers.js

@@ -1,5 +1,5 @@
 import { postJsonWithRetry } from "./http.js"
-import { limit, stableHash } from "./utilities.js"
+import { formatText, stableHash } from "./utilities.js"
 
 // Intentional sanitization of non-printable control bytes before logging.
 // eslint-disable-next-line no-control-regex
@@ -11,7 +11,7 @@ const WINDOWS_PATH = /\b[A-Za-z]:\\(?:[^\\\s]+\\)+[^\s]*/g
 const POSIX_PATH = /(^|\s)\/(?:[^/\s]+\/)+[^\s]*/g
 
 export function sanitizeErrorMessage(value) {
-  return limit(value, 2000)
+  return formatText(value)
     .replace(CONTROL_CHARACTERS, " ")
     .replace(BEARER_TOKEN, "Bearer [redacted]")
     .replace(SECRET_ASSIGNMENT, "$1=[redacted]")
@@ -27,11 +27,10 @@ export function sanitizeErrorMessage(value) {
     .replace(POSIX_PATH, "$1[path redacted]")
     .replace(/\s+/g, " ")
     .trim()
-    .slice(0, 500)
 }
 
 export function safeErrorDetails(error) {
-  const name = limit(error?.name || "OpenCodeError", 100)
+  const name = formatText(error?.name || "OpenCodeError")
   const message = sanitizeErrorMessage(error?.data?.message ?? error?.message)
   const statusCode = Number.isInteger(error?.data?.statusCode)
     ? String(error.data.statusCode)
@@ -48,7 +47,7 @@ async function resolveSessionTitle(client, directory, sessionID, reporter) {
       query: { directory },
       throwOnError: true,
     })
-    return limit((result?.data ?? result)?.title)
+    return formatText((result?.data ?? result)?.title)
   } catch (error) {
     reporter.debug("Session title unavailable", error)
     return ""
@@ -162,7 +161,7 @@ export async function publishSessionError({
     // Backeer/iOS currently support info, warning and critical severities.
     severity: "critical",
     title: "OpenCode task failed",
-    body: limit(body, 1000),
+    body: formatText(body),
     payload: [
       { key: "OpenCode session", value: sessionTitle },
       { key: "Outcome", value: "Failed" },
@@ -175,7 +174,7 @@ export async function publishSessionError({
 }
 
 export async function publishOpenCodeUpdate({ config, reporter, version }) {
-  const safeVersion = limit(version, 100)
+  const safeVersion = formatText(version)
   await publish(config, reporter, undefined, undefined, {
     severity: "info",
     title: "OpenCode update available",
@@ -186,8 +185,8 @@ export async function publishOpenCodeUpdate({ config, reporter, version }) {
 }
 
 export function errorCorrelation(event, sessionState) {
-  if (typeof event?.id === "string" && event.id) return limit(event.id, 200)
-  if (sessionState?.lastAssistant?.id) return limit(sessionState.lastAssistant.id, 200)
+  if (typeof event?.id === "string" && event.id) return formatText(event.id)
+  if (sessionState?.lastAssistant?.id) return formatText(sessionState.lastAssistant.id)
   const details = safeErrorDetails(event?.properties?.error)
   return stableHash(`${details.name}:${details.statusCode}:${details.message}`)
 }

package/src/live-bridge-client.js

@@ -15,24 +15,23 @@ export function createV2LiveClient(ctx) {
     if (disposed) return info
     await ownsSession(info)
     known.set(id, info)
-    if (known.size > 100) known.delete(known.keys().next().value)
     return info
   }
   return {
     async list() {
       const refreshed = []
       if (typeof ctx.session.list === "function") {
-        const result = await ctx.session.list({ directory: ctx.location.directory, limit: 100, order: "desc" })
+        const result = await ctx.session.list({ directory: ctx.location.directory, order: "desc" })
         const values = Array.isArray(result) ? result : result?.data
         if (!Array.isArray(values)) throw new Error("Invalid native session list")
-        for (const info of values.slice(0, 100)) {
+        for (const info of values) {
           if (await ownsSession(info)) {
             refreshed.push(info)
             known.set(info.id, info)
           }
         }
       }
-      for (const id of [...known.keys()].slice(0, 100)) {
+      for (const id of [...known.keys()]) {
         if (refreshed.some(info => info.id === id)) continue
         try { refreshed.push(await get(id)) } catch { known.delete(id) }
       }

package/src/live-bridge-config.js

@@ -10,16 +10,15 @@ function readCredential(file) {
     descriptor = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) |
       (constants.O_NONBLOCK ?? 0))
     const stat = fstatSync(descriptor)
-    if (!stat.isFile() || stat.size > 4096 ||
-        (process.platform !== "win32" && ((stat.mode & 0o077) !== 0 ||
+    if (!stat.isFile() || (process.platform !== "win32" && ((stat.mode & 0o077) !== 0 ||
           stat.uid !== process.getuid()))) {
       throw new Error("invalid_file")
     }
     const token = readFileSync(descriptor, "utf8").trim()
-    if (!/^[A-Za-z0-9_-]{32,256}$/.test(token)) throw new Error("invalid_token")
+    if (!/^[A-Za-z0-9_-]{32,}$/.test(token)) throw new Error("invalid_token")
     return token
   } catch {
-    throw new Error("Live control credential must be an owner-only regular file containing a 32–256 character token")
+    throw new Error("Live control credential must be an owner-only regular file containing a token of at least 32 characters")
   } finally {
     if (descriptor !== undefined) closeSync(descriptor)
   }

package/src/live-bridge-events.js

@@ -1,24 +1,22 @@
-const ID = /^[A-Za-z0-9_-]{1,160}$/
+const ID = /^[A-Za-z0-9_-]+$/
 export const validBridgeID = (value) => typeof value === "string" && ID.test(value)
 
 export function createBridgeSanitizer(secrets = []) {
   const known = secrets.filter((value) => typeof value === "string" && value.length > 0)
   const assistants = new Map()
-  function clipped(value, max = 12_000) {
-    if (typeof value !== "string") return { value: "", truncated: false }
-    let result = value.slice(0, 64_000)
+  function text(value) {
+    if (typeof value !== "string") return ""
+    let result = value
     for (const secret of known) result = result.split(secret).join("[REDACTED]")
     result = result
       .replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g, "[REDACTED PRIVATE KEY]")
       .replace(/\bBearer\s+[^\s"'<>]+/gi, "Bearer [REDACTED]")
       .replace(/\b(?:sk|bgi)_[A-Za-z0-9_-]{12,}|\bsk-[A-Za-z0-9_-]{12,}/g, "[REDACTED]")
       .replace(/((?:api[_-]?key|access[_-]?token|secret|password|authorization)\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]")
-    return { value: result.slice(0, max), truncated: value.length > 64_000 || result.length > max }
+    return result
   }
-  function text(value, max) { return clipped(value, max).value }
   function content(key, value) {
-    const result = clipped(value)
-    return { [key]: result.value, ...(result.truncated ? { truncated: true } : {}) }
+    return { [key]: text(value) }
   }
   function sanitize(event) {
     const p = event?.properties ?? event?.data ?? {}
@@ -30,7 +28,6 @@ export function createBridgeSanitizer(secrets = []) {
       if (!validBridgeID(info?.id)) return undefined
       if (info.role === "assistant") {
         assistants.set(info.id, sessionID)
-        if (assistants.size > 256) assistants.delete(assistants.keys().next().value)
       }
       return info.role === "assistant" ? { ...base, data: {
         messageID: info.id, completed: !!info.time?.completed, failed: !!info.error,