salmon-loop 0.2.3

package/dist/core/grizzco/dsl/strategies.js

@@ -0,0 +1,69 @@
+import { text } from '../../../locales/index.js';
+import { FileStatus, OpType } from '../domain/grizzco-types.js';
+const isStaged = (status) => status === FileStatus.STAGED_MODIFIED ||
+    status === FileStatus.STAGED_ADDED ||
+    status === FileStatus.STAGED_DELETED;
+/**
+ * StandardStrategy keeps macro orchestration outside the DSL and only expresses
+ * per-file decision rules in a synchronous, auditable chain.
+ */
+export const SafetyChecks = (engine) => {
+    return engine
+        .phase('Security')
+        .require((c) => !c.file.isSymlink, 'Symlinks are not supported')
+        .require((c) => c.snapshot.exists, 'Snapshot required for safe rollback')
+        .require((c) => !c.file.isIgnored || c.options.force, 'Refusing to modify ignored file without --force')
+        .phase('Lock Check')
+        .requireData('remote_lock')
+        .require((c) => !c.data?.remote_lock?.isLocked, text.grizzco.remoteLocked)
+        .requireData('git_config')
+        .require((c) => !!(c.data?.git_config?.user?.name && c.data?.git_config?.user?.email), text.grizzco.gitUserConfigMissing);
+};
+export const IntentRouting = (engine) => {
+    return engine
+        .phase('Routing')
+        .when((c) => c.operation.type === OpType.PATCH, (p) => p.setWorker('git-apply'))
+        .when((c) => c.operation.type === OpType.OVERWRITE, (p) => p.setWorker('direct-write'))
+        .when((c) => c.operation.type === OpType.DELETE, (p) => p.addAction('FS_DELETE'));
+};
+export const IndexProtection = (engine) => {
+    return engine
+        .phase('Index Protection')
+        .when((c) => isStaged(c.file.status) && !c.options.force, (p) => p.reject(text.grizzco.stagedFileProtected))
+        .when((c) => isStaged(c.file.status) && c.options.force, (p) => p.setWorker('union-merge-safe'));
+};
+export const MMHandling = (engine) => {
+    return engine
+        .phase('MM Handling')
+        .when((c) => c.file.status === FileStatus.MM && c.file.isBinary, (p) => p.reject(text.grizzco.binaryMmCannotBeMerged))
+        .when((c) => c.operation.type !== OpType.PATCH &&
+        c.file.status === FileStatus.MM &&
+        !c.file.isBinary &&
+        c.options.force, (p) => p.setWorker('union-merge-safe'))
+        .when((c) => c.operation.type !== OpType.PATCH &&
+        c.file.status === FileStatus.MM &&
+        !c.file.isBinary &&
+        !c.options.force, (p) => p.setWorker('3way-mm-advanced'));
+};
+export const StatusValidation = (engine) => {
+    return engine
+        .phase('Status Validation')
+        .when((c) => c.operation.type === OpType.OVERWRITE &&
+        c.file.status === FileStatus.UNSTAGED_MODIFIED &&
+        !c.file.isBinary, (p) => p.setWorker('3way-standard'))
+        .when((c) => c.file.status === FileStatus.CONFLICT, (p) => p.reject(text.grizzco.fileHasExistingConflict));
+};
+/**
+ * StandardStrategy uses pipeline pattern for readable, auditable decision chain.
+ * Each step is applied in sequence, building up the execution plan.
+ */
+export const StandardStrategy = (engine) => {
+    return engine
+        .apply(SafetyChecks)
+        .apply(IntentRouting)
+        .apply(IndexProtection)
+        .apply(MMHandling)
+        .apply(StatusValidation)
+        .setWorker('direct-write');
+};
+//# sourceMappingURL=strategies.js.map

package/dist/core/grizzco/dsl/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/grizzco/engine/observability/event-adapter.js

