@volter-ai-dev/supercode-ui 0.1.65 → 0.1.66

package/README.md

@@ -243,6 +243,11 @@ heartbeat churn, treats compaction as a new baseline, and returns the delay for
 settlement timer. This keeps unread and finished semantics identical in an editor, extension,
 desktop app, or mobile companion without moving file persistence into the UI package.
 
+`createNativeMessengerState` wraps that ledger with bounded per-conversation drafts and per-harness
+Terminal/Headless preferences. It emits one serializable snapshot, so native hosts do not need to
+duplicate state parsing or coordinate several independent maps. The host still owns where that
+snapshot is stored, its debounce and encryption policy, and any multi-device synchronization.
+
 Native continuation exposes one action and a quiet execution-transport selector. A host with a real
 terminal provider can add `terminal` to `continuationModes` and handle `onResumeTerminal`; Terminal
 is then the initial choice and Headless remains available from the selector. The UI never infers

package/host.d.ts

@@ -109,6 +109,35 @@ export function createNativeSessionAttentionTracker(options?: {
   onChange?(state: NativeSessionAttentionTrackerState): void;
 }): NativeSessionAttentionTracker;
 
+export interface NativeMessengerStateSnapshot extends NativeSessionAttentionTrackerState {
+  drafts: Record<string, string>;
+  preferredLaunchModes: Record<string, 'headless' | 'terminal'>;
+}
+
+export function normalizeNativeMessengerState(value: unknown): NativeMessengerStateSnapshot;
+
+export class NativeMessengerState {
+  constructor(options?: {
+    state?: unknown;
+    onChange?(state: NativeMessengerStateSnapshot): void;
+  });
+  acknowledge(key: string): boolean;
+  observeAttention(options: NativeSessionAttentionObservation): {
+    attention: import('./index.js').SessionAttention[];
+    settleAfterMs: number | null;
+  };
+  draft(key: string): string;
+  setDraft(key: string, draft: string): boolean;
+  preferredLaunchMode(harness: string): 'headless' | 'terminal' | null;
+  setPreferredLaunchMode(harness: string, mode: 'headless' | 'terminal'): boolean;
+  snapshot(): NativeMessengerStateSnapshot;
+}
+
+export function createNativeMessengerState(options?: {
+  state?: unknown;
+  onChange?(state: NativeMessengerStateSnapshot): void;
+}): NativeMessengerState;
+
 export interface RemoteUiBindingOptions
   extends Pick<
     UiAdapter,

package/host.mjs

@@ -3,11 +3,18 @@ import { dispatchControllerIntent, projectClientSnapshot } from './controller.mj
 import { conversationPreviewText } from '@volter-ai-dev/supercode-client';
 
 const FRAME_SCHEMA = 'supercode.ui-host-state.v1';
