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

package/dist/platform/domain/repository-tracking-events.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+declare const issueRecordedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"issue-recorded">;
+    at: z.ZodString;
+    issueNumber: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "issue-recorded";
+    at: string;
+    issueNumber: number;
+}, {
+    type: "issue-recorded";
+    at: string;
+    issueNumber: number;
+}>;
+declare const branchRecordedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"branch-recorded">;
+    at: z.ZodString;
+    branch: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "branch-recorded";
+    at: string;
+    branch: string;
+}, {
+    type: "branch-recorded";
+    at: string;
+    branch: string;
+}>;
+declare const prRecordedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pr-recorded">;
+    at: z.ZodString;
+    prNumber: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "pr-recorded";
+    at: string;
+    prNumber: number;
+}, {
+    type: "pr-recorded";
+    at: string;
+    prNumber: number;
+}>;
+export declare const repositoryMetadataEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"issue-recorded">;
+    at: z.ZodString;
+    issueNumber: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "issue-recorded";
+    at: string;
+    issueNumber: number;
+}, {
+    type: "issue-recorded";
+    at: string;
+    issueNumber: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"branch-recorded">;
+    at: z.ZodString;
+    branch: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "branch-recorded";
+    at: string;
+    branch: string;
+}, {
+    type: "branch-recorded";
+    at: string;
+    branch: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"pr-recorded">;
+    at: z.ZodString;
+    prNumber: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "pr-recorded";
+    at: string;
+    prNumber: number;
+}, {
+    type: "pr-recorded";
+    at: string;
+    prNumber: number;
+}>]>;
+/** @riviere-role value-object */
+export type DomainMetadataEvent = z.infer<typeof repositoryMetadataEventSchema>;
+/** @riviere-role value-object */
+export type IssueRecordedEvent = z.infer<typeof issueRecordedSchema>;
+/** @riviere-role value-object */
+export type BranchRecordedEvent = z.infer<typeof branchRecordedSchema>;
+/** @riviere-role value-object */
+export type PrRecordedEvent = z.infer<typeof prRecordedSchema>;
+export {};

package/dist/platform/domain/repository-tracking-events.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+const issueRecordedSchema = z.object({
+    type: z.literal('issue-recorded'),
+    at: z.string(),
+    issueNumber: z.number(),
+});
+const branchRecordedSchema = z.object({
+    type: z.literal('branch-recorded'),
+    at: z.string(),
+    branch: z.string(),
+});
+const prRecordedSchema = z.object({
+    type: z.literal('pr-recorded'),
+    at: z.string(),
+    prNumber: z.number(),
+});
+export const repositoryMetadataEventSchema = z.discriminatedUnion('type', [
+    issueRecordedSchema,
+    branchRecordedSchema,
+    prRecordedSchema,
+]);

package/dist/platform/domain/workflow-engine-support.d.ts

@@ -0,0 +1,13 @@
+import type { BaseEvent } from './base-event';
+import type { WorkflowEngineDeps } from './workflow-engine-types';
+import type { WorkflowRegistry } from './workflow-registry';
+/** @riviere-role domain-service */
+export declare function buildPrefixPattern<TStateName extends string, TState>(registry: WorkflowRegistry<TState, TStateName, string>): RegExp;
+/** @riviere-role domain-service */
+export declare function getExpectedPrefix<TStateName extends string, TState, TOperation extends string>(stateName: TStateName, registry: WorkflowRegistry<TState, TStateName, TOperation>): string;
+/** @riviere-role domain-service */
+export declare function buildProcedurePath<TStateName extends string>(engineDeps: WorkflowEngineDeps, stateName: TStateName): string;
+/** @riviere-role domain-service */
+export declare function readProcedure<TStateName extends string>(engineDeps: WorkflowEngineDeps, stateName: TStateName): string;
+/** @riviere-role domain-service */
+export declare function enrichSessionStartedEvents<TStateName extends string>(engineDeps: WorkflowEngineDeps, events: readonly BaseEvent[], transcriptPath: string, repository: string, currentState: TStateName, states: readonly string[]): readonly BaseEvent[];

