@stratusagent/gateway 0.14.7 → 0.14.9

package/dist/recovery.js

@@ -0,0 +1,487 @@
+/*
+ * Restart recovery: the turns the last process left parked on a person or
+ * still running, the sub-sessions it orphaned, and how a repeated
+ * idempotency key settles against an unfinished item or a rollover's
+ * archived transcript. Moved out of `createGateway` in index.ts as is: the
+ * statements are unchanged, inside a factory that takes what they closed
+ * over there, and `createGateway` calls it where they were. The edits:
+ * `stopping`, `abortingWith` and `orphanedAtStart` are `let`s reassigned
+ * later, so they are read through `isStopping()`, `getAbortingWith()` and
+ * `getOrphanedAtStart()`, and `onSessionChain`, declared further down, is
+ * passed late-bound.
+ */
+import { completeAnsweredTurn, lastResponseIsAnswer, PENDING_APPROVAL_METADATA_KEY, readPendingApproval, recordTurnFailure, turnKeyOf, turnMessageOf, workItemState, } from '@stratusagent/core';
+import { delegatingSessionIdOf, isDelegatedSession, outstandingDelegationFor, SCHEDULE_ID_METADATA_KEY, } from '@stratusagent/agents';
+import { ABANDONED_TURN_ERROR, crossIdentityError, isSubAgentSession, ORPHANED_DELEGATION_ERROR, ROLLED_OVER_FROM_METADATA_KEY, ROLLOVER_REPEAT_WINDOW_MS, } from "./session-keys.js";
+import { FALLBACK_ACTIVE_METADATA_KEY } from '@stratusagent/state';
+export const createRecovery = ({ log, warn, bus, store, scheduler, effectiveApprovalTimeoutMs, refreshAgent, runtimeContextFor, runnerFor, withWatchdog, isStopping, trackTurn, untrackTurn, getAbortingWith, shutdownAbort, activeTurns, onTurnRuntime, getOrphanedAtStart, runtimeForAgent, watchdogStreamsFor, reachesHarness, onSessionChain, }) => {
+    /**
+     * Finishes the turns that were parked on a human when this daemon last
+     * went down.
+     *
+     * Run after the channels are up, deliberately: recovery re-asks, and a
+     * request emitted into a gateway with no live adapter would be declined
+     * for want of anywhere to put it — turning "your approval survived the
+     * restart" into "your approval was denied by the restart".
+     *
+     * Each session is recovered independently and failures are per-session:
+     * one unrecoverable turn must not stop the daemon from serving, or from
+     * recovering the others.
+     */
+    const recoverParkedTurns = async (orphaned) => {
+        if (!store.listIdsByStatus) {
+            return;
+        }
+        const parked = await store.listIdsByStatus('pending_approval');
+        if (parked.length === 0) {
+            return;
+        }
+        log(`recovering ${parked.length} turn(s) parked on approval`);
+        // Started together, not one after another. Each recovery re-asks and
+        // then waits on a human, so awaiting them in sequence would mean the
+        // second parked turn is not even *announced* until the first is
+        // answered — fifteen minutes later by default, and never at all with a
+        // zero timeout. They are independent turns; only same-session work is
+        // ordered, and onSessionChain already guarantees that.
+        await Promise.allSettled(parked.map((sessionId) => recoverOne(sessionId, orphaned.has(sessionId))));
+    };
+    /**
+     * The parked sub-sessions whose delegating turn the last process was
+     * still inside — read BEFORE the channels start, for the same reason the
+     * abandoned list is.
+     *
+     * The proof is the parent's transcript: only the runner writes an
+     * assistant `agent.delegate` call, and only a delegation in flight leaves
+     * one with no result behind it. That evidence does not survive contact
+     * with a channel, though — a message for the parent arriving once the
+     * adapters are up resumes it, and the resume closes the dangling call as
+     * interrupted. Read live from the sweep, the parent would then look as if
+     * it awaited nothing and the child would be re-asked after all, which is
+     * the bug this exists to stop. So it is read while nothing can dispatch,
+     * and the sweep judges from the snapshot; a child whose parent is missing
+     * or not inside such a call is left to ordinary recovery.
+     *
+     * Matched call by call, not parent by parent: the call that awaits a
+     * child names it (see `outstandingDelegationFor`), and a call can await
+     * only one. Two parked children claiming the same call — one of them a
+     * sub-session continued from outside under a version that kept its
+     * markers, parked again on something of its own — is an ambiguity this
+     * cannot settle, and both are left to ordinary recovery rather than one
+     * of them being failed for a delegation that was never its.
+     */
+    const listOrphanedDelegations = async () => {
+        const claimants = new Map();
+        if (!store.listIdsByStatus) {
+            return new Set();
+        }
+        for (const sessionId of await store.listIdsByStatus('pending_approval')) {
+            const parentId = delegatingSessionIdOf(sessionId);
+            if (parentId === undefined) {
+                continue;
+            }
+            const session = await store.get(sessionId);
+            if (!session || !isDelegatedSession(session)) {
+                continue;
+            }
+            const parent = await store.get(parentId);
+            const callId = parent ? outstandingDelegationFor(parent, session) : undefined;
+            if (callId !== undefined) {
+                const key = `${parentId}\u0000${callId}`;
+                claimants.set(key, [...(claimants.get(key) ?? []), sessionId]);
+            }
+        }
+        return new Set([...claimants.values()].filter((ids) => ids.length === 1).map(([id]) => id));
+    };
+    const recoverOne = (sessionId, orphaned) => onSessionChain(sessionId, () => recoverParked(sessionId, orphaned));
+    /**
+     * `recoverOne`'s work, for a caller already on the session's chain: a
+     * repeated idempotency key that reached the chain before the parked sweep
+     * did, and would otherwise wait on a turn nothing is running yet.
+     */
+    const recoverParked = async (sessionId, orphaned) => {
+        if (isStopping()) {
+            return;
+        }
+        try {
+            const session = await store.get(sessionId);
+            if (!session) {
+                return;
+            }
+            const record = readPendingApproval(session);
+            // A delegated sub-session is only ever awaited by its parent's
+            // `agent.delegate` call, and that parent was running when the last
+            // process died — it is in the abandoned sweep, not in this one.
+            // Nothing will read the reply, so the parked call is not re-asked:
+            // a person would be approving a command that runs for no one.
+            //
+            // Judged on the re-read, on the chain: the channels are up before
+            // this sweep starts, so a message for this id can have taken the
+            // chain first and moved the session on — and a turn that finished
+            // normally must not be rewritten as failed. The delegation metadata
+            // is durable, so it proves what the session is, not what state it
+            // is in; the status and the checkpoint say that.
+            //
+            // Whether it IS an orphan was decided before the channels started
+            // (`listOrphanedDelegations`), from the parent's transcript, which
+            // a message arriving since may already have rewritten.
+            // A sub-agent never parks (nobody is asked for it), and if one ever
+            // did, its parent's turn died with the last process: nothing would
+            // read its answer, and recovering it would run it as the full agent.
+            if (isSubAgentSession(session) && session.status === 'pending_approval') {
+                log(`${sessionId}: a sub-agent parked when the last stratusd stopped; failing it`);
+                await failParked(session, ABANDONED_TURN_ERROR);
+                return;
+            }
+            if (orphaned && isDelegatedSession(session) && session.status === 'pending_approval' && record) {
+                log(`${sessionId}: parked on ${record.call.toolName} for a delegating turn the last stratusd was still running; failing it`);
+                await failOrphanedDelegation(session);
+                return;
+            }
+            // A wait that outlived its window while the daemon was down is
+            // honoured, not restarted: the request really did go unanswered for
+            // the whole time it was configured to wait, and downtime is not a
+            // reason to extend a security decision. Measured from when the turn
+            // parked against this daemon's timeout — the transport's original
+            // deadline was chosen after the checkpoint was written and is gone
+            // with the process that chose it. Denying goes through the same
+            // recovery path, so the queue behind it still drains.
+            const parkedAt = record ? Date.parse(record.parkedAt) : Number.NaN;
+            const expired = effectiveApprovalTimeoutMs > 0
+                && Number.isFinite(parkedAt)
+                && Date.now() - parkedAt >= effectiveApprovalTimeoutMs;
+            if (expired) {
+                log(`${sessionId}: the approval for ${record?.call.toolName} outlived its window while the daemon was down; denying it`);
+            }
+            // Resolved the way a dispatch for this agent would resolve it, so a
+            // recovered turn finishes on the same provider, model, and
+            // credentials it was parked on.
+            const source = await refreshAgent(session.agent.id);
+            // And on the CURRENT definition, saved before recovery reads the
+            // session back. An allowlist is a permission boundary: a soul that
+            // dropped a tool while the daemon was down must not have that tool
+            // executed by the turn that outlived the change, and
+            // `allowedToolsFor` reads the definition frozen into the session
+            // ahead of the registry. Dispatch refreshes it the same way before
+            // resuming.
+            session.agent = source.definition;
+            await store.save(session);
+            const recoveredConfig = await runtimeForAgent(source);
+            const runner = runnerFor(recoveredConfig, source.definition.id);
+            // Tracked like a dispatched turn's controller: a recovered turn that
+            // runs on past its approval is a turn like any other, so a restart's
+            // window has to be able to cut it short with the same reason (or it
+            // runs unseen to the second window and the restart reports
+            // undrained), and a stop for the session has to find it. Only once
+            // the checkpoint has been read on this chain, right before the runner
+            // takes it: a stop counted then always ends in the turn's own
+            // outcome. A stop sent during the reads above finds nothing running
+            // and reaches the session as an ordinary message, queued behind it.
+            const controller = new AbortController();
+            if (record) {
+                trackTurn(sessionId, controller);
+                if (getAbortingWith() !== undefined) {
+                    controller.abort(shutdownAbort());
+                }
+            }
+            try {
+                await onTurnRuntime(sessionId, { source, config: recoveredConfig }, () => runner.recoverPendingApproval(sessionId, {
+                    denyPending: expired,
+                    runtime: runtimeContextFor(source, recoveredConfig, session.metadata?.[FALLBACK_ACTIVE_METADATA_KEY] === true, session.metadata),
+                    signal: controller.signal,
+                }));
+            }
+            finally {
+                untrackTurn(sessionId, controller);
+                // A recovered firing's row outlived the process that would have
+                // retired it, and the firing is over either way — a recovery that
+                // failed has durably failed its session, which is as finished as
+                // completing. The scheduler decides whether there is a row to
+                // retire, and only this firing's own.
+                const scheduleId = session.metadata?.[SCHEDULE_ID_METADATA_KEY];
+                if (typeof scheduleId === 'string') {
+                    scheduler.retireSpentOneShot(scheduleId, sessionId);
+                }
+            }
+        }
+        catch (error) {
+            warn(`could not recover parked session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+            // A keyed item is a promise to its caller, and one whose recovery
+            // cannot even start (its agent gone, its provider unresolvable) would
+            // otherwise stay parked for every later start and redelivery to try
+            // again. An unkeyed one keeps waiting for a sweep that can, as before.
+            const after = await store.get(sessionId).catch(() => undefined);
+            const key = after === undefined ? undefined : turnKeyOf(turnMessageOf(after));
+            if (after !== undefined && key !== undefined && after.status === 'pending_approval' && workItemState(after, key) === 'unfinished') {
+                await failParked(after, ABANDONED_TURN_ERROR).catch(() => { });
+            }
+        }
+    };
+    /**
+     * Closes an orphaned sub-session the way the abandoned sweep closes its
+     * parent: durably failed, with the checkpoint retired so no later sweep
+     * can find a call to re-enter, and announced where surfaces can hear it.
+     */
+    const failOrphanedDelegation = (session) => failParked(session, ORPHANED_DELEGATION_ERROR);
+    const failParked = async (session, error) => {
+        const metadata = { ...(session.metadata ?? {}) };
+        delete metadata[PENDING_APPROVAL_METADATA_KEY];
+        session.metadata = metadata;
+        recordTurnFailure(session, error);
+        await store.save(session);
+        await bus.emit({ type: 'session.updated', sessionId: session.id, status: 'failed' });
+        await bus.emit({ type: 'session.failed', sessionId: session.id, error });
+    };
+    /**
+     * Turns the last process was still running when it stopped being able to
+     * finish them.
+     *
+     * `pending_approval` is the one window a turn can be picked up from, and
+     * it has its own sweep above. Everything else a turn does is saved as
+     * `running`: the provider call, the executor, and — on a provider that
+     * hosts its own loop — the approval wait too, since a hosted call is
+     * deliberately not checkpointed (`executeHostedToolCall` passes
+     * `recoverable: false`, because the SDK's inner loop is not something a
+     * restart can rebuild). None of those can be re-entered where they
+     * stopped, and nothing else sweeps them, so the record would go on
+     * claiming the turn is running for as long as the session exists. A turn
+     * whose caller gave it an idempotency key is continued from its
+     * transcript instead, with its dangling calls closed as interrupted
+     * (`settleAbandonedTurn`); the rest are failed.
+     *
+     * Note what this is *not* for. A graceful stop denies everything parked
+     * and drains the turns those denials release, so an operator restarting
+     * the daemon normally has nothing here. These are the turns a crash, a
+     * SIGKILL, or a lost machine left behind.
+     */
+    const listAbandonedTurns = async () => {
+        if (!store.listIdsByStatus) {
+            return [];
+        }
+        return store.listIdsByStatus('running');
+    };
+    /**
+     * Settles each of them — continued if keyed, otherwise marked failed with
+     * a reason that says what happened.
+     *
+     * Read BEFORE the channels start and applied after, which is the only
+     * ordering that is both honest and safe. Reading first means the list is
+     * exactly what the last process left, with no chance of a turn this
+     * process started being in it. Applying after means the failure is
+     * emitted into a gateway whose surfaces are listening, rather than into
+     * one where nothing is.
+     *
+     * The gap between the two is real, though: an inbound message for one of
+     * these sessions can arrive as soon as the channels are up. What makes
+     * that safe is single-flight — every writer of a session goes through
+     * `onSessionChain`, so this runs either wholly before that turn (it
+     * fails, and `resume()` then clears `lastError` and starts fresh) or
+     * wholly after it (the status has moved off `running`, and the re-read
+     * below leaves it alone). There is no interleaving in which this
+     * overwrites a live turn.
+     *
+     * What that invariant does NOT cover is a second daemon on the same
+     * database, whose turns are running with no chain of ours in front of
+     * them. Two processes sharing a session store is already unsupported —
+     * the parked sweep above would re-ask that daemon's approvals for the
+     * same reason — and no check here would make it supported.
+     */
+    const failAbandonedTurns = async (abandoned) => {
+        if (abandoned.length === 0) {
+            return;
+        }
+        log(`settling ${abandoned.length} turn(s) left running by the last stratusd`);
+        await Promise.allSettled(abandoned.map((id) => failAbandonedTurn(id)));
+    };
+    const failAbandonedTurn = (id) => onSessionChain(id, async () => {
+        if (isStopping()) {
+            return;
+        }
+        try {
+            const session = await store.get(id);
+            // Re-read on the chain, because the snapshot is from before the
+            // channels came up: a message that arrived since has already taken
+            // this session somewhere else, and that turn owns it now.
+            if (!session || session.status !== 'running') {
+                return;
+            }
+            await settleAbandonedTurn(session);
+        }
+        catch (error) {
+            warn(`could not settle abandoned turn ${id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    /**
+     * A turn left `running` with nothing running it, read on its chain.
+     *
+     * One whose message carries an idempotency key is a work item its caller
+     * was promised would finish, so it is continued from the transcript
+     * (`AgentRunner.continueTurn`) — once. A turn that already was, and is
+     * here again, took the last process down with it, and continuing it again
+     * would do the same on every start; it is failed like an unkeyed one,
+     * whose caller was never promised anything and is told to send again.
+     */
+    const settleAbandonedTurn = async (session) => {
+        const message = turnMessageOf(session);
+        if (message === undefined || turnKeyOf(message) === undefined) {
+            return failAbandoned(session);
+        }
+        // An answer already in the transcript is completed whatever came before
+        // — a second crash, a harness, an agent or provider gone since —
+        // because completing it needs none of them and runs nothing again;
+        // failing it would throw away a finished reply.
+        if (lastResponseIsAnswer(session)) {
+            log(`${session.id}: a keyed turn the last stratusd was running had saved its answer; completing it`);
+            return completeAnsweredTurn(session, store, bus);
+        }
+        if (message.continuedAfterCrash === true) {
+            return failAbandoned(session);
+        }
+        if (message.hostedLoop === true) {
+            log(`${session.id}: a keyed turn the last stratusd was running could reach a harness, which cannot be continued; failing it`);
+            return failAbandoned(session);
+        }
+        return continueAbandonedTurn(session);
+    };
+    const failAbandoned = async (session) => {
+        recordTurnFailure(session, ABANDONED_TURN_ERROR);
+        await store.save(session);
+        await bus.emit({ type: 'session.updated', sessionId: session.id, status: 'failed' });
+        await bus.emit({ type: 'session.failed', sessionId: session.id, error: ABANDONED_TURN_ERROR });
+        return session;
+    };
+    /**
+     * Continues an abandoned turn on the configuration a dispatch for its
+     * agent would resolve now, and under the same watchdog — it is a provider
+     * call like any turn's. The definition is refreshed and saved first, as
+     * `recoverOne` does and for the same reason: an allowlist is a permission
+     * boundary, and a tool dropped while the daemon was down must not run.
+     *
+     * Not on a harness (`runsOnHarness`) — neither one the turn could have
+     * run on (`Message.hostedLoop`, recorded when it was accepted) nor one it
+     * would continue on. A harness runs its own tool loop inside a single
+     * provider call and keeps its own conversation, so the prompt the dead
+     * turn sent may already have run tools there that the transcript never
+     * saw, and continuing would send it again. That turn is failed as an
+     * unkeyed one is — the same answer as before keys existed. (A turn whose
+     * answer is already saved never gets here: `settleAbandonedTurn`
+     * completes it first.)
+     */
+    const continueAbandonedTurn = async (session) => {
+        // Its parent's turn died with the last process, and continuing it here
+        // would run it as the full agent. (Sub-agent turns carry no key today,
+        // so this is a guard, not a path.)
+        if (isSubAgentSession(session)) {
+            return failAbandoned(session);
+        }
+        // Settled either way: a turn whose agent left the roster, or whose
+        // provider no longer resolves, must not stay `running` for every later
+        // start and every redelivery to find unfinished and trip over again.
+        let source;
+        let config;
+        try {
+            source = await refreshAgent(session.agent.id);
+            config = await runtimeForAgent(source);
+        }
+        catch (error) {
+            log(`${session.id}: a keyed turn the last stratusd was running cannot be continued (${error instanceof Error ? error.message : String(error)}); failing it`);
+            return failAbandoned(session);
+        }
+        const { switchedToFallback, effectiveStreams, fallbackStreams } = watchdogStreamsFor(session, config);
+        // The message's own record covers the runtimes the turn could have run
+        // on; this covers the ones it would continue on — a fallback included —
+        // which a changed config may make a harness.
+        if (reachesHarness(config, switchedToFallback)) {
+            log(`${session.id}: a keyed turn the last stratusd was running would continue on a harness; failing it`);
+            return failAbandoned(session);
+        }
+        log(`${session.id}: continuing a keyed turn the last stratusd was still running`);
+        session.agent = source.definition;
+        await store.save(session);
+        const runner = runnerFor(config, source.definition.id);
+        return onTurnRuntime(session.id, { source, config }, () => withWatchdog(session.id, undefined, effectiveStreams, fallbackStreams, async (signal) => await runner.continueTurn(session.id, {
+            runtime: runtimeContextFor(source, config, switchedToFallback, session.metadata),
+            signal,
+        }) ?? session));
+    };
+    /**
+     * A repeated idempotency key that reached the session's chain, so nothing
+     * else is running on the session. `undefined` means the key is new here
+     * and the dispatch runs as any other; otherwise this is the session to
+     * resolve with, and no new turn starts.
+     *
+     * An unfinished item here has no live turn — the live map would have
+     * answered first — so it is one the last process left, reached before
+     * the start-up sweep that would have settled it: settled now, the way
+     * that sweep would, which then finds it no longer needs anything.
+     */
+    const settleRepeat = async (sessionId, idempotencyKey, agentId, turnId, onRepeat) => {
+        const session = await store.get(sessionId);
+        if (session === undefined) {
+            return undefined;
+        }
+        // Before anything is returned: the turn a dispatch would run is refused
+        // for naming another agent, and the one it would repeat is no less that
+        // agent's — a repeat is not a way to read its transcript.
+        if (agentId !== undefined && session.agent.id !== agentId) {
+            throw crossIdentityError(sessionId, session.agent.id, agentId);
+        }
+        const state = workItemState(session, idempotencyKey);
+        if (state === undefined) {
+            const archived = await archivedRepeat(session, idempotencyKey);
+            if (archived !== undefined) {
+                onRepeat?.('finished');
+            }
+            return archived;
+        }
+        if (state === 'finished') {
+            onRepeat?.('finished');
+            return session;
+        }
+        // Run now, on this caller's behalf, so its events are this caller's
+        // turn — the adapter waiting on them has no other way to claim them.
+        if (turnId !== undefined) {
+            activeTurns.set(sessionId, turnId);
+        }
+        try {
+            return await settleUnfinished(session);
+        }
+        finally {
+            if (turnId !== undefined) {
+                activeTurns.delete(sessionId);
+            }
+        }
+    };
+    /**
+     * The archived transcript holding a key the live row does not, when the
+     * row is a rollover's fresh one made inside `ROLLOVER_REPEAT_WINDOW_MS`.
+     * Only the one rollover back: a second inside the window is a redelivery
+     * outliving two deliberate resets, and the chain is not walked for it.
+     * Always finished — a rollover refuses a session with a turn in flight.
+     */
+    const archivedRepeat = async (session, idempotencyKey) => {
+        const archivedAs = session.metadata?.[ROLLED_OVER_FROM_METADATA_KEY];
+        if (typeof archivedAs !== 'string' || Date.now() - Date.parse(session.createdAt) > ROLLOVER_REPEAT_WINDOW_MS) {
+            return undefined;
+        }
+        const archived = await store.get(archivedAs);
+        return archived !== undefined && workItemState(archived, idempotencyKey) !== undefined ? archived : undefined;
+    };
+    /** An unfinished item with no live turn, settled the way the start-up sweeps would. */
+    const settleUnfinished = async (session) => {
+        if (session.status === 'pending_approval') {
+            await recoverParked(session.id, getOrphanedAtStart().has(session.id));
+            return (await store.get(session.id)) ?? session;
+        }
+        return settleAbandonedTurn(session);
+    };
+    return {
+        recoverParkedTurns,
+        listOrphanedDelegations,
+        listAbandonedTurns,
+        failAbandonedTurns,
+        settleRepeat,
+        archivedRepeat,
+        settleUnfinished,
+    };
+};
+//# sourceMappingURL=recovery.js.map

package/dist/recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"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"}

package/dist/session-keys.d.ts

@@ -0,0 +1,101 @@
+import { type JsonObject, type Session } from '@stratusagent/core';
+/**
+ * Recorded on a turn the previous process was still running when it died.
+ *
+ * Exported because "distinguishable" is the whole point: a surface, a
+ * test, or an operator reading `lastError` has to be able to tell a turn
+ * nobody finished apart from one a provider or a tool actually failed, and
+ * matching on prose that lives in one place beats each caller inventing
+ * its own guess at the wording.
+ */
+export declare const ABANDONED_TURN_ERROR = "stratusd stopped while this turn was still running; it was not resumed. Send the message again.";
+/**
+ * The longest `DispatchInput.idempotencyKey` accepted. A platform message id
+ * is far shorter; the bound is so a key cannot be used to grow every row it
+ * is stored on.
+ */
+/**
+ * Recorded on a delegated sub-session that was parked on a human when the
+ * previous process died.
+ *
+ * Its parent — the turn whose `agent.delegate` call was awaiting the reply
+ * — was running, so the restart settles it as abandoned (above). Recovering
+ * the child anyway would re-ask a person to approve a call whose result no
+ * turn will ever read, and then run it: a command executed, tokens spent,
+ * and a reply delivered to nobody. Distinguishable from the parent's error
+ * because the remedy differs — there is no message to send again here;
+ * the parent's is the one to repeat.
+ */
+/**
+ * Session metadata keys the daemon writes for itself, which no external
+ * dispatch may supply.
+ *
+ * Metadata is one bag: the keys a channel attaches to say where a turn is
+ * happening sit beside the ones the kernel, the scheduler, the fallback
+ * wrapper, and `agent.delegate` write to remember what a session *is* —
+ * and the control API forwards a caller's `metadata` into a new session as
+ * given. A caller who can write `delegatedBy` can have the restart sweep
+ * fail its own parked turn as an orphan; one who can write `fallbackActive`
+ * bills its conversation to the fallback model from the first turn. The
+ * scheduler already refused to trust its own keys for exactly this reason
+ * (see `activeFirings`); the durable ones cannot be re-derived in memory,
+ * so they are refused at the door instead.
+ */
+/**
+ * A rolled-over session: the fresh row records where its predecessor's
+ * transcript went, and the archived row records which live id continues
+ * the conversation. See `Gateway.rolloverSession`.
+ */
+export declare const ROLLED_OVER_FROM_METADATA_KEY = "rolledOverFrom";
+export declare const ROLLED_OVER_TO_METADATA_KEY = "rolledOverTo";
+/** The segment a rollover mints into the archived transcript's id. */
+export declare const ROLLED_OVER_SESSION_ID_MARKER = ":rolledover:";
+/**
+ * How long after a rollover a repeated key is still looked for in the
+ * archived transcript. A rollover moves every keyed message out of the
+ * live row, so a redelivery arriving after one would otherwise read as a
+ * new message and run again. Platforms redeliver within minutes — Slack
+ * gives up after about five — and past the window the archive is not
+ * loaded at all, since every new message to the fresh row would pay for a
+ * read that can no longer find anything.
+ */
+export declare const ROLLOVER_REPEAT_WINDOW_MS: number;
+/**
+ * The one refusal for a dispatch naming an agent other than its session's.
+ * Its own type so a repeat attached to a claimant can tell the claimant was
+ * refused for who it named — the item then still has no owner — from the
+ * claimant's turn failing. Internal: callers read the message.
+ */
+export declare class CrossIdentityError extends Error {
+    constructor(sessionId: string, owner: string, claimed: string);
+}
+export declare const crossIdentityError: (sessionId: string, owner: string, claimed: string) => Error;
+/** Where the session's tool calls ran: `local-command`, or a contributed executor's registered name. */
+export declare const EXECUTOR_METADATA_KEY = "executor";
+/**
+ * Marks a sub-agent's session (roadmap 24). Reserved: it is what makes the
+ * daemon deny the session's gated calls without asking anyone, so a caller
+ * that could set it could also clear it.
+ */
+export declare const SUB_AGENT_METADATA_KEY = "subAgent";
+export declare const SUB_AGENT_SESSION_ID_MARKER = ":subagent:";
+/** How many sub-agents one parent turn runs at once unless the host says otherwise. */
+export declare const DEFAULT_SUB_AGENTS_PER_TURN = 4;
+export declare const isSubAgentSession: (session: Pick<Session, "id" | "metadata">) => boolean;
+/**
+ * Tools a sub-agent never gets, whatever its parent holds. `agent.spawn`
+ * would fan out inside a fan-out; `agent.delegate` runs a roster agent
+ * under that agent's own allowlist, which is the way out of a narrowed
+ * slice; `memory.*` would let it persist what nobody reviewed; and
+ * `credential.request` asks a person, which a sub-agent never does.
+ */
+export declare const subAgentNeverGets: (name: string) => boolean;
+export declare const RESERVED_SESSION_METADATA_KEYS: readonly string[];
+/**
+ * The first reserved key `metadata` carries, or undefined when it carries
+ * none. Exported so the control API can refuse the request where the
+ * caller can see it, with the same rule the gateway applies at dispatch.
+ */
+export declare const reservedSessionMetadataKey: (metadata: JsonObject | undefined) => string | undefined;
+export declare const ORPHANED_DELEGATION_ERROR = "stratusd stopped while the turn that delegated this one was still running; the delegation was not resumed. Send the original message again.";
+//# sourceMappingURL=session-keys.d.ts.map

package/dist/session-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-keys.d.ts","sourceRoot":"","sources":["../src/session-keys.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,UAAU,EAEf,KAAK,OAAO,EAGb,MAAM,oBAAoB,CAAC;AAY5B;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,oGACkE,CAAC;AAEpG;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH;;;;;;;;;;;;;;GAcG;AACH;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,mBAAmB,CAAC;AAC9D,eAAO,MAAM,2BAA2B,iBAAiB,CAAC;AAC1D,sEAAsE;AACtE,eAAO,MAAM,6BAA6B,iBAAiB,CAAC;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,QAAiB,CAAC;AAExD;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI9D;AAED,eAAO,MAAM,kBAAkB,GAAI,WAAW,MAAM,EAAE,OAAO,MAAM,EAAE,SAAS,MAAM,KAAG,KACpC,CAAC;AAEpD,wGAAwG;AACxG,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,aAAa,CAAC;AACjD,eAAO,MAAM,2BAA2B,eAAe,CAAC;AACxD,uFAAuF;AACvF,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,eAAO,MAAM,iBAAiB,GAAI,SAAS,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,UAAU,CAAC,KAAG,OAC2B,CAAC;AAE1G;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,OAIP,CAAC;AAE3C,eAAO,MAAM,8BAA8B,EAAE,SAAS,MAAM,EA8B3D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,GAAI,UAAU,UAAU,GAAG,SAAS,KAAG,MAAM,GAAG,SAGgB,CAAC;AAExG,eAAO,MAAM,yBAAyB,gJACyG,CAAC"}