@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/core/control-plane.js

@@ -1,192 +0,0 @@
-export function createControlPlane(deps) {
-    let running = true;
-    let lastStatus;
-    let lastIntakeStatus;
-    let lastRunnerStatus;
-    let consecutiveIdleTicks = 0;
-    let consecutiveIntakeIdleTicks = 0;
-    let consecutiveRunnerIdleTicks = 0;
-    let lastSingleTickRequest;
-    let lastIntakeTickRequest;
-    let lastRunnerTickRequest;
-    const maxIntervalMs = deps.maxIntervalMs ?? deps.intervalMs * 16;
-    function nextSleepMs(consecutiveTicks) {
-        const backoffMs = deps.intervalMs * 2 ** Math.min(consecutiveTicks, 20);
-        return Math.min(backoffMs, maxIntervalMs);
-    }
-    async function tickRequestPending(input) {
-        const request = (await deps.readTickRequest?.()) ?? null;
-        if (request === null || request === input.getLastRequest()) {
-            return false;
-        }
-        input.setLastRequest(request);
-        return true;
-    }
-    async function sleepUntilNextTick(ms, requestState) {
-        if (deps.readTickRequest === undefined || ms <= 0) {
-            await deps.sleep(ms);
-            return { forced: false };
-        }
-        if (await tickRequestPending(requestState)) {
-            return { forced: true };
-        }
-        const deadline = Date.now() + ms;
-        while (running) {
-            const remainingMs = deadline - Date.now();
-            if (remainingMs <= 0) {
-                return { forced: false };
-            }
-            await deps.sleep(Math.min(remainingMs, 250));
-            if (await tickRequestPending(requestState)) {
-                return { forced: true };
-            }
-        }
-        return { forced: false };
-    }
-    async function isPaused() {
-        return Boolean(await deps.isPaused());
-    }
-    function logStatus(message, status, last) {
-        if (status !== last) {
-            deps.logger.info(message);
-        }
-        return status;
-    }
-    async function runLoopOnce(input) {
-        if (await isPaused()) {
-            const status = 'paused';
-            if (input.label === 'intake') {
-                lastIntakeStatus = logStatus('[wake] intake status=paused', status, lastIntakeStatus);
-            }
-            else {
-                lastRunnerStatus = logStatus('[wake] runner status=paused', status, lastRunnerStatus);
-            }
-            return { status: 'paused' };
-        }
-        const result = await input.run();
-        const status = result?.status ?? 'unknown';
-        if (input.label === 'intake') {
-            lastIntakeStatus = logStatus(`[wake] intake status=${status}`, status, lastIntakeStatus);
-        }
-        else {
-            lastRunnerStatus = logStatus(`[wake] runner status=${status}`, status, lastRunnerStatus);
-        }
-        return result;
-    }
-    async function startLoop(input) {
-        while (running) {
-            let result;
-            try {
-                result = await runLoopOnce({ run: input.run, label: input.label });
-            }
-            catch (error) {
-                deps.logger.error(error instanceof Error ? error.message : String(error));
-            }
-            if (!running) {
-                break;
-            }
-            const status = result?.status;
-            if (status === 'processed') {
-                input.setIdleTicks(0);
-                if (input.label === 'intake') {
-                    await sleepUntilNextTick(deps.intervalMs, {
-                        getLastRequest: input.getLastRequest,
-                        setLastRequest: input.setLastRequest,
-                    });
-                }
-            }
-            else {
-                const waitMs = input.idleBackoff ? nextSleepMs(input.getIdleTicks()) : deps.intervalMs;
-                const wait = await sleepUntilNextTick(waitMs, {
-                    getLastRequest: input.getLastRequest,
-                    setLastRequest: input.setLastRequest,
-                });
-                if (!wait.forced && input.idleBackoff) {
-                    input.setIdleTicks(input.getIdleTicks() + 1);
-                }
-            }
-        }
-    }
-    return {
-        stop() {
-            running = false;
-        },
-        async runOnce() {
-            if (await isPaused()) {
-                if (lastStatus !== 'paused') {
-                    deps.logger.info('[wake] status=paused');
-                    lastStatus = 'paused';
-                }
-                return { status: 'paused' };
-            }
-            const result = await deps.tickRunner.runTick();
-            const status = result?.status ?? 'unknown';
-            if (status !== lastStatus) {
-                deps.logger.info(`[wake] status=${status}`);
-                lastStatus = status;
-            }
-            return result;
-        },
-        async start() {
-            if (deps.tickRunner.runIntakeTick !== undefined &&
-                deps.tickRunner.runRunnerTick !== undefined) {
-                await Promise.all([
-                    startLoop({
-                        run: deps.tickRunner.runIntakeTick,
-                        label: 'intake',
-                        getIdleTicks: () => consecutiveIntakeIdleTicks,
-                        setIdleTicks: (value) => {
-                            consecutiveIntakeIdleTicks = value;
-                        },
-                        getLastRequest: () => lastIntakeTickRequest,
-                        setLastRequest: (value) => {
-                            lastIntakeTickRequest = value;
-                        },
-                        idleBackoff: true,
-                    }),
-                    startLoop({
-                        run: deps.tickRunner.runRunnerTick,
-                        label: 'runner',
-                        getIdleTicks: () => consecutiveRunnerIdleTicks,
-                        setIdleTicks: (value) => {
-                            consecutiveRunnerIdleTicks = value;
-                        },
-                        getLastRequest: () => lastRunnerTickRequest,
-                        setLastRequest: (value) => {
-                            lastRunnerTickRequest = value;
-                        },
-                        idleBackoff: false,
-                    }),
-                ]);
-                return;
-            }
-            while (running) {
-                let result;
-                try {
-                    result = await this.runOnce();
-                }
-                catch (error) {
-                    deps.logger.error(error instanceof Error ? error.message : String(error));
-                }
-                if (!running) {
-                    break;
-                }
-                const status = result?.status;
-                if (status === 'processed') {
-                    consecutiveIdleTicks = 0;
-                }
-                else {
-                    const wait = await sleepUntilNextTick(nextSleepMs(consecutiveIdleTicks), {
-                        getLastRequest: () => lastSingleTickRequest,
-                        setLastRequest: (value) => {
-                            lastSingleTickRequest = value;
-                        },
-                    });
-                    if (!wait.forced) {
-                        consecutiveIdleTicks += 1;
-                    }
-                }
-            }
-        },
-    };
-}

