Compare commits

...
4 changed files with 839 additions and 1 deletions

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,