dsh-cindy-host 0.1.35 → 0.1.37

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.1.37 — 2026-11-06
+
+- Use explicit source-order history snapshots for both validated persistence and the hot fallback reader. Preserve legacy raw order, reconcile live reasoning through native history-live client identities, and page by source cuts; unknown cursors now fail explicitly rather than silently skipping history.
+- Fold raw thinking pushes only for the subscribed controller that successfully received a current history page. Reset this disposable state on read/send failure and lifecycle changes, preserve pending-read trailing refreshes, and fence replies against stale relay generations.
+- Coalesce interim reasoning at 1s with latest-wins deduplication and serialized UTF-8 budgets (32 KiB/s, 64 KiB burst/snapshot). Bound automatic preview ranges to 5 rows/6 KiB without truncating full details or delaying terminal retirement. These are Host-side safeguards, not handset white-screen acceptance or proof that every device's failure is resolved.
+
+## 0.1.36 — 2026-11-06
+
+- Project proven native interruption identities and timestamp tuples consistently into session list/get, boundaries and reconnect updates. Clear non-pending/hidden/running presentation without fabricating transcript-clear or completion facts.
+- Serve existing interruption acknowledgement and committed-error dismissal calls through authenticated owner-scoped, revisioned native settings. Store hashed display preferences only, verify authoritative readback, guard source/controller/tail races, and overlay history without rewriting source events or receipt evidence.
+- Treat the pinned current Cindy continuation prompt as a new explicit durable human input with planMode:false. Capture and recheck the native tail around proven scoped plan-off, deduplicate continuations for that tail, and reconcile superseded/non-admitted refusals as removed receipts instead of retrying automatically. Legacy non-durable fallback refuses this control contract.
+- Extend Host/ledger/native-input regressions and opt-in read-only Cindy consumer contracts. Existing wire limitations remain explicit: no atomic CAS against unrelated desktop writers, screen-generation token in acknowledgement, immediate client rollback of failed ignores, or automatic replay of unknown tool outcomes.
+
 ## 0.1.35 — 2026-11-05
 
 - Show distinct native interruption, cancellation, sign-out, output-limit and blocked-turn notices without inventing model failures. Keep explicit native scheduled/started retries nonterminal, with safe known-code/count/delay details and stable live/history identities.

package/README.md

@@ -4,16 +4,20 @@ A Host-side adapter connecting current Cindy clients to DeepSeek Harness.
 
 ## Requirements and installation
 
-Version **0.1.35** adds native interruption, cancellation, output-limit and retry notices, cold-session diagnostic recovery and canonical tool-result pairing. It retains 0.1.34's question synchronization and safe model-failure display, plus the earlier regional authentication, reasoning streaming and native capability subsets.
+Version **0.1.37** stabilizes source-order history pagination, per-controller history delivery state and bounded interim reasoning updates. It retains 0.1.36's interruption controls and the earlier diagnostics, question synchronization, authentication and native capability subsets. Host regressions do not establish that handset white-screen issues are resolved.
 
 It supports the exact **DSH 0.2.2-alpha.2** carrier, while retaining `0.2.1-rc.3`, `0.2.1-rc.4` and `0.2.1-rc.5`. Alpha requires **Node.js >=24.9** (tested with 24.12); the older carriers retain this plugin's Node.js >=22.16 minimum. Agent/session/settings peers and alpha Schemastery are explicitly allowed, not a blanket promise for future prereleases. The full Web installation gate uses DSH **0.2.1-rc.5**; alpha core-contract checks do not establish alpha Web/relay/handset acceptance. Install through the Desktop DSH plugin manager. CLI-managed profiles can use:
 
 ```sh
-dsh plugin --profile <profile> add dsh-cindy-host@0.1.35
+dsh plugin --profile <profile> add dsh-cindy-host@0.1.37
 ```
 
 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.
 
+## 0.1.36: interruption controls
+
+The existing Cindy acknowledgement/dismissal actions update owner-scoped display preferences, not failure or completion facts. Manual continuation is a new human input; it verifies the current native tail and effective plan-mode off rather than retrying old tool calls. These changes are Host-only: Cindy is a read-only protocol/test dependency. See the [diagnostic protocol and limitations](<doc/model-errors.md>) for persistence, concurrency and current-client boundaries. Source contracts do not establish live-handset acceptance.
+
 ## 0.1.32: credentials without keytar
 
 No native npm credential module or C++ build toolchain is required. Linux uses `secret-tool` with an unlocked Secret Service (headless sessions need their own DBus/keyring setup); macOS uses the system Keychain through `/usr/bin/security`. Both keep the existing `DSH Cindy Host` service and installation-specific account.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-cindy-host",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "private": false,
   "description": "Cindy 手机客户端连接 DSH 的 Host 侧插件：会话/消息/审批/todo/goal 的手机通道，以及配套的设置卡片",
   "license": "MIT",

