@clowder-ai/companion 0.1.0-alpha.3 → 0.1.0-alpha.31

package/renderer/reply-letter-controller.mjs

@@ -0,0 +1,361 @@
+import { newestHistoryAnchor, projectReplyBody, selectReplyPresentation } from './reply-letter-state.mjs';
+
+const replyVisibleDuration = text => Math.min(30_000, 6_000 + Math.ceil([...text].length / 8) * 1_000);
+
+/**
+ * Transient presentation state for a Host-owned conversation.
+ *
+ * Inputs are normalized bridge rows. In particular, inputMessageIds must be
+ * supplied by the trusted Host projection; this controller never guesses a
+ * relationship from timestamps, call ids, adjacency or equal text.
+ */
+export class ReplyLetterController {
+  constructor({ render, requestContinuation = () => {}, now = Date.now,
+    schedule = setTimeout, cancel = clearTimeout }) {
+    Object.assign(this, { render, requestContinuation, now });
+    this.schedule = (...args) => Reflect.apply(schedule, globalThis, args);
+    this.cancel = (...args) => Reflect.apply(cancel, globalThis, args);
+    this.mode = 'idle';
+    this.pending = new Map();
+    this.settled = [];
+    this.pairs = new Map();
+    this.history = [];
+    this.draft = null;
+    this.letter = null;
+    this.reply = null;
+    this.retained = false;
+    this.hasNewer = false;
+    this.historyPresentation = null;
+    this.selectedMessageId = null;
+    this.pauseReasons = new Set();
+    this.requestedContinuations = new Set();
+    this.dismissedReplies = new Set();
+    this.timerHandle = null;
+    this.timerStartedAt = null;
+    this.timerRemainingMs = 0;
+    this.blockedReason = null;
+    this.draftNotice = null;
+  }
+
+  recordDelivery(receipt, text, context = {}) {
+    this.blockedReason = null;
+    if (receipt.delivery !== 'accepted') {
+      this.draft = {
+        text,
+        clientMessageId: receipt.clientMessageId,
+        ...(context.submissionRevision === undefined ? {} : { submissionRevision: context.submissionRevision }),
+        ...(context.scopeRef === undefined ? {} : { scopeRef: context.scopeRef }),
+        settlement: receipt.delivery === 'rejected' ? receipt.reason : 'unconfirmed',
+      };
+      if (this.mode !== 'history') this.mode = 'compose';
+      this.emit();
+      return;
+    }
+    const letter = { text, clientMessageId: receipt.clientMessageId, inputMessageId: receipt.messageId };
+    const known = this.pending.get(receipt.messageId) ?? this.pairs.get(receipt.messageId)?.letter;
+    if (known?.clientMessageId === receipt.clientMessageId) {
+      if (this.draft?.clientMessageId === receipt.clientMessageId) this.draft = null;
+      this.emit();
+      return;
+    }
+    this.pending.set(receipt.messageId, letter);
+    if (context.restored === false || this.draft?.clientMessageId === receipt.clientMessageId) this.draft = null;
+    if (this.mode !== 'history') {
+      this.stopTimer();
+      this.reply = null;
+      this.letter = letter;
+      this.retained = false;
+      this.mode = 'sent';
+    }
+    this.emit();
+  }
+
+  invalidateDraft(value) {
+    this.draft = {
+      text: value.text,
+      clientMessageId: value.clientMessageId,
+      submissionRevision: value.submissionRevision,
+      scopeRef: value.scopeRef,
+      settlement: value.reason ?? 'scope_changed',
+    };
+    if (this.mode !== 'history') this.mode = 'compose';
+    this.emit();
+  }
+
+  setDraftNotice(value) {
+    if (this.draftNotice === value) return;
+    this.draftNotice = value;
+    this.emit();
+  }
+
+  openCompose() {
+    if (this.reply) this.dismissedReplies.add(this.reply.id);
+    this.stopTimer();
+    this.reply = null;
+    this.letter = null;
+    this.mode = 'compose';
+    this.retained = false;
+    this.hasNewer = false;
+    this.historyPresentation = null;
+    this.selectedMessageId = null;
+    this.pauseReasons.clear();
+    this.emit();
+  }
+
+  loadHistory(rows) {
+    this.history = rows.map(row => ({
+      id: row.id,
+      role: row.role,
+      text: row.text,
+      body: projectReplyBody(row),
+      inputMessageIds: [...(row.inputMessageIds ?? [])],
+      responsePhase: row.responsePhase ?? 'unknown',
+      deliveryReceipt: row.deliveryReceipt ? { ...row.deliveryReceipt } : undefined,
+    }));
+    let restoredLetter = null;
+    for (const row of this.history) {
+      const receipt = row.deliveryReceipt;
+      if (row.role !== 'user' || receipt?.delivery !== 'accepted' || receipt.messageId !== row.id) continue;
+      if (this.pending.has(row.id) || this.pairs.has(row.id)) continue;
+      restoredLetter = {
+        text: row.text,
+        clientMessageId: receipt.clientMessageId,
+        inputMessageId: row.id,
+      };
+      this.pending.set(row.id, restoredLetter);
+    }
+    let newestPair = null;
+    const settledNow = [];
+    for (const row of this.history) {
+      if (row.role !== 'assistant') continue;
+      if (row.responsePhase === 'completed') this.requestMissingBody(row);
+      for (const inputMessageId of row.inputMessageIds) {
+        const pending = this.pending.get(inputMessageId);
+        const existing = this.pairs.get(inputMessageId);
+        if (!pending && !existing) continue;
+        if (row.responsePhase !== 'completed') {
+          if (pending) {
+            const updated = { ...pending, responsePhase: row.responsePhase };
+            this.pending.set(inputMessageId, updated);
+            if (this.letter?.inputMessageId === inputMessageId) this.letter = updated;
+          }
+          continue;
+        }
+        const letter = pending ?? existing.letter;
+        const pair = { inputMessageId, replyId: row.id, letter, reply: this.replyValue(row) };
+        if (!existing) {
+          this.pending.delete(inputMessageId);
+          this.settled.push({ inputMessageId, replyId: row.id });
+          settledNow.push(pair);
+        }
+        this.pairs.set(inputMessageId, pair);
+        newestPair = pair;
+      }
+    }
+
+    const presentationPair = selectReplyPresentation({ mode: this.mode, letter: this.letter,
+      reply: this.reply, settledPairs: settledNow, pairs: this.pairs,
+      dismissedReplies: this.dismissedReplies });
+    if (newestPair && this.mode === 'history') {
+      if (newestPair.replyId !== this.selectedMessageId) this.hasNewer = true;
+    } else if (presentationPair) {
+      const changedReply = this.reply?.id !== presentationPair.replyId;
+      const becameComplete = this.reply?.id === presentationPair.replyId
+        && this.reply.complete === false && presentationPair.reply.complete === true;
+      this.letter = presentationPair.letter;
+      this.reply = presentationPair.reply;
+      this.selectedMessageId = presentationPair.replyId;
+      this.mode = 'reply';
+      this.historyPresentation = null;
+      if (changedReply) {
+        this.retained = false;
+        this.pauseReasons.clear();
+        this.stopTimer();
+      }
+      if ((changedReply || becameComplete) && presentationPair.reply.complete) {
+        this.timerRemainingMs = replyVisibleDuration(presentationPair.reply.text);
+        this.startTimer();
+      }
+    } else if (this.mode === 'sent') {
+      this.letter = [...this.pending.values()].at(-1) ?? null;
+      if (!this.letter) this.mode = 'idle';
+    } else if (restoredLetter && this.mode === 'idle') {
+      this.letter = restoredLetter;
+      this.mode = 'sent';
+    }
+    this.emit();
+  }
+
+  replyValue(row) {
+    return { id: row.id, text: row.text, complete: row.body.complete,
+      responsePhase: row.responsePhase };
+  }
+
+  requestMissingBody(row) {
+    const reference = row.body.continuation;
+    if (row.body.complete || !reference) {
+      for (const key of this.requestedContinuations) {
+        if (key.startsWith(`${row.id}\u0000`)) this.requestedContinuations.delete(key);
+      }
+      return;
+    }
+    const key = `${row.id}\u0000${reference}`;
+    if (this.requestedContinuations.has(key)) return;
+    this.requestedContinuations.add(key);
+    this.requestContinuation({ messageId: row.id, continuation: reference });
+  }
+
+  releaseContinuation(messageId, continuation) {
+    this.requestedContinuations.delete(`${messageId}\u0000${continuation}`);
+  }
+
+  pause(reason) {
+    if (this.pauseReasons.has(reason)) return;
+    this.pauseReasons.add(reason);
+    if (this.timerHandle !== null) {
+      this.timerRemainingMs = Math.max(0, this.timerRemainingMs - (this.now() - this.timerStartedAt));
+      this.stopTimer(false);
+    }
+    this.emit();
+  }
+
+  resume(reason) {
+    if (!this.pauseReasons.delete(reason)) return;
+    if (this.pauseReasons.size === 0) this.startTimer();
+    this.emit();
+  }
+
+  pin() {
+    if (this.mode !== 'reply') return;
+    this.retained = true;
+    this.stopTimer();
+    this.emit();
+  }
+
+  close() {
+    if (this.reply) this.dismissedReplies.add(this.reply.id);
+    this.stopTimer();
+    this.reply = null;
+    this.retained = false;
+    this.historyPresentation = null;
+    this.selectedMessageId = null;
+    this.letter = [...this.pending.values()].at(-1) ?? null;
+    this.mode = this.letter ? 'sent' : 'idle';
+    this.emit();
+  }
+
+  withdrawReply(replyId) {
+    let restored = null;
+    for (const [inputMessageId, pair] of this.pairs) {
+      if (pair.replyId !== replyId) continue;
+      restored = { ...pair.letter, responsePhase: 'withdrawn' };
+      this.pairs.delete(inputMessageId);
+      this.pending.set(inputMessageId, restored);
+    }
+    this.settled = this.settled.filter(value => value.replyId !== replyId);
+    this.history = this.history.filter(value => value.id !== replyId);
+    this.dismissedReplies.delete(replyId);
+    for (const key of this.requestedContinuations) {
+      if (key.startsWith(`${replyId}\u0000`)) this.requestedContinuations.delete(key);
+    }
+    if (this.reply?.id === replyId) {
+      this.stopTimer();
+      this.reply = null;
+      this.retained = false;
+      this.historyPresentation = null;
+      this.selectedMessageId = null;
+      this.letter = restored ?? [...this.pending.values()].at(-1) ?? null;
+      this.mode = this.letter ? 'sent' : 'idle';
+    }
+    this.emit();
+  }
+
+  clearProtected(reason) {
+    this.stopTimer();
+    this.pending.clear();
+    this.settled = [];
+    this.pairs.clear();
+    this.history = [];
+    this.letter = null;
+    this.reply = null;
+    this.retained = false;
+    this.hasNewer = false;
+    this.historyPresentation = null;
+    this.selectedMessageId = null;
+    this.requestedContinuations.clear();
+    this.dismissedReplies.clear();
+    this.blockedReason = reason;
+    this.mode = this.draft ? 'compose' : 'idle';
+    this.emit();
+  }
+
+  openHistory(messageId = newestHistoryAnchor(this.selectedMessageId, this.settled, this.history)) {
+    this.stopTimer();
+    this.mode = 'history';
+    this.retained = true;
+    this.historyPresentation = 'conversation';
+    this.selectedMessageId = messageId;
+    this.hasNewer = false;
+    this.emit();
+  }
+
+  openReplyHistory(messageId = newestHistoryAnchor(this.selectedMessageId, this.settled, this.history)) {
+    this.stopTimer();
+    this.mode = 'history';
+    this.retained = true;
+    this.historyPresentation = 'reply';
+    this.selectedMessageId = messageId;
+    this.hasNewer = false;
+    this.emit();
+  }
+
+  returnLatest() {
+    this.selectedMessageId = this.settled.at(-1)?.replyId ?? this.history.at(-1)?.id ?? null;
+    this.hasNewer = false;
+    this.emit();
+  }
+
+  startTimer() {
+    if (this.timerHandle !== null || this.timerRemainingMs <= 0 || this.retained
+      || this.mode !== 'reply' || !this.reply?.complete || this.pauseReasons.size > 0) return;
+    this.timerStartedAt = this.now();
+    this.timerHandle = this.schedule(() => {
+      this.timerHandle = null;
+      this.timerStartedAt = null;
+      this.timerRemainingMs = 0;
+      this.close();
+    }, this.timerRemainingMs);
+  }
+
+  stopTimer(reset = true) {
+    if (this.timerHandle !== null) this.cancel(this.timerHandle);
+    this.timerHandle = null;
+    this.timerStartedAt = null;
+    if (reset) this.timerRemainingMs = 0;
+  }
+
+  snapshot() {
+    const elapsed = this.timerHandle === null ? 0 : this.now() - this.timerStartedAt;
+    return {
+      mode: this.mode,
+      draft: this.draft,
+      letter: this.letter,
+      reply: this.reply,
+      retained: this.retained,
+      historyPresentation: this.mode === 'history' ? this.historyPresentation : null,
+      selectedMessageId: this.selectedMessageId,
+      hasNewer: this.hasNewer,
+      blockedReason: this.blockedReason,
+      draftNotice: this.draftNotice,
+      pendingInputMessageIds: [...this.pending.keys()],
+      settled: this.settled.map(value => ({ ...value })),
+      history: this.history.map(row => ({ ...row, body: { ...row.body }, inputMessageIds: [...row.inputMessageIds] })),
+      timer: {
+        running: this.timerHandle !== null,
+        remainingMs: Math.max(0, this.timerRemainingMs - elapsed),
+      },
+    };
+  }
+
+  emit() { this.render(this.snapshot()); }
+}