@@ -0,0 +1,41 @@
+import { sanitizeUiLogMessage } from '../../../observability/ui-log-sanitize.js';
+function sanitizeLoopEvent(event) {
+    if (event.type === 'log') {
+        return {
+            ...event,
+            // Default attribution when not provided by the caller.
+            source: event.source ?? 'core',
+            message: sanitizeUiLogMessage(event.message, event.level),
+        };
+    }
+    return event;
+}
+export function createFlowEventAdapter(params) {
+    let currentPhase = 'UNKNOWN';
+    const emitToClient = (event) => params.onEvent?.(event);
+    const emitWithTelemetry = (event, telemetryPhase) => {
+        emitToClient(event);
+        if (event.type === 'log' && telemetryPhase) {
+            params.telemetry.recordLog(telemetryPhase, event.message, event.level !== 'error');
+        }
+    };
+    const emitSanitized = (event) => {
+        const sanitizedEvent = sanitizeLoopEvent(event);
+        emitWithTelemetry(sanitizedEvent, 'PREFLIGHT');
+    };
+    const emitFlow = (event) => {
+        const sanitizedEvent = sanitizeLoopEvent(event);
+        if (sanitizedEvent.type === 'phase.start') {
+            currentPhase = sanitizedEvent.phase;
+        }
+        else if (sanitizedEvent.type === 'phase.end') {
+            currentPhase = 'UNKNOWN';
+        }
+        emitWithTelemetry(sanitizedEvent, sanitizedEvent.type === 'log' ? currentPhase : undefined);
+    };
+    return {
+        emitSanitized,
+        emitFlow,
+    };
+}
+//# sourceMappingURL=event-adapter.js.map

package/dist/core/grizzco/engine/observability/index.js

@@ -0,0 +1,3 @@
+export { createFlowEventAdapter } from './event-adapter.js';
+export { LoopTelemetry } from './loop-telemetry.js';
+//# sourceMappingURL=index.js.map

package/dist/core/grizzco/engine/observability/loop-telemetry.js

@@ -0,0 +1,51 @@
+import { LIMITS } from '../../../config/limits.js';
+export class LoopTelemetry {
+    now;
+    logs = [];
+    history = [];
+    constructor(now) {
+        this.now = now;
+    }
+    recordLog(step, output, success = true) {
+        let outputStr;
+        if (typeof output === 'string') {
+            outputStr = output;
+        }
+        else {
+            outputStr = (() => {
+                try {
+                    return JSON.stringify(output);
+                }
+                catch {
+                    try {
+                        return String(output);
+                    }
+                    catch {
+                        return '[Unserializable]';
+                    }
+                }
+            })();
+        }
+        if (outputStr.length > LIMITS.maxLogLength) {
+            outputStr = outputStr.substring(0, LIMITS.maxLogLength) + '\n...[Truncated due to length]...';
+        }
+        const log = {
+            step,
+            success,
+            output: outputStr,
+            timestamp: this.now(),
+        };
+        this.logs.push(log);
+        return log;
+    }
+    addHistory(entry) {
+        this.history.push(entry);
+    }
+    getLogs() {
+        return [...this.logs];
+    }
+    getHistory() {
+        return [...this.history];
+    }
+}
+//# sourceMappingURL=loop-telemetry.js.map

package/dist/core/grizzco/engine/outcome/index.js

@@ -0,0 +1,2 @@
+export { buildLoopFailureResult, buildLoopResultFromTransaction } from './loop-result-mapper.js';
+//# sourceMappingURL=index.js.map

package/dist/core/grizzco/engine/outcome/loop-result-mapper.js

