@tomflow/proflow-task-orchestration 0.1.12 → 0.1.13

package/dist/src/phase4-contracts.js

@@ -0,0 +1,193 @@
+import { z } from "zod";
+import { publicOperationNames as legacyPublicOperationNames, validatePublicInput as validateLegacyPublicInput, } from "./contracts.js";
+import { requiredTaskAgentPackageRefs } from "./model.js";
+const id = z.string().min(1);
+const version = z.number().int().positive();
+const revision = z.number().int().nonnegative();
+const actor = { actorRef: id, idempotencyKey: id };
+const startAuthority = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("HUMAN_CONFIRMATION") }).strict(),
+    z
+        .object({
+        type: z.literal("CAMPAIGN_AUTHORIZATION"),
+        authorizationRef: id,
+        expectedAuthorizationVersion: version,
+        expectedCampaignVersion: version,
+    })
+        .strict(),
+]);
+const planNode = z
+    .object({
+    nodeId: id,
+    title: id,
+    objective: id,
+    requiredAgentPackageRef: z.enum(requiredTaskAgentPackageRefs),
+    inputDocuments: z.array(id),
+    outputDocuments: z.array(id),
+})
+    .strict();
+const trustedRoleBinding = z
+    .object({
+    agentPackageRef: z.enum(requiredTaskAgentPackageRefs),
+    roleRef: id,
+})
+    .strict();
+const productDocument = z
+    .object({
+    documentRef: id,
+    documentType: id,
+    filePath: id,
+    contentHash: id,
+    revision: version,
+})
+    .strict();
+export const phase4OperationNames = [
+    "createCampaignAuthorization",
+    "getProductCampaign",
+    "getCampaignAuthorization",
+    "revokeCampaignAuthorization",
+    "putProductDocument",
+    "getProductDocument",
+    "submitProductTaskIntent",
+    "transferProductIntentToTask",
+    "recordProductGapReview",
+    "recordProductGoalSatisfied",
+    "getProductContinuationProjection",
+];
+const submitProductTaskIntentSchema = z
+    .object({
+    intentRef: id,
+    campaignRef: id.optional(),
+    discussionRef: id,
+    goalRevision: version,
+    intentRevision: version,
+    predecessorTaskId: id.optional(),
+    title: id,
+    objective: id,
+    scope: z.unknown(),
+    constraints: z.unknown(),
+    plan: z.object({ nodes: z.array(planNode).min(1) }).strict(),
+    productDocuments: z.array(productDocument).optional().default([]),
+    roleBindings: z.array(trustedRoleBinding).length(3),
+    expectedCampaignVersion: version.optional(),
+    ...actor,
+})
+    .strict()
+    .superRefine((input, context) => {
+    if ((input.campaignRef === undefined) !== (input.expectedCampaignVersion === undefined))
+        context.addIssue({
+            code: "custom",
+            message: "campaignRef and expectedCampaignVersion must be supplied together",
+            path: ["expectedCampaignVersion"],
+        });
+    const packages = new Set(input.roleBindings.map((binding) => binding.agentPackageRef));
+    if (packages.size !== requiredTaskAgentPackageRefs.length ||
+        requiredTaskAgentPackageRefs.some((packageRef) => !packages.has(packageRef)))
+        context.addIssue({
+            code: "custom",
+            message: "roleBindings must declare exactly the fixed Product, Dev, and Test packages",
+            path: ["roleBindings"],
+        });
+});
+const continuationProjectionSchema = z
+    .object({ campaignRef: id.optional(), taskId: id.optional() })
+    .strict()
+    .superRefine((input, context) => {
+    if (input.campaignRef === undefined && input.taskId === undefined)
+        context.addIssue({
+            code: "custom",
+            message: "campaignRef or taskId is required",
+            path: ["campaignRef"],
+        });
+});
+const phase4Schemas = {
+    createCampaignAuthorization: z
+        .object({
+        authorizationRef: id.optional(),
+        campaignRef: id,
+        discussionRef: id,
+        goalRevision: version,
+        goalSummary: id,
+        scope: z.unknown(),
+        constraints: z.unknown(),
+        ...actor,
+    })
+        .strict(),
+    getProductCampaign: z.object({ campaignRef: id }).strict(),
+    getCampaignAuthorization: z.object({ authorizationRef: id }).strict(),
+    revokeCampaignAuthorization: z
+        .object({
+        authorizationRef: id,
+        expectedAuthorizationVersion: version,
+        reason: id,
+        ...actor,
+    })
+        .strict(),
+    putProductDocument: z
+        .object({
+        documentRef: id,
+        campaignRef: id,
+        discussionRef: id,
+        documentType: id,
+        content: z.string().min(1),
+        expectedRevision: revision,
+        ...actor,
+    })
+        .strict(),
+    getProductDocument: z.object({ documentRef: id, campaignRef: id, discussionRef: id }).strict(),
+    submitProductTaskIntent: submitProductTaskIntentSchema,
+    transferProductIntentToTask: z
+        .object({
+        intentRef: id,
+        taskId: id,
+        expectedIntentVersion: version,
+        expectedTaskVersion: version,
+        ...actor,
+    })
+        .strict(),
+    recordProductGapReview: z
+        .object({
+        discussionRef: id,
+        campaignRef: id,
+        intentRef: id,
+        taskId: id,
+        gapIdentity: id,
+        progressEvidenceRefs: z.array(id),
+        terminalTaskVersion: version,
+        expectedIntentVersion: version,
+        ...actor,
+    })
+        .strict(),
+    recordProductGoalSatisfied: z
+        .object({
+        discussionRef: id,
+        campaignRef: id,
+        taskId: id,
+        goalRevision: version,
+        terminalTaskVersion: version,
+        expectedCampaignVersion: version,
+        closureSummary: id,
+        ...actor,
+    })
+        .strict(),
+    getProductContinuationProjection: continuationProjectionSchema,
+};
+const startTaskSchema = z
+    .object({
+    taskId: id,
+    expectedTaskVersion: version,
+    startAuthority: startAuthority.optional(),
+    ...actor,
+})
+    .strict();
+export const publicOperationNames = [
+    ...legacyPublicOperationNames,
+    ...phase4OperationNames,
+];
+export function validatePublicInput(operation, input) {
+    if (operation === "startTask")
+        return startTaskSchema.parse(input);
+    if (phase4OperationNames.includes(operation))
+        return phase4Schemas[operation].parse(input);
+    return validateLegacyPublicInput(operation, input);
+}

