create-harness-vibe-coding 0.8.19 → 0.9.3

package/src/wf-ui-server/__tests__/workflow-magnetic-topology.test.mjs

@@ -0,0 +1,222 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+// ── Helpers (mirror workflow-node-runtime.test.mjs) ──
+function tempProjectRoot() {
+  const id = crypto.randomBytes(4).toString('hex');
+  const dir = path.join(process.cwd(), '.tmp-magnetic-test-' + id);
+  fs.mkdirSync(path.join(dir, 'Harness', 'a2a', 'component-nodes'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'Harness', 'a2a', 'component-nodes', 'index.json'), JSON.stringify({ schemaVersion: 1, nodes: [] }));
+  fs.mkdirSync(path.join(dir, 'Harness', 'a2a'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'Harness', 'a2a', 'workflow-map.json'), JSON.stringify({ schemaVersion: 1, version: 1, nodes: [], edges: [], positions: {}, undoStack: [], redoStack: [], deletedNodes: [] }));
+  return dir;
+}
+
+function cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+}
+
+function seedAgentGraphNode(root, nodeId = 'session-mag-agent-01', overrides = {}) {
+  const graph = runtime.loadWorkflowGraphMap(root);
+  const sessionId = overrides.sessionId || `${nodeId}-pty`;
+  runtime.writeWorkflowGraphMap(root, {
+    ...graph,
+    version: graph.version + 1,
+    nodes: [
+      ...(graph.nodes || []),
+      {
+        nodeId,
+        sessionId,
+        agentKind: overrides.agentKind || 'main',
+        runtime: overrides.runtime || 'codex',
+        status: overrides.status || 'stopped',
+        label: overrides.label || 'Magnetic Agent',
+        cwd: root,
+        taskId: null,
+        role: overrides.role || overrides.agentKind || 'main',
+      },
+    ],
+    positions: {
+      ...(graph.positions || {}),
+      [nodeId]: { x: 100, y: 120 },
+    },
+  });
+  return nodeId;
+}
+
+function dockLink(a, b, connections = null) {
+  const pair = [a, b].sort();
+  const conns = connections || [
+    {
+      source: a,
+      target: b,
+      relation: 'wf-bridge',
+      direction: 'source-to-target',
+      sourceHandle: 'dock',
+      targetHandle: 'dock',
+    },
+  ];
+  return {
+    id: `dock:${pair[0]}::${pair[1]}`,
+    nodeIds: pair,
+    anchorId: pair[0],
+    draggedId: pair[1],
+    side: 'top',
+    edges: [],
+    connections: conns,
+  };
+}
+
+let store;
+let runtime;
+
+before(async () => {
+  store = await import('../a2a-store.mjs');
+  runtime = await import('../workflow-node-runtime.mjs');
+});
+
+// ── Pure function tests ──
+describe('computeMagneticTopology (pure function)', () => {
+  it('returns empty groups for empty input', () => {
+    const topo = store.computeMagneticTopology([]);
+    assert.deepEqual(topo.groups, []);
+    assert.deepEqual(topo.byNode, {});
+  });
+
+  it('returns empty groups for missing/null input', () => {
+    assert.deepEqual(store.computeMagneticTopology(undefined).groups, []);
+    assert.deepEqual(store.computeMagneticTopology(null).groups, []);
+  });
+
+  it('links A-B and B-C into one magnetic group (transitive)', () => {
+    const links = [
+      { nodeIds: ['A', 'B'] },
+      { nodeIds: ['B', 'C'] },
+    ];
+    const topo = store.computeMagneticTopology(links);
+    assert.equal(topo.groups.length, 1);
+    const groupId = topo.byNode.A.magneticGroupId;
+    assert.equal(topo.byNode.B.magneticGroupId, groupId);
+    assert.equal(topo.byNode.C.magneticGroupId, groupId);
+    assert.deepEqual(topo.groups[0].nodeIds.sort(), ['A', 'B', 'C']);
+  });
+
+  it('reports directMagneticNeighbors and transitive magneticReachableNodes', () => {
+    const links = [
+      { nodeIds: ['A', 'B'] },
+      { nodeIds: ['B', 'C'] },
+    ];
+    const { byNode } = store.computeMagneticTopology(links);
+    // A is docked only to B directly
+    assert.deepEqual(byNode.A.directMagneticNeighbors, ['B']);
+    // A can reach C transitively, and never reaches itself
+    assert.ok(byNode.A.magneticReachableNodes.includes('C'), 'A should reach C transitively');
+    assert.ok(!byNode.A.magneticReachableNodes.includes('A'), 'A must not list itself as reachable');
+    // C is docked only to B directly
+    assert.deepEqual(byNode.C.directMagneticNeighbors, ['B']);
+    // B is docked to both A and C directly
+    assert.deepEqual(byNode.B.directMagneticNeighbors.sort(), ['A', 'C']);
+  });
+
+  it('forms a separate group for an isolated D-E dock', () => {
+    const links = [
+      { nodeIds: ['A', 'B'] },
+      { nodeIds: ['B', 'C'] },
+      { nodeIds: ['D', 'E'] },
+    ];
+    const topo = store.computeMagneticTopology(links);
+    assert.equal(topo.groups.length, 2);
+    const aGroup = topo.byNode.A.magneticGroupId;
+    const dGroup = topo.byNode.D.magneticGroupId;
+    assert.notEqual(aGroup, dGroup);
+    // D-E pair: each directly neighbors the other
+    assert.deepEqual(topo.byNode.D.directMagneticNeighbors, ['E']);
+    assert.deepEqual(topo.byNode.E.directMagneticNeighbors, ['D']);
+    assert.deepEqual(topo.byNode.D.magneticReachableNodes, ['E']);
+    // The D-E group contains exactly D and E
+    const deGroup = topo.groups.find(group => group.nodeIds.includes('D'));
+    assert.deepEqual(deGroup.nodeIds.sort(), ['D', 'E']);
+  });
+
+  it('is deterministic: identical input yields identical output (no Date.now/Math.random)', () => {
+    const links = [
+      { nodeIds: ['A', 'B'] },
+      { nodeIds: ['B', 'C'] },
+      { nodeIds: ['D', 'E'] },
+    ];
+    const first = store.computeMagneticTopology(links);
+    const second = store.computeMagneticTopology(links);
+    assert.deepEqual(second, first);
+  });
+
+  it('ignores malformed links gracefully', () => {
+    const links = [
+      { nodeIds: ['A', 'B'] },
+      null,
+      { nodeIds: ['X'] }, // single endpoint, no edge
+      { notNodeIds: true },
+    ];
+    const topo = store.computeMagneticTopology(links);
+    // A-B is the only valid dock link
+    assert.equal(topo.groups.filter(group => group.nodeIds.length > 1).length, 1);
+    assert.deepEqual(topo.byNode.A.directMagneticNeighbors, ['B']);
+  });
+});
+
+// ── Context integration test ──
+describe('Workflow magnetic topology context', () => {
+  it('exposes magneticTopology in agent node context with shared magneticGroupId', async () => {
+    const root = tempProjectRoot();
+    try {
+      const aId = seedAgentGraphNode(root, 'session-mag-a');
+      const bId = seedAgentGraphNode(root, 'session-mag-b');
+      const cId = seedAgentGraphNode(root, 'session-mag-c');
+      const graph = runtime.loadWorkflowGraphMap(root);
+      runtime.writeWorkflowGraphMap(root, {
+        ...graph,
+        version: graph.version + 1,
+        edges: [],
+        capsuleDockLinks: [
+          dockLink(aId, bId),
+          dockLink(bId, cId),
+        ],
+      });
+
+      const aContext = await runtime.getNodeContext(root, aId);
+      assert.ok(aContext.context.magneticTopology, 'agent context must expose magneticTopology');
+      assert.ok(Array.isArray(aContext.context.magneticTopology.groups));
+      assert.equal(aContext.context.magneticTopology.groupCount, 1);
+      assert.equal(aContext.context.magneticTopology.dockLinkCount, 2);
+      // Per-node fields are present
+      assert.ok('magneticGroupId' in aContext.context, 'magneticGroupId must be present');
+      assert.ok(Array.isArray(aContext.context.directMagneticNeighbors));
+      assert.ok(Array.isArray(aContext.context.magneticReachableNodes));
+      // A is docked directly only to B
+      assert.deepEqual(aContext.context.directMagneticNeighbors, [bId]);
+      // A reaches C transitively
+      assert.ok(aContext.context.magneticReachableNodes.includes(cId));
+      assert.ok(!aContext.context.magneticReachableNodes.includes(aId));
+
+      const bContext = await runtime.getNodeContext(root, bId);
+      const cContext = await runtime.getNodeContext(root, cId);
+      // All three share the same magneticGroupId
+      assert.equal(
+        aContext.context.magneticGroupId,
+        bContext.context.magneticGroupId,
+        'A and B must share magneticGroupId',
+      );
+      assert.equal(
+        aContext.context.magneticGroupId,
+        cContext.context.magneticGroupId,
+        'A and C must share magneticGroupId',
+      );
+      // C is docked directly only to B
+      assert.deepEqual(cContext.context.directMagneticNeighbors, [bId]);
+    } finally {
+      cleanup(root);
+    }
+  });
+});

