wowbagger 0.1.0-alpha.2 → 0.1.0-alpha.4

package/docs/work-claim-contract.md

@@ -263,6 +263,10 @@ It returns `result.read_back` with exactly `ledger_namespace`, `item_id`,
 reservation. It is the recovery operation after a lost claim response: the
 caller reads the tuple before retrying an acquire, renew, or release.
 
+`work-claim.read`, capability discovery, and `ledger-publication.read` are
+observational. They MUST NOT take the namespace write lock, advance the durable
+clock floor, reconcile publications, or change coordinator files.
+
 ### Acquire and takeover
 
 `work-claim.acquire` accepts exactly:
@@ -467,10 +471,11 @@ journal; that log is a derived audit artifact, not authority.
 
 A clean verification returns exit 0 and `state: "committed"`. Findings named
 `pending-intent-resolved` are clean recovery. Any
-`publication-outcome-unknown`, `revision-regression`, or
-`stale-write-detected` finding returns exit 6 and `state: "unknown"`. A caller
-MUST stop publication work and inspect those findings. Repeating verification
-MUST NOT duplicate a publication finalization.
+`legacy-mutation-outcome-unknown`, `publication-outcome-unknown`,
+`revision-regression`, or `stale-write-detected` finding returns exit 6 and
+`state: "unknown"`. A caller MUST stop publication work and inspect those
+findings. Repeating verification MUST NOT duplicate a publication
+finalization.
 
 The top-level `state: "committed"` describes durable reconciliation state, not
 Git finalization of every successful publication. A caller MUST gate Git
@@ -498,6 +503,18 @@ create MUST reject any item identity whose tuple has claim history with exit 4
 high-water mark. Both checks persist authoritative decision time before their
 response.
 
+Before a merge-coordinated backend permits a legacy transition or patch to
+write bytes, it MUST fsync a `legacy-mutation-intent` with the expected and
+candidate revisions. Under the same namespace lock, it MUST reserve journal
+capacity for that intent, one recovery clock entry, and one terminal entry. A
+committed write appends `legacy-mutation`; an unchanged write appends
+`legacy-mutation-abort`. Reconciliation resolves a pending intent to the
+committed terminal when the candidate revision is present, or to the abort
+terminal when the expected revision remains. Any third revision produces
+`legacy-mutation-outcome-unknown`. The latest committed terminal is the
+authorized expected revision. A later unrecorded revision remains a stale
+write.
+
 An implementation may instead route a legacy write through `publish-claimed`,
 but it cannot silently omit a fence. Administrative repair, bulk import,
 plugins, direct database writes, and filesystem writers count as alternate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowbagger",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.4",
   "description": "Plain-Markdown, Git-native work ledger for coordinating agents — validate, ready-select, and mutate a task ledger from the CLI.",
   "type": "module",
   "license": "MIT",
@@ -36,6 +36,7 @@
     "src",
     "skills",
     "adapters",
+    "docs/adapter-contract.md",
     "docs/mutation-contract.md",
     "docs/work-claim-contract.md",
     "scripts/migrate-schema-2.js",
@@ -45,6 +46,7 @@
   ],
   "scripts": {
     "check": "npm test && git diff --check && git diff --cached --check",
+    "report": "node bin/wowbagger.js report --ledger ledger --json",
     "test": "node --test test/*.test.js",
     "prepublishOnly": "node bin/wowbagger.js validate --ledger ledger --json >/dev/null && node --check bin/wowbagger.js && node scripts/verify-release-tag.js"
   },

package/skills/wowbagger/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: wowbagger
-description: Use when coordinating work through a wowbagger ledger — reading the ready queue, inspecting or filing an item, transitioning one through its lifecycle, taking a work claim, or publishing claimed work. Triggers on "ready queue", "what should I work on", "file a ledger item", "close this item", "claim this work", "publish claimed work", or any mention of a wowbagger ledger. Not for general backlog talk where no wowbagger ledger exists.
+description: Use when coordinating work through a wowbagger ledger — reading the ready queue, inspecting or filing an item, generating an HTML ledger report, transitioning one through its lifecycle, taking a work claim, or publishing claimed work. Triggers on "ready queue", "ledger report", "backlog report", "what should I work on", "file a ledger item", "close this item", "claim this work", "publish claimed work", or any mention of a wowbagger ledger. Not for general backlog talk where no wowbagger ledger exists.
 ---
 
 # Wowbagger
