@nt-ai-lab/deterministic-agent-workflow-engine 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -2,6 +2,7 @@ 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 { nonEmptyStringSchema, requireNonEmptyString, } from './platform/domain/non-empty-string';
 export type { EventEnvelope, StoredEvent, } from './platform/domain/stored-event';
 export { flattenStoredEvent, stripEnvelopeKeys, toPayload, } from './platform/domain/stored-event';
 export { reflectionCategorySchema, reflectionConfidenceSchema, reflectionEvidenceSchema, reflectionFindingSchema, reflectionPayloadSchema, recordReflectionInputSchema, storedReflectionSchema, } from './platform/domain/reflection-types';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { WorkflowStateError } from './platform/domain/workflow-state.js';
 export { baseEventSchema } from './platform/domain/base-event.js';
+export { nonEmptyStringSchema, requireNonEmptyString, } from './platform/domain/non-empty-string.js';
 export { flattenStoredEvent, stripEnvelopeKeys, toPayload, } from './platform/domain/stored-event.js';
 export { reflectionCategorySchema, reflectionConfidenceSchema, reflectionEvidenceSchema, reflectionFindingSchema, reflectionPayloadSchema, recordReflectionInputSchema, storedReflectionSchema, } from './platform/domain/reflection-types.js';
 export { reviewTypeSchema, reviewVerdictSchema, reviewFindingSeveritySchema, reviewFindingStatusSchema, reviewFindingSchema, reviewPayloadSchema, recordReviewInputSchema, storedReviewSchema, listedReviewSchema, reviewFiltersSchema, } from './platform/domain/review-types.js';

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
+import { nonEmptyStringSchema } from './non-empty-string.js';
 export const baseEventSchema = z.object({
-    type: z.string(),
-    at: z.string(),
+    type: nonEmptyStringSchema,
+    at: nonEmptyStringSchema,
 }).passthrough();

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

