Add bounded approved editorial brief ingestion pending independent QA
This commit is contained in:
1 parent
ba0aa5ee4e
commit
9cb503d85b
4 files changed
+839
-1
No files matched your search
@@ -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": "<uuid>" }`. 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.
|
||||
@@ -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,
|
||||
);
|
||||
});
|
||||
},
|
||||
);
|
||||
@@ -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<string, unknown>;
|
||||
}
|
||||
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,
|
||||
};
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
Reference in new issue
Block a user