diff --git a/AGENTS.md b/AGENTS.md
index 6e34f197c..2e6faaa78 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -88,6 +88,8 @@ Saved projects are listed through [ProjectSummaries](src/services/projectSummari
 
 [AnalysisSessions](src/services/analysisSessions.ts) keeps the host's sessions, behind the `openSession`, `closeSession` and `setAnalysisLanguage` commands. A session is a handle on one source project's draft, paired with the interlinear project it saves to, or on a Paratext 9 import alone, read-only. A source has at most one session: opening another closes it. Each session runs its commands one at a time, through `run`, or `runEdit` for a command that changes stored analysis, which a read-only session refuses. An edit reaches the repository as a `ChangeSet` of whole-record puts and deletes, applied through the session's [EditHistory](src/services/editHistory.ts) so that undo can revert it; boundary changes ride in the change set's scope record. The WebView doesn't use sessions yet.
 
+Host commands live in [src/services/commands/](src/services/commands/), one module per family. A command stages its changes in a [ChangeBuffer](src/services/commands/changeBuffer.ts), whose reads answer as the repository will once those changes apply, and `AnalysisSessions.edit` applies what it staged as one undo step after the approval rule passes. Each command copies the reducer it replaces, step for step, and its parity tests run one input through both with [runParity](src/__tests__/services/commands/parity.ts); a reducer change in Phase 3 updates its command and parity tests in the same PR.
+
 ### Components
 
 Prefer Platform.Bible's `platform-bible-react` components (`Button`, `Input`, `Textarea`, `Label`, `Switch`, `RadioGroup`, `Popover`, `Tooltip`, etc.) over hand-rolled raw HTML (`<button>`, `<input>`, `<textarea>`, `<label>`, custom dropdowns) wherever an equivalent exists — this keeps the UI visually and behaviorally consistent with the host app and gives us theming and accessibility for free. Reserve raw elements for cases where the platform component can't preserve behavior the extension depends on (e.g. `field-sizing: content` gloss inputs); when you do, add a comment explaining why. When a raw element is replaced by a platform component in tests, extend `__mocks__/platform-bible-react.tsx` to stub the newly-used component.
diff --git a/src/__tests__/analysis-repository-conformance.ts b/src/__tests__/analysis-repository-conformance.ts
index b4a41e3f8..022aca122 100644
--- a/src/__tests__/analysis-repository-conformance.ts
+++ b/src/__tests__/analysis-repository-conformance.ts
@@ -1229,6 +1229,27 @@ export function describeAnalysisRepositoryConformance(
         return store.open(SOURCE);
       }
 
+      it("reads the draft's own record", async () => {
+        const repository = await overFullDraft();
+
+        await expect(repository.getScope()).resolves.toStrictEqual(scopeRecordOf(fullDraft()));
+      });
+
+      it("reads the record of a draft never saved as an empty draft's", async () => {
+        await expect((await store.open(SOURCE)).getScope()).resolves.toStrictEqual(
+          scopeRecordOf(emptyDraft(SOURCE)),
+        );
+      });
+
+      it('reads the record the applied changes leave', async () => {
+        const repository = await overFullDraft();
+        const scope = { ...scopeRecordOf(fullDraft()), analysisLanguages: ['de'] };
+
+        await repository.apply({ intent: 'rescope', scope });
+
+        await expect(repository.getScope()).resolves.toStrictEqual(scope);
+      });
+
       it('gets each payload kind by id, once per id, skipping ids with nothing stored', async () => {
         const repository = await overFullDraft();
 
diff --git a/src/__tests__/main.test.ts b/src/__tests__/main.test.ts
index b24169bbe..7973e5b8d 100644
--- a/src/__tests__/main.test.ts
+++ b/src/__tests__/main.test.ts
@@ -12,6 +12,7 @@ import * as projectStorage from '../services/projectStorage';
 import * as pt9ImportService from '../services/pt9ImportService';
 import { type AnalysisRepository, UnreadableBooksError } from '../types/analysis-repository';
 import { emptyDraft } from '../types/empty-factories';
+import { scopeRecordOf } from '../utils/change-set';
 import { toProjectSummary } from '../types/interlinear-project-summary';
 import { createTestActivationContext, makeStubProject } from './test-helpers';
 
@@ -401,6 +402,8 @@ describe('main', () => {
           'interlinearizer.undoEdit',
           'interlinearizer.redoEdit',
           'interlinearizer.checkIndexes',
+          'interlinearizer.writeGloss',
+          'interlinearizer.approveAnalysisForToken',
           'interlinearizer.openSelectProjectModal',
           'interlinearizer.openNewProjectModal',
           'interlinearizer.openProjectInfoModal',
@@ -1848,6 +1851,7 @@ describe('main', () => {
         checkIndexes: async () => [
           { index: 'tokenAnalyses', key: 'ta-1', missing: ['ta-1'], extra: [] },
         ],
+        getScope: async () => scopeRecordOf(draft),
       };
     }
 
@@ -1877,6 +1881,22 @@ describe('main', () => {
         checkIndexes: handler<(sessionId: string) => Promise<string>>(
           'interlinearizer.checkIndexes',
         ),
+        writeGloss: handler<
+          (
+            sessionId: string,
+            tokenRef: string,
+            surfaceText: string,
+            value: string,
+          ) => Promise<string>
+        >('interlinearizer.writeGloss'),
+        approveAnalysisForToken: handler<
+          (
+            sessionId: string,
+            tokenRef: string,
+            surfaceText: string,
+            analysisId: string,
+          ) => Promise<string>
+        >('interlinearizer.approveAnalysisForToken'),
       };
     }
 
@@ -2060,6 +2080,44 @@ describe('main', () => {
       );
     });
 
+    it("writes a token's gloss in the session's language, replying with the changes", async () => {
+      const { openSession, setAnalysisLanguage, writeGloss } = await activateSessionCommands();
+      const { sessionId } = JSON.parse(await openSession('src-project'));
+      await setAnalysisLanguage(sessionId, 'fr');
+
+      const changes = JSON.parse(await writeGloss(sessionId, 'GEN 1:1:0', 'In', 'au'));
+
+      expect(changes).toMatchObject({
+        intent: 'writeGloss',
+        tokenAnalyses: { puts: [{ surfaceText: 'In', gloss: { fr: 'au' } }], deletes: [] },
+        tokenAnalysisLinks: {
+          puts: [{ status: 'approved', token: { tokenRef: 'GEN 1:1:0', surfaceText: 'In' } }],
+          deletes: [],
+        },
+      });
+    });
+
+    it('logs the error and rethrows when an edit fails', async () => {
+      const { writeGloss } = await activateSessionCommands();
+
+      await expect(writeGloss('not-a-session', 'GEN 1:1:0', 'In', 'at')).rejects.toThrow(
+        'no session not-a-session is open',
+      );
+      expect(__mockLogger.error).toHaveBeenCalledWith(
+        'Interlinearizer: failed to writeGloss in session not-a-session',
+        expect.any(Error),
+      );
+    });
+
+    it('approves an analysis for a token, replying with the changes', async () => {
+      const { openSession, approveAnalysisForToken } = await activateSessionCommands();
+      const { sessionId } = JSON.parse(await openSession('src-project'));
+
+      await expect(
+        approveAnalysisForToken(sessionId, 'GEN 1:1:0', 'In', 'ta-unknown').then(JSON.parse),
+      ).resolves.toStrictEqual({ intent: 'approveAnalysisForToken' });
+    });
+
     it('closes every session on deactivation', async () => {
       const { openSession } = await activateSessionCommands();
       await openSession('src-project');
diff --git a/src/__tests__/services/analysisSessions.test.ts b/src/__tests__/services/analysisSessions.test.ts
index 0ebc62366..e00a8c112 100644
--- a/src/__tests__/services/analysisSessions.test.ts
+++ b/src/__tests__/services/analysisSessions.test.ts
@@ -6,6 +6,7 @@ import {
   type SessionHost,
   UNDETERMINED_LANGUAGE,
 } from '../../services/analysisSessions';
+import { ApprovalRuleError } from '../../services/commands/approvalRule';
 import { DraftRepository } from '../../services/draftRepository';
 import { Pt9ImportRepository } from '../../services/pt9ImportRepository';
 import { draftKey } from '../../services/storageKeys';
@@ -477,6 +478,114 @@ describe('AnalysisSessions', () => {
     });
   });
 
+  describe('edit', () => {
+    const payload = (id: string) => ({ id, ...FIXTURE_STAMPS, surfaceText: id });
+    const approvedLink = (id: string) => ({
+      id,
+      analysisId: 'a',
+      ...FIXTURE_STAMPS,
+      status: 'approved' as const,
+      token: { tokenRef: 'GEN 1:1:0', surfaceText: 'a' },
+    });
+
+    /** The source project's draft as stored. */
+    const stored = async (storage: ReturnType<typeof makeSessions>['storage']) =>
+      (await new DraftRepository(storage, SOURCE, silentLogger()).exportAll()).draft;
+
+    it('applies what the command stages as one undo step, marking the draft dirty', async () => {
+      const { sessions, storage } = makeSessions();
+      const { sessionId } = await sessions.open(SOURCE);
+
+      const changes = await sessions.edit(sessionId, 'add', async (buffer) => {
+        buffer.create('tokenAnalyses', payload('a'));
+        buffer.create('tokenAnalyses', payload('b'));
+      });
+
+      expect(changes).toMatchObject({ intent: 'add' });
+      await expect(stored(storage)).resolves.toMatchObject({
+        dirty: true,
+        analysis: { tokenAnalyses: [payload('a'), payload('b')] },
+      });
+      await sessions.undo(sessionId);
+      await expect(stored(storage)).resolves.toMatchObject({ analysis: { tokenAnalyses: [] } });
+    });
+
+    it("lists the session's analysis language on a draft listing none, undoing it with the edit", async () => {
+      const { host, sessions, storage } = makeSessions();
+      host.getInterfaceLanguages.mockResolvedValue(['de']);
+      const { sessionId } = await sessions.open(SOURCE);
+
+      await sessions.edit(sessionId, 'add', async (buffer) => {
+        buffer.create('tokenAnalyses', payload('a'));
+      });
+
+      await expect(stored(storage)).resolves.toMatchObject({ analysisLanguages: ['de'] });
+      await sessions.undo(sessionId);
+      await expect(stored(storage)).resolves.toMatchObject({ analysisLanguages: [] });
+    });
+
+    it('leaves the analysis languages of a draft listing some', async () => {
+      const { sessions, storage, saveDraft } = makeSessions();
+      await saveDraft({ ...emptyDraft(SOURCE), analysisLanguages: ['fr', 'en'] });
+      const { sessionId } = await sessions.open(SOURCE);
+      await sessions.setAnalysisLanguage(sessionId, 'de');
+
+      const changes = await sessions.edit(sessionId, 'add', async (buffer) => {
+        buffer.create('tokenAnalyses', payload('a'));
+      });
+
+      expect(changes.scope).toBeUndefined();
+      await expect(stored(storage)).resolves.toMatchObject({ analysisLanguages: ['fr', 'en'] });
+    });
+
+    it('applies nothing, and records no undo step, for a command staging nothing', async () => {
+      const { sessions, storage } = makeSessions();
+      const { sessionId } = await sessions.open(SOURCE);
+
+      await expect(sessions.edit(sessionId, 'nothing', async () => {})).resolves.toStrictEqual({
+        intent: 'nothing',
+      });
+
+      await expect(sessions.undo(sessionId)).resolves.toBeUndefined();
+      await expect(stored(storage)).resolves.toMatchObject({ dirty: false });
+    });
+
+    it('gives the command the session it runs on', async () => {
+      const { sessions } = makeSessions();
+      const { sessionId } = await sessions.open(SOURCE);
+      await sessions.setAnalysisLanguage(sessionId, 'fr');
+
+      await sessions.edit(sessionId, 'read', async (_buffer, session) => {
+        expect(session.analysisLanguage).toBe('fr');
+      });
+    });
+
+    it('refuses changes that would approve a second analysis for a token, applying nothing', async () => {
+      const { sessions, storage } = makeSessions();
+      const { sessionId } = await sessions.open(SOURCE);
+
+      await expect(
+        sessions.edit(sessionId, 'approveTwice', async (buffer) => {
+          buffer.create('tokenAnalysisLinks', approvedLink('l-1'));
+          buffer.create('tokenAnalysisLinks', approvedLink('l-2'));
+        }),
+      ).rejects.toThrow(ApprovalRuleError);
+
+      await expect(stored(storage)).resolves.toMatchObject({
+        analysis: { tokenAnalysisLinks: [] },
+      });
+    });
+
+    it("refuses an edit on a Paratext 9 import's session without running it", async () => {
+      const { sessions } = makeSessions([makeImport()]);
+      const { sessionId } = await sessions.open(SOURCE, 'import-id');
+      const command = jest.fn(async () => {});
+
+      await expect(sessions.edit(sessionId, 'add', command)).rejects.toThrow(ReadOnlyAnalysisError);
+      expect(command).not.toHaveBeenCalled();
+    });
+  });
+
   describe('setAnalysisLanguage', () => {
     it('sets the language the commands sent after it read', async () => {
       const { sessions } = makeSessions();
diff --git a/src/__tests__/services/commands/approvalRule.test.ts b/src/__tests__/services/commands/approvalRule.test.ts
new file mode 100644
index 000000000..3c37315dd
--- /dev/null
+++ b/src/__tests__/services/commands/approvalRule.test.ts
@@ -0,0 +1,92 @@
+/// <reference types="jest" />
+
+import type { SegmentAnalysisLink, TextAnalysis, TokenAnalysisLink } from 'interlinearizer';
+import { ApprovalRuleError, assertApprovalRule } from '../../../services/commands/approvalRule';
+import { ChangeBuffer } from '../../../services/commands/changeBuffer';
+import { DraftRepository } from '../../../services/draftRepository';
+import { emptyAnalysis, emptyDraft } from '../../../types/empty-factories';
+import { FIXTURE_STAMPS, memoryStorage, silentLogger } from '../../test-helpers';
+
+function tokenLink(
+  id: string,
+  status: TokenAnalysisLink['status'] = 'approved',
+): TokenAnalysisLink {
+  return {
+    id,
+    analysisId: `ta-${id}`,
+    ...FIXTURE_STAMPS,
+    status,
+    token: { tokenRef: 'GEN 1:1:0', surfaceText: 'In' },
+  };
+}
+
+function segmentLink(id: string): SegmentAnalysisLink {
+  return {
+    id,
+    analysisId: `sa-${id}`,
+    ...FIXTURE_STAMPS,
+    status: 'approved',
+    segmentId: 'GEN 1:1',
+  };
+}
+
+async function over(analysis: Partial<TextAnalysis>) {
+  const { storage } = memoryStorage();
+  const repository = new DraftRepository(storage, 'src', silentLogger());
+  await repository.replaceAll({
+    ...emptyDraft('src'),
+    analysis: { ...emptyAnalysis(), ...analysis },
+  });
+  return { repository, buffer: new ChangeBuffer(repository) };
+}
+
+describe('assertApprovalRule', () => {
+  it('accepts changes that leave each token one approval', async () => {
+    const { repository, buffer } = await over({ tokenAnalysisLinks: [tokenLink('a')] });
+
+    buffer.delete('tokenAnalysisLinks', tokenLink('a'));
+    buffer.create('tokenAnalysisLinks', tokenLink('b'));
+
+    await expect(assertApprovalRule(buffer, repository)).resolves.toBeUndefined();
+  });
+
+  it('refuses a second approval for a token', async () => {
+    const { repository, buffer } = await over({ tokenAnalysisLinks: [tokenLink('a')] });
+
+    buffer.create('tokenAnalysisLinks', tokenLink('b'));
+
+    await expect(assertApprovalRule(buffer, repository)).rejects.toThrow(
+      new ApprovalRuleError(['GEN 1:1:0']),
+    );
+  });
+
+  it('refuses a second approval for a segment', async () => {
+    const { repository, buffer } = await over({ segmentAnalysisLinks: [segmentLink('a')] });
+
+    buffer.create('segmentAnalysisLinks', segmentLink('b'));
+
+    await expect(assertApprovalRule(buffer, repository)).rejects.toThrow(ApprovalRuleError);
+  });
+
+  it('accepts changes that leave a stored breach no worse', async () => {
+    const { repository, buffer } = await over({
+      tokenAnalysisLinks: [tokenLink('a'), tokenLink('b'), tokenLink('c', 'suggested')],
+    });
+
+    buffer.put('tokenAnalysisLinks', { ...tokenLink('a'), updatedAt: '2026-06-01T00:00:00.000Z' });
+    buffer.put('tokenAnalysisLinks', tokenLink('c', 'rejected'));
+
+    await expect(assertApprovalRule(buffer, repository)).resolves.toBeUndefined();
+  });
+
+  it('names the places it refuses on the error', async () => {
+    const { repository, buffer } = await over({});
+
+    buffer.create('tokenAnalysisLinks', tokenLink('a'));
+    buffer.create('tokenAnalysisLinks', tokenLink('b'));
+
+    await expect(assertApprovalRule(buffer, repository)).rejects.toMatchObject({
+      places: ['GEN 1:1:0'],
+    });
+  });
+});
diff --git a/src/__tests__/services/commands/changeBuffer.test.ts b/src/__tests__/services/commands/changeBuffer.test.ts
new file mode 100644
index 000000000..b6862527b
--- /dev/null
+++ b/src/__tests__/services/commands/changeBuffer.test.ts
@@ -0,0 +1,192 @@
+/// <reference types="jest" />
+
+import type { TextAnalysis, TokenAnalysis, TokenAnalysisLink } from 'interlinearizer';
+import { ChangeBuffer } from '../../../services/commands/changeBuffer';
+import { DraftRepository } from '../../../services/draftRepository';
+import { emptyAnalysis, emptyDraft } from '../../../types/empty-factories';
+import { FIXTURE_STAMPS, makePhraseLink, memoryStorage, silentLogger } from '../../test-helpers';
+
+function payload(id: string, surfaceText = id): TokenAnalysis {
+  return { id, ...FIXTURE_STAMPS, surfaceText };
+}
+
+function link(id: string, analysisId: string, tokenRef: string): TokenAnalysisLink {
+  return {
+    id,
+    analysisId,
+    ...FIXTURE_STAMPS,
+    status: 'approved',
+    token: { tokenRef, surfaceText: 'In' },
+  };
+}
+
+/** A buffer over a draft holding `analysis`. */
+async function bufferOver(analysis: Partial<TextAnalysis> = {}): Promise<ChangeBuffer> {
+  const { storage } = memoryStorage();
+  const repository = new DraftRepository(storage, 'src', silentLogger());
+  await repository.replaceAll({
+    ...emptyDraft('src'),
+    analysis: { ...emptyAnalysis(), ...analysis },
+  });
+  return new ChangeBuffer(repository);
+}
+
+const ids = (records: readonly { id: string }[]) => records.map(({ id }) => id).sort();
+
+describe('ChangeBuffer', () => {
+  it('reads stored records as the repository does while nothing is staged', async () => {
+    const buffer = await bufferOver({
+      tokenAnalyses: [payload('ta-1')],
+      tokenAnalysisLinks: [link('tl-1', 'ta-1', 'GEN 1:1:0')],
+    });
+
+    await expect(buffer.getTokenAnalyses(['ta-1'])).resolves.toStrictEqual([payload('ta-1')]);
+    await expect(buffer.findLinksToAnalyses(['ta-1'])).resolves.toStrictEqual({
+      tokenAnalysisLinks: [link('tl-1', 'ta-1', 'GEN 1:1:0')],
+      phraseAnalysisLinks: [],
+      segmentAnalysisLinks: [],
+    });
+  });
+
+  it('answers with a staged put in place of the stored record', async () => {
+    const buffer = await bufferOver({ tokenAnalyses: [payload('ta-1')] });
+
+    buffer.put('tokenAnalyses', { ...payload('ta-1'), gloss: { en: 'one' } });
+
+    await expect(buffer.getTokenAnalyses(['ta-1'])).resolves.toStrictEqual([
+      { ...payload('ta-1'), gloss: { en: 'one' } },
+    ]);
+  });
+
+  it('leaves a staged removal out of every read', async () => {
+    const stored = link('tl-1', 'ta-1', 'GEN 1:1:0');
+    const buffer = await bufferOver({ tokenAnalysisLinks: [stored] });
+
+    buffer.delete('tokenAnalysisLinks', stored);
+
+    await expect(buffer.findLinksByToken(['GEN 1:1:0'])).resolves.toStrictEqual({
+      tokenAnalysisLinks: [],
+      phraseAnalysisLinks: [],
+    });
+  });
+
+  it('finds a record a staged put moves into a lookup, and not one it moves out', async () => {
+    const buffer = await bufferOver({
+      tokenAnalysisLinks: [link('tl-1', 'ta-1', 'GEN 1:1:0'), link('tl-2', 'ta-2', 'GEN 1:1:0')],
+    });
+
+    buffer.put('tokenAnalysisLinks', link('tl-1', 'ta-2', 'GEN 1:1:0'));
+
+    await expect(buffer.findLinksToAnalyses(['ta-1'])).resolves.toMatchObject({
+      tokenAnalysisLinks: [],
+    });
+    const { tokenAnalysisLinks } = await buffer.findLinksToAnalyses(['ta-2']);
+    expect(ids(tokenAnalysisLinks)).toStrictEqual(['tl-1', 'tl-2']);
+  });
+
+  it('answers every lookup through the staged changes', async () => {
+    const phrase = makePhraseLink('pa-1', ['GEN 1:1:0', 'GEN 1:1:3']);
+    const segmentLink = {
+      id: 'sl-1',
+      analysisId: 'sa-1',
+      ...FIXTURE_STAMPS,
+      status: 'approved' as const,
+      segmentId: 'GEN 1:1',
+    };
+    const buffer = await bufferOver({
+      phraseAnalyses: [{ id: 'pa-1', ...FIXTURE_STAMPS, surfaceText: 'In the' }],
+      phraseAnalysisLinks: [phrase],
+      segmentAnalyses: [{ id: 'sa-1', ...FIXTURE_STAMPS, surfaceText: 'In the beginning' }],
+      segmentAnalysisLinks: [segmentLink],
+    });
+
+    buffer.create('tokenAnalyses', payload('ta-new', 'In'));
+
+    await expect(buffer.findTokenAnalysesByForm(['in'])).resolves.toStrictEqual([
+      payload('ta-new', 'In'),
+    ]);
+    await expect(buffer.findPhraseAnalysesByForm(['in the']).then(ids)).resolves.toStrictEqual([
+      'pa-1',
+    ]);
+    await expect(buffer.getPhraseAnalyses(['pa-1']).then(ids)).resolves.toStrictEqual(['pa-1']);
+    await expect(buffer.getSegmentAnalyses(['sa-1']).then(ids)).resolves.toStrictEqual(['sa-1']);
+    await expect(buffer.findLinksBySegment(['GEN 1:1'])).resolves.toStrictEqual([segmentLink]);
+    await expect(buffer.findLinksByToken(['GEN 1:1:3'])).resolves.toStrictEqual({
+      tokenAnalysisLinks: [],
+      phraseAnalysisLinks: [phrase],
+    });
+    await expect(buffer.findLinksToAnalyses(['pa-1', 'sa-1'])).resolves.toStrictEqual({
+      tokenAnalysisLinks: [],
+      phraseAnalysisLinks: [phrase],
+      segmentAnalysisLinks: [segmentLink],
+    });
+  });
+
+  it('hands out copies, so changing a record read stages nothing', async () => {
+    const buffer = await bufferOver({ tokenAnalyses: [payload('ta-1')] });
+    const [read] = await buffer.getTokenAnalyses(['ta-1']);
+
+    read.surfaceText = 'changed';
+
+    expect(buffer.toChangeSet('nothing')).toStrictEqual({ intent: 'nothing' });
+    await expect(buffer.getTokenAnalyses(['ta-1'])).resolves.toStrictEqual([payload('ta-1')]);
+  });
+
+  it('keeps a staged record as it stood when staged', async () => {
+    const buffer = await bufferOver();
+    const created = payload('ta-1');
+
+    buffer.create('tokenAnalyses', created);
+    created.surfaceText = 'changed';
+
+    expect(buffer.toChangeSet('create').tokenAnalyses?.puts).toStrictEqual([payload('ta-1')]);
+  });
+
+  it('collects the staged puts and removals of each kind into one change set', async () => {
+    const stored = link('tl-1', 'ta-1', 'GEN 1:1:0');
+    const buffer = await bufferOver({
+      tokenAnalyses: [payload('ta-1')],
+      tokenAnalysisLinks: [stored],
+    });
+
+    buffer.put('tokenAnalyses', { ...payload('ta-1'), gloss: { en: 'one' } });
+    buffer.delete('tokenAnalysisLinks', stored);
+
+    expect(buffer.toChangeSet('edit')).toStrictEqual({
+      intent: 'edit',
+      tokenAnalyses: { puts: [{ ...payload('ta-1'), gloss: { en: 'one' } }], deletes: [] },
+      tokenAnalysisLinks: { puts: [], deletes: ['tl-1'] },
+    });
+  });
+
+  it('stages nothing for a record it created and then removed', async () => {
+    const buffer = await bufferOver();
+
+    buffer.create('tokenAnalyses', payload('ta-new'));
+    buffer.delete('tokenAnalyses', payload('ta-new'));
+
+    expect(buffer.toChangeSet('none')).toStrictEqual({ intent: 'none' });
+  });
+
+  it('stages a put again after a removal of a stored record', async () => {
+    const buffer = await bufferOver({ tokenAnalyses: [payload('ta-1')] });
+
+    buffer.delete('tokenAnalyses', payload('ta-1'));
+    buffer.put('tokenAnalyses', payload('ta-1'));
+
+    expect(buffer.toChangeSet('restore').tokenAnalyses).toStrictEqual({
+      puts: [payload('ta-1')],
+      deletes: [],
+    });
+  });
+
+  it('lists the records it touches as they stood before a removal or will stand after a put', async () => {
+    const stored = link('tl-1', 'ta-1', 'GEN 1:1:0');
+    const buffer = await bufferOver({ tokenAnalysisLinks: [stored] });
+
+    buffer.delete('tokenAnalysisLinks', stored);
+    buffer.create('tokenAnalysisLinks', link('tl-2', 'ta-1', 'GEN 1:1:3'));
+
+    expect(ids(buffer.touched('tokenAnalysisLinks'))).toStrictEqual(['tl-1', 'tl-2']);
+  });
+});
diff --git a/src/__tests__/services/commands/parity.ts b/src/__tests__/services/commands/parity.ts
new file mode 100644
index 000000000..4307d22d1
--- /dev/null
+++ b/src/__tests__/services/commands/parity.ts
@@ -0,0 +1,75 @@
+/// <reference types="jest" />
+
+import type { UnknownAction } from '@reduxjs/toolkit';
+import type { TextAnalysis } from 'interlinearizer';
+import { ChangeBuffer } from '../../../services/commands/changeBuffer';
+import { DraftRepository } from '../../../services/draftRepository';
+import reducer from '../../../store/analysisSlice';
+import type { ChangeSet, IndexDifference } from '../../../types/analysis-repository';
+import { emptyDraft } from '../../../types/empty-factories';
+import { memoryStorage, silentLogger } from '../../test-helpers';
+
+/** What one input gives through the store's reducer and through the host's command. */
+export type ParityOutcome = {
+  /** The analysis the reducer leaves, its record lists in id order. */
+  store: TextAnalysis;
+  /** The analysis the command's changes leave once applied and reloaded, in id order. */
+  host: TextAnalysis;
+  /** The changes the command staged. */
+  changes: ChangeSet;
+  /** Where the repository's kept indexes differ from its records after applying the changes. */
+  indexDifferences: IndexDifference[];
+};
+
+/** `analysis` as JSON holds it, with each record list in id order. */
+function normalized(analysis: TextAnalysis): TextAnalysis {
+  const plain: TextAnalysis = JSON.parse(JSON.stringify(analysis));
+  const byId = <T extends { id: string }>(records: T[]) =>
+    [...records].sort((a, b) => a.id.localeCompare(b.id));
+  return {
+    segmentAnalyses: byId(plain.segmentAnalyses),
+    segmentAnalysisLinks: byId(plain.segmentAnalysisLinks),
+    tokenAnalyses: byId(plain.tokenAnalyses),
+    tokenAnalysisLinks: byId(plain.tokenAnalysisLinks),
+    phraseAnalyses: byId(plain.phraseAnalyses),
+    phraseAnalysisLinks: byId(plain.phraseAnalysisLinks),
+  };
+}
+
+/**
+ * Runs one input both ways over `analysis`: `action` through the store's reducer, working in
+ * `analysisLanguage`, and `command` staging changes over a draft holding the same analysis, which
+ * are then applied and the draft reloaded from storage.
+ */
+export async function runParity(
+  analysis: TextAnalysis,
+  analysisLanguage: string,
+  action: UnknownAction,
+  command: (buffer: ChangeBuffer) => Promise<void>,
+): Promise<ParityOutcome> {
+  const store = reducer(
+    { analysis: JSON.parse(JSON.stringify(analysis)), analysisLanguage },
+    action,
+  );
+
+  const { storage } = memoryStorage();
+  const logger = silentLogger();
+  await new DraftRepository(storage, 'src', logger).replaceAll({
+    ...emptyDraft('src'),
+    analysisLanguages: [analysisLanguage],
+    analysis: JSON.parse(JSON.stringify(analysis)),
+  });
+  const repository = new DraftRepository(storage, 'src', logger);
+  const buffer = new ChangeBuffer(repository);
+  await command(buffer);
+  const changes = buffer.toChangeSet('parity');
+  await repository.apply(changes);
+  const { draft: reloaded } = await new DraftRepository(storage, 'src', logger).exportAll();
+
+  return {
+    store: normalized(store.analysis),
+    host: normalized(reloaded.analysis),
+    changes,
+    indexDifferences: await repository.checkIndexes(),
+  };
+}
diff --git a/src/__tests__/services/commands/tokenCommands.parity.test.ts b/src/__tests__/services/commands/tokenCommands.parity.test.ts
new file mode 100644
index 000000000..7d61825af
--- /dev/null
+++ b/src/__tests__/services/commands/tokenCommands.parity.test.ts
@@ -0,0 +1,552 @@
+/// <reference types="jest" />
+
+import type { TextAnalysis, TokenAnalysis, TokenAnalysisLink } from 'interlinearizer';
+import {
+  approveAnalysisForToken as approveCommand,
+  writeGloss as writeGlossCommand,
+} from '../../../services/commands/tokenCommands';
+import { approveAnalysisForToken, writeGloss } from '../../../store/analysisSlice';
+import { emptyAnalysis } from '../../../types/empty-factories';
+import { FIXTURE_STAMPS } from '../../test-helpers';
+import { runParity } from './parity';
+
+const NOW = '2026-06-01T00:00:00.000Z';
+const EARLIER = { createdAt: '2025-06-01T00:00:00.000Z', updatedAt: '2025-06-01T00:00:00.000Z' };
+const LATER = { createdAt: '2026-03-01T00:00:00.000Z', updatedAt: '2026-03-01T00:00:00.000Z' };
+
+function payload(id: string, surfaceText: string, fields: Partial<TokenAnalysis> = {}) {
+  return { id, ...FIXTURE_STAMPS, surfaceText, ...fields };
+}
+
+function link(
+  id: string,
+  analysisId: string,
+  tokenRef: string,
+  fields: Partial<TokenAnalysisLink> = {},
+): TokenAnalysisLink {
+  return {
+    id,
+    analysisId,
+    ...FIXTURE_STAMPS,
+    status: 'approved',
+    token: { tokenRef, surfaceText: 'in' },
+    ...fields,
+  };
+}
+
+function analysisOf(
+  tokenAnalyses: TokenAnalysis[],
+  tokenAnalysisLinks: TokenAnalysisLink[],
+): TextAnalysis {
+  return { ...emptyAnalysis(), tokenAnalyses, tokenAnalysisLinks };
+}
+
+const TOKEN = 'GEN 1:1:0';
+const OTHER_TOKEN = 'GEN 1:2:0';
+
+type ParityCase<Input> = {
+  analysis: TextAnalysis;
+  input: Input;
+  /** What the reducer's result must show, so the case exercises the path it names. */
+  expectStore: (store: TextAnalysis) => void;
+};
+
+type GlossInput = { surfaceText?: string; value: string };
+
+const ids = (records: readonly { id: string }[]) => records.map(({ id }) => id).sort();
+
+describe('writeGloss parity with the reducer', () => {
+  const cases: [string, ParityCase<GlossInput>][] = [
+    [
+      'creates a payload and an approved link for an unglossed token',
+      {
+        analysis: emptyAnalysis(),
+        input: { value: 'at' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['new-analysis']);
+          expect(ids(store.tokenAnalysisLinks)).toStrictEqual(['new-link']);
+        },
+      },
+    ],
+    [
+      'shares a stored payload whose content matches',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'in', { gloss: { en: 'at' } })],
+          [link('tl-other', 'ta-in', OTHER_TOKEN)],
+        ),
+        input: { value: 'at' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-in']);
+          expect(store.tokenAnalysisLinks.find(({ id }) => id === 'new-link')?.analysisId).toBe(
+            'ta-in',
+          );
+        },
+      },
+    ],
+    [
+      "approves the token's held link to the matching payload rather than adding one",
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'in', { gloss: { en: 'at' } })],
+          [link('tl-held', 'ta-in', TOKEN, { status: 'suggested', confidence: 'low' })],
+        ),
+        input: { value: 'at' },
+        expectStore: (store) => {
+          expect(store.tokenAnalysisLinks).toHaveLength(1);
+          expect(store.tokenAnalysisLinks[0].status).toBe('approved');
+        },
+      },
+    ],
+    [
+      'edits an unshared payload in place, refreshing surface text and keeping its sense',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-in', 'In', {
+              gloss: { en: 'at', fr: 'à' },
+              glossSenseRef: { authority: 'fwlite', senseId: 's-at' },
+            }),
+          ],
+          [link('tl-in', 'ta-in', TOKEN)],
+        ),
+        input: { surfaceText: 'In,', value: 'at first' },
+        expectStore: (store) => {
+          expect(store.tokenAnalyses).toStrictEqual([
+            payload('ta-in', 'In,', {
+              gloss: { en: 'at first', fr: 'à' },
+              glossSenseRef: { authority: 'fwlite', senseId: 's-at' },
+              updatedAt: NOW,
+            }),
+          ]);
+        },
+      },
+    ],
+    [
+      'forks a payload other tokens share, editing only the fork',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'In', { gloss: { en: 'at' } })],
+          [link('tl-in', 'ta-in', TOKEN), link('tl-other', 'ta-in', OTHER_TOKEN)],
+        ),
+        input: { value: 'start' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['new-analysis', 'ta-in']);
+        },
+      },
+    ],
+    [
+      "folds an edit matching another payload into it, clearing the survivor's stale breakdown",
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-at', 'in', { gloss: { en: 'at' } }),
+            payload('ta-within', 'In', {
+              ...EARLIER,
+              gloss: { en: 'within' },
+              morphemesStale: true,
+            }),
+          ],
+          [link('tl-in', 'ta-at', TOKEN), link('tl-other', 'ta-within', OTHER_TOKEN)],
+        ),
+        input: { value: 'within' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-within']);
+          expect(store.tokenAnalyses[0].morphemesStale).toBeUndefined();
+        },
+      },
+    ],
+    [
+      'leaves a token linking both folded payloads one link, dated by the earlier',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-at', 'In', { gloss: { en: 'at' } }),
+            payload('ta-within', 'In', { ...EARLIER, gloss: { en: 'within' } }),
+          ],
+          [
+            link('tl-in', 'ta-at', TOKEN, LATER),
+            link('tl-offered', 'ta-within', TOKEN, { ...EARLIER, status: 'suggested' }),
+          ],
+        ),
+        input: { value: 'within' },
+        expectStore: (store) => {
+          expect(store.tokenAnalysisLinks).toHaveLength(1);
+          expect(store.tokenAnalysisLinks[0]).toMatchObject({
+            id: 'tl-in',
+            status: 'approved',
+            createdAt: EARLIER.createdAt,
+          });
+        },
+      },
+    ],
+    [
+      'folds into a payload another token was offered, leaving that offer as it was',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-at', 'In', { gloss: { en: 'at' } }),
+            payload('ta-within', 'In', { ...EARLIER, gloss: { en: 'within' } }),
+          ],
+          [
+            link('tl-in', 'ta-at', TOKEN),
+            link('tl-offered', 'ta-within', OTHER_TOKEN, { status: 'suggested' }),
+          ],
+        ),
+        input: { value: 'within' },
+        expectStore: (store) => {
+          expect(store.tokenAnalysisLinks).toStrictEqual(
+            expect.arrayContaining([
+              expect.objectContaining({ id: 'tl-offered', status: 'suggested' }),
+            ]),
+          );
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-within']);
+        },
+      },
+    ],
+    [
+      'clears the gloss, removing the payload it empties and its link',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'In', { gloss: { en: 'at' } })],
+          [link('tl-in', 'ta-in', TOKEN)],
+        ),
+        input: { value: '' },
+        expectStore: (store) => {
+          expect(store).toStrictEqual(emptyAnalysis());
+        },
+      },
+    ],
+    [
+      'clears one language, keeping the others and the sense',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-in', 'In', {
+              gloss: { en: 'at', fr: 'à' },
+              glossSenseRef: { authority: 'fwlite', senseId: 's-at' },
+            }),
+          ],
+          [link('tl-in', 'ta-in', TOKEN)],
+        ),
+        input: { value: '  ' },
+        expectStore: (store) => {
+          expect(store.tokenAnalyses[0].gloss).toStrictEqual({ fr: 'à' });
+          expect(store.tokenAnalyses[0].glossSenseRef).toBeDefined();
+        },
+      },
+    ],
+    [
+      'clears a shared payload by dropping only this token’s link',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'In', { gloss: { en: 'at' } })],
+          [link('tl-in', 'ta-in', TOKEN), link('tl-other', 'ta-in', OTHER_TOKEN)],
+        ),
+        input: { value: '' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-in']);
+          expect(ids(store.tokenAnalysisLinks)).toStrictEqual(['tl-other']);
+        },
+      },
+    ],
+    [
+      'keeps an emptied payload another of the token’s links still names',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'In', { gloss: { en: 'at' } })],
+          [
+            link('tl-in', 'ta-in', TOKEN),
+            link('tl-rejected', 'ta-in', TOKEN, { status: 'rejected' }),
+          ],
+        ),
+        input: { value: '' },
+        expectStore: (store) => {
+          expect(store.tokenAnalyses).toStrictEqual([payload('ta-in', 'In', { updatedAt: NOW })]);
+          expect(ids(store.tokenAnalysisLinks)).toStrictEqual(['tl-rejected']);
+        },
+      },
+    ],
+    [
+      'folds a cleared payload into another its remaining content matches',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-in', 'In', { gloss: { en: 'at' }, pos: 'prep' }),
+            payload('ta-bare', 'in', { ...EARLIER, pos: 'prep' }),
+          ],
+          [link('tl-in', 'ta-in', TOKEN)],
+        ),
+        input: { value: '' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-bare']);
+          expect(store.tokenAnalysisLinks[0].analysisId).toBe('ta-bare');
+        },
+      },
+    ],
+    [
+      'folds a fork back onto the shared payload when the write leaves it unchanged',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'In', { gloss: { en: 'at' } })],
+          [link('tl-in', 'ta-in', TOKEN), link('tl-other', 'ta-in', OTHER_TOKEN)],
+        ),
+        input: { value: 'at' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-in']);
+          expect(store.tokenAnalysisLinks.every(({ analysisId }) => analysisId === 'ta-in')).toBe(
+            true,
+          );
+        },
+      },
+    ],
+    [
+      'edits the payload an approval tie picks among several approved links',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-old', 'In', { gloss: { en: 'old' } }),
+            payload('ta-new', 'In', { gloss: { en: 'new' } }),
+          ],
+          [link('tl-old', 'ta-old', TOKEN, EARLIER), link('tl-new', 'ta-new', TOKEN, LATER)],
+        ),
+        input: { value: 'newer' },
+        expectStore: (store) => {
+          expect(store.tokenAnalyses.find(({ id }) => id === 'ta-new')?.gloss).toStrictEqual({
+            en: 'newer',
+          });
+        },
+      },
+    ],
+    [
+      'stages nothing for a blank write to an unglossed token',
+      {
+        analysis: analysisOf([payload('ta-in', 'In', { gloss: { en: 'at' } })], []),
+        input: { value: '' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-in']);
+        },
+      },
+    ],
+    [
+      'removes an approved link whose payload is gone before writing',
+      {
+        analysis: analysisOf([], [link('tl-orphan', 'ta-missing', TOKEN)]),
+        input: { value: 'at' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalysisLinks)).toStrictEqual(['new-link']);
+        },
+      },
+    ],
+    [
+      'removes an approved link whose payload is gone even on a blank write',
+      {
+        analysis: analysisOf([], [link('tl-orphan', 'ta-missing', TOKEN)]),
+        input: { value: '' },
+        expectStore: (store) => {
+          expect(store).toStrictEqual(emptyAnalysis());
+        },
+      },
+    ],
+  ];
+
+  it.each(cases)('%s', async (_name, { analysis, input, expectStore }) => {
+    const surfaceText = input.surfaceText ?? 'In';
+    const outcome = await runParity(
+      analysis,
+      'en',
+      {
+        type: writeGloss.type,
+        payload: {
+          tokenRef: TOKEN,
+          surfaceText,
+          value: input.value,
+          id: 'new-analysis',
+          linkId: 'new-link',
+          now: NOW,
+        },
+      },
+      (buffer) =>
+        writeGlossCommand(buffer, {
+          tokenRef: TOKEN,
+          surfaceText,
+          value: input.value,
+          analysisLanguage: 'en',
+          analysisId: 'new-analysis',
+          linkId: 'new-link',
+          now: NOW,
+        }),
+    );
+
+    expectStore(outcome.store);
+    expect(outcome.host).toStrictEqual(outcome.store);
+    expect(outcome.indexDifferences).toStrictEqual([]);
+  });
+});
+
+type ApproveInput = { analysisId: string };
+
+describe('approveAnalysisForToken parity with the reducer', () => {
+  const cases: [string, ParityCase<ApproveInput>][] = [
+    [
+      'gives a token with no approval a new approved link',
+      {
+        analysis: analysisOf([payload('ta-in', 'In', { gloss: { en: 'at' } })], []),
+        input: { analysisId: 'ta-in' },
+        expectStore: (store) => {
+          expect(store.tokenAnalysisLinks).toStrictEqual([
+            {
+              id: 'new-link',
+              analysisId: 'ta-in',
+              createdAt: NOW,
+              updatedAt: NOW,
+              status: 'approved',
+              token: { tokenRef: TOKEN, surfaceText: 'In' },
+            },
+          ]);
+        },
+      },
+    ],
+    [
+      'approves the link the token holds to the payload rather than adding one',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'In', { gloss: { en: 'at' } })],
+          [link('tl-held', 'ta-in', TOKEN, { status: 'candidate', confidence: 'guess' })],
+        ),
+        input: { analysisId: 'ta-in' },
+        expectStore: (store) => {
+          expect(store.tokenAnalysisLinks).toHaveLength(1);
+          expect(store.tokenAnalysisLinks[0]).toMatchObject({
+            status: 'approved',
+            confidence: 'guess',
+          });
+        },
+      },
+    ],
+    [
+      'moves the approval off a payload, removing it once nothing links it',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-at', 'In', { gloss: { en: 'at' } }),
+            payload('ta-on', 'In', { gloss: { en: 'on' } }),
+          ],
+          [link('tl-in', 'ta-at', TOKEN)],
+        ),
+        input: { analysisId: 'ta-on' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-on']);
+          expect(store.tokenAnalysisLinks[0].analysisId).toBe('ta-on');
+        },
+      },
+    ],
+    [
+      'keeps the payload the approval leaves when another token links it',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-at', 'In', { gloss: { en: 'at' } }),
+            payload('ta-on', 'In', { gloss: { en: 'on' } }),
+          ],
+          [link('tl-in', 'ta-at', TOKEN), link('tl-other', 'ta-at', OTHER_TOKEN)],
+        ),
+        input: { analysisId: 'ta-on' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-at', 'ta-on']);
+        },
+      },
+    ],
+    [
+      'approves a held link in place of the approval, keeping the earlier creation date',
+      {
+        analysis: analysisOf(
+          [
+            payload('ta-at', 'In', { gloss: { en: 'at' } }),
+            payload('ta-on', 'In', { gloss: { en: 'on' } }),
+          ],
+          [
+            link('tl-in', 'ta-at', TOKEN, EARLIER),
+            link('tl-held', 'ta-on', TOKEN, { ...LATER, status: 'suggested' }),
+          ],
+        ),
+        input: { analysisId: 'ta-on' },
+        expectStore: (store) => {
+          expect(store.tokenAnalysisLinks).toStrictEqual([
+            expect.objectContaining({
+              id: 'tl-held',
+              status: 'approved',
+              createdAt: EARLIER.createdAt,
+            }),
+          ]);
+          expect(ids(store.tokenAnalyses)).toStrictEqual(['ta-on']);
+        },
+      },
+    ],
+    [
+      'stages nothing for a payload not stored',
+      {
+        analysis: analysisOf([], [link('tl-orphan', 'ta-missing', TOKEN)]),
+        input: { analysisId: 'ta-unknown' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalysisLinks)).toStrictEqual(['tl-orphan']);
+        },
+      },
+    ],
+    [
+      'removes orphaned approvals even when the payload is already approved',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'In', { gloss: { en: 'at' } })],
+          [link('tl-in', 'ta-in', TOKEN, LATER), link('tl-orphan', 'ta-missing', TOKEN, EARLIER)],
+        ),
+        input: { analysisId: 'ta-in' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalysisLinks)).toStrictEqual(['tl-in']);
+        },
+      },
+    ],
+    [
+      'removes orphaned approvals before approving',
+      {
+        analysis: analysisOf(
+          [payload('ta-in', 'In', { gloss: { en: 'at' } })],
+          [link('tl-orphan', 'ta-missing', TOKEN)],
+        ),
+        input: { analysisId: 'ta-in' },
+        expectStore: (store) => {
+          expect(ids(store.tokenAnalysisLinks)).toStrictEqual(['new-link']);
+        },
+      },
+    ],
+  ];
+
+  it.each(cases)('%s', async (_name, { analysis, input, expectStore }) => {
+    const outcome = await runParity(
+      analysis,
+      'en',
+      {
+        type: approveAnalysisForToken.type,
+        payload: {
+          tokenRef: TOKEN,
+          surfaceText: 'In',
+          analysisId: input.analysisId,
+          linkId: 'new-link',
+          now: NOW,
+        },
+      },
+      (buffer) =>
+        approveCommand(buffer, {
+          tokenRef: TOKEN,
+          surfaceText: 'In',
+          analysisId: input.analysisId,
+          linkId: 'new-link',
+          now: NOW,
+        }),
+    );
+
+    expectStore(outcome.store);
+    expect(outcome.host).toStrictEqual(outcome.store);
+    expect(outcome.indexDifferences).toStrictEqual([]);
+  });
+});
diff --git a/src/__tests__/services/commands/tokenCommands.test.ts b/src/__tests__/services/commands/tokenCommands.test.ts
new file mode 100644
index 000000000..7550f665e
--- /dev/null
+++ b/src/__tests__/services/commands/tokenCommands.test.ts
@@ -0,0 +1,92 @@
+/// <reference types="jest" />
+
+import type { TextAnalysis, TokenAnalysis, TokenAnalysisLink } from 'interlinearizer';
+import { ChangeBuffer } from '../../../services/commands/changeBuffer';
+import { approveAnalysisForToken, writeGloss } from '../../../services/commands/tokenCommands';
+import { DraftRepository } from '../../../services/draftRepository';
+import { emptyAnalysis, emptyDraft } from '../../../types/empty-factories';
+import { FIXTURE_STAMPS, memoryStorage, silentLogger } from '../../test-helpers';
+
+const NOW = '2026-06-01T00:00:00.000Z';
+const STAMP = { analysisId: 'new-analysis', linkId: 'new-link', now: NOW };
+
+const shared: TokenAnalysis = {
+  id: 'ta-in',
+  ...FIXTURE_STAMPS,
+  surfaceText: 'In',
+  gloss: { en: 'at' },
+};
+
+function link(id: string, tokenRef: string): TokenAnalysisLink {
+  return {
+    id,
+    analysisId: 'ta-in',
+    ...FIXTURE_STAMPS,
+    status: 'approved',
+    token: { tokenRef, surfaceText: 'In' },
+  };
+}
+
+async function bufferOver(analysis: Partial<TextAnalysis>): Promise<ChangeBuffer> {
+  const { storage } = memoryStorage();
+  const repository = new DraftRepository(storage, 'src', silentLogger());
+  await repository.replaceAll({
+    ...emptyDraft('src'),
+    analysis: { ...emptyAnalysis(), ...analysis },
+  });
+  return new ChangeBuffer(repository);
+}
+
+describe('writeGloss', () => {
+  it("stages only the link's removal when clearing a shared payload, never its fork", async () => {
+    const buffer = await bufferOver({
+      tokenAnalyses: [shared],
+      tokenAnalysisLinks: [link('tl-1', 'GEN 1:1:0'), link('tl-2', 'GEN 1:2:0')],
+    });
+
+    await writeGloss(buffer, {
+      ...STAMP,
+      tokenRef: 'GEN 1:1:0',
+      surfaceText: 'In',
+      value: '',
+      analysisLanguage: 'en',
+    });
+
+    expect(buffer.toChangeSet('writeGloss')).toStrictEqual({
+      intent: 'writeGloss',
+      tokenAnalysisLinks: { puts: [], deletes: ['tl-1'] },
+    });
+  });
+
+  it('stages nothing for a blank write to an unglossed token', async () => {
+    const buffer = await bufferOver({ tokenAnalyses: [shared] });
+
+    await writeGloss(buffer, {
+      ...STAMP,
+      tokenRef: 'GEN 1:1:0',
+      surfaceText: 'In',
+      value: ' ',
+      analysisLanguage: 'en',
+    });
+
+    expect(buffer.toChangeSet('writeGloss')).toStrictEqual({ intent: 'writeGloss' });
+  });
+});
+
+describe('approveAnalysisForToken', () => {
+  it('stages nothing for a payload already approved for the token', async () => {
+    const buffer = await bufferOver({
+      tokenAnalyses: [shared],
+      tokenAnalysisLinks: [link('tl-1', 'GEN 1:1:0')],
+    });
+
+    await approveAnalysisForToken(buffer, {
+      ...STAMP,
+      tokenRef: 'GEN 1:1:0',
+      surfaceText: 'In',
+      analysisId: 'ta-in',
+    });
+
+    expect(buffer.toChangeSet('approve')).toStrictEqual({ intent: 'approve' });
+  });
+});
diff --git a/src/__tests__/services/indexedRepository.test.ts b/src/__tests__/services/indexedRepository.test.ts
index 79ca69dbe..d60a4d0bb 100644
--- a/src/__tests__/services/indexedRepository.test.ts
+++ b/src/__tests__/services/indexedRepository.test.ts
@@ -2,27 +2,30 @@
 
 import type { TextAnalysis } from 'interlinearizer';
 import { AnalysisIndex } from '../../services/analysisIndex';