package/dist/platform/domain/workflow-engine-support.js

@@ -0,0 +1,47 @@
+/** @riviere-role domain-service */
+export function buildPrefixPattern(registry) {
+    const prefixes = [];
+    for (const stateName in registry) {
+        const definition = registry[stateName];
+        prefixes.push(`${definition.emoji} ${stateName}`);
+    }
+    return new RegExp(`^(${prefixes.join('|')})`);
+}
+/** @riviere-role domain-service */
+export function getExpectedPrefix(stateName, registry) {
+    return `${registry[stateName].emoji} ${stateName}`;
+}
+/** @riviere-role domain-service */
+export function buildProcedurePath(engineDeps, stateName) {
+    return `${engineDeps.getPluginRoot()}/states/${String(stateName).toLowerCase()}.md`;
+}
+/** @riviere-role domain-service */
+export function readProcedure(engineDeps, stateName) {
+    return engineDeps.readFile(buildProcedurePath(engineDeps, stateName));
+}
+/** @riviere-role domain-service */
+export function enrichSessionStartedEvents(engineDeps, events, transcriptPath, repository, currentState, states) {
+    const enriched = events.map((event) => {
+        if (event.type !== 'session-started') {
+            return event;
+        }
+        return {
+            ...event,
+            transcriptPath,
+            repository,
+            currentState,
+            states: [...states],
+        };
+    });
+    if (enriched.some((event) => event.type === 'session-started')) {
+        return enriched;
+    }
+    return [{
+            type: 'session-started',
+            at: engineDeps.now(),
+            transcriptPath,
+            repository,
+            currentState,
+            states: [...states],
+        }, ...enriched];
+}

package/dist/platform/domain/workflow-engine-types.d.ts

@@ -0,0 +1,57 @@
+import type { ZodType } from 'zod';
+import type { BaseEvent } from './base-event';
+import type { PreconditionResult } from './precondition-result';
+import type { TranscriptReader } from '../infra/external-clients/transcript/transcript-reader';
+import type { BaseWorkflowState } from './workflow-state';
+import type { TransitionContext, WorkflowRegistry } from './workflow-registry';
+/** @riviere-role value-object */
+export type EngineResult = {
+    readonly type: 'success';
+    readonly output: string;
+} | {
+    readonly type: 'blocked';
+    readonly output: string;
+} | {
+    readonly type: 'error';
+    readonly output: string;
+};
+/** @riviere-role value-object */
+export interface RehydratableWorkflow<TState extends BaseWorkflowState> {
+    getState(): TState;
+    appendEvent(event: BaseEvent): void;
+    getPendingEvents(): readonly BaseEvent[];
+    startSession(transcriptPath: string, repository: string | undefined): void;
+    getTranscriptPath(): string;
+    registerAgent(agentType: string, agentId: string): PreconditionResult;
+    handleTeammateIdle(agentName: string): PreconditionResult;
+}
+/** @riviere-role value-object */
+export interface WorkflowDefinition<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string> {
+    fold(state: TState, event: BaseEvent): TState;
+    buildWorkflow(state: TState, deps: TDeps): TWorkflow;
+    stateSchema: ZodType<TStateName>;
+    initialState(): TState;
+    getRegistry(): WorkflowRegistry<TState, TStateName, TOperation>;
+    buildTransitionContext(state: TState, from: TStateName, to: TStateName, deps: TDeps): TransitionContext<TState, TStateName>;
+    getOperationBody?(op: string, state: TState): string;
+    getTransitionTitle?(to: TStateName, state: TState): string;
+    buildTransitionEvent?(from: TStateName, to: TStateName, stateBefore: TState, stateAfter: TState, now: string): BaseEvent;
+}
+/** @riviere-role value-object */
+export interface WorkflowEventStore {
+    readEvents(sessionId: string): readonly BaseEvent[];
+    appendEvents(sessionId: string, events: readonly BaseEvent[]): void;
+    sessionExists(sessionId: string): boolean;
+    hasSessionStarted(sessionId: string): boolean;
+}
+/** @riviere-role value-object */
+export type WorkflowEngineDeps = {
+    readonly store: WorkflowEventStore;
+    readonly getPluginRoot: () => string;
+    readonly getEnvFilePath: () => string;
+    readonly getRepositoryName?: () => string | undefined;
+    readonly readFile: (path: string) => string;
+    readonly appendToFile: (filePath: string, content: string) => void;
+    readonly now: () => string;
+    readonly transcriptReader: TranscriptReader;
+};

