amalgm 0.1.158 → 0.1.159

package/runtime/scripts/amalgm-mcp/tests/workspace-cards.test.js

@@ -0,0 +1,401 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-repo-cards-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_COMPUTER_ID = 'computer-test';
+
+const { closeLocalDb, openLocalDb } = require('../state/db');
+const {
+  buildRepoCard,
+  cardFingerprint,
+  discoverWorktrees,
+  remoteIdentity,
+} = require('../workspace/card');
+const { classifyDirectory } = require('../workspace/git');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+async function run(cwd, ...args) {
+  await execFileAsync(
+    'git',
+    [
+      '-c', 'user.email=test@amalgm.test',
+      '-c', 'user.name=Amalgm Test',
+      '-c', 'commit.gpgsign=false',
+      '-c', 'protocol.file.allow=always',
+      ...args,
+    ],
+    { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' } },
+  );
+}
+
+function write(dir, file, content) {
+  fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true });
+  fs.writeFileSync(path.join(dir, file), content);
+}
+
+let repoCounter = 0;
+async function makeRepo(name, { commit = true } = {}) {
+  const dir = path.join(tempRoot, name);
+  fs.mkdirSync(dir, { recursive: true });
+  await run(dir, 'init', '-b', 'main');
+  if (commit) {
+    write(dir, 'README.md', `# ${name} ${repoCounter++}\n`);
+    await run(dir, 'add', '.');
+    await run(dir, 'commit', '-m', 'initial');
+  }
+  return dir;
+}
+
+test('remoteIdentity folds every clone style onto one https identity', () => {
+  const canonical = 'https://github.com/Org/Repo';
+  assert.equal(remoteIdentity('git@github.com:Org/Repo.git'), canonical);
+  assert.equal(remoteIdentity('https://github.com/Org/Repo.git'), canonical);
+  assert.equal(remoteIdentity('https://user:token@GitHub.com/Org/Repo/'), canonical);
+  assert.equal(remoteIdentity('ssh://git@github.com:2222/Org/Repo.git'), canonical);
+});
+
+test('remoteIdentity never lets a secret or a machine-local name survive', () => {
+  // Credentials and tokens are stripped wherever they hide.
+  assert.equal(
+    remoteIdentity('https://ci:SECRET123@github.com/org/repo.git'),
+    'https://github.com/org/repo',
+  );
+  assert.equal(
+    remoteIdentity('https://github.com/org/repo?access_token=SECRET123'),
+    'https://github.com/org/repo',
+  );
+  assert.equal(
+    remoteIdentity('https://github.com/org/repo.git#token=SECRET123'),
+    'https://github.com/org/repo',
+  );
+  // Machine-local remotes identify nothing off this machine.
+  assert.equal(remoteIdentity('file:///Users/dev/repo'), null);
+  assert.equal(remoteIdentity('/Users/dev/repo'), null);
+  assert.equal(remoteIdentity('../sibling/repo'), null);
+  assert.equal(remoteIdentity('~/repos/thing'), null);
+  // ssh aliases resolve through this machine's own ssh config.
+  assert.equal(remoteIdentity('github-work:org/repo.git'), null);
+  assert.equal(remoteIdentity('git@bastion:org/repo.git'), null);
+  // scp-like absolute paths on a real host keep their identity.
+  assert.equal(remoteIdentity('git@build.example.com:/srv/git/repo.git'), 'https://build.example.com/srv/git/repo');
+});
+
+test('a clean repo cards with exact head, clean counts, and full identity', async () => {
+  const dir = await makeRepo('clean');
+  await run(dir, 'remote', 'add', 'origin', 'git@github.com:amalgm/clean.git');
+
+  const card = await buildRepoCard(dir);
+  assert.equal(card.card, 'repo-card@2');
+  assert.equal(card.machine, 'computer-test');
+  assert.match(card.replica, /^rpl_[A-Za-z0-9_-]+$/);
+  assert.equal(card.path, await fs.promises.realpath(dir));
+  assert.equal(card.kind, 'primary');
+  assert.equal(card.repo.remote, 'https://github.com/amalgm/clean');
+  assert.match(card.repo.rootCommit, /^[0-9a-f]{40}$/);
+  assert.equal(card.head.branch, 'main');
+  assert.match(card.head.oid, /^[0-9a-f]{40}$/);
+  assert.equal(card.head.detached, false);
+  assert.deepEqual(card.dirty, { staged: 0, unstaged: 0, untracked: 0, conflicted: 0, submodulesChanged: 0 });
+  assert.equal(card.operation, 'none');
+});
+
+test('observation never runs repo-configured programs, and repo config cannot hide files', async () => {
+  const dir = await makeRepo('hostile');
+  const spy = path.join(tempRoot, 'fsmonitor-ran');
+  const hook = path.join(tempRoot, 'fsmonitor-spy.sh');
+  fs.writeFileSync(hook, `#!/bin/sh\ntouch "${spy}"\necho '/'\n`, { mode: 0o755 });
+  await run(dir, 'config', 'core.fsmonitor', hook);
+  await run(dir, 'config', 'status.showUntrackedFiles', 'no');
+  write(dir, 'loose.txt', 'x\n');
+
+  const card = await buildRepoCard(dir);
+  assert.equal(fs.existsSync(spy), false, 'core.fsmonitor must never execute during observation');
+  assert.equal(card.dirty.untracked, 1, 'repo config must not hide untracked files from the count');
+});
+
+test('replica identity is stable per checkout and new after a move', async () => {
+  const dir = await makeRepo('identity');
+  const first = await buildRepoCard(dir);
+  const second = await buildRepoCard(dir);
+  assert.equal(first.replica, second.replica);
+
+  const movedDir = path.join(tempRoot, 'identity-moved');
+  fs.renameSync(dir, movedDir);
+  const moved = await buildRepoCard(movedDir);
+  assert.notEqual(moved.replica, first.replica, 'a moved checkout is a new replica');
+  assert.equal(moved.repo.rootCommit, first.repo.rootCommit, 'same history keeps its identity anchor');
+});
+
+test('two worktrees of one repo are two replicas sharing one root commit', async () => {
+  const dir = await makeRepo('twin');
+  const worktreePath = path.join(tempRoot, 'twin-wt');
+  await run(dir, 'worktree', 'add', worktreePath, '-b', 'feature');
+
+  const main = await buildRepoCard(dir);
+  const linked = await buildRepoCard(worktreePath);
+  assert.equal(main.kind, 'primary');
+  assert.equal(linked.kind, 'linked-worktree');
+  assert.equal(linked.head.branch, 'feature');
+  assert.notEqual(main.replica, linked.replica);
+  assert.equal(main.repo.rootCommit, linked.repo.rootCommit);
+
+  const fromMain = await discoverWorktrees(dir);
+  const fromLinked = await discoverWorktrees(worktreePath);
+  const expected = [await fs.promises.realpath(dir), await fs.promises.realpath(worktreePath)].sort();
+  assert.deepEqual(fromMain.worktrees, expected);
+  assert.deepEqual(fromLinked.worktrees, expected);
+});
+
+test('the root commit is read from the replica cache, not re-walked per observation', async () => {
+  const dir = await makeRepo('anchored');
+  const first = await buildRepoCard(dir);
+  const sentinel = 'cafe'.repeat(10);
+  openLocalDb()
+    .prepare('UPDATE repo_replicas SET root_commit = ? WHERE replica_id = ?')
+    .run(sentinel, first.replica);
+
+  const second = await buildRepoCard(dir);
+  assert.equal(second.repo.rootCommit, sentinel);
+});
+
+test('a card is for the worktree root no matter which subdirectory was asked about', async () => {
+  const dir = await makeRepo('subdir');
+  write(dir, 'src/lib/deep.txt', 'x\n');
+  await run(dir, 'add', '.');
+  await run(dir, 'commit', '-m', 'deep');
+
+  const card = await buildRepoCard(path.join(dir, 'src/lib'));
+  assert.equal(card.path, await fs.promises.realpath(dir));
+});
+
+test('dirty counts are git status entries: renames once, directories once, dual-state files twice', async () => {
+  const dir = await makeRepo('dirty');
+  write(dir, 'tracked.txt', 'v1\n');
+  await run(dir, 'add', '.');
+  await run(dir, 'commit', '-m', 'base');
+
+  write(dir, 'staged.txt', 'staged\n');
+  await run(dir, 'add', 'staged.txt');
+  write(dir, 'tracked.txt', 'v2\n');
+  write(dir, 'loose-1.txt', 'x\n');
+  write(dir, 'loose-2.txt', 'y\n');
+
+  const card = await buildRepoCard(dir);
+  assert.deepEqual(card.dirty, { staged: 1, unstaged: 1, untracked: 2, conflicted: 0, submodulesChanged: 0 });
+
+  // An untracked directory of many files is one status entry, not a census.
+  write(dir, 'newdir/a.txt', 'a\n');
+  write(dir, 'newdir/b.txt', 'b\n');
+  const withDir = await buildRepoCard(dir);
+  assert.equal(withDir.dirty.untracked, 3);
+
+  // A file staged and then edited again counts on both sides.
+  write(dir, 'staged.txt', 'staged then edited\n');
+  const dual = await buildRepoCard(dir);
+  assert.equal(dual.dirty.staged, 1);
+  assert.equal(dual.dirty.unstaged, 2);
+
+  await run(dir, 'mv', 'README.md', 'RENAMED.md');
+  const renamed = await buildRepoCard(dir);
+  assert.equal(renamed.dirty.staged, 2);
+});
+
+test('a detached HEAD cards with the exact commit and no branch', async () => {
+  const dir = await makeRepo('detached');
+  await run(dir, 'checkout', '--detach');
+
+  const card = await buildRepoCard(dir);
+  assert.equal(card.head.branch, null);
+  assert.equal(card.head.detached, true);
+  assert.match(card.head.oid, /^[0-9a-f]{40}$/);
+});
+
+test('an unborn repo cards with null oid and null root commit', async () => {
+  const dir = await makeRepo('unborn', { commit: false });
+
+  const card = await buildRepoCard(dir);
+  assert.equal(card.head.branch, 'main');
+  assert.equal(card.head.oid, null);
+  assert.equal(card.repo.rootCommit, null);
+  assert.equal(card.dirty.untracked, 0);
+});
+
+test('ahead/behind report against the upstream after local and remote commits', async () => {
+  const origin = await makeRepo('ab-origin');
+  const dir = path.join(tempRoot, 'ab-clone');
+  await run(tempRoot, 'clone', origin, dir);
+
+  write(dir, 'local.txt', 'local\n');
+  await run(dir, 'add', '.');
+  await run(dir, 'commit', '-m', 'local work');
+
+  write(origin, 'remote.txt', 'remote\n');
+  await run(origin, 'add', '.');
+  await run(origin, 'commit', '-m', 'remote work');
+  await run(dir, 'fetch');
+
+  const card = await buildRepoCard(dir);
+  assert.equal(card.head.upstream, 'origin/main');
+  assert.equal(card.head.ahead, 1);
+  assert.equal(card.head.behind, 1);
+  assert.equal(card.repo.remote, null, 'a local-path clone has no transportable remote identity');
+});
+
+test('a conflicted merge cards as operation=merge with conflicted counts', async () => {
+  const dir = await makeRepo('merging');
+  write(dir, 'file.txt', 'base\n');
+  await run(dir, 'add', '.');
+  await run(dir, 'commit', '-m', 'base');
+  await run(dir, 'checkout', '-b', 'side');
+  write(dir, 'file.txt', 'side\n');
+  await run(dir, 'commit', '-am', 'side');
+  await run(dir, 'checkout', 'main');
+  write(dir, 'file.txt', 'main\n');
+  await run(dir, 'commit', '-am', 'main');
+  await assert.rejects(run(dir, 'merge', 'side'));
+
+  const card = await buildRepoCard(dir);
+  assert.equal(card.operation, 'merge');
+  assert.equal(card.dirty.conflicted, 1);
+});
+
+test('a conflicted cherry-pick cards as operation=cherry-pick', async () => {
+  const dir = await makeRepo('picking');
+  write(dir, 'file.txt', 'base\n');
+  await run(dir, 'add', '.');
+  await run(dir, 'commit', '-m', 'base');
+  await run(dir, 'checkout', '-b', 'side');
+  write(dir, 'file.txt', 'side\n');
+  await run(dir, 'commit', '-am', 'side');
+  await run(dir, 'checkout', 'main');
+  write(dir, 'file.txt', 'main\n');
+  await run(dir, 'commit', '-am', 'main');
+  await assert.rejects(run(dir, 'cherry-pick', 'side'));
+
+  const card = await buildRepoCard(dir);
+  assert.equal(card.operation, 'cherry-pick');
+});
+
+test('a submodule cards as kind=submodule when tracked explicitly, and stays out of parent discovery', async () => {
+  const inner = await makeRepo('sub-inner');
+  const outer = await makeRepo('sub-outer');
+  await run(outer, 'submodule', 'add', inner, 'vendored');
+  await run(outer, 'commit', '-m', 'add submodule');
+
+  const submoduleDir = path.join(outer, 'vendored');
+  const classified = await classifyDirectory(submoduleDir);
+  assert.equal(classified.kind, 'worktree');
+  assert.equal(classified.superproject, await fs.promises.realpath(outer));
+
+  const card = await buildRepoCard(submoduleDir);
+  assert.equal(card.kind, 'submodule');
+
+  const discovered = await discoverWorktrees(outer);
+  assert.deepEqual(discovered.worktrees, [await fs.promises.realpath(outer)]);
+});
+
+test('a folder of projects discovers its repos, skips the rest, ignores hidden entries', async () => {
+  const parent = path.join(tempRoot, 'projects');
+  fs.mkdirSync(parent, { recursive: true });
+  const repoA = await makeRepo('projects/alpha');
+  const repoB = await makeRepo('projects/beta');
+  fs.mkdirSync(path.join(parent, 'notes'));
+  fs.writeFileSync(path.join(parent, 'stray.txt'), 'not a folder\n');
+  await makeRepo('projects/.hidden-repo');
+  await run(parent, 'init', '--bare', 'archive.git');
+
+  const { worktrees, skipped } = await discoverWorktrees(parent);
+  assert.deepEqual(worktrees, [await fs.promises.realpath(repoA), await fs.promises.realpath(repoB)].sort());
+  assert.deepEqual(
+    skipped.map((entry) => [path.basename(entry.path), entry.reason]).sort((a, b) => a[0].localeCompare(b[0])),
+    [['archive.git', 'bare'], ['notes', 'not-a-repo']],
+  );
+});
+
+test('a deleted-but-registered worktree is skipped as prunable, not crashed on', async () => {
+  const dir = await makeRepo('stale');
+  const worktreePath = path.join(tempRoot, 'stale-wt');
+  await run(dir, 'worktree', 'add', worktreePath, '-b', 'stale-branch');
+  fs.rmSync(worktreePath, { recursive: true, force: true });
+
+  const { worktrees, skipped } = await discoverWorktrees(dir);
+  assert.deepEqual(worktrees, [await fs.promises.realpath(dir)]);
+  const recordedPath = path.join(await fs.promises.realpath(tempRoot), 'stale-wt');
+  assert.deepEqual(skipped, [{ path: recordedPath, reason: 'prunable' }]);
+});
+
+test('two doors into one repo expand it once — no duplicate cards or skips', async () => {
+  const parent = path.join(tempRoot, 'twin-doors');
+  fs.mkdirSync(parent, { recursive: true });
+  const repo = await makeRepo('twin-doors/repo');
+  const worktreePath = path.join(parent, 'repo-wt');
+  await run(repo, 'worktree', 'add', worktreePath, '-b', 'door-two');
+  const stalePath = path.join(parent, 'repo-stale');
+  await run(repo, 'worktree', 'add', stalePath, '-b', 'door-gone');
+  fs.rmSync(stalePath, { recursive: true, force: true });
+
+  const { worktrees, skipped } = await discoverWorktrees(parent);
+  assert.deepEqual(
+    worktrees,
+    [await fs.promises.realpath(repo), await fs.promises.realpath(worktreePath)].sort(),
+  );
+  assert.equal(skipped.filter((entry) => entry.reason === 'prunable').length, 1);
+});
+
+test('a worktree orphaned by a repo move is skipped as broken, not crashed on', async () => {
+  const dir = await makeRepo('mover');
+  const worktreePath = path.join(tempRoot, 'mover-wt');
+  await run(dir, 'worktree', 'add', worktreePath, '-b', 'orphan-branch');
+  const movedDir = path.join(tempRoot, 'mover-moved');
+  fs.renameSync(dir, movedDir);
+
+  const { worktrees, skipped } = await discoverWorktrees(movedDir);
+  assert.deepEqual(worktrees, [await fs.promises.realpath(movedDir)]);
+  assert.deepEqual(skipped, [{ path: await fs.promises.realpath(worktreePath), reason: 'broken-worktree' }]);
+});
+
+test('a symlinked project resolves to the real repo and dedupes', async () => {
+  const parent = path.join(tempRoot, 'linked-projects');
+  fs.mkdirSync(parent, { recursive: true });
+  const repo = await makeRepo('linked-projects/real');
+  fs.symlinkSync(repo, path.join(parent, 'alias'));
+
+  const { worktrees } = await discoverWorktrees(parent);
+  assert.deepEqual(worktrees, [await fs.promises.realpath(repo)]);
+});
+
+test('building a card never writes to the repo', async () => {
+  const dir = await makeRepo('untouched');
+  write(dir, 'work.txt', 'w\n');
+  const indexPath = path.join(dir, '.git', 'index');
+  const before = fs.statSync(indexPath).mtimeMs;
+
+  await buildRepoCard(dir);
+  assert.equal(fs.statSync(indexPath).mtimeMs, before);
+});
+
+test('the fingerprint holds across observations and moves on any real change', async () => {
+  const dir = await makeRepo('printed');
+
+  const first = await buildRepoCard(dir);
+  const second = await buildRepoCard(dir);
+  assert.equal(cardFingerprint(first), cardFingerprint(second));
+
+  write(dir, 'new.txt', 'n\n');
+  const third = await buildRepoCard(dir);
+  assert.notEqual(cardFingerprint(second), cardFingerprint(third));
+});