package/renderer/reply-letter-state.mjs

@@ -0,0 +1,38 @@
+export const projectReplyBody = row => ({
+  revision: row.body?.revision ?? '',
+  complete: row.body?.complete === true,
+  continuation: row.body?.continuation ?? null,
+});
+
+function newestSettledPair(settledPairs, dismissedReplies, inputMessageId) {
+  for (let index = settledPairs.length - 1; index >= 0; index -= 1) {
+    const pair = settledPairs[index];
+    if (dismissedReplies.has(pair.replyId)) continue;
+    if (inputMessageId !== undefined && pair.inputMessageId !== inputMessageId) continue;
+    return pair;
+  }
+  return undefined;
+}
+
+/** Only a newly settled relevant reply, or the reply already on screen, may take presentation focus. */
+export function selectReplyPresentation({ mode, letter, reply, settledPairs, pairs, dismissedReplies }) {
+  if (mode === 'compose' || mode === 'history') return undefined;
+  if (mode === 'sent') {
+    if (!letter) return undefined;
+    return newestSettledPair(settledPairs, dismissedReplies, letter.inputMessageId);
+  }
+  const freshPair = newestSettledPair(settledPairs, dismissedReplies);
+  if (mode === 'idle' || (mode === 'reply' && freshPair)) return freshPair;
+  if (mode !== 'reply' || !reply) return undefined;
+  for (const pair of pairs.values()) {
+    if (pair.replyId === reply.id) return pair;
+  }
+  return undefined;
+}
+
+export function newestHistoryAnchor(selectedMessageId, settled, history) {
+  if (selectedMessageId !== null) return selectedMessageId;
+  const settledReplyId = settled.at(-1)?.replyId;
+  if (settledReplyId !== undefined) return settledReplyId;
+  return history.at(-1)?.id ?? null;
+}