@@ -0,0 +1,167 @@
+import { text } from '../../../../locales/index.js';
+import { getBudgetRunSummary } from '../../../context/budget/integration.js';
+import { getAuthorizationDecisionsFromAuditTrail } from '../../../observability/authorization-decisions.js';
+import { buildFailureEnvelope } from '../../../observability/error-envelope.js';
+import { getTokenUsageFromAuditTrail } from '../../../observability/token-usage.js';
+import { ErrorType, Phase } from '../../../types/runtime.js';
+export function buildLoopResultFromTransaction({ executionReport, flowMode, options, telemetry, auditPath, }) {
+    const ctx = executionReport.lastContext ??
+        executionReport.flowReport.data;
+    const contextHash = (() => {
+        const hashFromBudget = ctx?.contextResult?.meta?.contextHash;
+        if (typeof hashFromBudget === 'string')
+            return hashFromBudget;
+        const hashFromContext = ctx && typeof ctx === 'object' && 'context' in ctx
+            ? ctx.context?.contextHash
+            : undefined;
+        return typeof hashFromContext === 'string' ? hashFromContext : undefined;
+    })();
+    const verifyArtifact = ctx && typeof ctx === 'object' && 'verifyArtifact' in ctx
+        ? ctx.verifyArtifact
+        : executionReport.lastVerifyArtifact;
+    const assistantMessage = flowMode === 'answer'
+        ? ctx?.report?.summary?.trim?.()
+            ? String(ctx.report.summary).trim()
+            : ''
+        : undefined;
+    const finalPatch = ctx && typeof ctx === 'object' && 'diff' in ctx ? ctx.diff : undefined;
+    const changedFiles = ctx && typeof ctx === 'object' && 'changedFiles' in ctx ? ctx.changedFiles : undefined;
+    const authorizationDecisions = (() => {
+        if (!options.eventPayload?.includeAuthorizationDecisions)
+            return undefined;
+        const decisions = getAuthorizationDecisionsFromAuditTrail();
+        return decisions.length > 0 ? decisions : undefined;
+    })();
+    if (executionReport.success) {
+        const attempts = executionReport.attempts;
+        const usage = getTokenUsageFromAuditTrail() ?? undefined;
+        const budgetSummary = getBudgetRunSummary() ?? undefined;
+        if (options.dryRun ||
+            flowMode === 'review' ||
+            flowMode === 'research' ||
+            flowMode === 'answer') {
+            return {
+                success: true,
+                reason: text.loop.operationCompleted,
+                reasonCode: options.dryRun ? 'DRY_RUN' : 'SUCCESS',
+                attempts,
+                contextHash,
+                logs: telemetry.getLogs(),
+                usage,
+                authorizationDecisions,
+                history: telemetry.getHistory(),
+                finalPatch,
+                changedFiles,
+                assistantMessage,
+                auditPath,
+                verifyArtifact,
+                authorizationSummary: executionReport.authorizationSummary || undefined,
+                strategyName: executionReport.flowReport.strategyName ?? flowMode,
+                fsMode: executionReport.flowReport.fsMode ?? flowMode,
+                budgetSummary,
+            };
+        }
+        return {
+            success: true,
+            reason: text.loop.operationCompleted,
+            reasonCode: 'SUCCESS',
+            attempts,
+            contextHash,
+            logs: telemetry.getLogs(),
+            usage,
+            authorizationDecisions,
+            history: telemetry.getHistory(),
+            finalPatch,
+            changedFiles,
+            assistantMessage,
+            auditPath,
+            verifyArtifact,
+            authorizationSummary: executionReport.authorizationSummary || undefined,
+            strategyName: executionReport.flowReport.strategyName ?? flowMode,
+            fsMode: executionReport.flowReport.fsMode ?? flowMode,
+            budgetSummary,
+        };
+    }
+    const retryFailureReason = executionReport.history.at(-1)?.error ?? text.loop.loopExecutionFailed;
+    const failureReason = executionReport.terminalReason ||
+        (executionReport.retryExhausted ? text.loop.exceededMaxRetriesSimple : retryFailureReason);
+    const safeHint = executionReport.terminalSafeHint ||
+        (executionReport.retryExhausted
+            ? text.loop.exceededMaxRetriesSimple
+            : executionReport.terminalReason || failureReason);
+    const remediationSteps = executionReport.terminalRemediationSteps ?? [];
+    const reasonCode = executionReport.terminalReasonCode ||
+        (executionReport.retryExhausted ? 'MAX_RETRIES' : 'LOOP_FAILED');
+    const failurePhase = executionReport.terminalFailurePhase ||
+        (executionReport.retryExhausted ? Phase.VERIFY : undefined);
+    const usage = getTokenUsageFromAuditTrail() ?? undefined;
+    const budgetSummary = getBudgetRunSummary() ?? undefined;
+    const errorEnvelope = buildFailureEnvelope({
+        code: executionReport.lastErrorCode,
+        phase: failurePhase,
+        safeHint,
+        remediationSteps,
+        fallbackMessage: failureReason,
+    });
+    return {
+        success: false,
+        reason: safeHint,
+        reasonCode,
+        diagnosticCode: executionReport.terminalDiagnosticCode ?? reasonCode,
+        safeHint,
+        remediationSteps,
+        errorEnvelope,
+        attempts: executionReport.attempts,
+        contextHash,
+        logs: telemetry.getLogs(),
+        usage,
+        authorizationDecisions,
+        history: telemetry.getHistory(),
+        failurePhase,
+        errorType: ErrorType.UNKNOWN,
+        errorCode: executionReport.lastErrorCode,
+        auditPath,
+        verifyArtifact,
+        authorizationSummary: executionReport.authorizationSummary || undefined,
+        strategyName: executionReport.flowReport.strategyName ?? flowMode,
+        fsMode: executionReport.flowReport.fsMode ?? flowMode,
+        budgetSummary,
+        inputRequired: executionReport.terminalReasonCode === 'AWAITING_INPUT'
+            ? executionReport.terminalInputRequired
+            : undefined,
+    };
+}
+export function buildLoopFailureResult({ message, flowMode, telemetry, auditPath, reasonCode, failurePhase, errorCode, }) {
+    const usage = getTokenUsageFromAuditTrail() ?? undefined;
+    const budgetSummary = getBudgetRunSummary() ?? undefined;
+    const authorizationDecisions = (() => {
+        const decisions = getAuthorizationDecisionsFromAuditTrail();
+        return decisions.length > 0 ? decisions : undefined;
+    })();
+    const errorEnvelope = buildFailureEnvelope({
+        phase: failurePhase,
+        fallbackMessage: message,
+    });
+    return {
+        success: false,
+        reason: message,
+        reasonCode,
+        diagnosticCode: reasonCode,
+        safeHint: message,
+        remediationSteps: [],
+        errorEnvelope,
+        attempts: 0,
+        logs: telemetry.getLogs(),
+        usage,
+        authorizationDecisions,
+        history: telemetry.getHistory(),
+        failurePhase,
+        errorType: ErrorType.UNKNOWN,
+        errorCode,
+        auditPath,
+        strategyName: flowMode,
+        fsMode: flowMode,
+        budgetSummary,
+    };
+}
+//# sourceMappingURL=loop-result-mapper.js.map