package/dist/platform/domain/workflow-engine-types.js

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

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

@@ -0,0 +1,23 @@
+import type { PreconditionResult } from './precondition-result';
+import type { BashForbiddenConfig } from './workflow-registry';
+import type { EngineResult, RehydratableWorkflow, WorkflowDefinition, WorkflowEngineDeps } from './workflow-engine-types';
+import type { BaseWorkflowState } from './workflow-state';
+/** @riviere-role domain-service */
+export declare class WorkflowEngine<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string> {
+    private readonly factory;
+    private readonly engineDeps;
+    private readonly workflowDeps;
+    constructor(factory: WorkflowDefinition<TWorkflow, TState, TDeps, TStateName, TOperation>, engineDeps: WorkflowEngineDeps, workflowDeps: TDeps);
+    startSession(sessionId: string, transcriptPath: string, repository?: string): EngineResult;
+    transaction(sessionId: string, op: string, fn: (workflow: TWorkflow) => PreconditionResult): EngineResult;
+    transition(sessionId: string, target: TStateName): EngineResult;
+    checkBash(sessionId: string, toolName: string, command: string, bashForbidden: BashForbiddenConfig): EngineResult;
+    checkWrite(sessionId: string, toolName: string, filePath: string, isWriteAllowed: (filePath: string, state: TState) => boolean): EngineResult;
+    persistSessionId(sessionId: string): void;
+    hasSession(sessionId: string): boolean;
+    hasSessionStarted(sessionId: string): boolean;
+    private requireSession;
+    private rehydrateFromEvents;
+    private persistEvents;
+    private verifyIdentity;
+}

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

