@exaudeus/workrail 2.0.0 → 3.0.0

package/dist/engine/types.d.ts

@@ -0,0 +1,130 @@
+declare const StateTokenBrand: unique symbol;
+declare const AckTokenBrand: unique symbol;
+declare const CheckpointTokenBrand: unique symbol;
+export type StateToken = string & {
+    readonly [StateTokenBrand]: never;
+};
+export type AckToken = string & {
+    readonly [AckTokenBrand]: never;
+};
+export type CheckpointToken = string & {
+    readonly [CheckpointTokenBrand]: never;
+};
+export declare function asStateToken(s: string): StateToken;
+export declare function asAckToken(s: string): AckToken;
+export declare function asCheckpointToken(s: string): CheckpointToken;
+export declare function unwrapToken(t: StateToken | AckToken | CheckpointToken): string;
+export interface PendingStep {
+    readonly stepId: string;
+    readonly title: string;
+    readonly prompt: string;
+    readonly agentRole?: string;
+}
+export type Autonomy = 'guided' | 'full_auto_stop_on_user_deps' | 'full_auto_never_stop';
+export type RiskPolicy = 'conservative' | 'balanced' | 'aggressive';
+export interface StepPreferences {
+    readonly autonomy: Autonomy;
+    readonly riskPolicy: RiskPolicy;
+}
+export type NextIntent = 'perform_pending_then_continue' | 'await_user_confirmation' | 'rehydrate_only' | 'complete';
+export type BlockerCode = 'USER_ONLY_DEPENDENCY' | 'MISSING_REQUIRED_OUTPUT' | 'INVALID_REQUIRED_OUTPUT' | 'MISSING_REQUIRED_NOTES' | 'MISSING_CONTEXT_KEY' | 'CONTEXT_BUDGET_EXCEEDED' | 'REQUIRED_CAPABILITY_UNKNOWN' | 'REQUIRED_CAPABILITY_UNAVAILABLE' | 'INVARIANT_VIOLATION' | 'STORAGE_CORRUPTION_DETECTED';
+export interface Blocker {
+    readonly code: BlockerCode;
+    readonly message: string;
+    readonly suggestedFix?: string;
+}
+interface StepResponseBase {
+    readonly stateToken: StateToken;
+    readonly ackToken: AckToken | null;
+    readonly checkpointToken: CheckpointToken | null;
+    readonly isComplete: boolean;
+    readonly preferences: StepPreferences;
+    readonly nextIntent: NextIntent;
+}
+export interface StepResponseOk extends StepResponseBase {
+    readonly kind: 'ok';
+    readonly pending: PendingStep | null;
+}
+export interface StepResponseBlocked extends StepResponseBase {
+    readonly kind: 'blocked';
+    readonly pending: PendingStep | null;
+    readonly blockers: readonly Blocker[];
+    readonly retryable: boolean;
+    readonly retryAckToken: AckToken | null;
+}
+export type StepResponse = StepResponseOk | StepResponseBlocked;
+export interface CheckpointResponse {
+    readonly checkpointNodeId: string;
+    readonly stateToken: StateToken;
+}
+export interface WorkflowListItem {
+    readonly workflowId: string;
+    readonly name: string;
+    readonly description: string;
+    readonly version: string;
+}
+export interface WorkflowListResponse {
+    readonly workflows: readonly WorkflowListItem[];
+}
+export type InfraErrorCode = string;
+export type EngineError = {
+    readonly kind: 'workflow_not_found';
+    readonly workflowId: string;
+} | {
+    readonly kind: 'workflow_has_no_steps';
+    readonly workflowId: string;
+} | {
+    readonly kind: 'workflow_compile_failed';
+    readonly message: string;
+} | {
+    readonly kind: 'validation_failed';
+    readonly message: string;
+} | {
+    readonly kind: 'token_invalid';
+    readonly message: string;
+    readonly code?: InfraErrorCode;
+} | {
+    readonly kind: 'token_signing_failed';
+    readonly message: string;
+} | {
+    readonly kind: 'session_error';
+    readonly message: string;
+    readonly code?: InfraErrorCode;
+} | {
+    readonly kind: 'storage_error';
+    readonly message: string;
+    readonly code?: InfraErrorCode;
+} | {
+    readonly kind: 'prompt_render_failed';
+    readonly message: string;
+} | {
+    readonly kind: 'precondition_failed';
+    readonly message: string;
+} | {
+    readonly kind: 'internal_error';
+    readonly message: string;
+    readonly code?: InfraErrorCode;
+};
+export type EngineResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: EngineError;
+};
+export declare function engineOk<T>(value: T): EngineResult<T>;
+export declare function engineErr<T>(error: EngineError): EngineResult<T>;
+export interface EngineConfig {
+    readonly dataDir?: string;
+}
+export interface WorkRailEngine {
+    readonly startWorkflow: (workflowId: string) => Promise<EngineResult<StepResponse>>;
+    readonly continueWorkflow: (stateToken: StateToken, ackToken: AckToken | null, output?: {
+        readonly notesMarkdown?: string;
+        readonly artifacts?: readonly unknown[];
+    }, context?: Readonly<Record<string, unknown>>) => Promise<EngineResult<StepResponse>>;
+    readonly checkpointWorkflow: (checkpointToken: CheckpointToken) => Promise<EngineResult<CheckpointResponse>>;
+    readonly listWorkflows: () => Promise<EngineResult<WorkflowListResponse>>;
+    readonly close: () => Promise<void>;
+}
+export {};