+const NATIVE_STATE_LIMIT = 500;
 
 function objectRecord(value) {
   return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
 
+function setRecentBounded(map, key, value) {
+  map.delete(key);
+  map.set(key, value);
+  while (map.size > NATIVE_STATE_LIMIT) map.delete(map.keys().next().value);
+}
+
 function defaultInstanceId() {
   if (typeof globalThis.crypto?.randomUUID === 'function') return globalThis.crypto.randomUUID();
   return `host-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
@@ -325,10 +332,12 @@ export function createSessionAttentionTracker(options) {
 function nativeAttentionState(value) {
   const parsed = objectRecord(value);
   const attention = Array.isArray(parsed?.attention)
-    ? parsed.attention.slice(0, 500).flatMap((candidate) => {
+    ? parsed.attention.slice(0, NATIVE_STATE_LIMIT).flatMap((candidate) => {
         const item = objectRecord(candidate);
         if (
           typeof item?.key !== 'string' ||
+          !item.key ||
+          item.key.length > 200 ||
           !['unseen', 'finished', 'failed'].includes(item.kind)
         ) return [];
         return [{
@@ -349,7 +358,7 @@ function nativeAttentionState(value) {
   const cursors = objectRecord(parsed?.observedCursors);
   const observedCursors = cursors
     ? Object.fromEntries(
-        Object.entries(cursors).slice(0, 500).filter(
+        Object.entries(cursors).slice(0, NATIVE_STATE_LIMIT).filter(
           ([key, cursor]) => key.length <= 200 && typeof cursor === 'string' && cursor.length <= 200,
         ),
       )
@@ -434,7 +443,7 @@ export class NativeSessionAttentionTracker {
             runtimeStatus: row.runtimeStatus,
           });
           if (current.cursor !== null) {
-            this.#observedCursors.set(row.key, current.cursor);
+            setRecentBounded(this.#observedCursors, row.key, current.cursor);
             changed = true;
           }
           continue;
@@ -468,7 +477,7 @@ export class NativeSessionAttentionTracker {
       }
 
       if (prior.cursor !== null && this.#observedCursors.get(row.key) !== prior.cursor) {
-        this.#observedCursors.set(row.key, prior.cursor);
+        setRecentBounded(this.#observedCursors, row.key, prior.cursor);
         changed = true;
       }
       this.#observedUpdates.set(row.key, {
@@ -549,7 +558,7 @@ export class NativeSessionAttentionTracker {
       ...(boundedPreview ? { preview: boundedPreview } : {}),
     };
     if (JSON.stringify(prior) === JSON.stringify(next)) return false;
-    this.#attention.set(key, next);
+    setRecentBounded(this.#attention, key, next);
     return true;
   }
 
@@ -562,6 +571,120 @@ export function createNativeSessionAttentionTracker(options) {
   return new NativeSessionAttentionTracker(options);
 }
 
+export function normalizeNativeMessengerState(value) {
+  const parsed = objectRecord(value);
+  const attention = nativeAttentionState(parsed);
+  const draftRecord = objectRecord(parsed?.drafts);
+  const drafts = draftRecord
+    ? Object.fromEntries(
+        Object.entries(draftRecord).slice(0, NATIVE_STATE_LIMIT).flatMap(([key, draft]) =>
+          key && key.length <= 200 && typeof draft === 'string' && draft
+            ? [[key, draft.slice(0, 50_000)]]
+            : [],
+        ),
+      )
+    : {};
+  const modeRecord = objectRecord(parsed?.preferredLaunchModes);
+  const preferredLaunchModes = modeRecord
+    ? Object.fromEntries(
+        Object.entries(modeRecord).slice(0, NATIVE_STATE_LIMIT).filter(
+          ([key, mode]) =>
+            key && key.length <= 200 && (mode === 'headless' || mode === 'terminal'),
+        ),
+      )
+    : {};
+  return {
+    version: 1,
+    attention: attention.attention,
+    observedCursors: attention.observedCursors,
+    drafts,
+    preferredLaunchModes,
+  };
+}
+
+/** One serializable, bounded state owner for native-session messenger chrome. Storage location,
+ * encryption, debounce, and multi-device synchronization remain host policy. */
+export class NativeMessengerState {
+  #attention;
+  #drafts;
+  #onChange;
+  #preferredLaunchModes;
+
+  constructor(options = {}) {
+    const state = normalizeNativeMessengerState(options.state);
+    this.#onChange = options.onChange;
+    this.#drafts = new Map(Object.entries(state.drafts));
+    this.#preferredLaunchModes = new Map(Object.entries(state.preferredLaunchModes));
+    this.#attention = new NativeSessionAttentionTracker({
+      state,
+      onChange: () => this.#emit(),
+    });
+  }
+
+  observeAttention(options) {
+    return this.#attention.observe(options);
+  }
+
+  acknowledge(key) {
+    return this.#attention.acknowledge(key);
+  }
+
+  draft(key) {
+    return this.#drafts.get(key) ?? '';
+  }
+
+  setDraft(key, draft) {
+    if (typeof key !== 'string' || !key || key.length > 200 || typeof draft !== 'string') {
+      throw new TypeError('NativeMessengerState draft needs a bounded key and string value.');
+    }
+    const next = draft.slice(0, 50_000);
+    const previous = this.#drafts.get(key) ?? '';
+    if (previous === next) return false;
+    if (next) setRecentBounded(this.#drafts, key, next);
+    else this.#drafts.delete(key);
+    this.#emit();
+    return true;
+  }
+
+  preferredLaunchMode(harness) {
+    return this.#preferredLaunchModes.get(harness) ?? null;
+  }
+
+  setPreferredLaunchMode(harness, mode) {
+    if (
+      typeof harness !== 'string' ||
+      !harness ||
+      harness.length > 200 ||
+      (mode !== 'headless' && mode !== 'terminal')
+    ) {
+      throw new TypeError('NativeMessengerState launch preference must be headless or terminal.');
+    }
+    if (this.#preferredLaunchModes.get(harness) === mode) return false;
+    setRecentBounded(this.#preferredLaunchModes, harness, mode);
+    this.#emit();
+    return true;
+  }
+
+  snapshot() {
+    const attention = this.#attention.snapshot();
+    return {
+      version: 1,
+      attention: attention.attention,
+      observedCursors: attention.observedCursors,
+      drafts: Object.fromEntries(this.#drafts),
+      preferredLaunchModes: Object.fromEntries(this.#preferredLaunchModes),
+    };
+  }
+
+  #emit() {
+    this.#onChange?.(this.snapshot());
+  }
+}
+
+export function createNativeMessengerState(options) {
+  return new NativeMessengerState(options);
+}
+
 /** Browser binding for any transport that can post one intent and return an
  * optional authoritative frame. Local host actions may intercept an intent. */
 export function createRemoteUiBinding(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter-ai-dev/supercode-ui",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "type": "module",
   "description": "Composable default UI kit for Supercode-powered coding-agent experiences",
   "exports": {