dsh-cindy-host 0.1.26 → 0.1.27

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.27 — 2026-10-28
+
+- Implements current input-delivery v1 in Host: transactional complete-payload ownership before ACK, receipts, cancellation seals, authoritative clear boundaries, immutable logical identity and recoverable edits.
+- Adds real persistent around/around-client-id history with content bounds and confirmation-anchor-preserving frame degradation.
+- Uses public DSH flush and storage read checkpoints; a live claim/admission gap never authorizes replay. Verified dead-process/cold-owned-queue recovery is distinct from same-process reload.
+- Captures attachment bytes before handoff; no temporary file receipt or staging URL is treated as durable ownership.
+- Requires the verified DSH 0.2.1-rc.3 carrier and Node >=22.16; exact DSH peers prevent mixed-prerelease dependency graphs. Unsupported optional operations remain explicit refusals.
+- Retains editable names, desktop string queue content, production model/active-session features and optional keytar.
+- Upstream mobile outbox execution tests cover FIFO, lost ACK, cancellation and history-cache completion. Live handset acceptance remains a separate gate.
+
 ## 0.1.26 — 2026-10-28
 
 Host-only patch based on 0.1.25; retains its DSH 0.2 adapter, model catalog, active-session listing, optional keytar and bundle identity.

package/README.md

@@ -1,28 +1,29 @@
 # DSH Cindy Host
 
-A Host-side adapter connecting Cindy desktop and mobile clients to DeepSeek Harness.
+A Host-side adapter connecting current Cindy clients to DeepSeek Harness.
 
-## Install
+## Requirements and installation
 
-Requires Node.js 22 or newer. Use the DSH plugin manager, or:
+Version 0.1.27 targets the verified **DSH 0.2.1-rc.3** service contracts, with **Node.js >=22.16**. Its DSH peer versions are pinned to this carrier to prevent an installer from mixing a newer prerelease SDK into the running host. The verified Desktop runtime includes Node.js 24.21. Install through the Desktop DSH plugin manager. CLI-managed profiles can use:
 
 ```sh
-dsh plugin --profile desktop add dsh-cindy-host@0.1.26
+dsh plugin --profile <profile> add dsh-cindy-host@0.1.27
 ```
 
-Reload the Host plugin (or restart DSH) after installation, then refresh Settings → Cindy 手机连接. Keep your existing Cindy sign-in and device identity. Do not run two Host processes with the same device identity.
+Reload the Host plugin after installation. A full DSH restart is separate. Keep existing Cindy sign-in, device identity and settings; do not run two Host processes with the same identity.
 
-DSH provides its own session/settings services. DSH 0.1 and 0.2 paths are retained; this release is verified with the DSH 0.2.1-rc.3 desktop runtime. Optional keytar supports OS-backed credentials; without its native binary, sign-in reports an unavailable credential store instead of preventing mounting.
+## 0.1.27: current durable input delivery
 
-## 0.1.26
+- Implements input-delivery v1, not a legacy history-only fallback. Complete text and attachment bytes are held in a private, FULL-synchronous SQLite ledger **before enqueue acknowledgment**.
+- Provides per-clientId pending/accepted/removed/unknown receipts and real chronological around/around-client-id history. Accepted means a real user event was flushed and verified through public persistent storage, not an empty inbox or an in-memory event.
+- Serializes delivery and mutation, persists cancellation fences and clear boundaries, and keeps edited payloads recoverable. Existing editable Host names and the plain-text desktop queue fix remain.
+- Lost acknowledgments and same-process reloads cannot blindly replay an uncertain admission. A verified dead-process recovery may rebuild missing input; cold inbox wake-up requires verified ownership and preserved FIFO. Mixed/uncertain recovery remains pending with diagnostics rather than fabricating success or duplicate input.
+- The latest upstream mobile outbox implementation is exercised against Host RPC and SQLite, including same-session FIFO, ACK loss, cancellation, and its mandatory history-cache gate. This is not a claim of live handset acceptance.
 
-- Edit the Host display name in Settings → Cindy 手机连接 → 主机名称. Names are saved locally, support Unicode and are limited to 64 UTF-16 code units. Online names synchronize without forcing a relay reconnect. Local save and cloud sync are reported separately. Device ID and OS computer name do not change.
-- Queue UI content is plain text as expected by current Cindy rendering.
-- Recent durable-consumption evidence prevents late acknowledgments or stale snapshots from restoring already-consumed messages to pending/steering. This bounded record is per runtime, not a persistent message store.
-- Host status reports pluginVersion separately from its Cindy compatibility identity.
+The ledger lives under the active DSH profile state directory. Pending payloads and attachments are retained until persistent user-history verification or sealed cancellation; terminal identity fences do not expire silently. Do not delete state to repair an uncertain send. Back up that state before rollback: older Host releases cannot replay this ledger.
 
-These changes are Host-only; no modified Cindy client is required. Advanced optional features remain unavailable rather than returning fabricated success. Automated checks are not a claim that every new-client feature is supported or every live incident is resolved.
+All changes are Host-only: no Cindy or DSH core patch is required. The handshake compatibility stamp is separate from the actual plugin version and explicit v1 capability. Unsupported optional features are refused; this is not a promise of all native Cindy features or exactly-once external tool effects.
 
-## Rollback
+## Previous release and rollback
 
-Reinstall dsh-cindy-host@0.1.25 and reload the Host plugin. Preserve profile settings, device ID and the OS credential store.
+0.1.26 added editable, locally persistent Host names and desktop-safe plain-text queue content. Reinstalling 0.1.26 is possible, but pause input first and preserve the 0.1.27 ledger: downgrading disables durable-input recovery until 0.1.27 is restored.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-cindy-host",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "private": false,
   "description": "Cindy 手机客户端连接 DSH 的 Host 侧插件：会话/消息/审批/todo/goal 的手机通道，以及配套的设置卡片",
   "license": "MIT",