@@ -15,23 +15,29 @@ This skill does **not** bundle the wowbagger core. It drives an installed one,
 so a version mismatch is detectable rather than silent.
 
 ```sh
+wowbagger --version
 wowbagger capabilities --json
 ```
 
-Read the top-level `contract_version` from this core response. **This skill
-requires core `contract_version: 2`.**
+Read the plain distribution version from the first command and the top-level
+`contract_version` from the second. **This skill requires distribution version
+`0.1.0-alpha.4` and core `contract_version: 2`.**
 
 - Command not found → the core is not installed. Tell the user, point them at
   <https://github.com/lstutzman/wowbagger>, and stop. Do not fall back to
   editing ledger files by hand — hand-edits bypass validation and atomic
   publication, which is the whole point of the tool.
+- If the distribution version is missing or is different, stop and report the
+  installed and required versions. An older core can share contract version 2
+  while still lacking behavior this skill requires. Do not guess from the
+  contract version alone.
 - `contract_version` is anything other than `2` → stop and say so plainly. A
   core reporting `1` predates schema version 2, where `depends_on` records
   declared prerequisites rather than only live blockers; an older or newer core
   may have changed the request or response shape. Do not guess.
 
-Run this once per session before the first ledger command, not before every
-command.
+Run both commands once per session before the first ledger command, not before
+every command.
 
 ## Reading
 
@@ -55,6 +61,32 @@ wowbagger capabilities --json
   revision is what `transition` compares against, so inspect immediately before
   transitioning.
 
+## Generating an HTML report
+
+The report is read-only derived output. Its configuration is
+`<ledger>/.wowbagger/report.json`.
+
+```sh
+wowbagger report --ledger <dir> --as-of <YYYY-MM-DD> --json
+```
+
+Use today's date for `--as-of`. Use `--out <file>` only when the caller needs to
+override the configured output. The resolved output must stay outside the
+ledger. Do not use an npm script as a machine protocol; invoke `wowbagger`
+directly so standard output contains exactly one compact JSON object.
+
+On success, require exit `0`, `ok: true`, `command: "report"`,
+`contract_version: 2`, `result.report_version: 1`, and the requested
+`result.as_of`. Read the generated file from the absolute `result.output`.
+On failure, require `ok: false` and inspect `error.code`; do not treat an
+existing output as fresh because failed publication preserves the prior report.
+
+The generated HTML does not authorize transitions, claims, or parallel work.
+It has no live ledger revision. Its readiness state is the canonical projection
+at generation time, but the file is only a static view. Area-diverse batches are
+scheduling hints. Use `inspect` plus `transition` for lifecycle changes and the
+claim commands below for coordination.
+
 ## Writing
 
 Every write is an explicit, reviewable Git change. Show the user the command

package/src/adapter/entrypoint-main.js

@@ -26,6 +26,18 @@ const STANDARD_LIMITS = Object.freeze({
 });
 const PROBE_LIVE_CORE = Symbol('probe-live-core');
 
