Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
import type { BrainEngine, TakeBatchInput } from '../engine.ts';
import type { GBrainConfig } from '../config.ts';
import { OperationError, opError, type OperationContext } from '../ops/contract.ts';
import { readFix } from '../ops/op-fix.ts';
import type { RegistryCode } from '../error-registry.ts';
import { isValidHolder, parseTakesFence, upsertTakeRow, supersedeRow, type ParsedTake, type TakeQuality } from '../takes-fence.ts';
import { takesPreparation as edit, TakesWriteError } from '../takes-write.ts';
import { serializePageToMarkdown } from '../markdown.ts';
import { preparePageMutation } from './page-prepare.ts';
import { wholeBodySnapshot } from './segmented-apply.ts';
import { authorizeTakeHolder } from './authority.ts';
import type { WriteRequest } from './model.ts';
import type { PreparedMutation } from './coordinator.ts';
import { assertPageRevision } from '../page-state/types.ts';
import { engineMutationPrecondition, parseMutationPrecondition } from './preconditions.ts';
import { normalizeTargetFences, storedFenceRows } from '../fence-repair/import-step.ts';
import { nextFreeRowNum } from '../fence-repair/normalize.ts';
import { scanCanonicalFences, targetFenceRefusal } from '../fence-repair/refusal.ts';
import { pageFencesNormalized } from '../fence-repair/report.ts';
import { requestChannelTrust } from '../trust/channel.ts';
import { gateField, gateInput, heldOutcome, loadWriteGateConfig } from '../trust/gate-outcomes.ts';
import { finishOwnerAcceptedTake, ownerAcceptedTake, recordContestedTake, supersessionGuarded } from '../trust/supersede-handlers.ts';
import { storedTrustTier, type TrustTier } from '../trust/tier.ts';
import { contestHeldRows } from '../trust/fence-guard.ts';
import { ownerAcceptedRemoval } from '../trust/held-removals.ts';
import { transitionTrustProposal } from '../trust/proposals.ts';
import { tierRaiseFix } from '../trust/confirm.ts';
import { requestAttribution } from './attribution.ts';
import { withWriteAttribution } from './context.ts';
import { decideTakeWrite, recordFlaggedRow, recordWriteGateHold } from '../write-gate-store.ts';
import { writeGateRejectedError } from '../write-gate.ts';
import { beliefTransaction } from '../belief/writers.ts';
import { clearFenceHold, fenceOwnerKey, readFenceBlocks, TAKE_FENCE_KIND } from '../generations/fence.ts';
/** Server-derived values are frozen after replay lookup, before admission. */
export async function normalizeTakesIntent(ctx: OperationContext, params: Record<string, unknown>): Promise<Record<string, unknown>> {
const date = new Date().toISOString().slice(0,10);
let resolvedBy = params.resolved_by;
if (ctx.remote !== false) {
const id = (ctx.auth?.clientId ?? ctx.transport ?? 'remote').replace(/[^\w.:-]/g,'_').slice(0,64);
resolvedBy = `mcp:${id}`;
} else if (typeof resolvedBy !== 'string' || !resolvedBy) {
const { resolveOwnerHolder } = await import('../owner-holder.ts');
resolvedBy = resolveOwnerHolder({ configValue: await ctx.engine.getConfig('emotional_weight.user_holder') });
}
let holder = params.holder;
if (holder === 'me' && ctx.remote === false) {
const { resolveOwnerHolder } = await import('../owner-holder.ts');
holder = resolveOwnerHolder({ configValue: await ctx.engine.getConfig('emotional_weight.user_holder') });
}
return { ...params, holder, resolved_by: resolvedBy, resolved_at: date, since: params.since ?? date,
since_supplied: params.since !== undefined };
}
/** A refused takes publication: the journal keeps code and message only, so the suggestion stands alone. */
function takesRefusal(code: RegistryCode, message: string, row: WriteRequest, cause: string): OperationError {
return opError(code, message, `${cause} Takes request ${row.request_id} on ${row.slug} in source ${row.source_id} failed before anything was written; correct it and submit it as a new request with a new request_id.`,
{ fix: readFix(`Shows page ${row.slug} in source ${row.source_id} as it is now, with its takes table and revision, read-only.`,
{ argv: ['gbrain', 'get', '--source', row.source_id, '--', row.slug], mcp: { tool: 'get_page', arguments: { slug: row.slug, source_id: row.source_id } } }) });
}
/**
* #6450: the holder is trimmed and checked against the fence grammar at the write boundary (syntax before authority), so a
* malformed holder is refused `invalid_params` instead of being published into a fence the next write would refuse.
*/
function validHolder(raw: string, row: WriteRequest): string {
const holder = raw.trim();
if (isValidHolder(holder)) return holder;
throw takesRefusal('invalid_params', 'holder must be world | brain | people/<slug> | companies/<slug> (a legacy bare slug is accepted).', row,
`Its holder is not a value the takes fence can carry; pass holder as world, brain, people/<slug> or companies/<slug>.`);
}
function fail(error: unknown): never {
if (!(error instanceof TakesWriteError)) throw error;
const code = error.code === 'holder_denied' ? 'permission_denied' : error.code === 'row_not_found' ? 'not_found'
: error.code === 'page_not_found' ? 'page_not_found' : 'invalid_params';
throw new OperationError(code, error.message, error.hint);
}
/**
* A lower-tier takes_remove of a more trusted take: files the `forget` proposal in its own transaction (attributed to the
* request) and returns the refusal carrying its ref; nothing was removed. A retry reuses the proposal.
*/
async function takeRemovalRequiresOwner(engine: BrainEngine, row: WriteRequest, take: { id: number; tier: TrustTier; rowNum: number }, writer: TrustTier): Promise<OperationError> {
// W1 #6783 §6.2: the refusal's own transaction records trust.contested on the take.
const [ref] = await beliefTransaction(engine, { sourceId: row.source_id, slugs: [row.slug], publicationId: row.id, op: row.operation,
remote: row.authority.remote !== false, cause: { refused: 'forget_requires_owner' } }, tx => contestHeldRows(tx, { sourceId: row.source_id, slug: row.slug,
table: 'takes', proposer: 'takes_remove', writer, rows: [{ id: take.id, tier: take.tier, change: 'removed' }] }),
(tx, run) => withWriteAttribution(tx, { ...requestAttribution(row), trust: requestChannelTrust(row) ?? undefined }, run));
const error = opError('forget_requires_owner', `Take row #${take.rowNum} on ${row.slug} is ${take.tier}; this write cannot remove it. Proposal ${ref} asks the owner.`,
`Do not retry. Tell the user take row #${take.rowNum} on ${row.slug} needs their decision: they can remove it with gbrain trust confirm ${ref} on the brain host.`);
error.fix = tierRaiseFix(['gbrain', 'trust', 'confirm', ref!], 'Removing a take the owner confirmed or curated is their decision; the confirm prompt applies the removal.',
`Run on the brain host, in a terminal: gbrain trust confirm ${ref}`);
return error;
}
/**
* Every stored take of page `pageId` as its fence row, in row order (resolution cells included when it is graded), while
* its take_fence generation is held `fence_absent`: once a fence parses again the projection compares it with exactly
* these rows (canonical-projections.ts `heldTakeFence`). None otherwise.
*/
export async function heldTakeRows(engine: BrainEngine, sourceId: string, slug: string, pageId: number): Promise<ParsedTake[]> {
if (!(await engine.executeRaw(`SELECT 1 FROM derived_generations WHERE source_id=$1 AND kind=$2 AND owner_key=$3 AND state='held' AND held_reason='fence_absent'`,
[sourceId, TAKE_FENCE_KIND, fenceOwnerKey(slug)])).length) return [];
const rows = await engine.executeRaw<{ row_num: number; claim: string; kind: string; holder: string; weight: number; since_date: string | null; until_date: string | null;
source: string | null; active: boolean; resolved_at: Date | string | null; resolved_quality: TakeQuality | null; resolved_outcome: boolean | null; resolved_source: string | null;
resolved_value: number | null; resolved_unit: string | null; resolved_by: string | null }>(`SELECT row_num, claim, kind, holder, weight, since_date, until_date, source, active,
resolved_at, resolved_quality, resolved_outcome, resolved_source, resolved_value, resolved_unit, resolved_by FROM takes WHERE page_id=$1 ORDER BY row_num`, [pageId]);
return rows.map(t => ({ rowNum: Number(t.row_num), claim: t.claim, kind: t.kind, holder: t.holder, weight: Number(t.weight), active: t.active,
...(t.since_date ? { sinceDate: t.since_date } : {}), ...(t.until_date ? { untilDate: t.until_date } : {}), ...(t.source ? { source: t.source } : {}),
...(t.resolved_quality ? { resolvedQuality: t.resolved_quality, resolvedAt: t.resolved_at ? new Date(t.resolved_at).toISOString() : undefined,
...(t.resolved_outcome !== null ? { resolvedOutcome: t.resolved_outcome } : {}), ...(t.resolved_source ? { resolvedEvidence: t.resolved_source } : {}),
...(t.resolved_value !== null ? { resolvedValue: Number(t.resolved_value) } : {}), ...(t.resolved_unit ? { resolvedUnit: t.resolved_unit } : {}),
...(t.resolved_by ? { resolvedBy: t.resolved_by } : {}) } : {}) }));
}
/** `editBody`: a same-page edit published with the takes change (consolidation closes its fenced facts here). */
export async function prepareTakesMutation(engine: BrainEngine, row: WriteRequest, config: GBrainConfig, editBody?: (body: string) => string): Promise<PreparedMutation> {
try { return await prepare(engine,row,config,editBody); } catch (error) { return fail(error); }
}
async function prepare(engine: BrainEngine, row: WriteRequest, config: GBrainConfig, editBody?: (body: string) => string): Promise<PreparedMutation> {
const stored = await engine.readPageSnapshot(row.slug, { sourceId: row.source_id });
if (!stored || stored.page.id !== row.page_id) throw takesRefusal('page_identity_changed','The accepted page no longer exists.',row,
`Page ${row.slug} was deleted or replaced after the takes request was accepted.`);
const p = row.intent!;
if (p.expected_revision !== undefined) assertPageRevision(stored,engineMutationPrecondition(parseMutationPrecondition(p)));
// Wave B: a segmented page within 24 MiB is read back whole and written as a normal put; a larger one refuses.
const snapshot = (await wholeBodySnapshot(engine, stored, row.operation))!;
// #6188 (D19, D20): takes_add / takes_update normalize the stored takes fence in this write; every other
// takes write refuses typed `target_fence_malformed` (location only) while the fence does not compile.
const appends = row.operation === 'takes_add' || row.operation === 'takes_update';
const defect = appends ? undefined : scanCanonicalFences(snapshot.page).defects.find(d => d.fence === 'takes');
if (defect) throw targetFenceRefusal(defect, row.slug, row.source_id);
const target = appends ? await normalizeTargetFences(engine, { sourceId: row.source_id, slug: row.slug, kind: 'takes', page: snapshot.page }) : null;
const rendered = serializePageToMarkdown(target ? { ...snapshot.page, ...target.page } : snapshot.page,snapshot.tags);
// A rewrite that dropped the takes fence left the page's takes stored (held fence_absent): a takes write that creates
// the fence again renders them into it first, or the next projected write would read the new fence as their removal.
const recreated = readFenceBlocks(target?.page ?? snapshot.page,'takes').state==='absent';
const held = recreated ? await heldTakeRows(engine,row.source_id,row.slug,snapshot.page.id) : [];
const body = held.length ? edit.replaceFence(upsertTakeRow(rendered,held[0]!).body,held) : rendered;
const parsed = parseTakesFence(body);
edit.assertFenceRoundTrips(parsed);
for (const key of ['claim','kind','holder','source','evidence','unit','resolved_by']) {
if (p[key] !== undefined && typeof p[key] !== 'string') throw takesRefusal('invalid_params',`${key} must be text.`,row,`Its ${key} is not text; pass ${key} as a string.`);
edit.assertSafeCellText(key,p[key] as string | undefined);
}
edit.assertValidWeight(p.weight as number | undefined);
edit.assertValidSinceDate(p.since as string | undefined);
const holders = row.authority.remote ? row.authority.takesHolders ?? ['world'] : null;
const requiredHolders = new Set<string>();
let next = body;
let changed: ParsedTake[] = [];
let result: Record<string, unknown>;
let oldRow: number | undefined;
let removedRow: number | undefined;
// #5575: the takes write's declared tier (ENG-18) for the guarded supersession and the write gate.
const trust = requestChannelTrust(row) ?? { tier: 'unknown' as const, origin: null };
let contestedOld: { id: number; tier: string } | undefined;
let acceptedProposal: { id: number; newId: number; newRow: number } | null = null;
let acceptedRemoval: number | null = null;
// W9F item 4: a new row number never seen on this page, fence rows (reservations included) and stored rows alike.
let allocated: number | undefined;
const nextRow = async () => nextFreeRowNum({ compiled_truth: body, timeline: '' },
await storedFenceRows(engine, row.source_id, row.slug, snapshot.page.id));
if (row.operation === 'takes_add') {
if (typeof p.claim !== 'string' || !p.claim.trim() || typeof p.kind !== 'string' || typeof p.holder !== 'string') throw takesRefusal('invalid_params','claim, kind and holder are required.',row,
'takes_add needs claim, kind and holder as non-empty text.');
const holder=validHolder(p.holder,row);
edit.assertHolderAllowed(holder,holders); requiredHolders.add(holder);
const added = upsertTakeRow(body,{claim:p.claim,kind:p.kind,holder,weight:p.weight as number ?? 0.5,
source:p.source as string | undefined,sinceDate:p.since as string,active:true,rowNum:await nextRow()});
next=added.body; allocated=added.rowNum; changed=parseTakesFence(next).takes.filter(t=>t.rowNum===added.rowNum);
result={slug:row.slug,row_num:added.rowNum,holder};
} else {
if (!Number.isSafeInteger(p.row_num) || Number(p.row_num)<1) throw takesRefusal('invalid_params','row_num must be a positive integer.',row,
`Pass row_num as the take's row number on the page (takes_list with page_slug ${row.slug} lists them).`);
const number=Number(p.row_num);
const target=edit.findFenceRow(parsed.takes,number,holders,row.slug);
requiredHolders.add(target.holder);
if (target.resolvedAt) throw new TakesWriteError('already_resolved','Resolved takes are immutable.');
if (row.operation==='takes_remove') {
const citing=parsed.takes.find(t=>t.rowNum!==number && Number(t.source?.match(/superseded by #(\d+)/)?.[1])===number);
if (citing) throw takesRefusal('invalid_params',`Row #${number} replaces row #${citing.rowNum}.`,row,
`Row #${citing.rowNum} on ${row.slug} cites row #${number} as "superseded by #${number}"; remove row #${citing.rowNum} first, or keep both.`);
const [stored]=await engine.executeRaw<{id:number;claim:string;trust_tier:string}>('SELECT id,claim,trust_tier FROM takes WHERE page_id=$1 AND row_num=$2',[snapshot.page.id,number]);
if (stored && stored.claim!==target.claim) throw takesRefusal('invalid_params',`Row #${number}'s database copy disagrees with the page's takes fence; run gbrain takes rebuild ${row.slug} --source-id ${row.source_id} first.`,row,
`Rebuild the page's takes index from its fence first with gbrain takes rebuild ${row.slug} --source-id ${row.source_id}, check the row, then remove it again.`);
// W1 #6783 §12 (a): a lower-tier writer never removes a more trusted take; a `forget` proposal asks the owner.
acceptedRemoval=stored ? await ownerAcceptedRemoval(engine,row,Number(stored.id)) : null;
if (stored && acceptedRemoval===null && supersessionGuarded(trust.tier,stored.trust_tier)) throw await takeRemovalRequiresOwner(engine,row,
{id:Number(stored.id),tier:storedTrustTier(stored.trust_tier),rowNum:number},trust.tier);
removedRow=number;
next=edit.replaceFence(body,parsed.takes.filter(t=>t.rowNum!==number),[number]);
result={slug:row.slug,row_num:number,removed:true};
} else if (!target.active) throw new TakesWriteError('row_inactive','The take was superseded.');
else if (row.operation==='takes_supersede') {
if (typeof p.claim!=='string' || !p.claim.trim()) throw takesRefusal('invalid_params','claim is required.',row,
'takes_supersede needs the replacement claim as non-empty text.');
// Only an explicit override is validated; the inherited holder already round-tripped with the existing fence.
const holder=typeof p.holder==='string'?validHolder(p.holder,row):target.holder;
edit.assertHolderAllowed(holder,holders); requiredHolders.add(holder);
const [stored]=await engine.executeRaw<{id:number;trust_tier:string}>('SELECT id,trust_tier FROM takes WHERE page_id=$1 AND row_num=$2',[snapshot.page.id,number]);
const accepted=p.trust_accept!==undefined && stored ? await ownerAcceptedTake(engine,row,Number(stored.id),snapshot.page.id) : null;
if (accepted) {
// The owner accepted a supersede_take proposal (CEO-9): strike the old row toward the contested row already in the fence.
next=edit.replaceFence(body,parsed.takes.map(t=>t.rowNum===number?{...t,active:false,source:t.source?.trim()&&!/^superseded by #\d+$/i.test(t.source.trim())?`${t.source.trim()}; superseded by #${accepted.newRow}`:`superseded by #${accepted.newRow}`}:t));
oldRow=number; acceptedProposal=accepted;
changed=parseTakesFence(next).takes.filter(t=>t.rowNum===number);
result={slug:row.slug,old_row:number,new_row:accepted.newRow};
} else if (stored && supersessionGuarded(trust.tier,stored.trust_tier)) {
// A lower-tier writer never supersedes a more trusted take: the new claim is added contested and the owner decides (A5).
const added=upsertTakeRow(body,{claim:p.claim,kind:p.kind as string ?? target.kind,holder,weight:p.weight as number ?? Math.max(0,target.weight-0.1),
source:p.source as string | undefined,sinceDate:p.since as string,active:true,rowNum:await nextRow()});
next=added.body; allocated=added.rowNum; contestedOld={id:Number(stored.id),tier:stored.trust_tier};
changed=parseTakesFence(next).takes.filter(t=>t.rowNum===added.rowNum);
result={slug:row.slug,old_row:number,new_row:added.rowNum};
} else {
const superseded=supersedeRow(body,number,{claim:p.claim,kind:p.kind as string ?? target.kind,holder,
weight:p.weight as number ?? Math.max(0,target.weight-0.1),source:p.source as string | undefined,sinceDate:p.since as string},await nextRow());
next=superseded.body; oldRow=number; allocated=superseded.newRowNum;
changed=parseTakesFence(next).takes.filter(t=>t.rowNum===number || t.rowNum===superseded.newRowNum);
result={slug:row.slug,old_row:number,new_row:superseded.newRowNum};
}
} else {
let updated: ParsedTake;
if (row.operation==='takes_update') {
if (p.weight===undefined && p.source===undefined && p.since_supplied!==true) throw new TakesWriteError('no_fields','No mutable fields supplied.');
updated={...target,weight:p.weight as number ?? target.weight,source:p.source as string ?? target.source,
sinceDate:p.since_supplied===true?p.since as string:target.sinceDate};
} else if (row.operation==='takes_resolve') {
if (!['correct','incorrect','partial','unresolvable'].includes(String(p.quality))) throw takesRefusal('invalid_params','Unknown resolution quality.',row,
'Pass quality as one of: correct, incorrect, partial, unresolvable.');
if (p.value!==undefined && (typeof p.value!=='number' || !Number.isFinite(p.value))) throw takesRefusal('invalid_params','value must be finite.',row,
'Pass value as a finite number, or omit it.');
updated={...target,resolvedAt:String(p.resolved_at),resolvedQuality:p.quality as TakeQuality,
resolvedOutcome:p.quality==='correct'?true:p.quality==='incorrect'?false:undefined,
resolvedEvidence:p.evidence as string | undefined,resolvedValue:p.value as number | undefined,
resolvedUnit:p.unit as string | undefined,resolvedBy:String(p.resolved_by)};
} else throw takesRefusal('invalid_params','Unsupported takes mutation.',row,
`${row.operation} is not a takes mutation this release can publish (takes_add, takes_update, takes_supersede, takes_resolve or takes_remove).`);
changed=[updated]; next=edit.replaceFence(body,parsed.takes.map(t=>t.rowNum===number?updated:t));
result={slug:row.slug,row_num:number,...(row.operation==='takes_resolve'?{quality:p.quality,resolved_by:p.resolved_by}:{})};
}
}
if (editBody) next = editBody(next);
// #6450 post-condition: never publish a fence the next write would refuse.
const republished = parseTakesFence(next);
if (republished.warnings.length) throw takesRefusal('invalid_params',`The write would publish a takes fence the next write would refuse: ${republished.warnings[0]}`,row,
'One of the values would not round-trip through the takes fence; correct it (holder, kind, claim and source are single-line fence cells).');
const gate = allocated !== undefined ? decideTakeWrite({ claim: String(p.claim), source: (p.source as string | undefined) ?? null }, { sourceId: row.source_id, slug: row.slug,
payload: { page_id: snapshot.page.id, claim: p.claim, kind: p.kind ?? null, holder: p.holder ?? null, weight: p.weight ?? null, source: p.source ?? null, since: p.since ?? null },
input: gateInput(trust, row.id), cfg: await loadWriteGateConfig(engine) }) : null;
if (gate?.action === 'reject') throw writeGateRejectedError(gate.assessment);
if (gate?.action === 'hold') return { observedRevision: snapshot.revision, noop: true, apply: async tx => heldOutcome(gate.assessment, (await recordWriteGateHold(tx, gate.hold!)).holdId) };
// Rows Tier 1 rewrote are re-indexed with the row this write changes.
const normalizedRows=new Set((target?.fixes ?? []).filter(f=>f.fence==='takes' && f.row!==null).map(f=>f.row!));
if (normalizedRows.size) changed=[...changed,...parseTakesFence(next).takes.filter(t=>normalizedRows.has(t.rowNum) && !changed.some(c=>c.rowNum===t.rowNum))];
for (const holder of requiredHolders) await authorizeTakeHolder(engine,row.authority,holder);
const prepared=await preparePageMutation(engine,row,config,{content:next,expectedRevision:snapshot.revision});
return {...prepared,validate:async tx=>{
await prepared.validate?.(tx);
if (allocated!==undefined && (await tx.executeRaw('SELECT 1 FROM takes WHERE page_id=$1 AND row_num=$2',[snapshot.page.id,allocated])).length) {
throw takesRefusal('revision_conflict',`Take row #${allocated} was recorded on ${row.slug} while this write was prepared.`,row,
`Another writer recorded take row #${allocated} on ${row.slug} after this request read the page.`);
}
for (const holder of requiredHolders) await authorizeTakeHolder(tx,row.authority,holder);
await tx.executeRaw(`UPDATE persistence_requests
SET authority=jsonb_set(authority,'{takeHoldersUsed}',$2::text::jsonb)
WHERE id=$1::uuid`, [row.id, JSON.stringify([...requiredHolders].sort())]);
},apply:async tx=>{
const outcome=await prepared.apply(tx);
if (!prepared.noop) {
const batch:TakeBatchInput[]=changed.map(t=>edit.toBatchInput(snapshot.page.id,t,
t.rowNum===oldRow?Number(result.new_row):null));
if (batch.length) await tx.addTakesBatch(batch);
if (removedRow!==undefined) await tx.executeRaw('DELETE FROM takes WHERE page_id=$1 AND row_num=$2',[snapshot.page.id,removedRow]);
if (acceptedRemoval!==null && !await transitionTrustProposal(tx,acceptedRemoval,'pending','accepted')) throw new Error(`trust proposal tp${acceptedRemoval} is no longer pending`);
if (row.operation==='takes_resolve') {
const t=changed[0];
await tx.resolveTake(snapshot.page.id,t.rowNum,{quality:t.resolvedQuality!,outcome:t.resolvedOutcome,
value:t.resolvedValue,unit:t.resolvedUnit,source:t.resolvedEvidence,resolvedBy:t.resolvedBy!});
await tx.executeRaw('UPDATE takes SET resolved_at=$3::timestamptz WHERE page_id=$1 AND row_num=$2',[snapshot.page.id,t.rowNum,t.resolvedAt]);
}
const [written]=allocated!==undefined?await tx.executeRaw<{id:number;trust_tier:string}>('SELECT id,trust_tier FROM takes WHERE page_id=$1 AND row_num=$2',[snapshot.page.id,allocated]):[];
if (written && contestedOld) result.contested=await recordContestedTake(tx,{sourceId:row.source_id,oldId:contestedOld.id,oldTier:storedTrustTier(contestedOld.tier),
newId:Number(written.id),newTier:storedTrustTier(written.trust_tier),guard:'takes_supersede'});
if (acceptedProposal) await finishOwnerAcceptedTake(tx,acceptedProposal);
if (recreated && readFenceBlocks({compiled_truth:next},'takes').state==='parsed') await clearFenceHold(tx,{kind:TAKE_FENCE_KIND,sourceId:row.source_id,ownerKey:fenceOwnerKey(row.slug)});
const flagged=written && gate ? gateField(gate.assessment,`t${written.id}`,await recordFlaggedRow(tx,gate,{table:'takes',id:Number(written.id),sourceId:row.source_id})) : undefined;
if (flagged) result.gate=flagged;
}
return {...outcome,...result,mirror_written:!!prepared.file,...(target?.fixes.length?{fences_normalized:pageFencesNormalized({sourceId:row.source_id,slug:row.slug,
// A remote caller may not see every holder's rows, so its report names classes and columns, never row numbers.
fixes:row.authority.remote?target.fixes.map(f=>({...f,row:null})):target.fixes,writer:row.principal_kind,path:snapshot.page.source_path ?? null,remote:row.authority.remote})}:{})};
}};
}