package/dist/engine/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asStateToken = asStateToken;
+exports.asAckToken = asAckToken;
+exports.asCheckpointToken = asCheckpointToken;
+exports.unwrapToken = unwrapToken;
+exports.engineOk = engineOk;
+exports.engineErr = engineErr;
+function asStateToken(s) { return s; }
+function asAckToken(s) { return s; }
+function asCheckpointToken(s) { return s; }
+function unwrapToken(t) { return t; }
+function engineOk(value) {
+    return { ok: true, value };
+}
+function engineErr(error) {
+    return { ok: false, error };
+}

package/dist/infrastructure/storage/file-workflow-storage.d.ts

@@ -26,6 +26,7 @@ export declare class FileWorkflowStorage implements IWorkflowStorage {
     private loadDefinitionFromFile;
     loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
+    getRoutineDefinitions(): Promise<ReadonlyMap<string, WorkflowDefinition>>;
     listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
     save(definition: WorkflowDefinition): Promise<void>;
 }

package/dist/infrastructure/storage/file-workflow-storage.js

@@ -55,6 +55,9 @@ class FileWorkflowStorage {
                         continue;
                     }
                 }
+                if (!this.featureFlags.isEnabled('leanWorkflows') && file.includes('.lean.')) {
+                    continue;
+                }
                 if (!this.featureFlags.isEnabled('v2Tools') && file.includes('.v2.')) {
                     continue;
                 }