-import { type IndexedAnalysis, IndexedRepository } from '../../services/indexedRepository';
-import { emptyAnalysis } from '../../types/empty-factories';
+import { type IndexedDraft, IndexedRepository } from '../../services/indexedRepository';
+import { emptyAnalysis, emptyDraft } from '../../types/empty-factories';
 import { FIXTURE_STAMPS } from '../test-helpers';
 
 /** Answers lookups from an index over `records`, reporting it as kept when `keep` is `'kept'`. */
 class StubRepository extends IndexedRepository {
-  readonly kept: IndexedAnalysis | undefined;
+  readonly kept: IndexedDraft | undefined;
 
-  private readonly index: AnalysisIndex;
+  private readonly indexedDraft: IndexedDraft;
 
   constructor(records: TextAnalysis, keep: 'kept' | 'none') {
     super();
-    this.index = new AnalysisIndex(records);
-    this.kept = keep === 'kept' ? { analysis: records, index: this.index } : undefined;
+    this.indexedDraft = {
+      draft: { ...emptyDraft('src'), analysisLanguages: ['en'], analysis: records },
+      index: new AnalysisIndex(records),
+    };
+    this.kept = keep === 'kept' ? this.indexedDraft : undefined;
   }
 
-  protected async indexed(): Promise<AnalysisIndex> {
-    return this.index;
+  protected async indexed(): Promise<IndexedDraft> {
+    return this.indexedDraft;
   }
 
-  protected keptIndex(): IndexedAnalysis | undefined {
+  protected keptIndex(): IndexedDraft | undefined {
     return this.kept;
   }
 }
@@ -54,7 +57,7 @@ describe('IndexedRepository', () => {
 
   it('reports the differences of the index it keeps from its analysis', async () => {
     const repository = new StubRepository(analysis(), 'kept');
-    repository.kept?.analysis.tokenAnalyses.pop();
+    repository.kept?.draft.analysis.tokenAnalyses.pop();
 
     await expect(repository.checkIndexes()).resolves.toContainEqual({
       index: 'tokenAnalyses',
@@ -64,6 +67,14 @@ describe('IndexedRepository', () => {
     });
   });
 
+  it("reads the draft's own record without its analysis", async () => {
+    await expect(new StubRepository(analysis(), 'none').getScope()).resolves.toStrictEqual({
+      sourceProjectId: 'src',
+      modelVersion: emptyDraft('src').modelVersion,
+      analysisLanguages: ['en'],
+    });
+  });
+
   it('reports nothing while it keeps no index', async () => {
     await expect(new StubRepository(analysis(), 'none').checkIndexes()).resolves.toStrictEqual([]);
   });
diff --git a/src/__tests__/services/projectStorage.test.ts b/src/__tests__/services/projectStorage.test.ts
index 80094fd0f..1030b3c67 100644
--- a/src/__tests__/services/projectStorage.test.ts
+++ b/src/__tests__/services/projectStorage.test.ts
@@ -2995,6 +2995,11 @@ describe('projectStorage', () => {
       ],
       ['findPhraseAnalysesByForm', (r: AnalysisRepository) => r.findPhraseAnalysesByForm(['x']), 0],
       ['checkIndexes', (r: AnalysisRepository) => r.checkIndexes(), 0],
+      [
+        'getScope',
+        (r: AnalysisRepository) => r.getScope().then(({ analysisLanguages }) => analysisLanguages),
+        0,
+      ],
     ])('answers %s from the draft saveDraft saved', async (_name, lookup, count) => {
       await saveDraft(token, 'src-proj', makeDraftSpanningBooks('src-proj', 'GEN'));
 
diff --git a/src/__tests__/store/analysisSlice.test.ts b/src/__tests__/store/analysisSlice.test.ts
index 5cd38f52d..9f109d4ea 100644
--- a/src/__tests__/store/analysisSlice.test.ts
+++ b/src/__tests__/store/analysisSlice.test.ts
@@ -208,7 +208,7 @@ describe('writeGloss', () => {
     expect(tokenAnalyses[0].gloss).toStrictEqual({ und: 'hello' });
   });
 
-  it('drops the sense reference when the reader rewrites the gloss', () => {
+  it('keeps the sense reference when the reader rewrites the gloss', () => {
     const store = createAnalysisStore({
       analysis: {
         analysis: makeAnalysis({
@@ -226,7 +226,10 @@ describe('writeGloss', () => {
 
     const { tokenAnalyses } = store.getState().analysis.analysis;
     expect(tokenAnalyses[0].gloss).toStrictEqual({ und: 'race' });
-    expect(tokenAnalyses[0].glossSenseRef).toBeUndefined();
+    expect(tokenAnalyses[0].glossSenseRef).toStrictEqual({
+      authority: 'x-test',
+      senseId: 'sense-run',
+    });
   });
 
   it('drops the sense reference when the reader clears the gloss', () => {
@@ -5154,7 +5157,7 @@ describe('analysis-keyed reducers', () => {
       expect(tokenAnalyses[0].gloss).toBeUndefined();
     });
 
-    it('drops the sense reference when the reader rewrites the gloss', () => {
+    it('keeps the sense reference when the reader rewrites the gloss', () => {
       const store = makeSharedStore({
         glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
         morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
@@ -5164,7 +5167,10 @@ describe('analysis-keyed reducers', () => {
 
       const { tokenAnalyses } = store.getState().analysis.analysis;
       expect(tokenAnalyses[0].gloss).toEqual({ und: 'race' });
-      expect(tokenAnalyses[0].glossSenseRef).toBeUndefined();
+      expect(tokenAnalyses[0].glossSenseRef).toStrictEqual({
+        authority: 'x-test',
+        senseId: 'sense-run',
+      });
     });
 
     it('drops the sense reference when the reader clears the gloss', () => {
diff --git a/src/__tests__/utils/change-set.test.ts b/src/__tests__/utils/change-set.test.ts
index a8f19f1ec..b0894f579 100644
--- a/src/__tests__/utils/change-set.test.ts
+++ b/src/__tests__/utils/change-set.test.ts
@@ -2,7 +2,7 @@
 
 import type { DraftProject, TokenAnalysis } from 'interlinearizer';
 import { emptyAnalysis, emptyDraft } from '../../types/empty-factories';
-import { applyChangeSet, scopeRecordOf } from '../../utils/change-set';
+import { applyChangeSet, isEmptyChangeSet, scopeRecordOf } from '../../utils/change-set';
 import { FIXTURE_STAMPS } from '../test-helpers';
 
 function payload(id: string, gloss?: string): TokenAnalysis {
@@ -189,3 +189,19 @@ describe('applyChangeSet', () => {
     ).toStrictEqual([['sa'], ['sl'], ['a'], ['tl'], ['pa'], ['pl']]);
   });
 });
+
+describe('isEmptyChangeSet', () => {
+  it('finds a change set naming only its intent empty', () => {
+    expect(isEmptyChangeSet({ intent: 'none' })).toBe(true);
+  });
+
+  it('finds a change set with record changes not empty', () => {
+    expect(isEmptyChangeSet({ intent: 'edit', tokenAnalyses: { puts: [], deletes: ['a'] } })).toBe(
+      false,
+    );
+  });
+
+  it("finds a change set putting the scope's record not empty", () => {
+    expect(isEmptyChangeSet({ intent: 'edit', scope: scopeRecordOf(draftOf()) })).toBe(false);
+  });
+});
diff --git a/src/__tests__/utils/token-analysis-content.test.ts b/src/__tests__/utils/token-analysis-content.test.ts
new file mode 100644
index 000000000..5625fd3a3
--- /dev/null
+++ b/src/__tests__/utils/token-analysis-content.test.ts
@@ -0,0 +1,59 @@
+/// <reference types="jest" />
+
+import type { TokenAnalysis } from 'interlinearizer';
+import { clearAnalysisGloss, isEmptyTokenAnalysis } from '../../utils/token-analysis-content';
+import { FIXTURE_STAMPS } from '../test-helpers';
+
+function analysis(fields: Partial<TokenAnalysis> = {}): TokenAnalysis {
+  return { id: 'ta-1', ...FIXTURE_STAMPS, surfaceText: 'In', ...fields };
+}
+
+describe('isEmptyTokenAnalysis', () => {
+  it('finds a record holding only blank glosses and provenance empty', () => {
+    expect(isEmptyTokenAnalysis(analysis({ gloss: { en: ' ' }, confidence: 'high' }))).toBe(true);
+  });
+
+  it.each([
+    ['a gloss', { gloss: { en: 'at' } }],
+    ['morphemes', { morphemes: [{ id: 'm-1', form: 'in', writingSystem: 'en' }] }],
+    ['a part of speech', { pos: 'prep' }],
+    ['features', { features: { case: 'loc' } }],
+    ['a gloss sense', { glossSenseRef: { authority: 'fwlite', senseId: 's-1' } }],
+  ])('finds a record holding %s not empty', (_field, fields) => {
+    expect(isEmptyTokenAnalysis(analysis(fields))).toBe(false);
+  });
+});
+
+describe('clearAnalysisGloss', () => {
+  it('clears one language, keeping the others and the sense', () => {
+    const record = analysis({
+      gloss: { en: 'at', fr: 'à' },
+      glossSenseRef: { authority: 'fwlite', senseId: 's-1' },
+    });
+
+    clearAnalysisGloss(record, 'en');
+
+    expect(record).toStrictEqual(
+      analysis({ gloss: { fr: 'à' }, glossSenseRef: { authority: 'fwlite', senseId: 's-1' } }),
+    );
+  });
+
+  it('drops the gloss and the sense once no language holds usable text', () => {
+    const record = analysis({
+      gloss: { en: 'at', fr: ' ' },
+      glossSenseRef: { authority: 'fwlite', senseId: 's-1' },
+    });
+
+    clearAnalysisGloss(record, 'en');
+
+    expect(record).toStrictEqual(analysis());
+  });
+
+  it('drops a sense left with no gloss at all', () => {
+    const record = analysis({ glossSenseRef: { authority: 'fwlite', senseId: 's-1' } });
+
+    clearAnalysisGloss(record, 'en');
+
+    expect(record).toStrictEqual(analysis());
+  });
+});
diff --git a/src/main.ts b/src/main.ts
index 039043714..0db89f7aa 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -11,8 +11,10 @@ import type { ProjectConfig } from 'interlinearizer';
 import { formatReplacementString, type LocalizeKey } from 'platform-bible-utils';
 import interlinearizerReact from './interlinearizer.web-view?inline';
 import interlinearizerStyles from './interlinearizer.web-view.scss?inline';
-import { AnalysisSessions, type OpenedSession } from './services/analysisSessions';
+import { AnalysisSessions, type OpenedSession, type Session } from './services/analysisSessions';
 import * as bookService from './services/bookService';
+import type { ChangeBuffer } from './services/commands/changeBuffer';
+import * as tokenCommands from './services/commands/tokenCommands';
 import { readHostPerf, setHostPerfMarks } from './services/hostPerf';
 import * as projectStorage from './services/projectStorage';
 import * as pt9ImportService from './services/pt9ImportService';
@@ -825,6 +827,80 @@ async function checkIndexes(sessionId: string): Promise<string> {
   }
 }
 
+/**
+ * Runs `command` as one edit of a session's analysis.
+ *
+ * @returns The changes it applied, as JSON.
+ * @throws If the session is read-only or not open, or the edit is refused or fails. The error is
+ *   logged before rethrowing.
+ */
+async function runSessionEdit(
+  sessionId: string,
+  intent: string,
+  command: (buffer: ChangeBuffer, session: Session) => Promise<void>,
+): Promise<string> {
+  try {
+    return JSON.stringify(await sessions.edit(sessionId, intent, command));
+  } catch (e) {
+    logger.error(`Interlinearizer: failed to ${intent} in session ${sessionId}`, e);
+    throw e;
+  }
+}
+
+/** Ids that a new record or link would take, and the time an edit lands. */
+function editStamp() {
+  return {
+    analysisId: crypto.randomUUID(),
+    linkId: crypto.randomUUID(),
+    now: new Date().toISOString(),
+  };
+}
+
+/**
+ * Writes a token's gloss in the session's analysis language; a blank value clears it.
+ *
+ * @returns The changes it applied, as JSON.
+ * @throws As {@link runSessionEdit} does.
+ */
+function writeGloss(
+  sessionId: string,
+  tokenRef: string,
+  surfaceText: string,
+  value: string,
+): Promise<string> {
+  return runSessionEdit(sessionId, 'writeGloss', (buffer, session) =>
+    tokenCommands.writeGloss(buffer, {
+      ...editStamp(),
+      tokenRef,
+      surfaceText,
+      value,
+      analysisLanguage: session.analysisLanguage,
+    }),
+  );
+}
+
+/**
+ * Approves a stored token analysis for a token, in place of any approval the token held.
+ *
+ * @returns The changes it applied, as JSON.
+ * @throws As {@link runSessionEdit} does.
+ */
+function approveAnalysisForToken(
+  sessionId: string,
+  tokenRef: string,
+  surfaceText: string,
+  analysisId: string,
+): Promise<string> {
+  return runSessionEdit(sessionId, 'approveAnalysisForToken', (buffer) =>
+    tokenCommands.approveAnalysisForToken(buffer, {
+      ...editStamp(),
+      tokenRef,
+      surfaceText,
+      analysisId,
+    }),
+  );
+}
+
 /**
  * Returns a summary of every interlinearizer project for the given source project as a JSON string.
  * The WebView deserializes this to populate its project picker and to decide whether to prompt
@@ -1430,6 +1506,71 @@ export async function activate(context: ExecutionActivationContext): Promise<voi
     },
   );
 
+  /** The parameters naming the token a token edit acts on. */
+  const tokenParams = [
+    {
+      name: 'tokenRef',
+      required: true,
+      summary: 'Token.ref of the token edited',
+      schema: { type: 'string' },
+    },
+    {
+      name: 'surfaceText',
+      required: true,
+      summary: "The token's current surface text",
+      schema: { type: 'string' },
+    },
+  ] as const;
+
+  const editResult = {
+    name: 'return value',
+    summary: 'JSON-stringified ChangeSet the edit applied',
+    schema: { type: 'string' },
+  } as const;
+
+  const writeGlossCommandRegistration = await papi.commands.registerCommand(
+    'interlinearizer.writeGloss',
+    writeGloss,
+    {
+      method: {
+        summary: "Write a token's gloss in a session's analysis language; a blank value clears it",
+        params: [
+          sessionIdParam,
+          ...tokenParams,
+          {
+            name: 'value',
+            required: true,
+            summary: 'The gloss',
+            schema: { type: 'string' },
+          },
+        ],
+        result: editResult,
+      },
+    },
+  );
+
+  const approveAnalysisForTokenCommandRegistration = await papi.commands.registerCommand(
+    'interlinearizer.approveAnalysisForToken',
+    approveAnalysisForToken,
+    {
+      method: {
+        summary:
+          'Approve a stored token analysis for a token, in place of any approval the token held',
+        params: [
+          sessionIdParam,
+          ...tokenParams,
+          {
+            name: 'analysisId',
+            required: true,
+            summary: 'Id of the stored token analysis to approve',
+            schema: { type: 'string' },
+          },
+        ],
+        result: editResult,
+      },
+    },
+  );
+
   const checkIndexesCommandRegistration = await papi.commands.registerCommand(
     'interlinearizer.checkIndexes',
     checkIndexes,
@@ -1823,6 +1964,8 @@ export async function activate(context: ExecutionActivationContext): Promise<voi
     undoEditCommandRegistration,
     redoEditCommandRegistration,
     checkIndexesCommandRegistration,
+    writeGlossCommandRegistration,
+    approveAnalysisForTokenCommandRegistration,
     setPerfMarksCommandRegistration,
     readPerfCommandRegistration,
     updateProjectMetadataCommandRegistration,
diff --git a/src/services/analysisSessions.ts b/src/services/analysisSessions.ts
index 29bae4c82..c73c4ea0c 100644
--- a/src/services/analysisSessions.ts
+++ b/src/services/analysisSessions.ts
@@ -1,7 +1,10 @@
 import type { AnalysisRepository, ChangeSet } from '../types/analysis-repository';
 import { ReadOnlyAnalysisError } from '../types/read-only-analysis-error';
 import type { InterlinearProjectSummary } from '../types/interlinear-project-summary';
+import { isEmptyChangeSet } from '../utils/change-set';
 import { analysisHasFreeTranslations } from '../utils/free-translations';
+import { assertApprovalRule } from './commands/approvalRule';
+import { ChangeBuffer } from './commands/changeBuffer';
 import { EditHistory } from './editHistory';
 
 /** BCP 47 tag for a language that cannot be determined. */
@@ -202,6 +205,39 @@ export class AnalysisSessions {
     return this.run(sessionId, edit);
   }
 
+  /**
+   * Runs `command` as one edit of the session's analysis, in the session's turn. What it stages
+   * applies as one undo step, marking the draft dirty; a command staging nothing applies nothing.
+   * When the draft lists no analysis languages, that step adds the session's analysis language.
+   *
+   * @returns The changes applied, naming `intent`.
+   * @throws {ReadOnlyAnalysisError} If the session is read-only.
+   * @throws {ApprovalRuleError} If the changes would give a token or segment a second approved
+   *   link; nothing is applied.
+   * @throws {Error} If the session is not open.
+   * @throws Whatever the command, reading the draft's record, or applying its changes throws;
+   *   nothing is applied.
+   */
+  edit(
+    sessionId: string,
+    intent: string,
+    command: (buffer: ChangeBuffer, session: Session) => Promise<void>,
+  ): Promise<ChangeSet> {
+    return this.runEdit(sessionId, async (session) => {
+      const buffer = new ChangeBuffer(session.repository);
+      await command(buffer, session);
+      const changes = buffer.toChangeSet(intent);
+      if (isEmptyChangeSet(changes)) return changes;
+      await assertApprovalRule(buffer, session.repository);
+      const scope = await session.repository.getScope();
+      if (scope.analysisLanguages.length === 0) {
+        changes.scope = { ...scope, analysisLanguages: [session.analysisLanguage] };
+      }
+      await session.history.apply(changes);
+      return changes;
+    });
+  }
+
   /**
    * Reverts the session's latest edit not yet undone.
    *
diff --git a/src/services/commands/approvalRule.ts b/src/services/commands/approvalRule.ts
new file mode 100644
index 000000000..23d570005
--- /dev/null
+++ b/src/services/commands/approvalRule.ts
@@ -0,0 +1,68 @@
+import type { AnalysisRepository } from '../../types/analysis-repository';
+import type { ChangeBuffer } from './changeBuffer';
+
+/** Thrown by an edit that would give a token or segment a second approved link. */
+export class ApprovalRuleError extends Error {
+  /** The token refs and segment ids the edit would leave holding several approved links. */
+  readonly places: readonly string[];
+
+  constructor(places: readonly string[]) {
+    super(`Interlinearizer: an edit would approve several analyses at ${places.join(', ')}`);
+    this.name = 'ApprovalRuleError';
+    this.places = places;
+  }
+}
+
+/** How many approved links each place holds, placing each link by `placeOf`. */
+function approvedCounts<Link extends { status: string }>(
+  links: readonly Link[],
+  placeOf: (link: Link) => string,
+): Map<string, number> {
+  const counts = new Map<string, number>();
+  links.forEach((link) => {
+    if (link.status !== 'approved') return;
+    counts.set(placeOf(link), (counts.get(placeOf(link)) ?? 0) + 1);
+  });
+  return counts;
+}
+
+/** The places where `after` holds more than one approved link, and more than `before` held. */
+function breaches<Link extends { status: string }>(
+  before: readonly Link[],
+  after: readonly Link[],
+  placeOf: (link: Link) => string,
+): string[] {
+  const held = approvedCounts(before, placeOf);
+  return [...approvedCounts(after, placeOf)].flatMap(([place, count]) =>
+    count > 1 && count > (held.get(place) ?? 0) ? [place] : [],
+  );
+}
+
+/**
+ * Refuses the staged changes where they would give a token or segment more than one approved link,
+ * and more than it has now.
+ *
+ * @throws {ApprovalRuleError} If the changes breach the rule anywhere.
+ */
+export async function assertApprovalRule(
+  buffer: ChangeBuffer,
+  repository: AnalysisRepository,
+): Promise<void> {
+  const tokenRefs = [
+    ...new Set(buffer.touched('tokenAnalysisLinks').map(({ token }) => token.tokenRef)),
+  ];
+  const segmentIds = [...new Set(buffer.touched('segmentAnalysisLinks').map((l) => l.segmentId))];
+  const found = [
+    ...breaches(
+      (await repository.findLinksByToken(tokenRefs)).tokenAnalysisLinks,
+      (await buffer.findLinksByToken(tokenRefs)).tokenAnalysisLinks,
+      ({ token }) => token.tokenRef,
+    ),
+    ...breaches(
+      await repository.findLinksBySegment(segmentIds),
+      await buffer.findLinksBySegment(segmentIds),
+      ({ segmentId }) => segmentId,
+    ),
+  ];
+  if (found.length > 0) throw new ApprovalRuleError(found);
+}
diff --git a/src/services/commands/changeBuffer.ts b/src/services/commands/changeBuffer.ts
new file mode 100644
index 000000000..67a49cfb5
--- /dev/null
+++ b/src/services/commands/changeBuffer.ts
@@ -0,0 +1,216 @@
+import type {
+  PhraseAnalysis,
+  SegmentAnalysis,
+  SegmentAnalysisLink,
+  TextAnalysis,
+  TokenAnalysis,
+} from 'interlinearizer';
+import type { AnalysisLinks, AnalysisRepository, ChangeSet } from '../../types/analysis-repository';
+import { normalizeSurfaceForm } from '../../utils/analysis-identity';
+import { jsonCopy } from '../../utils/json-copy';
+
+/** A record kind, named as {@link TextAnalysis} names its list. */
+export type RecordKind = keyof TextAnalysis;
+
+/** A record of one kind. */
+export type RecordOf<Kind extends RecordKind> = TextAnalysis[Kind][number];
+
+/** One kind's staged changes. */
+type Staged<T> = {
+  /** Records to store, by id. */
+  puts: Map<string, T>;
+  /** Records to remove, as they were staged, by id. */
+  deletes: Map<string, T>;
+  /** Ids of the staged puts that no stored record shares, so removing one stages nothing. */
+  created: Set<string>;
+};
+
+function emptyStaged<T>(): Staged<T> {
+  return { puts: new Map(), deletes: new Map(), created: new Set() };
+}
+
+/**
+ * A command's changes, staged over a repository until they apply. Reads through the buffer answer
+ * as if the changes had applied. Each read returns copies that the command may change.
+ */
+export class ChangeBuffer {
+  private readonly repository: AnalysisRepository;
+
+  private readonly staged: { [Kind in RecordKind]: Staged<RecordOf<Kind>> } = {
+    segmentAnalyses: emptyStaged(),
+    segmentAnalysisLinks: emptyStaged(),
+    tokenAnalyses: emptyStaged(),
+    tokenAnalysisLinks: emptyStaged(),
+    phraseAnalyses: emptyStaged(),
+    phraseAnalysisLinks: emptyStaged(),
+  };
+
+  constructor(repository: AnalysisRepository) {
+    this.repository = repository;
+  }
+
+  /** The token analyses stored under `ids` once the staged changes apply. */
+  async getTokenAnalyses(ids: string[]): Promise<TokenAnalysis[]> {
+    const wanted = new Set(ids);
+    const stored = await this.repository.getTokenAnalyses(ids);
+    return this.overlay('tokenAnalyses', stored, ({ id }) => wanted.has(id));
+  }
+
+  /** The phrase analyses stored under `ids` once the staged changes apply. */
+  async getPhraseAnalyses(ids: string[]): Promise<PhraseAnalysis[]> {
+    const wanted = new Set(ids);
+    const stored = await this.repository.getPhraseAnalyses(ids);
+    return this.overlay('phraseAnalyses', stored, ({ id }) => wanted.has(id));
+  }
+
+  /** The segment analyses stored under `ids` once the staged changes apply. */
+  async getSegmentAnalyses(ids: string[]): Promise<SegmentAnalysis[]> {
+    const wanted = new Set(ids);
+    const stored = await this.repository.getSegmentAnalyses(ids);
+    return this.overlay('segmentAnalyses', stored, ({ id }) => wanted.has(id));
+  }
+
+  /**
+   * The token links on the tokens `tokenRefs` names, and the phrase links touching any of them,
+   * once the staged changes apply.
+   */
+  async findLinksByToken(
+    tokenRefs: string[],
+  ): Promise<Pick<AnalysisLinks, 'tokenAnalysisLinks' | 'phraseAnalysisLinks'>> {
+    const wanted = new Set(tokenRefs);
+    const stored = await this.repository.findLinksByToken(tokenRefs);
+    return {
+      tokenAnalysisLinks: this.overlay('tokenAnalysisLinks', stored.tokenAnalysisLinks, (link) =>
+        wanted.has(link.token.tokenRef),
+      ),
+      phraseAnalysisLinks: this.overlay('phraseAnalysisLinks', stored.phraseAnalysisLinks, (link) =>
+        link.tokens.some(({ tokenRef }) => wanted.has(tokenRef)),
+      ),
+    };
+  }
+
+  /** The segment links on the segments `segmentIds` names once the staged changes apply. */
+  async findLinksBySegment(segmentIds: string[]): Promise<SegmentAnalysisLink[]> {
+    const wanted = new Set(segmentIds);
+    const stored = await this.repository.findLinksBySegment(segmentIds);
+    return this.overlay('segmentAnalysisLinks', stored, (link) => wanted.has(link.segmentId));
+  }
+
+  /** The links of every kind to the analyses `analysisIds` names once the staged changes apply. */
+  async findLinksToAnalyses(analysisIds: string[]): Promise<AnalysisLinks> {
+    const wanted = new Set(analysisIds);
+    const stored = await this.repository.findLinksToAnalyses(analysisIds);
+    const linksTo = ({ analysisId }: { analysisId: string }) => wanted.has(analysisId);
+    return {
+      tokenAnalysisLinks: this.overlay('tokenAnalysisLinks', stored.tokenAnalysisLinks, linksTo),
+      phraseAnalysisLinks: this.overlay('phraseAnalysisLinks', stored.phraseAnalysisLinks, linksTo),
+      segmentAnalysisLinks: this.overlay(
+        'segmentAnalysisLinks',
+        stored.segmentAnalysisLinks,
+        linksTo,
+      ),
+    };
+  }
+
+  /**
+   * The token analyses whose surface text normalizes to one of `normalizedForms` once the staged
+   * changes apply.
+   */
+  async findTokenAnalysesByForm(normalizedForms: string[]): Promise<TokenAnalysis[]> {
+    const wanted = new Set(normalizedForms);
+    const stored = await this.repository.findTokenAnalysesByForm(normalizedForms);
+    return this.overlay('tokenAnalyses', stored, ({ surfaceText }) =>
+      wanted.has(normalizeSurfaceForm(surfaceText)),
+    );
+  }
+
+  /**
+   * The phrase analyses whose surface text normalizes to one of `normalizedForms` once the staged
+   * changes apply.
+   */
+  async findPhraseAnalysesByForm(normalizedForms: string[]): Promise<PhraseAnalysis[]> {
+    const wanted = new Set(normalizedForms);
+    const stored = await this.repository.findPhraseAnalysesByForm(normalizedForms);
+    return this.overlay('phraseAnalyses', stored, ({ surfaceText }) =>
+      wanted.has(normalizeSurfaceForm(surfaceText)),
+    );
+  }
+
+  /** Stages a new record of `kind`, under an id no stored record has. */
+  create<Kind extends RecordKind>(kind: Kind, record: RecordOf<Kind>): void {
+    this.stagedOf(kind).created.add(record.id);
+    this.put(kind, record);
+  }
+
+  /** Stages `record` to be stored whole under its id. */
+  put<Kind extends RecordKind>(kind: Kind, record: RecordOf<Kind>): void {
+    const staged = this.stagedOf(kind);
+    staged.deletes.delete(record.id);
+    staged.puts.set(record.id, jsonCopy(record));
+  }
+
+  /** Stages `record`'s removal; removing one the buffer created stages nothing for it. */
+  delete<Kind extends RecordKind>(kind: Kind, record: RecordOf<Kind>): void {
+    const staged = this.stagedOf(kind);
+    staged.puts.delete(record.id);
+    if (staged.created.delete(record.id)) return;
+    staged.deletes.set(record.id, jsonCopy(record));
+  }
+
+  /**
+   * Every staged record of `kind`: those to store as they will be stored, those to remove as they
+   * were staged.
+   */
+  touched<Kind extends RecordKind>(kind: Kind): RecordOf<Kind>[] {
+    const staged = this.stagedOf(kind);
+    return [...staged.puts.values(), ...staged.deletes.values()].map((record) => jsonCopy(record));
+  }
+
+  /** The staged changes as one change set; a kind with nothing staged is left out. */
+  toChangeSet(intent: string): ChangeSet {
+    const changes: ChangeSet = { intent };
+    const kinds: RecordKind[] = [
+      'segmentAnalyses',
+      'segmentAnalysisLinks',
+      'tokenAnalyses',
+      'tokenAnalysisLinks',
+      'phraseAnalyses',
+      'phraseAnalysisLinks',
+    ];
+    kinds.forEach((kind) => this.collect(changes, kind));
+    return changes;
+  }
+
+  /**
+   * `stored` as it stands once the staged changes of `kind` apply, keeping only the records
+   * `matches` accepts; `stored` must hold every stored record `matches` accepts.
+   */
+  private overlay<Kind extends RecordKind>(
+    kind: Kind,
+    stored: readonly RecordOf<Kind>[],
+    matches: (record: RecordOf<Kind>) => boolean,
+  ): RecordOf<Kind>[] {
+    const staged = this.stagedOf(kind);
+    const latest = new Map<string, RecordOf<Kind>>();
+    stored.forEach((record) => {
+      if (!staged.deletes.has(record.id)) latest.set(record.id, record);
+    });
+    staged.puts.forEach((record, id) => latest.set(id, record));
+    return [...latest.values()].filter(matches).map((record) => jsonCopy(record));
+  }
+
+  private collect<Kind extends RecordKind>(changes: ChangeSet, kind: Kind): void {
+    const { puts, deletes } = this.stagedOf(kind);
+    if (puts.size === 0 && deletes.size === 0) return;
+    Object.assign(changes, {
+      [kind]: {
+        puts: [...puts.values()].map((record) => jsonCopy(record)),
+        deletes: [...deletes.keys()],
+      },
+    });
+  }
+
+  private stagedOf<Kind extends RecordKind>(kind: Kind): Staged<RecordOf<Kind>> {
+    return this.staged[kind];
+  }
+}
diff --git a/src/services/commands/tokenCommands.ts b/src/services/commands/tokenCommands.ts
new file mode 100644
index 000000000..82c8387b8
--- /dev/null
+++ b/src/services/commands/tokenCommands.ts
@@ -0,0 +1,299 @@
+import type { TokenAnalysis, TokenAnalysisLink } from 'interlinearizer';
+import { analysesAreIdentical, normalizeSurfaceForm } from '../../utils/analysis-identity';
+import { preferredLink, preferredPayload } from '../../utils/pick-rules';
+import { clearAnalysisGloss, isEmptyTokenAnalysis } from '../../utils/token-analysis-content';
+import type { ChangeBuffer } from './changeBuffer';
+
+/** What every token edit needs. */
+type TokenEdit = {
+  /** `Token.ref` of the token edited. */
+  tokenRef: string;
+  /** The token's current surface text, refreshed on the records the edit touches. */
+  surfaceText: string;
+  /** ISO 8601 time of the edit, stamped on the records it touches. */
+  now: string;
+  /** Id a new link takes, spent only when the edit makes one. */
+  linkId: string;
+};
+
+/** What writing a token's gloss needs. */
+export type WriteGlossRequest = TokenEdit & {
+  /** The gloss; blank clears the token's gloss in `analysisLanguage`. */
+  value: string;
+  /** BCP 47 tag of the language the gloss is written in. */
+  analysisLanguage: string;
+  /** Id a new token analysis takes, spent only when the write makes one. */
+  analysisId: string;
+};
+
+/** What approving a stored analysis for a token needs. */
+export type ApproveAnalysisRequest = TokenEdit & {
+  /** The stored token analysis to approve. */
+  analysisId: string;
+};
+
+/**
+ * The token's approved link that an approval tie picks, with its payload, or `undefined` when there
+ * is none. Approved links that name no stored payload are removed first, so that they never persist
+ * or crowd the pick.
+ */
+async function resolveApprovedAnalysis(
+  buffer: ChangeBuffer,
+  tokenRef: string,
+): Promise<{ link: TokenAnalysisLink; analysis: TokenAnalysis } | undefined> {
+  const { tokenAnalysisLinks } = await buffer.findLinksByToken([tokenRef]);
+  const approved = tokenAnalysisLinks.filter(({ status }) => status === 'approved');
+  const payloads = new Map(
+    (await buffer.getTokenAnalyses(approved.map(({ analysisId }) => analysisId))).map(
+      (analysis) => [analysis.id, analysis],
+    ),
+  );
+  approved
+    .filter(({ analysisId }) => !payloads.has(analysisId))
+    .forEach((orphan) => buffer.delete('tokenAnalysisLinks', orphan));
+  const link = preferredLink(approved.filter(({ analysisId }) => payloads.has(analysisId)));
+  const analysis = link && payloads.get(link.analysisId);
+  return link && analysis ? { link, analysis } : undefined;
+}
+
+/** Whether a token other than `link`'s links the payload `analysisId`, at any status. */
+async function isSharedByOtherTokens(
+  buffer: ChangeBuffer,
+  link: TokenAnalysisLink,
+  analysisId: string,
+): Promise<boolean> {
+  const { tokenAnalysisLinks } = await buffer.findLinksToAnalyses([analysisId]);
+  return tokenAnalysisLinks.some(({ token }) => token.tokenRef !== link.token.tokenRef);
+}
+
+/**
+ * Repoints `link` to a private copy of its shared payload, so that editing the link's token leaves
+ * the other tokens alone. The copy is dated by the edit. Staging `link` is left to the caller.
+ *
+ * @returns The copy, staged.
+ */
+function forkSharedAnalysis(
+  buffer: ChangeBuffer,
+  link: TokenAnalysisLink,
+  analysis: TokenAnalysis,
+  forkId: string,
+  now: string,
+): TokenAnalysis {
+  const fork: TokenAnalysis = { ...analysis, id: forkId, createdAt: now, updatedAt: now };
+  buffer.create('tokenAnalyses', fork);
+  link.analysisId = forkId;
+  return fork;
+}
+
+/**
+ * Approves the non-approved link `tokenRef` holds to `analysisId`, so a token taking on a record it
+ * was offered keeps one link to it. The link keeps its creation date and `confidence`.
+ *
+ * @returns The approved link, staged, or `undefined` when the token holds no such link.
+ */
+async function approveHeldLink(
+  buffer: ChangeBuffer,
+  tokenRef: string,
+  analysisId: string,
+  surfaceText: string,
+  now: string,
+): Promise<TokenAnalysisLink | undefined> {
+  const { tokenAnalysisLinks } = await buffer.findLinksByToken([tokenRef]);
+  const held = preferredLink(
+    tokenAnalysisLinks.filter((l) => l.status !== 'approved' && l.analysisId === analysisId),
+  );
+  if (!held) return undefined;
+  held.status = 'approved';
+  held.token.surfaceText = surfaceText;
+  held.updatedAt = now;
+  buffer.put('tokenAnalysisLinks', held);
+  return held;
+}
+
+/** Removes the payload once no link of any status names it. */
+async function reclaimIfUnlinked(buffer: ChangeBuffer, analysis: TokenAnalysis): Promise<void> {
+  const { tokenAnalysisLinks } = await buffer.findLinksToAnalyses([analysis.id]);
+  if (tokenAnalysisLinks.length === 0) buffer.delete('tokenAnalyses', analysis);
+}
+
+/**
+ * Leaves each token holding one link to `analysisId` where it held several. An approval tie picks
+ * the survivor from the token's approved links, or from all the token's links when none is
+ * approved. The survivor takes the earliest creation date among the token's links to `analysisId`.
+ */
+async function coalesceLinksPerToken(buffer: ChangeBuffer, analysisId: string): Promise<void> {
+  const { tokenAnalysisLinks } = await buffer.findLinksToAnalyses([analysisId]);
+  const byToken = new Map<string, TokenAnalysisLink[]>();
+  tokenAnalysisLinks.forEach((link) => {
+    byToken.set(link.token.tokenRef, [...(byToken.get(link.token.tokenRef) ?? []), link]);
+  });
+  byToken.forEach((links) => {
+    const kept =
+      preferredLink(links.filter(({ status }) => status === 'approved')) ?? preferredLink(links);
+    /* v8 ignore next -- every token's group holds a link */
+    if (!kept) return;
+    const createdAt = links.reduce(
+      (earliest, link) => (link.createdAt < earliest ? link.createdAt : earliest),
+      kept.createdAt,
+    );
+    links.forEach((link) => {
+      if (link !== kept) buffer.delete('tokenAnalysisLinks', link);
+    });
+    if (kept.createdAt !== createdAt) buffer.put('tokenAnalysisLinks', { ...kept, createdAt });
+  });
+}
+
+/**
+ * When the edit made `analysis` identical to another payload, folds it into that one, so that an
+ * edit never leaves a duplicate.
+ *
+ * Every link to `analysis` moves to the survivor. The survivor keeps its own timestamps. A token
+ * that links both keeps one link. The survivor's breakdown stays stale only when both payloads'
+ * were.
+ */
+async function mergeIntoIdenticalPayload(
+  buffer: ChangeBuffer,
+  analysis: TokenAnalysis,
+  now: string,
+): Promise<void> {
+  const candidates = await buffer.findTokenAnalysesByForm([
+    normalizeSurfaceForm(analysis.surfaceText),
+  ]);
+  const other = preferredPayload(
+    candidates.filter((ta) => ta.id !== analysis.id && analysesAreIdentical(ta, analysis)),
+  );
+  if (!other) return;
+  if (other.morphemesStale && !analysis.morphemesStale) {
+    delete other.morphemesStale;
+    other.updatedAt = now;
+    buffer.put('tokenAnalyses', other);
+  }
+  const { tokenAnalysisLinks } = await buffer.findLinksToAnalyses([analysis.id]);
+  tokenAnalysisLinks.forEach((link) =>
+    buffer.put('tokenAnalysisLinks', { ...link, analysisId: other.id }),
+  );
+  await coalesceLinksPerToken(buffer, other.id);
+  buffer.delete('tokenAnalyses', analysis);
+}
+
+/**
+ * Gives a token an approved link to a payload that holds `analysis`'s content. A content-identical
+ * stored payload is shared where one exists. Otherwise `analysis` is staged. A non-approved link
+ * that the token holds to the shared payload is approved, rather than joined by a second link.
+ */
+async function appendApprovedAnalysis(
+  buffer: ChangeBuffer,
+  analysis: TokenAnalysis,
+  { tokenRef, now, linkId }: TokenEdit,
+): Promise<void> {
+  const candidates = await buffer.findTokenAnalysesByForm([
+    normalizeSurfaceForm(analysis.surfaceText),
+  ]);
+  const existing = preferredPayload(candidates.filter((ta) => analysesAreIdentical(ta, analysis)));
+  if (!existing) buffer.create('tokenAnalyses', analysis);
+  else if (await approveHeldLink(buffer, tokenRef, existing.id, analysis.surfaceText, now)) return;
+  buffer.create('tokenAnalysisLinks', {
+    id: linkId,
+    analysisId: existing?.id ?? analysis.id,
+    createdAt: now,
+    updatedAt: now,
+    status: 'approved',
+    token: { tokenRef, surfaceText: analysis.surfaceText },
+  });
+}
+
+/**
+ * Stages writing a token's gloss.
+ *
+ * The edit is per token: a payload that other tokens share is forked first. An edit that makes the
+ * payload identical to another folds it into that one. A rewrite keeps the payload's
+ * `glossSenseRef`. A token with no approved analysis takes a content-identical stored one, or a new
+ * one.
+ *
+ * A blank value clears the gloss. A payload that the clear leaves empty goes once nothing links it.
+ * A blank write to a token with no approved analysis stages nothing.
+ */
+export async function writeGloss(buffer: ChangeBuffer, request: WriteGlossRequest): Promise<void> {
+  const { tokenRef, surfaceText, value, analysisLanguage: lang, analysisId, now } = request;
+  const isBlank = value.trim() === '';
+
+  const resolved = await resolveApprovedAnalysis(buffer, tokenRef);
+  if (resolved) {
+    const { link, analysis } = resolved;
+    const target = (await isSharedByOtherTokens(buffer, link, analysis.id))
+      ? forkSharedAnalysis(buffer, link, analysis, analysisId, now)
+      : analysis;
+    target.surfaceText = surfaceText;
+    target.updatedAt = now;
+    link.token.surfaceText = surfaceText;
+    link.updatedAt = now;
+    if (isBlank) {
+      clearAnalysisGloss(target, lang);
+      if (isEmptyTokenAnalysis(target)) {
+        buffer.delete('tokenAnalysisLinks', link);
+        const { tokenAnalysisLinks } = await buffer.findLinksToAnalyses([target.id]);
+        if (tokenAnalysisLinks.length === 0) buffer.delete('tokenAnalyses', target);
+        else buffer.put('tokenAnalyses', target);
+        return;
+      }
+    } else {
+      target.gloss = { ...target.gloss, [lang]: value };
+    }
+    buffer.put('tokenAnalyses', target);
+    buffer.put('tokenAnalysisLinks', link);
+    await mergeIntoIdenticalPayload(buffer, target, now);
+    return;
+  }
+
+  if (isBlank) return;
+  await appendApprovedAnalysis(
+    buffer,
+    { id: analysisId, createdAt: now, updatedAt: now, surfaceText, gloss: { [lang]: value } },
+    request,
+  );
+}
+
+/**
+ * Stages approving the stored payload `analysisId` for a token, in place of any approval the token
+ * held. Nothing is staged for a payload that isn't stored, or one already approved for the token.
+ *
+ * A token that holds a non-approved link to the payload has that link approved. The approved link
+ * keeps the earlier of its own creation date and the replaced approval's. A token with no approval
+ * and no link to the payload gets a new link. The payload that the replaced approval named goes
+ * once nothing links it.
+ */
+export async function approveAnalysisForToken(
+  buffer: ChangeBuffer,
+  { tokenRef, surfaceText, analysisId, now, linkId }: ApproveAnalysisRequest,
+): Promise<void> {
+  if ((await buffer.getTokenAnalyses([analysisId])).length === 0) return;
+  const resolved = await resolveApprovedAnalysis(buffer, tokenRef);
+  if (resolved?.link.analysisId === analysisId) return;
+
+  const pending = await approveHeldLink(buffer, tokenRef, analysisId, surfaceText, now);
+  if (pending) {
+    if (resolved) {
+      if (resolved.link.createdAt < pending.createdAt) {
+        buffer.put('tokenAnalysisLinks', { ...pending, createdAt: resolved.link.createdAt });
+      }
+      buffer.delete('tokenAnalysisLinks', resolved.link);
+    }
+  } else if (resolved) {
+    const { link } = resolved;
+    link.analysisId = analysisId;
+    link.token.surfaceText = surfaceText;
+    link.updatedAt = now;
+    buffer.put('tokenAnalysisLinks', link);
+  } else {
+    buffer.create('tokenAnalysisLinks', {
+      id: linkId,
+      analysisId,
+      createdAt: now,
+      updatedAt: now,
+      status: 'approved',
+      token: { tokenRef, surfaceText },
+    });
+  }
+
+  if (resolved) await reclaimIfUnlinked(buffer, resolved.analysis);
+}
diff --git a/src/services/draftRepository.ts b/src/services/draftRepository.ts
index d4f0e0787..080ca2ffd 100644
--- a/src/services/draftRepository.ts
+++ b/src/services/draftRepository.ts
@@ -23,7 +23,7 @@ import { applyChangeSet } from '../utils/change-set';
 import { jsonCopy } from '../utils/json-copy';
 import { perfTime, perfTimeAsync, perfTimeAsyncExcluding } from '../utils/perf-marks';
 import { AnalysisIndex } from './analysisIndex';
-import { IndexedRepository, type IndexedAnalysis } from './indexedRepository';
+import { IndexedRepository, type IndexedDraft } from './indexedRepository';
 import { draftAnalysisKey, draftJournalKey, draftKey } from './storageKeys';
 
 /**
@@ -136,7 +136,7 @@ export class DraftRepository extends IndexedRepository implements AnalysisReposi
    * its records. A whole save drops it, since its caller may hold another draft, and so does
    * {@link exportAll}, which reads storage afresh.
    */
-  private current: { draft: DraftProject; index: AnalysisIndex } | undefined;
+  private current: IndexedDraft | undefined;
 
   constructor(storage: KeyValueStorage, sourceProjectId: string, logger: WarningLogger) {
     super();
@@ -264,7 +264,7 @@ export class DraftRepository extends IndexedRepository implements AnalysisReposi
    *   is left as it was.
    */
   async apply(changes: ChangeSet): Promise<ApplyResult> {
-    const { draft: base, index } = await this.keptDraft();
+    const { draft: base, index } = await this.indexed();
     const copied = jsonCopy(changes);
     const { draft, inverse } = applyChangeSet(base, copied);
     await this.writeDraft(draft, undefined, { refuseUnreadable: true });
@@ -273,21 +273,13 @@ export class DraftRepository extends IndexedRepository implements AnalysisReposi
     return { inverse };
   }
 
-  protected async indexed(): Promise<AnalysisIndex> {
-    return (await this.keptDraft()).index;
-  }
-
-  protected keptIndex(): IndexedAnalysis | undefined {
-    return this.current && { analysis: this.current.draft.analysis, index: this.current.index };
-  }
-
   /**
    * The draft this instance keeps and the index over its records, loading the draft from storage
    * and building the index when none is kept.
    *
    * @throws Whatever {@link exportAll} throws.
    */
-  private async keptDraft(): Promise<{ draft: DraftProject; index: AnalysisIndex }> {
+  protected async indexed(): Promise<IndexedDraft> {
     if (!this.current) {
       const { draft } = await this.read(false);
       this.current = { draft, index: new AnalysisIndex(draft.analysis) };
@@ -295,6 +287,10 @@ export class DraftRepository extends IndexedRepository implements AnalysisReposi
     return this.current;
   }
 
+  protected keptIndex(): IndexedDraft | undefined {
+    return this.current;
+  }
+
   /**
    * Loads the stored draft as {@link readDraft} does, noting that this instance has loaded it.
    *
diff --git a/src/services/indexedRepository.ts b/src/services/indexedRepository.ts
index bfbcc7ff0..d0573b317 100644
--- a/src/services/indexedRepository.ts
+++ b/src/services/indexedRepository.ts
@@ -1,28 +1,31 @@
 import type {
   AssignmentStatus,
+  DraftProject,
   PhraseAnalysis,
   SegmentAnalysis,
   SegmentAnalysisLink,
-  TextAnalysis,
   TokenAnalysis,
 } from 'interlinearizer';
 import type {
   AnalysisLinks,
   AnalysisRepository,
   IndexDifference,
+  ScopeRecord,
 } from '../types/analysis-repository';
+import { scopeRecordOf } from '../utils/change-set';
 import { jsonCopy } from '../utils/json-copy';
 import type { AnalysisIndex } from './analysisIndex';
 
-/** An index, with the analysis whose records it is kept over. */
-export type IndexedAnalysis = {
-  analysis: TextAnalysis;
+/** An index, with the draft whose records it is kept over. */
+export type IndexedDraft = {
+  draft: DraftProject;
   index: AnalysisIndex;
 };
 
-/** The lookups of a repository that answers them from an {@link AnalysisIndex} over its records. */
+/** The reads of a repository that keeps an {@link AnalysisIndex} over its records. */
 export abstract class IndexedRepository implements Pick<
   AnalysisRepository,
+  | 'getScope'
   | 'getTokenAnalyses'
   | 'getPhraseAnalyses'
   | 'getSegmentAnalyses'
@@ -34,6 +37,10 @@ export abstract class IndexedRepository implements Pick<
   | 'findPhraseAnalysesByForm'
   | 'checkIndexes'
 > {
+  async getScope(): Promise<ScopeRecord> {
+    return jsonCopy(scopeRecordOf((await this.indexed()).draft));
+  }
+
   getTokenAnalyses(ids: string[]): Promise<TokenAnalysis[]> {
     return this.query((index) => index.getTokenAnalyses(ids));
   }
@@ -78,21 +85,21 @@ export abstract class IndexedRepository implements Pick<
    */
   async checkIndexes(): Promise<IndexDifference[]> {
     const kept = this.keptIndex();
-    return kept ? kept.index.differencesFrom(kept.analysis) : [];
+    return kept ? kept.index.differencesFrom(kept.draft.analysis) : [];
   }
 
   /** Runs `read` against the index and returns a copy of its result, so callers may change it. */
   private async query<T>(read: (index: AnalysisIndex) => T): Promise<T> {
-    return jsonCopy(read(await this.indexed()));
+    return jsonCopy(read((await this.indexed()).index));
   }
 
   /**
-   * The kept index, built over the stored records first when none is kept.
+   * The kept index and its draft, loaded from storage first when none is kept.
    *
    * @throws Whatever loading the stored records throws.
    */
-  protected abstract indexed(): Promise<AnalysisIndex>;
+  protected abstract indexed(): Promise<IndexedDraft>;
 
-  /** The kept index and the analysis it is kept over, or `undefined` when none is kept. */
-  protected abstract keptIndex(): IndexedAnalysis | undefined;
+  /** The kept index and the draft it is kept over, or `undefined` when none is kept. */
+  protected abstract keptIndex(): IndexedDraft | undefined;
 }
diff --git a/src/services/projectStorage.ts b/src/services/projectStorage.ts
index f3b6e714a..7f7fcc0d5 100644
--- a/src/services/projectStorage.ts
+++ b/src/services/projectStorage.ts
@@ -1144,6 +1144,7 @@ export function openDraftRepository(
     replaceAll: (draft, options) => counted((repository) => repository.replaceAll(draft, options)),
     markClean: () => queued((repository) => repository.markClean()),
     apply: (changes) => counted((repository) => repository.apply(changes)),
+    getScope: () => queued((repository) => repository.getScope()),
     getTokenAnalyses: (ids) => queued((repository) => repository.getTokenAnalyses(ids)),
     getPhraseAnalyses: (ids) => queued((repository) => repository.getPhraseAnalyses(ids)),
     getSegmentAnalyses: (ids) => queued((repository) => repository.getSegmentAnalyses(ids)),
diff --git a/src/services/pt9ImportRepository.ts b/src/services/pt9ImportRepository.ts
index 4aec82bda..a7e9166ea 100644
--- a/src/services/pt9ImportRepository.ts
+++ b/src/services/pt9ImportRepository.ts
@@ -8,7 +8,7 @@ import type {
 import { CURRENT_MODEL_VERSION } from '../types/model-version';
 import { ReadOnlyAnalysisError } from '../types/read-only-analysis-error';
 import { AnalysisIndex } from './analysisIndex';
-import { IndexedRepository, type IndexedAnalysis } from './indexedRepository';
+import { IndexedRepository, type IndexedDraft } from './indexedRepository';
 
 /**
  * A Paratext 9 import's analysis, read in a draft's shape. Only a sync replaces an import's
@@ -27,7 +27,7 @@ export class Pt9ImportRepository extends IndexedRepository implements AnalysisRe
    * The import as first read for a lookup, with the index over its records; dropped once a sync
    * replaces the import or a deletion removes it.
    */
-  private loaded: { draft: DraftProject; revision: number; index: AnalysisIndex } | undefined;
+  private loaded: (IndexedDraft & { revision: number }) | undefined;
 
   /**
    * @param interlinearProjectId - Id of the project to read, which must be a Paratext 9 import.
@@ -83,23 +83,19 @@ export class Pt9ImportRepository extends IndexedRepository implements AnalysisRe
     throw this.readOnlyError();
   }
 
-  protected async indexed(): Promise<AnalysisIndex> {
-    const kept = this.kept();
-    if (kept) return kept.index;
+  /** @throws Whatever {@link exportAll} throws. */
+  protected async indexed(): Promise<IndexedDraft> {
+    const kept = this.keptIndex();
+    if (kept) return kept;
     // The revision is taken before the read, so a sync landing during it forces another.
     const revision = this.revision();
     const draft = await this.readImport();
     this.loaded = { draft, revision, index: new AnalysisIndex(draft.analysis) };
-    return this.loaded.index;
-  }
-
-  protected keptIndex(): IndexedAnalysis | undefined {
-    const kept = this.kept();
-    return kept && { analysis: kept.draft.analysis, index: kept.index };
+    return this.loaded;
   }
 
   /** The import as last read, unless a sync or a deletion has changed it since. */
-  private kept() {
+  protected keptIndex(): IndexedDraft | undefined {
     if (this.loaded?.revision !== this.revision()) this.loaded = undefined;
     return this.loaded;
   }
diff --git a/src/store/analysisSlice.ts b/src/store/analysisSlice.ts
index f2635e7b4..50f24f9e6 100644
--- a/src/store/analysisSlice.ts
+++ b/src/store/analysisSlice.ts
@@ -22,6 +22,7 @@ import {
 import { buildCatalogRows, type HeadingPlacement } from '../utils/analysis-query';
 import type { StaleFreeTranslation } from '../utils/stale-free-translations';
 import { isEmptyMultiString } from '../utils/multi-string';
+import { clearAnalysisGloss, isEmptyTokenAnalysis } from '../utils/token-analysis-content';
 import {
   preferredLink,
   preferredLinkByKey,
@@ -856,7 +857,6 @@ function writeGlossOntoAnalysis(
   } else {
     if (!analysis.gloss) analysis.gloss = {};
     analysis.gloss[lang] = value;
-    delete analysis.glossSenseRef;
   }
   analysis.updatedAt = now;
 
@@ -868,46 +868,6 @@ function writeGlossOntoAnalysis(
   mergeIntoIdenticalPayload(state, analysis, now);
 }
 
-/**
- * Determines whether a `TokenAnalysis` carries no analysis content, so a reducer that just emptied
- * one field can decide to drop the whole record instead of letting empty records accumulate in
- * storage. Checks every content field of the type — `gloss`, `morphemes`, `pos`, `features`, and
- * `glossSenseRef` — not only the field the caller emptied, so records carrying imported
- * morphosyntactic or lexicon data are never discarded by an unrelated edit. A gloss counts as empty
- * when it has no entries or every entry is blank, so a record left holding only whitespace glosses
- * (junk from clearing a gloss field) is treated the same as one with no gloss at all.
- *
- * Provenance fields (`confidence`, `producer`, `sourceUser`) are intentionally NOT treated as
- * content: they describe who/what produced an analysis, not an analysis worth keeping on their own.
- * A record holding only provenance and no glosses/morphemes/pos/features is therefore considered
- * empty and may be dropped when its last content field is cleared. This is a deliberate choice — if
- * a future workflow needs provenance-only records (e.g. imported parser metadata) to survive a
- * gloss clear, add the relevant fields to the check below.
- */
-function isEmptyTokenAnalysis(analysis: TokenAnalysis): boolean {
-  return (
-    isEmptyMultiString(analysis.gloss) &&
-    /* v8 ignore next -- the length===0 sub-branch needs an empty-but-defined morphemes array, which no caller produces */
-    (!analysis.morphemes || analysis.morphemes.length === 0) &&
-    analysis.pos === undefined &&
-    analysis.features === undefined &&
-    analysis.glossSenseRef === undefined
-  );
-}
-
-/**
- * Empties one language's gloss, dropping the gloss and the analysis-wide `glossSenseRef` once no
- * language is left holding usable text — a sibling left holding only whitespace counts for neither,
- * so the sense is never stranded on a gloss nothing renders.
- */
-function clearAnalysisGloss(analysis: TokenAnalysis, lang: string): void {
-  if (analysis.gloss) {
-    delete analysis.gloss[lang];
-    if (isEmptyMultiString(analysis.gloss)) delete analysis.gloss;
-  }
-  if (!analysis.gloss) delete analysis.glossSenseRef;
-}
-
 /**
  * The annotated forms a re-split to `forms` would strand: those whose morpheme carries a gloss or a
  * lexicon reference and which the new breakdown leaves no morpheme to hold, in the order the old
@@ -979,9 +939,9 @@ const analysisSlice = createSlice({
        * stranded on an emptied payload. A blank write to a token with no approved analysis is a
        * no-op, so a focus/blur cycle on an empty gloss never creates a record.
        *
-       * A gloss the reader typed resolves through no lexicon sense of theirs, so a rewrite drops
-       * the payload's `glossSenseRef`. A clear drops it only once no language still holds usable
-       * gloss text, the sense belonging to the analysis rather than to the emptied language.
+       * A rewrite keeps the payload's `glossSenseRef`. A clear drops it only once no language still
+       * holds usable gloss text, the sense belonging to the analysis rather than to the emptied
+       * language.
        */
       reducer(state, action: PayloadAction<WriteGlossPayload>) {
         const { tokenRef, surfaceText, value, id, linkId, now } = action.payload;
@@ -1016,7 +976,6 @@ const analysisSlice = createSlice({
           }
           if (!target.gloss) target.gloss = {};
           target.gloss[lang] = value;
-          delete target.glossSenseRef;
           // An in-place edit can make this payload identical to an existing one (e.g. a homograph
           // instance re-glossed to match its sibling); re-converge so the dedupe the create path
           // guarantees on first write also holds after edits.
@@ -1249,9 +1208,9 @@ const analysisSlice = createSlice({
      * removes it and every link to it. An edit that makes the record identical to a sibling
      * collapses it into that sibling, so the edited row disappears from the catalog.
      *
-     * A gloss the reader typed resolves through no lexicon sense of theirs, so a rewrite drops the
-     * record's `glossSenseRef`. A clear drops it only once no language still holds usable gloss
-     * text, the sense belonging to the analysis rather than to the emptied language.
+     * A rewrite keeps the record's `glossSenseRef`. A clear drops it only once no language still
+     * holds usable gloss text, the sense belonging to the analysis rather than to the emptied
+     * language.
      */
     writeAnalysisGloss: {
       /** Reads the clock before the action reaches the reducer, keeping the reducer pure. */
diff --git a/src/types/analysis-repository.ts b/src/types/analysis-repository.ts
index cd5bdda2a..d67f56f02 100644
--- a/src/types/analysis-repository.ts
+++ b/src/types/analysis-repository.ts
@@ -206,6 +206,13 @@ export interface AnalysisRepository {
    */
   apply(changes: ChangeSet): Promise<ApplyResult>;
 
+  /**
+   * The draft's own record, as {@link AnalysisRepository.exportAll} would load it.
+   *
+   * @throws Whatever {@link AnalysisRepository.exportAll} throws.
+   */
+  getScope(): Promise<ScopeRecord>;
+
   /**
    * The token analyses stored under `ids`; an id with none stored under it is skipped.
    *
diff --git a/src/types/interlinearizer.d.ts b/src/types/interlinearizer.d.ts
index c43af3ea6..29ceb1abc 100644
--- a/src/types/interlinearizer.d.ts
+++ b/src/types/interlinearizer.d.ts
@@ -390,6 +390,34 @@ declare module 'papi-shared-types' {
      */
     'interlinearizer.checkIndexes': (sessionId: string) => Promise<string>;
 
+    /**
+     * Writes a token's gloss in a session's analysis language; a blank value clears it.
+     *
+     * @returns A JSON string of the changes it applied.
+     * @throws If the session is read-only or not open, or the edit is refused or fails (logged
+     *   before rethrowing).
+     */
+    'interlinearizer.writeGloss': (
+      sessionId: string,
+      tokenRef: string,
+      surfaceText: string,
+      value: string,
+    ) => Promise<string>;
+
+    /**
+     * Approves a stored token analysis for a token, in place of any approval the token held.
+     *
+     * @returns A JSON string of the changes it applied.
+     * @throws If the session is read-only or not open, or the edit is refused or fails (logged
+     *   before rethrowing).
+     */
+    'interlinearizer.approveAnalysisForToken': (
+      sessionId: string,
+      tokenRef: string,
+      surfaceText: string,
+      analysisId: string,
+    ) => Promise<string>;
+
     /**
      * Turns the extension host's timing entries on or off, discarding any it holds. Off until
      * turned on.
diff --git a/src/utils/change-set.ts b/src/utils/change-set.ts
index 0f48c72e5..e11a47445 100644
--- a/src/utils/change-set.ts
+++ b/src/utils/change-set.ts
@@ -7,6 +7,11 @@ export type AppliedChanges = {
   inverse: ChangeSet;
 };
 
+/** Whether `changes` change no record, the scope's record included. */
+export function isEmptyChangeSet(changes: ChangeSet): boolean {
+  return Object.keys(changes).every((key) => key === 'intent');
+}
+
 /** The draft's record, without its analysis or its `dirty` flag. */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- named only to leave them out
 export function scopeRecordOf({ analysis, dirty, ...scope }: DraftProject): ScopeRecord {
diff --git a/src/utils/token-analysis-content.ts b/src/utils/token-analysis-content.ts
new file mode 100644
index 000000000..1b4bbbe65
--- /dev/null
+++ b/src/utils/token-analysis-content.ts
@@ -0,0 +1,29 @@
+import type { TokenAnalysis } from 'interlinearizer';
+import { isEmptyMultiString } from './multi-string';
+
+/**
+ * Whether `analysis` holds no analysis content, so that an edit can drop the record rather than
+ * store an empty one. A gloss with only blank entries counts as empty. Provenance isn't content.
+ */
+export function isEmptyTokenAnalysis(analysis: TokenAnalysis): boolean {
+  return (
+    isEmptyMultiString(analysis.gloss) &&
+    /* v8 ignore next -- the length===0 sub-branch needs an empty-but-defined morphemes array, which no caller produces */
+    (!analysis.morphemes || analysis.morphemes.length === 0) &&
+    analysis.pos === undefined &&
+    analysis.features === undefined &&
+    analysis.glossSenseRef === undefined
+  );
+}
+
+/**
+ * Empties `lang`'s gloss, dropping `gloss` and `glossSenseRef` once no language holds non-blank
+ * text.
+ */
+export function clearAnalysisGloss(analysis: TokenAnalysis, lang: string): void {
+  if (analysis.gloss) {
+    delete analysis.gloss[lang];
+    if (isEmptyMultiString(analysis.gloss)) delete analysis.gloss;
+  }
+  if (!analysis.gloss) delete analysis.glossSenseRef;
+}