@@ -2,24 +2,24 @@ 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">>;
+    transcriptPath: z.ZodString;
+    repository: z.ZodString;
+    currentState: z.ZodString;
+    states: z.ZodArray<z.ZodString, "many">;
 }, "strip", z.ZodTypeAny, {
     type: "session-started";
     at: string;
-    repository?: string | undefined;
-    transcriptPath?: string | undefined;
-    currentState?: string | undefined;
-    states?: string[] | undefined;
+    repository: string;
+    transcriptPath: string;
+    currentState: string;
+    states: string[];
 }, {
     type: "session-started";
     at: string;
-    repository?: string | undefined;
-    transcriptPath?: string | undefined;
-    currentState?: string | undefined;
-    states?: string[] | undefined;
+    repository: string;
+    transcriptPath: string;
+    currentState: string;
+    states: string[];
 }>;
 declare const transitionedSchema: z.ZodObject<{
     type: z.ZodLiteral<"transitioned">;
@@ -230,24 +230,24 @@ export declare const reviewRecordedEventSchema: z.ZodObject<{
 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">>;
+    transcriptPath: z.ZodString;
+    repository: z.ZodString;
+    currentState: z.ZodString;
+    states: z.ZodArray<z.ZodString, "many">;
 }, "strip", z.ZodTypeAny, {
     type: "session-started";
     at: string;
-    repository?: string | undefined;
-    transcriptPath?: string | undefined;
-    currentState?: string | undefined;
-    states?: string[] | undefined;
+    repository: string;
+    transcriptPath: string;
+    currentState: string;
+    states: string[];
 }, {
     type: "session-started";
     at: string;
-    repository?: string | undefined;
-    transcriptPath?: string | undefined;
-    currentState?: string | undefined;
-    states?: string[] | undefined;
+    repository: string;
+    transcriptPath: string;
+    currentState: string;
+    states: string[];
 }>, z.ZodObject<{
     type: z.ZodLiteral<"transitioned">;
     at: z.ZodString;

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

@@ -1,86 +1,87 @@
 import { z } from 'zod';
+import { nonEmptyStringSchema } from './non-empty-string.js';
 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(),
+    at: nonEmptyStringSchema,
+    transcriptPath: nonEmptyStringSchema,
+    repository: nonEmptyStringSchema,
+    currentState: nonEmptyStringSchema,
+    states: z.array(nonEmptyStringSchema),
 });
 const transitionedSchema = z.object({
     type: z.literal('transitioned'),
-    at: z.string(),
-    from: z.string(),
-    to: z.string(),
-    preBlockedState: z.string().optional(),
+    at: nonEmptyStringSchema,
+    from: nonEmptyStringSchema,
+    to: nonEmptyStringSchema,
+    preBlockedState: nonEmptyStringSchema.optional(),
     iteration: z.number().optional(),
-    developingHeadCommit: z.string().optional(),
+    developingHeadCommit: nonEmptyStringSchema.optional(),
     developerDone: z.boolean().optional(),
 });
 const agentRegisteredSchema = z.object({
     type: z.literal('agent-registered'),
-    at: z.string(),
-    agentType: z.string(),
-    agentId: z.string(),
+    at: nonEmptyStringSchema,
+    agentType: nonEmptyStringSchema,
+    agentId: nonEmptyStringSchema,
 });
 const agentShutDownSchema = z.object({
     type: z.literal('agent-shut-down'),
-    at: z.string(),
-    agentName: z.string(),
+    at: nonEmptyStringSchema,
+    agentName: nonEmptyStringSchema,
 });
 const journalEntrySchema = z.object({
     type: z.literal('journal-entry'),
-    at: z.string(),
-    agentName: z.string(),
-    content: z.string(),
+    at: nonEmptyStringSchema,
+    agentName: nonEmptyStringSchema,
+    content: nonEmptyStringSchema,
 });
 const writeCheckedSchema = z.object({
     type: z.literal('write-checked'),
-    at: z.string(),
-    tool: z.string(),
-    filePath: z.string(),
+    at: nonEmptyStringSchema,
+    tool: nonEmptyStringSchema,
+    filePath: nonEmptyStringSchema,
     allowed: z.boolean(),
-    reason: z.string().optional(),
+    reason: nonEmptyStringSchema.optional(),
 });
 const bashCheckedSchema = z.object({
     type: z.literal('bash-checked'),
-    at: z.string(),
-    tool: z.string(),
-    command: z.string(),
+    at: nonEmptyStringSchema,
+    tool: nonEmptyStringSchema,
+    command: nonEmptyStringSchema,
     allowed: z.boolean(),
-    reason: z.string().optional(),
+    reason: nonEmptyStringSchema.optional(),
 });
 const pluginReadCheckedSchema = z.object({
     type: z.literal('plugin-read-checked'),
-    at: z.string(),
-    tool: z.string(),
-    path: z.string(),
+    at: nonEmptyStringSchema,
+    tool: nonEmptyStringSchema,
+    path: nonEmptyStringSchema,
     allowed: z.boolean(),
-    reason: z.string().optional(),
+    reason: nonEmptyStringSchema.optional(),
 });
 const idleCheckedSchema = z.object({
     type: z.literal('idle-checked'),
-    at: z.string(),
-    agentName: z.string(),
+    at: nonEmptyStringSchema,
+    agentName: nonEmptyStringSchema,
     allowed: z.boolean(),
-    reason: z.string().optional(),
+    reason: nonEmptyStringSchema.optional(),
 });
 const identityVerifiedSchema = z.object({
     type: z.literal('identity-verified'),
-    at: z.string(),
-    status: z.string(),
-    transcriptPath: z.string(),
+    at: nonEmptyStringSchema,
+    status: nonEmptyStringSchema,
+    transcriptPath: nonEmptyStringSchema,
 });
 const contextRequestedSchema = z.object({
     type: z.literal('context-requested'),
-    at: z.string(),
-    agentName: z.string(),
+    at: nonEmptyStringSchema,
+    agentName: nonEmptyStringSchema,
 });
 export const reviewRecordedEventSchema = z.object({
     type: z.literal('review-recorded'),
-    at: z.string(),
+    at: nonEmptyStringSchema,
     reviewId: z.number().int().positive(),
-    reviewType: z.string(),
+    reviewType: nonEmptyStringSchema,
     verdict: z.enum(['PASS', 'FAIL']),
 });
 export const engineEventSchema = z.discriminatedUnion('type', [

package/dist/platform/domain/non-empty-string.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+/** @riviere-role value-object */
+export declare const nonEmptyStringSchema: z.ZodString;
+/** @riviere-role domain-service */
+export declare function requireNonEmptyString(value: string, name: string): string;

package/dist/platform/domain/non-empty-string.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/** @riviere-role value-object */
+export const nonEmptyStringSchema = z.string().trim().min(1);
+/** @riviere-role domain-service */
+export function requireNonEmptyString(value, name) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        throw new TypeError(`${name} must be a non-empty string.`);
+    return trimmed;
+}

package/dist/platform/domain/reflection-types.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { nonEmptyStringSchema } from './non-empty-string.js';
 export const reflectionCategorySchema = z.enum([
     'state-efficiency',
     'review-rework',
@@ -7,13 +8,13 @@ export const reflectionCategorySchema = z.enum([
     'workflow-design',
 ]);
 export const reflectionConfidenceSchema = z.enum(['low', 'medium', 'high']);
-const evidenceBaseSchema = z.object({ label: z.string().min(1).optional(), });
+const evidenceBaseSchema = z.object({ label: nonEmptyStringSchema.optional(), });
 export const reflectionEvidenceSchema = z.discriminatedUnion('kind', [
     evidenceBaseSchema.extend({
         kind: z.literal('state-period'),
-        state: z.string().min(1),
-        startedAt: z.string().min(1).optional(),
-        endedAt: z.string().min(1).optional(),
+        state: nonEmptyStringSchema,
+        startedAt: nonEmptyStringSchema.optional(),
+        endedAt: nonEmptyStringSchema.optional(),
     }),
     evidenceBaseSchema.extend({
         kind: z.literal('event'),
@@ -26,8 +27,8 @@ export const reflectionEvidenceSchema = z.discriminatedUnion('kind', [
     }),
     evidenceBaseSchema.extend({
         kind: z.literal('journal-entry'),
-        at: z.string().min(1),
-        agentName: z.string().min(1).optional(),
+        at: nonEmptyStringSchema,
+        agentName: nonEmptyStringSchema.optional(),
     }),
     evidenceBaseSchema.extend({
         kind: z.literal('transcript-range'),
@@ -36,37 +37,37 @@ export const reflectionEvidenceSchema = z.discriminatedUnion('kind', [
     }),
     evidenceBaseSchema.extend({
         kind: z.literal('tool-activity'),
-        state: z.string().min(1).optional(),
-        toolName: z.string().min(1).optional(),
-        metric: z.string().min(1).optional(),
+        state: nonEmptyStringSchema.optional(),
+        toolName: nonEmptyStringSchema.optional(),
+        metric: nonEmptyStringSchema.optional(),
     }),
 ]);
 export const reflectionFindingSchema = z.object({
-    title: z.string().min(1),
+    title: nonEmptyStringSchema,
     category: reflectionCategorySchema,
-    opportunity: z.string().min(1),
-    likelyCause: z.string().min(1),
-    suggestedChange: z.string().min(1),
-    expectedImpact: z.string().min(1),
+    opportunity: nonEmptyStringSchema,
+    likelyCause: nonEmptyStringSchema,
+    suggestedChange: nonEmptyStringSchema,
+    expectedImpact: nonEmptyStringSchema,
     confidence: reflectionConfidenceSchema.optional(),
     evidence: z.array(reflectionEvidenceSchema).min(1),
 });
 export const reflectionPayloadSchema = z.object({
-    summary: z.string().min(1).optional(),
+    summary: nonEmptyStringSchema.optional(),
     findings: z.array(reflectionFindingSchema).max(10),
 }).strict();
 export const recordReflectionInputSchema = z.object({
-    label: z.string().min(1).optional(),
-    agentName: z.string().min(1).optional(),
-    sourceState: z.string().min(1).optional(),
+    label: nonEmptyStringSchema.optional(),
+    agentName: nonEmptyStringSchema.optional(),
+    sourceState: nonEmptyStringSchema.optional(),
     reflection: reflectionPayloadSchema,
 }).strict();
 export const storedReflectionSchema = z.object({
     id: z.number().int().positive(),
-    sessionId: z.string().min(1),
-    createdAt: z.string().min(1),
-    label: z.string().min(1).optional(),
-    agentName: z.string().min(1).optional(),
-    sourceState: z.string().min(1).optional(),
+    sessionId: nonEmptyStringSchema,
+    createdAt: nonEmptyStringSchema,
+    label: nonEmptyStringSchema.optional(),
+    agentName: nonEmptyStringSchema.optional(),
+    sourceState: nonEmptyStringSchema.optional(),
     reflection: reflectionPayloadSchema,
 }).strict();

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

@@ -1,17 +1,18 @@
 import { z } from 'zod';
+import { nonEmptyStringSchema } from './non-empty-string.js';
 const issueRecordedSchema = z.object({
     type: z.literal('issue-recorded'),
-    at: z.string(),
+    at: nonEmptyStringSchema,
     issueNumber: z.number(),
 });
 const branchRecordedSchema = z.object({
     type: z.literal('branch-recorded'),
-    at: z.string(),
-    branch: z.string(),
+    at: nonEmptyStringSchema,
+    branch: nonEmptyStringSchema,
 });
 const prRecordedSchema = z.object({
     type: z.literal('pr-recorded'),
-    at: z.string(),
+    at: nonEmptyStringSchema,
     prNumber: z.number(),
 });
 export const repositoryMetadataEventSchema = z.discriminatedUnion('type', [

package/dist/platform/domain/review-types.js

@@ -1,18 +1,19 @@
 import { z } from 'zod';
-export const reviewTypeSchema = z.string().min(1);
+import { nonEmptyStringSchema } from './non-empty-string.js';
+export const reviewTypeSchema = nonEmptyStringSchema;
 export const reviewVerdictSchema = z.enum(['PASS', 'FAIL']);
 export const reviewFindingSeveritySchema = z.enum(['minor', 'major', 'critical']);
 export const reviewFindingStatusSchema = z.enum(['blocking', 'non-blocking', 'accepted-risk']);
 export const reviewFindingSchema = z.object({
-    title: z.string().min(1).optional(),
+    title: nonEmptyStringSchema.optional(),
     severity: reviewFindingSeveritySchema.optional(),
     status: reviewFindingStatusSchema.optional(),
-    rule: z.string().min(1).optional(),
-    file: z.string().min(1).optional(),
+    rule: nonEmptyStringSchema.optional(),
+    file: nonEmptyStringSchema.optional(),
     startLine: z.number().int().positive().optional(),
     endLine: z.number().int().positive().optional(),
-    details: z.string().min(1).optional(),
-    recommendation: z.string().min(1).optional(),
+    details: nonEmptyStringSchema.optional(),
+    recommendation: nonEmptyStringSchema.optional(),
 }).strict().superRefine((finding, context) => {
     if (finding.title === undefined && finding.details === undefined && finding.rule === undefined) {
         context.addIssue({
@@ -38,24 +39,24 @@ export const reviewFindingSchema = z.object({
 });
 export const reviewPayloadSchema = z.object({
     verdict: reviewVerdictSchema,
-    summary: z.string().min(1).optional(),
-    branch: z.string().min(1).optional(),
+    summary: nonEmptyStringSchema.optional(),
+    branch: nonEmptyStringSchema.optional(),
     pullRequestNumber: z.number().int().positive().optional(),
     findings: z.array(reviewFindingSchema),
 }).strict();
 export const recordReviewInputSchema = reviewPayloadSchema.extend({
     reviewType: reviewTypeSchema,
-    sourceState: z.string().min(1).optional(),
+    sourceState: nonEmptyStringSchema.optional(),
 }).strict();
 export const storedReviewSchema = recordReviewInputSchema.extend({
     id: z.number().int().positive(),
-    sessionId: z.string().min(1),
-    createdAt: z.string().min(1),
+    sessionId: nonEmptyStringSchema,
+    createdAt: nonEmptyStringSchema,
 }).strict();
-export const listedReviewSchema = storedReviewSchema.extend({ repository: z.string().min(1).optional() }).strict();
+export const listedReviewSchema = storedReviewSchema.extend({ repository: nonEmptyStringSchema.optional() }).strict();
 export const reviewFiltersSchema = z.object({
-    repository: z.string().min(1).optional(),
-    branch: z.string().min(1).optional(),
+    repository: nonEmptyStringSchema.optional(),
+    branch: nonEmptyStringSchema.optional(),
     pullRequestNumber: z.number().int().positive().optional(),
     reviewType: reviewTypeSchema.optional(),
     verdict: reviewVerdictSchema.optional(),

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

@@ -10,4 +10,4 @@ export declare function buildProcedurePath<TStateName extends string>(engineDeps
 /** @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 | undefined, currentState: TStateName, states: readonly string[]): readonly BaseEvent[];
+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

@@ -1,3 +1,4 @@
+import { requireNonEmptyString } from './non-empty-string.js';
 /** @riviere-role domain-service */
 export function buildPrefixPattern(registry) {
     const prefixes = [];
@@ -21,14 +22,16 @@ export function readProcedure(engineDeps, stateName) {
 }
 /** @riviere-role domain-service */
 export function enrichSessionStartedEvents(engineDeps, events, transcriptPath, repository, currentState, states) {
+    const validRepository = requireNonEmptyString(repository, 'repository');
+    const validTranscriptPath = requireNonEmptyString(transcriptPath, 'transcriptPath');
     const enriched = events.map((event) => {
         if (event.type !== 'session-started') {
             return event;
         }
         return {
             ...event,
-            transcriptPath,
-            ...(repository === undefined ? {} : { repository }),
+            transcriptPath: validTranscriptPath,
+            repository: validRepository,
             currentState,
             states: [...states],
         };
@@ -39,8 +42,8 @@ export function enrichSessionStartedEvents(engineDeps, events, transcriptPath, r
     return [{
             type: 'session-started',
             at: engineDeps.now(),
-            transcriptPath,
-            ...(repository === undefined ? {} : { repository }),
+            transcriptPath: validTranscriptPath,
+            repository: validRepository,
             currentState,
             states: [...states],
         }, ...enriched];

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

@@ -23,7 +23,7 @@ export interface RehydratableWorkflow<TState extends BaseWorkflowState> {
     getState(): TState;
     appendEvent(event: BaseEvent): void;
     getPendingEvents(): readonly BaseEvent[];
-    startSession(transcriptPath: string, repository: string | undefined): void;
+    startSession(transcriptPath: string, repository: string): void;
     getTranscriptPath(): string;
     registerAgent(agentType: string, agentId: string): PreconditionResult;
     handleTeammateIdle(agentName: string): PreconditionResult;

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

@@ -8,7 +8,7 @@ export declare class WorkflowEngine<TWorkflow extends RehydratableWorkflow<TStat
     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;
+    startSession(sessionId: string, transcriptPath: string, repository: string): EngineResult;
     transaction(sessionId: string, op: string, fn: (workflow: TWorkflow) => PreconditionResult): EngineResult;
     writeJournal(sessionId: string, agentName: string, content: string): EngineResult;
     transition(sessionId: string, target: TStateName): EngineResult;

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

@@ -7,6 +7,7 @@ import { engineEventSchema } from './engine-events.js';
 import { WorkflowStateError, } from './workflow-state.js';
 import { reduceWorkflowStateFromStoredEvents } from './workflow-state-reducer.js';
 import { serializeWorkflowState } from './workflow-state-serialization.js';
+import { requireNonEmptyString } from './non-empty-string.js';
 /** @riviere-role domain-service */
 export class WorkflowEngine {
     factory;
@@ -18,7 +19,10 @@ export class WorkflowEngine {
         this.workflowDeps = workflowDeps;
     }
     startSession(sessionId, transcriptPath, repository) {
-        if (this.engineDeps.store.hasSessionStarted(sessionId)) {
+        const validSessionId = requireNonEmptyString(sessionId, 'sessionId');
+        const validTranscriptPath = requireNonEmptyString(transcriptPath, 'transcriptPath');
+        const validRepository = requireNonEmptyString(repository, 'repository');
+        if (this.engineDeps.store.hasSessionStarted(validSessionId)) {
             return {
                 type: 'success',
                 output: ''
@@ -26,12 +30,11 @@ export class WorkflowEngine {
         }
         const initialState = this.factory.initialState();
         const workflow = this.factory.buildWorkflow(initialState, this.workflowDeps);
-        const resolvedRepository = repository ?? this.engineDeps.getRepositoryName?.();
-        workflow.startSession(transcriptPath, resolvedRepository);
+        workflow.startSession(validTranscriptPath, validRepository);
         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, this.wrapEvents(pendingEvents, initialState));
+        const pendingEvents = enrichSessionStartedEvents(this.engineDeps, workflow.getPendingEvents(), validTranscriptPath, validRepository, initialState.currentStateMachineState, stateNames);
+        this.engineDeps.store.appendEvents(validSessionId, this.wrapEvents(pendingEvents, initialState));
         const procedureContent = this.engineDeps.readFile(buildProcedurePath(this.engineDeps, initialState.currentStateMachineState));
         const expectedPrefix = getExpectedPrefix(initialState.currentStateMachineState, registry);
         return {

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

@@ -256,11 +256,26 @@ function createEngine() {
     };
 }
 describe('WorkflowEngine platform-owned events', () => {
+    it.each([
+        ['repository', ''],
+        ['repository', '   '],
+        ['transcriptPath', ''],
+        ['transcriptPath', '   '],
+        ['sessionId', ''],
+        ['sessionId', '   '],
+    ])('rejects empty %s before persisting a session', (field, value) => {
+        const { engine, store, } = createEngine();
+        const sessionId = field === 'sessionId' ? value : 'session-1';
+        const transcriptPath = field === 'transcriptPath' ? value : '/transcripts/session-1.jsonl';
+        const repository = field === 'repository' ? value : 'test/repo';
+        expect(() => engine.startSession(sessionId, transcriptPath, repository)).toThrow(`${field} must be a non-empty string.`);
+        expect(store.readEvents('session-1')).toStrictEqual([]);
+    });
     it('persists journal and write-check events without routing them through the consumer workflow', () => {
         const { engine, store, } = createEngine();
-        engine.startSession('session-1', '/transcripts/session-1.jsonl');
+        engine.startSession('session-1', '/transcripts/session-1.jsonl', 'test/repo');
         const journalResult = engine.writeJournal('session-1', 'gpt-5.4', 'Captured planning context.');
-        const writeCheckResult = engine.checkWrite('session-1', 'Read', '', () => true);
+        const writeCheckResult = engine.checkWrite('session-1', 'Read', '/src/example.ts', () => true);
         const stateResult = engine.getState('session-1');
         expect(journalResult.type).toBe('success');
         expect(writeCheckResult).toStrictEqual({

package/dist/platform/infra/cli/presentation/output-guidance.spec.js

@@ -181,7 +181,7 @@ const engineDeps = {
 it('reinserts the current procedure when identity verification fails', () => {
     const emptyWorkflowDeps = {};
     const engine = new WorkflowEngine(workflowDefinition, engineDeps, emptyWorkflowDeps);
-    engine.startSession('session-1', '/transcripts/session-1.jsonl');
+    engine.startSession('session-1', '/transcripts/session-1.jsonl', 'test/repo');
     const result = engine.checkWrite('session-1', 'Write', '/workspace/note.md', () => true);
     const expectedOutput = [
         'Cannot write-check',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/deterministic-agent-workflow-engine",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "private": false,
   "type": "module",
   "repository": {