@@ -0,0 +1,325 @@
+import { checkBashCommand } from './bash-enforcement.js';
+import { checkIdentity } from './identity-verification.js';
+import { buildPrefixPattern, buildProcedurePath, enrichSessionStartedEvents, getExpectedPrefix, readProcedure, } from './workflow-engine-support.js';
+import { formatIllegalTransitionError, formatInitSuccess, formatOperationGateError, formatOperationSuccess, formatTransitionError, formatTransitionSuccess, } from '../infra/cli/presentation/output-guidance.js';
+import { WorkflowStateError } from './workflow-state.js';
+/** @riviere-role domain-service */
+export class WorkflowEngine {
+    factory;
+    engineDeps;
+    workflowDeps;
+    constructor(factory, engineDeps, workflowDeps) {
+        this.factory = factory;
+        this.engineDeps = engineDeps;
+        this.workflowDeps = workflowDeps;
+    }
+    startSession(sessionId, transcriptPath, repository) {
+        if (this.engineDeps.store.hasSessionStarted(sessionId)) {
+            return {
+                type: 'success',
+                output: ''
+            };
+        }
+        const initialState = this.factory.initialState();
+        const workflow = this.factory.buildWorkflow(initialState, this.workflowDeps);
+        const resolvedRepository = repository ?? this.engineDeps.getRepositoryName?.();
+        if (resolvedRepository === undefined || resolvedRepository === '') {
+            return {
+                type: 'error',
+                output: 'Could not determine repository name for session-started event.'
+            };
+        }
+        workflow.startSession(transcriptPath, resolvedRepository);
+        const registry = this.factory.getRegistry();
+        const stateNames = Object.keys(registry);
+        const pendingEvents = enrichSessionStartedEvents(this.engineDeps, workflow.getPendingEvents(), transcriptPath, resolvedRepository, initialState.currentStateMachineState, stateNames);
+        this.engineDeps.store.appendEvents(sessionId, pendingEvents);
+        const procedureContent = this.engineDeps.readFile(buildProcedurePath(this.engineDeps, initialState.currentStateMachineState));
+        const expectedPrefix = getExpectedPrefix(initialState.currentStateMachineState, registry);
+        return {
+            type: 'success',
+            output: formatInitSuccess(procedureContent, expectedPrefix)
+        };
+    }
+    transaction(sessionId, op, fn) {
+        this.requireSession(sessionId);
+        const workflow = this.rehydrateFromEvents(sessionId);
+        const registry = this.factory.getRegistry();
+        const identityResult = this.verifyIdentity(sessionId, workflow);
+        if (identityResult !== undefined) {
+            this.persistEvents(sessionId, workflow);
+            const currentPrefix = getExpectedPrefix(workflow.getState().currentStateMachineState, registry);
+            return {
+                type: 'blocked',
+                output: formatOperationGateError(op, identityResult, currentPrefix)
+            };
+        }
+        const result = fn(workflow);
+        this.persistEvents(sessionId, workflow);
+        const currentPrefix = getExpectedPrefix(workflow.getState().currentStateMachineState, registry);
+        if (!result.pass) {
+            return {
+                type: 'blocked',
+                output: formatOperationGateError(op, result.reason, currentPrefix)
+            };
+        }
+        const body = this.factory.getOperationBody?.(op, workflow.getState()) ?? op;
+        return {
+            type: 'success',
+            output: formatOperationSuccess(op, body, currentPrefix)
+        };
+    }
+    transition(sessionId, target) {
+        this.requireSession(sessionId);
+        const workflow = this.rehydrateFromEvents(sessionId);
+        const state = workflow.getState();
+        const currentStateName = state.currentStateMachineState;
+        const registry = this.factory.getRegistry();
+        const identityResult = this.verifyIdentity(sessionId, workflow);
+        if (identityResult !== undefined) {
+            this.persistEvents(sessionId, workflow);
+            const currentPrefix = getExpectedPrefix(currentStateName, registry);
+            return {
+                type: 'blocked',
+                output: formatOperationGateError('transition', identityResult, currentPrefix)
+            };
+        }
+        const currentDef = registry[currentStateName];
+        if (!currentDef.canTransitionTo.includes(target)) {
+            const legalTargets = currentDef.canTransitionTo;
+            const reason = `Illegal transition ${currentStateName} -> ${target}. Legal targets from ${currentStateName}: [${legalTargets.join(', ') || 'none'}].`;
+            const currentProcedure = readProcedure(this.engineDeps, workflow.getState().currentStateMachineState);
+            const currentPrefix = getExpectedPrefix(currentStateName, registry);
+            return {
+                type: 'blocked',
+                output: formatIllegalTransitionError(reason, currentProcedure, currentPrefix)
+            };
+        }
+        if (target !== 'BLOCKED' && currentDef.transitionGuard) {
+            const context = this.factory.buildTransitionContext(state, currentStateName, target, this.workflowDeps);
+            const guardResult = currentDef.transitionGuard(context);
+            if (!guardResult.pass) {
+                const currentProcedure = readProcedure(this.engineDeps, workflow.getState().currentStateMachineState);
+                const currentPrefix = getExpectedPrefix(currentStateName, registry);
+                return {
+                    type: 'blocked',
+                    output: formatTransitionError(target, guardResult.reason, currentProcedure, currentPrefix),
+                };
+            }
+        }
+        const targetDef = registry[target];
+        const stateBefore = workflow.getState();
+        const context = this.factory.buildTransitionContext(stateBefore, currentStateName, target, this.workflowDeps);
+        const stateAfter = targetDef.onEntry ? targetDef.onEntry(stateBefore, context) : stateBefore;
+        const transitionEvent = this.factory.buildTransitionEvent
+            ? this.factory.buildTransitionEvent(currentStateName, target, stateBefore, stateAfter, this.engineDeps.now())
+            : {
+                type: 'transitioned',
+                at: this.engineDeps.now(),
+                from: currentStateName,
+                to: target
+            };
+        workflow.appendEvent(transitionEvent);
+        targetDef.afterEntry?.();
+        this.persistEvents(sessionId, workflow);
+        const newState = workflow.getState();
+        const title = this.factory.getTransitionTitle?.(newState.currentStateMachineState, newState)
+            ?? newState.currentStateMachineState;
+        const procedure = readProcedure(this.engineDeps, workflow.getState().currentStateMachineState);
+        const newPrefix = getExpectedPrefix(newState.currentStateMachineState, registry);
+        return {
+            type: 'success',
+            output: formatTransitionSuccess(title, procedure, newPrefix)
+        };
+    }
+    checkBash(sessionId, toolName, command, bashForbidden) {
+        this.requireSession(sessionId);
+        const workflow = this.rehydrateFromEvents(sessionId);
+        const registry = this.factory.getRegistry();
+        const currentStateName = workflow.getState().currentStateMachineState;
+        const currentPrefix = getExpectedPrefix(currentStateName, registry);
+        const identityResult = this.verifyIdentity(sessionId, workflow);
+        if (identityResult !== undefined) {
+            this.persistEvents(sessionId, workflow);
+            return {
+                type: 'blocked',
+                output: formatOperationGateError('bash-check', identityResult, currentPrefix)
+            };
+        }
+        if (toolName !== 'Bash') {
+            workflow.appendEvent({
+                type: 'bash-checked',
+                at: this.engineDeps.now(),
+                tool: toolName,
+                command,
+                allowed: true
+            });
+            this.persistEvents(sessionId, workflow);
+            return {
+                type: 'success',
+                output: ''
+            };
+        }
+        const exemptions = registry[currentStateName].allowForbidden?.bash ?? [];
+        const result = checkBashCommand(command, bashForbidden, exemptions);
+        if (!result.pass) {
+            const reason = `Bash command blocked in ${currentStateName}. ${result.reason}`;
+            workflow.appendEvent({
+                type: 'bash-checked',
+                at: this.engineDeps.now(),
+                tool: toolName,
+                command,
+                allowed: false,
+                reason,
+            });
+            this.persistEvents(sessionId, workflow);
+            return {
+                type: 'blocked',
+                output: formatOperationGateError('bash-check', reason, currentPrefix)
+            };
+        }
+        workflow.appendEvent({
+            type: 'bash-checked',
+            at: this.engineDeps.now(),
+            tool: toolName,
+            command,
+            allowed: true
+        });
+        this.persistEvents(sessionId, workflow);
+        return {
+            type: 'success',
+            output: ''
+        };
+    }
+    checkWrite(sessionId, toolName, filePath, isWriteAllowed) {
+        this.requireSession(sessionId);
+        const workflow = this.rehydrateFromEvents(sessionId);
+        const registry = this.factory.getRegistry();
+        const currentStateName = workflow.getState().currentStateMachineState;
+        const currentPrefix = getExpectedPrefix(currentStateName, registry);
+        const identityResult = this.verifyIdentity(sessionId, workflow);
+        if (identityResult !== undefined) {
+            this.persistEvents(sessionId, workflow);
+            return {
+                type: 'blocked',
+                output: formatOperationGateError('write-check', identityResult, currentPrefix)
+            };
+        }
+        const writeTools = new Set(['Write', 'Edit', 'NotebookEdit']);
+        if (!writeTools.has(toolName)) {
+            workflow.appendEvent({
+                type: 'write-checked',
+                at: this.engineDeps.now(),
+                tool: toolName,
+                filePath,
+                allowed: true
+            });
+            this.persistEvents(sessionId, workflow);
+            return {
+                type: 'success',
+                output: ''
+            };
+        }
+        const storePath = `${this.engineDeps.getPluginRoot()}/workflow.db`;
+        if (filePath === storePath) {
+            workflow.appendEvent({
+                type: 'write-checked',
+                at: this.engineDeps.now(),
+                tool: toolName,
+                filePath,
+                allowed: true
+            });
+            this.persistEvents(sessionId, workflow);
+            return {
+                type: 'success',
+                output: ''
+            };
+        }
+        if (!(registry[currentStateName].forbidden?.write ?? false)) {
+            workflow.appendEvent({
+                type: 'write-checked',
+                at: this.engineDeps.now(),
+                tool: toolName,
+                filePath,
+                allowed: true
+            });
+            this.persistEvents(sessionId, workflow);
+            return {
+                type: 'success',
+                output: ''
+            };
+        }
+        if (!isWriteAllowed(filePath, workflow.getState())) {
+            const reason = `Write to '${filePath}' is forbidden in state ${currentStateName}`;
+            workflow.appendEvent({
+                type: 'write-checked',
+                at: this.engineDeps.now(),
+                tool: toolName,
+                filePath,
+                allowed: false,
+                reason,
+            });
+            this.persistEvents(sessionId, workflow);
+            return {
+                type: 'blocked',
+                output: formatOperationGateError('write-check', reason, currentPrefix)
+            };
+        }
+        workflow.appendEvent({
+            type: 'write-checked',
+            at: this.engineDeps.now(),
+            tool: toolName,
+            filePath,
+            allowed: true
+        });
+        this.persistEvents(sessionId, workflow);
+        return {
+            type: 'success',
+            output: ''
+        };
+    }
+    persistSessionId(sessionId) {
+        this.engineDeps.appendToFile(this.engineDeps.getEnvFilePath(), `export CLAUDE_SESSION_ID='${sessionId}'\n`);
+    }
+    hasSession(sessionId) {
+        return this.engineDeps.store.hasSessionStarted(sessionId);
+    }
+    hasSessionStarted(sessionId) {
+        return this.engineDeps.store.hasSessionStarted(sessionId);
+    }
+    requireSession(sessionId) {
+        if (!this.engineDeps.store.hasSessionStarted(sessionId)) {
+            throw new WorkflowStateError(`No session found for '${sessionId}'. Run init first.`);
+        }
+    }
+    rehydrateFromEvents(sessionId) {
+        const events = this.engineDeps.store.readEvents(sessionId);
+        const state = events.reduce((accumulator, event) => this.factory.fold(accumulator, event), this.factory.initialState());
+        return this.factory.buildWorkflow(state, this.workflowDeps);
+    }
+    persistEvents(sessionId, workflow) {
+        const pending = workflow.getPendingEvents();
+        if (pending.length > 0) {
+            this.engineDeps.store.appendEvents(sessionId, pending);
+        }
+    }
+    verifyIdentity(sessionId, workflow) {
+        const transcriptPath = workflow.getTranscriptPath();
+        const state = workflow.getState().currentStateMachineState;
+        const registry = this.factory.getRegistry();
+        const expectedPrefix = getExpectedPrefix(state, registry);
+        const pattern = buildPrefixPattern(registry);
+        const messages = this.engineDeps.transcriptReader.readMessages(transcriptPath);
+        const result = checkIdentity(messages, pattern);
+        this.engineDeps.store.appendEvents(sessionId, [{
+                type: 'identity-verified',
+                at: this.engineDeps.now(),
+                status: result.status,
+                transcriptPath,
+            }]);
+        if (result.status === 'lost') {
+            return `You forgot. Next message MUST begin with: ${expectedPrefix}`;
+        }
+        return undefined;
+    }
+}