package/src/wf-ui-server/__tests__/workflow-markdown-lock.test.mjs

@@ -0,0 +1,359 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { makeHarnessTempRoot } from '../../../tests/support/temp-root.js';
+
+async function loadModules() {
+  const store = await import('../component-node-store.mjs');
+  const markdown = await import('../workflow-node-types/markdown-node.mjs');
+  return { store, markdown };
+}
+
+function makeProject(prefix = 'wf-markdown-lock-') {
+  const projectRoot = makeHarnessTempRoot(prefix);
+  fs.mkdirSync(path.join(projectRoot, 'Harness', 'tasks'), { recursive: true });
+  return projectRoot;
+}
+
+function createMarkdown(store, projectRoot, title, markdown) {
+  return store.createComponentNode(projectRoot, { type: 'markdown', title, markdown });
+}
+
+test('T8/AC-016 markdown.find by nodeId and by title returns nodeId + stateRef, never content', async () => {
+  const { store, markdown } = await loadModules();
+  const projectRoot = makeProject();
+  try {
+    const board = createMarkdown(store, projectRoot, 'Sprint Board', '# Sprint\nsecret body');
+    const design = createMarkdown(store, projectRoot, 'Design Notes', '# Design\nsecret body');
+
+    const byNodeId = markdown.find(board.node.nodeId, projectRoot, { nodeId: board.node.nodeId });
+    assert.equal(byNodeId.count, 1);
+    assert.equal(byNodeId.matches[0].nodeId, board.node.nodeId);
+    assert.equal(byNodeId.matches[0].title, 'Sprint Board');
+    assert.equal(byNodeId.matches[0].revision, 1);
+    assert.deepEqual(byNodeId.matches[0].stateRef, { path: board.node.statePath, revision: 1 });
+    assert.ok(!('markdown' in byNodeId.matches[0]), 'find must never return content');
+
+    const byTitle = markdown.find(board.node.nodeId, projectRoot, { title: 'design' });
+    assert.equal(byTitle.count, 1);
+    assert.equal(byTitle.matches[0].nodeId, design.node.nodeId);
+    assert.ok(!('markdown' in byTitle.matches[0]), 'title search must never return content');
+
+    const noMatch = markdown.find(board.node.nodeId, projectRoot, { title: 'does-not-exist' });
+    assert.equal(noMatch.count, 0);
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('T9/AC-017 lock lease + revision guard: second writer gets markdown_conflict, never silent overwrite', async () => {
+  const { store, markdown } = await loadModules();
+  const projectRoot = makeProject();
+  try {
+    const created = createMarkdown(store, projectRoot, 'Shared Notes', 'v1');
+    const nodeId = created.node.nodeId;
+
+    // Writer A acquires the lease (default TTL 30s)
+    const lock = markdown.acquireLock(nodeId, projectRoot, { lockOwner: 'agent-a' });
+    assert.equal(lock.owner, 'agent-a');
+    assert.equal(lock.revision, 1);
+    assert.ok(lock.lockId);
+    assert.ok(lock.expiresAt > Date.now());
+    assert.ok(lock.expiresAt - Date.now() >= 29000, 'default ttlSeconds should be 30');
+
+    // Writer B cannot acquire while A holds it
+    assert.throws(
+      () => markdown.acquireLock(nodeId, projectRoot, { lockOwner: 'agent-b', ttlSeconds: 30 }),
+      (err) => {
+        assert.equal(err.code, 'markdown_locked');
+        assert.equal(err.holder, 'agent-a');
+        assert.ok(err.expiresAt);
+        return true;
+      },
+    );
+
+    // A writes with its lockId + expectedRevision
+    const written = markdown.append(nodeId, projectRoot, {
+      markdown: '\nv2 from A',
+      lockId: lock.lockId,
+      expectedRevision: lock.revision,
+    });
+    assert.equal(written.revision, 2);
+    assert.ok(written.markdown.includes('v2 from A'));
+
+    // B cannot release a lock it does not hold
+    assert.throws(
+      () => markdown.releaseLock(nodeId, projectRoot, { lockOwner: 'agent-b', lockId: lock.lockId }),
+      (err) => {
+        assert.equal(err.code, 'markdown_locked');
+        return true;
+      },
+    );
+
+    // A releases the lease; the revision guard (markdown_conflict) then applies
+    // to writes without a lock (F18/D15: lockless writes stay compatible).
+    const released = markdown.releaseLock(nodeId, projectRoot, { lockOwner: 'agent-a', lockId: lock.lockId });
+    assert.equal(released.released, true);
+
+    // B holds a stale expectedRevision -> recoverable conflict, no write happens
+    assert.throws(
+      () => markdown.append(nodeId, projectRoot, { markdown: '\nclobbered by B', expectedRevision: 1 }),
+      (err) => {
+        assert.equal(err.code, 'markdown_conflict');
+        assert.equal(err.currentRevision, 2);
+        assert.equal(err.expectedRevision, 1);
+        assert.match(err.message, /Reread, merge your changes, and retry/);
+        return true;
+      },
+    );
+    const after = markdown.read(nodeId, projectRoot);
+    assert.equal(after.revision, 2);
+    assert.ok(!after.markdown.includes('clobbered by B'), 'conflict must not write');
+
+    // B rereads and retries with the fresh revision (AC-018 flow)
+    const retried = markdown.append(nodeId, projectRoot, { markdown: '\nv3 from B', expectedRevision: after.revision });
+    assert.equal(retried.revision, 3);
+    assert.ok(retried.markdown.includes('v3 from B'));
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('F18/D15: write while lock held by another conflicts with markdown_locked even without expectedRevision', async () => {
+  const { store, markdown } = await loadModules();
+  const projectRoot = makeProject();
+  try {
+    const created = createMarkdown(store, projectRoot, 'Locked Notes', 'body');
+    const nodeId = created.node.nodeId;
+    markdown.acquireLock(nodeId, projectRoot, { lockOwner: 'agent-a', ttlSeconds: 30 });
+
+    // Mandatory exclusion while held: a valid foreign lock rejects patch/append/
+    // replace with markdown_locked EVEN IF no expectedRevision is supplied.
+    assert.throws(
+      () => markdown.patch(nodeId, projectRoot, { diff: { op: 'append', text: 'x' } }),
+      (err) => {
+        assert.equal(err.code, 'markdown_locked');
+        assert.equal(err.holder, 'agent-a');
+        assert.ok(err.expiresAt);
+        return true;
+      },
+    );
+    assert.throws(
+      () => markdown.append(nodeId, projectRoot, { markdown: '\nclobbered' }),
+      (err) => {
+        assert.equal(err.code, 'markdown_locked');
+        assert.equal(err.holder, 'agent-a');
+        return true;
+      },
+    );
+    assert.throws(
+      () => markdown.replace(nodeId, projectRoot, { markdown: 'clobbered' }),
+      (err) => {
+        assert.equal(err.code, 'markdown_locked');
+        assert.equal(err.holder, 'agent-a');
+        return true;
+      },
+    );
+    const after = markdown.read(nodeId, projectRoot);
+    assert.equal(after.markdown, 'body', 'no write may land while a valid foreign lock is held');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-018 conflict carries currentRevision; reread + merge + retry succeeds', async () => {
+  const { store, markdown } = await loadModules();
+  const projectRoot = makeProject();
+  try {
+    const created = createMarkdown(store, projectRoot, 'Merge Notes', 'base');
+    const nodeId = created.node.nodeId;
+
+    const r1 = markdown.read(nodeId, projectRoot);
+    assert.equal(r1.revision, 1);
+
+    // Concurrent writer A writes without a guard (compat path)
+    markdown.append(nodeId, projectRoot, { markdown: '\nA writes' });
+
+    // Writer B with stale expectedRevision gets a recoverable conflict
+    assert.throws(
+      () => markdown.replace(nodeId, projectRoot, { markdown: 'B overwrite', expectedRevision: r1.revision }),
+      (err) => {
+        assert.equal(err.code, 'markdown_conflict');
+        assert.equal(err.currentRevision, 2);
+        assert.equal(err.expectedRevision, 1);
+        return true;
+      },
+    );
+
+    // B rereads, merges, and retries with the fresh currentRevision
+    const fresh = markdown.read(nodeId, projectRoot);
+    assert.equal(fresh.revision, 2);
+    const merged = markdown.replace(nodeId, projectRoot, {
+      markdown: `${fresh.markdown}\nB merged`,
+      expectedRevision: fresh.revision,
+    });
+    assert.equal(merged.revision, 3);
+    const final = markdown.read(nodeId, projectRoot);
+    assert.ok(final.markdown.includes('A writes'));
+    assert.ok(final.markdown.includes('B merged'));
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('compat: patch/append/replace with no lock and no expectedRevision keep last-write-wins behavior', async () => {
+  const { store, markdown } = await loadModules();
+  const projectRoot = makeProject();
+  try {
+    const created = createMarkdown(store, projectRoot, 'Compat Notes', 'v1');
+    const nodeId = created.node.nodeId;
+
+    const appended = markdown.append(nodeId, projectRoot, { markdown: '\nv2' });
+    assert.equal(appended.revision, 2);
+
+    const patched = markdown.patch(nodeId, projectRoot, { diff: { op: 'insert', text: 'X', offset: 0 } });
+    assert.equal(patched.revision, 3);
+
+    const replaced = markdown.replace(nodeId, projectRoot, { markdown: 'v4' });
+    assert.equal(replaced.revision, 4);
+    assert.equal(replaced.markdown, 'v4');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('store lease: TTL expiry + renewal + release rules via clock injection (no sleeping)', async () => {
+  const { store } = await loadModules();
+  const projectRoot = makeProject();
+  try {
+    const created = createMarkdown(store, projectRoot, 'Ttl Notes', 'x');
+    const nodeId = created.node.nodeId;
+    const T0 = Date.UTC(2026, 7, 12, 9, 0, 0);
+
+    const lock = store.acquireLock(nodeId, 'agent-a', 30000, { now: T0 });
+    assert.equal(lock.expiresAt, T0 + 30000);
+    assert.ok(store.isLocked(nodeId, T0 + 1000));
+
+    // second acquire while held -> markdown_locked with holder + expiresAt
+    assert.throws(
+      () => store.acquireLock(nodeId, 'agent-b', 30000, { now: T0 + 1000 }),
+      (err) => {
+        assert.equal(err.code, 'markdown_locked');
+        assert.equal(err.holder, 'agent-a');
+        assert.equal(err.expiresAt, T0 + 30000);
+        return true;
+      },
+    );
+
+    // renewal: same holder re-acquires with its own lockId -> same lockId, extended expiry
+    const renewed = store.acquireLock(nodeId, 'agent-a', 30000, { now: T0 + 1000, lockId: lock.lockId });
+    assert.equal(renewed.lockId, lock.lockId);
+    assert.equal(renewed.expiresAt, T0 + 31000);
+
+    // expiry: at T0 + 61000 the lease is gone; another holder may acquire freely
+    assert.equal(store.isLocked(nodeId, T0 + 61000), null);
+    const bLock = store.acquireLock(nodeId, 'agent-b', 30000, { now: T0 + 61000 });
+    assert.equal(bLock.holder, 'agent-b');
+
+    // release when not holder -> error; release by holder -> released
+    assert.throws(
+      () => store.releaseLock(nodeId, 'agent-a', { now: T0 + 62000 }),
+      (err) => err.code === 'markdown_locked',
+    );
+    const released = store.releaseLock(nodeId, 'agent-b', { now: T0 + 62000, lockId: bLock.lockId });
+    assert.equal(released.released, true);
+    assert.equal(store.isLocked(nodeId, T0 + 62000), null);
+
+    // release after expiry is a no-op
+    const a2 = store.acquireLock(nodeId, 'agent-a', 30000, { now: T0 + 70000 });
+    const noop = store.releaseLock(nodeId, 'agent-a', { now: T0 + 70000 + 40000, lockId: a2.lockId });
+    assert.equal(noop.released, false);
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('F18/D15: lock survives store re-init — persisted in node state, read on load, TTL honored', async () => {
+  const { store, markdown } = await loadModules();
+  const projectRoot = makeProject();
+  try {
+    const created = createMarkdown(store, projectRoot, 'Persist Notes', 'body');
+    const nodeId = created.node.nodeId;
+    const lock = markdown.acquireLock(nodeId, projectRoot, { lockOwner: 'agent-a', ttlSeconds: 30 });
+    assert.ok(lock.lockId);
+
+    // A brand-new store module instance (fresh in-memory registry, i.e. a
+    // restarted process) must see the persisted lease from the node state.
+    const freshStore = await import(`../component-node-store.mjs?restart=${Date.now()}`);
+    const persisted = freshStore.isLocked(nodeId, Date.now() + 1000, { projectRoot });
+    assert.ok(persisted, 'persisted lock must survive store re-init');
+    assert.equal(persisted.holder, 'agent-a');
+    assert.equal(persisted.lockId, lock.lockId);
+
+    // The fresh instance also refuses writes under the foreign persisted lock.
+    await assert.rejects(
+      freshMarkdownAppend(nodeId, projectRoot, 'clobber'),
+      (err) => {
+        assert.equal(err.code, 'markdown_locked');
+        assert.equal(err.holder, 'agent-a');
+        return true;
+      },
+    );
+    const untouched = markdown.read(nodeId, projectRoot);
+    assert.equal(untouched.markdown, 'body');
+
+    // Owner renewal keeps the SAME persisted lockId and extends the expiry.
+    const renewed = freshStore.acquireLock(nodeId, 'agent-a', 30000, { lockId: lock.lockId, projectRoot });
+    assert.equal(renewed.lockId, lock.lockId);
+    assert.ok(renewed.expiresAt > lock.expiresAt, 'renewal must extend the lease');
+
+    // Release clears the persisted lease so a new store sees no lock.
+    freshStore.releaseLock(nodeId, 'agent-a', { lockId: lock.lockId, projectRoot });
+    const afterRelease = freshStore.isLocked(nodeId, Date.now() + 1000, { projectRoot });
+    assert.equal(afterRelease, null, 'release must clear the persisted lease');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+// Append through the FRESH markdown module instance so the memory cache of the
+// original store is irrelevant — the persisted lock is the only source.
+async function freshMarkdownAppend(nodeId, projectRoot, text) {
+  const freshMarkdown = await import(`../workflow-node-types/markdown-node.mjs?fresh=${Date.now()}`);
+  return freshMarkdown.append(nodeId, projectRoot, { markdown: `\n${text}` });
+}
+
+test('F18/D15: after TTL expiry a foreign-lock write is allowed again (expiry honored on read)', async () => {
+  const { store, markdown } = await loadModules();
+  const projectRoot = makeProject();
+  try {
+    const created = createMarkdown(store, projectRoot, 'Expiry Notes', 'v1');
+    const nodeId = created.node.nodeId;
+    const lock = markdown.acquireLock(nodeId, projectRoot, { lockOwner: 'agent-a', ttlSeconds: 1 });
+    assert.ok(lock.lockId);
+
+    await new Promise(resolve => setTimeout(resolve, 1200));
+
+    // Lease expired on read -> the write gate sees no valid lock and allows the
+    // lockless write (compat path), clearing the stale persisted record.
+    const written = markdown.append(nodeId, projectRoot, { markdown: '\nv2 after expiry' });
+    assert.equal(written.revision, 2);
+    const state = store.getComponentNode(projectRoot, nodeId);
+    assert.equal(state.state.lock, null, 'stale persisted lock record must be cleared by the write');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('store assertRevision: null on match, markdown_conflict error on mismatch with currentRevision', async () => {
+  const { store } = await loadModules();
+  assert.equal(store.assertRevision(2, 2), null);
+  assert.equal(store.assertRevision(2, undefined), null);
+  assert.equal(store.assertRevision(2, '2'), null, 'numeric string should compare as number');
+  const err = store.assertRevision(2, 1);
+  assert.equal(err.code, 'markdown_conflict');
+  assert.equal(err.currentRevision, 2);
+  assert.equal(err.expectedRevision, 1);
+  assert.match(err.message, /revision 1 -> 2/);
+});