fix(editorial): constrain synthesis contract and admit fenced completed-run recovery

This commit is contained in:
devops authored and devops committed 2026-10-24 17:35:42 +00:00
1 parent c8063b5f2a
commit 65063e224a
8 files changed
+696 -2

No files matched your search

@@ -4,7 +4,7 @@ import {
Injectable,
NotFoundException,
} from '@nestjs/common';
import { IsInt, Min, IsNotEmpty, IsString, IsObject, IsUUID } from 'class-validator';
import { IsInt, Min, IsNotEmpty, IsString, IsObject, IsUUID, Matches } from 'class-validator';
import { createHash } from 'crypto';
import {
PrepareWorkflowService,
@@ -25,6 +25,12 @@ export class EditorialResultDto extends EditorialClaimDto {
@IsUUID() leaseToken!: string;
@IsObject() brief!: Record<string, unknown>;
}
export class CompletedRecoveryDto {
@IsUUID() runId!: string;
@IsInt() @Min(1) expectedVersion!: number;
@Matches(/^[a-f0-9]{64}$/) evidenceSha256!: string;
@IsObject() evidence!: Record<string, unknown>;
}
const suffix =
'\nResearch and evidence-backed brief only. No publication, release, production changes or execution authorization.';
export function admittedEditorialTask(t: any): boolean {
@@ -312,6 +318,105 @@ export class EditorialExecutionService {
};
});
}
async recoverCompleted(a: WorkflowIdentity, taskId: string, dto: CompletedRecoveryDto) {
if (a?.role !== 'SUPER_ADMIN' || !a.id || a.id === 'pmo')
throw new ForbiddenException('Independent Stage reviewer required');
const e: any = dto.evidence;
const evidenceBytes = JSON.stringify(e);
const digest = (s: string) => createHash('sha256').update(s).digest('hex');
if (Buffer.byteLength(evidenceBytes) > 262144 || digest(evidenceBytes) !== dto.evidenceSha256 ||
e?.taskId !== taskId || e.runId !== dto.runId || e.expectedVersion !== dto.expectedVersion ||
typeof e.originalText !== 'string' || !Array.isArray(e.sessions) || e.sessions.length !== 4 ||
!Array.isArray(e.outputs) || e.correction?.mode !== 'STORED_REPORTS_ONLY' ||
!Array.isArray(e.correction.statusChanges) || !Array.isArray(e.correction.omissions) ||
!text(e.correction.reason, 1000)) throw new BadRequestException('Bounded exact stored evidence required');
const profiles = ['canina-competitor-worker','canina-content-worker','canina-seo-worker','pmo'];
if (e.sessions.some((s: any, i: number) => s.profile !== profiles[i] ||
!/^\d{8}_\d{6}_[a-f0-9]{6}$/.test(s.sessionId) || s.outcome !== 'COMPLETED' ||
!/^[a-f0-9]{64}$/.test(s.outputSha256)) ||
e.sessions[3].outputSha256 !== digest(e.originalText))
throw new BadRequestException('Four immutable completed session bindings required');
const brief = validateEditorialBrief(e.brief);
let original: any;
try { original = JSON.parse(e.originalText); } catch { throw new BadRequestException('Original JSON required'); }
const same = (x: any, y: any) => JSON.stringify(x) === JSON.stringify(y);
if (!Array.isArray(original.inputAvailability) || !Array.isArray(original.findings) || !Array.isArray(original.candidates) ||
original.researchDate !== brief.researchDate || original.inputAvailability.length !== brief.inputAvailability.length)
throw new BadRequestException('Original meaning and dates must be preserved');
for (let i=0;i<brief.inputAvailability.length;i++) {
const before=original.inputAvailability[i], after=brief.inputAvailability[i];
if (before.input !== after.input || before.details !== after.details) throw new BadRequestException('Availability text must be preserved');
const changes=e.correction.statusChanges.filter((x:any)=>x.index===i);
if (before.status !== after.status && (changes.length!==1 || changes[0].from!==before.status || changes[0].to!==after.status ||
!text(changes[0].reason,1000))) throw new BadRequestException('Explicit grounded status correction required');
}
for (const collection of ['findings','candidates']) {
if (!brief[collection].every((x:any)=>original[collection].some((y:any)=>same(x,y))))
throw new BadRequestException('No rewritten findings, candidates or source lists');
for (let i=0;i<original[collection].length;i++) if (!brief[collection].some((x:any)=>same(x,original[collection][i])) &&
!e.correction.omissions.some((x:any)=>x.collection===collection && x.index===i && text(x.reason,1000)))
throw new BadRequestException('Explicit omission metadata required');
}
const retrieved = new Set<string>();
for (const output of e.outputs) {
const pending: any[] = [];
if (!Array.isArray(output.retrievalEvents)) throw new BadRequestException('Retrieval events required');
for (const event of output.retrievalEvents) {
if (event.type === 'tool_use' && event.name === 'web_extract') pending.push(event);
if (event.type !== 'tool_result' || event.name !== 'web_extract') continue;
const index = pending.findIndex(x => x.tool_call_id === event.tool_call_id);
if (index < 0) continue;
const use = pending.splice(index, 1)[0];
if (event.is_error || typeof event.output !== 'string') continue;
let entries: any;
try { entries = JSON.parse(event.output).results; } catch { continue; }
if (Array.isArray(entries) && Array.isArray(use.input?.urls))
for (const x of entries) if (use.input.urls.includes(x?.url) && !x.error &&
typeof x.content === 'string' && x.content.trim()) retrieved.add(x.url);
}
}
if (brief.findings.some((x: any) => !retrieved.has(x.sourceUrl)))
throw new BadRequestException('Finding lacks matched successful worker extraction');
return this.db.$transaction(async (tx: any) => {
const t = await this.lock(tx, taskId);
const o = await tx.prepareWorkflowOutbox.findUnique({where:{taskId}});
const r = await tx.orchestrationRun.findUnique({where:{id:dto.runId}});
if (t.state !== 'RUNNING' || t.version !== dto.expectedVersion || e.commitSha !== t.metadata.commitSha ||
!o || o.status !== 'PENDING' || o.leaseOwner !== 'pmo' || o.runId !== dto.runId ||
!o.leaseUntil || o.leaseUntil > new Date() || !r || r.taskId !== taskId ||
r.status !== 'RUNNING' || r.environment !== 'staging' || r.commitSha !== e.commitSha ||
await tx.orchestrationArtifact.count({where:{run:{taskId}}}))
throw new ForbiddenException('Exact expired artifact-free same run required');
const reserve = await tx.orchestrationBudgetLedger.findUnique({where:{id:o.reservationId}});
const ledger = await tx.orchestrationBudgetLedger.aggregate({where:{taskId},_sum:{amountCents:true}});
if (!reserve || reserve.taskId !== taskId || reserve.actorId !== 'pmo' || reserve.kind !== 'RESERVE' ||
reserve.amountCents !== 20 || reserve.idempotencyKey !== `prepare-reserve:${r.id}` ||
ledger._sum.amountCents !== 20 || await tx.orchestrationBudgetLedger.findFirst({where:{taskId,kind:'RECONCILE'}}))
throw new ForbiddenException('Existing unreconciled reservation required');
await tx.orchestrationArtifact.create({data:{runId:r.id,kind:'EDITORIAL_RECOVERY_EVIDENCE',sha256:dto.evidenceSha256,
uri:`urn:canina:editorial-recovery:sha256:${dto.evidenceSha256}`,sizeBytes:Buffer.byteLength(evidenceBytes),
metadata:{bytes:evidenceBytes,originalOutputSha256:digest(e.originalText),reviewerId:a.id,qaStatus}}});
const stored = await tx.orchestrationArtifact.findFirst({where:{runId:r.id,kind:'EDITORIAL_RECOVERY_EVIDENCE',sha256:dto.evidenceSha256}});
if (!stored || stored.metadata?.bytes !== evidenceBytes || digest(stored.metadata.bytes) !== dto.evidenceSha256)
throw new ForbiddenException('Stored canonical evidence hash required');
const bytes = JSON.stringify({kind,pilotKind:EDITORIAL_PILOT_KIND,schemaVersion:1,taskId,runId:r.id,
commitSha:r.commitSha,environment:'staging',qaStatus,costStatus:'upper-bound-reserved',brief,
recoveryEvidenceSha256:dto.evidenceSha256});
const hash = digest(bytes);
await tx.orchestrationArtifact.create({data:{runId:r.id,kind,sha256:hash,uri:`urn:canina:editorial-brief:sha256:${hash}`,
sizeBytes:Buffer.byteLength(bytes),metadata:{bytes,qaStatus,costStatus:'upper-bound-reserved'}}});
await tx.orchestrationRun.update({where:{id:r.id},data:{status:'AWAITING_QA',finishedAt:new Date()}});
await tx.prepareWorkflowOutbox.update({where:{id:o.id},data:{status:'DONE',leaseToken:null,leaseUntil:null}});
const updated = await tx.orchestrationTask.update({where:{id:taskId},data:{state:'VERIFYING',version:{increment:1}}});
await tx.orchestrationEvent.create({data:{taskId,sequence:updated.version,actorId:a.id,eventType:'EDITORIAL_COMPLETED_RUN_RECOVERED',
fromState:'RUNNING',toState:'VERIFYING',idempotencyKey:`editorial-recovery:${r.id}`,
payload:{artifactSha256:hash,evidenceSha256:dto.evidenceSha256,originalOutputSha256:digest(e.originalText),qaStatus,
retainedReservationCents:20,costStatus:'upper-bound-reserved',newResearch:false}}});
return {taskId,runId:r.id,state:updated.state,artifactSha256:hash,qaStatus,retainedReservationCents:20,costStatus:'upper-bound-reserved'};
});
}
async result(a: WorkflowIdentity, dto: EditorialResultDto) {
this.pmo(a);
const brief = validateEditorialBrief(dto.brief);