From 9cb503d85b2744d3b99b1a8ddc9d295654b54e6f Mon Sep 17 00:00:00 2001 From: devops Date: Sat, 24 Oct 2026 04:03:46 +0000 Subject: [PATCH] Add bounded approved editorial brief ingestion pending independent QA --- .../editorial-execution.md | 31 ++ .../editorial-execution.spec.ts | 387 +++++++++++++++++ .../editorial-execution.ts | 409 ++++++++++++++++++ .../worker-transport.module.ts | 13 +- 4 files changed, 839 insertions(+), 1 deletion(-) create mode 100644 backend/src/orchestration-worker/editorial-execution.md create mode 100644 backend/src/orchestration-worker/editorial-execution.spec.ts create mode 100644 backend/src/orchestration-worker/editorial-execution.ts diff --git a/backend/src/orchestration-worker/editorial-execution.md b/backend/src/orchestration-worker/editorial-execution.md new file mode 100644 index 00000000..9991a426 --- /dev/null +++ b/backend/src/orchestration-worker/editorial-execution.md @@ -0,0 +1,31 @@ +# Bounded editorial approved-run contract + +Only the explicitly configured WORKFLOW_WORKER grant `pmo` may use these routes under `/api/internal/prepare-worker` (the application's prefix supplies `/api`). No new credential or reviewer grant is provisioned here. + +- `GET editorial-proposals/:taskId`: exact bridge-created proposal status and, after ingestion, canonical immutable brief bytes/digest. No lease token, raw events, reviewer identities or arbitrary task projection. +- `POST editorial-claim`: `{ "taskId": "" }`. Requires exact bridge key/title/scope/metadata plus original PMO creation/submission events, READY/RUNNING, latest independent unexpired approved Gate1, no blocking kill switch. Core claim runs inside the same admission/task-lock transaction, preserving reservations, ownership and 30-second leases. Competing claim returns null lease. Expired attempts retain unknown reservation; a 20-cent task cannot reserve a second 20 cents. +- `POST heartbeat`: existing `{taskId,runId,leaseToken}` while working. Extends lease by 30 seconds. Result rechecks Gate1 independently; heartbeat is not approval extension. +- `POST editorial-result`: `{taskId,runId,leaseToken,brief}`. No cost, QA pass, role, URI or caller identity fields accepted. + +`brief` has exactly: + +```json +{ + "researchDate": "YYYY-MM-DD", + "inputAvailability": [{"input":"input name","status":"AVAILABLE|UNAVAILABLE|PARTIAL","details":"availability explanation"}], + "findings": [{"sourceUrl":"https://public-source.example.org/path","sourceDate":"YYYY-MM-DD","finding":"source-backed finding"}], + "candidates": [ + {"title":"Distinct candidate A","score":80,"rationale":"Reason","sourceUrls":["https://public-source.example.org/path"]}, + {"title":"Distinct candidate B","score":70,"rationale":"Reason","sourceUrls":["https://public-source.example.org/path"]}, + {"title":"Distinct candidate C","score":60,"rationale":"Reason","sourceUrls":["https://public-source.example.org/path"]} + ] +} +``` + +Limits: canonical brief UTF-8 <=24,576 bytes; 1..10 inputs (name 120/details 500 characters); 1..20 findings (HTTPS DNS URL 2000/finding 1000 characters); 3..10 unique candidates (title 180/rationale 1000, integer score 0..100, 1..10 source references all in findings). Dates must be valid calendar dates, not future; source dates cannot exceed research date. Unknown nested keys rejected. Example URLs above illustrate shape only, not real research evidence. + +Canonical artifact kind `EDITORIAL_RESEARCH_BRIEF` is stored in append-only artifact metadata with SHA-256 and a URN; authenticated status retrieves actual bytes. No filesystem/external URL persistence dependency. Transaction atomically checks task/approval/lease/run/reservation, inserts evidence/event, closes outbox and moves task to VERIFYING. Run is AWAITING_QA, quality PENDING_INDEPENDENT_QA; no attestation, success, publication, Gate2 or release authorization is created. Unknown cost retains RESERVE 20 without RECONCILE. Replay after lease closure is rejected, not silently overwritten. + +Validation checks structure/source references, not source truth, retrieval, novelty, scoring quality, SEO value or factuality. No research/article/LLM execution is performed by this contract. Independent QA ingestion is deliberately not implemented; generic tracer/tech and Stage evidence cannot certify this evidence. + +Verification: disposable Node22 + PostgreSQL16, source/dependency donors read-only and privately copied, generated Prisma client. New suite observed RED (missing routes) then GREEN. Final combined bridge/execution/tech/transport suites: 22/22; `npm run build`: exit 0. Full historical migrations fail on fresh database because pre-existing blog migration expects missing blogs table; final tests instead applied only real orchestration core, immutable-ledger and outbox migrations directly to empty disposable DB, including append-only triggers. No live database, proposal approval, cron, deployment or publication used. diff --git a/backend/src/orchestration-worker/editorial-execution.spec.ts b/backend/src/orchestration-worker/editorial-execution.spec.ts new file mode 100644 index 00000000..e2fa6e59 --- /dev/null +++ b/backend/src/orchestration-worker/editorial-execution.spec.ts @@ -0,0 +1,387 @@ +import { Test } from '@nestjs/testing'; +import { INestApplication } from '@nestjs/common'; +import { PrismaClient } from '@prisma/client'; +import { createHash, randomUUID } from 'crypto'; +import { PrismaService } from '../prisma/prisma.service'; +import { PrepareWorkflowService } from '../orchestration/prepare-workflow.service'; +import { WorkerTransportModule, tracerReport } from './worker-transport.module'; + +(process.env.EDITORIAL_EXECUTION_DB === '1' ? describe : describe.skip)( + 'editorial approved-run real TCP/PostgreSQL', + () => { + const db = new PrismaClient(); + const token = 'disposable-editorial-pmo-'.repeat(3), + other = 'disposable-other-editor-'.repeat(3), + ci = 'disposable-editorial-ci-'.repeat(3); + const sha = (s: string) => createHash('sha256').update(s).digest('hex'); + let app: INestApplication, base: string, workflow: PrepareWorkflowService; + const brief = () => ({ + researchDate: '2026-10-24', + inputAvailability: [ + { + input: 'search console', + status: 'UNAVAILABLE', + details: 'No authenticated property supplied', + }, + ], + findings: [ + { + sourceUrl: 'https://www.who.int/news', + sourceDate: '2026-10-20', + finding: 'Fixture finding for contract testing, not real research', + }, + ], + candidates: [0, 1, 2].map((i) => ({ + title: 'Fixture candidate ' + i, + score: 80 - i, + rationale: 'Contract fixture only', + sourceUrls: ['https://www.who.int/news'], + })), + }); + beforeAll(async () => { + const m = await Test.createTestingModule({ + imports: [ + WorkerTransportModule.register({ + enabled: true, + grants: [ + { + id: 'pmo', + role: 'WORKFLOW_WORKER', + credentialSha256: sha(token), + }, + { + id: 'other', + role: 'WORKFLOW_WORKER', + credentialSha256: sha(other), + }, + { id: 'ci', role: 'STAGE_CI', credentialSha256: sha(ci) }, + ], + workerIds: ['pmo', 'other'], + stageCiIds: ['ci'], + artifactDirectory: '/work/tmp/editorial-execution', + artifactBaseUrl: + 'https://isolated.invalid/internal/prepare-worker/artifacts', + }), + ], + }) + .overrideProvider(PrismaService) + .useValue(db) + .compile(); + app = m.createNestApplication(); + await app.listen(0, '127.0.0.1'); + base = await app.getUrl(); + workflow = app.get(PrepareWorkflowService); + }); + afterAll(async () => { + await app?.close(); + await db.$disconnect(); + }); + async function request(route: string, body?: any, secret = token) { + const r = await fetch(base + '/internal/prepare-worker/' + route, { + method: body === undefined ? 'GET' : 'POST', + headers: { + authorization: 'Bearer ' + secret, + 'content-type': 'application/json', + }, + ...(body === undefined ? {} : { body: JSON.stringify(body) }), + }); + return { status: r.status, body: await r.json() }; + } + async function proposal(ready = true, ttl = 60000) { + const r = await request('editorial-proposals', { + requestId: randomUUID(), + pilotKind: 'editorial-research-to-brief-v1', + operationMode: 'PREPARE', + environment: 'staging', + scope: 'EDITORIAL_RESEARCH_TO_BRIEF', + researchTopic: 'Disposable research contract', + acceptanceCriteria: ['Evidence with dates'], + commitSha: 'a'.repeat(40), + budgetLimitCents: 20, + }); + expect(r.status).toBe(201); + let t = await db.orchestrationTask.findUniqueOrThrow({ + where: { id: r.body.taskId }, + }); + if (ready) { + t = await workflow.decide( + t.id, + 1, + { + decision: 'APPROVED', + expiresAt: new Date(Date.now() + ttl).toISOString(), + expectedVersion: t.version, + idempotencyKey: randomUUID(), + }, + { id: 'independent-disposable-reviewer', role: 'SUPER_ADMIN' }, + ); + t = await workflow.transition( + t.id, + { + toState: 'READY', + expectedVersion: t.version, + idempotencyKey: randomUUID(), + }, + { id: 'pmo', role: 'Admin' }, + ); + } + return t; + } + async function lease(ttl = 60000) { + const t = await proposal(true, ttl); + const r = await request('editorial-claim', { taskId: t.id }); + expect(r.status).toBe(201); + expect(r.body.lease).toBeTruthy(); + const l = r.body.lease; + return { + t, + l, + b: { taskId: t.id, runId: l.runId, leaseToken: l.leaseToken }, + }; + } + it('projects only owned exact proposals and refuses pending dispatch', async () => { + const t = await proposal(false); + const p = await request('editorial-proposals/' + t.id); + expect(p.status).toBe(200); + expect(p.body).toMatchObject({ + taskId: t.id, + state: 'GATE1_PENDING', + qaStatus: 'PENDING_INDEPENDENT_QA', + }); + expect(JSON.stringify(p.body)).not.toMatch( + /leaseToken|credential|createdBy|fingerprint/, + ); + expect((await request('editorial-claim', { taskId: t.id })).status).toBe( + 403, + ); + expect( + (await request('editorial-proposals/' + t.id, undefined, other)).status, + ).toBe(403); + expect( + (await request('editorial-proposals/' + randomUUID())).status, + ).toBe(404); + }); + it('races claims, ingests immutable bounded brief, never self-attests QA or reconciles unknown cost', async () => { + const t = await proposal(); + const claims = await Promise.all([ + request('editorial-claim', { taskId: t.id }), + request('editorial-claim', { taskId: t.id }), + ]); + const leases = claims.filter((x) => x.body.lease); + expect(leases).toHaveLength(1); + const l = leases[0].body.lease, + b = { taskId: t.id, runId: l.runId, leaseToken: l.leaseToken }; + expect((await request('heartbeat', b)).status).toBe(201); + expect((await request('claim', { taskId: t.id })).status).toBe(403); + expect((await request('tech-claim', { taskId: t.id })).status).toBe(403); + expect( + (await request('complete', { ...b, report: tracerReport(l) })).status, + ).toBe(403); + const r = await request('editorial-result', { ...b, brief: brief() }); + expect(r.status).toBe(201); + expect(r.body).toMatchObject({ + state: 'VERIFYING', + qaStatus: 'PENDING_INDEPENDENT_QA', + retainedReservationCents: 20, + }); + const p = await request('editorial-proposals/' + t.id); + expect(p.body.artifact.brief).toEqual(brief()); + expect(sha(p.body.artifact.bytes)).toBe(r.body.artifactSha256); + await expect( + db.orchestrationArtifact.updateMany({ + where: { runId: l.runId }, + data: { metadata: { bytes: 'tampered' } }, + }), + ).rejects.toThrow('append-only'); + expect(JSON.parse(p.body.artifact.bytes)).toMatchObject({ + taskId: t.id, + runId: l.runId, + brief: brief(), + }); + expect( + await db.orchestrationAttestation.count({ where: { runId: l.runId } }), + ).toBe(0); + expect( + ( + await db.orchestrationRun.findUniqueOrThrow({ + where: { id: l.runId }, + }) + ).status, + ).toBe('AWAITING_QA'); + expect( + ( + await db.orchestrationBudgetLedger.findMany({ + where: { taskId: t.id }, + }) + ).map((x) => [x.kind, x.amountCents]), + ).toEqual([['RESERVE', 20]]); + expect( + (await request('editorial-result', { ...b, brief: brief() })).status, + ).toBe(403); + expect( + ( + await request( + 'stage-evidence', + { + taskId: t.id, + runId: l.runId, + commitSha: l.commitSha, + sha256: r.body.artifactSha256, + evidenceSha256: 'b'.repeat(64), + uri: 'https://isolated.invalid/fixture', + }, + ci, + ) + ).status, + ).toBe(403); + }); + it('rejects impersonation, unsafe or incomplete briefs, and expired ownership without artifacts', async () => { + const { l, b } = await lease(); + for (const secret of [other, ci]) + expect( + (await request('editorial-result', { ...b, brief: brief() }, secret)) + .status, + ).toBe(403); + for (const patch of [ + { actualCents: 0 }, + { qa: { passed: true } }, + { actorId: 'pmo' }, + ]) + expect( + ( + await request('editorial-result', { + ...b, + brief: brief(), + ...patch, + }) + ).status, + ).toBe(400); + for (const bad of [ + { ...brief(), candidates: brief().candidates.slice(0, 2) }, + { ...brief(), researchDate: '2026-02-30' }, + { + ...brief(), + findings: [ + { + sourceUrl: 'http://127.0.0.1', + sourceDate: '2026-10-20', + finding: 'x', + }, + ], + }, + { ...brief(), inputAvailability: [] }, + { + ...brief(), + candidates: brief().candidates.map((c) => ({ ...c, score: 101 })), + }, + { ...brief(), article: 'not allowed' }, + ]) + expect( + (await request('editorial-result', { ...b, brief: bad })).status, + ).toBe(400); + expect( + ( + await request('editorial-result', { + ...b, + leaseToken: randomUUID(), + brief: brief(), + }) + ).status, + ).toBe(403); + await db.prepareWorkflowOutbox.update({ + where: { taskId: b.taskId }, + data: { leaseUntil: new Date(Date.now() - 1000) }, + }); + expect( + (await request('editorial-result', { ...b, brief: brief() })).status, + ).toBe(403); + expect( + (await request('editorial-claim', { taskId: b.taskId })).status, + ).toBe(403); + expect( + await db.orchestrationArtifact.count({ where: { runId: l.runId } }), + ).toBe(0); + expect( + await db.orchestrationBudgetLedger.count({ + where: { taskId: b.taskId }, + }), + ).toBe(1); + }); + it('enforces cancellation, approval expiry and kill switch inside ingestion', async () => { + for (const mode of ['cancel', 'approval', 'kill']) { + const { l, b } = await lease(mode === 'approval' ? 1500 : 60000); + if (mode === 'cancel') + await db.orchestrationTask.update({ + where: { id: b.taskId }, + data: { state: 'CANCELLED' }, + }); + if (mode === 'approval') + await new Promise((resolve) => setTimeout(resolve, 1600)); + if (mode === 'kill') + await db.orchestrationKillSwitch.upsert({ + where: { scope: 'GLOBAL' }, + create: { + scope: 'GLOBAL', + level: 'STOP_AGENTS', + active: true, + reason: 'disposable execution test', + actorId: 'fixture', + }, + update: { level: 'STOP_AGENTS', active: true }, + }); + try { + expect( + (await request('editorial-result', { ...b, brief: brief() })) + .status, + ).toBe(403); + expect( + await db.orchestrationArtifact.count({ where: { runId: l.runId } }), + ).toBe(0); + } finally { + if (mode === 'kill') + await db.orchestrationKillSwitch.update({ + where: { scope: 'GLOBAL' }, + data: { active: false }, + }); + } + } + }); + it('rejects arbitrary CONTENT tasks and forged stored scope/provenance', async () => { + const raw = await workflow.create( + { + key: 'arbitrary-' + randomUUID(), + title: 'arbitrary', + department: 'CONTENT', + operationMode: 'PREPARE', + budgetLimitCents: 20, + metadata: { + scope: 'editorial-research-to-brief-v1', + commitSha: 'a'.repeat(40), + acceptanceCriteria: ['x'], + }, + }, + { id: 'pmo', role: 'Admin' }, + ); + expect((await request('editorial-proposals/' + raw.id)).status).toBe(404); + expect( + (await request('editorial-claim', { taskId: raw.id })).status, + ).toBe(404); + const t = await proposal(); + await db.orchestrationTask.update({ + where: { id: t.id }, + data: { + metadata: { + ...(t.metadata as any), + scope: 'editorial-research-to-brief-v1\nforged', + }, + }, + }); + expect((await request('editorial-claim', { taskId: t.id })).status).toBe( + 404, + ); + expect(await db.orchestrationRun.count({ where: { taskId: t.id } })).toBe( + 0, + ); + }); + }, +); diff --git a/backend/src/orchestration-worker/editorial-execution.ts b/backend/src/orchestration-worker/editorial-execution.ts new file mode 100644 index 00000000..24f97375 --- /dev/null +++ b/backend/src/orchestration-worker/editorial-execution.ts @@ -0,0 +1,409 @@ +import { + BadRequestException, + ForbiddenException, + Injectable, + NotFoundException, +} from '@nestjs/common'; +import { IsObject, IsUUID } from 'class-validator'; +import { createHash } from 'crypto'; +import { + PrepareWorkflowService, + WorkflowIdentity, +} from '../orchestration/prepare-workflow.service'; +import { PrismaService } from '../prisma/prisma.service'; +import { EDITORIAL_PILOT_KIND } from './editorial-bridge'; + +export class EditorialClaimDto { + @IsUUID() taskId!: string; +} +export class EditorialResultDto extends EditorialClaimDto { + @IsUUID() runId!: string; + @IsUUID() leaseToken!: string; + @IsObject() brief!: Record; +} +const suffix = + '\nResearch and evidence-backed brief only. No publication, release, production changes or execution authorization.'; +export function admittedEditorialTask(t: any): boolean { + const m = t?.metadata; + const topic = + typeof t?.title === 'string' && t.title.startsWith('Editorial research: ') + ? t.title.slice(20) + : ''; + return !!( + t && + /^editorial-v1:[a-f0-9]{64}$/.test(t.key) && + t.department === 'CONTENT' && + t.operationMode === 'PREPARE' && + t.budgetLimitCents === 20 && + m?.createdBy === 'pmo' && + m.workflowScope === 'STAGE_PREPARE' && + m.environment === 'staging' && + typeof m.commitSha === 'string' && + /^[a-f0-9]{40}$/.test(m.commitSha) && + topic.trim() && + topic.length <= 180 && + m.scope === `${EDITORIAL_PILOT_KIND}\nTopic: ${topic}${suffix}` && + Array.isArray(m.acceptanceCriteria) && + m.acceptanceCriteria.length >= 1 && + m.acceptanceCriteria.length <= 10 && + m.acceptanceCriteria.every( + (x: unknown) => typeof x === 'string' && x.trim() && x.length <= 500, + ) + ); +} +function keys(v: any, names: string[]) { + return ( + v && + typeof v === 'object' && + !Array.isArray(v) && + Object.keys(v).length === names.length && + names.every((k) => Object.prototype.hasOwnProperty.call(v, k)) + ); +} +function text(v: any, max: number) { + return typeof v === 'string' && !!v.trim() && v.length <= max; +} +function date(v: any) { + return ( + typeof v === 'string' && + /^\d{4}-\d{2}-\d{2}$/.test(v) && + Number.isFinite(Date.parse(v)) && + new Date(v).toISOString().slice(0, 10) === v && + v <= new Date().toISOString().slice(0, 10) + ); +} +function source(v: any) { + try { + if (!text(v, 2000)) return false; + const u = new URL(v); + return ( + u.protocol === 'https:' && + !u.username && + !u.password && + !u.port && + /^[a-z0-9.-]+\.[a-z]{2,}$/.test(u.hostname) && + !/(^|\.)(localhost|local|internal|lan|home|invalid|test|example)$/.test( + u.hostname, + ) + ); + } catch { + return false; + } +} +export function validateEditorialBrief(b: any) { + const fail = () => { + throw new BadRequestException( + 'Bounded research brief requires dated sources, input availability and 3..10 scored candidates', + ); + }; + if ( + !keys(b, ['researchDate', 'inputAvailability', 'findings', 'candidates']) || + Buffer.byteLength(JSON.stringify(b), 'utf8') > 24576 || + !date(b.researchDate) + ) + fail(); + if ( + !Array.isArray(b.inputAvailability) || + b.inputAvailability.length < 1 || + b.inputAvailability.length > 10 || + !b.inputAvailability.every( + (x: any) => + keys(x, ['input', 'status', 'details']) && + text(x.input, 120) && + ['AVAILABLE', 'UNAVAILABLE', 'PARTIAL'].includes(x.status) && + text(x.details, 500), + ) + ) + fail(); + if ( + !Array.isArray(b.findings) || + b.findings.length < 1 || + b.findings.length > 20 || + !b.findings.every( + (x: any) => + keys(x, ['sourceUrl', 'sourceDate', 'finding']) && + source(x.sourceUrl) && + date(x.sourceDate) && + x.sourceDate <= b.researchDate && + text(x.finding, 1000), + ) + ) + fail(); + const urls = new Set(b.findings.map((x: any) => x.sourceUrl)); + if ( + !Array.isArray(b.candidates) || + b.candidates.length < 3 || + b.candidates.length > 10 || + !b.candidates.every( + (x: any) => + keys(x, ['title', 'score', 'rationale', 'sourceUrls']) && + text(x.title, 180) && + Number.isInteger(x.score) && + x.score >= 0 && + x.score <= 100 && + text(x.rationale, 1000) && + Array.isArray(x.sourceUrls) && + x.sourceUrls.length >= 1 && + x.sourceUrls.length <= 10 && + x.sourceUrls.every((u: any) => urls.has(u)), + ) || + new Set(b.candidates.map((x: any) => x.title.trim().toLowerCase())).size !== + b.candidates.length + ) + fail(); + return JSON.parse(JSON.stringify(b)); +} +const kind = 'EDITORIAL_RESEARCH_BRIEF'; +const qaStatus = 'PENDING_INDEPENDENT_QA'; +@Injectable() +export class EditorialExecutionService { + constructor(private readonly db: PrismaService) {} + private pmo(a: WorkflowIdentity) { + if (a?.role !== 'WORKFLOW_WORKER' || a.id !== 'pmo') + throw new ForbiddenException( + 'Explicit canonical PMO worker grant required', + ); + } + private async scope(tx: any, id: string) { + if (typeof id !== 'string' || !/^[0-9a-f-]{36}$/i.test(id)) + throw new NotFoundException('Editorial proposal not found'); + const t = await tx.orchestrationTask.findUnique({ where: { id } }); + if (!admittedEditorialTask(t)) + throw new NotFoundException('Editorial proposal not found'); + const proposed = await tx.orchestrationEvent.findFirst({ + where: { + taskId: id, + sequence: 1, + eventType: 'PREPARE_PROPOSED', + actorId: 'pmo', + toState: 'DRAFT', + }, + }); + const submitted = await tx.orchestrationEvent.findFirst({ + where: { + taskId: id, + sequence: 2, + eventType: 'PREPARE_TRANSITION', + actorId: 'pmo', + fromState: 'DRAFT', + toState: 'GATE1_PENDING', + idempotencyKey: t.key + ':submit', + }, + }); + if (!proposed || !submitted) + throw new NotFoundException('Editorial proposal not found'); + return t; + } + private async approval(tx: any, t: any) { + const approval = await tx.orchestrationApprovalDecision.findFirst({ + where: { taskId: t.id, gate: 1 }, + orderBy: { createdAt: 'desc' }, + }); + if ( + !approval || + approval.decision !== 'APPROVED' || + approval.actorId === 'pmo' || + approval.expiresAt <= new Date() + ) + throw new ForbiddenException('Valid independent Gate1 required'); + } + private async lock(tx: any, id: string, claim = false) { + const switches = + await tx.$queryRaw`SELECT level, active FROM orchestration_kill_switches WHERE scope = 'GLOBAL' FOR SHARE`; + if ( + switches[0]?.active && + (claim || switches[0].level !== 'FREEZE_NEW_WORK') + ) + throw new ForbiddenException('Kill switch blocks workflow'); + await tx.$queryRaw`SELECT id FROM orchestration_tasks WHERE id = ${id}::uuid FOR UPDATE`; + const t = await this.scope(tx, id); + await this.approval(tx, t); + return t; + } + async status(a: WorkflowIdentity, id: string) { + this.pmo(a); + return this.db.$transaction(async (tx: any) => { + const t = await this.scope(tx, id); + const artifacts = await tx.orchestrationArtifact.findMany({ + where: { kind, run: { taskId: id } }, + orderBy: { createdAt: 'desc' }, + take: 1, + }); + const artifact = artifacts[0]; + let result: any = null; + if (artifact) { + const bytes = artifact.metadata?.bytes; + if ( + typeof bytes !== 'string' || + Buffer.byteLength(bytes) > 32768 || + createHash('sha256').update(bytes).digest('hex') !== artifact.sha256 + ) + throw new ForbiddenException('Artifact integrity mismatch'); + const parsed = JSON.parse(bytes); + if ( + parsed.taskId !== t.id || + parsed.runId !== artifact.runId || + parsed.commitSha !== t.metadata.commitSha + ) + throw new ForbiddenException('Artifact binding mismatch'); + result = { kind, sha256: artifact.sha256, bytes, brief: parsed.brief }; + } + return { + taskId: t.id, + pilotKind: EDITORIAL_PILOT_KIND, + state: t.state, + version: t.version, + operationMode: t.operationMode, + budgetLimitCents: 20, + qaStatus, + metadata: { + scope: t.metadata.scope, + acceptanceCriteria: t.metadata.acceptanceCriteria, + commitSha: t.metadata.commitSha, + environment: 'staging', + }, + artifact: result, + }; + }); + } + async claim(a: WorkflowIdentity, dto: EditorialClaimDto) { + this.pmo(a); + return this.db.$transaction(async (tx: any) => { + const t = await this.lock(tx, dto.taskId, true); + if (!['READY', 'RUNNING'].includes(t.state)) + throw new ForbiddenException('Ready editorial proposal required'); + // Reuse core claim/reservation/lease algorithm in THIS scoped transaction. No + // nested transaction or check-then-claim gap: task lock spans admission/claim. + const core = new PrepareWorkflowService( + new Proxy(tx, { + get(target, key) { + if (key === '$transaction') return (fn: any) => fn(tx); + const value = target[key]; + return typeof value === 'function' ? value.bind(target) : value; + }, + }), + { workerIds: ['pmo'], stageCiIds: [] }, + ); + const lease = await core.claim(a, t.id); + return { + lease: lease ? { ...lease, pilotKind: EDITORIAL_PILOT_KIND } : null, + }; + }); + } + async result(a: WorkflowIdentity, dto: EditorialResultDto) { + this.pmo(a); + const brief = validateEditorialBrief(dto.brief); + // Core complete writes a passed QA attestation and reconciles supplied costs. + // It is deliberately NOT reused for unreviewed research or unknown cost. + return this.db.$transaction(async (tx: any) => { + const t = await this.lock(tx, dto.taskId); + const o = await tx.prepareWorkflowOutbox.findUnique({ + where: { taskId: t.id }, + }); + const r = await tx.orchestrationRun.findUnique({ + where: { id: dto.runId }, + }); + if ( + t.state !== 'RUNNING' || + !o || + o.status !== 'PENDING' || + o.leaseOwner !== a.id || + o.leaseToken !== dto.leaseToken || + o.runId !== dto.runId || + !o.leaseUntil || + o.leaseUntil <= new Date() || + !r || + r.taskId !== t.id || + r.status !== 'RUNNING' || + r.environment !== 'staging' || + r.commitSha !== t.metadata.commitSha + ) + throw new ForbiddenException('Active owned editorial lease required'); + const reserve = await tx.orchestrationBudgetLedger.findUnique({ + where: { id: o.reservationId }, + }); + const ledger = await tx.orchestrationBudgetLedger.aggregate({ + where: { taskId: t.id }, + _sum: { amountCents: true }, + }); + if ( + !reserve || + reserve.taskId !== t.id || + reserve.actorId !== a.id || + reserve.kind !== 'RESERVE' || + reserve.amountCents !== 20 || + reserve.idempotencyKey !== `prepare-reserve:${r.id}` || + ledger._sum.amountCents !== 20 || + (await tx.orchestrationBudgetLedger.findFirst({ + where: { taskId: t.id, kind: 'RECONCILE' }, + })) + ) + throw new ForbiddenException( + 'Unreconciled owned 20 cent reservation required', + ); + const bytes = JSON.stringify({ + kind, + pilotKind: EDITORIAL_PILOT_KIND, + schemaVersion: 1, + taskId: t.id, + runId: r.id, + commitSha: r.commitSha, + environment: 'staging', + qaStatus, + costStatus: 'upper-bound-reserved', + brief, + }); + const hash = createHash('sha256').update(bytes).digest('hex'); + // Canonical bytes live in append-only DB artifact metadata, not a caller URI + // or mutable external file. PMO status is the authenticated retrieval path. + 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: t.id }, + data: { state: 'VERIFYING', version: { increment: 1 } }, + }); + await tx.orchestrationEvent.create({ + data: { + taskId: t.id, + sequence: updated.version, + actorId: a.id, + eventType: 'EDITORIAL_BRIEF_RECEIVED', + fromState: t.state, + toState: 'VERIFYING', + idempotencyKey: `editorial-result:${r.id}`, + payload: { + artifactSha256: hash, + qaStatus, + costStatus: 'upper-bound-reserved', + retainedReservationCents: 20, + }, + }, + }); + return { + taskId: t.id, + runId: r.id, + state: updated.state, + artifactSha256: hash, + qaStatus, + costStatus: 'upper-bound-reserved', + retainedReservationCents: 20, + }; + }); + } +} diff --git a/backend/src/orchestration-worker/worker-transport.module.ts b/backend/src/orchestration-worker/worker-transport.module.ts index 62274f38..1bbc0d30 100644 --- a/backend/src/orchestration-worker/worker-transport.module.ts +++ b/backend/src/orchestration-worker/worker-transport.module.ts @@ -33,6 +33,7 @@ import { } from "../orchestration/prepare-workflow.service"; import { EditorialProposalBridge, EditorialProposalDto, isEditorialProposal } from "./editorial-bridge"; +import { EditorialExecutionService, EditorialClaimDto, EditorialResultDto } from './editorial-execution'; import { admittedTechTask, TECH_PILOT_KIND, techArtifact, validateTechSource } from "./tech-pilot-validator"; // This is reviewed static configuration, not a URL fetched by the transport. @@ -319,7 +320,16 @@ class WorkerTransportService { }), ) class WorkerTransportController { - constructor(private readonly service: WorkerTransportService, private readonly editorial: EditorialProposalBridge) {} + constructor(private readonly service: WorkerTransportService, private readonly editorial: EditorialProposalBridge, private readonly execution: EditorialExecutionService) {} + @Get('editorial-proposals/:taskId') editorialStatus(@Req() req: any, @Param('taskId') taskId: string) { + return this.execution.status(req.workerIdentity, taskId); + } + @Post('editorial-claim') editorialClaim(@Req() req: any, @Body() dto: EditorialClaimDto) { + return this.execution.claim(req.workerIdentity, dto); + } + @Post('editorial-result') editorialResult(@Req() req: any, @Body() dto: EditorialResultDto) { + return this.execution.result(req.workerIdentity, dto); + } @Post("editorial-proposals") editorialProposal(@Req() req: any, @Body() dto: EditorialProposalDto) { return this.editorial.submit(req.workerIdentity, dto); } @@ -402,6 +412,7 @@ export class WorkerTransportModule { WorkerIdentityGuard, WorkerTransportService, EditorialProposalBridge, + EditorialExecutionService, { provide: CONFIG, useValue: snapshot }, { provide: PREPARE_WORKFLOW_CONFIG,