Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
Test label repairs over derived stamps on PGLite and Postgres (GST-2603)
garrytanbe9790b583ba
diff --git a/test/label-repair-derived-stamps-gst2603.test.ts b/test/label-repair-derived-stamps-gst2603.test.tsnew file mode 100644index 0000000000..aae32e4ea5--- /dev/null+++ b/test/label-repair-derived-stamps-gst2603.test.ts@@ -0,0 +1,324 @@+/**+ * GST-2603: a label repair refused pages whose file differs from the database row only in frontmatter gbrain derived itself.+ *+ * 1. Protects: gbrain repair visibility --slug (and repair private-labels, through the same label-only write) labels a page+ * whose stored row carries a stamp its file never had: a schema-pack retype (type plus its legacy_type record, the file+ * still naming the old type), the pre-#6454 stored type copy of a renamed gbrain-base type, the grandfather validate:false+ * stamp, or a legacy_type record whose file already names the page's type. The file changes only on its label line. A page+ * whose file differs in a real key (a date, the tags) is held in the preview with that key named, never a stamp, and stays+ * out of the preview hash and the approved set; at apply a page whose file changed since the preview declines alone+ * (source_changed, or label_edit_refused when its label line can no longer be edited as a line), counts in declined,+ * never trips item_failures_systemic, and the run exits 0. A repo-less brain and an unmanaged checkout label the same way.+ * An exact-page access rule (gbrain access rule add --slug) is a readers list, not the private label: a named reader reads+ * it, while the label repair's private page stays hidden from that reader.+ * 2. Fails when: a stamp-only page refuses or trips the breaker, a held page is listed, approved, hashed or names a stamp, a+ * declined page stops the run or exits 1, or a page rule is offered as the same label class.+ * 3. Real seams: the managed-brain harness (claimed Git worktree, managed sync, the maintenance door, the Git effect),+ * remote:false, the gbrain repair and gbrain access rule command entries, MCP dispatch with minted tokens; a repo-less brain+ * and a brain without managed persistence whose source has a checkout. PGLite, and Postgres with DATABASE_URL.+ */+import { describe, expect, spyOn, test } from 'bun:test';+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';+import { tmpdir } from 'node:os';+import { join } from 'node:path';+import type { BrainEngine } from '../src/core/engine.ts';+import type { AuthInfo } from '../src/core/ops/contract.ts';+import { importFromContent } from '../src/core/import-file.ts';+import { parseMarkdown } from '../src/core/markdown.ts';+import { withCoordinatedWrite, withTrustBackfill } from '../src/core/persistence/context.ts';+import { performManagedSync } from '../src/core/persistence/sync-run.ts';+import { disposePersistenceConsumer } from '../src/core/persistence/service.ts';+import { _resetWriteThroughCacheForTest } from '../src/core/write-through.ts';+import { runRepairCommand } from '../src/commands/repair.ts';+import { runAccessRules } from '../src/commands/access-rules.ts';+import { _resetCliExitVerdictForTests, currentExitCode } from '../src/core/cli-force-exit.ts';+import { GBrainOAuthProvider } from '../src/core/oauth-provider.ts';+import { sqlQueryForEngine } from '../src/core/sql-query.ts';+import { mintLegacyToken } from '../src/core/token-mint.ts';+import { dispatchToolCall } from '../src/mcp/dispatch.ts';+import { __resetPrivateVisibilityCacheForTests } from '../src/core/search/private-visibility.ts';+import { durableGitRepo, git } from './helpers/git-publication.ts';+import { managedBrain, settleManagedGitEffects } from './helpers/managed-brain.ts';+import { isolatedSharedSkillsEngine } from './helpers/shared-skills-engine.ts';+import { requirePostgresTestDatabase, testBackends } from './helpers/test-backends.ts';+import { withEnv } from './helpers/with-env.ts';+import { TEST_WRITE_ATTRIBUTION } from './helpers/write-attribution.ts';++const NL = String.fromCharCode(10);+const OPTS = { sourceId: 'default', noPull: true, noEmbed: true, noExtract: true };+const note = (title: string, lines: string[], body: string) => ['---', 'title: ' + title, ...lines, '---', '', body, ''].join(NL);+/** The file a label repair publishes: the same bytes with \`visibility: private\` as the frontmatter's last line. */+const withVisibility = (text: string) => text.replace(NL + '---' + NL + NL, NL + 'visibility: private' + NL + '---' + NL + NL);++/** Each page's file and the database-only edit an older gbrain made to its row. */+const PAGES: Record<string, { file: string; stamp: string }> = {+ // A schema-pack retype: the column took the new type and legacy_type records the old one; the file still names the old type.+ 'notes/retyped-example': { file: note('Retyped', ['type: note'], 'Retyped body.'), stamp: "type='media', frontmatter=frontmatter || '{\"legacy_type\":\"note\"}'::jsonb" },+ // Pre-#6454: the stored frontmatter kept a type copy, the gbrain-base 1.0.0 name for the path; a later pack retyped the column.+ 'writing/essay-example': { file: ['---', 'type: writing', 'title: Essay', '---', '', 'An essay body.', ''].join(NL), stamp: "type='media', frontmatter=frontmatter || '{\"type\":\"writing\"}'::jsonb" },+ // The v0.13.1 grandfather stamped validate:false into the database only.+ 'notes/grand-example': { file: note('Grand', [], 'Grand body.'), stamp: "frontmatter=frontmatter || '{\"validate\":false}'::jsonb" },+ // A retype record whose file already names the page's type.+ 'notes/legacy-example': { file: note('Legacy', ['type: media'], 'Legacy body.'), stamp: "frontmatter=frontmatter || '{\"legacy_type\":\"note\"}'::jsonb" },+ // Real differences: a date and a tag the file does not hold.+ 'notes/dated-example': { file: note('Dated', ['date: 2024-01-02'], 'Dated body.'), stamp: "frontmatter=frontmatter || '{\"date\":\"2023-05-06\",\"validate\":false}'::jsonb" },+ 'notes/tagged-example': { file: note('Tagged', ['tags:', ' - alpha'], 'Tagged body.'), stamp: '' },+ // Stamps and a real key at once.+ 'notes/mixed-example': { file: note('Mixed', ['type: note', 'date: 2024-01-02'], 'Mixed body.'), stamp: "type='media', frontmatter=frontmatter || '{\"legacy_type\":\"note\",\"validate\":false,\"date\":\"2023-05-06\"}'::jsonb" },+};+/** A page whose frontmatter holds only what a file with no frontmatter imports as (its title from the slug), stamped validate:false. */+const bare = (slug: string) => 'Body of ' + slug.split('/').pop() + '.' + NL;+const framed = (slug: string) => note(parseMarkdown(bare(slug), slug).title, [], bare(slug).trimEnd());++async function capture(fn: () => Promise<void>): Promise<string> {+ let printed = '';+ const original = console.log;+ console.log = (...parts: unknown[]) => { printed += parts.map(String).join(' ') + NL; };+ try { await fn(); } finally { console.log = original; }+ return printed;+}+/** One repair run through the command entry: its first result and the CLI exit verdict. */+const run = async (engine: BrainEngine, argv: string[]) => {+ _resetCliExitVerdictForTests();+ const out = await withEnv({ GBRAIN_INTERACTIVE: '0', CI: '1' }, () => capture(() => runRepairCommand(engine, [...argv, '--json'])));+ const exit = currentExitCode();+ _resetCliExitVerdictForTests();+ return { result: JSON.parse(out).results[0], exit };+};+const repair = async (engine: BrainEngine, argv: string[]) => (await run(engine, argv)).result;+const previewApply = async (engine: BrainEngine, argv: string[]) => {+ const preview = await repair(engine, argv);+ expect(preview.preview_hash).toBeString();+ const applied = await run(engine, [...argv, '--apply', '--expect', preview.preview_hash]);+ return { preview, applied: applied.result, exit: applied.exit };+};+const slugArgs = (slugs: string[]) => ['visibility', ...slugs.flatMap(slug => ['--slug', slug])];+const row = async (engine: BrainEngine, slug: string, sourceId = 'default') => (await engine.executeRaw<{ type: string; frontmatter: Record<string, unknown> }>(+ 'SELECT type, frontmatter FROM pages WHERE source_id=$1 AND slug=$2 AND deleted_at IS NULL', [sourceId, slug]))[0]!;+const stampRow = (engine: BrainEngine, sourceId: string, slug: string, set: string) => engine.transaction(tx => withCoordinatedWrite(tx, [sourceId], () => withTrustBackfill(tx, () =>+ tx.executeRaw('UPDATE pages SET ' + set + ', knowledge_revision=gen_random_uuid() WHERE source_id=$1 AND slug=$2', [sourceId, slug])), TEST_WRITE_ATTRIBUTION));++for (const backend of testBackends()) describe('[' + backend + '] label repairs over gbrain\'s own derived stamps on a managed git source', () => {+ const databaseUrl = backend === 'postgres' ? requirePostgresTestDatabase() : undefined;+ const setup = ({ root }: { root: string }) => { writeFileSync(join(root, '.gitignore'), 'archive/' + NL); durableGitRepo(root, ['.gitignore']); };+ const onDisk = (root: string, slug: string) => readFileSync(join(root, slug + '.md'), 'utf8');+ /** Commits the pages' files, syncs them, then makes each stored row's database-only edit as an older gbrain did. */+ async function seed(engine: BrainEngine, root: string, files: Record<string, string>, stamps: Record<string, string> = {}) {+ for (const [slug, text] of Object.entries(files)) { mkdirSync(join(root, slug, '..'), { recursive: true }); writeFileSync(join(root, slug + '.md'), text); }+ git(root, 'add', '-A');+ git(root, '-c', 'user.name=Example', '-c', '[email protected]', 'commit', '-qm', 'notes');+ await performManagedSync(engine, OPTS);+ await settleManagedGitEffects(engine);+ for (const [slug, set] of Object.entries(stamps)) {+ if (slug === 'notes/tagged-example') await engine.transaction(tx => withCoordinatedWrite(tx, ['default'], () => tx.executeRaw(+ "INSERT INTO tags (page_id, tag) SELECT id, 'beta' FROM pages WHERE source_id='default' AND slug=$1", [slug]), TEST_WRITE_ATTRIBUTION));+ else if (set) await stampRow(engine, 'default', slug, set);+ }+ }+ const seedPages = (engine: BrainEngine, root: string, slugs: string[]) => seed(engine, root, Object.fromEntries(slugs.map(slug => [slug, PAGES[slug]!.file])),+ Object.fromEntries(slugs.map(slug => [slug, slug === 'notes/tagged-example' ? 'tag' : PAGES[slug]!.stamp])));+ const listedItems = (preview: { listing?: Array<{ item: string }> }) => (preview.listing ?? []).map(entry => entry.item).sort();++ test('only the type stamp differs (a schema-pack retype, a renamed gbrain-base type): the pages are labelled and their files gain only the visibility line', () => managedBrain(async ({ engine, root }) => {+ const slugs = ['notes/retyped-example', 'writing/essay-example'];+ await seedPages(engine, root, slugs);+ const before = Object.fromEntries(slugs.map(slug => [slug, onDisk(root, slug)]));+ const { preview, applied, exit } = await previewApply(engine, slugArgs(slugs));+ expect(listedItems(preview)).toEqual(slugs.map(slug => 'default:' + slug).sort());+ expect(preview.details?.held).toBeUndefined();+ expect({ applied: applied.applied, failed: applied.failed, stopped: applied.stopped, exit }).toEqual({ applied: 2, failed: [], stopped: undefined, exit: 0 });+ await settleManagedGitEffects(engine);+ for (const slug of slugs) {+ expect(onDisk(root, slug)).toBe(withVisibility(before[slug]!));+ expect(await row(engine, slug)).toMatchObject({ type: 'media', frontmatter: expect.objectContaining({ visibility: 'private' }) });+ }+ expect((await row(engine, 'notes/retyped-example')).frontmatter.legacy_type).toBe('note');+ }, { databaseUrl, setup }), 240_000);++ test('only the grandfather stamp differs: the page is labelled, keeps the stamp, and its file gains only the visibility line', () => managedBrain(async ({ engine, root }) => {+ const slug = 'notes/grand-example';+ await seedPages(engine, root, [slug]);+ const before = onDisk(root, slug);+ const { applied, exit } = await previewApply(engine, slugArgs([slug]));+ expect({ applied: applied.applied, failed: applied.failed, exit }).toEqual({ applied: 1, failed: [], exit: 0 });+ await settleManagedGitEffects(engine);+ expect(onDisk(root, slug)).toBe(withVisibility(before));+ expect((await row(engine, slug)).frontmatter).toMatchObject({ visibility: 'private', validate: false });+ }, { databaseUrl, setup }), 240_000);++ test('only legacy_type differs (the file already names the page\'s type): the page is labelled and keeps its retype record', () => managedBrain(async ({ engine, root }) => {+ const slug = 'notes/legacy-example';+ await seedPages(engine, root, [slug]);+ const before = onDisk(root, slug);+ const { applied, exit } = await previewApply(engine, slugArgs([slug]));+ expect({ applied: applied.applied, failed: applied.failed, exit }).toEqual({ applied: 1, failed: [], exit: 0 });+ await settleManagedGitEffects(engine);+ expect(onDisk(root, slug)).toBe(withVisibility(before));+ expect((await row(engine, slug)).frontmatter).toMatchObject({ visibility: 'private', legacy_type: 'note' });+ }, { databaseUrl, setup }), 240_000);++ test('a real key differs (a date, the tags): held in the preview with the key named, outside the approved set; the other pages apply, and a page edited since the preview declines alone with exit 0', () => managedBrain(async ({ engine, root }) => {+ const slugs = ['notes/grand-example', 'notes/retyped-example', 'notes/dated-example', 'notes/tagged-example'];+ await seedPages(engine, root, slugs);+ const preview = await repair(engine, slugArgs(slugs));+ expect(listedItems(preview)).toEqual(['default:notes/grand-example', 'default:notes/retyped-example']);+ expect(preview.details.held).toEqual([+ { item: 'default:notes/dated-example', reason: 'file_database_drift', keys: ['date'], next: 'gbrain sources reconcile default notes/dated-example --preview' },+ { item: 'default:notes/tagged-example', reason: 'file_database_drift', keys: ['tags'], next: 'gbrain sources reconcile default notes/tagged-example --preview' },+ ]);+ expect(preview.residuals).toMatchObject({ held_file_drift: 2 });+ const held = { dated: onDisk(root, 'notes/dated-example'), tagged: onDisk(root, 'notes/tagged-example') };+ // An approved page whose file takes a hand edit after the preview declines at apply.+ writeFileSync(join(root, 'notes/retyped-example.md'), PAGES['notes/retyped-example']!.file.replace('Retyped body.', 'Retyped body, edited by hand.'));+ const applied = await run(engine, [...slugArgs(slugs), '--apply', '--expect', preview.preview_hash]);+ expect({ applied: applied.result.applied, declined: applied.result.declined, stopped: applied.result.stopped, complete: applied.result.complete, exit: applied.exit })+ .toEqual({ applied: 1, declined: { source_changed: 1 }, stopped: undefined, complete: true, exit: 0 });+ expect(applied.result.failed.map((failed: { item: string; reason: string }) => [failed.item, failed.reason])).toEqual([['default:notes/retyped-example', 'source_changed']]);+ expect(applied.result.failed[0].message).toContain('uncoordinated local edit');+ await settleManagedGitEffects(engine);+ expect((await row(engine, 'notes/grand-example')).frontmatter.visibility).toBe('private');+ for (const slug of ['notes/retyped-example', 'notes/dated-example', 'notes/tagged-example']) expect((await row(engine, slug)).frontmatter.visibility).toBeUndefined();+ expect({ dated: onDisk(root, 'notes/dated-example'), tagged: onDisk(root, 'notes/tagged-example') }).toEqual(held);+ }, { databaseUrl, setup }), 240_000);++ test('a page that differs by stamps and by a real key is held, naming the real key and never a stamp', () => managedBrain(async ({ engine, root }) => {+ const slugs = ['notes/mixed-example', 'notes/grand-example'];+ await seedPages(engine, root, slugs);+ const preview = await repair(engine, slugArgs(slugs));+ expect(listedItems(preview)).toEqual(['default:notes/grand-example']);+ expect(preview.details.held).toEqual([{ item: 'default:notes/mixed-example', reason: 'file_database_drift', keys: ['date'], next: 'gbrain sources reconcile default notes/mixed-example --preview' }]);+ expect(preview.warnings.join(' ')).toContain('1 page(s) are held');+ expect(JSON.stringify(preview.details.held)).not.toMatch(/validate|legacy_type|"type"/);+ }, { databaseUrl, setup }), 240_000);++ test('the preview hash does not change when a held page\'s file changes, and the approved set still applies', () => managedBrain(async ({ engine, root }) => {+ const slugs = ['notes/grand-example', 'notes/dated-example'];+ await seedPages(engine, root, slugs);+ const first = await repair(engine, slugArgs(slugs));+ expect(first.details.held.map((hold: { item: string }) => hold.item)).toEqual(['default:notes/dated-example']);+ writeFileSync(join(root, 'notes/dated-example.md'), PAGES['notes/dated-example']!.file.replace('Dated body.', 'Dated body, edited again.'));+ const second = await repair(engine, slugArgs(slugs));+ expect(second.preview_hash).toBe(first.preview_hash);+ expect(second.details.held).toEqual([{ item: 'default:notes/dated-example', reason: 'file_database_drift', keys: ['date', 'body'], next: 'gbrain sources reconcile default notes/dated-example --preview' }]);+ const applied = await run(engine, [...slugArgs(slugs), '--apply', '--expect', first.preview_hash]);+ expect({ applied: applied.result.applied, failed: applied.result.failed, exit: applied.exit }).toEqual({ applied: 1, failed: [], exit: 0 });+ expect((await row(engine, 'notes/dated-example')).frontmatter.visibility).toBeUndefined();+ }, { databaseUrl, setup }), 240_000);++ test('a refusal mid-batch does not stop the other pages: stamped pages apply around a page edited since the preview and one whose label line can no longer be edited', () => managedBrain(async ({ engine, root }) => {+ const slugs = [1, 2, 3, 4, 5, 6].map(n => 'notes/batch-' + n);+ await seed(engine, root, Object.fromEntries(slugs.map(slug => [slug, framed(slug)])), Object.fromEntries(slugs.map(slug => [slug, PAGES['notes/grand-example']!.stamp])));+ const preview = await repair(engine, slugArgs(slugs));+ expect(listedItems(preview)).toEqual(slugs.map(slug => 'default:' + slug).sort());+ // batch-3: the same page without a frontmatter block (no label line to edit); batch-5: a hand edit.+ writeFileSync(join(root, 'notes/batch-3.md'), bare('notes/batch-3'));+ writeFileSync(join(root, 'notes/batch-5.md'), framed('notes/batch-5').replace('Body of', 'Edited body of'));+ const applied = await run(engine, [...slugArgs(slugs), '--apply', '--expect', preview.preview_hash]);+ expect({ applied: applied.result.applied, declined: applied.result.declined, stopped: applied.result.stopped, complete: applied.result.complete, exit: applied.exit })+ .toEqual({ applied: 4, declined: { label_edit_refused: 1, source_changed: 1 }, stopped: undefined, complete: true, exit: 0 });+ expect(applied.result.failed.map((failed: { item: string; reason: string }) => [failed.item, failed.reason]).sort())+ .toEqual([['default:notes/batch-3', 'label_edit_refused'], ['default:notes/batch-5', 'source_changed']]);+ expect(applied.result.failed.find((failed: { item: string }) => failed.item === 'default:notes/batch-3').message).toContain('visibility line cannot be edited as one line');+ await settleManagedGitEffects(engine);+ for (const slug of ['notes/batch-1', 'notes/batch-2', 'notes/batch-4', 'notes/batch-6']) {+ expect(onDisk(root, slug)).toBe(withVisibility(framed(slug)));+ expect((await row(engine, slug)).frontmatter).toMatchObject({ visibility: 'private', validate: false });+ }+ expect(onDisk(root, 'notes/batch-3')).toBe(bare('notes/batch-3'));+ }, { databaseUrl, setup }), 240_000);++ test('label-edit refusals never count toward item_failures_systemic: five pages whose label line cannot be edited decline, the sixth applies, and the next preview holds them', () => managedBrain(async ({ engine, root }) => {+ const slugs = [1, 2, 3, 4, 5, 6].map(n => 'notes/line-' + n);+ await seed(engine, root, Object.fromEntries(slugs.map(slug => [slug, framed(slug)])));+ const preview = await repair(engine, slugArgs(slugs));+ for (const slug of slugs.slice(0, 5)) writeFileSync(join(root, slug + '.md'), bare(slug));+ const applied = await run(engine, [...slugArgs(slugs), '--apply', '--expect', preview.preview_hash]);+ expect({ applied: applied.result.applied, declined: applied.result.declined, stopped: applied.result.stopped, complete: applied.result.complete, exit: applied.exit })+ .toEqual({ applied: 1, declined: { label_edit_refused: 5 }, stopped: undefined, complete: true, exit: 0 });+ const next = await repair(engine, slugArgs(slugs));+ expect(listedItems(next)).toEqual([]);+ expect(next.details.held.map((hold: { item: string; reason: string; keys: string[] }) => [hold.item, hold.reason, hold.keys])).toEqual(slugs.slice(0, 5).map(slug => ['default:' + slug, 'label_edit_refused', []]));+ expect(next.details.held[0].next).toContain('write visibility as one plain line');+ }, { databaseUrl, setup }), 240_000);++ test('repair private-labels clears a label on a page with gbrain\'s stamps, changing only the label line', () => managedBrain(async ({ engine, root }) => {+ const slug = 'notes/labelled-example';+ await seed(engine, root, { [slug]: note('Labelled', ['type: note', 'access: private'], 'Labelled body.') },+ { [slug]: "type='media', frontmatter=frontmatter || '{\"legacy_type\":\"note\",\"validate\":false}'::jsonb" });+ const before = onDisk(root, slug);+ const { applied, exit } = await previewApply(engine, ['private-labels']);+ expect({ applied: applied.applied, failed: applied.failed, exit }).toEqual({ applied: 1, failed: [], exit: 0 });+ await settleManagedGitEffects(engine);+ expect(onDisk(root, slug)).toBe(before.replace('access: private' + NL, ''));+ expect((await row(engine, slug)).frontmatter).toMatchObject({ legacy_type: 'note', validate: false });+ }, { databaseUrl, setup }), 240_000);+});++/** A brain with no managed persistence (the default keyless install) whose pages carry gbrain's stamps. */+for (const backend of testBackends()) describe('[' + backend + '] label repairs over derived stamps without managed persistence', () => {+ const databaseUrl = backend === 'postgres' ? requirePostgresTestDatabase() : undefined;+ async function brain(fn: (engine: BrainEngine, home: string) => Promise<void>) {+ const home = mkdtempSync(join(tmpdir(), 'gbrain-gst2603-'));+ try {+ await withEnv({ GBRAIN_HOME: home, DATABASE_URL: undefined, GBRAIN_DATABASE_URL: undefined }, async () => {+ const { engine, close } = await isolatedSharedSkillsEngine(databaseUrl);+ try { await fn(engine, home); } finally { _resetWriteThroughCacheForTest(); await disposePersistenceConsumer(engine); await close(); }+ });+ } finally { rmSync(home, { recursive: true, force: true }); }+ }++ test('a repo-less brain labels a stamped page in the database only', () => brain(async engine => {+ const slug = 'notes/retyped-example';+ expect((await importFromContent(engine, slug, PAGES[slug]!.file, { noEmbed: true, sourceId: 'default' })).status).toBe('imported');+ await stampRow(engine, 'default', slug, "type='media', frontmatter=frontmatter || '{\"legacy_type\":\"note\",\"validate\":false}'::jsonb");+ const { preview, applied, exit } = await previewApply(engine, ['visibility', '--source', 'default', '--slug', slug]);+ expect(preview.details?.held).toBeUndefined();+ expect({ applied: applied.applied, failed: applied.failed, exit }).toEqual({ applied: 1, failed: [], exit: 0 });+ expect(await row(engine, slug)).toMatchObject({ type: 'media', frontmatter: expect.objectContaining({ visibility: 'private', legacy_type: 'note', validate: false }) });+ }), 180_000);++ test('a page whose file is in its source\'s checkout gets only the visibility line in that file', () => brain(async (engine, home) => {+ const slug = 'notes/grand-example', checkout = join(home, 'checkout'), path = join(checkout, slug + '.md');+ mkdirSync(join(checkout, 'notes'), { recursive: true });+ const before = PAGES[slug]!.file;+ writeFileSync(path, before);+ await engine.executeRaw("INSERT INTO sources (id, name, local_path) VALUES ('source-b', 'source-b', $1) ON CONFLICT (id) DO NOTHING", [checkout]);+ expect((await importFromContent(engine, slug, before, { noEmbed: true, sourceId: 'source-b' })).status).toBe('imported');+ await stampRow(engine, 'source-b', slug, "source_path='" + slug + ".md', frontmatter=frontmatter || '{\"validate\":false}'::jsonb");+ const { applied, exit } = await previewApply(engine, ['visibility', '--source', 'source-b', '--slug', slug]);+ expect({ applied: applied.applied, failed: applied.failed, exit }).toEqual({ applied: 1, failed: [], exit: 0 });+ expect(readFileSync(path, 'utf8')).toBe(withVisibility(before));+ expect((await row(engine, slug, 'source-b')).frontmatter).toMatchObject({ visibility: 'private', validate: false });+ }), 180_000);++ test('an exact-page access rule is a readers list, not the private label: its named reader reads the page, which the label repair\'s private page hides from that reader', () => brain(async engine => {+ for (const slug of ['notes/labelled-example', 'notes/ruled-example']) {+ expect((await importFromContent(engine, slug, note('Page', [], 'Body canary-' + slug.replace(/\//g, '-') + '.'), { noEmbed: true, sourceId: 'default' })).status).toBe('imported');+ }+ await engine.executeRaw("INSERT INTO access_members (id) VALUES ('owner-example'), ('alice-example') ON CONFLICT DO NOTHING");+ await engine.setConfig('access.owner_member', 'owner-example');+ const { applied } = await previewApply(engine, ['visibility', '--source', 'default', '--slug', 'notes/labelled-example']);+ expect(applied.applied).toBe(1);+ const lines: string[] = [];+ const spy = spyOn(console, 'log').mockImplementation((...parts: unknown[]) => { lines.push(parts.map(String).join(' ')); });+ try { await runAccessRules(engine, 'rule', ['add', '--slug', 'notes/ruled-example', '--readers', 'alice-example', '--source', 'default', '--yes', '--json'], true); } finally { spy.mockRestore(); }+ expect(JSON.parse(lines.join(NL)).state).toBe('applied');+ expect((await row(engine, 'notes/labelled-example')).frontmatter.visibility).toBe('private');+ expect((await row(engine, 'notes/ruled-example')).frontmatter.visibility).toBeUndefined();+ const tokens: Record<string, string> = {};+ for (const who of ['alice', 'unbound'] as const) {+ const minted = await mintLegacyToken(engine, { name: 'gst2603-' + who, scopes: ['read'], takesHolders: ['world'], sourceGrant: ['default'] });+ tokens[who] = minted.token;+ if (who === 'alice') await engine.executeRaw("UPDATE access_tokens SET member_id = 'alice-example' WHERE id = $1::uuid", [minted.id]);+ }+ const provider = new GBrainOAuthProvider({ sql: sqlQueryForEngine(engine), transaction: fn => engine.transaction(tx => fn(sqlQueryForEngine(tx))) });+ __resetPrivateVisibilityCacheForTests();+ const reads = async (who: 'alice' | 'unbound', slug: string) => {+ const auth = await provider.verifyAccessToken(tokens[who]!) as unknown as AuthInfo;+ const out = await dispatchToolCall(engine, 'get_page', { slug }, { remote: true, transport: 'http', auth, sourceId: 'default', takesHoldersAllowList: ['world'] });+ return out.isError !== true && out.content.map(c => c.text).join(NL).includes('canary-' + slug.replace(/\//g, '-'));+ };+ expect({ labelled: await reads('alice', 'notes/labelled-example'), ruled: await reads('alice', 'notes/ruled-example') }).toEqual({ labelled: false, ruled: true });+ expect({ labelled: await reads('unbound', 'notes/labelled-example'), ruled: await reads('unbound', 'notes/ruled-example') }).toEqual({ labelled: false, ruled: false });+ }), 180_000);+});diff --git a/test/postgres-unit-arms.txt b/test/postgres-unit-arms.txtindex c9fee257e9..1f0983acbc 100644--- a/test/postgres-unit-arms.txt+++ b/test/postgres-unit-arms.txt@@ -187,6 +187,7 @@ test/init-cold-home-embedding.test.tstest/keyword-statement-timeout-knob-6495.test.tstest/keyword-timeout-negative-cache-6495.test.tstest/label-only-repairs.test.ts+test/label-repair-derived-stamps-gst2603.test.tstest/lane-apply-pipelining.test.tstest/large-pages/append-concurrency.test.tstest/large-pages/append-cost.test.ts