@nt-ai-lab/deterministic-agent-workflow-engine 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export type { BaseWorkflowState } from './platform/domain/workflow-state';
+export { WorkflowStateError } from './platform/domain/workflow-state';
+export type { BaseEvent } from './platform/domain/base-event';
+export { baseEventSchema } from './platform/domain/base-event';
+export { engineEventSchema } from './platform/domain/engine-events';
+export type { EngineEvent, SessionStartedEvent, TransitionedEvent, AgentRegisteredEvent, AgentShutDownEvent, JournalEntryEvent, WriteCheckedEvent, BashCheckedEvent, PluginReadCheckedEvent, IdleCheckedEvent, IdentityVerifiedEvent, ContextRequestedEvent, } from './platform/domain/engine-events';
+export { repositoryMetadataEventSchema } from './platform/domain/repository-tracking-events';
+export type { DomainMetadataEvent, IssueRecordedEvent, BranchRecordedEvent, PrRecordedEvent, } from './platform/domain/repository-tracking-events';
+export { checkBashCommand } from './platform/domain/bash-enforcement';
+export type { PreconditionResult } from './platform/domain/precondition-result';
+export { pass, fail } from './platform/domain/precondition-result';
+export type { GitInfo, TransitionContext, BashForbiddenConfig, WorkflowStateDefinition, WorkflowRegistry, } from './platform/domain/workflow-registry';
+export { WorkflowEngine } from './platform/domain/workflow-engine';
+export type { EngineResult, RehydratableWorkflow, WorkflowDefinition, WorkflowEventStore, WorkflowEngineDeps, } from './platform/domain/workflow-engine-types';
+export type { TranscriptMessage, TranscriptReader } from './platform/infra/external-clients/transcript/transcript-reader';
+export type { IdentityCheckResult } from './platform/domain/identity-verification';
+export { checkIdentity } from './platform/domain/identity-verification';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { WorkflowStateError } from './platform/domain/workflow-state.js';
+export { baseEventSchema } from './platform/domain/base-event.js';
+export { engineEventSchema } from './platform/domain/engine-events.js';
+export { repositoryMetadataEventSchema } from './platform/domain/repository-tracking-events.js';
+export { checkBashCommand } from './platform/domain/bash-enforcement.js';
+export { pass, fail } from './platform/domain/precondition-result.js';
+export { WorkflowEngine } from './platform/domain/workflow-engine.js';
+export { checkIdentity } from './platform/domain/identity-verification.js';

