@ductape/sdk 0.1.110 → 0.1.114

package/dist/features/feature-executor.js

@@ -11,9 +11,9 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a, _b;
+var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeatureExecutor = void 0;
+exports.FeatureExecutor = exports.UnresolvedInputReferenceError = void 0;
 const crypto_1 = require("crypto");
 const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
 const products_service_1 = __importDefault(require("../products/services/products.service"));
@@ -32,12 +32,24 @@ const inputs_types_1 = require("../types/inputs.types");
 const processor_utils_1 = require("../processor/utils/processor.utils");
 const productsBuilder_types_1 = require("../types/productsBuilder.types");
 const date_fns_1 = require("date-fns");
+const functions_1 = require("../functions");
+const context_1 = require("../context");
+class UnresolvedInputReferenceError extends Error {
+    constructor(reference, required) {
+        super(`Runtime input reference ${reference} is absent${required ? ' but required by the feature contract' : ''}.`);
+        this.reference = reference;
+        this.required = required;
+        this.code = 'UNRESOLVED_INPUT_REFERENCE';
+        this.name = 'UnresolvedInputReferenceError';
+    }
+}
+exports.UnresolvedInputReferenceError = UnresolvedInputReferenceError;
 /** Only log when DUCTAPE_DEBUG is set to avoid sync I/O and serialization cost in hot path */
 const debugLog = typeof process !== 'undefined' && (((_a = process.env) === null || _a === void 0 ? void 0 : _a.DUCTAPE_DEBUG) === 'true' || ((_b = process.env) === null || _b === void 0 ? void 0 : _b.DUCTAPE_DEBUG) === '1')
     ? (...args) => console.log(...args)
     : () => { };
-/** Always-on step/summary logging for visibility in tests and support */
-const stepLog = typeof process !== 'undefined'
+/** Detailed step logging is opt-in; synchronous stdout is expensive in server runtimes. */
+const stepLog = typeof process !== 'undefined' && (((_c = process.env) === null || _c === void 0 ? void 0 : _c.DUCTAPE_DEBUG) === 'true' || ((_d = process.env) === null || _d === void 0 ? void 0 : _d.DUCTAPE_DEBUG) === '1')
     ? (msg, data) => {
         if (data != null && Object.keys(data).length > 0) {
             console.log(`[FeatureExecutor] ${msg}`, data);
@@ -47,6 +59,39 @@ const stepLog = typeof process !== 'undefined'
         }
     }
     : () => { };
+const SENSITIVE_LOG_KEY = /(?:authorization|cookie|password|passwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key|client[_-]?secret|session)/i;
+const MAX_LOG_STRING_LENGTH = 2000;
+/** Produce useful payload traces without leaking credentials or exploding logs. */
+const sanitizeForLog = (value, key = '', seen = new WeakSet()) => {
+    if (key !== 'has_session' && SENSITIVE_LOG_KEY.test(key))
+        return '[REDACTED]';
+    if (value == null || typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value === 'string') {
+        return value.length > MAX_LOG_STRING_LENGTH
+            ? `${value.slice(0, MAX_LOG_STRING_LENGTH)}...[truncated ${value.length - MAX_LOG_STRING_LENGTH} chars]`
+            : value;
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+        return `[Buffer ${value.length} bytes]`;
+    }
+    if (value instanceof Error)
+        return { name: value.name, message: value.message, stack: value.stack };
+    if (Array.isArray(value))
+        return value.map((item) => sanitizeForLog(item, key, seen));
+    if (typeof value === 'object') {
+        if (seen.has(value))
+            return '[Circular]';
+        seen.add(value);
+        return Object.fromEntries(Object.entries(value).map(([nestedKey, nestedValue]) => [
+            nestedKey,
+            sanitizeForLog(nestedValue, nestedKey, seen),
+        ]));
+    }
+    return String(value);
+};
 /** Observability must not disappear because a successful result contains BigInt or cycles. */
 const stringifyProcessorValue = (value) => {
     const seen = new WeakSet();
@@ -115,6 +160,9 @@ class FeatureExecutor {
         this.graphConnectionUsed = false;
         /** Pre-fetched bootstrap data per step tag (feature batch prefetch). */
         this.stepBootstrapCache = new Map();
+        this.functionInvocations = new Map();
+        /** Step telemetry is accumulated and persisted with the terminal feature record in one round trip. */
+        this.pendingProcessorResults = [];
         debugLog('[FeatureExecutor] constructor ENTRY', {
             feature_tag: feature.tag,
             product: options.product,
@@ -123,6 +171,7 @@ class FeatureExecutor {
         });
         this.config = config;
         this.feature = feature;
+        this.inheritedSession = options.session;
         this.sessionLogFields = sessionLogFields || {};
         this._privateKey = private_key || '';
         this.preInitializedProduct = Boolean(preInitializedBuilder);
@@ -158,8 +207,26 @@ class FeatureExecutor {
             feature_id: this.state.feature_id,
             feature_tag: this.state.feature_tag,
             steps_count: (_b = (_a = feature.steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+            has_session: Boolean(this.inheritedSession),
+            input: sanitizeForLog(options.input),
         });
     }
+    /** Debug-only structured execution trace. Payloads are recursively redacted. */
+    trace(stage, payload = {}) {
+        debugLog('[FeatureExecutor][trace]', sanitizeForLog(Object.assign({ stage, feature_id: this.state.feature_id, feature_tag: this.state.feature_tag, product: this.state.product, env: this.state.env, has_session: Boolean(this.inheritedSession) }, payload)));
+    }
+    /** Brokers expose the same session as separate tag/token fields. */
+    inheritedBrokerSession() {
+        if (!this.inheritedSession)
+            return undefined;
+        const separator = this.inheritedSession.indexOf(':');
+        if (separator < 1)
+            return undefined;
+        return {
+            tag: this.inheritedSession.slice(0, separator),
+            token: this.inheritedSession.slice(separator + 1),
+        };
+    }
     /**
      * Get auth payload for API calls
      */
@@ -190,6 +257,10 @@ class FeatureExecutor {
                 access_key: this.config.access_key,
                 preInitializedProductBuilder: this.productBuilder,
             });
+            this._processorService.setFeatureExecutionContext({
+                feature_id: this.state.feature_id,
+                feature_tag: this.state.feature_tag,
+            });
         }
         return this._processorService;
     }
@@ -204,6 +275,7 @@ class FeatureExecutor {
                 env_type: this.config.env_type,
                 private_key: this._privateKey,
                 access_key: this.config.access_key,
+                redis_client: this.config.redis_client,
             });
         }
         return this._graphService;