package/dist/src/core/event-builders.js

@@ -1,153 +0,0 @@
-import { LABELS_REQUESTED_EVENT, PUBLISH_INTENT_REQUESTED_EVENT } from '../domain/event-types.js';
-import { createEventEnvelope } from '../lib/event-log.js';
-import { extractTokenCount, formatCostUsd, formatDuration, formatTokenCount, } from '../lib/format.js';
-function isReviewThreadResourceUri(resourceUri) {
-    return resourceUri.split(':')[1] === 'pr-review-thread';
-}
-// `latestComment` is a sticky, per-work-item field: projection-updater.ts's
-// comment fold overwrites it unconditionally on every inbound comment
-// (any surface) and nothing ever resets it. So it means "the last comment
-// this work item has ever received," not "the comment that triggered the
-// currently completing run." Several needsWakeAction trigger paths (first
-// run, quota-failure retry, first workflow-stage pass) complete a run
-// with no fresh comment driving it at all — in those cases latestComment
-// may still be pointing at an older, already-handled comment from a
-// different surface (e.g. a PR) and must not be trusted as this run's
-// trigger. This mirrors policy-engine.ts's needsWakeAction "is there an
-// unhandled human comment" check exactly, so a comment is only treated as
-// having driven this run when it's human-authored and not yet the
-// candidate's own lastHandledCommentId (read from the pre-completion
-// projection passed in as `candidate`/`projection`, since the completion
-// event that would update lastHandledCommentId for *this* run hasn't been
-// folded yet at the point this runs).
-function isFreshTriggeringComment(candidate) {
-    const context = candidate.context;
-    const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
-    return (candidate.latestComment !== undefined &&
-        !candidate.latestComment.isBotAuthored &&
-        candidate.latestComment.id !== handledCommentId);
-}
-export function createPublishIntentEvent(input) {
-    const tokenCount = extractTokenCount(input.runnerResult.tokenUsage);
-    const duration = formatDuration(input.startedAt, input.occurredAt);
-    const failureRepeated = input.runnerResult.failureClass !== undefined &&
-        input.previousFailureClass === input.runnerResult.failureClass;
-    return createEventEnvelope({
-        eventId: `${input.runId}-publish-intent`,
-        workItemKey: input.projection.workItemKey,
-        streamScope: 'work-item',
-        direction: 'outbound',
-        sourceSystem: 'wake',
-        sourceEventType: PUBLISH_INTENT_REQUESTED_EVENT,
-        sourceRefs: {
-            repo: input.projection.issue.repo,
-            issueNumber: input.projection.issue.number,
-            runId: input.runId,
-            // Carries the triggering comment's surface (set only when the human
-            // reply that woke this run came from a correlated PR/review-thread
-            // resource, per the ad1cf45 comment fold) through to the sink
-            // router, so createOutboundSinkRouter's kind-based routing (Task 11,
-            // sink-router.ts) can send the reply back to that surface instead of
-            // defaulting to the issue thread. Without this, every reply landed
-            // on the origin sink regardless of which surface triggered the run.
-            //
-            // Gated on isFreshTriggeringComment: latestComment is sticky (see
-            // that function's comment) and several run-completion paths (first
-            // run, quota retry, first workflow-stage pass) have no fresh
-            // comment behind them at all — for those, threading the stale
-            // latestComment.resourceUri would misroute the reply to whatever
-            // surface last happened to comment, even long after that comment
-            // was already replied to.
-            //
-            // Never threads a pr-review-thread surface specifically: this is
-            // Wake's own status, approval-request, or question card: a milestone
-            // message, not a targeted reply to one inline comment — burying it
-            // as a reply deep in a single review thread makes it easy to miss.
-            // Omitting resourceUri here falls back to sourceOrigin in
-            // sink-router.ts, landing it on the correlated issue (or, for a
-            // standalone PR-only work item, GitHub's shared issue/PR comments
-            // endpoint posts it as a top-level PR comment instead). Replies to
-            // individual review threads are the agent's own job now — see
-            // prompts/revise.md — via `gh api .../replies`, not this card.
-            ...(input.projection.latestComment?.resourceUri === undefined ||
-                !isFreshTriggeringComment(input.projection) ||
-                isReviewThreadResourceUri(input.projection.latestComment.resourceUri)
-                ? {}
-                : { resourceUri: input.projection.latestComment.resourceUri }),
-        },
-        occurredAt: input.occurredAt,
-        ingestedAt: input.occurredAt,
-        trigger: 'context-only',
-        payload: {
-            kind: input.sentinel === 'DONE' && input.approvalGated === true
-                ? 'approval-request'
-                : input.sentinel === 'BLOCKED'
-                    ? 'question'
-                    : input.sentinel === 'FAILED'
-                        ? 'failure'
-                        : 'status-update',
-            origin: input.projection.origin ?? 'github',
-            body: input.parsedRunnerResult.body,
-            action: input.action,
-            sentinel: input.sentinel,
-            runId: input.runId,
-            ...(input.runnerResult.session_id === undefined
-                ? {}
-                : { sessionId: input.runnerResult.session_id }),
-            model: input.runnerResult.model,
-            cli: input.runnerResult.cli,
-            ...(input.runnerResult.routing === undefined
-                ? {}
-                : {
-                    runnerName: input.runnerResult.routing.runnerName,
-                    runnerKind: input.runnerResult.routing.runnerKind,
-                    runnerTier: input.runnerResult.routing.tier,
-                    runnerReason: input.runnerResult.routing.reason,
-                }),
-            ...(duration === undefined ? {} : { duration }),
-            ...(tokenCount === undefined ? {} : { tokens: formatTokenCount(tokenCount) }),
-            ...(input.runnerResult.tokenUsage?.costUsd === undefined
-                ? {}
-                : { cost: formatCostUsd(input.runnerResult.tokenUsage.costUsd) }),
-            ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
-            idempotencyKey: `${input.runId}:result-comment`,
-            deliveryState: 'PENDING',
-            ...(failureRepeated ? { failureRepeated } : {}),
-            ...(input.previousFailureClass === undefined
-                ? {}
-                : { previousFailureClass: input.previousFailureClass }),
-        },
-        derivedHints: {
-            stage: input.sentinel === 'DONE' ? 'done' : input.projection.wake.stage,
-        },
-    });
-}
-export function createLabelsEvent(input) {
-    const labelKind = input.statusLabel === 'wake:status.working' ? 'working-label' : 'completion-label';
-    return createEventEnvelope({
-        eventId: `${input.runId}-labels-${input.statusLabel.replace(/[^a-z0-9]+/gi, '-')}-${input.stageLabel.replace(/[^a-z0-9]+/gi, '-')}-${input.workflowLabel.replace(/[^a-z0-9]+/gi, '-')}`,
-        workItemKey: input.projection.workItemKey,
-        streamScope: 'work-item',
-        direction: 'outbound',
-        sourceSystem: 'wake',
-        sourceEventType: LABELS_REQUESTED_EVENT,
-        sourceRefs: {
-            repo: input.projection.issue.repo,
-            issueNumber: input.projection.issue.number,
-            runId: input.runId,
-        },
-        occurredAt: input.occurredAt,
-        ingestedAt: input.occurredAt,
-        trigger: 'context-only',
-        payload: {
-            statusLabel: input.statusLabel,
-            stageLabel: input.stageLabel,
-            workflowLabel: input.workflowLabel,
-            ...(input.frozenLabel === undefined ? {} : { frozenLabel: input.frozenLabel }),
-            ...(input.scheduledLabel === undefined ? {} : { scheduledLabel: input.scheduledLabel }),
-            origin: input.projection.origin ?? 'github',
-            idempotencyKey: `${input.runId}:${labelKind}`,
-            deliveryState: 'PENDING',
-        },
-    });
-}