package/dist/platform/domain/workflow-registry.d.ts

@@ -0,0 +1,41 @@
+import type { PreconditionResult } from './precondition-result';
+/** @riviere-role value-object */
+export type GitInfo = {
+    readonly currentBranch: string;
+    readonly workingTreeClean: boolean;
+    readonly headCommit: string;
+    readonly changedFilesVsDefault: readonly string[];
+    readonly hasCommitsVsDefault: boolean;
+};
+/** @riviere-role value-object */
+export type TransitionContext<TState, TStateName extends string = string> = {
+    readonly state: TState;
+    readonly gitInfo: GitInfo;
+    readonly from: TStateName;
+    readonly to: TStateName;
+};
+/** @riviere-role value-object */
+export type BashForbiddenConfig = {
+    readonly commands: readonly string[];
+    readonly flags?: readonly string[];
+};
+/** @riviere-role value-object */
+export type WorkflowStateDefinition<TState, TStateName extends string = string, TOperation extends string = string> = {
+    readonly emoji: string;
+    readonly agentInstructions: string;
+    readonly canTransitionTo: readonly TStateName[];
+    readonly allowedWorkflowOperations: readonly TOperation[];
+    readonly forbidden?: {
+        readonly write?: boolean;
+    };
+    readonly allowForbidden?: {
+        readonly bash?: readonly string[];
+    };
+    readonly transitionGuard?: (ctx: TransitionContext<TState, TStateName>) => PreconditionResult;
+    readonly onEntry?: (state: TState, ctx: TransitionContext<TState, TStateName>) => TState;
+    readonly afterEntry?: () => void;
+};
+/** @riviere-role value-object */
+export type WorkflowRegistry<TState, TStateName extends string = string, TOperation extends string = string> = {
+    readonly [K in TStateName]: WorkflowStateDefinition<TState, TStateName, TOperation>;
+};

