Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript

fix(facts): list a page write the job's own check skips for re-extraction; freeze the stored moved-entity texts (#7602 review)

garrytand571f0b72c04
diff --git a/docs/architecture/key-files/core-utilities-2.md b/docs/architecture/key-files/core-utilities-2.md
index 5c4a6e49af..d0fb587d49 100644
--- a/docs/architecture/key-files/core-utilities-2.md
+++ b/docs/architecture/key-files/core-utilities-2.md
@@ -13,7 +13,7 @@ Current behavior and load-bearing invariants; history belongs in Git and CHANGEL
- `src/core/repair/captured-facts.ts` — `gbrain repair captured-facts`, explicit-only and preview-bound. `classifyCapturedFacts` (read-only; also the `captured_facts_active` count) takes active capture-lane facts and classes each by its session (`captureSessionId`: `sweep:corpus:<file>` resolves through `corpusFileSessionId`): `evidenced` when a gbrain claude-cli scratch project holds the session's harness transcript or its corpus file sits in `<corpus>.quarantine/`; `ambiguous` (paste candidate) when a retained corpus file of the session holds a paste block and at least 60% of the claim's content words occur there only inside paste blocks; `excluded:legitimate_duplicate` when the claim and entity also have an active row that is not proven suspect. Sessions with no transcript and no corpus file are counted `unclassifiable`. The preview hashes every candidate with the selection (`--include-ambiguous`) and saves one approved item per page through `preview-approval.ts`; the apply reclassifies each fact, expires database-only rows through one database-only `managed_maintenance_expire_captured_facts` request per page on a managed brain (owner-checked by `maintenancePreflight`; `prepareCapturedFactsExpiry`, dispatched from `prepareMaintenanceMutation`) or one transaction on an unmanaged brain, and strikes fenced rows in the page's `## Facts` fence through one revision-bound `put_page`, so the canonical projection expires them and a later page write cannot reactivate them. No withdrawal is recorded, so `remember` can save the same claim again. Pinned by `test/repair-captured-facts.test.ts` (+ Postgres arm).
- `src/core/repair/redacted-facts.ts` — `gbrain repair redacted-facts` (#7125), explicit-only and preview-bound. `classifyRedactedFacts` (read-only) takes active facts whose text holds a redaction marker and runs `restoreNeutralized` (`think/sanitize.ts`, with the pre-fix `LEGACY_EVAL_SHELL` shape) against the page the fact's context names and the page holding it (`pageTexts`: an inline page's body + timeline, a segmented page's body through `readBodyRange` up to 16 MiB, then up to 50 `page_versions` bodies): `evidenced` when every proving text proves the same restoration, `ambiguous` (`conflicting_sources`) when a text holds two spans around the words or texts disagree, `unproven` (`no_source_page` / `not_in_source`) otherwise. A proved fenced row on a segmented page is `segmented` (`segmented_page`): listed with its restoration, never rewritten (`restoreFencedRows` reads and publishes inline bodies only). The preview hashes every candidate with its restoration and saves one approved item per page; the apply reclassifies each fact, rewrites database-only rows through one database-only `managed_maintenance_restore_redacted_facts` request per page on a managed brain (`prepareRedactedFactsRestore`, dispatched from `prepareMaintenanceMutation`) or one transaction on an unmanaged brain (exact-text compare-and-set; context gets `restored: redacted-facts repair`), and rewrites fenced rows' claims in the page's `## Facts` fence through one revision-bound `put_page`, so the canonical projection replaces the row. Pinned by `test/repair-redacted-facts.test.ts` (+ Postgres arm).
- `src/core/repair/loop-facts.ts` — `gbrain repair loop-facts` (#5869), explicit-only and preview-bound (`--apply --expect <hash>`): candidates are `loopFactDrift` rows (closed `done`/`dropped` loops whose commitment fact is active, in the loop's source and shared with no open loop); each item is rechecked (`changed_since_preview`) and retired through `retireLoopFact`, the same coordinated strike-plus-expire publication `loops_close` uses.
-- `src/core/repair/failed-writes.ts` — `gbrain repair failed-writes` (#5983), explicit-only and preview-bound: candidates are failed, uncompacted `persistence_requests` refused by the managed writer guard (`writer_coordinator_required`, or `storage_error` "Publication failed (P0001)"). Caller writes (`put_page` without an internal `kind`, `add_timeline_entry`, `remember`) are classified `replay` / `already_written` / `duplicate` / `superseded` / `unpinned_target` by later requests on the same page and by a committed replay request id, and `file_database_drift` (W4.11) when its last replay attempt was refused `source_changed` and the page has not been written since (`lastFailedAttempt`; the detail and an apply's `file_database_drift` outcome name `gbrain sources reconcile <source> <slug> --preview`; `test/repair-failed-writes-drift-w411.test.ts`); owner-produced writes are `producer_owned` residuals with the producer command (a failed `managed_file_repair` names both `gbrain repair frontmatter` and `gbrain repair fences`). #7602: fact rows (moved-entity refusals included) use `factsRecovery`: `recover:` (retry-dead reset) only while the page write's facts-absorb job is dead and the entity page is the one admitted, `pending:` while that job runs, `not recoverable:` for a deleted page, and `re-extract:` otherwise (replaced page, completed or missing job, exhausted follow-ups, a source page written again since the job's page write, which the job's own `readFactsBackstopJobPage` check skips as superseded, an extraction whose open entity requests are not all moved-entity or all held-file refusals, a guard refusal). Only the preview reads fact rows (`failedWrites(..., { facts: true })`); the sync-time remember replay and apply-by-id keep the guard/drift query. The approved set records each target page's revision. Apply resumes an admitted replay attempt, otherwise reclassifies and rechecks the revision, re-runs `authorizeStoredRequest` on the failed row, and resubmits the retained intent on the original trust lane (`laneContext`: remote, take holders, delegated prefixes) through `submitPageMutation` / `submitRememberMutation`, with `put_page` bound to the previewed revision and `remember` pinned to its resolved subject, under a request id derived from the failed request id and attempt (`repair-failed-writes-5983.test.ts`). #5994: `laneContext` sets `ctx.replayAuthority` to the stored authority, so admission (`submissionAuthority` → `replayedAuthority` in `persistence/authority.ts`, and `requestPrincipalForContext`) reuses its principal, delegation, scopes and autoLinkTrusted for the same source incarnation and re-authorizes it live; a restricted write gets back its recorded job (`delegatedJobId`, or the id in a single legacy `wiki/agents/<id>/*` prefix, replayed on the legacy sandboxed path when its original was), and one with neither is accepted by `enforceSubagentSlugFence` (`ops/context.ts`) only through that marker with the exact non-empty stored allow-list. The fence still fails closed for every live dispatch. A put_page replay passes the stored `timeline_section` (#5969). The superseded / already-written / duplicate rule lives in `persistence/terminal-classify.ts`, shared with the #6650 terminal-failure readers.
+- `src/core/repair/failed-writes.ts` — `gbrain repair failed-writes` (#5983), explicit-only and preview-bound: candidates are failed, uncompacted `persistence_requests` refused by the managed writer guard (`writer_coordinator_required`, or `storage_error` "Publication failed (P0001)"). Caller writes (`put_page` without an internal `kind`, `add_timeline_entry`, `remember`) are classified `replay` / `already_written` / `duplicate` / `superseded` / `unpinned_target` by later requests on the same page and by a committed replay request id, and `file_database_drift` (W4.11) when its last replay attempt was refused `source_changed` and the page has not been written since (`lastFailedAttempt`; the detail and an apply's `file_database_drift` outcome name `gbrain sources reconcile <source> <slug> --preview`; `test/repair-failed-writes-drift-w411.test.ts`); owner-produced writes are `producer_owned` residuals with the producer command (a failed `managed_file_repair` names both `gbrain repair frontmatter` and `gbrain repair fences`). #7602: fact rows (moved-entity refusals included) use `factsRecovery`: `recover:` (retry-dead reset) only while the page write's facts-absorb job is dead and the entity page is the one admitted, `pending:` while that job runs, `not recoverable:` for a deleted page, and `re-extract:` otherwise (replaced page, completed or missing job, exhausted follow-ups, a page write the job's own `readFactsBackstopJobPage` check now skips (written again since, or a narrowed writer grant), an extraction whose open entity requests are not all moved-entity or all held-file refusals, a guard refusal). Only the preview reads fact rows (`failedWrites(..., { facts: true })`); the sync-time remember replay and apply-by-id keep the guard/drift query. The approved set records each target page's revision. Apply resumes an admitted replay attempt, otherwise reclassifies and rechecks the revision, re-runs `authorizeStoredRequest` on the failed row, and resubmits the retained intent on the original trust lane (`laneContext`: remote, take holders, delegated prefixes) through `submitPageMutation` / `submitRememberMutation`, with `put_page` bound to the previewed revision and `remember` pinned to its resolved subject, under a request id derived from the failed request id and attempt (`repair-failed-writes-5983.test.ts`). #5994: `laneContext` sets `ctx.replayAuthority` to the stored authority, so admission (`submissionAuthority` → `replayedAuthority` in `persistence/authority.ts`, and `requestPrincipalForContext`) reuses its principal, delegation, scopes and autoLinkTrusted for the same source incarnation and re-authorizes it live; a restricted write gets back its recorded job (`delegatedJobId`, or the id in a single legacy `wiki/agents/<id>/*` prefix, replayed on the legacy sandboxed path when its original was), and one with neither is accepted by `enforceSubagentSlugFence` (`ops/context.ts`) only through that marker with the exact non-empty stored allow-list. The fence still fails closed for every live dispatch. A put_page replay passes the stored `timeline_section` (#5969). The superseded / already-written / duplicate rule lives in `persistence/terminal-classify.ts`, shared with the #6650 terminal-failure readers.
- `src/core/repair/ontology-facts.ts` — `gbrain repair ontology-facts` (#6264), explicit-only and preview-bound (`--apply --expect <hash>`). `classifyOntologyFacts` (read-only; also doctor `ontology_facts_fenced`) takes ontology rows (`dimension IS NOT NULL`) carrying the pre-fix fence step's signature, a `row_num` or a `source_markdown_slug` that differs from `source` (`mergeOntologyFact` writes them equal and never sets `row_num`), and classes each `fenced` or `retired`, or excluded as `withdrawn` (`fact_withdrawals`), `consolidated` or `duplicate` (restoring would collide with the ontology dedup key). The apply sets `row_num` NULL, `source_markdown_slug = source` and `expired_at` NULL in one statement that rechecks row number, page, expiry and the dedup key (`changed_since_preview` otherwise), through `coordinatedDatabaseWrite('ontology_propose')` on the entity and page keys on a managed brain or one maintenance transaction otherwise; the withdrawal trigger re-expires a claim forgotten after the preview (`withdrawn`). Page text is never rewritten. Tests: `test/ontology-fence-sweep.test.ts`.
- `src/core/repair/timeline-comments.ts` — `gbrain repair timeline-comments` (#6184), explicit-only. The plan lists pages with timeline rows whose source, summary or detail carries `<!--`/`-->` or whose body has a materialized bullet carrying markup (`dropCommentBullets`), with residuals `comment_only_rows`, `comment_bearing_rows`, `pages_with_comment_bullets`. Apply: one revision-bound `put_page` per page dropping those generated bullets (user-written bullets are left), then one transaction under the page lock (`withCoordinatedWrite` with maintenance attribution on managed brains) that deletes comment-only rows and rewrites the rest to their stripped tuple, or deletes them when the page already has it. Idempotent. `timeline.ts` warns `timeline_comment_markup` naming this kind while such rows exist. Rows on a segmented page are not planned (the apply rewrites a whole body): residuals `segmented_pages` / `segmented_rows` and a warning naming them.
- `src/core/repair/aliases.ts` — `gbrain repair aliases` (#6619), explicit-only, projection publication, wired to doctor `dangling_aliases`. One item per (source, target slug) whose alias rows (`page_aliases.slug`, `slug_aliases.canonical_slug`) point at a slug with no page row at all; apply rechecks that under the page key lock and deletes both tables' rows for it, inside `withCoordinatedWrite` on a managed brain (both tables carry the managed writer guard). Aliases of soft-deleted pages are the `soft_deleted_target` residual; rename redirects (`alias_slug` = the missing slug) are never touched. Exports `ORPHANED_ALIAS_COUNTS_SQL` / `SOFT_DELETED_ALIAS_COUNT_SQL`, which `checkDanglingAliases` (`src/core/onboard/checks.ts`) reports apart, naming `repairPreviewCommand('aliases', {source})` per source instead of raw SQL. Test: `test/purge-aliases-6619.test.ts`.
diff --git a/src/core/repair/failed-writes.ts b/src/core/repair/failed-writes.ts
index 45b1c722c0..39e7b54322 100644
--- a/src/core/repair/failed-writes.ts
+++ b/src/core/repair/failed-writes.ts
@@ -119,9 +119,9 @@ function previewCommand(scope: RepairScope): string {
* recovered by resetting that job once it is dead: its retry re-admits them at the entity page's current revision with
* no model call, once the cause clears. Only an extraction whose open entity requests are all moved-entity refusals (the
* entity walk) or all held-file refusals (the file walk) is re-admitted by one retry. A mixed extraction, a batch whose
- * follow-ups were refused too, an entity page replaced since, a job that completed or is gone, a source page written
- * again since the job's page write (the retry skips it as superseded), a writer-guard refusal and a batch with no page
- * write would replay the refusal or have no job to retry: those are extracted again. While the job still runs (a walk in
+ * follow-ups were refused too, an entity page replaced since, a job that completed or is gone, a page write the job's
+ * own page check now skips (written again since, or a narrowed writer grant), a writer-guard refusal and a batch with
+ * no page write would replay the refusal or have no job to retry: those are extracted again. While the job still runs (a walk in
* progress leaves follow-ups open), an entity page that is still the admitted one is listed `pending:`.
*/
async function factsRecovery(engine: BrainEngine, write: FailedWrite, extractions: Map<string, ExtractionRequest[]>): Promise<string> {
@@ -144,13 +144,14 @@ async function factsRecovery(engine: BrainEngine, write: FailedWrite, extraction
}
if (run?.status !== 'dead') return `${extractAgain}; its facts-absorb job ${run ? `is ${run.status}` : 'is gone'}, so gbrain facts retry-dead has no dead job to reset`;
const source = await readFactsBackstopJobPage(engine, run.data);
- if ('skipped' in source && (source.skipped === 'superseded' || source.skipped === 'page_missing')) {
- return `${extractAgain}; ${origin ?? 'the source page'} changed after the page write its facts-absorb job extracts, so a job retry skips it`;
+ if ('skipped' in source) {
+ return source.skipped === 'superseded' || source.skipped === 'page_missing'
+ ? `${extractAgain}; ${origin ?? 'the source page'} changed after the page write its facts-absorb job extracts, so a job retry skips it`
+ : `${extractAgain}; a job retry would skip the page write (${source.skipped}), so gbrain facts retry-dead cannot recover it`;
}
return `recover: ${factsRetryDeadCommand('--reset', key)} (the next facts_drain pass retries the page's facts-absorb job, which re-admits the retained facts without a model call${write.error_code === 'source_changed' ? ' once the file check passes' : ''})`;
}
-
/** The command that produces an owner-internal write again, from current content. */
function producerCommand(producer: string, sourceId: string): string {
const parts = producer.split(':');
diff --git a/test/facts-entity-moved-7602.test.ts b/test/facts-entity-moved-7602.test.ts
index 44f52e1835..c453c3f689 100644
--- a/test/facts-entity-moved-7602.test.ts
+++ b/test/facts-entity-moved-7602.test.ts
@@ -269,6 +269,25 @@ for (const backend of testBackends()) {
expect((await factsListing(engine)).map(entry => entry.detail)).toEqual([`re-extract: gbrain call extract_facts again on the current text of ${loser.slug} with a new request_id (one model call); ${loser.slug} changed after the page write its facts-absorb job extracts, so a job retry skips it`]);
}, { databaseUrl }), 120_000);
+ // Value: protects=a dead job whose page write its own retry would skip for a reason other than a newer write (here the writer's
+ // grant no longer covers the source page) is listed for re-extraction, not the reset; fails_when=factsRecovery offers recover: for
+ // any skip but superseded/page_missing; why_new=the row above covers superseded only; seam=the grant is narrowed by SQL on the
+ // writer row; no_claim=does not run the reset job
+ test(`#7602 [${backend}]: a refusal whose page write its job would skip (writer grant narrowed) is listed for re-extraction`, () => managedBrain(async brain => {
+ const { engine } = brain;
+ const { move, loser } = await setup(brain, 1);
+ const before = await loser.session();
+ before.entityMoveRetry = false;
+ const race = raceEntityReads(engine, 1, move);
+ expect((await publishManagedFacts(engine, before, loser.backstop, [fact(CLAIM_B)], 'private', loser.slug).catch(error => error).finally(race.restore)).code).toBe('revision_conflict');
+ const key = await factsAbsorbJob(engine, loser, 'dead');
+ expect((await factsListing(engine)).map(entry => entry.detail?.split(' (')[0])).toEqual([`recover: gbrain facts retry-dead --reset '${key}'`]);
+ const [writer] = await engine.executeRaw<{ principal_kind: string; principal_id: string }>('SELECT principal_kind, principal_id FROM persistence_requests WHERE id=$1::uuid', [loser.write]);
+ expect(writer!.principal_kind).toBe('local_cli');
+ expect(await engine.executeRaw("UPDATE persistence_local_writers SET grant_ceiling = jsonb_set(COALESCE(grant_ceiling, '{}'::jsonb), '{slugPrefixes}', '[\"people/\"]'::jsonb) WHERE id=$1::uuid RETURNING id", [writer!.principal_id])).toHaveLength(1);
+ expect((await factsListing(engine)).map(entry => entry.detail)).toEqual([`re-extract: gbrain call extract_facts again on the current text of ${loser.slug} with a new request_id (one model call); a job retry would skip the page write (permission_denied), so gbrain facts retry-dead cannot recover it`]);
+ }, { databaseUrl }), 120_000);
+
// Value: protects=repair failed-writes offers the job reset only for a dead facts-absorb job, and the reset's replay publishes the
// retained facts; fails_when=a waiting or completed job is listed with retry-dead (a command that finds no dead job), or the replay
// does not publish; why_new=the rows above never list a recoverable refusal; seam=the job's status is set by SQL; no_claim=does not
@@ -351,6 +370,39 @@ for (const backend of testBackends()) {
're-extract: gbrain call extract_facts again on the current text of the source turn with a new request_id (one model call)']]);
}, { databaseUrl }), 120_000);
+ // Value: protects=the stored moved-entity refusal texts stay the ones pre-fix and current receipts carry, so a reword cannot
+ // silently stop the walk and the repair preview from matching stored rows; fails_when=any FACTS_ENTITY_MOVED_MESSAGES entry is
+ // reworded, dropped or reordered without a decision about stored receipts; why_new=the rows below iterate the list itself;
+ // seam=none; no_claim=does not prove every thrower uses these constants
+ test(`#7602 [${backend}]: the stored moved-entity refusal texts are frozen`, () => {
+ expect([...FACTS_ENTITY_MOVED_MESSAGES]).toEqual(['The fact entity changed after extraction admission.', 'The fact entity changed during preparation.',
+ 'The fact deduplication state changed before publication.', 'The page changed during preparation.',
+ 'The page changed after it was read. Read its current revision before retrying.']);
+ });
+
+ // Value: protects=a revision_conflict whose stored message is not a moved-entity text (the source page changed) is neither
+ // re-admitted by the walk nor listed by repair; fails_when=the predicate widens to every revision_conflict and re-admits facts
+ // whose source page moved; why_new=every other row stores a moved-entity text; seam=the stored message is set by SQL;
+ // no_claim=does not reproduce the source-page refusal path itself
+ test(`#7602 [${backend}]: a revision_conflict stored with the source-page text is not followed or listed`, () => managedBrain(async brain => {
+ const { engine } = brain;
+ const { move, loser } = await setup(brain, 1);
+ const before = await loser.session();
+ before.entityMoveRetry = false;
+ const race = raceEntityReads(engine, 1, move);
+ expect((await publishManagedFacts(engine, before, loser.backstop, [fact(CLAIM_B)], 'private', loser.slug).catch(error => error).finally(race.restore)).code).toBe('revision_conflict');
+ await engine.transaction(async tx => {
+ await declarePersistenceProtocol(tx);
+ expect(await tx.executeRaw("UPDATE persistence_requests SET error_message='The source page changed during fact extraction.' WHERE operation='extract_facts' AND slug=$1 AND state='conflict' RETURNING id", [TARGET])).toHaveLength(1);
+ });
+ await factsAbsorbJob(engine, loser, 'dead');
+ const requests = await entityRequests(engine);
+ expect((await resumeManagedFacts(engine, await loser.session()).catch(error => error)).code).toBe('revision_conflict');
+ expect(await entityRequests(engine)).toEqual(requests);
+ expect(await claimB(engine)).toEqual([]);
+ expect(await factsListing(engine)).toEqual([]);
+ }, { databaseUrl }), 120_000);
+
// Value: protects=a refusal stored with any moved-entity message (the admission, preparation, deduplication and coordinator kinds,
// and the page layer's stale-revision message stored before the fix) is listed with the job reset and re-admitted by it, and
// repair --apply leaves it alone; fails_when=a message is missing from FACTS_ENTITY_MOVED_MESSAGES, so the receipt is never listed
@@ -547,6 +599,43 @@ for (const backend of testBackends()) {
expect(await engine.executeRaw('SELECT fact FROM facts WHERE fact=$1', [CLAIM_OTHER])).toEqual([]);
}, { databaseUrl }), 120_000);
+ // Value: protects=the entity walk stops when the moved requests it would follow carry different embedding signatures, and follows
+ // them once they match; fails_when=the sameSignature check is dropped and facts embedded under another model are admitted under
+ // the first request's signature; why_new=every other #7602 row retains one null signature; seam=none; no_claim=the second
+ // signature is stamped onto a stored receipt by SQL (one admission never mixes them)
+ test(`#7602 [${backend}]: moved requests whose retained embedding signatures differ are not followed until they match`, () => managedBrain(async brain => {
+ const { engine, ctx } = brain;
+ const { move, loser } = await setup(brain, 1);
+ await put(ctx, OTHER, 'company');
+ const before = await loser.session();
+ before.entityMoveRetry = false;
+ const race = raceEntityReads(engine, 1, async n => {
+ await move(n);
+ const other = (await engine.readPageSnapshot(OTHER, { sourceId: 'default' }))!;
+ await submitPageMutation(ctx, { operation: 'put_page', params: { slug: OTHER, request_id: randomUUID(), expected_revision: other.revision,
+ content: `---\ntype: company\ntitle: Example\n---\n${BODY} (moved)\n` } });
+ });
+ expect((await publishManagedFacts(engine, before, loser.backstop, [{ ...fact(CLAIM_OTHER), entity_slug: OTHER }, fact(CLAIM_B)], 'private', loser.slug)
+ .catch(error => error).finally(race.restore)).code).toBe('revision_conflict');
+ const requests = () => engine.executeRaw<{ slug: string; state: string; error_code: string | null }>(`SELECT slug, state, error_code FROM persistence_requests
+ WHERE operation='extract_facts' AND slug = ANY($1::text[]) AND intent->>'origin' LIKE '%chats/source-loser%' ORDER BY sequence`, [[OTHER, TARGET]]);
+ expect(await requests()).toEqual([{ slug: OTHER, state: 'conflict', error_code: 'revision_conflict' }, { slug: TARGET, state: 'conflict', error_code: 'revision_conflict' }]);
+ const signature = (value: unknown) => engine.transaction(async tx => {
+ await declarePersistenceProtocol(tx);
+ expect(await tx.executeRaw(`UPDATE persistence_requests SET intent=jsonb_set(intent, '{embedding}', $2::text::jsonb) WHERE operation='extract_facts'
+ AND slug=$1 AND state='conflict' AND intent->>'origin' LIKE '%chats/source-loser%' RETURNING id`, [OTHER, JSON.stringify(value)])).toHaveLength(1);
+ });
+ const published = () => engine.executeRaw<{ fact: string }>('SELECT fact FROM facts WHERE fact = ANY($1::text[]) ORDER BY fact', [[CLAIM_OTHER, CLAIM_B]]);
+ await signature({ model: 'openai:text-embedding-3-small', dimensions: 1536 });
+ const stopped = await resumeManagedFacts(engine, await loser.session()).catch(error => error);
+ expect([stopped.code, stopped.retryable]).toEqual(['revision_conflict', false]);
+ expect(await requests()).toHaveLength(2);
+ expect(await published()).toEqual([]);
+ await signature(null);
+ expect((await resumeManagedFacts(engine, await loser.session()))?.inserted).toBe(2);
+ expect((await published()).map(row => row.fact).sort()).toEqual([CLAIM_OTHER, CLAIM_B].sort());
+ }, { databaseUrl }), 120_000);
+
test(`#7602 [${backend}]: the facts-absorb job that lost the race completes in one attempt with one model call`, () => managedBrain(async brain => {
const { engine } = brain;
const { move, loser } = await setup(brain, 1);