package/dist/src/core/event-resolver.js

@@ -1,249 +0,0 @@
-import { createWorkId } from '../lib/work-id.js';
-import { CORRELATION_REGISTERED_EVENT, UNRESOLVED_WORK_ITEM_KEY, WORK_ITEM_CREATED_EVENT, } from '../domain/schema.js';
-import { createEventEnvelope } from '../lib/event-log.js';
-// How an unkeyed source event becomes a work item — the correlation-resolution
-// subsystem described in docs/adrs/0001-correlating-external-resources-to-work-items.md.
-export function createEventResolver(deps) {
-    // Events are stamped by reading the clock at the moment of stamping, never
-    // from a frozen tick-start snapshot. `tickStartedAt` is the tick's *decision*
-    // clock (policy/staleness), and reusing it to date events inverts them
-    // against the work source's own poll-time ingestedAt — pollEvents() runs
-    // after tickStartedAt is captured, so in production every polled upsert is
-    // LATER than the tick's start. An event dated before the upsert that creates
-    // the projection it folds into sorts ahead of it in rebuildFromEvents' global
-    // replay, folds against `current === null`, and is silently dropped. Reading
-    // per event also stays correct once ticks work items in parallel, where a
-    // shared per-tick snapshot would tie every concurrent event on ingestedAt and
-    // leave append order as the only discriminator.
-    function eventStampNow() {
-        return deps.clock.now().toISOString();
-    }
-    // Returns whichever of the two timestamps is unambiguously later, defaulting
-    // to `left`. `right` wins only if it is later by BOTH the actual instant and
-    // the lexicographic order rebuildFromEvents sorts on — the envelope schema is
-    // `z.string().datetime({ offset: true })`, so a timestamp may legally carry a
-    // non-UTC offset or differing sub-second precision, and lexicographic order
-    // alone is not a reliable proxy for chronology across those formats. Falling
-    // back to `left` (the source event's own exact string) is always safe: it
-    // ties with that event under localeCompare, and the stable sort then preserves
-    // append order, which puts the mint events after it — exactly what we need.
-    function laterTimestamp(left, right) {
-        const isLater = Date.parse(right) > Date.parse(left) && right.localeCompare(left) > 0;
-        return isLater ? right : left;
-    }
-    // The two internal events a mint (or a heal) appends after the source event
-    // that founded a work item: wake.workitem.created, then the
-    // wake.correlation.registered that claims the originating resource as this
-    // work item's primary representation. Their ids are derived from the work id,
-    // so re-emitting them is idempotent — appendEventEnvelope dedups on the id.
-    //
-    // Ordering and timestamps matter, and not only for readability. Both fold
-    // against the projection the source event creates, and applyEvent drops
-    // anything that folds while `current === null`. So they must never sort
-    // *before* that source event in rebuildFromEvents' globally-ordered replay —
-    // if they did, replay would silently discard the registration, leaving
-    // correlatedResources[] empty and the index unpopulated, while the events
-    // still on record stop any later tick from re-registering. Permanent,
-    // self-concealing loss (Task 5, round 3). Reading the clock here is already
-    // after pollEvents(), but that alone is not a guarantee: the source event's
-    // ingestedAt comes from the *source's* clock, which for a real source is
-    // another machine's and can legitimately run ahead of ours. Anchoring on the
-    // source event's own timestamp makes the ordering hold by construction rather
-    // than by clock agreement; appending the source event first means a tie
-    // resolves in its favour (the sort is stable, so equal timestamps keep append
-    // order).
-    function buildOriginCorrelationEvents(workItemKey, unkeyed, resourceUri) {
-        const mintedAt = laterTimestamp(unkeyed.ingestedAt, eventStampNow());
-        const sourceRefs = {
-            ...unkeyed.sourceRefs,
-            resourceUri,
-        };
-        const createdEvent = createEventEnvelope({
-            eventId: `${workItemKey}-created`,
-            workItemKey,
-            streamScope: 'work-item',
-            direction: 'internal',
-            sourceSystem: 'wake',
-            sourceEventType: WORK_ITEM_CREATED_EVENT,
-            sourceRefs,
-            occurredAt: mintedAt,
-            ingestedAt: mintedAt,
-            trigger: 'context-only',
-            // The envelope's workItemKey already carries the identity.
-            payload: {},
-        });
-        const registeredEvent = createEventEnvelope({
-            eventId: `${workItemKey}-origin-correlation`,
-            workItemKey,
-            streamScope: 'work-item',
-            direction: 'internal',
-            sourceSystem: 'wake',
-            sourceEventType: CORRELATION_REGISTERED_EVENT,
-            sourceRefs,
-            occurredAt: mintedAt,
-            ingestedAt: mintedAt,
-            trigger: 'context-only',
-            payload: {
-                resourceUri,
-                role: 'representation',
-                relation: 'primary',
-                provenance: 'wake-created',
-            },
-        });
-        return [createdEvent, registeredEvent];
-    }
-    // The central resolver (spec D1): sources name the *resource* an event came
-    // from and never the work item, so between pollEvents() and the append every
-    // inbound event's sourceRefs.resourceUri is resolved through the reverse
-    // index to the canonical workItemKey, minting a work item on a miss. This is
-    // the one mechanism — there is no founding-surface special case, and no
-    // resolution is ever cached in process memory between ticks (CLAUDE.md: the
-    // tick is a pure function of durable state; the index on disk *is* that
-    // state).
-    //
-    // Each resolved event carries whether it is already `persisted`, so the
-    // caller can skip re-appending it (appendEventEnvelope would only re-read it
-    // and hand back the same envelope). Minting *is* registration, so a freshly
-    // minted work item's correlatedResources[] is complete from its first event.
-    async function resolveInboundEvent(unkeyed) {
-        const { resourceUri } = unkeyed.sourceRefs;
-        if (resourceUri === undefined) {
-            // A programming error in the adapter, not a runtime condition to absorb.
-            // Guessing an identity here would silently fork a duplicate work item
-            // for work already in flight — exactly the corruption the reverse index
-            // exists to prevent — so fail loudly instead.
-            throw new Error(`cannot resolve inbound event ${unkeyed.eventId} from ${unkeyed.sourceSystem}: ` +
-                'sourceRefs.resourceUri is required for every unkeyed source event');
-        }
-        // An event we have already persisted was already resolved, on some earlier
-        // tick, and its stamped key is the durable answer. Re-resolving it through
-        // the index would be wrong as well as wasteful: if that work item has since
-        // retracted this resource, the index no longer holds it, the lookup misses,
-        // and a miss means mint — so a re-polled event (sources legitimately
-        // re-emit the same eventId, e.g. an unchanged issue) would fork a duplicate
-        // work item. Reusing the persisted key keeps resolution idempotent per
-        // event id, which is what the append-only log already promises.
-        const persisted = await deps.stateStore.readEventEnvelope(unkeyed.eventId);
-        if (persisted !== null) {
-            // Heal a partially minted work item. The index entry for a resource is
-            // written only when its origin wake.correlation.registered event is
-            // *folded*, several appends after the founding source event. A crash in
-            // that window leaves the source event durable — so this branch suppresses
-            // re-minting — while the index has no entry, and a later event on the
-            // same resource would miss the index and fork a duplicate work item
-            // (crash/restart safety, CLAUDE.md). If the index does not credit this
-            // event's work item *and* its origin correlation never landed, re-emit
-            // the mint tail (idempotent by id). The guard is the missing origin
-            // event, not merely an empty index: a deliberately *retracted* resource
-            // also resolves to undefined but keeps its origin-correlation event on
-            // record, and must not be silently re-registered.
-            const owner = await deps.resourceIndex.resolve(resourceUri);
-            if (persisted.workItemKey !== UNRESOLVED_WORK_ITEM_KEY &&
-                owner === undefined &&
-                (await deps.stateStore.readEventEnvelope(`${persisted.workItemKey}-origin-correlation`)) ===
-                    null) {
-                return [
-                    { envelope: persisted, persisted: true },
-                    ...buildOriginCorrelationEvents(persisted.workItemKey, unkeyed, resourceUri).map((envelope) => ({ envelope, persisted: false })),
-                ];
-            }
-            return [{ envelope: persisted, persisted: true }];
-        }
-        const existingWorkItemKey = await deps.resourceIndex.resolve(resourceUri);
-        if (existingWorkItemKey !== undefined) {
-            return [
-                {
-                    envelope: createEventEnvelope({ ...unkeyed, workItemKey: existingWorkItemKey }),
-                    persisted: false,
-                },
-            ];
-        }
-        // resourceUri itself misses the index (e.g. a review-thread comment's
-        // resourceUri is unique per thread, never registered on its own), but the
-        // adapter may have named a parent resource this one belongs to. Resolve
-        // through that instead of minting — and register this exact resourceUri
-        // as a secondary correlation so it's on record on the work item, even
-        // though (being secondary) it still won't shortcut future lookups via the
-        // index itself (ADR 0001 §5: the index is primary-only).
-        if (unkeyed.sourceRefs.parentResourceUri !== undefined) {
-            const parentWorkItemKey = await deps.resourceIndex.resolve(unkeyed.sourceRefs.parentResourceUri);
-            if (parentWorkItemKey !== undefined) {
-                const mintedAt = laterTimestamp(unkeyed.ingestedAt, eventStampNow());
-                return [
-                    {
-                        envelope: createEventEnvelope({ ...unkeyed, workItemKey: parentWorkItemKey }),
-                        persisted: false,
-                    },
-                    {
-                        envelope: createEventEnvelope({
-                            eventId: `${parentWorkItemKey}-correlation-${resourceUri.replace(/[^a-z0-9]+/gi, '-')}`,
-                            workItemKey: parentWorkItemKey,
-                            streamScope: 'work-item',
-                            direction: 'internal',
-                            sourceSystem: 'wake',
-                            sourceEventType: CORRELATION_REGISTERED_EVENT,
-                            sourceRefs: unkeyed.sourceRefs,
-                            occurredAt: mintedAt,
-                            ingestedAt: mintedAt,
-                            trigger: 'context-only',
-                            payload: {
-                                resourceUri,
-                                role: 'review',
-                                relation: 'secondary',
-                                provenance: 'detected',
-                            },
-                        }),
-                        persisted: false,
-                    },
-                ];
-            }
-        }
-        if (!deps.qualifiesForMint(unkeyed, deps.config)) {
-            return [
-                {
-                    envelope: createEventEnvelope({ ...unkeyed, workItemKey: UNRESOLVED_WORK_ITEM_KEY }),
-                    persisted: false,
-                },
-            ];
-        }
-        const workItemKey = createWorkId();
-        const keyed = createEventEnvelope({ ...unkeyed, workItemKey });
-        return [
-            { envelope: keyed, persisted: false },
-            ...buildOriginCorrelationEvents(workItemKey, unkeyed, resourceUri).map((envelope) => ({
-                envelope,
-                persisted: false,
-            })),
-        ];
-    }
-    async function ingestInboundEvents(unkeyedEvents) {
-        const ingested = [];
-        for (const unkeyed of unkeyedEvents) {
-            const resolved = await resolveInboundEvent(unkeyed);
-            // Fold what was actually persisted, never the in-memory copy:
-            // appendEventEnvelope is id-deduplicated and returns the *existing*
-            // envelope when one is already on record. Folding our own copy instead
-            // would let state/ diverge from events/ — and replay is defined by
-            // events/, so the divergence would only surface after a rebuild. An event
-            // already flagged `persisted` needs no second append: appendEventEnvelope
-            // would only re-read it off disk and hand back the same envelope, and
-            // every unchanged issue is re-polled every tick, so that read is the
-            // dominant redundant cost this branch avoids.
-            const events = [];
-            for (const { envelope, persisted } of resolved) {
-                events.push(persisted ? envelope : await deps.stateStore.appendEventEnvelope(envelope));
-            }
-            // Folded before the next event is resolved, because it is the fold of
-            // the registration event that writes the index entry the *next* event on
-            // the same resource resolves through. Deferring the fold to the end of
-            // the batch would let a second event for the same ticket miss and mint a
-            // duplicate work item. Every event in a poll batch shares the source's
-            // one ingestedAt, so folding per event preserves exactly the order a
-            // single batched fold would have produced.
-            await deps.projectionUpdater.rebuildFromEvents(events);
-            ingested.push(...events);
-        }
-        return ingested;
-    }
-    return { ingestInboundEvents };
-}

package/dist/src/core/lifecycle-service.js

@@ -1,8 +0,0 @@
-import { builtInDefaultWorkflowDefinition, nextStage } from '../domain/workflows.js';
-export function createLifecycleService() {
-    return {
-        nextStageFromSentinel(stage, sentinel, workflow = builtInDefaultWorkflowDefinition) {
-            return nextStage(stage, sentinel, workflow);
-        },
-    };
-}