+function invalidDescribeResponse(details) {
+  return {
+    ok: false,
+    bootstrap_wire_version: 1,
+    error: {
+      code: 'invalid-describe-request',
+      message: 'The adapter describe request is invalid.',
+      details,
+    },
+  };
+}
+
 export function standardDynamicResult(manifest, coreProbe) {
   return {
     ok: true,
@@ -296,17 +308,19 @@ export async function runAdapterEntrypoint({
             details: incoming.detail,
           },
         }
-      : { ok: false, error: { code: incoming.error_code } };
+      : invalidDescribeResponse(incoming.detail);
     await writeBootstrapResponse(process.stdout, response);
     return;
   }
 
   if (operation === 'describe') {
     const described = describeAdapter(incoming.request, manifest, dynamic);
-    await writeBootstrapResponse(
-      process.stdout,
-      described.ok ? described.result : { ok: false, error: { code: described.error_code } },
-    );
+    const response = described.ok
+      ? described.result
+      : described.error_code === 'invalid-describe-request'
+        ? invalidDescribeResponse({ member: described.detail })
+        : { ok: false, error: { code: described.error_code } };
+    await writeBootstrapResponse(process.stdout, response);
     return;
   }
 

package/src/claim-coordinator.js

@@ -1,5 +1,11 @@
+import { randomUUID } from 'node:crypto';
 
-import { claimJournalPath, replayClaimJournal } from './claim-journal.js';
+import {
+  appendClaimEntry,
+  assertClaimJournalCapacity,
+  claimJournalPath,
+  replayClaimJournal,
+} from './claim-journal.js';
 import { resolveWorkClaimCapability } from './claim-capabilities.js';
 import { readBack } from './claim-operations.js';
 import { reconcileClaimJournal } from './claim-publication.js';
@@ -7,13 +13,19 @@ import { claimStorePath, resolveVerifiedGitCommonDir, withClaimLock } from './cl
 import { readNamespace } from './namespace.js';
 
 export async function withLegacyMutationFence(ledgerDirectory, itemId, command, write) {
-  const gitCommonDir = await resolveVerifiedGitCommonDir(ledgerDirectory);
+  let gitCommonDir;
+  try {
+    gitCommonDir = await resolveVerifiedGitCommonDir(ledgerDirectory, { failClosed: true });
+  } catch {
+    return claimStoreUnavailable(command, 'git-verification-failed');
+  }
   const namespace = gitCommonDir ? await readNamespace(ledgerDirectory) : null;
   const capability = resolveWorkClaimCapability({ gitCommonDir, namespace });
   if (!capability.claim_protected_publication) return write();
 
   const storePath = claimStorePath(gitCommonDir, namespace);
   const journalPath = claimJournalPath(gitCommonDir, namespace);
+  let intent = null;
   try {
     return await withClaimLock(storePath, async () => {
       const replayed = await replayClaimJournal(journalPath, namespace);
@@ -35,13 +47,107 @@ export async function withLegacyMutationFence(ledgerDirectory, itemId, command,
       const mustRefuse = command === 'create-v1'
         ? record.last_epoch !== '0'
         : record.active !== null && observedAt < record.active.expires_at;
-      if (!mustRefuse) return write();
-      return legacyRefusal(command, namespace, itemId, observedAt, record);
+      if (mustRefuse) return legacyRefusal(command, namespace, itemId, observedAt, record);
+
+      const authorize = async (expectedRevision, candidateRevision) => {
+        const attemptId = randomUUID();
+        const intentEntry = {
+          type: 'legacy-mutation-intent',
+          attempt_id: attemptId,
+          ledger_namespace: namespace,
+          item_id: itemId,
+          command,
+          expected_revision: expectedRevision,
+          candidate_revision: candidateRevision,
+          observed_at: observedAt,
+        };
+        const terminalEntry = {
+          type: 'legacy-mutation',
+          attempt_id: attemptId,
+          ledger_namespace: namespace,
+          item_id: itemId,
+          command,
+          committed_revision: candidateRevision,
+          observed_at: observedAt,
+        };
+        const abortEntry = {
+          type: 'legacy-mutation-abort',
+          attempt_id: attemptId,
+          ledger_namespace: namespace,
+          item_id: itemId,
+          observed_revision: expectedRevision,
+          observed_at: observedAt,
+        };
+        const resolutionEntry = Buffer.byteLength(JSON.stringify(terminalEntry))
+          >= Buffer.byteLength(JSON.stringify(abortEntry))
+          ? terminalEntry
+          : abortEntry;
+        await assertClaimJournalCapacity(journalPath, [
+          intentEntry,
+          { type: 'clock', now: observedAt, floor: observedAt },
+          resolutionEntry,
+        ]);
+        intent = await appendClaimEntry(journalPath, intentEntry);
+      };
+      let outcome;
+      try {
+        outcome = await write(authorize);
+      } catch (error) {
+        if (intent) {
+          return claimStoreUnavailable(command, 'legacy-mutation-outcome-unknown', {
+            attempt_id: intent.attempt_id,
+            candidate_revision: intent.candidate_revision,
+          }, 'unknown');
+        }
+        throw error;
+      }
+      if (!intent) return outcome;
+      if (outcome?.state === 'committed') {
+        const committedRevision = outcome.ok === true
+          ? outcome.item?.revision
+          : outcome.error?.details?.revision;
+        if (committedRevision !== intent.candidate_revision) {
+          return claimStoreUnavailable(command, 'legacy-mutation-outcome-unknown', {
+            attempt_id: intent.attempt_id,
+            candidate_revision: intent.candidate_revision,
+          }, 'unknown');
+        }
+        try {
+          await appendClaimEntry(journalPath, {
+            type: 'legacy-mutation',
+            attempt_id: intent.attempt_id,
+            ledger_namespace: namespace,
+            item_id: itemId,
+            command,
+            committed_revision: committedRevision,
+            observed_at: observedAt,
+          });
+        } catch {
+          return claimStoreUnavailable(command, 'legacy-mutation-record-failed', {
+            attempt_id: intent.attempt_id,
+            committed_revision: committedRevision,
+          }, 'unknown');
+        }
+      } else if (outcome?.state === 'unchanged') {
+        try {
+          await appendClaimEntry(journalPath, {
+            type: 'legacy-mutation-abort',
+            attempt_id: intent.attempt_id,
+            ledger_namespace: namespace,
+            item_id: itemId,
+            observed_revision: intent.expected_revision,
+            observed_at: observedAt,
+          });
+        } catch {
+          return claimStoreUnavailable(command, 'legacy-mutation-record-failed');
+        }
+      }
+      return outcome;
     });
   } catch (error) {
     return claimStoreUnavailable(command, error?.code === 'CLAIM_LOCK_HELD'
       ? 'claim-store-locked'
-      : 'claim-store-unreadable');
+      : 'claim-store-unreadable', {}, intent ? 'unknown' : 'unchanged');
   }
 }
 
@@ -66,7 +172,7 @@ function legacyRefusal(command, namespace, itemId, observedAt, record) {
   };
 }
 
