@gobing-ai/ts-dual-workflow-engine 0.4.28 → 0.4.31

package/src/events.ts

@@ -1,3 +1,5 @@
+import type { EventSeverity } from '@gobing-ai/ts-infra';
+
 /** Typed event map for workflow-engine run observability. All events prefixed `workflow.`. */
 export type WorkflowEngineEvents = {
     /** Emitted when a run begins (inside the span). */
@@ -7,6 +9,7 @@ export type WorkflowEngineEvents = {
         runId: string;
         dryRun: boolean;
         externalKey?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when a run completes successfully. */
     'workflow.run.done': (data: {
@@ -14,11 +17,23 @@ export type WorkflowEngineEvents = {
         finalState: string;
         transitionsTaken: number;
         externalKey?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when a run fails. */
-    'workflow.run.failed': (data: { runId: string; finalState: string; reason: string; externalKey?: string }) => void;
+    'workflow.run.failed': (data: {
+        runId: string;
+        finalState: string;
+        reason: string;
+        externalKey?: string;
+        severity: EventSeverity;
+    }) => void;
     /** Emitted when entering a state or node. */
-    'workflow.node.enter': (data: { runId: string; node: string; transitionsTaken: number }) => void;
+    'workflow.node.enter': (data: {
+        runId: string;
+        node: string;
+        transitionsTaken: number;
+        severity: EventSeverity;
+    }) => void;
     /** Emitted on a state/node transition. */
     'workflow.node.transition': (data: {
         runId: string;
@@ -26,9 +41,10 @@ export type WorkflowEngineEvents = {
         to: string;
         trigger: string | null;
         externalKey?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when an action starts executing. */
-    'workflow.action.start': (data: { runId: string; node: string; kind: string }) => void;
+    'workflow.action.start': (data: { runId: string; node: string; kind: string; severity: EventSeverity }) => void;
     /** Emitted when an action finishes executing (success or failure). */
     'workflow.action.done': (data: {
         runId: string;
@@ -36,6 +52,7 @@ export type WorkflowEngineEvents = {
         kind: string;
         durationMs: number;
         ok: boolean;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when a non-fatal action failure is continued past (onError: 'continue'). */
     'workflow.action.failed_continue': (data: {
@@ -43,11 +60,12 @@ export type WorkflowEngineEvents = {
         node: string;
         transitionsTaken: number;
         error?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted by the builtin `event.emit` action for custom user-defined events. */
-    'workflow.custom': (data: { name: string; payload: Record<string, unknown> }) => void;
+    'workflow.custom': (data: { name: string; payload: Record<string, unknown>; severity: EventSeverity }) => void;
     /** Emitted by the builtin `note` action for workflow-visible annotations. */
-    'workflow.hitl.note': (data: { runId: string; node: string; message: string }) => void;
+    'workflow.hitl.note': (data: { runId: string; node: string; message: string; severity: EventSeverity }) => void;
     /** Emitted when a guard condition is evaluated. Fires for every guard, including rejected ones. */
     'workflow.guard.evaluated': (data: {
         runId: string;
@@ -56,17 +74,25 @@ export type WorkflowEngineEvents = {
         kind: string;
         passed: boolean;
         externalKey?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when an interactive HITL prompt is presented and the engine waits for input. */
-    'workflow.hitl.ask': (data: { runId: string; node: string; kind: string; message: string }) => void;
+    'workflow.hitl.ask': (data: {
+        runId: string;
+        node: string;
+        kind: string;
+        message: string;
+        severity: EventSeverity;
+    }) => void;
     /** Emitted when an interactive HITL prompt receives a response. */
-    'workflow.hitl.response': (data: { runId: string; node: string; ok: boolean }) => void;
+    'workflow.hitl.response': (data: { runId: string; node: string; ok: boolean; severity: EventSeverity }) => void;
     /** Emitted when a run's state is force-set via reseed (consumer-side authority reconciliation). */
     'workflow.run.reseeded': (data: {
         runId: string;
         fromState: string;
         toState: string;
         externalKey?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when an external transition request is allowed and committed. */
     'workflow.transition.requested': (data: {
@@ -75,6 +101,7 @@ export type WorkflowEngineEvents = {
         to: string;
         trigger: string | null;
         externalKey?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when an external transition request is denied. */
     'workflow.transition.denied': (data: {
@@ -83,6 +110,7 @@ export type WorkflowEngineEvents = {
         to: string;
         reason: string;
         externalKey?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when a run pauses at a declared pause point. */
     'workflow.run.paused': (data: {
@@ -90,7 +118,13 @@ export type WorkflowEngineEvents = {
         node: string;
         transitionsTaken: number;
         externalKey?: string;
+        severity: EventSeverity;
     }) => void;
     /** Emitted when a paused run is resumed. */
-    'workflow.run.resumed': (data: { runId: string; node: string; externalKey?: string }) => void;
+    'workflow.run.resumed': (data: {
+        runId: string;
+        node: string;
+        externalKey?: string;
+        severity: EventSeverity;
+    }) => void;
 };

package/src/extensions.ts

@@ -1,10 +1,9 @@
 import type { Logger } from '@gobing-ai/ts-infra';
-import { basenamePath, dirnamePath, SEP } from '@gobing-ai/ts-runtime';
 import type { ExtensionRef, LoadExtensionsOptions } from '@gobing-ai/ts-runtime/extension';
 import { loadExtensionModules } from '@gobing-ai/ts-runtime/extension';
 import { WorkflowValidationError } from './errors';
 import type { WorkflowEngineHost } from './host';
-import type { ActionRunner, GuardRunner } from './types';
+import type { ActionRunner, GuardRunner, WorkflowExtensions } from './types';
 
 /** Minimal warning sink accepted for non-fatal extension diagnostics; a full {@link Logger} satisfies it. */
 export type WorkflowExtensionLogger = Pick<Logger, 'warn'>;
@@ -21,15 +20,17 @@ export type WorkflowExtensionKind = 'actions' | 'guards';
 /**
  * A single workflow extension module reference.
  *
- * The caller provides a pre-resolved absolute path; the loader adapts it to the
- * shared `ExtensionRef` format before delegating to the generic core so the
- * trust guard always governs the module that gets imported.
+ * The caller supplies the authored relative path plus the declaring directory; the
+ * shared loader resolves `(baseDir, path)` and applies its traversal + symlink
+ * guards to the authored string exactly as declared (task 0060 C2).
  */
 export interface WorkflowExtensionRef {
     /** Target capability registry. */
     readonly kind: WorkflowExtensionKind;
-    /** Absolute path to the module to import. */
-    readonly absPath: string;
+    /** Relative path as authored (e.g. `./exts/foo.ts`). */
+    readonly path: string;
+    /** Absolute directory the authored `path` is resolved against. */
+    readonly baseDir: string;
     /** Name of the config declaring this extension (for diagnostics). */
     readonly sourceName: string;
 }
@@ -59,6 +60,30 @@ export interface LoadWorkflowExtensionsOptions {
     readonly realPath?: (absPath: string) => string;
 }
 
+/**
+ * Build `WorkflowExtensionRef[]` from a YAML `extensions` block without importing
+ * or resolving anything.
+ *
+ * Kind order is `actions` then `guards`. Paths are kept **as authored** (no
+ * basename smash, no `resolve(sourceDir, path)`) so the shared loader sees the
+ * real declaration — a `..` segment or absolute path is rejected there by
+ * `assertRelativeExtensionPath`, not after a rewrite here.
+ */
+export function collectWorkflowExtensions(
+    sourceName: string,
+    sourceDir: string,
+    extensions: WorkflowExtensions | undefined,
+): WorkflowExtensionRef[] {
+    if (extensions === undefined) return [];
+    const refs: WorkflowExtensionRef[] = [];
+    for (const kind of ['actions', 'guards'] as const) {
+        for (const path of extensions[kind] ?? []) {
+            refs.push({ kind, sourceName, path, baseDir: sourceDir });
+        }
+    }
+    return refs;
+}
+
 /**
  * Import each extension module behind an explicit trust gate and register
  * its actions and/or guards on the workflow host.
@@ -79,28 +104,13 @@ export async function loadWorkflowExtensionsIntoHost(
 ): Promise<void> {
     if (refs.length === 0) return;
 
-    // Enforce relative-path guard before adapting to the shared format.
-    // The shared loader's assertRelativeExtensionPath applies to the derived
-    // (basename) path, which is always clean — this pre-check catches `..`
-    // traversal in the caller-supplied absPath before basename strips it (R6).
-    for (const ref of refs) {
-        const segments = ref.absPath.split(SEP);
-        if (segments.includes('..')) {
-            throw new Error(
-                `extension path "${ref.absPath}" declared by "${ref.sourceName}" must not contain ".." traversal`,
-            );
-        }
-    }
-
-    // Adapt WorkflowExtensionRef → shared ExtensionRef so the generic loader
-    // governs every import.  The shared loader resolves (baseDir, path) ->
-    // absPath internally; we supply dirname/basename so the resolved path
-    // reconstructs the caller's original absPath.  assertRelativeExtensionPath
-    // is satisfied because basenamePath() is always a simple filename.
+    // Map 1:1 onto the shared ref shape — no dirname/basename smash, so the shared
+    // loader's assertRelativeExtensionPath + realPath confinement govern the authored
+    // path exactly as declared (task 0060 C2).
     const sharedRefs: ExtensionRef<WorkflowExtensionKind>[] = refs.map((ref) => ({
         kind: ref.kind,
-        path: `./${basenamePath(ref.absPath)}`,
-        baseDir: dirnamePath(ref.absPath),
+        path: ref.path,
+        baseDir: ref.baseDir,
         sourceName: ref.sourceName,
     }));
 

package/src/host.ts

@@ -123,6 +123,7 @@ export class NoteActionRunner implements ActionRunner {
             runId: context.runId,
             node: context.stateOrNodeId,
             message,
+            severity: 'info',
         });
         return { ok: true, data: { message } };
     }
@@ -136,7 +137,7 @@ export class EventEmitActionRunner implements ActionRunner {
         const name = String(options.name ?? '');
         if (!name) return { ok: false, error: 'event.emit requires a non-empty "name" option' };
         const payload = (options.payload as Record<string, unknown>) ?? {};
-        void context?.events?.emit('workflow.custom', { name, payload });
+        void context?.events?.emit('workflow.custom', { name, payload, severity: 'info' });
         return { ok: true, data: { name, payload } };
     }
 }

package/src/index.ts

@@ -2,6 +2,7 @@ export { loadWorkflowDef, loadWorkflowDefFromText, validateWorkflowDef } from '.
 export { FSMError, RunCollisionError, WorkflowResumeError, WorkflowValidationError } from './errors';
 export type { WorkflowEngineEvents } from './events';
 export {
+    collectWorkflowExtensions,
     type LoadWorkflowExtensionsOptions,
     loadWorkflowExtensionsIntoHost,
     type WorkflowExtensionKind,
@@ -36,6 +37,7 @@ export {
     StateMachineWorkflowDefSchema,
     TransitionFlowWorkflowDefSchema,
     WorkflowDefSchema,
+    WorkflowExtensionsSchema,
 } from './schema';
 export { WORKFLOW_ENGINE_SCHEMA_SQL } from './schema-sql';
 export { WorkflowService } from './service';
@@ -66,6 +68,7 @@ export type {
     TransitionRequestResult,
     Vars,
     WorkflowDef,
+    WorkflowExtensions,
     WorkflowPersistenceAdapter,
     WorkflowRunOptions,
     WorkflowRunRecord,

package/src/persistence.ts

@@ -17,6 +17,36 @@ export async function applyWorkflowEngineSchema(db: DbAdapter): Promise<void> {
     }
 }
 
+/** Narrow to a non-array object record. */
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Default result redactor (task 0060 F4): shell action results keep `ok`/`exitCode`
+ * but drop raw `stdout`/`stderr`, which may carry secrets, from the persisted row.
+ * Non-shell results pass through unchanged.
+ */
+export function defaultActionRedactor(kind: string, payload: Record<string, unknown>): Record<string, unknown> {
+    if (kind !== 'shell') return payload;
+    const data = isRecord(payload.data) ? { ...payload.data } : payload.data;
+    if (isRecord(data)) {
+        if ('stdout' in data) data.stdout = '[redacted]';
+        if ('stderr' in data) data.stderr = '[redacted]';
+    }
+    return { ...payload, data };
+}
+
+/** Apply the caller redactor, or the built-in default when none is supplied. */
+export function applyRedactor(
+    redactor: ActionRedactor | undefined,
+    kind: string,
+    result: unknown,
+): Record<string, unknown> {
+    const payload = isRecord(result) ? result : { value: result };
+    return redactor !== undefined ? redactor(kind, payload) : defaultActionRedactor(kind, payload);
+}
+
 /** SQLite/D1-compatible workflow persistence adapter backed by ts-db. */
 export class DbWorkflowPersistenceAdapter implements WorkflowPersistenceAdapter {
     /** Memoized schema-ensure; the DDL runs at most once per adapter instance. */
@@ -180,8 +210,9 @@ export class DbWorkflowPersistenceAdapter implements WorkflowPersistenceAdapter
         status: WorkflowStatus,
         durationMs: number,
         ok: boolean,
+        kind: string,
         result?: unknown,
-        _redactor?: ActionRedactor,
+        redactor?: ActionRedactor,
     ): Promise<void> {
         const now = Date.now();
         await this.db.run(
@@ -191,7 +222,7 @@ export class DbWorkflowPersistenceAdapter implements WorkflowPersistenceAdapter
             status,
             durationMs,
             ok ? 1 : 0,
-            result !== undefined ? JSON.stringify(result) : null,
+            result !== undefined ? JSON.stringify(applyRedactor(redactor, kind, result)) : null,
             new Date(now).toISOString(),
             now,
             actionId,
@@ -241,16 +272,18 @@ export class DbWorkflowPersistenceAdapter implements WorkflowPersistenceAdapter
         return { ...record };
     }
 
-    /** Force-set the current state of a run (reseed). */
+    /** Force-set the current state of a run (reseed). Atomic: snapshot + `__reseed__` transition
+     *  commit in one `db.batch`, and the previous snapshot's `effectiveVars` survive (task 0060 F6). */
     async reseedRun(runId: string, newState: string): Promise<WorkflowReseedResult> {
-        const now = Date.now();
         await this.ensureSchema();
-        const previous = await this.db.queryFirst<{ state: string }>(
-            'SELECT state FROM workflow_states WHERE run_id = ? ORDER BY created_at DESC, rowid DESC LIMIT 1',
-            runId,
-        );
-        await this.saveWorkflowState(runId, newState, { reseeded: true, reseededAt: new Date(now).toISOString() });
-        await this.saveTransition(runId, previous?.state ?? '', newState, '__reseed__');
+        const previous = await this.loadLatestStateSnapshot(runId);
+        const now = Date.now();
+        const data = {
+            ...(previous?.data ?? {}),
+            reseeded: true,
+            reseededAt: new Date(now).toISOString(),
+        };
+        await this.commitTransition(runId, previous?.state ?? '', newState, '__reseed__', newState, data);
         return { fromState: previous?.state ?? null, toState: newState };
     }
 
@@ -357,15 +390,16 @@ export class MemoryWorkflowPersistenceAdapter implements WorkflowPersistenceAdap
         status: WorkflowStatus,
         durationMs: number,
         ok: boolean,
+        kind: string,
         result?: unknown,
-        _redactor?: ActionRedactor,
+        redactor?: ActionRedactor,
     ): Promise<void> {
         const row = this.actionRuns.find((a) => a.id === actionId);
         if (row === undefined) return;
         row.status = status;
         row.durationMs = durationMs;
         row.ok = ok ? 1 : 0;
-        row.resultJson = result !== undefined ? JSON.stringify(result) : null;
+        row.resultJson = result !== undefined ? JSON.stringify(applyRedactor(redactor, kind, result)) : null;
     }
 
     /** Save one phase/state execution record. */
@@ -430,9 +464,13 @@ export class MemoryWorkflowPersistenceAdapter implements WorkflowPersistenceAdap
 
     /** Force-set the current state of a run (reseed). */
     async reseedRun(runId: string, newState: string): Promise<WorkflowReseedResult> {
-        const previous = this.states.findLast((state) => state.runId === runId);
-        await this.saveWorkflowState(runId, newState, { reseeded: true, reseededAt: new Date().toISOString() });
-        await this.saveTransition(runId, previous?.state ?? '', newState, '__reseed__');
+        const previous = await this.loadLatestStateSnapshot(runId);
+        const data = {
+            ...(previous?.data ?? {}),
+            reseeded: true,
+            reseededAt: new Date().toISOString(),
+        };
+        await this.commitTransition(runId, previous?.state ?? '', newState, '__reseed__', newState, data);
         return { fromState: previous?.state ?? null, toState: newState };
     }
 

package/src/run-lifecycle.ts

@@ -165,6 +165,7 @@ export class RunLifecycle {
                     runId: lifecycle.runId,
                     dryRun: options.dryRun ?? false,
                     externalKey: extKey,
+                    severity: 'info',
                 });
                 return await loop(lifecycle);
             },
@@ -217,6 +218,7 @@ export class RunLifecycle {
             runId: this.runId,
             node: stateOrNodeId,
             transitionsTaken,
+            severity: 'info',
         });
     }
 
@@ -251,6 +253,7 @@ export class RunLifecycle {
             to,
             trigger,
             externalKey: this.externalKey,
+            severity: 'info',
         });
     }
     async recordTransition(from: string, to: string, trigger: string | null): Promise<void> {
@@ -267,6 +270,7 @@ export class RunLifecycle {
             to,
             trigger,
             externalKey: this.externalKey,
+            severity: 'info',
         });
     }
 
@@ -281,6 +285,7 @@ export class RunLifecycle {
             finalState,
             transitionsTaken,
             externalKey: this.externalKey,
+            severity: 'info',
         });
         return this.result('done', finalState, transitionsTaken);
     }
@@ -295,6 +300,7 @@ export class RunLifecycle {
             finalState,
             reason,
             externalKey: this.externalKey,
+            severity: 'error',
         });
         this.logger.warn('workflow run failed', { finalState, transitionsTaken, reason });
         return this.result('failed', finalState, transitionsTaken, reason);
@@ -320,6 +326,7 @@ export class RunLifecycle {
             node: stateOrNodeId,
             transitionsTaken,
             externalKey: this.externalKey,
+            severity: 'warning',
         });
         return this.result('paused', stateOrNodeId, transitionsTaken);
     }
@@ -327,13 +334,23 @@ export class RunLifecycle {
     /** Emit the resumed event (called by WorkflowService after re-creating a lifecycle for resume). */
     emitResumed(node: string): void {
         addSpanEvent('workflow.run.resumed', { runId: this.runId, node });
-        void this.events?.emit('workflow.run.resumed', { runId: this.runId, node, externalKey: this.externalKey });
+        void this.events?.emit('workflow.run.resumed', {
+            runId: this.runId,
+            node,
+            externalKey: this.externalKey,
+            severity: 'info',
+        });
     }
 
     /** Emit action-level observability before a host action is invoked. */
     actionStart(stateOrNodeId: string, kind: string): void {
         addSpanEvent('workflow.action.start', { runId: this.runId, node: stateOrNodeId, kind });
-        void this.events?.emit('workflow.action.start', { runId: this.runId, node: stateOrNodeId, kind });
+        void this.events?.emit('workflow.action.start', {
+            runId: this.runId,
+            node: stateOrNodeId,
+            kind,
+            severity: 'info',
+        });
     }
 
     /** Emit action-level observability after a host action settles. */
@@ -345,6 +362,7 @@ export class RunLifecycle {
             kind,
             durationMs,
             ok,
+            severity: ok ? 'info' : 'error',
         });
     }
 
@@ -361,6 +379,7 @@ export class RunLifecycle {
             node: stateOrNodeId,
             transitionsTaken,
             ...(error === undefined ? {} : { error }),
+            severity: 'warning',
         });
         this.logger.warn('action failed (continuing)', { node: stateOrNodeId, transitionsTaken, error });
     }
@@ -374,17 +393,23 @@ export class RunLifecycle {
             kind,
             passed,
             externalKey: this.externalKey,
+            severity: passed ? 'info' : 'warning',
         });
     }
 
     /** Emit when an interactive HITL prompt is presented. */
     hitlAsk(node: string, kind: string, message: string): void {
-        void this.events?.emit('workflow.hitl.ask', { runId: this.runId, node, kind, message });
+        void this.events?.emit('workflow.hitl.ask', { runId: this.runId, node, kind, message, severity: 'info' });
     }
 
     /** Emit when an interactive HITL prompt resolves. */
     hitlResponse(node: string, ok: boolean): void {
-        void this.events?.emit('workflow.hitl.response', { runId: this.runId, node, ok });
+        void this.events?.emit('workflow.hitl.response', {
+            runId: this.runId,
+            node,
+            ok,
+            severity: ok ? 'info' : 'warning',
+        });
     }
 
     private result(

package/src/schema.ts

@@ -1,3 +1,4 @@
+import { assertRelativeExtensionPath } from '@gobing-ai/ts-runtime/extension';
 import { z } from 'zod';
 
 /** Identifier names reserved for runtime template namespaces; not allowed as user vars. */
@@ -23,6 +24,38 @@ const EnvSchema = z.object({
     allow: z.array(z.string().regex(IDENTIFIER, 'env.allow entries must be valid identifiers')).optional(),
 });
 
+/**
+ * Extension module paths must be relative and must not escape the declaring
+ * directory. Mirrors rule-engine's private helper; the real guard is the shared
+ * `assertRelativeExtensionPath` (ADR-010) so schema-time and load-time
+ * validation share one source of truth.
+ */
+const relativeExtensionPath = z
+    .string()
+    .min(1)
+    .superRefine((value, ctx) => {
+        try {
+            assertRelativeExtensionPath(value);
+        } catch (error) {
+            ctx.addIssue({
+                code: 'custom',
+                message: error instanceof Error ? error.message : 'invalid extension path',
+            });
+        }
+    });
+
+/**
+ * Rule-style `extensions` block for workflow YAML: relative module paths for
+ * the two extension-loadable capability kinds. `.strict()` rejects unknown keys
+ * (e.g. `evaluators` or `plugins`).
+ */
+export const WorkflowExtensionsSchema = z
+    .object({
+        actions: z.array(relativeExtensionPath).optional(),
+        guards: z.array(relativeExtensionPath).optional(),
+    })
+    .strict();
+
 /** Zod schema for workflow action definitions. */
 export const ActionDefSchema = z.object({
     kind: z.string().min(1),
@@ -75,6 +108,7 @@ export const StateMachineWorkflowDefSchema = z
                 })
                 .strict(),
         ),
+        extensions: WorkflowExtensionsSchema.optional(),
     })
     .strict();
 
@@ -115,6 +149,7 @@ export const TransitionFlowWorkflowDefSchema = z
                 })
                 .strict(),
         ),
+        extensions: WorkflowExtensionsSchema.optional(),
     })
     .strict();
 

package/src/service.ts

@@ -147,6 +147,7 @@ export class WorkflowService {
             fromState: result.fromState ?? '',
             toState: result.toState,
             externalKey: extKey,
+            severity: 'warning',
         });
     }
 