package/dist/platform/domain/workflow-registry.js

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

package/dist/platform/domain/workflow-state.d.ts

@@ -0,0 +1,8 @@
+/** @riviere-role domain-error */
+export declare class WorkflowStateError extends Error {
+    constructor(message: string);
+}
+/** @riviere-role value-object */
+export type BaseWorkflowState<TStateName extends string = string> = {
+    currentStateMachineState: TStateName;
+};

package/dist/platform/domain/workflow-state.js

@@ -0,0 +1,7 @@
+/** @riviere-role domain-error */
+export class WorkflowStateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WorkflowStateError';
+    }
+}

package/dist/platform/infra/cli/presentation/output-guidance.d.ts

@@ -0,0 +1,15 @@
+export declare const SEPARATOR = "----------------------------------------------------------------";
+/** @riviere-role cli-output-formatter */
+export declare function formatBlock(title: string, body: string): string;
+/** @riviere-role cli-output-formatter */
+export declare function formatTransitionSuccess(title: string, procedureContent: string, expectedPrefix: string): string;
+/** @riviere-role cli-output-formatter */
+export declare function formatTransitionError(to: string, reason: string, currentProcedure: string, expectedPrefix: string): string;
+/** @riviere-role cli-output-formatter */
+export declare function formatIllegalTransitionError(reason: string, currentProcedure: string, expectedPrefix: string): string;
+/** @riviere-role cli-output-formatter */
+export declare function formatOperationGateError(op: string, reason: string, expectedPrefix: string): string;
+/** @riviere-role cli-output-formatter */
+export declare function formatOperationSuccess(op: string, body: string, expectedPrefix: string): string;
+/** @riviere-role cli-output-formatter */
+export declare function formatInitSuccess(procedureContent: string, expectedPrefix: string): string;