package/dist/src/phase4-model.d.ts

@@ -0,0 +1,122 @@
+import type { TaskRepositories, TaskStore } from "./model.ts";
+export type ProductCampaignStatus = "OPEN" | "CLOSED";
+export interface ProductCampaign {
+    campaignRef: string;
+    discussionRef: string;
+    goalRevision: number;
+    goalSummary: string;
+    scope: unknown;
+    constraints: unknown;
+    status: ProductCampaignStatus;
+    version: number;
+    createdByRef: string;
+    createdAt: string;
+    closedAt: string | null;
+    closureSummary: string | null;
+}
+export interface ProductIntent {
+    intentRef: string;
+    campaignRef: string | null;
+    discussionRef: string;
+    goalRevision: number;
+    intentRevision: number;
+    predecessorTaskId: string | null;
+    title: string;
+    objective: string;
+    scope: unknown;
+    constraints: unknown;
+    plan: unknown;
+    materializedTaskId: string | null;
+    version: number;
+    createdByRef: string;
+    createdAt: string;
+    materializedAt: string | null;
+}
+export interface ProductDocument {
+    documentRef: string;
+    campaignRef: string;
+    intentRef: string | null;
+    documentType: string;
+    filePath: string;
+    contentHash: string;
+    revision: number;
+    updatedByRef: string;
+    updatedAt: string;
+}
+export interface CampaignAuthorization {
+    authorizationRef: string;
+    campaignRef: string;
+    discussionRef: string;
+    goalRevision: number;
+    goalSummary: string;
+    scope: unknown;
+    constraints: unknown;
+    version: number;
+    createdByRef: string;
+    createdAt: string;
+    revokedAt: string | null;
+    revokedByRef: string | null;
+    revokeReason: string | null;
+}
+export interface ProductGapReview {
+    reviewRef: string;
+    campaignRef: string;
+    intentRef: string;
+    taskId: string;
+    discussionRef: string;
+    gapIdentity: string;
+    progressEvidenceRefs: string[];
+    terminalTaskVersion: number;
+    createdByRef: string;
+    createdAt: string;
+}
+export interface TaskProductLink {
+    taskId: string;
+    sourceProductIntentRef: string | null;
+    campaignRef: string | null;
+}
+export interface Phase4TaskRepositories {
+    productCampaigns: {
+        get(campaignRef: string): ProductCampaign | undefined;
+        insert(value: ProductCampaign): void;
+        update(value: ProductCampaign): void;
+    };
+    productIntents: {
+        get(intentRef: string): ProductIntent | undefined;
+        insert(value: ProductIntent): void;
+        update(value: ProductIntent): void;
+        listByCampaign(campaignRef: string): ProductIntent[];
+    };
+    productDocuments: {
+        get(documentRef: string): ProductDocument | undefined;
+        insert(value: ProductDocument): void;
+        update(value: ProductDocument): void;
+        bindIntent(input: {
+            documentRef: string;
+            intentRef: string;
+            expectedRevision: number;
+        }): void;
+        listByIntent(intentRef: string): ProductDocument[];
+    };
+    campaignAuthorizations: {
+        get(authorizationRef: string): CampaignAuthorization | undefined;
+        insert(value: CampaignAuthorization): void;
+        update(value: CampaignAuthorization): void;
+        listByCampaign(campaignRef: string): CampaignAuthorization[];
+    };
+    productGapReviews: {
+        getByIntent(intentRef: string): ProductGapReview | undefined;
+        getByTask(taskId: string): ProductGapReview | undefined;
+        insert(value: ProductGapReview): void;
+        listByCampaign(campaignRef: string): ProductGapReview[];
+    };
+    taskProductLinks: {
+        get(taskId: string): TaskProductLink | undefined;
+        set(value: TaskProductLink): void;
+    };
+}
+export type Phase4TaskRepositoryView = TaskRepositories & Phase4TaskRepositories;
+export interface Phase4TaskStore extends TaskStore {
+    phase4Transaction<T>(work: (repositories: Phase4TaskRepositoryView) => T): T;
+    phase4Read<T>(work: (repositories: Phase4TaskRepositoryView) => T): T;
+}