package/dist/platform/domain/base-event.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const baseEventSchema: z.ZodObject<{
+    type: z.ZodString;
+    at: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+    at: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    at: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+/** @riviere-role value-object */
+export type BaseEvent = z.infer<typeof baseEventSchema>;

package/dist/platform/domain/base-event.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export const baseEventSchema = z.object({
+    type: z.string(),
+    at: z.string(),
+}).passthrough();

package/dist/platform/domain/bash-enforcement.d.ts

@@ -0,0 +1,4 @@
+import { type PreconditionResult } from './precondition-result';
+import type { BashForbiddenConfig } from './workflow-registry';
+/** @riviere-role domain-service */
+export declare function checkBashCommand(command: string, forbidden: BashForbiddenConfig, stateExemptions: readonly string[]): PreconditionResult;

package/dist/platform/domain/bash-enforcement.js

@@ -0,0 +1,24 @@
+import { fail, pass } from './precondition-result.js';
+function buildCommandPattern(command) {
+    const parts = command.trim().split(/\s+/);
+    const escapedParts = parts.map((part) => part.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const patternBody = escapedParts.join('\\s+');
+    return new RegExp(`(?:^|\\s|&&|;)${patternBody}(?:\\s|$|-|;|&)`);
+}
+/** @riviere-role domain-service */
+export function checkBashCommand(command, forbidden, stateExemptions) {
+    for (const flag of forbidden.flags ?? []) {
+        if (command.includes(flag)) {
+            return fail(`Forbidden flag '${flag}' in command.`);
+        }
+    }
+    for (const forbiddenCommand of forbidden.commands) {
+        if (stateExemptions.includes(forbiddenCommand))
+            continue;
+        const pattern = buildCommandPattern(forbiddenCommand);
+        if (pattern.test(command)) {
+            return fail(`Forbidden command '${forbiddenCommand}' in command.`);
+        }
+    }
+    return pass();
+}

package/dist/platform/domain/engine-events.d.ts

@@ -0,0 +1,434 @@
+import { z } from 'zod';
+declare const sessionStartedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session-started">;
+    at: z.ZodString;
+    transcriptPath: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    currentState: z.ZodOptional<z.ZodString>;
+    states: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "session-started";
+    at: string;
+    transcriptPath?: string | undefined;
+    repository?: string | undefined;
+    currentState?: string | undefined;
+    states?: string[] | undefined;
+}, {
+    type: "session-started";
+    at: string;
+    transcriptPath?: string | undefined;
+    repository?: string | undefined;
+    currentState?: string | undefined;
+    states?: string[] | undefined;
+}>;
+declare const transitionedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"transitioned">;
+    at: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    preBlockedState: z.ZodOptional<z.ZodString>;
+    iteration: z.ZodOptional<z.ZodNumber>;
+    developingHeadCommit: z.ZodOptional<z.ZodString>;
+    developerDone: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "transitioned";
+    at: string;
+    from: string;
+    to: string;
+    preBlockedState?: string | undefined;
+    iteration?: number | undefined;
+    developingHeadCommit?: string | undefined;
+    developerDone?: boolean | undefined;
+}, {
+    type: "transitioned";
+    at: string;
+    from: string;
+    to: string;
+    preBlockedState?: string | undefined;
+    iteration?: number | undefined;
+    developingHeadCommit?: string | undefined;
+    developerDone?: boolean | undefined;
+}>;
+declare const agentRegisteredSchema: z.ZodObject<{
+    type: z.ZodLiteral<"agent-registered">;
+    at: z.ZodString;
+    agentType: z.ZodString;
+    agentId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "agent-registered";
+    at: string;
+    agentType: string;
+    agentId: string;
+}, {
+    type: "agent-registered";
+    at: string;
+    agentType: string;
+    agentId: string;
+}>;
+declare const agentShutDownSchema: z.ZodObject<{
+    type: z.ZodLiteral<"agent-shut-down">;
+    at: z.ZodString;
+    agentName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "agent-shut-down";
+    at: string;
+    agentName: string;
+}, {
+    type: "agent-shut-down";
+    at: string;
+    agentName: string;
+}>;
+declare const journalEntrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"journal-entry">;
+    at: z.ZodString;
+    agentName: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "journal-entry";
+    at: string;
+    agentName: string;
+    content: string;
+}, {
+    type: "journal-entry";
+    at: string;
+    agentName: string;
+    content: string;
+}>;
+declare const writeCheckedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"write-checked">;
+    at: z.ZodString;
+    tool: z.ZodString;
+    filePath: z.ZodString;
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "write-checked";
+    at: string;
+    tool: string;
+    filePath: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}, {
+    type: "write-checked";
+    at: string;
+    tool: string;
+    filePath: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}>;
+declare const bashCheckedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bash-checked">;
+    at: z.ZodString;
+    tool: z.ZodString;
+    command: z.ZodString;
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "bash-checked";
+    at: string;
+    tool: string;
+    allowed: boolean;
+    command: string;
+    reason?: string | undefined;
+}, {
+    type: "bash-checked";
+    at: string;
+    tool: string;
+    allowed: boolean;
+    command: string;
+    reason?: string | undefined;
+}>;
+declare const pluginReadCheckedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"plugin-read-checked">;
+    at: z.ZodString;
+    tool: z.ZodString;
+    path: z.ZodString;
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "plugin-read-checked";
+    at: string;
+    path: string;
+    tool: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}, {
+    type: "plugin-read-checked";
+    at: string;
+    path: string;
+    tool: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}>;
+declare const idleCheckedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"idle-checked">;
+    at: z.ZodString;
+    agentName: z.ZodString;
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "idle-checked";
+    at: string;
+    agentName: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}, {
+    type: "idle-checked";
+    at: string;
+    agentName: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}>;
+declare const identityVerifiedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"identity-verified">;
+    at: z.ZodString;
+    status: z.ZodString;
+    transcriptPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "identity-verified";
+    at: string;
+    status: string;
+    transcriptPath: string;
+}, {
+    type: "identity-verified";
+    at: string;
+    status: string;
+    transcriptPath: string;
+}>;
+declare const contextRequestedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"context-requested">;
+    at: z.ZodString;
+    agentName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "context-requested";
+    at: string;
+    agentName: string;
+}, {
+    type: "context-requested";
+    at: string;
+    agentName: string;
+}>;
+export declare const engineEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"session-started">;
+    at: z.ZodString;
+    transcriptPath: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    currentState: z.ZodOptional<z.ZodString>;
+    states: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "session-started";
+    at: string;
+    transcriptPath?: string | undefined;
+    repository?: string | undefined;
+    currentState?: string | undefined;
+    states?: string[] | undefined;
+}, {
+    type: "session-started";
+    at: string;
+    transcriptPath?: string | undefined;
+    repository?: string | undefined;
+    currentState?: string | undefined;
+    states?: string[] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"transitioned">;
+    at: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    preBlockedState: z.ZodOptional<z.ZodString>;
+    iteration: z.ZodOptional<z.ZodNumber>;
+    developingHeadCommit: z.ZodOptional<z.ZodString>;
+    developerDone: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "transitioned";
+    at: string;
+    from: string;
+    to: string;
+    preBlockedState?: string | undefined;
+    iteration?: number | undefined;
+    developingHeadCommit?: string | undefined;
+    developerDone?: boolean | undefined;
+}, {
+    type: "transitioned";
+    at: string;
+    from: string;
+    to: string;
+    preBlockedState?: string | undefined;
+    iteration?: number | undefined;
+    developingHeadCommit?: string | undefined;
+    developerDone?: boolean | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"agent-registered">;
+    at: z.ZodString;
+    agentType: z.ZodString;
+    agentId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "agent-registered";
+    at: string;
+    agentType: string;
+    agentId: string;
+}, {
+    type: "agent-registered";
+    at: string;
+    agentType: string;
+    agentId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"agent-shut-down">;
+    at: z.ZodString;
+    agentName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "agent-shut-down";
+    at: string;
+    agentName: string;
+}, {
+    type: "agent-shut-down";
+    at: string;
+    agentName: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"journal-entry">;
+    at: z.ZodString;
+    agentName: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "journal-entry";
+    at: string;
+    agentName: string;
+    content: string;
+}, {
+    type: "journal-entry";
+    at: string;
+    agentName: string;
+    content: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"write-checked">;
+    at: z.ZodString;
+    tool: z.ZodString;
+    filePath: z.ZodString;
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "write-checked";
+    at: string;
+    tool: string;
+    filePath: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}, {
+    type: "write-checked";
+    at: string;
+    tool: string;
+    filePath: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"bash-checked">;
+    at: z.ZodString;
+    tool: z.ZodString;
+    command: z.ZodString;
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "bash-checked";
+    at: string;
+    tool: string;
+    allowed: boolean;
+    command: string;
+    reason?: string | undefined;
+}, {
+    type: "bash-checked";
+    at: string;
+    tool: string;
+    allowed: boolean;
+    command: string;
+    reason?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"plugin-read-checked">;
+    at: z.ZodString;
+    tool: z.ZodString;
+    path: z.ZodString;
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "plugin-read-checked";
+    at: string;
+    path: string;
+    tool: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}, {
+    type: "plugin-read-checked";
+    at: string;
+    path: string;
+    tool: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"idle-checked">;
+    at: z.ZodString;
+    agentName: z.ZodString;
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "idle-checked";
+    at: string;
+    agentName: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}, {
+    type: "idle-checked";
+    at: string;
+    agentName: string;
+    allowed: boolean;
+    reason?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"identity-verified">;
+    at: z.ZodString;
+    status: z.ZodString;
+    transcriptPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "identity-verified";
+    at: string;
+    status: string;
+    transcriptPath: string;
+}, {
+    type: "identity-verified";
+    at: string;
+    status: string;
+    transcriptPath: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"context-requested">;
+    at: z.ZodString;
+    agentName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "context-requested";
+    at: string;
+    agentName: string;
+}, {
+    type: "context-requested";
+    at: string;
+    agentName: string;
+}>]>;
+/** @riviere-role value-object */
+export type EngineEvent = z.infer<typeof engineEventSchema>;
+/** @riviere-role value-object */
+export type SessionStartedEvent = z.infer<typeof sessionStartedSchema>;
+/** @riviere-role value-object */
+export type TransitionedEvent = z.infer<typeof transitionedSchema>;
+/** @riviere-role value-object */
+export type AgentRegisteredEvent = z.infer<typeof agentRegisteredSchema>;
+/** @riviere-role value-object */
+export type AgentShutDownEvent = z.infer<typeof agentShutDownSchema>;
+/** @riviere-role value-object */
+export type JournalEntryEvent = z.infer<typeof journalEntrySchema>;
+/** @riviere-role value-object */
+export type WriteCheckedEvent = z.infer<typeof writeCheckedSchema>;
+/** @riviere-role value-object */
+export type BashCheckedEvent = z.infer<typeof bashCheckedSchema>;
+/** @riviere-role value-object */
+export type PluginReadCheckedEvent = z.infer<typeof pluginReadCheckedSchema>;
+/** @riviere-role value-object */
+export type IdleCheckedEvent = z.infer<typeof idleCheckedSchema>;
+/** @riviere-role value-object */
+export type IdentityVerifiedEvent = z.infer<typeof identityVerifiedSchema>;
+/** @riviere-role value-object */
+export type ContextRequestedEvent = z.infer<typeof contextRequestedSchema>;
+export {};