@@ -176,7 +177,12 @@ export class WorkflowService {
         const extKey = run.external_key ?? undefined;
         await this.persistence.finalizeRun(runId, 'running', '');
         const events = this.resolveEvents(mergedOptions.events);
-        void events?.emit('workflow.run.resumed', { runId, node: currentState, externalKey: extKey });
+        void events?.emit('workflow.run.resumed', {
+            runId,
+            node: currentState,
+            externalKey: extKey,
+            severity: 'info',
+        });
 
         // Resume through the appropriate driver, starting from the paused state (skip on-enter).
         if (workflow.kind === 'transition-flow') {
@@ -305,6 +311,7 @@ export class WorkflowService {
             to: toState,
             trigger,
             externalKey: extKey,
+            severity: 'info',
         });
         return { allowed: true, fromState: currentState, toState };
     }
@@ -328,6 +335,7 @@ export class WorkflowService {
             to,
             reason: denial.reason,
             externalKey,
+            severity: 'error',
         });
         return { allowed: false, ...denial };
     }

package/src/types.ts

@@ -29,6 +29,17 @@ export interface GuardDef {
     readonly options?: Record<string, unknown>;
 }
 
+/**
+ * Rule-style `extensions` block: relative module paths for the two
+ * extension-loadable capability kinds (`actions`, `guards`). Mirrors
+ * rule-engine's preset extensions; paths are resolved by the caller against
+ * the declaring YAML directory.
+ */
+export interface WorkflowExtensions {
+    readonly actions?: readonly string[];
+    readonly guards?: readonly string[];
+}
+
 /** One state in a state-machine workflow. */
 export interface StateDef {
     readonly id: string;
@@ -72,6 +83,7 @@ export interface StateMachineWorkflowDef {
     readonly env?: Env;
     readonly states: readonly StateDef[];
     readonly transitions: readonly TransitionDef[];
+    readonly extensions?: WorkflowExtensions;
 }
 
 /** Transition-flow node definition. */
@@ -111,6 +123,7 @@ export interface TransitionFlowWorkflowDef {
     readonly env?: Env;
     readonly nodes: readonly FlowNodeDef[];
     readonly edges: readonly FlowEdgeDef[];
+    readonly extensions?: WorkflowExtensions;
 }
 
 /** Discriminated workflow definition union. */
@@ -178,6 +191,13 @@ export interface WorkflowRunOptions {
     readonly events?: EventBus<WorkflowEngineEvents>;
     /** Run-level error policy override. Lowest precedence; action-level wins. */
     readonly onError?: OnErrorPolicy;
+    /**
+     * Optional result redaction hook applied before an action row is finalized.
+     * When omitted, the built-in default scrubs shell stdout/stderr so raw command
+     * output never lands in the audit table. Callers that need raw output in
+     * `action_runs.result_json` must supply their own redactor (task 0060 F4).
+     */
+    readonly redactor?: ActionRedactor;
     /** Validate the definition and walk the transition graph without executing actions. */
     readonly dryRun?: boolean;
     /** Optional caller-supplied external key, unique per workflow definition. */
@@ -287,12 +307,13 @@ export interface WorkflowPersistenceAdapter {
      * persistence implementations ignore it (mirror-only — no new column, no alter, no redaction).
      */
     saveActionStart(runId: string, node: string, kind: string, options?: Record<string, unknown>): Promise<string>;
-    /** Finalize an action row with duration, ok, result. */
+    /** Finalize an action row with duration, ok, result. `kind` names the action for the redactor. */
     saveActionFinalize(
         actionId: string,
         status: WorkflowStatus,
         durationMs: number,
         ok: boolean,
+        kind: string,
         result?: unknown,
         redactor?: ActionRedactor,
     ): Promise<void>;