package/dist/src/phase4-model.js

@@ -0,0 +1 @@
+export {};

package/dist/src/phase4-services.d.ts

@@ -0,0 +1,118 @@
+import type { CampaignAuthorization, ProductCampaign, ProductGapReview, ProductIntent } from "./phase4-model.ts";
+import type { Task, TaskResult } from "./model.ts";
+import { createTaskServices as createLegacyTaskServices, type DocumentResult, type NodeResult, type TaskSummary, type TaskView } from "./services.ts";
+export type { DocumentResult, NodeResult, TaskSummary, TaskView } from "./services.ts";
+type ServiceOptions = Parameters<typeof createLegacyTaskServices>[0];
+export declare function createTaskServices(options: ServiceOptions): {
+    commands: {
+        createTaskGroup: (raw: unknown) => TaskResult<import("./model.ts").TaskGroup>;
+        startTaskGroup: (raw: unknown) => TaskResult<import("./model.ts").TaskGroup & {
+            firstEligibleTaskId: string | null;
+        }>;
+        createTask: (raw: unknown) => TaskResult<import("./services.ts").CreateTaskResult>;
+        bindTaskWorker: (raw: unknown) => TaskResult<import("./services.ts").BindTaskWorkerResult>;
+        pauseTask: (raw: unknown) => TaskResult<Task>;
+        resumeTask: (raw: unknown) => TaskResult<Task>;
+        terminateTask: (raw: unknown) => TaskResult<Task>;
+        startNode: (raw: unknown) => TaskResult<NodeResult>;
+        completeNode: (raw: unknown) => TaskResult<import("./services.ts").CompleteNodeResult>;
+        waitNode: (raw: unknown) => TaskResult<Task>;
+        failNode: (raw: unknown) => TaskResult<Task>;
+        reopenNode: (raw: unknown) => TaskResult<NodeResult & {
+            currentNodeId: string;
+        }>;
+        acknowledgeMessage: (raw: unknown) => TaskResult<import("./model.ts").TaskMessage>;
+        createCampaignAuthorization: (raw: unknown) => TaskResult<{
+            campaign: ProductCampaign;
+            authorization: CampaignAuthorization;
+        }>;
+        revokeCampaignAuthorization: (raw: unknown) => TaskResult<CampaignAuthorization>;
+        submitProductTaskIntent: (raw: unknown) => TaskResult<{
+            intentRef: string;
+            campaignRef: string | null;
+            taskId: string;
+            status: Task["status"];
+            version: number;
+            roleBindings: Array<{
+                agentPackageRef: string;
+                roleRef: string;
+                workerRef: null;
+                conversationLocator: null;
+            }>;
+        }>;
+        transferProductIntentToTask: (raw: unknown) => TaskResult<TaskView>;
+        recordProductGapReview: (raw: unknown) => TaskResult<ProductGapReview>;
+        recordProductGoalSatisfied: (raw: unknown) => TaskResult<ProductCampaign>;
+        startTask: (raw: unknown) => TaskResult<TaskView>;
+    };
+    queries: {
+        getTaskGroup: (raw: unknown) => TaskResult<import("./model.ts").TaskGroup & {
+            currentTaskId: string | null;
+            tasks: Task[];
+        }>;
+        listTasks: (raw: unknown) => TaskResult<{
+            tasks: TaskSummary[];
+        }>;
+        getTask: (raw: unknown) => TaskResult<TaskView>;
+        getTaskDriveProjection: (raw: unknown) => TaskResult<{
+            taskId: string;
+            taskStatus: Task["status"];
+            taskVersion: number;
+            terminal: boolean;
+            currentNode: {
+                nodeId: string;
+                status: import("./model.ts").NodeStatus;
+                version: number;
+                runNo: number;
+                requiredAgentPackageRef: string;
+            } | null;
+            roleBinding: {
+                agentPackageRef: string;
+                roleRef: string;
+                workerRef: string | null;
+                conversationLocator: string | null;
+            } | null;
+            canDrive: boolean;
+            blockedReason: string | null;
+            resumeSignalRef: string | null;
+        }>;
+        getNodeContext: (raw: unknown) => TaskResult<{
+            task: Pick<Task, "taskId" | "title" | "objective" | "status" | "version">;
+            node: Pick<import("./model.ts").TaskNode, "nodeId" | "title" | "objective" | "status" | "version" | "runNo" | "requiredAgentPackageRef" | "workerRef" | "inputDocuments" | "outputDocuments">;
+            documents: Array<{
+                documentType: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+            }>;
+        }>;
+        listPendingMessages: (raw: unknown) => TaskResult<{
+            messages: import("./model.ts").TaskMessage[];
+        }>;
+        listTaskEvents: (raw: unknown) => TaskResult<{
+            events: import("./model.ts").TaskEvent[];
+        }>;
+        getTaskDocument: (raw: unknown) => TaskResult<DocumentResult>;
+        getProductCampaign: (raw: unknown) => TaskResult<ProductCampaign>;
+        getCampaignAuthorization: (raw: unknown) => TaskResult<CampaignAuthorization>;
+        getProductContinuationProjection: (raw: unknown) => TaskResult<{
+            campaign: ProductCampaign;
+            intent: ProductIntent | null;
+            task: {
+                taskId: string;
+                status: Task["status"];
+                version: number;
+            } | null;
+            nextAction: "NONE" | "PROVISION" | "TRANSFER_REQUIREMENT" | "CONSIDER_START" | "PRODUCT_REVIEW_REQUIRED";
+        }>;
+    };
+    documents: {
+        putTaskDocument: (raw: unknown) => TaskResult<DocumentResult>;
+        reconcileDocumentIndex: (input: {
+            taskId: string;
+            actorRef: string;
+        }) => TaskResult<{
+            reconciled: number;
+        }>;
+    };
+};