-function claimStoreUnavailable(command, reason, details = {}) {
+function claimStoreUnavailable(command, reason, details = {}, state = 'unchanged') {
   return {
     exit: 6,
     stdout: {
@@ -74,7 +180,7 @@ function claimStoreUnavailable(command, reason, details = {}) {
       namespace: 'ledger-mutation',
       command,
       contract_version: 1,
-      state: 'unchanged',
+      state,
       error: {
         code: 'claim-store-unavailable',
         message: 'The durable claim store is unavailable.',

package/src/claim-journal.js

@@ -3,7 +3,7 @@ import { mkdir, open, readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { validateClaimRequest } from './claim-request.js';
 
-import { advanceClockFloor, claimAcquire, claimRead, claimRelease, claimRenew } from './claim-operations.js';
+import { advanceClockFloor, claimAcquire, claimRelease, claimRenew } from './claim-operations.js';
 import { emptyClaimState } from './claim-store.js';
 
 const MAX_JOURNAL_ENTRIES = 65536;
@@ -12,6 +12,9 @@ const MAX_RECONCILE_LOG_BYTES = MAX_JOURNAL_BYTES + 1024;
 const JOURNAL_ENTRY_TYPES = new Set([
   'claim',
   'clock',
+  'legacy-mutation',
+  'legacy-mutation-abort',
+  'legacy-mutation-intent',
   'publish-final',
   'publish-finalization',
   'publish-intent',
@@ -43,10 +46,23 @@ export async function appendClaimEntry(journalPath, entry) {
   return persisted;
 }
 
+export async function assertClaimJournalCapacity(journalPath, plannedEntries) {
+  const entries = await readJournalEntries(journalPath);
+  if (entries.length + plannedEntries.length > MAX_JOURNAL_ENTRIES) {
+    throw journalCapacityExceeded();
+  }
+  let plannedBytes = await fileSize(journalPath);
+  for (const [index, entry] of plannedEntries.entries()) {
+    const persisted = { seq: entries.length + index + 1, ...entry };
+    plannedBytes += Buffer.byteLength(`${JSON.stringify(persisted)}\n`);
+  }
+  if (plannedBytes > MAX_JOURNAL_BYTES) throw journalCapacityExceeded();
+}
+
 export async function replayClaimJournal(journalPath, namespace) {
   const entries = await readJournalEntries(journalPath, namespace);
   let state = emptyClaimState(namespace);
-  const operations = { acquire: claimAcquire, read: claimRead, release: claimRelease, renew: claimRenew };
+  const operations = { acquire: claimAcquire, release: claimRelease, renew: claimRenew };
   for (const entry of entries) {
     if (entry.type === 'clock') {
       advanceClockFloor(state, entry.floor);
@@ -177,6 +193,33 @@ function validJournalEntry(entry, namespace) {
       && validateClaimRequest(entry.command, entry.request).length === 0
       && (namespace === null || entry.request.ledger_namespace === namespace);
   }
+  if (entry.type === 'legacy-mutation-intent') {
+    return typeof entry.attempt_id === 'string'
+      && typeof entry.ledger_namespace === 'string'
+      && (namespace === null || entry.ledger_namespace === namespace)
+      && typeof entry.item_id === 'string'
+      && ['patch-v1', 'transition-v1'].includes(entry.command)
+      && typeof entry.expected_revision === 'string'
+      && typeof entry.candidate_revision === 'string'
+      && typeof entry.observed_at === 'string';
+  }
+  if (entry.type === 'legacy-mutation') {
+    return (!Object.hasOwn(entry, 'attempt_id') || typeof entry.attempt_id === 'string')
+      && typeof entry.ledger_namespace === 'string'
+      && (namespace === null || entry.ledger_namespace === namespace)
+      && typeof entry.item_id === 'string'
+      && ['patch-v1', 'transition-v1'].includes(entry.command)
+      && typeof entry.committed_revision === 'string'
+      && typeof entry.observed_at === 'string';
+  }
+  if (entry.type === 'legacy-mutation-abort') {
+    return typeof entry.attempt_id === 'string'
+      && typeof entry.ledger_namespace === 'string'
+      && (namespace === null || entry.ledger_namespace === namespace)
+      && typeof entry.item_id === 'string'
+      && typeof entry.observed_revision === 'string'
+      && typeof entry.observed_at === 'string';
+  }
   if (entry.type === 'publish-intent') {
     return typeof entry.operation_id === 'string'
       && typeof entry.operation_digest === 'string'

package/src/claim-publication.js

@@ -24,17 +24,28 @@ const EPOCH = /^(?:[1-9][0-9]{0,18}|1[0-7][0-9]{18}|18[0-3][0-9]{17}|184[0-3][0-
 const MAX_CANDIDATE_BYTES = 8388608;
 const MAX_CANDIDATE_BASE64_CHARS = Math.ceil(MAX_CANDIDATE_BYTES / 3) * 4;
 
+const PUBLICATION_MEMBERS = [
+  'candidate_sha256',
+  'candidate_source_base64',
+  'claim_fence',
+  'expected_revision',
+  'item_id',
+  'ledger_namespace',
+  'operation_id',
+];
+
 export function validatePublicationRequest(request) {
-  const required = [
-    'candidate_sha256',
-    'candidate_source_base64',
-    'claim_fence',
-    'expected_revision',
-    'item_id',
-    'ledger_namespace',
-    'operation_id',
-  ];
-  if (!isExactObject(request, required)
+  if (isExactObject(request, ['operation_id'])
+    && OPERATION_ID.test(request.operation_id)) {
+    return publicationError(
+      request,
+      'invalid-request',
+      'The publish-claimed retry must include its complete request.',
+      {},
+      2,
+    );
+  }
+  if (!isExactObject(request, PUBLICATION_MEMBERS)
     || !OPERATION_ID.test(request.operation_id)
     || !NAMESPACE_ID.test(request.ledger_namespace)
     || !ITEM_ID.test(request.item_id)
@@ -89,43 +100,40 @@ export function validatePublicationReadRequest(request) {
 }
 
 export async function readPublicationOutcome({ gitCommonDir, namespace, request }) {
-  const storePath = claimStorePath(gitCommonDir, namespace);
   const journalPath = claimJournalPath(gitCommonDir, namespace);
   try {
-    return await withClaimLock(storePath, async () => {
-      const replayed = await replayClaimJournal(journalPath, namespace);
-      const outcome = replayed.entries.find((entry) => (
-        entry.type === 'publish-final'
-          && entry.operation_id === request.operation_id
-          && entry.item_id === request.item_id
-      ));
-      if (!outcome) {
-        return publicationReadError(request, 'operation-not-found',
-          'The publication operation outcome was not found.', {
-            operation_id: request.operation_id,
-            ledger_namespace: request.ledger_namespace,
-            item_id: request.item_id,
-          });
-      }
-      return {
-        exit: 0,
-        stdout: {
-          ok: true,
-          namespace: 'ledger-publication',
-          command: 'read',
-          contract_version: 1,
-          state: 'committed',
+    const replayed = await replayClaimJournal(journalPath, namespace);
+    const outcome = replayed.entries.find((entry) => (
+      entry.type === 'publish-final'
+        && entry.operation_id === request.operation_id
+        && entry.item_id === request.item_id
+    ));
+    if (!outcome) {
+      return publicationReadError(request, 'operation-not-found',
+        'The publication operation outcome was not found.', {
           operation_id: request.operation_id,
-          result: {
-            operation_id: request.operation_id,
-            ledger_namespace: request.ledger_namespace,
-            item_id: request.item_id,
-            operation_digest: outcome.operation_digest,
-            outcome: structuredClone(outcome.outcome.stdout),
-          },
+          ledger_namespace: request.ledger_namespace,
+          item_id: request.item_id,
+        });
+    }
+    return {
+      exit: 0,
+      stdout: {
+        ok: true,
+        namespace: 'ledger-publication',
+        command: 'read',
+        contract_version: 1,
+        state: 'committed',
+        operation_id: request.operation_id,
+        result: {
+          operation_id: request.operation_id,
+          ledger_namespace: request.ledger_namespace,
+          item_id: request.item_id,
+          operation_digest: outcome.operation_digest,
+          outcome: structuredClone(outcome.outcome),
         },
-      };
-    });
+      },
+    };
   } catch (error) {
     return publicationReadError(request, 'claim-store-unavailable',
       'The durable claim store is unavailable.', {
@@ -282,6 +290,49 @@ export async function reconcileClaimJournal({
     error.code = 'CLOCK_FLOOR_PERSISTENCE_FAILED';
     throw error;
   }
+  const legacyMutationTerminals = new Set(entries
+    .filter((entry) => (
+      ['legacy-mutation', 'legacy-mutation-abort'].includes(entry.type)
+        && typeof entry.attempt_id === 'string'
+    ))
+    .map((entry) => entry.attempt_id));
+  const pendingLegacyMutations = entries.filter((entry) => (
+    entry.type === 'legacy-mutation-intent'
+      && !legacyMutationTerminals.has(entry.attempt_id)
+  ));
+  for (const intent of pendingLegacyMutations) {
+    const item = items.get(intent.item_id);
+    const actualRevision = item ? revisionFor(item.bytes) : null;
+    if (actualRevision === intent.candidate_revision) {
+      entries.push(await appendClaimEntry(journalPath, {
+        type: 'legacy-mutation',
+        attempt_id: intent.attempt_id,
+        ledger_namespace: namespace,
+        item_id: intent.item_id,
+        command: intent.command,
+        committed_revision: actualRevision,
+        observed_at: observedAt,
+      }));
+    } else if (actualRevision === intent.expected_revision) {
+      entries.push(await appendClaimEntry(journalPath, {
+        type: 'legacy-mutation-abort',
+        attempt_id: intent.attempt_id,
+        ledger_namespace: namespace,
+        item_id: intent.item_id,
+        observed_revision: actualRevision,
+        observed_at: observedAt,
+      }));
+    } else {
+      findings.push({
+        code: 'legacy-mutation-outcome-unknown',
+        item_id: intent.item_id,
+        attempt_id: intent.attempt_id,
+        actual_revision: actualRevision,
+        expected_revision: intent.expected_revision,
+        candidate_revision: intent.candidate_revision,
+      });
+    }
+  }
 
   for (const intent of pending) {
     const item = items.get(intent.item_id);
@@ -394,29 +445,40 @@ export async function reconcileClaimJournal({
     }
   }
 
-  const finalizedItems = new Set(entries
-    .filter((entry) => entry.type === 'publish-finalization')
+  const coordinatedItems = new Set(entries
+    .filter((entry) => (
+      entry.type === 'publish-finalization'
+        || entry.type === 'legacy-mutation'
+    ))
     .map((entry) => entry.item_id));
-  for (const itemId of finalizedItems) {
-    const published = entries.filter((entry) => (
-      entry.type === 'publish-final'
+  for (const itemId of coordinatedItems) {
+    const authorized = entries.filter((entry) => (
+      (entry.type === 'publish-final'
         && entry.item_id === itemId
-        && entry.outcome?.stdout?.state === 'committed'
+        && entry.outcome?.stdout?.state === 'committed')
+        || (entry.type === 'legacy-mutation' && entry.item_id === itemId)
     ));
-    const finalizations = entries.filter((entry) => (
-      entry.type === 'publish-finalization' && entry.item_id === itemId
-    ));
-    const expectedRevision = published.at(-1)?.outcome.stdout.result.committed_revision;
-    const finalizedRevision = finalizations.at(-1)?.committed_revision;
-    if (!expectedRevision || !finalizedRevision) continue;
+    const latestAuthorized = authorized.at(-1);
+    const expectedRevision = latestAuthorized?.type === 'legacy-mutation'
+      ? latestAuthorized.committed_revision
+      : latestAuthorized?.outcome.stdout.result.committed_revision;
+    const authorizedRevisions = new Set(authorized.map((entry) => (
+      entry.type === 'legacy-mutation'
+        ? entry.committed_revision
+        : entry.outcome.stdout.result.committed_revision
+    )));
+    for (const intent of entries) {
+      if (intent.type === 'legacy-mutation-intent' && intent.item_id === itemId) {
+        authorizedRevisions.add(intent.expected_revision);
+      }
+    }
+    if (!expectedRevision) continue;
     const item = items.get(itemId);
     const actualRevision = item ? revisionFor(item.bytes) : null;
     const headItem = headItems.get(itemId);
     const headRevision = headItem ? revisionFor(headItem.bytes) : null;
     const workingTreeChanged = actualRevision !== expectedRevision;
-    const gitHeadChanged = gitHead !== null
-      && headRevision !== expectedRevision
-      && headRevision !== finalizedRevision;
+    const gitHeadChanged = gitHead !== null && !authorizedRevisions.has(headRevision);
     if (!workingTreeChanged && !gitHeadChanged) continue;
     const record = replayed.state.claims.find((entry) => entry.item_id === itemId);
     findings.push({
@@ -438,7 +500,7 @@ export async function reconcileClaimJournal({
 
 
   for (const record of replayed.state.claims) {
-    if (finalizedItems.has(record.item_id)) continue;
+    if (coordinatedItems.has(record.item_id)) continue;
     if (record.active === null || observedAt >= record.active.expires_at) continue;
     const committed = entries.filter((entry) => (
       entry.type === 'publish-final'