package/src/cindy-channels.js

@@ -21,6 +21,7 @@ import { toGoalStatusPayload } from './host-goals.js';
 import { hostAttachmentsOf } from './host-attachments.js';
 import { historyLocateOptions, locateCommittedMessages, capReferenceRows } from './host-history-locate.js';
 import { assertNoStructuredSessionReferences } from './session-reference-boundary.js';
+import { continuationKind } from './continuation-protocol.js';
 
 async function deliveryReply(request, operation) {
   try { return invokeResult(request, await operation()); }
@@ -217,6 +218,8 @@ export const SUPPORTED_CHANNELS = Object.freeze([
   'local-db:sessions:list',
   'local-db:sessions:get',
   'local-db:messages:list',
+  'local-db:messages:dismiss-error',
+  'local-db:sessions:ack-interrupted',
   'local-db:messages:around',
   'local-db:messages:around-client-id',
   'local-db:sessions:patch-meta',
@@ -648,6 +651,14 @@ export function createChannelRouter({
       return invokeResult(request, sessionListPage(await sessionRows(), args));
     }
 
+    if (channel === 'local-db:sessions:ack-interrupted' || channel === 'local-db:messages:dismiss-error') {
+      const sid = args[0]; const cid = args[1]; const caps = capabilitiesNow();
+      if (typeof sid !== 'string' || !sid || args.length !== (channel === 'local-db:sessions:ack-interrupted' ? 1 : 2) || (channel === 'local-db:messages:dismiss-error' && (typeof cid !== 'string' || !cid))) return invokeError(request, 'INVALID_PARAMS', 'Session and message identities are required');
+      const action = channel === 'local-db:sessions:ack-interrupted' ? caps.ackInterrupted : caps.dismissError;
+      if (typeof action !== 'function') return invokeError(request, 'NOT_AVAILABLE', 'Diagnostic presentation actions are unavailable');
+      return deliveryReply(request, () => channel === 'local-db:sessions:ack-interrupted' ? action(sid, request.src) : action(sid, cid, request.src));
+    }
+
     if (channel === 'local-db:sessions:get') {
       const sessionId = String(args[0] ?? '');
       // A known blank session must be readable before its first enqueue. The
@@ -1164,6 +1175,8 @@ export function createChannelRouter({
         if (delivery) return deliveryReply(request, () => channel === 'maker:input:steer' ? delivery.steer(sessionId, args[1], args[2] ?? {}) : delivery.accept(sessionId, args[1], args[2] ?? {}));
       }
 
+      if (continuationKind(extractSendText(args[1]))) return invokeError(request, 'NOT_AVAILABLE', 'Safe manual continuation requires native durable input delivery');
+
       // 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

package/src/cindy-message-row.js

@@ -286,7 +286,7 @@ const RENDERABLE_SOURCE_KINDS = new Set(['user', 'model', 'tool']);
  *   user turn — the `clientId` the controller minted for the prompt.
  * @returns one row per renderable content block, in order.
  */
-export function toCindyMessageRows(message, { sessionId, createdAt, now = () => new Date(), promptClientId = null }) {
+export function toCindyMessageRows(message, { sessionId, createdAt, now = () => new Date(), promptClientId = null, reasoningIdentity = null }) {
   const rows = [];
   // Canonical DSH results use a tool-role message with root outcome/call ID,
   // not the legacy user-role nested tool-result block. Keep both formats.
@@ -372,7 +372,12 @@ export function toCindyMessageRows(message, { sessionId, createdAt, now = () =>
         if (typeof block.text !== 'string' || block.text === '') return;
         // Thinking is a structured native role on both Cindy clients. Unlike
         // ordinary prose, a string here is discarded by mobile normalizeThinking.
-        rows.push({ ...base, content: { text: block.text } });
+        // Native history-live refs resolve by clientId after the durable id replaces the live id.
+        const identity = reasoningIdentity;
+        const logical = Number.isSafeInteger(identity?.turn) && identity.turn >= 0
+          && Number.isSafeInteger(identity?.step) && identity.step >= 0
+          ? `${sessionId}:reasoning-stream:${identity.turn}:${identity.step}:${index}` : clientId;
+        rows.push({ ...base, clientId: logical, content: { text: block.text } });
         return;
       case 'tool-call':
         rows.push({
@@ -437,6 +442,7 @@ export function toCindyMessages(messages, { sessionId, now = () => new Date() })
     createdAt: entry.createdAt,
     now,
     promptClientId: entry.promptClientId ?? null,
+    reasoningIdentity: entry.reasoningIdentity ?? null,
   }));
   const rows = [];
   for (const group of perMessage.reverse()) rows.push(...group);

package/src/cindy-session-row.js

@@ -126,6 +126,7 @@ export function toCindySessionListRow(item, { now = () => new Date(), device, de
     // Not part of the stored row's contract, but harmless and honest: the
     // controller reads running state from `maker:list-active`, not from here.
     running: item.running === true,
+    ...(Object.hasOwn(item, 'activeTurnStartedAt') ? { activeTurnStartedAt: item.activeTurnStartedAt, interruptedTurnStartedAt: item.interruptedTurnStartedAt, lastTurnEndedAt: item.lastTurnEndedAt, clearedAt: item.clearedAt ?? null } : {}),
     // Which device this row came from. The controller's home aggregates sessions
     // from every linked computer and filters with
     // `canonicalDeviceId ?? deviceLinkDeviceId === selectedDeviceId`

package/src/continuation-protocol.js

@@ -0,0 +1,31 @@
+// Pinned Cindy maker-shared/syntheticTrigger constants; actual-consumer tests
+// assert byte equality. These are explicit manual inputs, never tool retries.
+const COMMON = ' Review the conversation above to determine how far the task progressed,'
+  + ' then continue from where it left off.'
+  + ' Do not repeat steps that already completed and had external effects'
+  + ' (messages or comments already sent, commits already pushed, files already written).';
+export const CONTINUE_INTERRUPTED = '[UI_ACTION_TRIGGER] The previous turn was interrupted because the app exited mid-run.' + COMMON;
+export const CONTINUE_ERROR = '[UI_ACTION_TRIGGER] The previous turn errored partway through.' + COMMON;
+export function continuationKind(text) { return text === CONTINUE_INTERRUPTED ? 'interrupted' : text === CONTINUE_ERROR ? 'error' : null; }
+
+/** Public native getters/projections prove the effective switch; never parse command prose. */
+export async function ensureNativeContinuationPlanOff({agent,controller,getService}) {
+  try {
+    const registry=agent?.ctx?.get?.('sessionProjections')??getService('sessionProjections');
+    const read=()=>controller?.get?.(agent)??registry?.stateOf?.(agent.session,'plan');
+    const off=()=>{const state=read();return state?.active===false&&state.pending!==true&&state.wanted!==true&&!state.running;};
+    // A logged projection alone cannot rule out a controller-private pending
+    // entry. Without the live getter, issue off even when logged active=false.
+    if(typeof controller?.get==='function'&&off())return;
+    if(typeof controller?.set==='function')await controller.set(agent,false);
+    else {
+      const commands=getService('commands');
+      if(typeof commands?.find!=='function'||typeof agent?.ctx?.get!=='function')throw Error('Native plan composition is not observable');
+      if(commands.find(agent,'plan')===undefined&&!controller)return; // exact resolved agent has no plan-mode owner
+      if(typeof commands.execute!=='function')throw Error('Native plan control is unavailable');
+      const result=await commands.execute(agent,'/plan off',[],AbortSignal.timeout(30000));
+      if(result?.result?.kind==='error')throw Error('Native plan-mode switch was refused');
+    }
+    if(!off())throw Error('Native plan-mode off is not committed');
+  } catch(cause) { throw Object.assign(new Error('Cannot verify native plan mode is off; continuation was not sent'),{code:'PLAN_MODE_UNAVAILABLE',cause}); }
+}

package/src/diagnostic-presentation.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+const hash = value => createHash('sha256').update(value).digest('hex');
+const unavailable = message => Object.assign(new Error(message), { code: 'NOT_AVAILABLE' });
+export const EMPTY_INTERRUPTION = Object.freeze({ activeTurnStartedAt: null, interruptedTurnStartedAt: null, lastTurnEndedAt: null, clearedAt: null });
+
+/** Presentation identities use the original turn/start, never a synthetic closer. */
+export function nativeInterruption(sessionId, start, end, priorEndedAt) {
+  if (end?.data?.reason?.kind !== 'interrupted' || !Number.isSafeInteger(start?.data?.turn) || start.data.turn < 0 || start?.data?.turn !== end?.data?.turn
+    || !Number.isSafeInteger(end.seq) || end.seq <= start?.seq || !Number.isFinite(end.time)
+    || !Number.isSafeInteger(start?.seq) || start.seq < 0 || !Number.isFinite(start.time) || start.time <= 0
+    || (Number.isFinite(priorEndedAt) && priorEndedAt >= start.time)) return null;
+  return { id: `${sessionId}:interrupted:${start.seq}:${start.time}:${start.data.turn}`,
+    startedAt: start.time, priorEndedAt: Number.isFinite(priorEndedAt) ? priorEndedAt : null };
+}
+export function advanceInterruptionMetadata(state, event, sessionId) {
+  const previous = state ?? { start: null, priorEndedAt: null, interruption: null };
+  if (event?.type === 'turn/start') return { ...previous, start: { seq: event.seq, time: event.time, data: { turn: event.data?.turn } }, interruption: null };
+  if (event?.type !== 'turn/end') return previous;
+  return { ...previous, interruption: nativeInterruption(sessionId, previous.start, event, previous.priorEndedAt),
+    priorEndedAt: event.data?.reason?.kind === 'interrupted' ? previous.priorEndedAt : Number.isFinite(event.time) ? event.time : previous.priorEndedAt };
+}
+export function diagnosticOwner(namespace, profile = '') {
+  return typeof namespace === 'string' && namespace ? hash(`${profile}|${namespace}`) : null;
+}
+export function preferenceHas(data, owner, sid, kind, id) {
+  return Boolean(owner && data?.[owner]?.[hash(sid)]?.[kind]?.[hash(id)] === true);
+}
+export function interruptionFields(candidate, running, hidden, data, owner, sid) {
+  if (!candidate || running || hidden || preferenceHas(data, owner, sid, 'interruptions', candidate.id)) return { ...EMPTY_INTERRUPTION };
+  return { activeTurnStartedAt: candidate.startedAt, interruptedTurnStartedAt: candidate.startedAt, lastTurnEndedAt: candidate.priorEndedAt, clearedAt: null };
+}
+export function projectDismissedErrors(rows, data, owner) {
+  return rows.map(row => row?.role === 'error' && preferenceHas(data, owner, row.sessionId, 'errors', row.clientId)
+    ? { ...row, content: { ...row.content, dismissed: true } } : row);
+}
+
+/** One transactional settings owner; no optimistic mirror of error/turn facts.
+ * Leaf writes preserve other grants/preferences. Revision conflicts are retried
+ * from describe, and successful writes are verified by authoritative readback. */
+export function diagnosticPreferenceStore(settings, ns) {
+  function describe() {
+    if (typeof settings?.describe !== 'function' || typeof settings?.mutate !== 'function') throw unavailable('Diagnostic preferences require revisioned native settings');
+    const entry = settings.describe().find(entry => entry.ns === ns);
+    if (!entry || !Number.isSafeInteger(entry.revision)) throw unavailable('Diagnostic settings namespace is unavailable');
+    return entry;
+  }
+  return {
+    snapshot() { try { return describe().value?.diagnosticPresentationV1 ?? {}; } catch { return {}; } },
+    async commit({ owner, sessionId, kind, id }, valid = () => true) {
+      if (!owner || !['interruptions', 'errors'].includes(kind)) throw unavailable('No authenticated diagnostic preference owner');
+      for (let attempt = 0; attempt < 3; attempt++) {
+        if (!valid()) throw unavailable('Diagnostic action scope changed');
+        const entry = describe();
+        if (preferenceHas(entry.value?.diagnosticPresentationV1, owner, sessionId, kind, id)) return;
+        try {
+          await settings.mutate(ns, [{ op: 'set', path: ['diagnosticPresentationV1', owner, hash(sessionId), kind, hash(id)], value: true }], entry.revision);
+        } catch (error) { if (error?.code === 'SETTINGS_CONFLICT') continue; throw error; }
+        if (!valid()) throw unavailable('Diagnostic action completed in an expired scope');
+        if (!preferenceHas(describe().value?.diagnosticPresentationV1, owner, sessionId, kind, id)) throw unavailable('Diagnostic preference was not committed');
+        return;
+      }
+      throw unavailable('Diagnostic settings changed concurrently; retry the action');
+    },
+  };
+}

package/src/dsh-input-delivery.js

@@ -1,6 +1,8 @@
 import { createAttachmentMaterializer, hostAttachmentsOf } from './host-attachments.js';
-import { foldSessionEvent } from './dsh-message-fold.js';
+import { historySnapshotFromEvents } from './dsh-message-fold.js';
 import { interruptedTurnClosers } from '@deepseek-ai/dsh-session';
+import { turnStateFromEvents } from './turn-error.js';
+import { continuationKind } from './continuation-protocol.js';
 import { queuedRowFromController } from './host-input-queue.js';
 import { deliveryError } from './host-input-delivery-store.js';
 import { assertNoStructuredSessionReferences } from './session-reference-boundary.js';
@@ -23,7 +25,7 @@ export function durableInputEvidence(events,sessionId) {
   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}){
+export function createDshInputDeliveryBackend({getServices,sessionController,getSession,ensurePlanModeOff}){
   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){
@@ -34,6 +36,17 @@ export function createDshInputDeliveryBackend({getServices,sessionController,get
   }
   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');}
+  async function continuationTail(sid,kind,clientId) {
+    const persisted=await readLog(sid); const s=services();
+    const agent=s.agents?.get(sid);
+    if(agent?.status==='running')throw deliveryError('CONTINUATION_SUPERSEDED','The session has already started another turn');
+    const events=!s.sessions.get(sid)&&!agent?[...persisted,...interruptedTurnClosers(persisted)]:persisted;
+    const state=turnStateFromEvents(events,sid);
+    const id=kind==='interrupted'?state?.interruption?.id:state?.error?.clientId;
+    if(!id||state.running||events.some(event=>event.seq>state.boundarySeq&&event.type==='user/message'&&event.data?.source?.kind==='user'&&event.data.source.rpcId!==clientId)
+      ||durableInputEvidence(persisted,sid).inbox.some(item=>item.clientId!==clientId))throw deliveryError('CONTINUATION_SUPERSEDED','The original continuation tail is no longer current');
+    return id;
+  }
   const backend={
     available(){try{services();return true;}catch{return false;}},
     stop(){active=false;},
@@ -44,7 +57,14 @@ export function createDshInputDeliveryBackend({getServices,sessionController,get
       // session or agent must never be diagnosed as a crashed writer.
       const cold=!s.sessions.get(sid)&&typeof s.agents?.get==='function'&&!s.agents.get(sid);
       const events=cold?[...persisted,...interruptedTurnClosers(persisted)]:persisted;
-      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();},
+      // Preserve the raw newest-first order/rowid contract while including the same
+      // public live overlay as history. Receipt evidence still reads the native log only.
+      return historySnapshotFromEvents(events, sid, { rowids: true }).rows.reverse();},
+    async historySnapshot(sid) {
+      const persisted = await readLog(sid); const s = services();
+      const cold = !s.sessions.get(sid) && typeof s.agents?.get === 'function' && !s.agents.get(sid);
+      return historySnapshotFromEvents(cold ? [...persisted, ...interruptedTurnClosers(persisted)] : persisted, sid);
+    },
     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'}={}){
       assertNoStructuredSessionReferences(row);
@@ -54,13 +74,26 @@ export function createDshInputDeliveryBackend({getServices,sessionController,get
       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 kind=continuationKind(text);
+      const continuation=kind?{kind,tailId:await continuationTail(sid,kind,row.clientId)}:null;
+      if(continuation&&row.createOpts?.planMode!==false)throw deliveryError('INVALID_PARAMS','Manual continuation requires explicit planMode:false');
       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}:{})}}};
+      return {payload:{text,assets:owned.parts,consumed:owned.consumed,mode,...(continuation?{continuation}: {})},queued:{...queued,...(continuation?{createOpts:{...queued.createOpts,planMode:false}}:{}),files:incoming,chatMessage:{...queued.chatMessage,...(row.chatMessage?.images?{images:row.chatMessage.images}:{})}}};
     },
     async dispatch(entry,{releaseAttachmentRef}={}){
       assertNoStructuredSessionReferences(entry.request,entry.payload);
       let agent;
       try{agent=await agentFor(entry.sessionId);}catch(error){error.deliveryNotAdmitted=true;throw error;}
+      if(entry.payload.continuation) {
+        try {
+          const origin=entry.payload.continuation;
+          if(await continuationTail(entry.sessionId,origin.kind,entry.clientId)!==origin.tailId)throw deliveryError('CONTINUATION_SUPERSEDED','A newer task superseded this manual continuation');
+          if(typeof ensurePlanModeOff!=='function')throw deliveryError('PLAN_MODE_UNAVAILABLE','Cannot verify native plan mode is off');
+          await ensurePlanModeOff({sessionId:entry.sessionId,agent});
+          if(await continuationTail(entry.sessionId,origin.kind,entry.clientId)!==origin.tailId)throw deliveryError('CONTINUATION_SUPERSEDED','A newer task superseded this manual continuation');
+          services();
+        } catch(error) { error.deliveryNotAdmitted=true; if(error.code==='CONTINUATION_SUPERSEDED')error.deliverySuperseded=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});

package/src/dsh-message-fold.js

@@ -16,8 +16,9 @@
  * history, and model requests all share, so a second copy here would drift.
  */
 import { deriveEventMessage, isAppendSurfaceEvent } from '@deepseek-ai/dsh-session/surface';
-import { createReasoningStream } from './reasoning-stream.js';
+import { createHistoryProjection } from './history-snapshot.js';
 import { turnDiagnosticRow, turnStateFromEvents } from './turn-error.js';
+import { advanceInterruptionMetadata } from './diagnostic-presentation.js';
 import { toCindyMessageRows, toCindyMessages, hydrateImageAttachments } from './cindy-message-row.js';
 
 /** Default page size when the controller does not ask for one. */
@@ -106,7 +107,8 @@ export function foldSessionEvent(event, { sessionId, now = () => new Date() }) {
   const createdAt = Number.isFinite(event.time) ? new Date(event.time).toISOString() : now().toISOString();
   // The controller's own id for a submitted prompt travels with the row so it
   // can retire the copy it showed optimistically.
-  return toCindyMessageRows(message, { sessionId, createdAt, now, promptClientId: promptRpcIdOf(event) });
+  return toCindyMessageRows(message, { sessionId, createdAt, now, promptClientId: promptRpcIdOf(event),
+    reasoningIdentity: event.type === 'assistant/message' ? event.data : null });
 }
 
 /** The `source` a message carries, whichever shape the surface handed over. */
@@ -290,6 +292,18 @@ function widenNewestPage(options) {
   return { ...options, limit: NEWEST_WINDOW_ROWS };
 }
 
+/** Shared public display fold; never changes input delivery evidence. */
+export function displayEventRows(event, context) {
+  const todo = entryForTodoWrite(event);
+  return todo ? toCindyMessageRows(todo.message, { ...context, createdAt: todo.createdAt }) : foldSessionEvent(event, context);
+}
+
+export function historySnapshotFromEvents(events, sessionId, options = {}) {
+  const projection = createHistoryProjection(sessionId);
+  for (const event of events) projection.consume(event, displayEventRows(event, { sessionId }));
+  return projection.snapshot(options);
+}
+
 /**
  * Render one DSH `todo/write` snapshot as the row the phone draws its plan card from.
  *
@@ -376,49 +390,25 @@ export function createMessageReader({
   const seeding = new Map();
   let clock = 0;
 
-  /** Fold one session's log into message entries, in log order. */
+  /** One fold feeds both the legacy raw order and the explicit history snapshot. */
   async function entriesFor(sessionId) {
     const snapshot = await readSessionLog(sessionId);
     const events = Array.isArray(snapshot?.events) ? snapshot.events : [];
     const entries = [];
-    const reasoning = createReasoningStream(sessionId);
+    const history = createHistoryProjection(sessionId);
     let lastSeq = null;
+    let nativeMetadata = null;
+    let nativeValid = true;
     for (const event of events) {
       if (event === null || typeof event !== 'object') continue;
-      // Every event's seq counts, not only the ones that render: contiguity is a
-      // property of the log, and a caller comparing against renders would read a
-      // gap as "nothing happened here".
+      if (!Number.isSafeInteger(event.seq) || event.seq < 0 || (lastSeq !== null && event.seq !== lastSeq + 1)) nativeValid = false;
       if (Number.isFinite(event.seq)) lastSeq = event.seq;
-      reasoning.consume(event);
-      const diagnostic = turnDiagnosticRow(event, sessionId);
-      if (diagnostic) {
-        entries.push({ rows: [diagnostic] });
-        continue;
-      }
-      const todo = entryForTodoWrite(event);
-      if (todo !== null) {
-        entries.push(todo);
-        continue;
-      }
-      if (!isAppendSurfaceEvent(event)) continue;
-      let message;
-      try {
-        message = deriveEventMessage(event);
-      } catch {
-        // One unprojectable event must not cost the whole transcript; the same
-        // rule the surface fold applies per node.
-        continue;
-      }
-      if (message === null || message === undefined) continue;
-      entries.push({
-        message,
-        createdAt: Number.isFinite(event.time) ? new Date(event.time).toISOString() : now().toISOString(),
-        // Same reason as the live fold: the durable read has to identify a user
-        // turn by the id the controller minted, or its optimistic copy survives.
-        promptClientId: promptRpcIdOf(event),
-      });
+      nativeMetadata = advanceInterruptionMetadata(nativeMetadata, event, sessionId);
+      const rows = displayEventRows(event, { sessionId, now });
+      history.consume(event, rows);
+      if (rows.length) entries.push({ rows });
     }
-    return { entries, lastSeq, reasoning };
+    return { entries, lastSeq, history, reasoning: history.reasoning, nativeValid, nativeMetadata: nativeValid ? nativeMetadata : null };
   }
 
   /** Drop the least recently used transcripts, keeping the window bounded. */
@@ -498,9 +488,9 @@ export function createMessageReader({
         // invalidation also detaches this flight so a post-invalidation read starts
         // fresh; an older completion must never overwrite that newer generation.
         if (seeding.get(sessionId) === flight && !flight.dirty) {
-          touch(sessionId, { rows, reasoning: read.reasoning, seq: read.lastSeq, at: clock });
+          touch(sessionId, { rows, history: read.history, reasoning: read.reasoning, seq: read.lastSeq, at: clock, nativeValid: read.nativeValid, nativeMetadata: read.nativeMetadata });
         }
-        return transcripts.get(sessionId) ?? { rows, reasoning: read.reasoning };
+        return transcripts.get(sessionId) ?? { rows, history: read.history, reasoning: read.reasoning, nativeMetadata: read.nativeMetadata };
       } finally {
         // Failure is not an authoritative empty transcript. Release this flight
         // on success or rejection, without deleting a newer read's ownership.
@@ -552,9 +542,10 @@ export function createMessageReader({
       transcripts.delete(sessionId);
       return false;
     }
+    if (entry.nativeValid !== false) entry.nativeMetadata = advanceInterruptionMetadata(entry.nativeMetadata, event, sessionId);
     entry.seq = seq;
     entry.at = ++clock;
-    entry.reasoning.consume(event);
+    // The history projection owns the raw overlay reducer too.
     // A live todo snapshot becomes the same `TodoWrite` row the durable read produces, so
     // the phone's plan card updates while the plan is being worked rather than only when
     // the transcript is re-read.
@@ -562,6 +553,7 @@ export function createMessageReader({
     const rows = todoEntry === null
       ? foldSessionEvent(event, { sessionId, now })
       : toCindyMessageRows(todoEntry.message, { sessionId, createdAt: todoEntry.createdAt, now });
+    entry.history.consume(event, rows);
     // Newest first: this event is the newest thing in the log, so its rows are the
     // new head of the array, in block order.
     if (rows.length > 0) entry.rows = [...rows, ...entry.rows];
@@ -590,7 +582,7 @@ export function createMessageReader({
   readMessages.count = countRows;
   /** Exact project-grouping evidence derived from the same folded transcript. */
   readMessages.activity = async (sessionId) => {
-    const { rows } = await ensureTranscript(sessionId);
+    const { rows, nativeMetadata } = await ensureTranscript(sessionId);
     let userSendAt = null;
     for (let index = rows.length - 1; index >= 0; index -= 1) {
       const row = rows[index];
@@ -599,7 +591,7 @@ export function createMessageReader({
         break;
       }
     }
-    return { messageCount: rows.length, userSendAt };
+    return { messageCount: rows.length, userSendAt, ...(nativeMetadata ? { interruption: nativeMetadata.interruption } : {}) };
   };
   /**
    * The whole cached transcript, newest first.
@@ -609,6 +601,7 @@ export function createMessageReader({
    * The array is the cache's own, so callers treat it as read-only.
    */
   readMessages.all = async (sessionId) => visibleRows(await ensureTranscript(sessionId));
+  readMessages.historySnapshot = async (sessionId) => (await ensureTranscript(sessionId)).history.snapshot();
   // Recovery deliberately bypasses the transcript cache: stale history cannot
   // decide whether the *current* turn has ended. Runtime generation guards the read.
   readMessages.turnState = async (sessionId) => {

package/src/dsh-plugin.js

@@ -3,6 +3,8 @@ import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { createDshInputDeliveryBackend } from './dsh-input-delivery.js';
+import { diagnosticPreferenceStore } from './diagnostic-presentation.js';
+import { ensureNativeContinuationPlanOff } from './continuation-protocol.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';
@@ -70,6 +72,7 @@ const HostSettingsSchema = Schema.object({
   deviceId: Schema.string().default(DEFAULT_HOST_SETTINGS.deviceId),
   deviceName: Schema.string().default(DEFAULT_HOST_SETTINGS.deviceName),
   sessionFlags: Schema.dict(SessionFlagSchema).default({}),
+  diagnosticPresentationV1: Schema.dict(Schema.dict(Schema.dict(Schema.dict(Schema.boolean())))).default({}),
 });
 
 /**
@@ -684,9 +687,9 @@ export function buildDshSource(ctx, serviceName, options = {}) {
      * The work-grouped history window the controller prefers once it has seen
      * `history-view-v1`.
      *
-     * Grouping runs over the same cached transcript the raw window pages
-     * (`readMessages.all`), so the two views can never disagree about what the session
-     * contains — and neither of them re-reads the log to answer.
+     * History consumes an explicit source-order snapshot, not the raw window's legacy
+     * array order. Prefer the flushed/validated durable backend when available; the
+     * fallback reader shares its cached fold and reasoning reducer with its raw window.
      */
     const deliveryServices = { sessions: undefined, persistence: undefined, agents: undefined };
     ctx.inject(['sessions', 'sessionPersistence', 'agents'], deliveryCtx => {
@@ -697,12 +700,20 @@ export function buildDshSource(ctx, serviceName, options = {}) {
       getServices: () => ({ ...deliveryServices, fileSystem: ctx.get('fs'), fileUploads: controls.fileUploads }),
       sessionController,
       getSession: (sessionId) => sessionSource.getSession(sessionId),
+      ensurePlanModeOff: ({agent}) => ensureNativeContinuationPlanOff({agent,controller:planModeFor(agent),getService:name=>ctx.get(name)}),
     });
-    const committedRows = (sessionId) => inputDeliveryBackend.available() ? inputDeliveryBackend.readRows(sessionId) : readMessages.all(sessionId);
+    const committedRows = async (sessionId) => {
+      const rows = await (inputDeliveryBackend.available() ? inputDeliveryBackend.readRows(sessionId) : readMessages.all(sessionId));
+      return options.projectMessages?.(rows) ?? rows;
+    };
     const historyView = readMessages === undefined
       ? undefined
       : createHistoryViewController({
-        rows: committedRows,
+        snapshot: async (sessionId) => {
+          const snapshot = await (inputDeliveryBackend.available()
+            ? inputDeliveryBackend.historySnapshot(sessionId) : readMessages.historySnapshot(sessionId));
+          return { ...snapshot, rows: options.projectMessages?.(snapshot.rows) ?? snapshot.rows };
+        },
         // 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
@@ -1881,6 +1892,7 @@ export function apply(ctx, config) {
         // Delete/pin and old archive overlays persist here; new archives live in
         // DSH's native workspace registry, not this plugin's settings section.
         persistSessionFlags: sessionFlagsWriter(ctx.settings, settingsNamespace(SETTINGS_NAMESPACE)),
+        diagnosticPreferences: diagnosticPreferenceStore(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'),
 
         identityIsCurrent: () => admitted || (!runtimeDisposed && lease()),
@@ -1914,6 +1926,7 @@ export function apply(ctx, config) {
         // Read lazily: the runtime resolves after this seam is built, and the state changes on
         // every turn boundary.
         isSessionRunning: (sessionId) => runtime?.isSessionRunning?.(sessionId) === true,
+        projectMessages: rows => runtime?.projectMessages?.(rows) ?? rows,
         getProjectOrderOwner: () => runtime?.getProjectOrderOwner?.(),
       });
       // The filesystem is a separate service; the controller's file reads are

package/src/dsh-session-source.js

@@ -207,7 +207,7 @@ export function createSessionControllerSource({
       const value = result.value;
       if (!Number.isFinite(value?.messageCount) || value.messageCount < 0) return;
       if (value.userSendAt !== null && typeof value.userSendAt !== 'string') return;
-      const evidence = { messageCount: Math.floor(value.messageCount), userSendAt: value.userSendAt };
+      const evidence = { messageCount: Math.floor(value.messageCount), userSendAt: value.userSendAt, ...(Object.hasOwn(value, 'interruption') ? { interruption: value.interruption } : {}) };
       activityEvidenceCache.set(ids[index], evidence);
       out?.set(ids[index], evidence);
     });
@@ -359,7 +359,7 @@ export function createSessionControllerSource({
           ...(typeof selectedProvider === 'string' && selectedProvider !== '' ? { providerId: selectedProvider } : {}),
           ...(typeof selectedEffort === 'string' && selectedEffort !== '' ? { effort: selectedEffort } : {}),
           ...(currentPermission === undefined ? {} : { permissionMode: currentPermission }),
-          ...(activity === undefined ? {} : { messageCount: activity.messageCount, userSendAt: activity.userSendAt }),
+          ...(activity === undefined ? {} : { messageCount: activity.messageCount, userSendAt: activity.userSendAt, ...(Object.hasOwn(activity, 'interruption') ? { interruption: activity.interruption } : {}) }),
           blank: item.blank === true,
         };
       });

package/src/history-delivery-state.js

@@ -0,0 +1,32 @@
+/** Disposable transport state, scoped to an accepted controller and its subscription lease. */
+export function createHistoryDeliveryState(canWatch) {
+  const controllers = new Map();
+  function forget(deviceId, sessionId) {
+    if (sessionId === undefined) controllers.delete(deviceId);
+    else { const sessions = controllers.get(deviceId); sessions?.delete(sessionId); if (!sessions?.size) controllers.delete(deviceId); }
+  }
+  function ready(deviceId, sessionId) {
+    if (!canWatch(deviceId, sessionId)) { forget(deviceId, sessionId); return false; }
+    return controllers.get(deviceId)?.get(sessionId)?.ready === true;
+  }
+  function begin(frame) {
+    if (frame.payload?.channel !== 'local-db:messages:view') return null;
+    const sessionId = frame.payload.args?.[0];
+    if (typeof sessionId !== 'string' || !canWatch(frame.src, sessionId)) return null;
+    const sessions = controllers.get(frame.src) ?? new Map();
+    const latest = !(typeof frame.payload.args?.[1]?.before === 'string' && frame.payload.args[1].before !== '');
+    const token = { deviceId: frame.src, sessionId, latest, dirty: false,
+      ready: !latest && sessions.get(sessionId)?.ready === true };
+    sessions.set(sessionId, token); controllers.set(frame.src, sessions);
+    return token;
+  }
+  function finish(token, success) {
+    if (!token || controllers.get(token.deviceId)?.get(token.sessionId) !== token) return false;
+    if (!success || !canWatch(token.deviceId, token.sessionId)) { forget(token.deviceId, token.sessionId); return false; }
+    if (token.latest) token.ready = true;
+    const dirty = token.dirty; token.dirty = false;
+    return dirty;
+  }
+  function changed(sessionId) { for (const sessions of controllers.values()) { const state = sessions.get(sessionId); if (state) state.dirty = true; } }
+  return { ready, begin, finish, changed, forget, clear: () => controllers.clear() };
+}