@@ -16,7 +16,7 @@
     "device-link"
   ],
   "engines": {
-    "node": ">=22"
+    "node": ">=22.16.0"
   },
   "//files": "白名单，而非整个目录：.sandbox/（含凭据与会话）、.claw/runtime、验收日志、开发记录都不进包。见 doc/publishing.md §3。",
   "files": [
@@ -71,8 +71,8 @@
   },
   "//peerDependencies": "DSH 自己的包必须由宿主提供，绝不能声明成 dependency/optionalDependency：pnpm 会把它们**连同整代依赖图**装进 profile，宿主再组合这个混合体就起不来（实测：`^0.1.1-rc.2` 会把 28 个 0.1.1-rc.2 的包装进一个 0.1.5-rc.2 的宿主，profile 启动失败于 dsh-client-file-upload / dsh-session）。区间必须覆盖宿主那一代（semver 的预发布规则：`^0.1.1-rc.2` 匹配不到 `0.1.5-rc.2`），与生态里 dsh-codex / dsh-cost-meter 的写法一致；`0.2.0-rc.2` 需要 `>=0.2.0-rc.1 <0.3.0-0`。",
   "peerDependencies": {
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.2 || ^0.1.5-rc.2 || >=0.2.0-rc.1 <0.3.0-0",
-    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2 || ^0.1.5-rc.2 || >=0.2.0-rc.1 <0.3.0-0",
+    "@deepseek-ai/dsh-session": "0.2.1-rc.3",
+    "@deepseek-ai/dsh-settings": "0.2.1-rc.3",
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "//peerDependenciesMeta": "**故意没有这个字段。** `@deepseek-ai/dsh-host-apiproxy` 曾经在这里标 optional，但 0.2 已经删掉了这个包，而 `evaluatePluginCompatibility` 会遍历 `peerDependencies` 的**每一个键且不查 `peerDependenciesMeta`**，所以只要它出现在 peers 里，`dsh plugin add` 就会直接拒绝安装（`installation rejected`），启动时 bundle 也会被静默跳过、`dsh-cindy-host` 行根本不会出现。该适配器本来就走惰性 `require` + 失败降级（见 src/dsh-plugin.js 的 apiProxy 分支），从 peers 里移除不改变任何运行时行为，只是让两道门禁都能正确判定。",

package/src/cindy-channels.js

@@ -9,10 +9,9 @@
  *
  * Everything outside that subset answers `CHANNEL_NOT_ALLOWED`, which is exactly
  * what a Cindy controlled device answers for a channel it does not serve. That
- * is a feature of the protocol: the controller treats it as "this device has no
- * such capability" and degrades, rather than waiting for a reply that never
- * comes. A channel we silently accepted and then failed would be worse — the
- * phone would show a broken feature instead of an absent one.
+ * is a permanent refusal, not proof of a working fallback. Only optional
+ * features with a verified caller fallback may use that boundary; the latest
+ * default input/durable-outbox path must be implemented end to end.
  */
 import { agentKindForModel, toCindyActiveSessions, toCindySessionList, toCindySessionListRow } from './cindy-session-row.js';
 import { toAgentCapabilities, toCindyPermissionMode, toDshPermissionMode, toNewMakerDefaults, toPermissionOptions, toProviderList } from './host-models.js';
@@ -20,6 +19,12 @@ import { queueItemsFromInbox } from './host-input-queue.js';
 import { toAgentSkills, toAgentCommands, toAtResources } from './host-palette.js';
 import { toGoalStatusPayload } from './host-goals.js';
 import { hostAttachmentsOf } from './host-attachments.js';
+import { historyLocateOptions, locateCommittedMessages, capReferenceRows } from './host-history-locate.js';
+
+async function deliveryReply(request, operation) {
+  try { return invokeResult(request, await operation()); }
+  catch (error) { return invokeError(request, typeof error?.code === 'string' ? error.code : 'DELIVERY_FAILURE', String(error?.message ?? error)); }
+}
 
 /** The phone's own unsubscribe channel, paired with subscribe. */
 const SUBSCRIBE = 'device-link:subscribe';
@@ -211,6 +216,8 @@ export const SUPPORTED_CHANNELS = Object.freeze([
   'local-db:sessions:list',
   'local-db:sessions:get',
   'local-db:messages:list',
+  'local-db:messages:around',
+  'local-db:messages:around-client-id',
   'local-db:sessions:patch-meta',
   'maker:create-session',
   'maker:send',
@@ -629,6 +636,24 @@ export function createChannelRouter({
       return invokeResult(request, row);
     }
 
+    if (channel === 'local-db:messages:around' || channel === 'local-db:messages:around-client-id') {
+      const capabilities = capabilitiesNow();
+      if (typeof args[0] !== 'string' || !args[0] || typeof args[1] !== 'string' || !args[1]) return invokeError(request, 'INVALID_PARAMS', 'sessionId and message identity must be nonempty strings');
+      const sessionId = args[0];
+      if (capabilities.sessionHidden?.(sessionId) === true) return invokeError(request, 'NOT_FOUND', 'Session does not exist');
+      if (typeof capabilities.readAllMessages !== 'function') return invokeError(request, 'NOT_AVAILABLE', 'This Host cannot read committed message history');
+      try {
+        const byClientId = channel === 'local-db:messages:around-client-id';
+        const options = historyLocateOptions(byClientId ? args[2] : {radius: args[2]?.radius});
+        const rows = locateCommittedMessages(await capabilities.readAllMessages(sessionId), {sessionId, identity: args[1], byClientId, radius: options.radius});
+        const hydrated = typeof capabilities.hydrateImages === 'function' ? await capabilities.hydrateImages(rows) : rows;
+        return invokeResult(request, capReferenceRows(hydrated, options.contentCharLimit));
+      } catch (error) {
+        if (error?.code === 'NOT_FOUND' || error?.code === 'INVALID_PARAMS' || error?.code === 'NOT_AVAILABLE') return invokeError(request, error.code, error.message);
+        throw error;
+      }
+    }
+
     if (channel === 'local-db:messages:list') {
       const sessionId = String(args[0] ?? '');
       const read = capabilitiesNow().readMessages;
@@ -1081,6 +1106,12 @@ export function createChannelRouter({
       const sessionId = String(args[0] ?? '');
       if (sessionId === '') return invokeError(request, 'BAD_REQUEST', `${channel} needs a session id`);
 
+      if (typeof capabilities.inputDelivery === 'function') {
+        let delivery;
+        try { delivery = capabilities.inputDelivery(); } catch (error) { return deliveryReply(request, () => { throw error; }); }
+        if (delivery) return deliveryReply(request, () => channel === 'maker:input:steer' ? delivery.steer(sessionId, args[1], args[2] ?? {}) : delivery.accept(sessionId, args[1], args[2] ?? {}));
+      }
+
       // A `steer` naming an item DSH already holds is a **promotion** of that
       // queued item, not a new message: the controller sends the queued row back
       // with `removeFromQueue`. Re-sending its text would duplicate it, which is
@@ -1288,6 +1319,19 @@ export function createChannelRouter({
       const control = capabilities.queueControl;
       const clientId = typeof args[1] === 'string' ? args[1] : (typeof args[1]?.clientId === 'string' ? args[1].clientId : null);
 
+      let durableQueue = null;
+      if (typeof capabilities.inputDelivery === 'function') {
+        try { durableQueue = capabilities.inputDelivery(); } catch (error) { return deliveryReply(request, () => { throw error; }); }
+      }
+      if (durableQueue && ['maker:input:remove', 'maker:input:clear-session', 'maker:input:update-text', 'maker:input:update-content'].includes(channel)) {
+        return deliveryReply(request, async () => {
+          const delivery = durableQueue;
+          if (channel === 'maker:input:clear-session') return delivery.clear(sessionId);
+          if (channel === 'maker:input:remove') return delivery.cancel(sessionId, clientId);
+          return delivery.edit(sessionId, clientId, args[2]);
+        });
+      }
+
       // Controller-owned queue UI state. The controller sets it here and reads it
       // back out of the projection, so it must be recorded rather than ignored.
       if (channel === 'maker:input:set-expanded') {
@@ -1318,7 +1362,7 @@ export function createChannelRouter({
         // is exactly what the controller asks for: it only ever sends
         // `keepQueue: true` (see `stopOptionsForProjection`).
         try {
-          control.cancel({ sessionId });
+          await control.cancel({ sessionId });
         } catch (error) {
           return invokeError(request, 'THREW', String(error?.message ?? error));
         }
@@ -1406,6 +1450,9 @@ export function createChannelRouter({
       const sessionId = String(args[0] ?? '');
       const clientId = typeof args[1] === 'string' ? args[1] : null;
       if (sessionId === '' || clientId === null) return invokeError(request, 'BAD_REQUEST', 'maker:input:move needs a session and an item id');
+      if (typeof capabilities.inputDelivery === 'function') {
+        try { if (capabilities.inputDelivery()) return invokeError(request, 'NOT_AVAILABLE', 'DSH has no public durable inbox reorder operation'); } catch (error) { return deliveryReply(request, () => { throw error; }); }
+      }
       // Reordering is presentation: DSH's inbox keeps its own order and a
       // reordered row would snap back on the next frame, so this Host records
       // the new order locally and says nothing it cannot keep.
@@ -1433,6 +1480,12 @@ export function createChannelRouter({
       const clientId = typeof args[1]?.clientId === 'string' && args[1].clientId !== ''
         ? args[1].clientId
         : (typeof args[2]?.clientId === 'string' && args[2].clientId !== '' ? args[2].clientId : null);
+      const capabilities = capabilitiesNow();
+      if (typeof capabilities.inputDelivery === 'function') {
+        let delivery;
+        try { delivery = capabilities.inputDelivery(); } catch (error) { return deliveryReply(request, () => { throw error; }); }
+        if (delivery) return deliveryReply(request, async () => { await delivery.accept(sessionId, { clientId: clientId ?? request.id, text: text ?? '', files: sendAttachments }, args[2] ?? {}); return { accepted: true }; });
+      }
       const sent = await send({
         sessionId,
         text: text ?? '',
@@ -1577,6 +1630,11 @@ export function createChannelRouter({
     if (channel === 'maker:input:get-projection') {
       const capabilities = capabilitiesNow();
       const sessionId = String(args[0] ?? '');
+      if (typeof capabilities.inputDelivery === 'function') {
+        let delivery;
+        try { delivery = capabilities.inputDelivery(); } catch (error) { return deliveryReply(request, () => { throw error; }); }
+        if (delivery) return deliveryReply(request, () => delivery.projection(sessionId, args[1]));
+      }
       // Read what DSH actually holds before falling back to the fold: a fold that
       // never heard a `queue` frame reports an empty queue, which is how the
       // controller came to keep a 队列中 row for a message the agent had answered.

package/src/dsh-input-delivery.js

@@ -0,0 +1,86 @@
+import { createAttachmentMaterializer, hostAttachmentsOf } from './host-attachments.js';
+import { foldSessionEvent } from './dsh-message-fold.js';
+import { queuedRowFromController } from './host-input-queue.js';
+import { deliveryError } from './host-input-delivery-store.js';
+
+/** Replay only a validated persisted prefix. A claim removal is not a user receipt. */
+export function durableInputEvidence(events,sessionId) {
+  const queues={'next-turn':[],'next-step':[]};const users=[];
+  if(!Array.isArray(events))throw deliveryError('DELIVERY_EVIDENCE_UNAVAILABLE','Stored session log has no event array');
+  for(let i=0;i<events.length;i++){
+    const event=events[i];if(event.seq!==i)throw deliveryError('DELIVERY_EVIDENCE_CORRUPT','Stored session prefix is not contiguous');
+    if(event.type==='agent/inbox/spliced'){
+      const s=event.data;const previous=queues[s?.target];const count=s?.removedCount??0;
+      if(!previous||!Number.isSafeInteger(s.start)||s.start<0||s.start>previous.length||!Number.isSafeInteger(count)||count<0||s.start+count>previous.length||!Array.isArray(s.inserted))throw deliveryError('DELIVERY_EVIDENCE_CORRUPT','Stored inbox splice is invalid');
+      const next=[...previous];next.splice(s.start,count,...s.inserted);queues[s.target]=next;
+      const ids=[...queues['next-turn'],...queues['next-step']].map(m=>m.id);if(ids.some(id=>typeof id!=='string'||!id)||new Set(ids).size!==ids.length)throw deliveryError('DELIVERY_EVIDENCE_CORRUPT','Stored inbox identities are invalid');
+    }
+    const source=event.data?.source;
+    if(event.type==='user/message'&&source?.kind==='user'&&typeof source.rpcId==='string'&&source.rpcId)users.push({clientId:source.rpcId,seq:event.seq});
+  }
+  const inbox=Object.entries(queues).flatMap(([placement,items])=>items.map(message=>({id:message.id,clientId:message.source?.kind==='user'&&typeof message.source.rpcId==='string'?message.source.rpcId:message.id,placement,message,foreign:message.source?.kind!=='user'})));
+  return {sessionId,users,inbox,throughSeq:events.length-1};
+}
+export function createDshInputDeliveryBackend({getServices,sessionController,getSession}){
+  let active=true;
+  function services(){if(!active)throw deliveryError('DELIVERY_BACKEND_STOPPED','Input delivery service was detached');const s=getServices();if(!s.sessions||typeof s.sessions.flush!=='function'||!s.persistence||typeof s.persistence.open!=='function')throw deliveryError('DELIVERY_NOT_AVAILABLE','Durable DSH session services are not mounted');return s;}
+  async function readLog(sid){
+    const s=services();const live=s.sessions.get(sid);
+    if(live && !await s.sessions.flush(live))throw deliveryError('DELIVERY_DURABILITY_UNAVAILABLE','No session durability listener participated');
+    const handle=await s.persistence.open(sid,'read',{signal:AbortSignal.timeout(30000)});
+    try{const result=await handle.read(0,Number.MAX_SAFE_INTEGER,{signal:AbortSignal.timeout(30000)});const events=result.events;durableInputEvidence(events,sid);return events;}finally{await handle.close();}
+  }
+  async function agentFor(sid){const resolved=await sessionController.resolveAgent(sid);if(resolved?.error)throw resolved.error;if(!resolved?.agent)throw deliveryError('DELIVERY_AGENT_UNAVAILABLE','DSH did not resolve an agent');return resolved.agent;}
+  async function flush(sid){const s=services();const session=s.sessions.get(sid);if(!session||!await s.sessions.flush(session))throw deliveryError('DELIVERY_DURABILITY_UNAVAILABLE','Cannot verify the DSH mutation durability');}
+  const backend={
+    available(){try{services();return true;}catch{return false;}},
+    stop(){active=false;},
+    async readRows(sid){const events=await readLog(sid);const rows=[];for(const event of events){const folded=foldSessionEvent(event,{sessionId:sid});folded.forEach((row,index)=>{const rowid=event.seq*65536+index;if(!Number.isSafeInteger(rowid))throw deliveryError('DELIVERY_EVIDENCE_CORRUPT','Message order exceeds the safe protocol range');rows.push({...row,rowid});});}return rows.reverse();},
+    async evidence(sid){const events=await readLog(sid);const proof=durableInputEvidence(events,sid);const agent=getServices().agents?.get(sid);return {...proof,running:agent?.status==='running',live:agent!==undefined};},
+    async prepare(sid,row,{resolveAttachmentRef,mode='queue'}={}){
+      services();const session=await getSession(sid);if(!session)throw deliveryError('NOT_FOUND','Session does not exist');
+      const incoming=hostAttachmentsOf(row);if(Array.isArray(row.files)&&incoming.length!==row.files.length)throw deliveryError('ATTACHMENT_UNAVAILABLE','Every submitted attachment must be persistently obtainable');
+      const text=typeof row.text==='string'?row.text:'';if(!text.trim()&&!incoming.length)throw deliveryError('BAD_REQUEST','Input has no text or attachment');
+      const materializer=createAttachmentMaterializer({fileSystem:getServices().fileSystem,resolveAttachmentRef,captureOnly:true});
+      const owned=await materializer.materialize({attachments:incoming,signal:AbortSignal.timeout(30000)});
+      if(owned.dropped.length)throw deliveryError('ATTACHMENT_UNAVAILABLE','Cannot durably receive all attachments: '+owned.dropped.map(x=>x.reason).join(', '));
+      const queued=queuedRowFromController({clientId:row.clientId,text,session});if(!queued)throw deliveryError('DELIVERY_SESSION_UNAVAILABLE','Session working directory is unavailable');
+      return {payload:{text,assets:owned.parts,consumed:owned.consumed,mode},queued:{...queued,files:incoming,chatMessage:{...queued.chatMessage,...(row.chatMessage?.images?{images:row.chatMessage.images}:{})}}};
+    },
+    async dispatch(entry,{releaseAttachmentRef}={}){
+      let agent;
+      try{agent=await agentFor(entry.sessionId);}catch(error){error.deliveryNotAdmitted=true;throw error;}
+      const content=entry.payload.text?[{type:'text',text:entry.payload.text}]:[];
+      for(const asset of entry.payload.assets??[]){
+        if(asset.mediaType)content.push({type:'image',mediaType:asset.mediaType,data:asset.data,name:asset.name});
+        else {try{const uploads=getServices().fileUploads;if(typeof uploads?.upload!=='function')throw deliveryError('ATTACHMENT_UNAVAILABLE','File upload service is unavailable');const uploaded=await uploads.upload(agent,{data:asset.data,name:asset.name},AbortSignal.timeout(30000));if(!uploaded?.receiptId)throw deliveryError('ATTACHMENT_UNAVAILABLE','No file receipt was created');content.push({type:'file',receiptId:uploaded.receiptId});}catch(error){error.deliveryNotAdmitted=true;throw error;}}
+      }
+      // Do not interpret an aborted signal as proof that admission did not happen.
+      const mode=entry.payload.mode==='steer'&&agent.status==='running'?'steer':'queue';
+      try{await sessionController.prompt({sessionId:entry.sessionId,requestId:entry.clientId,mode,content},AbortSignal.timeout(30000));}
+      catch(error){
+        const trace=agent.session.snapshotEvents().some(event=>event.type==='user/message'&&event.data?.source?.rpcId===entry.clientId || event.type==='agent/inbox/spliced'&&event.data?.inserted?.some(message=>message.source?.rpcId===entry.clientId));
+        if(!trace){error.deliveryNotAdmitted=true;if(mode==='steer')error.deliveryRetryMode='queue';}
+        throw error;
+      }
+      await flush(entry.sessionId);await readLog(entry.sessionId);
+      for(const key of entry.payload.consumed??[])if(typeof releaseAttachmentRef==='function')void releaseAttachmentRef(key).catch(()=>{});
+    },
+    async promote(sid,itemId){await sessionController.updateQueue({sessionId:sid,itemId,action:{kind:'steer'}});await flush(sid);await readLog(sid);},
+    async remove(sid,itemId){
+      await sessionController.updateQueue({sessionId:sid,itemId,action:{kind:'remove'}});
+      try{await flush(sid);await readLog(sid);}catch(error){error.deliveryRemovalApplied=true;throw error;}
+    },
+    async recoverColdInbox(sid,entries){
+      const initial=await backend.evidence(sid);if(initial.running||initial.inbox.some(item=>item.foreign))return false;
+      const owned=new Map(entries.filter(e=>e.payload&&e.phase!=='accepted'&&e.phase!=='removed').map(e=>[e.clientId,e]));
+      if(initial.inbox.some(item=>!owned.has(item.clientId)))return false;
+      const order=initial.inbox.map(x=>owned.get(x.clientId).ordinal);if(order.some((n,i)=>i>0&&n<order[i-1]))return false;
+      const agent=await agentFor(sid);if(agent.status==='running')return false;
+      // A public remove+durable checkpoint before re-admission is the only verified wake compensation.
+      for(const item of initial.inbox){if(agent.status==='running')throw deliveryError('DELIVERY_RECOVERY_WAITING','Agent became active during cold queue recovery');await backend.remove(sid,item.id);}
+      const after=await backend.evidence(sid);return !after.running&&!after.inbox.length;
+    },
+  };
+  return backend;
+}

package/src/dsh-plugin.js

@@ -1,5 +1,8 @@
 import Schema from '@deepseek-ai/schemastery';
 import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createDshInputDeliveryBackend } from './dsh-input-delivery.js';
 import { DEFAULT_HOST_SETTINGS, SETTINGS_NAMESPACE, validateHostSettings } from './host-settings.js';
 import { DshHostSource } from './dsh-host-source.js';
 import { createSessionControllerSource } from './dsh-session-source.js';
@@ -654,10 +657,21 @@ export function buildDshSource(ctx, serviceName, options = {}) {
      * (`readMessages.all`), so the two views can never disagree about what the session
      * contains — and neither of them re-reads the log to answer.
      */
+    const deliveryServices = { sessions: undefined, persistence: undefined, agents: undefined };
+    ctx.inject(['sessions', 'sessionPersistence', 'agents'], deliveryCtx => {
+      deliveryServices.sessions = deliveryCtx.get('sessions'); deliveryServices.persistence = deliveryCtx.get('sessionPersistence'); deliveryServices.agents = deliveryCtx.get('agents');
+      return () => { deliveryServices.sessions = undefined; deliveryServices.persistence = undefined; deliveryServices.agents = undefined; };
+    });
+    const inputDeliveryBackend = createDshInputDeliveryBackend({
+      getServices: () => ({ ...deliveryServices, fileSystem: ctx.get('fs'), fileUploads: controls.fileUploads }),
+      sessionController,
+      getSession: (sessionId) => sessionSource.getSession(sessionId),
+    });
+    const committedRows = (sessionId) => inputDeliveryBackend.available() ? inputDeliveryBackend.readRows(sessionId) : readMessages.all(sessionId);
     const historyView = readMessages === undefined
       ? undefined
       : createHistoryViewController({
-        rows: (sessionId) => readMessages.all(sessionId),
+        rows: committedRows,
         // The turn state has to be **wired** here; the controller's own default is `() => false`.
         // That default is why a running turn was never marked `isStreaming`, which cost two things
         // at once and looked like a client problem both times: the phone drew no live card, and
@@ -708,6 +722,8 @@ export function buildDshSource(ctx, serviceName, options = {}) {
     return {
       kind: 'session-controller',
       readMessages,
+      readAllMessages: readMessages === undefined ? undefined : committedRows,
+      inputDeliveryBackend,
       countMessages,
       historyView,
       // Reported through the status route: "the photo does not render" has three
@@ -1345,6 +1361,8 @@ export function buildDiagnostics({ runtime, sourceKind, seam, listingDiagnostics
 export function capabilityProvider(sources) {
   return {
     readMessages: sources.readMessages,
+    readAllMessages: sources.readAllMessages,
+    inputDeliveryBackend: sources.inputDeliveryBackend,
     countMessages: sources.countMessages,
     // The work-grouped history window the controller reaches for once it has seen
     // `history-view-v1`; without this forwarding the three channels would answer
@@ -1726,6 +1744,7 @@ export function apply(ctx, config) {
       // The controller's archive/delete/pin writes go straight to this plugin's
       // settings section, so the whole flag store reloads with the process.
       persistSessionFlags: sessionFlagsWriter(ctx.settings, settingsNamespace(SETTINGS_NAMESPACE)),
+      inputDeliveryDirectory: join(process.env.DSH_PROFILE_DIR || join(process.env.DSH_HOME || join(homedir(), '.dsh'), 'profiles', process.env.DSH_PROFILE || 'desktop'), 'state', 'dsh-cindy-host'),
     });
     // Settings can change while startHost awaits authentication. Reconcile the
     // latest snapshot after the runtime exists instead of dropping that update.

package/src/host-attachments.js

@@ -87,7 +87,7 @@ export function imageMediaTypeOf(attachment) {
  *   `consumed` being the staging keys whose bytes were taken, for the caller to
  *   release once the prompt has landed.
  */
-export function createAttachmentMaterializer({ fileSystem, fileUploads, resolveAttachmentRef, maxBytes = MAX_ATTACHMENT_BYTES } = {}) {
+export function createAttachmentMaterializer({ fileSystem, fileUploads, resolveAttachmentRef, maxBytes = MAX_ATTACHMENT_BYTES, captureOnly = false } = {}) {
   /** Read one whole file through the composed filesystem, or say why not. */
   async function readWholeFile(path) {
     if (fileSystem === undefined || fileSystem === null) return { ok: false, reason: 'no-filesystem' };
@@ -125,6 +125,7 @@ export function createAttachmentMaterializer({ fileSystem, fileUploads, resolveA
    * depend on where the bytes came from.
    */
   async function partFor({ buffer, name, mediaType, agent, signal }) {
+    if (captureOnly) return { part: { name, mediaType, data: buffer.toString('base64') } };
     if (mediaType !== null) return { part: { type: 'image', mediaType, data: buffer.toString('base64'), name } };
     if (typeof fileUploads?.upload !== 'function') return { dropped: 'no-upload-service' };
     try {

package/src/host-frame-budget.js

@@ -275,7 +275,18 @@ export function fitInvokeResultToFrame({ reply, request, channel, budgetBytes =
   }
   const placeholders = placeholderRows(rows);
   for (let keep = placeholders.length - 1; keep > 0; keep -= 1) {
-    const sliced = sliceRowsAtMessageBoundary(placeholders, keep);
+    let sliced;
+    if (channel === 'local-db:messages:around' || channel === 'local-db:messages:around-client-id') {
+      const identity = request?.payload?.args?.[1];
+      const anchor = placeholders.findIndex(row => (channel.endsWith('around-client-id') ? row?.clientId : row?.id) === identity);
+      if (anchor < 0) break;
+      let from = Math.max(0, Math.min(anchor - Math.floor((keep - 1) / 2), placeholders.length - keep));
+      let to = from + keep;
+      const same = (a, b) => typeof a?.id === 'string' && typeof b?.id === 'string' && /:[0-9]+$/.test(a.id) && /:[0-9]+$/.test(b.id) && a.id.replace(/:[0-9]+$/, '') === b.id.replace(/:[0-9]+$/, '');
+      while (from > 0 && same(placeholders[from - 1], placeholders[from])) from--;
+      while (to < placeholders.length && same(placeholders[to - 1], placeholders[to])) to++;
+      sliced = placeholders.slice(from, to);
+    } else sliced = sliceRowsAtMessageBoundary(placeholders, keep);
     const trimmed = sliced.map((row) => (row === null || typeof row !== 'object' ? row : { ...row, agentMeta: markRowsTrimmed(row.agentMeta, placeholders.length) }));
     const payload = { ...original, result: trimmed };
     const bytes = measure(payload);

package/src/host-history-locate.js

@@ -0,0 +1,39 @@
+/** Latest Cindy around/around-client-id contract over the one committed transcript. */
+function fail(code, message) { throw Object.assign(new Error(message), { code }); }
+export function historyLocateOptions(options = {}) {
+  const value = Number(options?.radius);
+  const radius = !Number.isFinite(value) || value < 0 ? 60 : Math.min(Math.floor(value), 200);
+  const limit = options?.contentCharLimit ?? null;
+  if (limit !== null && (typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1 || limit > 8000)) fail('INVALID_PARAMS', 'contentCharLimit must be an integer between 1 and 8000 or null');
+  return { radius, contentCharLimit: limit };
+}
+export function locateCommittedMessages(rows, { sessionId, identity, byClientId, radius, clearBoundaryMs = null }) {
+  if (!Array.isArray(rows)) fail('NOT_AVAILABLE', 'Committed message history is unavailable');
+  const ordered = rows.map((row, index) => ({ row, rank: Number.isFinite(row?.rowid) ? row.rowid : rows.length - index }))
+    .filter(({row}) => row && (row.sessionId === undefined || row.sessionId === sessionId) && row.rewindAt == null && (clearBoundaryMs === null || Date.parse(row.createdAt) > clearBoundaryMs))
+    .sort((a,b) => Date.parse(a.row.createdAt) - Date.parse(b.row.createdAt) || a.rank - b.rank);
+  const at = ordered.findIndex(({row}) => (byClientId ? row.clientId : row.id) === identity);
+  if (at < 0) fail('NOT_FOUND', 'Message does not exist in this session');
+  return ordered.slice(Math.max(0, at-radius), at+radius+1).map(({row})=>row);
+}
+function preview(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) return content.map(part => typeof part === 'string' ? part : part?.type === 'text' && typeof part.text === 'string' ? part.text : '').filter(Boolean).join(String.fromCharCode(10));
+  if (content && typeof content === 'object') { if(typeof content.text === 'string')return content.text; if(typeof content.content === 'string')return content.content; }
+  return JSON.stringify(content) ?? '';
+}
+function omitsData(content) {
+  if (Array.isArray(content)) return content.some(part => typeof part !== 'string' && !(part && typeof part === 'object' && part.type === 'text' && typeof part.text === 'string'));
+  if (!content || typeof content !== 'object') return false;
+  if (typeof content.text !== 'string' && typeof content.content !== 'string') return true;
+  return content.quotesEncoded === true || ['images','files','sessionReferences','pastedTextRanges','slashCommandRanges'].some(key=>Array.isArray(content[key]) && content[key].length>0);
+}
+export function capReferenceRows(rows, limit) {
+  if(limit === null)return rows;
+  return rows.map(row=>{const text=preview(row.content);const lossy=text.length>limit || omitsData(row.content);
+    if(!lossy)return typeof row.content === 'string' ? row : {...row,content:text};
+    const content=text.length<=limit ? text : limit===1 ? '…' : '…'+text.slice(-(limit-1));
+    const prior=row.agentMeta && typeof row.agentMeta==='object' && !Array.isArray(row.agentMeta) ? row.agentMeta : {};
+    return {...row,content,agentMeta:{...prior,remoteContentTruncated:true}};
+  });
+}

package/src/host-input-delivery-store.js

@@ -0,0 +1,57 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname, isAbsolute } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const epochKey = Symbol.for('dsh-cindy-host.process-epoch');
+export const INPUT_PROCESS_EPOCH = globalThis[epochKey] ??= randomUUID();
+export function deliveryError(code, message) { return Object.assign(new Error(message), {code}); }
+function processAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (error) { if(error.code === 'ESRCH') return false; return true; }
+}
+/** A private, single-writer FULL-synchronous ledger. No input or tombstone expires implicitly. */
+export function openInputDeliveryStore({ file, namespace, epoch=INPUT_PROCESS_EPOCH, pid=process.pid, isAlive=processAlive }) {
+  if(!isAbsolute(file) || typeof namespace !== 'string' || !namespace) throw new TypeError('An absolute delivery database path and owner namespace are required');
+  mkdirSync(dirname(file), {recursive:true,mode:0o700});
+  const db = new DatabaseSync(file);
+  const owner = randomUUID();
+  let closed=false, inTransaction=false;
+  try {
+    db.exec('PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA foreign_keys=ON;');
+    const version=db.prepare('PRAGMA user_version').get().user_version;
+    if(version!==0 && version!==1) throw deliveryError('DELIVERY_SCHEMA_UNSUPPORTED','Unsupported input delivery database version');
+    db.exec('CREATE TABLE IF NOT EXISTS owner (singleton INTEGER PRIMARY KEY CHECK(singleton=1), instance TEXT NOT NULL, epoch TEXT NOT NULL, pid INTEGER NOT NULL); CREATE TABLE IF NOT EXISTS sessions (namespace TEXT NOT NULL, session_id TEXT NOT NULL, boundary INTEGER, PRIMARY KEY(namespace,session_id)); CREATE TABLE IF NOT EXISTS inputs (ordinal INTEGER PRIMARY KEY AUTOINCREMENT, namespace TEXT NOT NULL, session_id TEXT NOT NULL, client_id TEXT NOT NULL, data TEXT NOT NULL, UNIQUE(namespace,session_id,client_id)); PRAGMA user_version=1;');
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      const previous=db.prepare('SELECT * FROM owner WHERE singleton=1').get();
+      if(previous && (previous.pid===pid ? previous.epoch===epoch : isAlive(previous.pid))) throw deliveryError('DELIVERY_OWNER_ACTIVE','Another live Host still owns the input delivery database');
+      db.prepare('INSERT OR REPLACE INTO owner VALUES (1,?,?,?)').run(owner,epoch,pid);
+      db.exec('COMMIT');
+    } catch(error) { db.exec('ROLLBACK'); throw error; }
+  } catch(error) {db.close();throw error;}
+  function guard() {
+    if(closed)throw deliveryError('DELIVERY_STORE_CLOSED','Input delivery store is closed');
+    if(db.prepare('SELECT instance FROM owner WHERE singleton=1').get()?.instance!==owner)throw deliveryError('DELIVERY_OWNER_LOST','Input delivery writer ownership was replaced');
+  }
+  function writeGuard(){guard();if(!inTransaction)throw new Error('Delivery mutation requires a transaction');}
+  const store={
+    epoch,pid,
+    transaction(fn){
+      guard();if(inTransaction)throw new Error('Nested delivery transaction');
+      db.exec('BEGIN IMMEDIATE');inTransaction=true;
+      try {guard();const result=fn(store);if(result && typeof result.then==='function')throw new Error('Delivery transactions must be synchronous');db.exec('COMMIT');return result;}
+      catch(error){db.exec('ROLLBACK');throw error;}finally{inTransaction=false;}
+    },
+    boundary(sessionId){guard();return db.prepare('SELECT boundary FROM sessions WHERE namespace=? AND session_id=?').get(namespace,sessionId)?.boundary??null;},
+    setBoundary(sessionId,boundary){writeGuard();db.prepare('INSERT INTO sessions VALUES (?,?,?) ON CONFLICT(namespace,session_id) DO UPDATE SET boundary=excluded.boundary').run(namespace,sessionId,boundary);},
+    get(sessionId,clientId){guard();const row=db.prepare('SELECT ordinal,data FROM inputs WHERE namespace=? AND session_id=? AND client_id=?').get(namespace,sessionId,clientId);return row?{...JSON.parse(row.data),ordinal:row.ordinal}:null;},
+    list(sessionId){guard();return db.prepare('SELECT ordinal,data FROM inputs WHERE namespace=?'+(sessionId===undefined?'':' AND session_id=?')+' ORDER BY ordinal').all(...(sessionId===undefined?[namespace]:[namespace,sessionId])).map(row=>({...JSON.parse(row.data),ordinal:row.ordinal}));},
+    put(entry){
+      writeGuard();const {ordinal,...value}=entry;const data=JSON.stringify(value);
+      if(Buffer.byteLength(data)>64*1024*1024)throw deliveryError('DELIVERY_TOO_LARGE','Input exceeds the durable storage limit');
+      db.prepare('INSERT INTO inputs(namespace,session_id,client_id,data) VALUES (?,?,?,?) ON CONFLICT(namespace,session_id,client_id) DO UPDATE SET data=excluded.data').run(namespace,value.sessionId,value.clientId,data);
+    },
+    close(){if(closed)return;guard();db.prepare('DELETE FROM owner WHERE singleton=1 AND instance=?').run(owner);db.close();closed=true;},
+  };
+  return store;
+}

package/src/host-input-delivery.js

@@ -0,0 +1,158 @@
+import { createHash } from 'node:crypto';
+import { deliveryError } from './host-input-delivery-store.js';
+const terminal = phase => phase==='accepted' || phase==='removed';
+function canonical(value) {
+  if(Array.isArray(value))return value.map(canonical);
+  if(value && typeof value==='object')return Object.fromEntries(Object.keys(value).sort().filter(k=>value[k]!==undefined).map(k=>[k,canonical(value[k])]));
+  return value;
+}
+export function inputFingerprint(value){return createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex');}
+export function deliveryClientIds(options) {
+  if(!options || typeof options!=='object' || !('deliveryClientIds' in options))return [];
+  const ids=options.deliveryClientIds;
+  if(!Array.isArray(ids)||ids.length>64||ids.some(id=>typeof id!=='string'||!id||id.length>256))throw deliveryError('INVALID_PARAMS','deliveryClientIds must contain at most 64 nonempty IDs (256 characters each)');
+  return [...new Set(ids)];
+}
+function identity(sessionId,clientId){if(typeof sessionId!=='string'||!sessionId||typeof clientId!=='string'||!clientId||clientId.length>256)throw deliveryError('INVALID_PARAMS','A sessionId and clientId of at most 256 characters are required');}
+function requestShape(row){return Object.fromEntries(['text','persistedContent','files','agentReferences','sessionRefs','origin','sourcePlugin','createOpts'].filter(k=>row[k]!==undefined).map(k=>[k,row[k]]));}
+/** One owner for durable handoff, session command serialization, and permission to retry admission. */
+export function createInputDeliveryCoordinator({store,backend,baseProjection=()=>({pendingQueue:[],steeringQueueClientIds:[]}),onChange=()=>{},onError=()=>{},validateProjection=()=>true,now=()=>Date.now()}){
+  const lanes=new Map(), scheduled=new Set();let stopped=false;
+  function notify(sid){queueMicrotask(()=>Promise.resolve().then(()=>onChange(sid)).catch(onError));}
+  function lane(sid,fn){const previous=lanes.get(sid)??Promise.resolve();const result=previous.catch(()=>{}).then(fn);const tail=result.catch(()=>{}).finally(()=>{if(lanes.get(sid)===tail)lanes.delete(sid);});lanes.set(sid,tail);return result;}
+  function save(entry){store.transaction(()=>store.put(entry));}
+  function view(sid,ids=[],override){
+    const base=override??baseProjection(sid);const pending=(base.pendingQueue??[]).filter(row=>!terminal(store.get(sid,row.clientId)?.phase));
+    for(const e of store.list(sid))if(e.phase==='stored' && e.queued){const at=pending.findIndex(p=>p.clientId===e.clientId);if(at<0)pending.push(e.queued);else pending[at]=e.queued;}
+    return {...base,sessionId:sid,pendingQueue:pending,inputDeliveryVersion:1,clearBoundaryMs:store.boundary(sid),deliveryReceipts:ids.map(clientId=>{const e=store.get(sid,clientId);return{clientId,state:e?e.phase==='removed'?'removed':e.phase==='accepted'?'accepted':e.payload===undefined?'unknown':'pending':'unknown'};})};
+  }
+  async function evidence(sid){
+    const proof=await backend.evidence(sid);
+    if(!proof || !Array.isArray(proof.users) || !Array.isArray(proof.inbox))throw deliveryError('DELIVERY_EVIDENCE_UNAVAILABLE','Durable DSH evidence is unavailable');
+    store.transaction(()=>{for(const user of proof.users){const e=store.get(sid,user.clientId);if(e?.phase==='removed')throw deliveryError('DELIVERY_CANCEL_CONFLICT','A sealed cancellation has a durable user message');if(e && e.phase!=='accepted')store.put({...e,phase:'accepted',payload:null,userSeq:user.seq,error:null});}});
+    return proof;
+  }
+  async function runSession(sid){
+    if(stopped)return;
+    let proof=await evidence(sid);
+    for(let current of store.list(sid)){
+      if(stopped)return;
+      current=store.get(sid,current.clientId);
+      if(terminal(current.phase))continue;
+      if(current.cancelRequested){await cancelNow(sid,current.clientId,proof);proof=await evidence(sid);continue;}
+      if(current.phase!=='stored'){
+        if(current.attemptEpoch===store.epoch)continue; // A live-process claim/admission may still settle.
+        const held=proof.inbox.find(item=>item.clientId===current.clientId);
+        if(held){
+          if(typeof backend.recoverColdInbox!=='function'||!await backend.recoverColdInbox(sid,store.list(sid))) {save({...current,error:'DELIVERY_RECOVERY_WAITING'});continue;}
+          proof=await evidence(sid);
+          if(!proof.running && !proof.inbox.length)store.transaction(()=>{for(const e of store.list(sid))if(!terminal(e.phase)&&e.attemptEpoch!==store.epoch&&!e.cancelRequested)store.put({...e,phase:'stored',error:null});});
+          if(proof.inbox.some(item=>item.clientId===current.clientId))throw deliveryError('DELIVERY_RECOVERY_WAITING','Cold inbox occurrence is still owned by DSH');
+        }
+        if(proof.running){save({...current,error:'DELIVERY_RECOVERY_WAITING'});continue;}
+        current=store.get(sid,current.clientId);
+        if(terminal(current.phase))continue;
+        save({...current,phase:'stored',error:null});
+      }
+      current=store.get(sid,current.clientId);
+      if(stopped || current.cancelRequested || current.phase!=='stored')continue;
+      if((current.nextAttemptAt??0)>now())break;
+      const attempted={...current,phase:'dispatching',attemptEpoch:store.epoch,attemptPid:store.pid,attemptNo:(current.attemptNo??0)+1,error:null};save(attempted);
+      try {
+        await backend.dispatch(attempted);
+        proof=await evidence(sid);
+        const settled=store.get(sid,current.clientId);
+        if(!terminal(settled.phase))save({...settled,phase:proof.inbox.some(item=>item.clientId===current.clientId)?'DSH-pending':'claimed',error:null});
+      }catch(error){const e=store.get(sid,current.clientId);if(!terminal(e.phase))save({...e,...(error.deliveryNotAdmitted?{phase:'stored',...(error.deliveryRetryMode?{payload:{...e.payload,mode:error.deliveryRetryMode}}:{}),nextAttemptAt:now()+Math.min(30000,1000*2**Math.min(e.attemptNo??1,5))}:{}),error:String(error?.code??'DELIVERY_ADMISSION_UNCERTAIN')});onError(error);if(error.deliveryNotAdmitted){notify(sid);break;}}
+      notify(sid);
+    }
+  }
+  function schedule(sid){if(stopped||scheduled.has(sid))return;scheduled.add(sid);setImmediate(()=>{scheduled.delete(sid);if(!stopped)void lane(sid,()=>runSession(sid)).catch(onError);});}
+  async function cancelNow(sid,cid,initial){
+    let e=store.get(sid,cid);if(e.phase==='removed')return true;
+    const proof=initial??await evidence(sid);e=store.get(sid,cid);
+    if(e.phase==='accepted'||proof.users.some(u=>u.clientId===cid))return false;
+    const held=proof.inbox.find(item=>item.clientId===cid);
+    if(held){if(e.payload===undefined)throw deliveryError('NOT_AVAILABLE','A foreign DSH input cannot be sealed by this delivery owner');try{await backend.remove(sid,held.id);}catch(error){if(error.deliveryRemovalApplied)save({...store.get(sid,cid),removalApplied:true});throw error;}const after=await evidence(sid);e=store.get(sid,cid);if(e.phase==='accepted'||after.users.some(u=>u.clientId===cid))return false;if(after.inbox.some(item=>item.clientId===cid))throw deliveryError('DELIVERY_CANCEL_UNCERTAIN','Input is still in the durable inbox');}
+    else if(e.phase!=='stored' && !e.removalApplied && e.attemptEpoch===store.epoch)return false; // Claimed or admission still capable of arriving.
+    else if(e.phase!=='stored' && proof.running)throw deliveryError('DELIVERY_CANCEL_UNCERTAIN','Cannot seal a potentially live input');
+    save({...store.get(sid,cid),phase:'removed',payload:null,cancelRequested:false,error:null});notify(sid);return true;
+  }
+  const api={
+    currentProjection:(sid,ids=[],base)=>view(sid,ids,base),
+    owns:(sid,cid)=>store.get(sid,cid)!==null,
+    async accept(sid,row,options={}){
+      identity(sid,row?.clientId);if(stopped)throw deliveryError('DELIVERY_STOPPED','Input delivery is stopping');
+      return lane(sid,async()=>{
+        if(stopped)throw deliveryError('DELIVERY_STOPPED','Input delivery is stopping');
+        let e=store.get(sid,row.clientId);const raw=inputFingerprint(requestShape(row));
+        if(e?.phase==='removed')return view(sid,[row.clientId]);
+        if(e && e.rawFingerprint===raw){schedule(sid);return view(sid,[row.clientId]);}
+        const hasBoundary=Object.hasOwn(options,'expectedClearBoundaryMs');
+        if(row.durableDelivery===true && !hasBoundary)throw deliveryError('INVALID_PARAMS','Durable input requires expectedClearBoundaryMs, including explicit null');
+        const expectedBoundary=hasBoundary?options.expectedClearBoundaryMs:store.boundary(sid);
+        if(!e && expectedBoundary!==store.boundary(sid))throw deliveryError('REMOTE_OPTIMISTIC_INPUT_CLEARED','REMOTE_OPTIMISTIC_INPUT_CLEARED: input clear boundary changed');
+        const prepared=await backend.prepare(sid,row,options);
+        if(!prepared || prepared.payload===undefined || !prepared.queued)throw deliveryError('DELIVERY_PREPARATION_FAILED','Host did not obtain complete replayable input');
+        const {consumed: _transit,mode: _mode,...semanticPayload}=prepared.payload;const fingerprint=inputFingerprint(semanticPayload);e=store.get(sid,row.clientId);
+        if(e){if(e.phase==='removed')return view(sid,[row.clientId]);if(e.fingerprint!==fingerprint)throw deliveryError('INPUT_DELIVERY_CONFLICT','clientId already belongs to a different input');return view(sid,[row.clientId]);}
+        if(expectedBoundary!==store.boundary(sid))throw deliveryError('REMOTE_OPTIMISTIC_INPUT_CLEARED','REMOTE_OPTIMISTIC_INPUT_CLEARED: input was cleared during preparation');
+        const preview=view(sid,[row.clientId]);preview.pendingQueue=[...preview.pendingQueue,prepared.queued];preview.deliveryReceipts=[{clientId:row.clientId,state:'pending'}];
+        if(!validateProjection(preview))throw deliveryError('DELIVERY_TOO_LARGE','Input queue projection cannot fit the negotiated transport budget');
+        save({sessionId:sid,clientId:row.clientId,phase:'stored',request:requestShape(row),rawFingerprint:raw,fingerprint,payload:prepared.payload,queued:prepared.queued,clearBoundaryMs:store.boundary(sid),sendAtMs:options.sendAtMs??null,createdAt:now(),attemptNo:0,cancelRequested:false});
+        notify(sid);schedule(sid);return view(sid,[row.clientId]);
+      });
+    },
+    async edit(sid,cid,value){
+      identity(sid,cid);
+      return lane(sid,async()=>{
+        let entry=store.get(sid,cid);if(!entry?.payload||terminal(entry.phase)||entry.cancelRequested)throw deliveryError('NOT_FOUND','Input is no longer editable');
+        const text=typeof value==='string'?value:value?.text;if(typeof text!=='string'||!text.trim())throw deliveryError('INVALID_PARAMS','Edited input needs text');
+        const candidate={...entry.queued,...(typeof value==='object'?value:{}),clientId:cid,text,files:typeof value==='object'&&Array.isArray(value.files)?value.files:entry.queued.files};
+        const filesChanged=inputFingerprint(candidate.files??[])!==inputFingerprint(entry.queued.files??[]);
+        const prepared=filesChanged?await backend.prepare(sid,candidate,{}):{payload:{...entry.payload,text,mode:'queue'},queued:{...entry.queued,text,persistedContent:typeof value==='object'&&typeof value.persistedContent==='string'?value.persistedContent:text,chatMessage:{...entry.queued.chatMessage,content:text}}};
+        entry=store.get(sid,cid);if(entry.cancelRequested||entry.clearBoundaryMs!==store.boundary(sid))throw deliveryError('REMOTE_OPTIMISTIC_INPUT_CLEARED','Input changed ownership during edit');
+        const proof=await evidence(sid);const held=proof.inbox.find(item=>item.clientId===cid);
+        if(held){if(held.placement==='next-step')throw deliveryError('NOT_AVAILABLE','An active steering input cannot be edited');await backend.remove(sid,held.id);const after=await evidence(sid);if(after.users.some(u=>u.clientId===cid)||after.inbox.some(item=>item.clientId===cid))throw deliveryError('DELIVERY_EDIT_UNCERTAIN','Input changed while editing');}
+        else if(entry.phase!=='stored')throw deliveryError('NOT_FOUND','Input was already claimed');
+        entry=store.get(sid,cid);if(terminal(entry.phase)||entry.cancelRequested)throw deliveryError('NOT_FOUND','Input changed while editing');
+        const {consumed,mode,...semantic}=prepared.payload;save({...entry,phase:'stored',request:requestShape(candidate),rawFingerprint:inputFingerprint(requestShape(candidate)),fingerprint:inputFingerprint(semantic),payload:prepared.payload,queued:prepared.queued,nextAttemptAt:0,error:null});
+        notify(sid);schedule(sid);return view(sid,[cid]);
+      });
+    },
+    async steer(sid,row,options={}){
+      identity(sid,row?.clientId);
+      const promoted=await lane(sid,async()=>{
+        const proof=await evidence(sid);const held=proof.inbox.find(x=>x.clientId===row.clientId);const entry=store.get(sid,row.clientId);
+        if(held){if(!entry?.payload)throw deliveryError('NOT_AVAILABLE','This input has no Host-owned replay payload for safe promotion');await backend.promote(sid,held.id);await evidence(sid);notify(sid);return true;}
+        if(entry)return entry.phase==='removed'?false:true;
+        return null;
+      });
+      if(promoted!==null)return promoted;
+      await api.accept(sid,row,{...options,mode:'steer'});return true;
+    },
+    async projection(sid,options){
+      if(typeof sid!=='string'||!sid)throw deliveryError('INVALID_PARAMS','sessionId is required');const ids=deliveryClientIds(options);
+      const proof=await evidence(sid);
+      // Actual durable user history is authoritative even for an input not submitted through this instance.
+      store.transaction(()=>{for(const cid of ids)if(!store.get(sid,cid)&&proof.users.some(u=>u.clientId===cid))store.put({sessionId:sid,clientId:cid,phase:'accepted',userSeq:proof.users.find(u=>u.clientId===cid).seq});});
+      schedule(sid);return view(sid,ids);
+    },
+    async cancel(sid,cid){
+      identity(sid,cid);if(stopped)throw deliveryError('DELIVERY_STOPPED','Input delivery is stopping');
+      // Persist intent now, including cancel-before-enqueue, even while another admission awaits.
+      store.transaction(()=>{const e=store.get(sid,cid);if(!e)store.put({sessionId:sid,clientId:cid,phase:'stored',cancelRequested:true,createdAt:now()});else if(!terminal(e.phase))store.put({...e,cancelRequested:true});});
+      return lane(sid,async()=>{const cancelled=await cancelNow(sid,cid);return {...view(sid,[cid]),inputDeliveryCancelled:cancelled};});
+    },
+    async clear(sid){
+      if(stopped)throw deliveryError('DELIVERY_STOPPED','Input delivery is stopping');
+      store.transaction(()=>{const previous=store.boundary(sid);store.setBoundary(sid,Math.max(now(),previous===null?0:previous+1));for(const e of store.list(sid))if(!terminal(e.phase))store.put({...e,cancelRequested:true});});
+      return lane(sid,async()=>{const proof=await evidence(sid);store.transaction(()=>{for(const item of proof.inbox)if(!store.get(sid,item.clientId))store.put({sessionId:sid,clientId:item.clientId,phase:'stored',cancelRequested:true,createdAt:now()});});for(const e of store.list(sid))if(e.cancelRequested)await cancelNow(sid,e.clientId);notify(sid);return view(sid);});
+    },
+    async drain(){while(scheduled.size||lanes.size){await new Promise(resolve=>setImmediate(resolve));await Promise.all([...lanes.values()]);}},
+    recover(){for(const sid of new Set(store.list().filter(e=>!terminal(e.phase)).map(e=>e.sessionId)))schedule(sid);},
+    diagnostics(){return store.list().filter(e=>!terminal(e.phase)).map(e=>({sessionId:e.sessionId,clientId:e.clientId,phase:e.phase,error:e.error??null}));},
+    async close(){stopped=true;await Promise.all([...lanes.values()]);store.close();},
+  };
+  return api;
+}

package/src/host-version.js

@@ -1,7 +1,7 @@
-/** Cindy desktop compatibility version, NOT this plugin's package version.
- * Source: G:/Projects/Cindy tag v0.1.82, latest non-beta September 2026 tag.
- * Commit 1d7aaa2fb4456c1ba96ab7f2125567d7c19bbf69, 2026-09-14T20:53:42+07:00.
+/** Conservative Cindy handshake identity, NOT this plugin release or feature negotiation.
+ * Modern input support is explicitly negotiated with inputDeliveryVersion: 1.
+ * Do not impersonate a native Cindy app version and implicitly enable unrelated features.
  */
 export const HOST_APP_VERSION = '0.1.82';
 /** Actual npm release, separate from the Cindy compatibility identity. */
-export const HOST_PLUGIN_VERSION = '0.1.26';
+export const HOST_PLUGIN_VERSION = '0.1.27';

package/src/host.js

@@ -19,6 +19,10 @@
  *    missing `pong`s as a dead socket.
  */
 import WebSocket from 'ws';
+import { join as joinDeliveryPath } from 'node:path';
+import { createHash as deliveryHash } from 'node:crypto';
+import { openInputDeliveryStore, deliveryError } from './host-input-delivery-store.js';
+import { createInputDeliveryCoordinator } from './host-input-delivery.js';
 import { realpath as realpathImpl, stat as statImpl } from 'node:fs/promises';
 import { extname as extnameImpl, resolve as resolvePathImpl } from 'node:path';
 import { restoreSession } from './auth-session.js';
@@ -49,7 +53,7 @@ import { createExportOwner } from './host-export-owner.js';
 import { createTransferDiagnostics } from './host-transfer-diagnostics.js';
 import { normalizeAuthBaseUrl } from './cindy-login-flow.js';
 import { RECONNECT_STABLE_RESET_MS, computeReconnectDelayMs } from './host-reconnect.js';
-import { MAX_FRAME_BYTES, fitInvokeResultToFrame, frameByteLength } from './host-frame-budget.js';
+import { MAX_FRAME_BYTES, FRAME_BUDGET_BYTES, fitInvokeResultToFrame, frameByteLength } from './host-frame-budget.js';
 
 /** Mainland DeviceLink relay. The settings card never guesses this value. */
 export const RELAY_WS_URL = 'wss://device-link.cindy.com.cn/api/device-link/ws';
@@ -1054,6 +1058,7 @@ export async function startHost(initialSource, settings = DEFAULT_HOST_SETTINGS,
    * @param payload - the channel's payload.
    */
   function pushSessionUpdate(sessionId, channel, payload) {
+    if (channel === 'maker:input:projection' && activeDelivery) payload = activeDelivery.currentProjection(sessionId, [], payload);
     const devices = sessionSubscribers.get(sessionId);
     const watchers = devices === undefined ? 0 : devices.size;
     const reachable = devices === undefined ? 0 : [...devices].filter((deviceId) => !offlineDevices.has(deviceId)).length;
@@ -1120,6 +1125,11 @@ export async function startHost(initialSource, settings = DEFAULT_HOST_SETTINGS,
    * chip instead of the picture.
    */
   async function pushSessionMessage(sessionId, message) {
+    if (message?.role === 'user' && activeDelivery?.owns(sessionId, message.clientId)) {
+      await new Promise(resolve => queueMicrotask(resolve));
+      const proof = await activeDelivery.projection(sessionId, { deliveryClientIds: [message.clientId] });
+      if (proof.deliveryReceipts[0]?.state !== 'accepted') return;
+    }
     try {
       // `options.resolveCapabilities` is the plugin's provider — the only source of the hydrator.
       // (Reading it through the router's own `resolveCapabilities` is not possible from here: that
@@ -1160,6 +1170,56 @@ export async function startHost(initialSource, settings = DEFAULT_HOST_SETTINGS,
     return sessionRowCache.get(sessionId);
   }
 
+  let deliveryNamespace = options.inputDeliveryNamespace ?? null;
+  var activeDelivery = null;
+  const deliveryInstances = new Set();
+  let deliveryLastError = null;
+  function getInputDelivery() {
+    if (!options.inputDeliveryDirectory) return null;
+    if (!deliveryNamespace) throw deliveryError('DELIVERY_NOT_AVAILABLE', 'Waiting for the authenticated Host account');
+    if (activeDelivery) return activeDelivery;
+    const namespace = deliveryNamespace;
+    const currentBackend = () => {
+      const backend = options.resolveCapabilities?.().inputDeliveryBackend;
+      if (!backend || !backend.available()) throw deliveryError('DELIVERY_NOT_AVAILABLE', 'Durable DSH delivery backend is unavailable');
+      return backend;
+    };
+    currentBackend();
+    const file = joinDeliveryPath(options.inputDeliveryDirectory, deliveryHash('sha256').update(namespace).digest('hex') + '.sqlite');
+    const store = openInputDeliveryStore({ file, namespace });
+    const coordinator = createInputDeliveryCoordinator({
+      store,
+      backend: {
+        prepare: (sid, row, opts) => currentBackend().prepare(sid, row, { ...opts, resolveAttachmentRef }),
+        evidence: sid => currentBackend().evidence(sid),
+        dispatch: entry => currentBackend().dispatch(entry, { releaseAttachmentRef: key => deliveryNamespace === namespace ? releaseAttachmentRef(key) : Promise.resolve() }),
+        remove: (sid, id) => currentBackend().remove(sid, id),
+        promote: (sid, id) => currentBackend().promote(sid, id),
+        recoverColdInbox: (sid, entries) => currentBackend().recoverColdInbox(sid, entries),
+      },
+      baseProjection: sid => inputQueue.projectionFor(sid, sessionRowFor(sid)),
+      validateProjection: projection => frameByteLength({ v: 1, kind: 'invoke-result', id: 'delivery', dst: 'controller', payload: { ok: true, result: projection } }) <= FRAME_BUDGET_BYTES - 24576,
+      onChange: sid => {
+        if (activeDelivery !== coordinator || deliveryNamespace !== namespace || stopped) return;
+        pushSessionUpdate(sid, 'maker:input:projection', coordinator.currentProjection(sid));
+        pushHistoryViewChanged(sid);
+      },
+      onError: error => { deliveryLastError = { at: new Date().toISOString(), code: error?.code ?? 'DELIVERY_FAILURE', message: String(error?.message ?? error).slice(0, 300) }; },
+    });
+    deliveryInstances.add(coordinator);
+    activeDelivery = coordinator;
+    coordinator.recover();
+    return coordinator;
+  }
+  function bindDeliveryNamespace(namespace) {
+    if (deliveryNamespace === namespace) return;
+    deliveryNamespace = namespace;
+    const previous = activeDelivery; activeDelivery = null;
+    if (previous) void previous.close().then(() => deliveryInstances.delete(previous)).catch(error => recordHandlerError('input-delivery-close', error));
+  }
+  const deliveryTimer = options.inputDeliveryDirectory ? setInterval(() => { if (!stopped) activeDelivery?.recover(); }, 1000) : null;
+  deliveryTimer?.unref?.();
+
   const routeInvoke = createChannelRouter({
     getSession: async (sessionId) => {
       if (source == null) throw new Error('no DSH session source is attached');
@@ -1230,7 +1290,8 @@ export async function startHost(initialSource, settings = DEFAULT_HOST_SETTINGS,
         // plugin owns the attachment reader, and a row must be renderable in the frame that
         // carries it (see `pushSessionMessage`).
         hydrateImages: provided.hydrateImages,
-      inputProjection: (sessionId, pending) => inputQueue.projectionFor(sessionId, sessionRowFor(sessionId), pending ?? null),
+      inputDelivery: getInputDelivery,
+      inputProjection: (sessionId, pending) => { const base = inputQueue.projectionFor(sessionId, sessionRowFor(sessionId), pending ?? null); return activeDelivery ? activeDelivery.currentProjection(sessionId, [], base) : base; },
       queuedRow: ({ clientId, text, sessionId }) => queuedRowFromController({ clientId, text, session: sessionRowFor(sessionId) }),
       goalStatus: (sessionId) => toGoalStatusPayload(sessionId, projections.goalOf(sessionId)),
       /**
@@ -1917,6 +1978,7 @@ export async function startHost(initialSource, settings = DEFAULT_HOST_SETTINGS,
           userId: typeof payload.userId === 'string' ? payload.userId : null,
           protocolVersion: typeof payload.serverProtocolVersion === 'number' ? payload.serverProtocolVersion : null,
         });
+        if (typeof payload.userId === 'string' && typeof payload.deviceId === 'string') bindDeliveryNamespace([mediaBase, normalizeAuthBaseUrl(socketSession?.authBaseUrl), payload.userId, payload.deviceId].join('|'));
         status.setState('waiting');
         syncDeviceName();
         // The relay itself accepted us, which is the first moment "online" is true —
@@ -2295,6 +2357,9 @@ export async function startHost(initialSource, settings = DEFAULT_HOST_SETTINGS,
     active = false;
     await disconnect();
     await fileExports.stop();
+    if (deliveryTimer !== null) clearInterval(deliveryTimer);
+    await Promise.all([...deliveryInstances].map(coordinator => coordinator.close()));
+    deliveryInstances.clear(); activeDelivery = null;
     status.setState('disconnected');
   }
 
@@ -2307,7 +2372,7 @@ export async function startHost(initialSource, settings = DEFAULT_HOST_SETTINGS,
     acceptedControllers,
     policy,
     status,
-    getStatus: () => ({ ...status.snapshot(), pluginVersion: HOST_PLUGIN_VERSION, nameSync: deviceNameSync.snapshot() }),
+    getStatus: () => ({ ...status.snapshot(), pluginVersion: HOST_PLUGIN_VERSION, nameSync: deviceNameSync.snapshot(), inputDelivery: { ready: activeDelivery !== null, version: activeDelivery ? 1 : null, pending: activeDelivery?.diagnostics().slice(0, 30) ?? [], lastError: deliveryLastError } }),
     deleteDevice,
     subscribeStatus: (listener) => status.subscribe(listener),
     /** The most recent invokes this Host served, for the status route's diagnostics. */