package/renderer/reply-letter-view.mjs

@@ -0,0 +1,116 @@
+const phaseLabel = phase => ({
+  processing: '正在回复',
+  failed: '回复失败',
+  interrupted: '回复中断',
+  canceled: '回复已取消',
+  withdrawn: '回复已撤回',
+}[phase] ?? '已发送');
+
+const draftStatus = settlement => ({
+  unconfirmed: '发送结果未确认',
+  scope_changed: '原聊天已变化 · 这条消息没有重发',
+  pending_limit: '待确认消息已达 32 条 · 这条没有发送',
+  draft_changed: '草稿已在别处变化 · 请核对后再发送',
+  unsupported_draft: '当前草稿含附件或过长 · 请回 Cat Café 继续编辑',
+  conflict: '草稿已在别处变化 · 本地输入仍保留',
+  readonly: '当前草稿含附件或过长 · 请回 Cat Café 继续编辑',
+  permission_required: '聊天权限已撤销 · 本地输入仍保留',
+  unavailable: '草稿暂未同步 · 本地输入仍保留',
+}[settlement] ?? '');
+
+/** DOM projection for compose → sent letter → complete reply → retained history. */
+export class ReplyLetterView {
+  constructor({ document, controller, retry, schedule = setTimeout, cancel = clearTimeout }) {
+    this.$ = id => document.getElementById(id);
+    Object.assign(this, { controller, retry });
+    this.schedule = (...args) => Reflect.apply(schedule, globalThis, args);
+    this.cancel = (...args) => Reflect.apply(cancel, globalThis, args);
+    this.bind();
+  }
+
+  bind() {
+    const card = this.$('reply-card');
+    card.addEventListener('pointerenter', () => this.controller.pause('hover'));
+    card.addEventListener('pointerleave', () => this.controller.resume('hover'));
+    card.addEventListener('focusin', () => this.controller.pause('focus'));
+    card.addEventListener('focusout', event => {
+      if (!event.relatedTarget || !card.contains?.(event.relatedTarget)) this.controller.resume('focus');
+    });
+    const pauseScroll = () => {
+      this.controller.pause('scroll');
+      if (this.scrollTimer !== undefined) this.cancel(this.scrollTimer);
+      this.scrollTimer = this.schedule(() => {
+        this.scrollTimer = undefined;
+        this.controller.resume('scroll');
+      }, 500);
+      this.scrollTimer?.unref?.();
+    };
+    card.addEventListener('wheel', pauseScroll);
+    card.addEventListener('scroll', pauseScroll);
+    card.addEventListener('pointerdown', () => this.controller.pause('pointer'));
+    card.addEventListener('pointerup', () => this.controller.resume('pointer'));
+    card.addEventListener('pointercancel', () => this.controller.resume('pointer'));
+    this.$('reply-retain').onclick = () => this.controller.pin();
+    this.$('reply-close').onclick = () => this.controller.close();
+    this.$('reply-history-open').onclick = () => this.controller.openReplyHistory();
+    this.$('reply-return-latest').onclick = () => this.controller.returnLatest();
+    this.$('reply-retry').onclick = () => { if (this.value?.draft) this.retry(this.value.draft); };
+  }
+
+  render(value) {
+    this.value = value;
+    const history = value.mode === 'history';
+    const replyHistory = history && value.historyPresentation === 'reply';
+    const conversationHistory = history && !replyHistory;
+    const compose = value.mode === 'compose' || conversationHistory;
+    this.$('compose').hidden = !compose;
+    this.$('chat-history-header').hidden = !conversationHistory;
+    this.$('chat-name').hidden = replyHistory;
+    this.$('chat-history-dismiss').hidden = replyHistory;
+    this.$('reply-history-close').hidden = !replyHistory;
+    this.$('chat-transcript-shell').hidden = !history;
+    this.$('chat-transcript-shell').dataset.hasNewer = String(history && value.hasNewer);
+    this.$('chat-transcript').hidden = !history;
+    this.$('chat-scope').hidden = !conversationHistory;
+    this.$('chat-connection-status').hidden = replyHistory;
+    this.$('reply-sent').hidden = value.mode !== 'sent';
+    this.$('reply-card').hidden = value.mode !== 'reply';
+    this.$('reply-return-latest').hidden = !history || !value.hasNewer;
+
+    const retrying = value.mode === 'compose' && value.draft?.settlement === 'unconfirmed';
+    this.$('reply-retry').hidden = !retrying;
+    const feedback = value.draft ? draftStatus(value.draft.settlement)
+      : value.draftNotice ? draftStatus(value.draftNotice)
+      : value.blockedReason === 'permission_required' ? '聊天权限已撤销' : '';
+    this.$('chat-status').textContent = feedback;
+    this.$('chat-feedback').hidden = !compose || (!feedback && !retrying);
+    if (value.draft) {
+      const input = this.$('message');
+      if (!input.value || input.value === this.lastRenderedDraft) input.value = value.draft.text;
+      this.lastRenderedDraft = value.draft.text;
+    }
+
+    if (value.letter) {
+      this.$('reply-letter-text').textContent = '';
+      this.$('reply-letter-text').hidden = true;
+      this.$('reply-input-text').textContent = value.letter.text;
+      this.$('reply-sent-status').textContent = phaseLabel(value.letter.responsePhase);
+    }
+    if (value.reply) {
+      this.$('reply-body').textContent = value.reply.text;
+      this.$('reply-body-status').textContent = value.reply.complete ? '' : '正在载入完整回复…';
+    } else {
+      this.$('reply-body').textContent = '';
+      this.$('reply-body-status').textContent = '';
+    }
+
+    const canRetain = value.mode === 'reply' && value.reply?.complete === true && !value.retained;
+    this.$('reply-retain').hidden = !canRetain;
+    this.$('reply-close').hidden = value.mode !== 'reply' || !value.retained;
+    this.$('reply-retain').dataset.running = String(canRetain && value.timer.running);
+    this.$('reply-retain').style.setProperty('--reply-visible-ms', `${value.timer.remainingMs}ms`);
+    this.$('chat').dataset.replyMode = value.mode;
+    this.$('chat').dataset.historyPresentation = history
+      ? value.historyPresentation ?? 'conversation' : '';
+  }
+}

