feat(hermes): persist guarded corporate orchestration backend

This commit is contained in:
Canina Automation committed 2026-10-28 11:57:15 +00:00
1 parent 5550c80a75
commit cc365bcda2
13 files changed
+1734

No files matched your search

@@ -0,0 +1,32 @@
import { normalizeSearch, pagination, taskInput } from './corporate-policy';
describe('corporate contract policy', () => {
it('normalizes Persian letters, digits and separators', () => {
expect(normalizeSearch('كيك ۱۲۳ (ة)‌')).toBe('کیک 123 ه');
});
it('bounds pagination and sort keys', () => {
expect(pagination({ limit: '100' }).limit).toBe(100);
expect(() => pagination({ limit: '101' })).toThrow();
expect(() => pagination({ page: '-1' })).toThrow();
expect(() => pagination({ sortBy: 'password' })).toThrow();
});
it('defaults CEO priority and rejects status/command injection', () => {
expect(
taskInput({
title: 'عنوان',
description: 'کار',
department: 'CONTENT_SEO',
}).priority,
).toBe('CEO_EXPEDITE');
expect(() =>
taskInput({
title: 'x',
description: 'x',
department: 'CONTENT_SEO',
status: 'DONE',
}),
).toThrow();
expect(() =>
taskInput({ title: '', description: 'x', department: 'CONTENT_SEO' }),
).toThrow();
});
});
@@ -0,0 +1,174 @@
import { BadRequestException } from '@nestjs/common';
export const departments = [
'CONTENT_SEO',
'CATALOG_COMMERCE',
'WIKI_SCIENTIFIC',
'TECH_DEVOPS',
'MARKET_INTELLIGENCE',
];
export const priorities = ['CEO_EXPEDITE', 'CRITICAL', 'HIGH', 'MEDIUM', 'LOW'];
export const statuses = [
'TODO',
'IN_PROGRESS',
'TEST',
'DONE',
'BLOCKED',
'REJECTED',
'CANCELLED',
];
export function object(value: unknown, keys: string[]): Record<string, any> {
if (
!value ||
typeof value !== 'object' ||
Array.isArray(value) ||
Object.keys(value).some((k) => !keys.includes(k))
)
throw new BadRequestException('Invalid fields');
return value as Record<string, any>;
}
export function text(value: unknown, max = 10000): string {
if (typeof value !== 'string' || !value.trim() || value.length > max)
throw new BadRequestException('Invalid text');
return value.trim();
}
export function uuid(value: unknown): string {
const id = text(value, 36);
if (
!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
id,
)
)
throw new BadRequestException('Invalid UUID');
return id;
}
export function choice(value: unknown, values: string[]): string {
if (typeof value !== 'string' || !values.includes(value))
throw new BadRequestException('Invalid enum');
return value;
}
export function normalizeSearch(value: string): string {
return value
.normalize('NFKC')
.toLowerCase()
.replace(/[يى]/g, 'ی')
.replace(/ك/g, 'ک')
.replace(/ة/g, 'ه')
.replace(/[۰-۹٠-٩]/g, (c) =>
String(
'۰۱۲۳۴۵۶۷۸۹'.includes(c)
? '۰۱۲۳۴۵۶۷۸۹'.indexOf(c)
: '٠١٢٣٤٥٦٧٨٩'.indexOf(c),
),
)
.replace(/[\u200c\u200d()()]/g, ' ')
.replace(/[\u064b-\u065f]/g, '')
.replace(/\s+/g, ' ')
.trim();
}
export function pagination(q: Record<string, any>) {
const page = Number(q.page ?? 1),
limit = Number(q.limit ?? 20);
if (
!Number.isSafeInteger(page) ||
page < 1 ||
page > 1000000 ||
!Number.isInteger(limit) ||
limit < 1 ||
limit > 100
)
throw new BadRequestException('Invalid pagination');
const sortBy = choice(q.sortBy ?? 'createdAt', [
'createdAt',
'updatedAt',
'title',
'taskCode',
'priority',
'status',
]);
const sortOrder = choice(q.sortOrder ?? 'desc', ['asc', 'desc']) as
| 'asc'
| 'desc';
return { page, limit, skip: (page - 1) * limit, sortBy, sortOrder };
}
export function meta(total: number, page: number, limit: number) {
const totalPages = Math.ceil(total / limit);
return {
total,
page,
limit,
totalPages,
hasNextPage: page < totalPages,
hasPrevPage: page > 1,
};
}
export function taskInput(input: unknown) {
const b = object(input, [
'title',
'department',
'description',
'priority',
'parentId',
'goalId',
'actionType',
'dueCycle',
]);
return {
title: text(b.title, 300),
description: text(b.description),
department: choice(b.department, departments),
priority: choice(b.priority ?? 'CEO_EXPEDITE', priorities),
parentId: b.parentId === undefined ? undefined : uuid(b.parentId),
goalId: b.goalId === undefined ? undefined : uuid(b.goalId),
actionType: choice(b.actionType ?? 'CEO_DIRECTIVE', [
'CEO_DIRECTIVE',
'BLOG_NEW',
'BLOG_UPDATE',
'CATALOG_ENRICH',
'RESEARCH',
'ENGINEERING',
]),
dueCycle: b.dueCycle === undefined ? undefined : text(b.dueCycle, 40),
};
}
export function canonical(value: any): string {
if (Array.isArray(value)) return '[' + value.map(canonical).join(',') + ']';
if (value && typeof value === 'object')
return (
'{' +
Object.keys(value)
.sort()
.map((k) => JSON.stringify(k) + ':' + canonical(value[k]))
.join(',') +
'}'
);
return JSON.stringify(value);
}
export function evidenceInput(input: unknown) {
const b = object(input, [
'claimToken',
'artifactUri',
'sha256',
'summary',
'tool',
'result',
]);
const uri = text(b.artifactUri, 2000);
if (
!/^(https:\/\/|urn:sha256:)/.test(uri) ||
/example\.(com|org)|localhost|127\.0\.0\.1/.test(uri)
)
throw new BadRequestException(
'Evidence locator must be a real HTTPS artifact or content digest',
);
const sha = text(b.sha256, 64);
if (!/^[a-f0-9]{64}$/.test(sha))
throw new BadRequestException('Invalid digest');
return {
claimToken: uuid(b.claimToken),
artifactUri: uri,
sha256: sha,
summary: text(b.summary),
tool: text(b.tool, 100),
result: text(b.result),
};
}
@@ -0,0 +1,121 @@
import {
Body,
Controller,
Get,
Headers,
Param,
Post,
Query,
Req,
UnauthorizedException,
UseGuards,
} from '@nestjs/common';
import { JwtAuthGuard } from '../../auth/jwt-auth.guard';
import { RolesGuard } from '../../common/guards/roles.guard';
import { Roles } from '../../common/decorators/roles.decorator';
import { CorporateService } from './corporate.service';
import { randomUUID } from 'crypto';
import { text } from './corporate-policy';
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles('Admin', 'SUPER_ADMIN')
@Controller('admin/hermes')
export class CorporateController {
constructor(private readonly service: CorporateService) {}
private actor(req: any) {
// API keys must use their authenticated key identity, not an editable worker label.
const user = req.user;
const id = user?.id ?? user?.sub;
if (!id) throw new UnauthorizedException('Authenticated subject required');
return (user.isApiKey ? 'apikey:' : 'user:') + text(String(id), 200);
}
private key(key?: string) {
return text(key, 200);
}
@Get('runtime') runtime() {
return {
mode: 'MANUAL_DORMANT',
schedulesEnabled: false,
externalExecutionEnabled: false,
};
}
@Get('tasks') tasks(@Query() query: Record<string, any>) {
return this.service.tasks(query);
}
@Get('tasks/:id') detail(@Param('id') id: string) {
return this.service.detail(id);
}
@Post('tasks') create(
@Req() req: any,
@Headers('idempotency-key') key: string,
@Body() body: unknown,
) {
return this.service.create(this.actor(req), key ?? randomUUID(), body);
}
@Post('claims') claim(
@Req() req: any,
@Headers('idempotency-key') key: string,
@Body() body: unknown,
) {
return this.service.claim(this.actor(req), this.key(key), body);
}
@Post('tasks/:id/evidence') evidence(
@Req() req: any,
@Headers('idempotency-key') key: string,
@Param('id') id: string,
@Body() body: unknown,
) {
return this.service.submitEvidence(
this.actor(req),
this.key(key),
id,
body,
);
}
@Post('tasks/:id/reviews') review(
@Req() req: any,
@Headers('idempotency-key') key: string,
@Param('id') id: string,
@Body() body: unknown,
) {
return this.service.review(this.actor(req), this.key(key), id, body);
}
@Post('tasks/:id/effects') effect(
@Req() req: any,
@Headers('idempotency-key') key: string,
@Param('id') id: string,
@Body() body: unknown,
) {
return this.service.effect(this.actor(req), this.key(key), id, body);
}
@Get('market-insights') insights(@Query() q: Record<string, any>) {
return this.service.collection('market-insights', q);
}
@Post('market-insights') research(
@Req() req: any,
@Headers('idempotency-key') key: string,
@Body() body: unknown,
) {
return this.service.research(this.actor(req), this.key(key), body);
}
@Get('monthly-roadmap') roadmaps(@Query() q: Record<string, any>) {
return this.service.collection('monthly-roadmap', q);
}
@Post('monthly-roadmap') roadmap(
@Req() req: any,
@Headers('idempotency-key') key: string,
@Body() body: unknown,
) {
return this.service.roadmap(this.actor(req), this.key(key), body);
}
@Get('reports') reports(@Query() q: Record<string, any>) {
return this.service.collection('reports', q);
}
@Post('reports') report(
@Req() req: any,
@Headers('idempotency-key') key: string,
@Body() body: unknown,
) {
return this.service.report(this.actor(req), this.key(key), body);
}
}
@@ -0,0 +1,303 @@
import passport from 'passport';
import { Strategy, ExtractJwt } from 'passport-jwt';
import { PrismaClient } from '@prisma/client';
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { randomUUID } from 'crypto';
import request from 'supertest';
import { PrismaService } from '../../prisma/prisma.service';
import { CorporateController } from './corporate.controller';
import { CorporateService } from './corporate.service';
import { ApiKeysService } from '../api-keys.service';
const integration = process.env.CORPORATE_TEST_DATABASE_URL
? describe
: describe.skip;
integration('corporate API / disposable PostgreSQL', () => {
let app: INestApplication, db: PrismaService;
const key = () => randomUUID();
const post = (path: string, body: any, actor = 'executor', op = key()) =>
request(app.getHttpServer())
.post('/admin/hermes/' + path)
.set('x-api-key', actor)
.set('Idempotency-Key', op)
.send(body);
const input = {
title: 'كيك ۱۲۳',
description: 'integration fixture',
department: 'CONTENT_SEO',
};
beforeAll(async () => {
// Explicit disposable loopback opt-in only; never consumes runtime DATABASE_URL.
const url = new URL(process.env.CORPORATE_TEST_DATABASE_URL!);
if (url.hostname !== '127.0.0.1' || url.pathname !== '/corporate_test')
throw new Error('Disposable loopback corporate_test DB required');
passport.use(
'jwt',
new Strategy(
{
jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
secretOrKey: 'test-only-not-runtime',
},
(_payload, done) => done(null, false),
),
);
db = new PrismaClient({
datasources: { db: { url: process.env.CORPORATE_TEST_DATABASE_URL } },
}) as PrismaService;
const module = await Test.createTestingModule({
controllers: [CorporateController],
providers: [
CorporateService,
{ provide: PrismaService, useValue: db },
{
provide: ApiKeysService,
useValue: {
validateKey: async (id: string) => ({
id,
isApiKey: true,
role: 'Admin',
scopes: id === 'unscoped' ? [] : ['admin'],
}),
},
},
],
}).compile();
app = module.createNestApplication();
await app.listen(0, '127.0.0.1');
});
afterAll(async () => {
if (db)
await db.$executeRawUnsafe(
'TRUNCATE corporate_operations, corporate_reports, corporate_effects, corporate_reviews, corporate_evidence, corporate_events, corporate_tasks, corporate_goals, corporate_roadmaps, corporate_sources, corporate_research CASCADE',
);
await app?.close();
await db?.$disconnect();
passport.unuse('jwt');
});
beforeEach(async () => {
await db.$executeRawUnsafe(
'TRUNCATE corporate_operations, corporate_reports, corporate_effects, corporate_reviews, corporate_evidence, corporate_events, corporate_tasks, corporate_goals, corporate_roadmaps, corporate_sources, corporate_research CASCADE',
);
});
it('auth, UI list contract, normalized search, immutable idempotent replay', async () => {
await request(app.getHttpServer()).get('/admin/hermes/tasks').expect(401);
await post('tasks', input, 'unscoped').expect(403);
const op = key(),
a = await post('tasks', input, 'executor', op).expect(201);
const b = await post('tasks', input, 'executor', op).expect(201);
expect(b.body.id).toBe(a.body.id);
await post('tasks', { ...input, title: 'changed' }, 'executor', op).expect(
409,
);
const list = await request(app.getHttpServer())
.get('/admin/hermes/tasks?search=کیک%20123&limit=1')
.set('x-api-key', 'executor')
.expect(200);
expect(list.body.meta).toEqual({
total: 1,
page: 1,
limit: 1,
totalPages: 1,
hasNextPage: false,
hasPrevPage: false,
});
expect(list.body.data[0].priority).toBe('CEO_EXPEDITE');
await request(app.getHttpServer())
.get('/admin/hermes/tasks?limit=101')
.set('x-api-key', 'executor')
.expect(400);
await request(app.getHttpServer())
.get('/admin/hermes/tasks?sortBy=password')
.set('x-api-key', 'executor')
.expect(400);
});
it('claims exclusively, expires/reclaims, fences stale executor, requires independent QA', async () => {
const task = (await post('tasks', input).expect(201)).body;
const claims = await Promise.all([
post('claims', {}, 'executor'),
post('claims', {}, 'competitor'),
]);
expect(claims.filter((x) => x.body.task !== null)).toHaveLength(1);
const claimed = claims.find((x) => x.body.task !== null)!.body.task;
const oldActor = claimed.assignedAgent.replace('apikey:', '');
await db.$executeRaw`UPDATE corporate_tasks SET "leasedUntil"=clock_timestamp()-interval '1 second' WHERE id=${task.id}::uuid`;
const renewed = (await post('claims', {}, 'new-executor').expect(201)).body
.task;
expect(renewed.claimToken).not.toBe(claimed.claimToken);
const evidence = {
claimToken: claimed.claimToken,
artifactUri: 'urn:sha256:' + 'a'.repeat(64),
sha256: 'a'.repeat(64),
summary: 'receipt',
tool: 'jest',
result: 'passed',
};
await post(`tasks/${task.id}/evidence`, evidence, oldActor).expect(409);
const e = (
await post(
`tasks/${task.id}/evidence`,
{ ...evidence, claimToken: renewed.claimToken },
'new-executor',
).expect(201)
).body;
const review = {
evidenceId: e.id,
passed: true,
findings: 'verified',
verification: {
artifactUri: e.artifactUri,
sha256: e.sha256,
method: 'digest readback',
result: 'match',
},
};
await post(`tasks/${task.id}/reviews`, review, 'new-executor').expect(409);
await post(`tasks/${task.id}/reviews`, review, 'reviewer').expect(201);
const detail = await request(app.getHttpServer())
.get('/admin/hermes/tasks/' + task.id)
.set('x-api-key', 'reviewer')
.expect(200);
expect(detail.body.status).toBe('DONE');
expect(detail.body.logs.map((x: any) => x.step)).toContain('QA_PASSED');
await post(`tasks/${task.id}/effects`, {
metric: 'engagement',
availability: 'UNAVAILABLE',
observed: 0,
source: 'provider unavailable',
observedAt: new Date().toISOString(),
}).expect(400);
});
it('skips a held row lock and gives CEO priority before lower priorities', async () => {
const urgent = (await post('tasks', input).expect(201)).body;
const low = (await post('tasks', { ...input, priority: 'LOW' }).expect(201))
.body;
let release!: () => void, locked!: () => void;
const ready = new Promise<void>((r) => (locked = r)),
hold = new Promise<void>((r) => (release = r));
const locking = db.$transaction(async (tx) => {
await tx.$queryRaw`SELECT id FROM corporate_tasks WHERE id=${urgent.id}::uuid FOR UPDATE`;
locked();
await hold;
});
await ready;
try {
const claim = (await post('claims', {}).expect(201)).body.task;
expect(claim.id).toBe(low.id);
} finally {
release();
await locking;
}
const next = (await post('claims', {}, 'other').expect(201)).body.task;
expect(next.id).toBe(urgent.id);
});
it('serializes simultaneous duplicate mutations into one durable record', async () => {
const op = key();
const responses = await Promise.all([
post('tasks', input, 'executor', op),
post('tasks', input, 'executor', op),
]);
expect(responses.map((r) => r.status)).toEqual([201, 201]);
expect(responses[0].body.id).toBe(responses[1].body.id);
expect(await db.corporateTask.count()).toBe(1);
});
it('gates parents on children, persists provenance, roadmap/goals and reports', async () => {
const parent = (await post('tasks', input).expect(201)).body;
const child = (
await post('tasks', { ...input, parentId: parent.id }).expect(201)
).body;
const claim = (await post('claims', {}).expect(201)).body.task;
expect(claim.id).toBe(child.id);
const e = (
await post(`tasks/${child.id}/evidence`, {
claimToken: claim.claimToken,
artifactUri: 'urn:sha256:' + 'b'.repeat(64),
sha256: 'b'.repeat(64),
summary: 'child artifact',
tool: 'jest',
result: 'receipt',
}).expect(201)
).body;
await post(
`tasks/${child.id}/reviews`,
{
evidenceId: e.id,
passed: false,
findings: 'needs correction',
verification: {
artifactUri: e.artifactUri,
sha256: e.sha256,
method: 'readback',
result: 'failed',
},
},
'reviewer',
).expect(201);
expect(
(await db.corporateTask.findUniqueOrThrow({ where: { id: parent.id } }))
.status,
).toBe('BLOCKED');
expect((await post('claims', {}).expect(201)).body.task.id).toBe(child.id);
const research = (
await post('market-insights', {
title: 'fixture research',
category: 'TREND',
source: 'study receipt',
opportunity: 'investigate',
impact: 'LOW',
recommendedAction: 'measure',
cadence: 'MONTHLY',
provenance: {
method: 'test fixture',
collector: 'integration',
context: 'disposable',
},
sources: [
{
url: 'https://pubmed.ncbi.nlm.nih.gov/',
title: 'fixture',
excerpt: 'test-only',
retrievedAt: '2026-01-01T00:00:00Z',
sha256: 'a'.repeat(64),
},
],
}).expect(201)
).body;
const roadmap = (
await post('monthly-roadmap', {
researchId: research.id,
cycleName: 'test',
month: '2026-10',
seasonalTheme: 'evidence pending seasonal analysis',
strategicGoals: ['measure'],
plannedArticlesCount: 31,
plannedRefreshesCount: 0,
plannedCatalogEnrichments: 0,
goals: [
{
title: 'goal',
department: 'CONTENT_SEO',
acceptanceCriteria: 'QA',
metric: 'engagement',
},
],
}).expect(201)
).body;
expect(roadmap.goals).toHaveLength(1);
await post('tasks', { ...input, goalId: roadmap.goals[0].id }).expect(201);
for (const path of ['market-insights', 'monthly-roadmap']) {
const r = await request(app.getHttpServer())
.get('/admin/hermes/' + path)
.set('x-api-key', 'executor')
.expect(200);
expect(r.body.meta.total).toBe(1);
}
const report = (
await post('reports', {
day: new Date().toISOString().slice(0, 10),
summary: 'test fixture daily report',
}).expect(201)
).body;
expect(report.snapshot.tasks).toHaveLength(3);
});
});
@@ -0,0 +1,600 @@
import {
Injectable,
BadRequestException,
ConflictException,
NotFoundException,
} from '@nestjs/common';
import { Prisma, CorporatePriority } from '@prisma/client';
import { createHash, randomUUID } from 'crypto';
import { PrismaService } from '../../prisma/prisma.service';
import {
canonical,
choice,
departments,
evidenceInput,
meta,
normalizeSearch,
object,
pagination,
priorities,
statuses,
taskInput,
text,
uuid,
} from './corporate-policy';
type Tx = Prisma.TransactionClient;
@Injectable()
export class CorporateService {
constructor(private readonly db: PrismaService) {}
private async operation(
actor: string,
op: string,
key: string,
body: unknown,
fn: (tx: Tx) => Promise<any>,
) {
text(key, 200);
const scoped = createHash('sha256')
.update(canonical([actor, op, key]))
.digest('hex');
const hash = createHash('sha256').update(canonical(body)).digest('hex');
return this.db.$transaction(
async (tx) => {
await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtextextended(${scoped}, 0))`;
const prior = await tx.corporateOperation.findUnique({
where: { key: scoped },
});
if (prior) {
if (prior.payloadHash !== hash)
throw new ConflictException('Idempotency key payload mismatch');
return prior.response;
}
const result = await fn(tx);
const response = JSON.parse(JSON.stringify(result));
await tx.corporateOperation.create({
data: { key: scoped, payloadHash: hash, response },
});
return response;
},
{ maxWait: 10000, timeout: 20000 },
);
}
private event(
tx: Tx,
taskId: string,
actor: string,
step: string,
content: string,
speaker = 'SYSTEM',
payload?: any,
) {
return tx.corporateEvent.create({
data: { taskId, speaker, speakerName: actor, step, content, payload },
});
}
private async lock(tx: Tx, id: string) {
uuid(id);
const rows = await tx.$queryRaw<
{ id: string }[]
>`SELECT id FROM corporate_tasks WHERE id=${id}::uuid FOR UPDATE`;
if (!rows.length) throw new NotFoundException('Task not found');
return tx.corporateTask.findUniqueOrThrow({ where: { id } });
}
private async fenced(tx: Tx, id: string, token: string, actor: string) {
const t = await this.lock(tx, id);
const rows = await tx.$queryRaw<
{ id: string }[]
>`SELECT id FROM corporate_tasks WHERE id=${id}::uuid AND "claimToken"=${token}::uuid AND "assignedAgent"=${actor} AND "leasedUntil">clock_timestamp() AND status='IN_PROGRESS'`;
if (!rows.length) throw new ConflictException('Stale lease or owner');
return t;
}
async tasks(q: Record<string, any>) {
const p = pagination(q),
where: Prisma.CorporateTaskWhereInput = {};
if (q.department) where.department = choice(q.department, departments);
if (q.priority)
where.priority = choice(q.priority, priorities) as CorporatePriority;
if (q.status) where.status = choice(q.status, statuses) as any;
if (q.search) {
const search = normalizeSearch(text(q.search, 300));
where.OR = [
{ normalizedTitle: { contains: search } },
{ normalizedCode: { contains: search } },
];
}
if (q.goalId) where.goalId = uuid(q.goalId);
return this.db.$transaction(
async (tx) => {
const total = await tx.corporateTask.count({ where });
const data = await tx.corporateTask.findMany({
where,
skip: p.skip,
take: p.limit,
orderBy: [{ [p.sortBy]: p.sortOrder }, { id: 'asc' }],
});
return { data, meta: meta(total, p.page, p.limit) };
},
{ isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead },
);
}
async detail(id: string) {
uuid(id);
const task = await this.db.corporateTask.findUnique({
where: { id },
include: {
logs: { orderBy: { timestamp: 'asc' } },
evidence: true,
reviews: true,
effects: true,
children: true,
},
});
if (!task) throw new NotFoundException('Task not found');
return task;
}
create(actor: string, key: string, input: unknown) {
const b = taskInput(input);
return this.operation(actor, 'create-task', key, b, async (tx) => {
if (b.parentId) {
const parent = await this.lock(tx, b.parentId);
if (!['TODO', 'IN_PROGRESS', 'BLOCKED'].includes(parent.status))
throw new ConflictException('Parent no longer accepts children');
}
const code = 'TSK-' + randomUUID();
const task = await tx.corporateTask.create({
data: {
...b,
priority: b.priority as CorporatePriority,
taskCode: code,
normalizedCode: normalizeSearch(code),
normalizedTitle: normalizeSearch(b.title),
createdBy: actor,
},
});
await this.event(tx, task.id, actor, 'CREATED', b.description, 'CEO');
return task;
});
}
claim(actor: string, key: string, input: unknown) {
const b = object(input, ['department', 'leaseSeconds']);
const department =
b.department === undefined ? null : choice(b.department, departments);
const seconds = Number(b.leaseSeconds ?? 300);
if (!Number.isInteger(seconds) || seconds < 30 || seconds > 900)
throw new BadRequestException('Lease must be 30..900 seconds');
return this.operation(
actor,
'claim',
key,
{ department, seconds },
async (tx) => {
const candidates = await tx.$queryRaw<
{ id: string }[]
>`SELECT t.id FROM corporate_tasks t
WHERE (t.status='TODO' OR (t.status='BLOCKED' AND EXISTS (SELECT 1 FROM corporate_tasks c WHERE c."parentId"=t.id)) OR (t.status='IN_PROGRESS' AND t."leasedUntil"<=clock_timestamp()))
AND (${department}::text IS NULL OR t.department=${department})
AND NOT EXISTS (SELECT 1 FROM corporate_tasks c WHERE c."parentId"=t.id AND c.status<>'DONE')
ORDER BY t.priority ASC,t."updatedAt" ASC,t.id ASC FOR UPDATE OF t SKIP LOCKED LIMIT 1`;
if (!candidates.length) return { task: null };
const id = candidates[0].id,
token = randomUUID();
await tx.$executeRaw`UPDATE corporate_tasks SET status='IN_PROGRESS', "assignedAgent"=${actor}, "claimToken"=${token}::uuid, "leasedUntil"=clock_timestamp()+make_interval(secs=>${seconds}::int), "executionCount"="executionCount"+1,"updatedAt"=clock_timestamp() WHERE id=${id}::uuid`;
await this.event(tx, id, actor, 'CLAIMED', 'Manual lease acquired');
return {
task: await tx.corporateTask.findUniqueOrThrow({ where: { id } }),
};
},
);
}
submitEvidence(actor: string, key: string, id: string, input: unknown) {
const b = evidenceInput(input);
return this.operation(actor, 'evidence:' + id, key, b, async (tx) => {
await this.fenced(tx, id, b.claimToken, actor);
const e = await tx.corporateEvidence.create({
data: { ...b, taskId: id, executor: actor },
});
await tx.corporateTask.update({
where: { id },
data: { status: 'TEST', leasedUntil: null },
});
await this.event(
tx,
id,
actor,
'EVIDENCE_SUBMITTED',
b.summary,
'AGENT',
{ evidenceId: e.id },
);
return e;
});
}
review(actor: string, key: string, id: string, input: unknown) {
const b = object(input, [
'evidenceId',
'passed',
'findings',
'verification',
]);
const evidenceId = uuid(b.evidenceId),
findings = text(b.findings);
if (typeof b.passed !== 'boolean')
throw new BadRequestException('passed must be boolean');
const v = object(b.verification, [
'artifactUri',
'sha256',
'method',
'result',
]);
const verification = {
artifactUri: text(v.artifactUri, 2000),
sha256: text(v.sha256, 64),
method: text(v.method, 1000),
result: text(v.result),
};
return this.operation(actor, 'review:' + id, key, b, async (tx) => {
uuid(id);
const relation = await tx.corporateTask.findUnique({
where: { id },
select: { parentId: true },
});
if (relation?.parentId) await this.lock(tx, relation.parentId);
const task = await this.lock(tx, id);
const evidence = await tx.corporateEvidence.findUnique({
where: { id: evidenceId },
});
if (
task.status !== 'TEST' ||
!evidence ||
evidence.taskId !== id ||
evidence.claimToken !== task.claimToken
)
throw new ConflictException('Current execution evidence required');
if (evidence.executor === actor)
throw new ConflictException('Independent reviewer required');
if (
verification.sha256 !== evidence.sha256 ||
verification.artifactUri !== evidence.artifactUri
)
throw new ConflictException('QA must verify exact artifact');
if (
b.passed &&
(await tx.corporateTask.count({
where: { parentId: id, status: { not: 'DONE' } },
}))
)
throw new ConflictException('Unfinished children');
const r = await tx.corporateReview.create({
data: {
taskId: id,
evidenceId,
reviewer: actor,
passed: b.passed,
findings,
verification,
},
});
await tx.corporateTask.update({
where: { id },
data: {
status: b.passed ? 'DONE' : 'TODO',
claimToken: null,
leasedUntil: null,
qaCount: { increment: 1 },
rejectionCount: { increment: b.passed ? 0 : 1 },
},
});
if (!b.passed && task.parentId) {
await tx.corporateTask.update({
where: { id: task.parentId },
data: { status: 'BLOCKED' },
});
await this.event(
tx,
task.parentId,
actor,
'CHILD_QA_REJECTED',
'Parent blocked pending child correction',
'QA',
{ childId: id },
);
}
await this.event(
tx,
id,
actor,
b.passed ? 'QA_PASSED' : 'QA_REJECTED',
findings,
'QA',
{ reviewId: r.id },
);
return r;
});
}
async collection(
kind: 'market-insights' | 'monthly-roadmap' | 'reports',
q: Record<string, any>,
) {
const p = pagination(q);
return this.db.$transaction(
async (tx) => {
const model =
kind === 'market-insights'
? tx.corporateResearch
: kind === 'monthly-roadmap'
? tx.corporateRoadmap
: tx.corporateReport;
const where: any = {};
if (kind === 'market-insights' && q.category)
where.category = choice(q.category, [
'TREND',
'COMPETITOR',
'NEW_CHANNEL',
'CATALOG_GAP',
]);
if (kind === 'monthly-roadmap' && q.month)
where.month = text(q.month, 40);
const delegate = model as any;
const total = await delegate.count({ where });
const data = await delegate.findMany({
where,
skip: p.skip,
take: p.limit,
orderBy: [{ createdAt: 'desc' }, { id: 'asc' }],
...(kind === 'market-insights'
? { include: { sources: true } }
: kind === 'monthly-roadmap'
? { include: { goals: true } }
: {}),
});
return { data, meta: meta(total, p.page, p.limit) };
},
{ isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead },
);
}
research(actor: string, key: string, input: unknown) {
const b = object(input, [
'title',
'category',
'source',
'opportunity',
'impact',
'recommendedAction',
'cadence',
'provenance',
'sources',
]);
if (!Array.isArray(b.sources) || !b.sources.length || b.sources.length > 30)
throw new BadRequestException('1..30 sources required');
const sources = b.sources.map((raw) => {
const s = object(raw, [
'url',
'title',
'excerpt',
'retrievedAt',
'sha256',
]);
const url = text(s.url, 2000),
sha256 = text(s.sha256, 64),
retrievedAt = new Date(s.retrievedAt);
if (
!url.startsWith('https://') ||
!/^[a-f0-9]{64}$/.test(sha256) ||
!Number.isFinite(retrievedAt.getTime()) ||
retrievedAt.getTime() > Date.now()
)
throw new BadRequestException('Invalid source');
return {
url,
sha256,
retrievedAt,
title: text(s.title, 300),
excerpt: text(s.excerpt),
};
});
const provenance = object(b.provenance, ['method', 'collector', 'context']);
const data = {
title: text(b.title, 300),
category: choice(b.category, [
'TREND',
'COMPETITOR',
'NEW_CHANNEL',
'CATALOG_GAP',
]),
source: text(b.source, 2000),
opportunity: text(b.opportunity),
impact: choice(b.impact, ['HIGH', 'MEDIUM', 'LOW']),
recommendedAction: text(b.recommendedAction),
cadence: choice(b.cadence, ['MONTHLY', 'EVENT']),
provenance: {
method: text(provenance.method),
collector: text(provenance.collector, 300),
context: text(provenance.context),
},
createdBy: actor,
};
return this.operation(actor, 'research', key, b, (tx) =>
tx.corporateResearch.create({
data: { ...data, sources: { create: sources } },
include: { sources: true },
}),
);
}
roadmap(actor: string, key: string, input: unknown) {
const b = object(input, [
'researchId',
'cycleName',
'month',
'seasonalTheme',
'strategicGoals',
'plannedArticlesCount',
'plannedRefreshesCount',
'plannedCatalogEnrichments',
'isActive',
'goals',
]);
if (
!Array.isArray(b.strategicGoals) ||
!b.strategicGoals.length ||
b.strategicGoals.length > 30 ||
!Array.isArray(b.goals) ||
!b.goals.length ||
b.goals.length > 100
)
throw new BadRequestException('Goals required');
for (const k of [
'plannedArticlesCount',
'plannedRefreshesCount',
'plannedCatalogEnrichments',
])
if (!Number.isInteger(b[k]) || b[k] < 0 || b[k] > 10000)
throw new BadRequestException('Invalid counts');
if (b.isActive !== undefined && typeof b.isActive !== 'boolean')
throw new BadRequestException('Invalid active flag');
const goals = b.goals.map((raw) => {
const g = object(raw, [
'title',
'department',
'acceptanceCriteria',
'metric',
'target',
]);
if (
g.target !== undefined &&
(typeof g.target !== 'number' || !Number.isFinite(g.target))
)
throw new BadRequestException('Invalid target');
return {
title: text(g.title, 300),
department: choice(g.department, departments),
acceptanceCriteria: text(g.acceptanceCriteria),
metric: text(g.metric, 300),
target: g.target,
};
});
const data = {
researchId: uuid(b.researchId),
cycleName: text(b.cycleName, 300),
month: text(b.month, 40),
seasonalTheme: text(b.seasonalTheme),
strategicGoals: b.strategicGoals.map((g) => text(g, 1000)),
plannedArticlesCount: b.plannedArticlesCount,
plannedRefreshesCount: b.plannedRefreshesCount,
plannedCatalogEnrichments: b.plannedCatalogEnrichments,
isActive: b.isActive ?? false,
createdBy: actor,
};
return this.operation(actor, 'roadmap', key, b, async (tx) => {
const research = await tx.corporateResearch.findUnique({
where: { id: data.researchId },
include: { sources: true },
});
if (!research || !research.sources.length)
throw new ConflictException('Evidence-backed research required');
const result = await tx.corporateRoadmap.create({
data: { ...data, goals: { create: goals } },
include: { goals: true },
});
await tx.corporateResearch.update({
where: { id: research.id },
data: { status: 'IN_BACKLOG' },
});
return result;
});
}
effect(actor: string, key: string, id: string, input: unknown) {
const b = object(input, [
'metric',
'availability',
'baseline',
'observed',
'source',
'observedAt',
]);
const availability = choice(b.availability, [
'MEASURED',
'UNAVAILABLE',
'UNINSTRUMENTED',
'BUSINESS_DISABLED',
]);
for (const k of ['baseline', 'observed'])
if (
b[k] !== undefined &&
b[k] !== null &&
(typeof b[k] !== 'number' || !Number.isFinite(b[k]))
)
throw new BadRequestException('Invalid metric');
if (availability === 'MEASURED' && typeof b.observed !== 'number')
throw new BadRequestException('Measured value required');
if (
availability !== 'MEASURED' &&
(b.observed != null || b.baseline != null)
)
throw new BadRequestException('Unavailable is not zero');
const observedAt = new Date(b.observedAt);
if (
!Number.isFinite(observedAt.getTime()) ||
observedAt.getTime() > Date.now()
)
throw new BadRequestException('Invalid observation time');
return this.operation(actor, 'effect:' + id, key, b, async (tx) => {
const task = await this.lock(tx, id);
if (task.status !== 'DONE')
throw new ConflictException('Effects require completed QA');
const e = await tx.corporateEffect.create({
data: {
taskId: id,
metric: text(b.metric, 300),
availability,
baseline: b.baseline,
observed: b.observed,
source: text(b.source, 2000),
observedAt,
recordedBy: actor,
},
});
await this.event(tx, id, actor, 'EFFECT_RECORDED', e.metric, 'SYSTEM', {
effectId: e.id,
});
return e;
});
}
report(actor: string, key: string, input: unknown) {
const b = object(input, ['day', 'summary']);
const day = text(b.day, 10),
summary = text(b.summary);
if (
!/^\d{4}-\d{2}-\d{2}$/.test(day) ||
!Number.isFinite(Date.parse(day + 'T00:00:00Z'))
)
throw new BadRequestException('ISO day required');
return this.operation(actor, 'report', key, b, async (tx) => {
const start = new Date(day + 'T00:00:00Z'),
end = new Date(start.getTime() + 86400000);
const tasks = await tx.corporateTask.findMany({
where: { updatedAt: { gte: start, lt: end } },
select: {
id: true,
taskCode: true,
title: true,
status: true,
department: true,
updatedAt: true,
},
});
const events = await tx.corporateEvent.findMany({
where: { timestamp: { gte: start, lt: end } },
orderBy: { timestamp: 'asc' },
});
const effects = await tx.corporateEffect.findMany({
where: { createdAt: { gte: start, lt: end } },
});
const snapshot = JSON.parse(
JSON.stringify({ timezone: 'UTC', tasks, events, effects }),
);
return tx.corporateReport.create({
data: { day, summary, snapshot, createdBy: actor },
});
});
}
}