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

@@ -0,0 +1,45 @@
import { EditorialExecutionService } from './editorial-execution';
import { createHash, randomUUID } from 'crypto';
const sha=(x:string)=>createHash('sha256').update(x).digest('hex');
describe('completed same-run recovery admission',()=>{
let s:EditorialExecutionService,tx:any,t:any,o:any,r:any,evidence:any,d:any;
const reviewer={id:'independent',role:'SUPER_ADMIN'};
beforeEach(()=>{
t={id:randomUUID(),state:'RUNNING',version:6,metadata:{commitSha:'a'.repeat(40)}};
r={id:randomUUID(),taskId:t.id,status:'RUNNING',environment:'staging',commitSha:t.metadata.commitSha};
o={id:randomUUID(),runId:r.id,status:'PENDING',leaseOwner:'pmo',leaseUntil:new Date(Date.now()-1000),reservationId:'reserve',leaseToken:randomUUID()};
const brief={researchDate:'2026-10-24',inputAvailability:[{input:'Analytics',status:'UNAVAILABLE',details:'Not provided'}],findings:[{sourceUrl:'https://canina.de/a',sourceDate:'2026-10-24',finding:'Stored report'}],candidates:['A','B','C'].map(title=>({title,score:50,rationale:'Stored report',sourceUrls:['https://canina.de/a']}))};
const sessions=['20261024_164035_8d20ed','20261024_164323_5b66bf','20261024_164531_02c075','20261024_164737_96755a'];
evidence={taskId:t.id,runId:r.id,expectedVersion:6,commitSha:r.commitSha,originalText:JSON.stringify(brief),sessions:sessions.map((sessionId,i)=>({profile:['canina-competitor-worker','canina-content-worker','canina-seo-worker','pmo'][i],sessionId,outputSha256:sha(i===3?JSON.stringify(brief):'stored report'),outcome:'COMPLETED'})),outputs:[{retrievalEvents:[{type:'tool_use',name:'web_extract',tool_call_id:'1',input:{urls:['https://canina.de/a']}},{type:'tool_result',name:'web_extract',tool_call_id:'1',is_error:false,output:JSON.stringify({results:[{url:'https://canina.de/a',content:'Stored report'}]})}]}],brief,correction:{mode:'STORED_REPORTS_ONLY',statusChanges:[],omissions:[],reason:'No new research; original preserved'}};
d={expectedVersion:6,runId:r.id,evidenceSha256:sha(JSON.stringify(evidence)),evidence};
tx={$queryRaw:async()=>[],orchestrationArtifact:{count:async()=>0,create:jest.fn(async({data}:any)=>data),findFirst:async()=>({metadata:{bytes:JSON.stringify(evidence)}})},orchestrationRun:{findUnique:async()=>r,update:jest.fn()},prepareWorkflowOutbox:{findUnique:async()=>o,update:jest.fn()},orchestrationTask:{update:jest.fn(async()=>({...t,state:'VERIFYING',version:7}))},orchestrationBudgetLedger:{findUnique:async()=>({taskId:t.id,actorId:'pmo',kind:'RESERVE',amountCents:20,idempotencyKey:'prepare-reserve:'+r.id}),aggregate:async()=>({_sum:{amountCents:20}}),findFirst:async()=>null},orchestrationEvent:{create:jest.fn()}};
s=new EditorialExecutionService({$transaction:async(fn:any)=>fn(tx)} as any);jest.spyOn(s as any,'scope').mockResolvedValue(t);jest.spyOn(s as any,'approval').mockResolvedValue(undefined);
});
it('stores original evidence and unreviewed artifact without lease renewal or cost writes',async()=>{
await expect((s as any).recoverCompleted(reviewer,t.id,d)).resolves.toMatchObject({state:'VERIFYING',qaStatus:'PENDING_INDEPENDENT_QA',retainedReservationCents:20});
expect(tx.orchestrationArtifact.create).toHaveBeenCalledTimes(2);
expect(tx.orchestrationArtifact.create.mock.calls[0][0].data.metadata.bytes).toBe(JSON.stringify(evidence));
expect(tx.prepareWorkflowOutbox.update.mock.calls[0][0].data.leaseToken).toBeNull();
});
it.each(['actor','version','hash','run','lease','cancel','artifact','source','evidenceBinding','session','approval','kill','storedHash','rewrite','omission'])('rejects %s before writes',async(mode)=>{
let a=reviewer;
if(mode==='actor')a={id:'pmo',role:'WORKFLOW_WORKER'};
if(mode==='version')d.expectedVersion=5;
if(mode==='hash')d.evidenceSha256='0'.repeat(64);
if(mode==='run')r.taskId=randomUUID();
if(mode==='lease')o.leaseUntil=new Date(Date.now()+60000);
if(mode==='cancel')t.state='CANCELLED';
if(mode==='artifact')tx.orchestrationArtifact.count=async()=>1;
if(mode==='source')evidence.brief.findings[0].sourceUrl='https://canina.de/search-only';
if(mode==='evidenceBinding')evidence.taskId=randomUUID();
if(mode==='session')evidence.sessions[0].outcome='RUNNING';
if(mode==='approval')jest.spyOn(s as any,'approval').mockRejectedValue(new Error('expired approval'));
if(mode==='kill')tx.$queryRaw=async()=>[{active:true,level:'STOP_AGENTS'}];
if(mode==='storedHash')tx.orchestrationArtifact.findFirst=async()=>({metadata:{bytes:'changed'}});
if(mode==='rewrite')evidence.brief.candidates[0].rationale='Changed meaning';
if(mode==='omission')evidence.brief.candidates.pop();
if(mode!=='hash')d.evidenceSha256=sha(JSON.stringify(evidence));
await expect((s as any).recoverCompleted(a,t.id,d)).rejects.toThrow();if(mode!=='storedHash')expect(tx.orchestrationArtifact.create).not.toHaveBeenCalled();
else expect(tx.orchestrationArtifact.create).toHaveBeenCalledTimes(1);
});
});
@@ -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);
@@ -1,3 +1,4 @@
import { EditorialExecutionService, CompletedRecoveryDto } from '../orchestration-worker/editorial-execution';
import {
Controller,
Body,
@@ -95,6 +96,7 @@ export class OrchestrationController {
constructor(
private readonly service: OrchestrationService,
@Optional() private readonly workflow?: PrepareWorkflowService,
@Optional() private readonly editorialExecution?: EditorialExecutionService,
) {}
private actor(req: any): WorkflowIdentity {
const id = req?.user?.id ?? req?.user?.sub;
@@ -219,6 +221,14 @@ export class OrchestrationController {
req,
);
}
@Post('tasks/:id/editorial-completed-recovery') async completedRecovery(
@Param('id') id: string,
@Body(workflowValidation) dto: CompletedRecoveryDto,
@Req() req: any,
) {
if (!this.workflow || !this.editorialExecution) return this.deny();
return this.editorialExecution.recoverCompleted(this.actor(req), id, dto);
}
@Post('tasks/:id/editorial-failure') async editorialFailure(
@Param('id') id: string,
@Body(workflowValidation) dto: EditorialFailureDto,
@@ -1,3 +1,4 @@
import { EditorialExecutionService } from '../orchestration-worker/editorial-execution';
import {
PrepareWorkflowService,
PREPARE_WORKFLOW_CONFIG,
@@ -13,6 +14,7 @@ import { OrchestrationService } from './orchestration.service';
imports: [PrismaModule],
controllers: [OrchestrationController],
providers: [
EditorialExecutionService,
OrchestrationService,
KillSwitchService,
ModelTierPolicyService,