package/renderer/settings-controller.mjs

@@ -0,0 +1,171 @@
+const sameValue = (left, right) => Object.is(left, right);
+const canStopCall = field => ['dutyCatProfileId', 'householdReadsAllowed'].includes(field);
+
+/**
+ * Renderer-side settings state only. The Host remains the single source of
+ * persisted values, roster truth, media stopping and plugin lifecycle.
+ */
+export class SettingsController {
+  constructor({ client, changed = () => {} }) {
+    this.client = client;
+    this.changed = changed;
+    this.readOperation = 0;
+    this.writeOperation = 0;
+    this.state = { phase: 'idle', page: 'main', saving: false, notice: null, confirmation: null, retry: null };
+  }
+
+  publish(patch = {}) {
+    this.state = { ...this.state, ...patch };
+    this.changed(this.state);
+  }
+
+  applySettings(reply, patch = {}) {
+    if (reply?.kind !== 'settings' || reply.status !== 'available') return false;
+    this.publish({
+      phase: this.state.saving ? 'saving' : 'ready',
+      values: reply.values,
+      companions: reply.companions,
+      selectedCompanionStatus: reply.selectedCompanionStatus,
+      ...patch,
+    });
+    return true;
+  }
+
+  async load({ preserveSettlement = false } = {}) {
+    // A panel reopen is presentation work, not authority to cancel an in-flight
+    // write. The write performs its own canonical readback before settlement.
+    if (this.state.saving) return false;
+    const operation = ++this.readOperation;
+    this.publish({ phase: 'loading', ...(preserveSettlement ? {} : { notice: null, retry: null }) });
+    try {
+      const reply = await this.client.readSettings();
+      if (operation !== this.readOperation) return false;
+      const clearsUnknown = preserveSettlement && this.state.notice?.kind === 'unconfirmed';
+      if (this.applySettings(reply, clearsUnknown ? { notice: null, retry: null } : {})) return true;
+      this.publish({ phase: 'unavailable', reason: reply.reason, saving: false });
+    } catch (error) {
+      if (operation !== this.readOperation) return false;
+      this.publish({ phase: 'unavailable', saving: false,
+        reason: error?.code === 'invalid_request' ? 'host_upgrade_required' : 'temporarily_unavailable' });
+    }
+    return false;
+  }
+
+  navigate(page) {
+    this.publish({ page, confirmation: null });
+  }
+
+  async requestUpdate(field, value, { confirm = false } = {}) {
+    if (this.state.saving || sameValue(this.state.values?.[field], value)) return false;
+    if (confirm) {
+      this.publish({ page: 'confirm',
+        confirmation: { kind: 'setting', field, value, returnPage: this.state.page },
+        notice: null, retry: null });
+      return true;
+    }
+    await this.commitUpdate(field, value, this.state.page);
+    return true;
+  }
+
+  async readCanonical(operation) {
+    try {
+      const reply = await this.client.readSettings();
+      if (operation !== this.writeOperation || reply?.kind !== 'settings' || reply.status !== 'available') return null;
+      return reply;
+    } catch { return null; }
+  }
+
+  async commitUpdate(field, value, returnPage = this.state.page) {
+    if (this.state.saving) return { callStopped: null };
+    const operation = ++this.writeOperation;
+    this.publish({ phase: 'saving', saving: true, notice: null, retry: null });
+    let receipt;
+    try {
+      receipt = await this.client.updateSetting(field, value);
+    } catch {
+      if (operation !== this.writeOperation) return { callStopped: null };
+      const canonical = await this.readCanonical(operation);
+      if (operation !== this.writeOperation) return { callStopped: null };
+      if (canonical) this.applySettings(canonical);
+      const saved = canonical && sameValue(canonical.values[field], value);
+      const callStopped = canStopCall(field) ? null : false;
+      this.publish({ phase: canonical ? 'ready' : this.state.values ? 'ready' : 'unavailable', saving: false,
+        page: returnPage, confirmation: null,
+        retry: canonical && !saved ? { field, value } : null,
+        notice: canonical
+          ? { kind: saved ? 'reconciled_saved' : 'reconciled_not_saved', field, callStopped }
+          : { kind: 'unconfirmed', field, callStopped } });
+      return { callStopped };
+    }
+    if (operation !== this.writeOperation) return { callStopped: null };
+    const canonical = await this.readCanonical(operation);
+    if (operation !== this.writeOperation) return { callStopped: null };
+    if (canonical) this.applySettings(canonical);
+    const callStopped = receipt.callStatus === 'stopped';
+    let notice;
+    if (receipt.outcome === 'saved') {
+      notice = { kind: 'saved', field, callStopped, applies: receipt.applies };
+    } else if (receipt.outcome === 'rejected') {
+      notice = { kind: 'rejected', field, callStopped, reason: receipt.reason };
+    } else if (!canonical) {
+      notice = { kind: 'unconfirmed', field, callStopped };
+    } else {
+      notice = {
+        kind: sameValue(canonical.values[field], value) ? 'reconciled_saved' : 'reconciled_not_saved',
+        field,
+        callStopped,
+      };
+    }
+    const retry = (receipt.outcome === 'rejected' && ['save_failed', 'call_stop_failed'].includes(receipt.reason))
+      || (receipt.outcome === 'unconfirmed' && canonical && !sameValue(canonical.values[field], value))
+      ? { field, value } : null;
+    this.publish({ phase: canonical ? 'ready' : this.state.values ? 'ready' : 'unavailable', saving: false,
+      page: returnPage, confirmation: null, notice, retry });
+    return { callStopped };
+  }
+
+  async confirm() {
+    const confirmation = this.state.confirmation;
+    if (!confirmation || this.state.saving) return { callStopped: null };
+    if (confirmation.kind === 'setting') {
+      return this.commitUpdate(confirmation.field, confirmation.value, confirmation.returnPage);
+    }
+    const operation = ++this.writeOperation;
+    this.publish({ phase: 'saving', saving: true, notice: null });
+    try {
+      await this.client.disableCompanion();
+      if (operation !== this.writeOperation) return { callStopped: null };
+      this.publish({ phase: 'disabled', saving: false, confirmation: null });
+      return { callStopped: true };
+    } catch {
+      if (operation !== this.writeOperation) return { callStopped: null };
+      this.publish({ phase: this.state.values ? 'ready' : 'unavailable', saving: false,
+        page: confirmation.returnPage, confirmation: null, notice: { kind: 'disable_failed' } });
+      return { callStopped: null };
+    }
+  }
+
+  requestDisable() {
+    if (this.state.saving) return;
+    this.publish({ page: 'disable', confirmation: { kind: 'disable', returnPage: this.state.page }, notice: null });
+  }
+
+  async retry({ confirm = false } = {}) {
+    const retry = this.state.retry;
+    if (!retry || this.state.saving) return;
+    if (confirm && canStopCall(retry.field)) {
+      this.publish({ page: 'confirm',
+        confirmation: { kind: 'setting', field: retry.field, value: retry.value, returnPage: this.state.page } });
+      return;
+    }
+    await this.commitUpdate(retry.field, retry.value, this.state.page);
+  }
+
+  async resetPosition() {
+    if (this.state.saving) return;
+    try {
+      await this.client.resetPosition();
+      this.publish({ notice: { kind: 'position_reset' } });
+    } catch { this.publish({ notice: { kind: 'position_reset_failed' } }); }
+  }
+}