@@ -219,6 +291,8 @@ class FeatureExecutor {
                 env_type: this.config.env_type,
                 private_key: this._privateKey,
                 access_key: this.config.access_key,
+                redis_client: this.config.redis_client,
+                preInitializedProductBuilder: this.productBuilder,
             });
         }
         return this._databaseService;
@@ -322,23 +396,10 @@ class FeatureExecutor {
             const resultStr = stringifyProcessorValue(resultData);
             const inputStr = stringifyProcessorValue(inputPayload);
             const encKey = this.getProcessorResultEncryptionKey();
-            const processorResult = {
-                process_id: this.state.feature_id,
-                product_id: this.productId || null,
-                env: this.state.env,
-                component: types_1.LogEventTypes.FEATURE,
-                status,
-                start: this.state.started_at,
-                end: Date.now(),
-                retryable: true,
-                result: encKey ? (0, processor_utils_1.encrypt)(resultStr, encKey) : resultStr,
-                input: encKey ? (0, processor_utils_1.encrypt)(inputStr, encKey) : inputStr,
-                feature_id: this.state.feature_id,
-                feature_tag: this.state.feature_tag,
-                product_tag: this.state.product,
-                workspace_id: this.config.workspace_id,
-            };
-            await this.processorApiService.saveResult(processorResult, this.getAuthPayload());
+            const processorResult = Object.assign(Object.assign({}, (0, context_1.executionContextFields)()), { process_id: this.state.feature_id, product_id: this.productId || null, env: this.state.env, component: types_1.LogEventTypes.FEATURE, status, start: this.state.started_at, end: Date.now(), retryable: true, result: encKey ? (0, processor_utils_1.encrypt)(resultStr, encKey) : resultStr, input: encKey ? (0, processor_utils_1.encrypt)(inputStr, encKey) : inputStr, feature_id: this.state.feature_id, feature_tag: this.state.feature_tag, product_tag: this.state.product, workspace_id: this.config.workspace_id });
+            this.trace('execution.persistence.sent', { status, payload: resultData });
+            await this.processorApiService.saveResultsBatch([...this.pendingProcessorResults.splice(0), processorResult], this.getAuthPayload());
+            this.trace('execution.persistence.acknowledged', { status, process_id: this.state.feature_id });
             debugLog('[FeatureExecutor] persistExecutionResult SUCCESS', { feature_id: this.state.feature_id, status });
         }
         catch (err) {
@@ -374,6 +435,7 @@ class FeatureExecutor {
      * Processor results for steps always have component: 'feature_step' and step_type set to the step kind.
      */
     async persistStepResult(step, status, output, error, duration, input) {
+        var _a;
         const resolvedInput = input !== null && input !== void 0 ? input : step.input;
         const stepType = this.getStepTypeForResult(step);
         debugLog('[FeatureExecutor] persistStepResult ENTRY', {
@@ -394,27 +456,17 @@ class FeatureExecutor {
             const resultStr = stringifyProcessorValue(value);
             const inputStr = stringifyProcessorValue(resolvedInput);
             const encKey = this.getProcessorResultEncryptionKey();
-            const stepResult = {
-                process_id: stepProcessId,
-                product_id: this.productId || null,
-                env: this.state.env,
-                component: types_1.LogEventTypes.FEATURE_STEP, // step results always feature_step
-                status,
-                start: Date.now() - (duration || 0),
-                end: Date.now(),
-                retryable: true,
-                result: encKey ? (0, processor_utils_1.encrypt)(resultStr, encKey) : resultStr,
-                input: encKey ? (0, processor_utils_1.encrypt)(inputStr, encKey) : inputStr,
-                feature_id: this.state.feature_id,
-                feature_tag: this.state.feature_tag,
-                product_tag: this.state.product,
-                workspace_id: this.config.workspace_id,
+            const stepResult = Object.assign(Object.assign(Object.assign({}, (0, context_1.executionContextFields)()), { process_id: stepProcessId, product_id: this.productId || null, env: this.state.env, component: types_1.LogEventTypes.FEATURE_STEP, // step results always feature_step
+                status, start: Date.now() - (duration || 0), end: Date.now(), retryable: true, result: encKey ? (0, processor_utils_1.encrypt)(resultStr, encKey) : resultStr, input: encKey ? (0, processor_utils_1.encrypt)(inputStr, encKey) : inputStr, feature_id: this.state.feature_id, feature_tag: this.state.feature_tag, product_tag: this.state.product, workspace_id: this.config.workspace_id, step_tag: step.tag, step_type: stepType, step_error: error, step_duration_ms: duration }), ((_a = this.functionInvocations.get(step.tag)) !== null && _a !== void 0 ? _a : {}));
+            this.trace('step.persistence.sent', {
                 step_tag: step.tag,
-                step_type: stepType, // action | notification | storage | produce | database_action | graph | vector | quota | fallback | child_feature | sleep | wait_for_signal | checkpoint
-                step_error: error,
-                step_duration_ms: duration,
-            };
-            await this.processorApiService.saveResult(stepResult, this.getAuthPayload());
+                step_type: stepType,
+                status,
+                input: resolvedInput,
+                output: value,
+            });
+            this.pendingProcessorResults.push(stepResult);
+            this.trace('step.persistence.queued', { step_tag: step.tag, status, process_id: stepProcessId });
             debugLog('[FeatureExecutor] persistStepResult SUCCESS', { feature_id: this.state.feature_id, step_tag: step.tag });
         }
         catch (err) {
@@ -467,7 +519,26 @@ class FeatureExecutor {
      * Execute the feature
      */
     async execute() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        var _a;
+        const context = (0, context_1.createExecutionContext)({
+            kind: 'feature',
+            workspace_id: this.config.workspace_id,
+            product_id: (_a = this.productId) !== null && _a !== void 0 ? _a : undefined,
+            product_tag: this.state.product,
+            env: this.state.env,
+            feature_id: this.state.feature_id,
+            feature_tag: this.state.feature_tag,
+            feature_run_id: this.state.feature_id,
+            process_id: this.state.feature_id,
+            session: this.inheritedSession,
+            session_id: this.sessionLogFields.session_id,
+            session_tag: this.sessionLogFields.session_tag,
+            session_user_id: this.sessionLogFields.session_user_id,
+        });
+        return (0, context_1.runWithExecutionContext)(context, () => this.executeInContext());
+    }
+    async executeInContext() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         const startTime = Date.now();
         debugLog('[FeatureExecutor] execute ENTRY', {
             feature_id: this.state.feature_id,
@@ -475,6 +546,10 @@ class FeatureExecutor {
             product: this.state.product,
             env: this.state.env,
         });
+        this.trace('execution.started', {
+            input: this.state.input,
+            configured_steps: (_a = this.feature.steps) === null || _a === void 0 ? void 0 : _a.map((step) => ({ tag: step.tag, type: step.type, input: step.input })),
+        });
         try {
             // Track phase so failures before first step are reported as (initialization)
             this.state.current_step = '(initialization)';
@@ -487,6 +562,7 @@ class FeatureExecutor {
                 this.productId = this.productBuilder.fetchProductId();
             }
             debugLog('[FeatureExecutor] execute product initialized', { feature_id: this.state.feature_id, product_id: this.productId });
+            this.trace('product.fetched', { product_id: this.productId, preinitialized: this.preInitializedProduct });
             // Initialize logging after we have product ID
             this.initializeLogging();
             this.state.status = types_1.FeatureStatus.RUNNING;
@@ -507,14 +583,17 @@ class FeatureExecutor {
             }
             catch (prefetchErr) {
                 stepLog('Bootstrap prefetch failed (continuing without prefetch)', {
-                    error: (_a = prefetchErr === null || prefetchErr === void 0 ? void 0 : prefetchErr.message) !== null && _a !== void 0 ? _a : String(prefetchErr),
+                    error: (_b = prefetchErr === null || prefetchErr === void 0 ? void 0 : prefetchErr.message) !== null && _b !== void 0 ? _b : String(prefetchErr),
                 });
                 this.stepBootstrapCache.clear();
             }
             // Execute each step
             for (const step of orderedSteps) {
                 // Check step condition if present
-                if (step.condition && !(await this.evaluateCondition(step.condition))) {
+                const conditionMet = step.condition ? await this.evaluateCondition(step.condition) : true;
+                if (step.condition)
+                    this.trace('step.condition.evaluated', { step_tag: step.tag, condition: step.condition, result: conditionMet });
+                if (!conditionMet) {
                     debugLog('[FeatureExecutor] execute step SKIPPED (condition)', { feature_id: this.state.feature_id, step_tag: step.tag });
                     this.logStepEvent(step, `Step ${step.tag} - skipped (condition not met)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
                     continue; // Skip step if condition not met
@@ -535,8 +614,8 @@ class FeatureExecutor {
                     success: result.success,
                     durationMs: result.duration,
                     hasError: !!result.error,
-                    input: result.input,
-                    output: result.output,
+                    input: sanitizeForLog(result.input),
+                    output: sanitizeForLog(result.output),
                 });
                 // Log step completion
                 this.logStepEvent(step, result.success ? `Step ${step.tag} - completed` : `Step ${step.tag} - failed`, result.success ? logs_types_1.LogEventStatus.SUCCESS : logs_types_1.LogEventStatus.FAIL, { duration: result.duration, error: result.error });
@@ -548,14 +627,14 @@ class FeatureExecutor {
                     try {
                         stepReturnValue = await this.resolveInput(outputSchema, result.output);
                     }
-                    catch (_p) {
+                    catch (_q) {
                         stepReturnValue = result.output;
                     }
                 }
                 else if (!result.success) {
                     stepReturnValue = undefined;
                 }
-                console.warn(`[FeatureExecutor] Step "${step.tag}" output:`, stepReturnValue);
+                debugLog(`[FeatureExecutor] Step "${step.tag}" output:`, stepReturnValue);
                 // Persist step result to backend (use step return shape, not raw primitive)
                 await this.persistStepResult(step, result.success ? types_1.LogEventStatus.SUCCESS : types_1.LogEventStatus.FAIL, stepReturnValue, result.error, result.duration, result.input);
                 this.state.step_timings.push({
@@ -565,22 +644,22 @@ class FeatureExecutor {
                 });
                 if (!result.success) {
                     this.state.failed_step = step.tag;
-                    stepLog('Step failed', { tag: step.tag, error: result.error, allow_fail: (_b = step.options) === null || _b === void 0 ? void 0 : _b.allow_fail, optional: (_c = step.options) === null || _c === void 0 ? void 0 : _c.optional });
+                    stepLog('Step failed', { tag: step.tag, error: result.error, allow_fail: (_c = step.options) === null || _c === void 0 ? void 0 : _c.allow_fail, optional: (_d = step.options) === null || _d === void 0 ? void 0 : _d.optional });
                     debugLog('[FeatureExecutor] execute step FAILED', {
                         feature_id: this.state.feature_id,
                         step_tag: step.tag,
                         error: result.error,
-                        allow_fail: (_d = step.options) === null || _d === void 0 ? void 0 : _d.allow_fail,
-                        optional: (_e = step.options) === null || _e === void 0 ? void 0 : _e.optional,
+                        allow_fail: (_e = step.options) === null || _e === void 0 ? void 0 : _e.allow_fail,
+                        optional: (_f = step.options) === null || _f === void 0 ? void 0 : _f.optional,
                     });
                     // Check if step allows failure
-                    if ((_f = step.options) === null || _f === void 0 ? void 0 : _f.allow_fail) {
+                    if ((_g = step.options) === null || _g === void 0 ? void 0 : _g.allow_fail) {
                         // Store error but continue
                         this.state.steps[step.tag] = { error: result.error };
                         continue;
                     }
                     // Check if step is optional
-                    if ((_g = step.options) === null || _g === void 0 ? void 0 : _g.optional) {
+                    if ((_h = step.options) === null || _h === void 0 ? void 0 : _h.optional) {
                         // Don't trigger rollback, just continue
                         continue;
                     }
@@ -592,7 +671,7 @@ class FeatureExecutor {
                         feature_id: this.state.feature_id,
                         success: rollbackResult.success,
                         rolled_back_steps: rollbackResult.rolled_back_steps,
-                        failed_rollbacks: (_j = (_h = rollbackResult.failed_steps) === null || _h === void 0 ? void 0 : _h.length) !== null && _j !== void 0 ? _j : 0,
+                        failed_rollbacks: (_k = (_j = rollbackResult.failed_steps) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : 0,
                     });
                     // Persist failed feature result
                     await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, result.error);
@@ -603,7 +682,7 @@ class FeatureExecutor {
                         completed_steps: this.state.completed_steps,
                         step_timings: this.state.step_timings,
                     });
-                    await ((_k = this.logService) === null || _k === void 0 ? void 0 : _k.publish());
+                    await ((_l = this.logService) === null || _l === void 0 ? void 0 : _l.publish());
                     if (this.graphConnectionUsed) {
                         await this.getGraphService().disconnect().catch(() => { });
                         await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
@@ -637,6 +716,7 @@ class FeatureExecutor {
             this.state.ended_at = Date.now();
             // Determine output - use last step output or aggregate (resolves $ operators)
             const output = await this.determineWorkflowOutput();
+            this.trace('execution.output.resolved', { output, completed_steps: this.state.completed_steps });
             stepLog('Run finished (completed)', {
                 status: types_1.FeatureStatus.COMPLETED,
                 completed_steps: this.state.completed_steps,
@@ -652,7 +732,7 @@ class FeatureExecutor {
             // Persist successful feature result
             await this.persistExecutionResult(types_1.LogEventStatus.SUCCESS, output);
             // Fire-and-forget log publish on success so we don't block on log upload
-            (_l = this.logService) === null || _l === void 0 ? void 0 : _l.publish().catch(() => { });
+            (_m = this.logService) === null || _m === void 0 ? void 0 : _m.publish().catch(() => { });
             if (this.graphConnectionUsed) {
                 await this.getGraphService().disconnect().catch(() => { });
                 await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
@@ -675,8 +755,9 @@ class FeatureExecutor {
             this.state.status = types_1.FeatureStatus.FAILED;
             this.state.ended_at = Date.now();
             const details = formatErrorDetails(error);
-            const failedAt = (_m = this.state.current_step) !== null && _m !== void 0 ? _m : '(unknown)';
-            debugLog('[FeatureExecutor] execute FAILED (exception)', Object.assign(Object.assign({ feature_id: this.state.feature_id, feature_tag: this.state.feature_tag, failed_at: failedAt, completed_steps: this.state.completed_steps, error: details.message }, (details.status != null && { http_status: details.status })), (details.responseBody != null && { response_body: details.responseBody })));
+            const failedAt = (_o = this.state.current_step) !== null && _o !== void 0 ? _o : '(unknown)';
+            debugLog('[FeatureExecutor] execute FAILED (exception)', Object.assign(Object.assign({ feature_id: this.state.feature_id, feature_tag: this.state.feature_tag, failed_at: failedAt, completed_steps: this.state.completed_steps, error: details.message }, (details.status != null && { http_status: details.status })), (details.responseBody != null && { response_body: sanitizeForLog(details.responseBody) })));
+            this.trace('execution.failed', { failed_at: failedAt, error: details, completed_steps: this.state.completed_steps });
             if (details.stack) {
                 debugLog('[FeatureExecutor] execute FAILED stack', details.stack);
             }
@@ -686,7 +767,7 @@ class FeatureExecutor {
                 : `Failed at ${failedAt}: ${details.message}`;
             stepLog('Run finished (failed - exception)', Object.assign({ status: types_1.FeatureStatus.FAILED, failed_step: failedAt, error: errorSummary, completed_steps: this.state.completed_steps, step_timings: this.state.step_timings }, (details.reason && { reason: details.reason })));
             await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, errorSummary);
-            await ((_o = this.logService) === null || _o === void 0 ? void 0 : _o.publish());
+            await ((_p = this.logService) === null || _p === void 0 ? void 0 : _p.publish());
             if (this.graphConnectionUsed) {
                 await this.getGraphService().disconnect().catch(() => { });
                 await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
@@ -711,6 +792,19 @@ class FeatureExecutor {
      * Execute a single step
      */
     async executeStep(step) {
+        const parent = (0, context_1.currentExecutionContext)();
+        const stepRunId = (0, crypto_1.randomUUID)();
+        const context = (0, context_1.createExecutionContext)({
+            kind: 'step',
+            step_tag: step.tag,
+            step_run_id: stepRunId,
+            step_attempt: 1,
+            process_id: `${this.state.feature_id}:${step.tag}`,
+            parent_process_id: this.state.feature_id,
+        }, parent);
+        return (0, context_1.runWithExecutionContext)(context, () => this.executeStepInContext(step));
+    }
+    async executeStepInContext(step) {
         const startTime = Date.now();
         debugLog('[FeatureExecutor] executeStep ENTRY', {
             feature_id: this.state.feature_id,
@@ -719,12 +813,14 @@ class FeatureExecutor {
         });
         let resolvedInput = {};
         try {
+            this.trace('step.input.supplied', { step_tag: step.tag, step_type: step.type, payload: step.input || {} });
             // Resolve input with data references and all $ operators
             resolvedInput = (await this.resolveInput(step.input || {}));
+            this.trace('step.input.resolved', { step_tag: step.tag, step_type: step.type, payload: resolvedInput });
             debugLog('[FeatureExecutor] executeStep input', {
                 feature_id: this.state.feature_id,
                 step_tag: step.tag,
-                input: resolvedInput,
+                input: sanitizeForLog(resolvedInput),
             });
             let output;
             // Route steps to dedicated services; only action and notification use ProcessorService.
@@ -751,6 +847,9 @@ class FeatureExecutor {
                 case types_1.FeatureStepType.VECTOR:
                     output = await this.executeVectorStep(step, resolvedInput);
                     break;
+                case types_1.FeatureStepType.FUNCTION:
+                    output = await this.executeFunctionStep(step, resolvedInput);
+                    break;
                 case types_1.FeatureStepType.QUOTA:
                     output = await this.executeQuotaStep(step, resolvedInput);
                     break;
@@ -792,15 +891,16 @@ class FeatureExecutor {
                 }
             }
             const duration = Date.now() - startTime;
+            this.trace('step.response.received', { step_tag: step.tag, step_type: step.type, payload: output, duration_ms: duration });
             debugLog('[FeatureExecutor] executeStep output', {
                 feature_id: this.state.feature_id,
                 step_tag: step.tag,
-                output,
+                output: sanitizeForLog(output),
                 durationMs: duration,
             });
             return {
                 success: true,
-                input: resolvedInput,
+                input: sanitizeForLog(resolvedInput),
                 output,
                 duration,
             };
@@ -812,7 +912,14 @@ class FeatureExecutor {
             const stepErrorMsg = details.reason != null
                 ? (details.status != null ? `${details.reason} (HTTP ${details.status})` : details.reason)
                 : (details.status != null ? `${details.message} (HTTP ${details.status})` : details.message);
-            debugLog('[FeatureExecutor] executeStep FAILED', Object.assign(Object.assign({ feature_id: this.state.feature_id, step_tag: step.tag, step_type: step.type, durationMs: duration, input: resolvedInput, error: stepErrorMsg }, (details.status != null && { http_status: details.status })), (details.responseBody != null && { response_body: details.responseBody })));
+            debugLog('[FeatureExecutor] executeStep FAILED', Object.assign(Object.assign({ feature_id: this.state.feature_id, step_tag: step.tag, step_type: step.type, durationMs: duration, input: resolvedInput, error: stepErrorMsg }, (details.status != null && { http_status: details.status })), (details.responseBody != null && { response_body: sanitizeForLog(details.responseBody) })));
+            this.trace('step.failed', {
+                step_tag: step.tag,
+                step_type: step.type,
+                payload: resolvedInput,
+                error: details,
+                duration_ms: duration,
+            });
             return {
                 success: false,
                 input: resolvedInput,
@@ -829,9 +936,10 @@ class FeatureExecutor {
         debugLog('[FeatureExecutor] executeActionStep', { feature_id: this.state.feature_id, step_tag: step.tag, app: step.app });
         // Step that only returns (no component call): no app → passthrough, output = resolved input
         if (!step.app) {
+            this.trace('action.passthrough', { step_tag: step.tag, payload: input });
             return input;
         }
-        return this.getProcessorService().processAction({
+        const payload = {
             product: this.state.product,
             env: this.state.env,
             app: step.app,
@@ -839,25 +947,30 @@ class FeatureExecutor {
             input: input,
             retries: ((_a = step.options) === null || _a === void 0 ? void 0 : _a.retries) || 0,
             cache: (_b = step.options) === null || _b === void 0 ? void 0 : _b.cache,
+            session: this.inheritedSession,
             preloadedBootstrap: this.stepBootstrapCache.get(step.tag),
-        });
+        };
+        this.trace('action.request.sent', { step_tag: step.tag, payload });
+        return this.getProcessorService().processAction(payload);
     }
     /**
      * Execute a database step: use query/insert/update/delete/upsert for DB operations, execute() for named actions.
      */
     async executeDatabaseStep(step, input) {
+        var _a;
         const database = step.database;
         const product = this.state.product;
         const env = this.state.env;
         const event = (step.event || '').toLowerCase();
         const db = this.getDatabaseService();
-        const opts = Object.assign({ product, env, database }, input);
+        const opts = Object.assign(Object.assign({ product, env, database }, input), { session: (_a = input.session) !== null && _a !== void 0 ? _a : this.inheritedSession });
         debugLog('[FeatureExecutor] executeDatabaseStep', {
             feature_id: this.state.feature_id,
             step_tag: step.tag,
             database,
             event,
         });
+        this.trace('database.request.sent', { step_tag: step.tag, event, payload: opts });
         switch (event) {
             case 'query':
                 return db.query(opts);
@@ -876,6 +989,7 @@ class FeatureExecutor {
                     database,
                     action: step.event,
                     input: input,
+                    session: this.inheritedSession,
                 });
         }
     }
@@ -886,14 +1000,17 @@ class FeatureExecutor {
         var _a;
         const event = `${step.notification}:${step.event}`;
         debugLog('[FeatureExecutor] executeNotificationStep', { feature_id: this.state.feature_id, step_tag: step.tag, event });
-        return this.getProcessorService().processNotification({
+        const payload = {
             product: this.state.product,
             env: this.state.env,
             event,
             input: input,
             retries: ((_a = step.options) === null || _a === void 0 ? void 0 : _a.retries) || 0,
+            session: this.inheritedSession,
             preloadedBootstrap: this.stepBootstrapCache.get(step.tag),
-        });
+        };
+        this.trace('notification.request.sent', { step_tag: step.tag, payload });
+        return this.getProcessorService().processNotification(payload);
     }
     /**
      * Execute a storage step using StorageService (upload, download, or delete by input shape).
@@ -903,9 +1020,10 @@ class FeatureExecutor {
         const product = this.state.product;
         const env = this.state.env;
         const storage = step.storage;
-        const opts = { product, env, storage };
+        const opts = { product, env, storage, session: this.inheritedSession };
         debugLog('[FeatureExecutor] executeStorageStep', { feature_id: this.state.feature_id, step_tag: step.tag, storage, event: step.event });
         const inp = input;
+        this.trace('storage.request.sent', { step_tag: step.tag, event: step.event, payload: Object.assign(Object.assign({}, opts), inp) });
         if (inp.buffer != null && inp.fileName != null) {
             return this.getStorageService().upload(Object.assign(Object.assign({}, opts), { fileName: String(inp.fileName), buffer: inp.buffer, mimeType: inp.mimeType != null ? String(inp.mimeType) : undefined }));
         }
@@ -922,12 +1040,15 @@ class FeatureExecutor {
         const event = `${step.broker}:${step.event}`;
         const message = (input && input.message != null) ? input.message : (input || {});
         debugLog('[FeatureExecutor] executeProduceStep', { feature_id: this.state.feature_id, step_tag: step.tag, event });
-        return this.getBrokersService().publish({
+        const payload = {
             product: this.state.product,
             env: this.state.env,
             event,
             message: message,
-        });
+            session: this.inheritedBrokerSession(),
+        };
+        this.trace('event.request.sent', { step_tag: step.tag, payload });
+        return this.getBrokersService().publish(payload);
     }
     /**
      * Execute a graph step
@@ -938,6 +1059,7 @@ class FeatureExecutor {
         const graphTag = step.graph;
         const action = step.event;
         debugLog('[FeatureExecutor] executeGraphStep', { feature_id: this.state.feature_id, step_tag: step.tag, graph: graphTag, action });
+        this.trace('graph.request.preparing', { step_tag: step.tag, action, graph: graphTag, payload: input });
         this.graphConnectionUsed = true;
         await this.getGraphService().connect({
             env: this.state.env,
@@ -951,6 +1073,7 @@ class FeatureExecutor {
                     const result = await this.getGraphService().createNode({
                         labels: input.labels,
                         properties: input.properties,
+                        session: this.inheritedSession,
                     });
                     return result;
                 }
@@ -958,6 +1081,7 @@ class FeatureExecutor {
                     const result = await this.getGraphService().updateNode({
                         id: input.id,
                         properties: input.properties,
+                        session: this.inheritedSession,
                     });
                     return result;
                 }
@@ -965,6 +1089,7 @@ class FeatureExecutor {
                     const result = await this.getGraphService().deleteNode({
                         id: input.id,
                         detach: input.detach,
+                        session: this.inheritedSession,
                     });
                     return result;
                 }
@@ -974,17 +1099,19 @@ class FeatureExecutor {
                         endNodeId: input.endNodeId || input.to,
                         type: input.type,
                         properties: input.properties,
+                        session: this.inheritedSession,
                     });
                     return result;
                 }
                 case 'deleteRelationship': {
                     const result = await this.getGraphService().deleteRelationship({
                         id: input.id,
+                        session: this.inheritedSession,
                     });
                     return result;
                 }
                 case 'query': {
-                    const result = await this.getGraphService().query(input.query, input.params);
+                    const result = await this.getGraphService().query(input.query, input.params, undefined, this.inheritedSession);
                     return result;
                 }
                 case 'findNodes': {
@@ -993,6 +1120,7 @@ class FeatureExecutor {
                         where: input.where,
                         limit: input.limit,
                         skip: input.skip,
+                        session: this.inheritedSession,
                     });
                     return result;
                 }
@@ -1002,6 +1130,7 @@ class FeatureExecutor {
                         relationshipTypes: input.relationshipTypes,
                         direction: input.direction,
                         maxDepth: input.maxDepth,
+                        session: this.inheritedSession,
                     });
                     return result;
                 }
@@ -1013,6 +1142,7 @@ class FeatureExecutor {
                         graph: graphTag,
                         action,
                         input,
+                        session: this.inheritedSession,
                     });
                     return result;
                 }
@@ -1026,7 +1156,7 @@ class FeatureExecutor {
      * Execute a vector step (query, upsert, deleteVectors, or custom action via execute).
      */
     async executeVectorStep(step, input) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         const vectorTag = step.vector;
         if (!vectorTag) {
             throw new Error(`Vector step "${step.tag}" has no vector tag`);
@@ -1041,21 +1171,22 @@ class FeatureExecutor {
             vector: vectorTag,
             event,
         });
+        this.trace('vector.request.preparing', { step_tag: step.tag, event, vector: vectorTag, payload: input });
         switch (event) {
             case 'query': {
-                const result = await svc.query(Object.assign({ product,
-                    env, tag: vectorTag }, input));
+                const result = await svc.query(Object.assign(Object.assign({ product,
+                    env, tag: vectorTag }, input), { session: (_a = input.session) !== null && _a !== void 0 ? _a : this.inheritedSession }));
                 return result;
             }
             case 'upsert': {
-                const result = await svc.upsert(Object.assign({ product,
-                    env, tag: vectorTag }, input));
+                const result = await svc.upsert(Object.assign(Object.assign({ product,
+                    env, tag: vectorTag }, input), { session: (_b = input.session) !== null && _b !== void 0 ? _b : this.inheritedSession }));
                 return result;
             }
             case 'delete':
             case 'deletevectors': {
-                const result = await svc.deleteVectors(Object.assign({ product,
-                    env, tag: vectorTag }, input));
+                const result = await svc.deleteVectors(Object.assign(Object.assign({ product,
+                    env, tag: vectorTag }, input), { session: (_c = input.session) !== null && _c !== void 0 ? _c : this.inheritedSession }));
                 return result;
             }
             default: {
@@ -1066,9 +1197,10 @@ class FeatureExecutor {
                     vector: vectorTag,
                     action: step.event,
                     input: input,
+                    session: this.inheritedSession,
                 });
-                const op = (_a = resolved === null || resolved === void 0 ? void 0 : resolved._operation) !== null && _a !== void 0 ? _a : resolved === null || resolved === void 0 ? void 0 : resolved.operation;
-                const opts = Object.assign({ product, env, tag: vectorTag }, resolved);
+                const op = (_d = resolved === null || resolved === void 0 ? void 0 : resolved._operation) !== null && _d !== void 0 ? _d : resolved === null || resolved === void 0 ? void 0 : resolved.operation;
+                const opts = Object.assign(Object.assign({ product, env, tag: vectorTag }, resolved), { session: (_e = resolved.session) !== null && _e !== void 0 ? _e : this.inheritedSession });
                 if (op === 'query' || !op) {
                     return svc.query(opts);
                 }
@@ -1082,6 +1214,54 @@ class FeatureExecutor {
             }
         }
     }
+    /** Execute a portable application function through a local handler or signed HTTP transport. */
+    async executeFunctionStep(step, input) {
+        var _a, _b, _c;
+        const reference = step.function_ref;
+        if (!reference) {
+            throw new Error(`Function step "${step.tag}" has no function_ref. Recompile the feature with ctx.functions.`);
+        }
+        const invocationId = (0, crypto_1.randomUUID)();
+        this.functionInvocations.set(step.tag, {
+            function_invocation_id: invocationId,
+            function_namespace: reference.namespace,
+            function_operation: reference.operation,
+            function_version: reference.version,
+        });
+        const deadlineAt = reference.timeout_ms ? Date.now() + reference.timeout_ms : undefined;
+        this.trace('function.resolution.started', {
+            step_tag: step.tag,
+            invocation_id: invocationId,
+            function: `${reference.namespace}.${reference.operation}@${reference.version}`,
+            transports: reference.transports.map(transport => transport.type),
+            payload: input,
+        });
+        const output = await functions_1.portableFunctions.invoke(reference, input, {
+            product: this.state.product,
+            env: this.state.env,
+            workspace_id: this.config.workspace_id,
+            feature_id: this.state.feature_id,
+            feature_tag: this.state.feature_tag,
+            feature_run_id: this.state.feature_id,
+            step_tag: step.tag,
+            step_run_id: (_a = (0, context_1.currentExecutionContext)()) === null || _a === void 0 ? void 0 : _a.step_run_id,
+            invocation_id: invocationId,
+            trace_id: (_b = (0, context_1.currentExecutionContext)()) === null || _b === void 0 ? void 0 : _b.trace_id,
+            parent_span_id: (_c = (0, context_1.currentExecutionContext)()) === null || _c === void 0 ? void 0 : _c.span_id,
+            session: this.inheritedSession,
+            session_id: this.sessionLogFields.session_id,
+            session_tag: this.sessionLogFields.session_tag,
+            session_user_id: this.sessionLogFields.session_user_id,
+            deadline_at: deadlineAt,
+        }, this.config.access_key);
+        this.trace('function.response.received', {
+            step_tag: step.tag,
+            invocation_id: invocationId,
+            function: `${reference.namespace}.${reference.operation}@${reference.version}`,
+            payload: output,
+        });
+        return output;
+    }
     /**
      * Execute a quota step
      */
@@ -1092,6 +1272,7 @@ class FeatureExecutor {
             env: this.state.env,
             tag: step.quota,
             input,
+            session: this.inheritedSession,
         });
     }
     /**
@@ -1104,6 +1285,7 @@ class FeatureExecutor {
             env: this.state.env,
             tag: step.fallback,
             input,
+            session: this.inheritedSession,
         });
     }
     /**
@@ -1130,7 +1312,8 @@ class FeatureExecutor {
             env: this.state.env,
             tag: childTag,
             input,
-        }, this._privateKey);
+            session: this.inheritedSession,
+        }, this._privateKey, this.sessionLogFields, this.productBuilder);
         const result = await childExecutor.execute();
         debugLog('[FeatureExecutor] executeChildWorkflowStep result', {
             feature_id: this.state.feature_id,
@@ -1405,12 +1588,13 @@ class FeatureExecutor {
      * Execute a rollback handler
      */
     async executeRollbackHandler(rollback, stepOutput) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         if (!rollback)
             return;
         debugLog('[FeatureExecutor] executeRollbackHandler', { feature_id: this.state.feature_id, rollback_type: rollback.type });
         // Resolve rollback input, including step output references
         const resolvedInput = await this.resolveInput(rollback.input || {}, stepOutput);
+        this.trace('rollback.input.resolved', { rollback_type: rollback.type, payload: resolvedInput });
         switch (rollback.type) {
             case types_1.FeatureStepType.ACTION:
                 await this.getProcessorService().processAction({
@@ -1420,6 +1604,7 @@ class FeatureExecutor {
                     action: rollback.event,
                     input: resolvedInput,
                     retries: (_a = rollback.retries) !== null && _a !== void 0 ? _a : 0,
+                    session: this.inheritedSession,
                 });
                 break;
             case types_1.FeatureStepType.DATABASE_ACTION: {
@@ -1428,7 +1613,7 @@ class FeatureExecutor {
                 const env = this.state.env;
                 const database = rollback.database;
                 const event = ((_b = rollback.event) !== null && _b !== void 0 ? _b : '').toLowerCase();
-                const opts = Object.assign({ product, env, database }, resolvedInput);
+                const opts = Object.assign(Object.assign({ product, env, database }, resolvedInput), { session: (_c = resolvedInput.session) !== null && _c !== void 0 ? _c : this.inheritedSession });
                 if (event === 'query')
                     await db.query(opts);
                 else if (event === 'insert')
@@ -1446,6 +1631,7 @@ class FeatureExecutor {
                         database,
                         action: rollback.event,
                         input: resolvedInput,
+                        session: this.inheritedSession,
                     });
                 break;
             }
@@ -1456,14 +1642,15 @@ class FeatureExecutor {
                     env: this.state.env,
                     event: notifEvent,
                     input: resolvedInput,
-                    retries: (_c = rollback.retries) !== null && _c !== void 0 ? _c : 0,
+                    retries: (_d = rollback.retries) !== null && _d !== void 0 ? _d : 0,
+                    session: this.inheritedSession,
                 });
                 break;
             case types_1.FeatureStepType.STORAGE: {
                 const product = this.state.product;
                 const env = this.state.env;
                 const storage = rollback.storage;
-                const opts = { product, env, storage };
+                const opts = { product, env, storage, session: this.inheritedSession };
                 const inp = resolvedInput;
                 if (inp.buffer != null && inp.fileName != null) {
                     await this.getStorageService().upload(Object.assign(Object.assign({}, opts), { fileName: String(inp.fileName), buffer: inp.buffer, mimeType: inp.mimeType != null ? String(inp.mimeType) : undefined }));
@@ -1472,7 +1659,7 @@ class FeatureExecutor {
                     await this.getStorageService().delete(Object.assign(Object.assign({}, opts), { fileName: String(inp.file_key) }));
                 }
                 else {
-                    await this.getStorageService().download(Object.assign(Object.assign({}, opts), { fileName: String((_e = (_d = inp.fileName) !== null && _d !== void 0 ? _d : inp.file_key) !== null && _e !== void 0 ? _e : '') }));
+                    await this.getStorageService().download(Object.assign(Object.assign({}, opts), { fileName: String((_f = (_e = inp.fileName) !== null && _e !== void 0 ? _e : inp.file_key) !== null && _f !== void 0 ? _f : '') }));
                 }
                 break;
             }
@@ -1481,16 +1668,16 @@ class FeatureExecutor {
                 const env = this.state.env;
                 const vectorTag = rollback.vector;
                 const inp = resolvedInput;
-                const event = ((_f = rollback.event) !== null && _f !== void 0 ? _f : '').toLowerCase();
+                const event = ((_g = rollback.event) !== null && _g !== void 0 ? _g : '').toLowerCase();
                 const svc = this.getVectorService();
                 if (event === 'query') {
-                    await svc.query(Object.assign({ product, env, tag: vectorTag }, inp));
+                    await svc.query(Object.assign(Object.assign({ product, env, tag: vectorTag }, inp), { session: (_h = inp.session) !== null && _h !== void 0 ? _h : this.inheritedSession }));
                 }
                 else if (event === 'upsert') {
-                    await svc.upsert(Object.assign({ product, env, tag: vectorTag }, inp));
+                    await svc.upsert(Object.assign(Object.assign({ product, env, tag: vectorTag }, inp), { session: (_j = inp.session) !== null && _j !== void 0 ? _j : this.inheritedSession }));
                 }
                 else if (event === 'delete' || event === 'deletevectors') {
-                    await svc.deleteVectors(Object.assign({ product, env, tag: vectorTag }, inp));
+                    await svc.deleteVectors(Object.assign(Object.assign({ product, env, tag: vectorTag }, inp), { session: (_k = inp.session) !== null && _k !== void 0 ? _k : this.inheritedSession }));
                 }
                 else {
                     const resolved = await svc.actions.resolve({
@@ -1499,9 +1686,10 @@ class FeatureExecutor {
                         vector: vectorTag,
                         action: rollback.event,
                         input: inp,
+                        session: this.inheritedSession,
                     });
-                    const op = (_g = resolved === null || resolved === void 0 ? void 0 : resolved._operation) !== null && _g !== void 0 ? _g : resolved === null || resolved === void 0 ? void 0 : resolved.operation;
-                    const opts = Object.assign({ product, env, tag: vectorTag }, resolved);
+                    const op = (_l = resolved === null || resolved === void 0 ? void 0 : resolved._operation) !== null && _l !== void 0 ? _l : resolved === null || resolved === void 0 ? void 0 : resolved.operation;
+                    const opts = Object.assign(Object.assign({ product, env, tag: vectorTag }, resolved), { session: (_m = resolved.session) !== null && _m !== void 0 ? _m : this.inheritedSession });
                     if (op === 'upsert')
                         await svc.upsert(opts);
                     else if (op === 'delete' || op === 'deleteVectors')
@@ -1519,6 +1707,7 @@ class FeatureExecutor {
                     env: this.state.env,
                     event: pubEvent,
                     input: resolvedInput,
+                    session: this.inheritedSession,
                 });
                 break;
         }
@@ -1532,7 +1721,10 @@ class FeatureExecutor {
         const resolvedValues = await Promise.all(entries.map(([, value]) => this.resolveValue(value, stepOutput)));
         const resolved = {};
         entries.forEach(([key], i) => {
-            resolved[key] = resolvedValues[i];
+            // An absent optional input is absence, not an unresolved operator string
+            // and not an explicit null. Omitting it preserves defaulting semantics.
+            if (resolvedValues[i] !== undefined)
+                resolved[key] = resolvedValues[i];
         });
         return resolved;
     }
@@ -1566,14 +1758,23 @@ class FeatureExecutor {
      * $Uppercase, $Lowercase, $Dateformat, $Replace, $Filter, $Find, $Size, $Length
      */
     async resolveStringValue(value, stepOutput) {
-        var _a;
+        var _a, _b;
         const v = value.trim();
         // --- Data references (exact match) ---
         if (v === '$Now' || v === '$Now()')
             return Date.now();
         const inputMatch = v.match(/^\$Input\{(.+)\}$/);
-        if (inputMatch)
-            return this.getNestedValue(this.state.input, inputMatch[1]);
+        if (inputMatch) {
+            const path = inputMatch[1];
+            const resolved = this.getNestedValue(this.state.input, path);
+            if (resolved !== undefined)
+                return resolved;
+            const root = path.split('.')[0];
+            const inputDefinition = (_a = this.feature.input) === null || _a === void 0 ? void 0 : _a[root];
+            if (inputDefinition === null || inputDefinition === void 0 ? void 0 : inputDefinition.required)
+                throw new UnresolvedInputReferenceError(v, true);
+            return undefined;
+        }
         const sequenceMatch = v.match(/^\$Sequence\{main\}\{([^}]+)\}\{(.+)\}$/);
         if (sequenceMatch) {
             const stepData = this.state.steps[sequenceMatch[1]];
@@ -1634,6 +1835,10 @@ class FeatureExecutor {
             const separator = concatMatch[2];
             const parts = arrContent.split(',').map((s) => this.unquote(s.trim()));
             const resolvedParts = await Promise.all(parts.map((p) => this.resolveValue(p, stepOutput)));
+            const missingIndex = resolvedParts.findIndex((part) => part === undefined);
+            if (missingIndex >= 0) {
+                throw new UnresolvedInputReferenceError(parts[missingIndex], false);
+            }
             return resolvedParts.map((x) => (x == null ? '' : String(x))).join(separator);
         }
         // $Substring(str, start, end)
@@ -1688,7 +1893,7 @@ class FeatureExecutor {
             const val = await this.resolveValue(this.unquote(pickMatch[1]), stepOutput);
             const idx = Number(pickMatch[2]);
             if (typeof val === 'string' || Array.isArray(val))
-                return (_a = val[idx]) !== null && _a !== void 0 ? _a : '';
+                return (_b = val[idx]) !== null && _b !== void 0 ? _b : '';
             return '';
         }
         // $Filter(array, "op", value)
@@ -1835,6 +2040,24 @@ class FeatureExecutor {
                     storage_tag: step.storage,
                 });
             }
+            else if (step.type === types_1.FeatureStepType.DATABASE_ACTION && step.database) {
+                workflowSteps.push({ step_tag: step.tag, type: 'database', database_tag: step.database });
+            }
+            else if ((step.type === types_1.FeatureStepType.PUBLISH || step.type === types_1.FeatureStepType.PRODUCE) && step.broker) {
+                workflowSteps.push({ step_tag: step.tag, type: 'broker', broker_tag: step.broker, topic_tag: step.event });
+            }
+            else if (step.type === types_1.FeatureStepType.GRAPH && step.graph) {
+                workflowSteps.push({ step_tag: step.tag, type: 'graph', graph_tag: step.graph });
+            }
+            else if (step.type === types_1.FeatureStepType.VECTOR && step.vector) {
+                workflowSteps.push({ step_tag: step.tag, type: 'vector', vector_tag: step.vector });
+            }
+            else if (step.type === types_1.FeatureStepType.QUOTA && step.quota) {
+                workflowSteps.push({ step_tag: step.tag, type: 'quota', component_tag: step.quota });
+            }
+            else if (step.type === types_1.FeatureStepType.FALLBACK && step.fallback) {
+                workflowSteps.push({ step_tag: step.tag, type: 'fallback', component_tag: step.fallback });
+            }
         }
         if (workflowSteps.length > 0) {
             stepLog('Bootstrap feature API call (single request)', {
@@ -1848,6 +2071,7 @@ class FeatureExecutor {
                 env_slug: env,
                 steps: workflowSteps,
             });
+            this.trace('bootstrap.response.fetched', { requested_steps: workflowSteps, payload: bootstraps });
             stepLog('Bootstrap feature API response', {
                 received_keys: Object.keys(bootstraps),
                 keys_count: Object.keys(bootstraps).length,
@@ -1858,6 +2082,9 @@ class FeatureExecutor {
                 }
             }
         }
+        // All primitive metadata above is fetched by the single feature bootstrap call.
+        return;
+        // Legacy fallback retained below for older servers; unreachable with the unified bootstrap.
         // Pre-fetch message brokers for produce steps so runBrokerPublish has broker/topic in cache
         const brokerTags = new Set();
         for (const step of steps) {
@@ -1871,6 +2098,7 @@ class FeatureExecutor {
                 var _a;
                 try {
                     const broker = await this.productBuilder.fetchMessageBroker(tag);
+                    this.trace('resource.fetched', { resource_type: 'event', resource_tag: tag, payload: broker });
                     return { tag, found: !!broker };
                 }
                 catch (e) {
@@ -1892,6 +2120,7 @@ class FeatureExecutor {
                 var _a;
                 try {
                     const db = await this.productBuilder.fetchDatabase(tag);
+                    this.trace('resource.fetched', { resource_type: 'database', resource_tag: tag, payload: db });
                     return { tag, found: !!db };
                 }
                 catch (e) {
@@ -1913,6 +2142,7 @@ class FeatureExecutor {
                 var _a;
                 try {
                     const graph = await this.productBuilder.fetchGraph(tag);
+                    this.trace('resource.fetched', { resource_type: 'graph', resource_tag: tag, payload: graph });
                     return { tag, found: !!graph };
                 }
                 catch (e) {
@@ -1933,6 +2163,7 @@ class FeatureExecutor {
                 var _a;
                 try {
                     const vec = await this.productBuilder.fetchVector(tag);
+                    this.trace('resource.fetched', { resource_type: 'vector', resource_tag: tag, payload: vec });
                     return { tag, found: !!vec };
                 }
                 catch (e) {
@@ -1954,6 +2185,7 @@ class FeatureExecutor {
                 var _a;
                 try {
                     const quota = await this.productBuilder.fetchQuota(tag);
+                    this.trace('resource.fetched', { resource_type: 'quota', resource_tag: tag, payload: quota });
                     return { tag, found: !!quota };
                 }
                 catch (e) {