package/runtime/scripts/amalgm-mcp/tests/workspace-wall.test.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-wall-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_WORKSPACES_DIR = path.join(process.env.AMALGM_DIR, 'workspaces');
+process.env.AMALGM_COMPUTER_ID = 'machine-a';
+process.env.AMALGM_DEVICE_ID = 'device-machine-a';
+
+fs.mkdirSync(process.env.AMALGM_DIR, { recursive: true });
+fs.writeFileSync(
+  path.join(process.env.AMALGM_DIR, 'computer.json'),
+  JSON.stringify({ computer_id: 'machine-a', user_id: '11111111-1111-4111-8111-111111111111' }),
+);
+
+const { closeLocalDb } = require('../state/db');
+const { registerReplica } = require('../state/replicas');
+const { openDoc, getDocText, writeDocText } = require('../state/docs');
+const { upsertWorkspace } = require('../workspace/store');
+const { refreshRepoCards } = require('../workspace/cards');
+const { publishWall, readWall, wallResourceId, wallStats } = require('../workspace/wall');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+async function run(cwd, ...args) {
+  await execFileAsync(
+    'git',
+    ['-c', 'user.email=test@amalgm.test', '-c', 'user.name=Amalgm Test', '-c', 'commit.gpgsign=false', ...args],
+    { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', LC_ALL: 'C' } },
+  );
+}
+
+const wallFile = path.join(process.env.AMALGM_DIR, 'state', 'machine-cards.jsonl');
+
+test('the wall resource id is derived from the account: stable per user, distinct across users, valid on the rail', () => {
+  const userA = '11111111-1111-4111-8111-111111111111';
+  const userB = '22222222-2222-4222-8222-222222222222';
+  assert.equal(wallResourceId(userA), wallResourceId(userA));
+  assert.notEqual(wallResourceId(userA), wallResourceId(userB));
+  assert.match(wallResourceId(userA), /^shr_[A-Za-z0-9_-]{16,128}$/);
+  assert.equal(wallResourceId(null), null);
+});
+
+test('publishing without a bound wall is a visible skip, never a write', () => {
+  const result = publishWall();
+  assert.equal(result.published, false);
+  assert.equal(result.reason, 'wall-not-bound');
+  assert.equal(fs.existsSync(wallFile), false);
+});
+
+test('a bound wall carries exactly one line per machine, replaced in place', async () => {
+  const repo = path.join(tempRoot, 'projects/app');
+  fs.mkdirSync(repo, { recursive: true });
+  await run(repo, 'init', '-b', 'main');
+  fs.writeFileSync(path.join(repo, 'README.md'), '# app\n');
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'initial');
+  upsertWorkspace({ path: path.join(tempRoot, 'projects'), name: 'Projects', source: 'computer' });
+  await refreshRepoCards();
+
+  // Bind the wall the way a completed attachment would: an empty file with
+  // a registered replica for the account's derived resource id.
+  fs.mkdirSync(path.dirname(wallFile), { recursive: true });
+  fs.writeFileSync(wallFile, '');
+  const opened = openDoc(wallFile);
+  registerReplica({
+    resourceId: wallResourceId(),
+    localResource: opened.resource,
+    localPath: wallFile,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+    authorityEpoch: 1,
+  });
+
+  const first = publishWall();
+  assert.equal(first.published, true);
+  const entries = readWall();
+  assert.equal(entries.length, 1);
+  assert.equal(entries[0].machine, 'machine-a');
+  assert.equal(entries[0].cards.length, 1);
+  assert.equal(entries[0].cards[0].head.branch, 'main');
+
+  // Same cards again: no new version, no doc write.
+  const again = publishWall();
+  assert.equal(again.published, false);
+  assert.equal(again.reason, 'unchanged');
+
+  // A real change replaces the line — never appends a second one.
+  fs.writeFileSync(path.join(repo, 'new.txt'), 'x\n');
+  await refreshRepoCards();
+  const republished = publishWall();
+  assert.equal(republished.published, true);
+  const after = readWall();
+  assert.equal(after.length, 1);
+  assert.equal(after[0].cards[0].dirty.untracked, 1);
+  assert.equal(getDocText(wallFile).trim().split('\n').length, 1);
+});
+
+test('a peer machine\'s line is preserved byte-for-byte through this machine\'s publishes', async () => {
+  const peerLine = JSON.stringify({
+    wall: 'machine-cards@1',
+    machine: 'machine-b',
+    publishedAt: '2026-07-19T00:00:00.000Z',
+    cards: [{ card: 'repo-card@2', machine: 'machine-b', replica: 'rpl_peer', path: '/work/app', head: { branch: 'preview' } }],
+  });
+  // Land the peer's line the way fanout would: a doc edit from elsewhere.
+  writeDocText(wallFile, `${getDocText(wallFile)}${peerLine}\n`);
+
+  const repo = path.join(tempRoot, 'projects/app');
+  fs.writeFileSync(path.join(repo, 'another.txt'), 'y\n');
+  await refreshRepoCards();
+  const result = publishWall();
+  assert.equal(result.published, true);
+
+  const lines = getDocText(wallFile).trim().split('\n');
+  assert.equal(lines.length, 2);
+  assert.ok(lines.includes(peerLine), 'the peer line must survive untouched');
+  const entries = readWall();
+  assert.deepEqual(entries.map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
+});
+
+test('a torn line is ignored by readers and healed by its owner, never fatal', () => {
+  writeDocText(wallFile, `${getDocText(wallFile)}{"wall":"machine-cards@1","machine":"machine-c","car\n`);
+  const entries = readWall();
+  assert.deepEqual(entries.map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
+});
+
+test('wall stats name the resource, the binding, and the publish counters', () => {
+  const stats = wallStats();
+  assert.equal(stats.resourceId, wallResourceId());
+  assert.equal(stats.contract, 'machine-cards@1');
+  assert.equal(stats.replica.appliedVersion >= 0, true);
+  assert.equal(stats.machines, 2);
+  assert.ok(stats.publishes >= 3);
+  assert.ok(stats.publishSkips >= 1);
+});