package/dist/core/grizzco/engine/pipeline/pipeline.js

@@ -0,0 +1,335 @@
+import { recordAuditEvent, setAuditContext } from '../../../observability/audit-trail.js';
+import { getLogger } from '../../../observability/logger.js';
+import { appendPlanNote } from '../../../plan/index.js';
+import { EXECUTION_PHASES, } from '../../../types/runtime.js';
+/**
+ * Typed Async Pipeline Container
+ */
+export class Pipeline {
+    promise;
+    startTime;
+    lastStepName;
+    traces;
+    ctxRef;
+    constructor(promise, startTime = Date.now(), lastStepName = 'INIT', traces = [], ctxRef = {}) {
+        this.promise = promise;
+        this.startTime = startTime;
+        this.lastStepName = lastStepName;
+        this.traces = traces;
+        this.ctxRef = ctxRef;
+    }
+    /**
+     * Initialize a new pipeline
+     */
+    static of(ctx) {
+        return new Pipeline(Promise.resolve(ctx), Date.now(), 'INIT', [], { current: ctx });
+    }
+    /**
+     * Add a step to the pipeline
+     */
+    step(name, action) {
+        const nextPromise = this.promise.then(async (ctx) => {
+            const start = Date.now();
+            let phaseStarted = false;
+            let errorStr;
+            let errorMeta;
+            let result;
+            const emit = ctx.emit;
+            const isPhase = (value) => EXECUTION_PHASES.includes(value);
+            const planRuntime = ctx?.planRuntime;
+            const persistenceRoot = ctx?.workspace?.baseRepoPath || ctx?.workspace?.workPath;
+            const attempt = ctx?.attempt ?? 1;
+            const tryAppendPlanNote = async (note) => {
+                if (!planRuntime || !persistenceRoot)
+                    return;
+                try {
+                    await appendPlanNote({
+                        persistenceRoot,
+                        sessionId: planRuntime.sessionId,
+                        note,
+                    });
+                    recordAuditEvent('plan.runtime.note.append', { note, ok: true }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
+                    return true;
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    recordAuditEvent('plan.runtime.note.append.failed', { note, error: msg }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
+                    getLogger().debug(`[PlanRuntime] Failed to append note: ${msg}`);
+                    return false;
+                }
+            };
+            try {
+                this.ctxRef.current = ctx;
+                const signal = ctx?.options?.signal;
+                const strategy = ctx?.workspace?.strategy ?? ctx?.options?.strategy;
+                if (signal?.aborted && strategy === 'worktree') {
+                    throw new Error('Operation cancelled by user');
+                }
+                setAuditContext({ phase: name });
+                if (emit && isPhase(name)) {
+                    emit({ type: 'phase.start', phase: name, timestamp: new Date() });
+                    phaseStarted = true;
+                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.start ${name}`);
+                    if (planRuntime && ok !== undefined) {
+                        emit({
+                            type: 'plan.runtime.journal',
+                            sessionId: planRuntime.sessionId,
+                            phase: name,
+                            kind: 'start',
+                            attempt,
+                            ok,
+                            timestamp: new Date(),
+                        });
+                    }
+                }
+                result = await action(ctx);
+                this.ctxRef.current = result;
+                // APPLY_BACK failure is represented as a structured result (not an exception) to preserve context.
+                // The pipeline must still treat it as a phase failure for progress reporting and plan journaling.
+                if (name === 'APPLY_BACK' &&
+                    result &&
+                    typeof result === 'object' &&
+                    result.applyBackResult &&
+                    typeof result.applyBackResult === 'object') {
+                    const applyBackResult = result.applyBackResult;
+                    if (applyBackResult.success === false && !applyBackResult.skipped) {
+                        errorStr = applyBackResult.safeMessage || applyBackResult.error || 'Apply-back failed';
+                        errorMeta = {
+                            name: 'ApplyBackFailure',
+                            code: applyBackResult.errorCode || 'APPLY_BACK_FAILED',
+                        };
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                errorStr = error instanceof Error ? error.message : String(error);
+                errorMeta =
+                    typeof error === 'object' && error !== null
+                        ? {
+                            name: error.name,
+                            code: error.code,
+                            llmCode: error.llmCode,
+                        }
+                        : undefined;
+                throw error;
+            }
+            finally {
+                if (emit && isPhase(name) && phaseStarted) {
+                    emit({
+                        type: 'phase.end',
+                        phase: name,
+                        success: !errorStr,
+                        timestamp: new Date(),
+                    });
+                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.end ${name} (success=${String(!errorStr)})`);
+                    if (planRuntime && ok !== undefined) {
+                        emit({
+                            type: 'plan.runtime.journal',
+                            sessionId: planRuntime.sessionId,
+                            phase: name,
+                            kind: 'end',
+                            attempt,
+                            ok,
+                            timestamp: new Date(),
+                        });
+                    }
+                }
+                setAuditContext({ phase: undefined });
+                const end = Date.now();
+                this.traces.push({
+                    name,
+                    start,
+                    end,
+                    duration: end - start,
+                    error: errorStr,
+                    metadata: errorMeta,
+                });
+            }
+        });
+        return new Pipeline(nextPromise, this.startTime, name, this.traces, this.ctxRef);
+    }
+    /**
+     * Add a step with error recovery
+     */
+    stepWithRecovery(name, action, recovery) {
+        const nextPromise = this.promise.then(async (ctx) => {
+            const start = Date.now();
+            let phaseStarted = false;
+            let abortedBeforeAction = false;
+            let errorStr;
+            let errorMeta;
+            let result;
+            const emit = ctx.emit;
+            const isPhase = (value) => EXECUTION_PHASES.includes(value);
+            const planRuntime = ctx?.planRuntime;
+            const persistenceRoot = ctx?.workspace?.baseRepoPath || ctx?.workspace?.workPath;
+            const attempt = ctx?.attempt ?? 1;
+            const tryAppendPlanNote = async (note) => {
+                if (!planRuntime || !persistenceRoot)
+                    return;
+                try {
+                    await appendPlanNote({
+                        persistenceRoot,
+                        sessionId: planRuntime.sessionId,
+                        note,
+                    });
+                    recordAuditEvent('plan.runtime.note.append', { note, ok: true }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
+                    return true;
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    recordAuditEvent('plan.runtime.note.append.failed', { note, error: msg }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
+                    getLogger().debug(`[PlanRuntime] Failed to append note: ${msg}`);
+                    return false;
+                }
+            };
+            try {
+                this.ctxRef.current = ctx;
+                const signal = ctx?.options?.signal;
+                const strategy = ctx?.workspace?.strategy ?? ctx?.options?.strategy;
+                if (signal?.aborted && strategy === 'worktree') {
+                    abortedBeforeAction = true;
+                    throw new Error('Operation cancelled by user');
+                }
+                setAuditContext({ phase: name });
+                if (emit && isPhase(name)) {
+                    emit({ type: 'phase.start', phase: name, timestamp: new Date() });
+                    phaseStarted = true;
+                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.start ${name}`);
+                    if (planRuntime && ok !== undefined) {
+                        emit({
+                            type: 'plan.runtime.journal',
+                            sessionId: planRuntime.sessionId,
+                            phase: name,
+                            kind: 'start',
+                            attempt,
+                            ok,
+                            timestamp: new Date(),
+                        });
+                    }
+                }
+                result = await action(ctx);
+                this.ctxRef.current = result;
+                return result;
+            }
+            catch (error) {
+                errorStr = error instanceof Error ? error.message : String(error);
+                errorMeta =
+                    typeof error === 'object' && error !== null
+                        ? {
+                            name: error.name,
+                            code: error.code,
+                            llmCode: error.llmCode,
+                        }
+                        : undefined;
+                if (abortedBeforeAction) {
+                    throw error;
+                }
+                // Trigger Recovery
+                const recStart = Date.now();
+                try {
+                    await recovery(ctx);
+                    this.traces.push({
+                        name: `${name}:recovery`,
+                        start: recStart,
+                        end: Date.now(),
+                        duration: Date.now() - recStart,
+                        metadata: { success: true },
+                    });
+                }
+                catch (recError) {
+                    const recEnd = Date.now();
+                    const errorDetail = recError instanceof Error ? recError.message : String(recError);
+                    // 1. Record recovery failure to internal traces
+                    this.traces.push({
+                        name: `${name}:recovery`,
+                        start: recStart,
+                        end: recEnd,
+                        duration: recEnd - recStart,
+                        error: errorDetail,
+                        metadata: { success: false, phase: 'RECOVERY_FAILURE' },
+                    });
+                    // 2. Force audit log to disk (persistent storage)
+                    getLogger().audit('PIPELINE_RECOVERY_FAILED', {
+                        step: name,
+                        originalError: errorStr,
+                        recoveryError: errorDetail,
+                    }, { source: 'system', severity: 'high', scope: 'session' });
+                }
+                throw error; // Propagate original error
+            }
+            finally {
+                if (emit && isPhase(name) && phaseStarted) {
+                    emit({
+                        type: 'phase.end',
+                        phase: name,
+                        success: !errorStr,
+                        timestamp: new Date(),
+                    });
+                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.end ${name} (success=${String(!errorStr)})`);
+                    if (planRuntime && ok !== undefined) {
+                        emit({
+                            type: 'plan.runtime.journal',
+                            sessionId: planRuntime.sessionId,
+                            phase: name,
+                            kind: 'end',
+                            attempt,
+                            ok,
+                            timestamp: new Date(),
+                        });
+                    }
+                }
+                setAuditContext({ phase: undefined });
+                const end = Date.now();
+                this.traces.push({
+                    name,
+                    start,
+                    end,
+                    duration: end - start,
+                    error: errorStr,
+                    metadata: errorMeta,
+                });
+            }
+        });
+        return new Pipeline(nextPromise, this.startTime, name, this.traces, this.ctxRef);
+    }
+    /**
+     * Execute the pipeline and get the final result
+     */
+    async execute() {
+        try {
+            const data = await this.promise;
+            return {
+                success: true,
+                duration: Date.now() - this.startTime,
+                lastStep: this.lastStepName,
+                data,
+                traces: this.traces,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+                lastStep: this.lastStepName,
+                duration: Date.now() - this.startTime,
+                data: this.ctxRef.current,
+                traces: this.traces,
+            };
+        }
+    }
+    /**
+     * Get the promise for direct access (advanced use)
+     */
+    async getPromise() {
+        return this.promise;
+    }
+    /**
+     * Cast the pipeline to a new context type (advanced usage).
+     */
+    cast() {
+        return this;
+    }
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/core/grizzco/engine/pipeline/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map