@@ -78,12 +81,14 @@ class FileWorkflowStorage {
         const flags = {
             v2Tools: this.featureFlags.isEnabled('v2Tools'),
             agenticRoutines: this.featureFlags.isEnabled('agenticRoutines'),
+            leanWorkflows: this.featureFlags.isEnabled('leanWorkflows'),
         };
         for (const [id, files] of idToFiles) {
             const candidates = files.map(f => ({
-                variantKind: f.file.includes('.v2.') ? 'v2'
-                    : f.file.includes('.agentic.') ? 'agentic'
-                        : 'standard',
+                variantKind: f.file.includes('.lean.') ? 'lean'
+                    : f.file.includes('.v2.') ? 'v2'
+                        : f.file.includes('.agentic.') ? 'agentic'
+                            : 'standard',
                 identifier: f.file,
             }));
             const selection = (0, workflow_resolution_1.selectVariant)(candidates, flags);
@@ -159,6 +164,16 @@ class FileWorkflowStorage {
         }
         return workflow;
     }
+    async getRoutineDefinitions() {
+        const index = await this.getWorkflowIndex();
+        const routines = new Map();
+        for (const entry of index.values()) {
+            if (entry.id.startsWith('routine-')) {
+                routines.set(entry.id, entry.definition);
+            }
+        }
+        return routines;
+    }
     async listWorkflowSummaries() {
         const workflows = await this.loadAllWorkflows();
         return workflows.map(workflow_1.toWorkflowSummary);

package/dist/infrastructure/storage/workflow-resolution.d.ts

@@ -1,19 +1,21 @@
 import type { Workflow } from '../../types/workflow.js';
 export type SourceRef = number;
+export type VariantKind = 'lean' | 'v2' | 'agentic' | 'standard';
 export type VariantResolution = {
     readonly kind: 'only_variant';
 } | {
     readonly kind: 'feature_flag_selected';
-    readonly selectedVariant: 'v2' | 'agentic' | 'standard';
-    readonly availableVariants: readonly ('v2' | 'agentic' | 'standard')[];
+    readonly selectedVariant: VariantKind;
+    readonly availableVariants: readonly VariantKind[];
     readonly enabledFlags: {
         readonly v2Tools: boolean;
         readonly agenticRoutines: boolean;
+        readonly leanWorkflows: boolean;
     };
 } | {
     readonly kind: 'precedence_fallback';
-    readonly selectedVariant: 'v2' | 'agentic' | 'standard';
-    readonly availableVariants: readonly ('v2' | 'agentic' | 'standard')[];
+    readonly selectedVariant: VariantKind;
+    readonly availableVariants: readonly VariantKind[];
 };
 export type ResolutionReason = {
     readonly kind: 'unique';
@@ -39,15 +41,16 @@ export declare function resolveWorkflowCandidates(candidates: readonly {
     readonly workflows: readonly Workflow[];
 }[], variantResolutions: ReadonlyMap<string, ReadonlyMap<SourceRef, VariantResolution>>): readonly ResolvedWorkflow[];
 export interface VariantCandidate {
-    readonly variantKind: 'v2' | 'agentic' | 'standard';
+    readonly variantKind: VariantKind;
     readonly identifier: string;
 }
 export interface VariantSelectionFlags {
     readonly v2Tools: boolean;
     readonly agenticRoutines: boolean;
+    readonly leanWorkflows: boolean;
 }
 export interface VariantSelectionResult {
-    readonly selectedVariant: 'v2' | 'agentic' | 'standard';
+    readonly selectedVariant: VariantKind;
     readonly selectedIdentifier: string;
     readonly resolution: VariantResolution;
 }

package/dist/infrastructure/storage/workflow-resolution.js

@@ -79,9 +79,22 @@ function selectVariant(candidates, flags) {
         };
     }
     const availableVariants = candidates.map(c => c.variantKind);
+    const leanCandidate = candidates.find(c => c.variantKind === 'lean');
     const v2Candidate = candidates.find(c => c.variantKind === 'v2');
     const agenticCandidate = candidates.find(c => c.variantKind === 'agentic');
     const standardCandidate = candidates.find(c => c.variantKind === 'standard');
+    if (flags.leanWorkflows && leanCandidate) {
+        return {
+            selectedVariant: 'lean',
+            selectedIdentifier: leanCandidate.identifier,
+            resolution: {
+                kind: 'feature_flag_selected',
+                selectedVariant: 'lean',
+                availableVariants,
+                enabledFlags: flags,
+            },
+        };
+    }
     if (flags.v2Tools && v2Candidate) {
         return {
             selectedVariant: 'v2',
@@ -117,7 +130,7 @@ function selectVariant(candidates, flags) {
             },
         };
     }
-    const fallback = v2Candidate ?? agenticCandidate ?? candidates[0];
+    const fallback = leanCandidate ?? v2Candidate ?? agenticCandidate ?? candidates[0];
     return {
         selectedVariant: fallback.variantKind,
         selectedIdentifier: fallback.identifier,