package/dist/platform/domain/engine-events.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+const sessionStartedSchema = z.object({
+    type: z.literal('session-started'),
+    at: z.string(),
+    transcriptPath: z.string().optional(),
+    repository: z.string().optional(),
+    currentState: z.string().optional(),
+    states: z.array(z.string()).optional(),
+});
+const transitionedSchema = z.object({
+    type: z.literal('transitioned'),
+    at: z.string(),
+    from: z.string(),
+    to: z.string(),
+    preBlockedState: z.string().optional(),
+    iteration: z.number().optional(),
+    developingHeadCommit: z.string().optional(),
+    developerDone: z.boolean().optional(),
+});
+const agentRegisteredSchema = z.object({
+    type: z.literal('agent-registered'),
+    at: z.string(),
+    agentType: z.string(),
+    agentId: z.string(),
+});
+const agentShutDownSchema = z.object({
+    type: z.literal('agent-shut-down'),
+    at: z.string(),
+    agentName: z.string(),
+});
+const journalEntrySchema = z.object({
+    type: z.literal('journal-entry'),
+    at: z.string(),
+    agentName: z.string(),
+    content: z.string(),
+});
+const writeCheckedSchema = z.object({
+    type: z.literal('write-checked'),
+    at: z.string(),
+    tool: z.string(),
+    filePath: z.string(),
+    allowed: z.boolean(),
+    reason: z.string().optional(),
+});
+const bashCheckedSchema = z.object({
+    type: z.literal('bash-checked'),
+    at: z.string(),
+    tool: z.string(),
+    command: z.string(),
+    allowed: z.boolean(),
+    reason: z.string().optional(),
+});
+const pluginReadCheckedSchema = z.object({
+    type: z.literal('plugin-read-checked'),
+    at: z.string(),
+    tool: z.string(),
+    path: z.string(),
+    allowed: z.boolean(),
+    reason: z.string().optional(),
+});
+const idleCheckedSchema = z.object({
+    type: z.literal('idle-checked'),
+    at: z.string(),
+    agentName: z.string(),
+    allowed: z.boolean(),
+    reason: z.string().optional(),
+});
+const identityVerifiedSchema = z.object({
+    type: z.literal('identity-verified'),
+    at: z.string(),
+    status: z.string(),
+    transcriptPath: z.string(),
+});
+const contextRequestedSchema = z.object({
+    type: z.literal('context-requested'),
+    at: z.string(),
+    agentName: z.string(),
+});
+export const engineEventSchema = z.discriminatedUnion('type', [
+    sessionStartedSchema,
+    transitionedSchema,
+    agentRegisteredSchema,
+    agentShutDownSchema,
+    journalEntrySchema,
+    writeCheckedSchema,
+    bashCheckedSchema,
+    pluginReadCheckedSchema,
+    idleCheckedSchema,
+    identityVerifiedSchema,
+    contextRequestedSchema,
+]);

