specrails-core 6.0.0 → 6.1.0

package/dist/agent-runtime/efficiency.js

@@ -1,12 +1,12 @@
+import { BUILTIN_ROLES } from './executor-types.js';
 import { CACHE_TOKEN_KEYS } from './efficiency-types.js';
 export * from './efficiency-types.js';
 function sum(values) {
     return values.some(value => value == null || !Number.isFinite(value) || value < 0) ? null : values.reduce((total, value) => total + (value ?? 0), 0);
 }
-const AGENT_PHASES = new Set(['architect', 'developer', 'reviewer']);
-function totals(attempts) {
+function totals(attempts, agentRoles) {
     const invocations = attempts.flatMap(attempt => attempt.invocations ?? []);
-    const measured = attempts.filter(attempt => !AGENT_PHASES.has(attempt.stepId) || attempt.invocations !== undefined);
+    const measured = attempts.filter(attempt => !agentRoles.has(attempt.stepId) || attempt.invocations !== undefined);
     const complete = measured.length === attempts.length && attempts.every(attempt => !attempt.pendingInvocations?.length);
     const duration = (attempt) => attempt.completedAt ? Math.max(0, Date.parse(attempt.completedAt) - Date.parse(attempt.startedAt)) : null;
     const cache = Object.fromEntries(CACHE_TOKEN_KEYS.map(key => [key, complete ? sum(invocations.map(call => call.usage[key])) : null]));
@@ -23,12 +23,13 @@ function totals(attempts) {
     };
 }
 /** Read-only projection: failed/superseded attempts remain spend, polling never changes it. */
-export function runtimeEfficiency(state) {
+export function runtimeEfficiency(state, roleIds = BUILTIN_ROLES) {
+    const agentRoles = new Set(roleIds);
     const phases = [...new Set(state.history.map(attempt => attempt.stepId))].map(stepId => {
         const attempts = state.history.filter(attempt => attempt.stepId === stepId);
         const calls = attempts.flatMap(attempt => attempt.invocations ?? []);
-        return { stepId, ...totals(attempts), providers: [...new Set(calls.map(call => call.provider))], models: [...new Set(calls.map(call => call.model).filter((model) => model !== undefined))] };
+        return { stepId, ...totals(attempts, agentRoles), providers: [...new Set(calls.map(call => call.provider))], models: [...new Set(calls.map(call => call.model).filter((model) => model !== undefined))] };
     });
     const pending = state.history.some(attempt => attempt.pendingInvocations?.length);
-    return { schemaVersion: 1, total: { ...totals(state.history), durationMs: state.usage.durationMs, inputTokens: pending ? null : state.usage.inputTokens, outputTokens: pending ? null : state.usage.outputTokens, costUsd: pending ? null : state.usage.costUsd }, phases };
+    return { schemaVersion: 1, total: { ...totals(state.history, agentRoles), durationMs: state.usage.durationMs, inputTokens: pending ? null : state.usage.inputTokens, outputTokens: pending ? null : state.usage.outputTokens, costUsd: pending ? null : state.usage.costUsd }, phases };
 }

package/dist/agent-runtime/engine/__fixtures__/implementation-component.json

@@ -0,0 +1,90 @@
+{
+    "schemaVersion": 1,
+    "id": "implementation-component",
+    "title": "Implementation inside a component",
+    "journal": "implementation",
+    "change": "new",
+    "entry": "work",
+    "maxTransitions": 100,
+    "roles": [
+        "architect",
+        "developer",
+        "reviewer"
+    ],
+    "nodes": {
+        "work": {
+            "kind": "component",
+            "params": {
+                "ref": "work"
+            },
+            "ends": {
+                "next": "verify",
+                "failed": "failed"
+            }
+        },
+        "done": {
+            "kind": "end",
+            "params": {
+                "outcome": "success",
+                "requiresVerified": true
+            },
+            "ends": {}
+        },
+        "failed": {
+            "kind": "end",
+            "params": {
+                "outcome": "failure"
+            },
+            "ends": {}
+        },
+        "verify": {
+            "kind": "verify",
+            "params": {
+                "commands": "configured"
+            },
+            "ends": {
+                "pass": "done",
+                "fail": "failed",
+                "failed": "failed"
+            }
+        }
+    },
+    "components": {
+        "work": {
+            "entry": "implement",
+            "nodes": {
+                "implement": {
+                    "kind": "implementation",
+                    "params": {
+                        "approvalBeforeArchive": false
+                    },
+                    "ends": {
+                        "next": "done",
+                        "rejected": "failed",
+                        "failed": "failed"
+                    }
+                },
+                "done": {
+                    "kind": "end",
+                    "params": {
+                        "outcome": "success",
+                        "exit": "next"
+                    },
+                    "ends": {}
+                },
+                "failed": {
+                    "kind": "end",
+                    "params": {
+                        "outcome": "failure",
+                        "exit": "failed"
+                    },
+                    "ends": {}
+                }
+            }
+        }
+    },
+    "delivery": {
+        "requiresVerified": true
+    },
+    "version": "3ebd003720588211080fe8515e19def7fd7516ff165765162d360839ca015e53"
+}

package/dist/agent-runtime/engine/__fixtures__/implementation-fixture.d.ts

@@ -0,0 +1,11 @@
+import type { AgentRequest, RuntimeConfig } from '../../executor-types.js';
+import { ExecutorRegistry } from '../../executors.js';
+export declare function implementationFixture(approval?: boolean): {
+    root: string;
+    repository: string;
+    context: import("../../../pipeline/pipeline-state.js").PipelineContext;
+    config: RuntimeConfig;
+    registry: ExecutorRegistry;
+    requests: AgentRequest[];
+    dispose: () => void;
+};

package/dist/agent-runtime/engine/__fixtures__/implementation-fixture.js

@@ -0,0 +1,60 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { validatePipelineContext } from '../../../pipeline/pipeline-state.js';
+import { ExecutorRegistry } from '../../executors.js';
+import { OpenSpecTools } from '../../openspec.js';
+const change = 'native-implementation';
+const usage = { inputTokens: 20, outputTokens: 10, costUsd: 0.1 };
+export function implementationFixture(approval = false) {
+    const root = mkdtempSync(path.join(tmpdir(), 'native implementation '));
+    const repository = path.join(root, 'repository'), backlog = path.join(root, 'backlog');
+    mkdirSync(repository);
+    mkdirSync(backlog);
+    execFileSync('git', ['init', '-q', repository]);
+    writeFileSync(path.join(repository, 'code.cjs'), 'module.exports = 1\n');
+    execFileSync('git', ['-C', repository, 'add', '.']);
+    execFileSync('git', ['-C', repository, '-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '-qm', 'baseline']);
+    const context = validatePipelineContext({ schemaVersion: 1, runId: 'implementation', backlogRoot: backlog, artifactRoot: repository, artifactRepositoryId: 'repo', repositories: [{ id: 'repo', name: 'Repo', path: repository }],
+        ownership: { git: 'host', backlog: 'host', worktrees: 'host' }, specs: [{ id: 7, title: 'Feature', description: 'Return two', repositoryIds: ['repo'], acceptanceCriteria: ['Function returns 2'] }] });
+    const role = { provider: 'fixture' };
+    const config = { schemaVersion: 1, enabled: true, providers: [], agents: { architect: role, developer: role, reviewer: role }, limits: { maxAttempts: 2 }, approvalBeforeArchive: approval,
+        verification: [{ repositoryId: 'repo', command: process.execPath, args: ['-e', 'if(require("./code.cjs")!==2)process.exit(9);console.log("real check passed")'] }] };
+    const requests = [];
+    const registry = new ExecutorRegistry().register('fixture', { capabilities: () => ({ transport: 'fixture', continuation: 'supported', effortSupport: 'unsupported', supportedEfforts: [], observedModel: false, observedEffort: false }),
+        async execute(request) {
+            requests.push(request);
+            const tools = new OpenSpecTools(request.openspec);
+            const capability = request.openspec.change === change ? 'feature' : 'feature-' + request.openspec.change.slice(-6);
+            await tools.execute({ action: 'load_skill' });
+            if (request.role !== 'architect')
+                await tools.execute({ action: 'instructions', artifact: 'apply' });
+            if (request.role === 'architect') {
+                await tools.execute({ action: 'new' });
+                const files = [
+                    ['proposal', 'proposal.md', '# Why\nReturn two.\n# What Changes\nUpdate the function.\n# Capabilities\n## New Capabilities\n- feature: Return the required value.\n# Impact\nOne function.'],
+                    ['design', 'design.md', '# Design\nUpdate code.cjs and verify the return value.'],
+                    ['specs', `specs/${capability}/spec.md`, '## ADDED Requirements\n### Requirement: Return the required value\nThe function SHALL return 2.\n#### Scenario: Calling the function\n- **WHEN** code.cjs is loaded\n- **THEN** it returns 2\n'],
+                    ['tasks', 'tasks.md', '- [ ] 1. Implement the return value and verify behavior\n'],
+                ];
+                for (const [artifact, file, content] of files) {
+                    await tools.execute({ action: 'instructions', artifact });
+                    await tools.execute({ action: 'write_artifact', path: file, content });
+                }
+                return { text: '{"confidence":"high"}', usage };
+            }
+            if (request.role === 'developer') {
+                writeFileSync(path.join(request.openspec.root, 'code.cjs'), 'module.exports = 2\n');
+                const tasks = path.join(request.openspec.root, 'openspec/changes', request.openspec.change, 'tasks.md');
+                writeFileSync(tasks, readFileSync(tasks, 'utf8').replaceAll('- [ ]', '- [x]'));
+                return { text: 'Implemented and checked the required behavior.', usage };
+            }
+            const obligations = JSON.parse(request.prompt.split('Current frozen acceptance obligations (all remain required):\n')[1].split('\n')[0]);
+            return { text: JSON.stringify({ approved: true, summary: 'Inspected actual code and verification evidence', issues: [], score: 90,
+                    aspects: { type_correctness: 90, pattern_adherence: 90, test_coverage: 90, security: 90, architectural_alignment: 90 },
+                    acceptance: { criteria: obligations.map(item => ({ specId: item.specId, criterionIndex: item.criterionIndex, status: 'met', evidence: ['code.cjs returns 2 and host verification passed'] })), checks: [], findings: [] } }), usage };
+        },
+    });
+    return { root, repository, context, config, registry, requests, dispose: () => rmSync(root, { recursive: true, force: true }) };
+}

package/dist/agent-runtime/engine/__fixtures__/implementation.json

@@ -0,0 +1,43 @@
+{
+    "schemaVersion": 1,
+    "id": "implementation",
+    "title": "Verified implementation",
+    "journal": "implementation",
+    "change": "new",
+    "entry": "implement",
+    "maxTransitions": 100,
+    "roles": [
+        "architect",
+        "developer",
+        "reviewer"
+    ],
+    "nodes": {
+        "implement": {
+            "kind": "implementation",
+            "params": {
+                "approvalBeforeArchive": false
+            },
+            "ends": {
+                "next": "done",
+                "rejected": "failed",
+                "failed": "failed"
+            }
+        },
+        "done": {
+            "kind": "end",
+            "params": {
+                "outcome": "success",
+                "requiresVerified": true
+            },
+            "ends": {}
+        },
+        "failed": {
+            "kind": "end",
+            "params": {
+                "outcome": "failure"
+            },
+            "ends": {}
+        }
+    },
+    "version": "e1aea44e144c42fe39ab782e9ce2df6e2253163ee3a1e503a966c2d99aaf45c4"
+}

package/dist/agent-runtime/engine/budget.d.ts

@@ -0,0 +1,9 @@
+import { type EngineUsage, type WorkflowBudget } from './contracts.js';
+export declare function budgetError(usage: EngineUsage, budget: WorkflowBudget, elapsedMs: number, admission?: boolean): string | undefined;
+/** Missing billing stays unknown; only reported lower bounds reduce headroom. */
+export declare function remainingBudget(usage: EngineUsage, budget: WorkflowBudget, elapsedMs: number, reserved?: {
+    costUsd: number;
+    tokens: number;
+}): WorkflowBudget;
+/** Graph and host limits intersect: an imported definition cannot raise host caps. */
+export declare function intersectBudgets(...values: Array<WorkflowBudget | undefined>): WorkflowBudget;

package/dist/agent-runtime/engine/budget.js

@@ -0,0 +1,33 @@
+import { EngineError } from './contracts.js';
+export function budgetError(usage, budget, elapsedMs, admission = true) {
+    const reached = (used, limit) => admission ? used >= limit : used > limit;
+    if (budget.maxCostUsd !== undefined && reached(usage.knownCostUsd, budget.maxCostUsd))
+        return 'cost_budget';
+    if (budget.maxTokens !== undefined && reached(usage.knownInputTokens + usage.knownOutputTokens, budget.maxTokens))
+        return 'token_budget';
+    if (budget.maxDurationMs !== undefined && reached(elapsedMs, budget.maxDurationMs))
+        return 'timeout';
+    return undefined;
+}
+/** Missing billing stays unknown; only reported lower bounds reduce headroom. */
+export function remainingBudget(usage, budget, elapsedMs, reserved = { costUsd: 0, tokens: 0 }) {
+    return {
+        ...(budget.maxCostUsd === undefined ? {} : { maxCostUsd: Math.max(0, budget.maxCostUsd - usage.knownCostUsd - reserved.costUsd) }),
+        ...(budget.maxTokens === undefined ? {} : { maxTokens: Math.max(0, Math.floor(budget.maxTokens - usage.knownInputTokens - usage.knownOutputTokens - reserved.tokens)) }),
+        ...(budget.maxDurationMs === undefined ? {} : { maxDurationMs: Math.max(0, budget.maxDurationMs - elapsedMs) }),
+    };
+}
+/** Graph and host limits intersect: an imported definition cannot raise host caps. */
+export function intersectBudgets(...values) {
+    const result = {};
+    for (const value of values)
+        for (const key of ['maxCostUsd', 'maxTokens', 'maxDurationMs']) {
+            const limit = value?.[key];
+            if (limit === undefined)
+                continue;
+            if (!Number.isFinite(limit) || limit < 0 || (key === 'maxTokens' && !Number.isSafeInteger(limit)))
+                throw new EngineError('invalid_arguments', `Invalid ${key}`);
+            result[key] = Math.min(result[key] ?? Infinity, limit);
+        }
+    return result;
+}

package/dist/agent-runtime/engine/canonical-json.d.ts

@@ -0,0 +1,9 @@
+import { type JsonValue } from './contracts.js';
+export declare const MAX_DEFINITION_BYTES: number;
+export declare const MAX_JSON_DEPTH = 64;
+/** RFC 8785: emit sorted keys directly, avoiding JS integer-key enumeration order. */
+export declare function canonicalJson(value: unknown): string;
+/** Reject duplicate keys before JSON.parse could silently discard their evidence. */
+export declare function parseDefinitionJson(input: string | Uint8Array): JsonValue;
+export declare function definitionVersion(definition: unknown): string;
+export declare function contentDigest(value: unknown): string;

package/dist/agent-runtime/engine/canonical-json.js

@@ -0,0 +1,162 @@
+import { createHash } from 'node:crypto';
+import { EngineError } from './contracts.js';
+export const MAX_DEFINITION_BYTES = 2 * 1024 * 1024;
+export const MAX_JSON_DEPTH = 64;
+const invalidSurrogate = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u;
+function fail(message) { throw new EngineError('invalid_definition', message); }
+function validString(value) {
+    if (invalidSurrogate.test(value))
+        fail('JSON strings must contain valid Unicode scalar values');
+}
+/** RFC 8785: emit sorted keys directly, avoiding JS integer-key enumeration order. */
+export function canonicalJson(value) {
+    const active = new Set();
+    function encode(item, depth) {
+        if (depth > MAX_JSON_DEPTH)
+            fail(`JSON exceeds depth ${MAX_JSON_DEPTH}`);
+        if (item === null || typeof item === 'boolean')
+            return JSON.stringify(item);
+        if (typeof item === 'number') {
+            if (!Number.isFinite(item))
+                fail('JSON numbers must be finite');
+            return JSON.stringify(item);
+        }
+        if (typeof item === 'string') {
+            validString(item);
+            return JSON.stringify(item);
+        }
+        if (typeof item !== 'object')
+            return fail('Only JSON values are permitted');
+        if (active.has(item))
+            fail('JSON must not contain cycles');
+        if (!Array.isArray(item) && ![Object.prototype, null].includes(Object.getPrototypeOf(item)))
+            fail('JSON objects must have a plain prototype');
+        if (Object.getOwnPropertySymbols(item).length)
+            fail('JSON objects must not contain symbol keys');
+        active.add(item);
+        let encoded;
+        if (Array.isArray(item)) {
+            encoded = '[' + Array.from({ length: item.length }, (_, index) => {
+                const descriptor = Object.getOwnPropertyDescriptor(item, String(index));
+                if (!descriptor || !('value' in descriptor))
+                    fail('JSON arrays must not contain holes or accessors');
+                return encode(descriptor.value, depth + 1);
+            }).join(',') + ']';
+        }
+        else {
+            encoded = '{' + Object.keys(item).sort().map(key => {
+                validString(key);
+                const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                if (!('value' in descriptor))
+                    fail('JSON objects must not contain accessors');
+                return JSON.stringify(key) + ':' + encode(descriptor.value, depth + 1);
+            }).join(',') + '}';
+        }
+        active.delete(item);
+        return encoded;
+    }
+    return encode(value, 0);
+}
+/** Reject duplicate keys before JSON.parse could silently discard their evidence. */
+export function parseDefinitionJson(input) {
+    if (Buffer.byteLength(input) > MAX_DEFINITION_BYTES)
+        fail(`Definition exceeds ${MAX_DEFINITION_BYTES} bytes`);
+    let source;
+    try {
+        source = typeof input === 'string' ? input : new TextDecoder('utf-8', { fatal: true }).decode(input);
+    }
+    catch {
+        return fail('Definition is not valid UTF-8');
+    }
+    let cursor = 0;
+    function whitespace() { while (/[\x20\x09\x0a\x0d]/.test(source[cursor] ?? '\0'))
+        cursor += 1; }
+    function string() {
+        const start = cursor++;
+        while (cursor < source.length) {
+            const token = source[cursor++];
+            if (token === '\\') {
+                cursor += 1;
+                continue;
+            }
+            if (token === '"') {
+                let value;
+                try {
+                    value = JSON.parse(source.slice(start, cursor));
+                }
+                catch {
+                    return fail('Invalid JSON string');
+                }
+                validString(value);
+                return value;
+            }
+        }
+        return fail('Unterminated JSON string');
+    }
+    function parse(depth) {
+        if (depth > MAX_JSON_DEPTH)
+            fail(`JSON exceeds depth ${MAX_JSON_DEPTH}`);
+        whitespace();
+        const token = source[cursor];
+        if (token === '"')
+            return string();
+        if (token === '{' || token === '[') {
+            cursor += 1;
+            whitespace();
+            const object = token === '{';
+            const value = object ? Object.create(null) : [];
+            const close = object ? '}' : ']';
+            if (source[cursor] === close) {
+                cursor += 1;
+                return value;
+            }
+            while (cursor < source.length) {
+                whitespace();
+                if (object) {
+                    if (source[cursor] !== '"')
+                        fail('JSON object key must be a string');
+                    const key = string();
+                    if (Object.hasOwn(value, key))
+                        fail(`Duplicate JSON key: ${key}`);
+                    whitespace();
+                    if (source[cursor++] !== ':')
+                        fail('Expected colon after JSON key');
+                    value[key] = parse(depth + 1);
+                }
+                else
+                    value.push(parse(depth + 1));
+                whitespace();
+                const next = source[cursor++];
+                if (next === close)
+                    return value;
+                if (next !== ',')
+                    fail('Expected JSON comma or closing delimiter');
+            }
+            return fail('Unterminated JSON container');
+        }
+        const literal = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(source.slice(cursor))?.[0];
+        if (!literal)
+            return fail('Invalid JSON value');
+        cursor += literal.length;
+        const value = JSON.parse(literal);
+        if (typeof value === 'number' && !Number.isFinite(value))
+            fail('JSON numbers must be finite');
+        return value;
+    }
+    const value = parse(0);
+    whitespace();
+    if (cursor !== source.length)
+        fail('Unexpected content after JSON value');
+    return value;
+}
+export function definitionVersion(definition) {
+    if (!definition || typeof definition !== 'object' || Array.isArray(definition))
+        fail('Definition must be an object');
+    // Encode before copying to reject accessor properties without invoking them.
+    canonicalJson(definition);
+    const content = Object.fromEntries(Object.entries(definition).filter(([key]) => key !== 'version'));
+    return createHash('sha256').update(canonicalJson(content), 'utf8').digest('hex');
+}
+export function contentDigest(value) {
+    return createHash('sha256').update(canonicalJson(value), 'utf8').digest('hex');
+}

package/dist/agent-runtime/engine/checkpoint/database.d.ts

@@ -0,0 +1,67 @@
+import { DatabaseSync, type SQLInputValue, type SQLOutputValue } from 'node:sqlite';
+import { type DurableEngineEvent, type JsonValue } from '../contracts.js';
+export { PersistenceError, ensurePrivateDirectory as ensurePrivateRunDirectory } from '../storage/private-path.js';
+export type DatabaseRow = Record<string, SQLOutputValue>;
+export type WriteRow = Record<string, SQLInputValue>;
+/** Every identifier interpolated into SQL comes from this closed adapter-owned map. */
+declare const keys: {
+    readonly runs: readonly ["run_id"];
+    readonly visits: readonly ["visit_id"];
+    readonly steps: readonly ["run_id", "node_path", "scope_id"];
+    readonly attempts: readonly ["attempt_id"];
+    readonly invocations: readonly ["invocation_id"];
+    readonly receipts: readonly ["receipt_id"];
+    readonly budget: readonly ["run_id"];
+    readonly interrupts: readonly ["interrupt_id"];
+    readonly control_inbox: readonly ["request_id"];
+    readonly role_sessions: readonly ["session_key"];
+    readonly piece_state: readonly ["run_id", "scope_id", "node_path", "key"];
+    readonly reservations: readonly ["reservation_id"];
+    readonly events: readonly ["run_id", "sequence"];
+    readonly checkpoints: readonly ["thread_id", "checkpoint_ns", "checkpoint_id"];
+    readonly writes: readonly ["thread_id", "checkpoint_ns", "checkpoint_id", "task_id", "idx"];
+};
+export type RevisionTable = keyof typeof keys;
+/** Short synchronous transactions own graph writes and ledger evidence together. */
+export declare class RunDatabase {
+    readonly filename: string;
+    readonly sqlite: DatabaseSync;
+    private activeRevision;
+    private inTransaction;
+    private closed;
+    private constructor();
+    static open(filename: string, options?: {
+        create?: boolean;
+        readOnly?: boolean;
+    }): Promise<RunDatabase>;
+    get revision(): number;
+    get transactionRevision(): number;
+    /** Undefined reason is reserved for leases/read reservations, which do not change graph history. */
+    transaction<T>(reason: string | undefined, operation: () => T): T;
+    get(table: RevisionTable, key: WriteRow): DatabaseRow | undefined;
+    put(table: RevisionTable, row: WriteRow): void;
+    delete(table: RevisionTable, key: WriteRow): void;
+    /** Immutable cut includes overwritten pending writes and all child namespaces. Caller holds an inactive-source reservation. */
+    rowsAt(revision: number): Array<{
+        table: RevisionTable;
+        row: WriteRow;
+    }>;
+    /**
+     * Copies a complete historical cut into an empty, separately staged database.
+     * The source writer reservation prevents takeover/steering while rows are read;
+     * serialized graph blobs, opaque thread IDs and child namespaces stay unchanged.
+     */
+    forkAt(destination: RunDatabase, options: {
+        revision: number;
+        runId: string;
+        omitPieceStatePrefixes?: string[];
+    }): {
+        sourceRunId: string;
+        checkpointThreadId: string;
+        revision: number;
+    };
+    checkIntegrity(): void;
+    close(): void;
+}
+/** Called inside the business transaction. Delivery/replay happens only after commit. */
+export declare function appendRunEvent(db: RunDatabase, runId: string, type: string, payload: JsonValue, context?: Partial<Pick<DurableEngineEvent, 'nodePath' | 'scopeId' | 'branchId' | 'visit' | 'attempt' | 'attemptId'>>, timestamp?: string): DurableEngineEvent;