package/dist/platform/domain/identity-verification.d.ts

@@ -0,0 +1,13 @@
+import type { TranscriptMessage } from '../infra/external-clients/transcript/transcript-reader';
+/** @riviere-role value-object */
+export type IdentityCheckResult = {
+    readonly status: 'verified';
+} | {
+    readonly status: 'never-spoken';
+} | {
+    readonly status: 'silent-turn';
+} | {
+    readonly status: 'lost';
+};
+/** @riviere-role domain-service */
+export declare function checkIdentity(messages: readonly TranscriptMessage[], pattern: RegExp): IdentityCheckResult;

package/dist/platform/domain/identity-verification.js

@@ -0,0 +1,19 @@
+/** @riviere-role domain-service */
+export function checkIdentity(messages, pattern) {
+    const textMessages = messages.filter((message) => message.textContent !== undefined);
+    if (textMessages.length === 0) {
+        return { status: 'never-spoken' };
+    }
+    const hasEverSpokenWithPrefix = textMessages.some((message) => message.textContent !== undefined && pattern.test(message.textContent));
+    if (!hasEverSpokenWithPrefix) {
+        return { status: 'lost' };
+    }
+    const lastMessage = messages.at(-1);
+    if (lastMessage?.textContent === undefined) {
+        return { status: 'silent-turn' };
+    }
+    if (pattern.test(lastMessage.textContent)) {
+        return { status: 'verified' };
+    }
+    return { status: 'lost' };
+}

package/dist/platform/domain/precondition-result.d.ts

@@ -0,0 +1,9 @@
+/** @riviere-role value-object */
+export type PreconditionResult = {
+    readonly pass: true;
+} | {
+    readonly pass: false;
+    readonly reason: string;
+};
+export declare const pass: () => PreconditionResult;
+export declare const fail: (reason: string) => PreconditionResult;

package/dist/platform/domain/precondition-result.js

@@ -0,0 +1,5 @@
+export const pass = () => ({ pass: true });
+export const fail = (reason) => ({
+    pass: false,
+    reason
+});