agentfootprint 10.9.0 → 11.0.0

package/dist/hosting/answeredPause.js

@@ -0,0 +1,536 @@
+"use strict";
+/**
+ * hosting/answeredPause — a stored pause whose resume failed and may have used
+ * its decision: answered, with the outcome not known.
+ *
+ * Role:   the one owner of that state, for EVERY door that keeps a paused run
+ *         (`standingAgent`, `streamHandler`). Once a resume's decision may have
+ *         reached the ledger the call may have run, so a failure — in the run,
+ *         or in storing its result — must stop the pause being offered for an
+ *         answer: a retry, a rebuilt instance, a restart or another host on the
+ *         same store would answer it again. The conversation must still be able
+ *         to go on.
+ *
+ *           readStoredSession   the one reading of a stored session: an
+ *                               answered pause is a conversation to
+ *                               continue, never a pause to answer
+ *           listedFormatOf      the same reading for a session listing
+ *           answeredRefusal     what an answer to it is refused with
+ *           watchAnswer         opened before a door hands an answer over
+ *           afterFailedAnswer   the one step after that answer's resume failed
+ *           unanswerablePause   a pause no answer can reach any more, and
+ *           closedConversation  the conversation it goes on from
+ *
+ * ── MARKED WHEN ITS DECISION MAY HAVE BEEN USED ─────────────────────────────
+ * The call may have run only if the decision reached a ledger, and
+ * `spendDecision` is the one place it does — so a door asks the watch it
+ * opened before handing the answer over (`core/consentRequest.ts` ·
+ * `watchDecisionUse`). Spent, refused as spent already, still unanswered, or a
+ * failed spend its ledger cannot say never landed: marked. Taken up by this
+ * library and never taken to a ledger — refused, or aborted before the spend:
+ * the pause stays answerable. Never taken up at all: marked, because that
+ * cannot be told apart from a use. What an error calls itself proves nothing,
+ * and nothing is read from the decision object for it, which a door may copy
+ * or wrap on its way to the resume.
+ *
+ * ── A PAUSE NO ANSWER CAN REACH IS CLOSED, NOT HELD ─────────────────────────
+ * A consent pause that recorded no request (stored before requests were
+ * named), whose call changed after the ask, or an ask made under rules the
+ * resuming agent no longer runs (a redeploy) can never be answered — every
+ * decision is refused. Held, it would hold the session for good. So a door
+ * closes it: the next message continues the conversation with the calls it
+ * left open settled, and a decision refused for one of those reasons — having
+ * used nothing — closes it too, when its question names the request it asked
+ * (one stored before requests were named names none: the next message closes
+ * that one).
+ *
+ * ── "DID NOT RUN" ONLY ON PROOF ─────────────────────────────────────────────
+ * A pause that still says it is waiting is no proof its call never ran: a
+ * resume can spend the decision, run the call, fail, and fail again to mark
+ * the pause answered — and a redeploy can then make it a pause no answer can
+ * reach. So a closed pause's open calls are settled as not run
+ * ({@link NOT_RUN_UNANSWERABLE}) only when the ledger the request was minted
+ * under — the serving agent's, and only that one — spends the request itself
+ * (`consentRequest.ts` · `proveNeverRan`): atomic, and it consumes the request
+ * so no later resume can run the call. Otherwise, and whenever that proof
+ * cannot be had, as possibly run ({@link OUTCOME_UNKNOWN_UNANSWERABLE}: do not
+ * run it again, ask the person). A false "may have run" is the safe
+ * direction: a model told a refund did not run may issue it again.
+ *
+ * Reads:  the stored session — never the runner's own state, which on a
+ *         shared agent may be another session's run, or a run that never
+ *         started.
+ * Writes: the marked pause, through the door's session store.
+ *
+ * ── WHY THE OPEN CALLS ARE SETTLED ─────────────────────────────────────────
+ * A conversation whose last assistant turn holds a tool call with no result
+ * cannot be continued: a provider refuses the next request. So every call left
+ * open gets the host's notice ({@link OUTCOME_NOT_RECORDED}) — never a result,
+ * because the host kept none and whether the call ran is not known. When the
+ * run kept this session's conversation while it ran (a durable writer), that
+ * is what goes on, its recorded results included.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settleOpenCalls = exports.openToolCalls = exports.markAnswered = exports.OUTCOME_NOT_RECORDED = exports.closedConversation = exports.unanswerablePause = exports.OUTCOME_UNKNOWN_UNANSWERABLE = exports.NOT_RUN_UNANSWERABLE = exports.afterFailedAnswer = exports.watchAnswer = exports.answeredRefusal = exports.listedFormatOfRow = exports.listedFormatOf = exports.readStoredSession = void 0;
+const checkin_js_1 = require("../core/checkin.js");
+const consentRequest_js_1 = require("../core/consentRequest.js");
+const pause_js_1 = require("../core/pause.js");
+const envelope_js_1 = require("./envelope.js");
+const processLocalStore_js_1 = require("./processLocalStore.js");
+/**
+ * Read a stored session the way every door must: a pause still waiting is
+ * offered for an answer; an ANSWERED pause is the conversation the next
+ * message continues and is never offered again; a conversation is a
+ * conversation. Throws as the envelope readers do on a format this runtime
+ * cannot read.
+ */
+function readStoredSession(stored) {
+    if (stored.format !== 'flowchart-v1')
+        return { prior: (0, envelope_js_1.readEnvelope)(stored) };
+    const paused = (0, envelope_js_1.readPausedRun)(stored);
+    return paused.answered === undefined
+        ? { waiting: paused }
+        : { prior: paused.conversation, answered: paused };
+}
+exports.readStoredSession = readStoredSession;
+/**
+ * The format a session LISTING reports for a stored envelope
+ * (`SessionSummary.format`): `'flowchart-v1'` only for a pause still waiting
+ * on somebody's answer — the one a door would offer for an answer — and
+ * `'conversation-v1'` for a conversation, an answered pause
+ * (`PausedRun.answered`) and a pause no answer can reach any more
+ * ({@link unanswerablePause}, as far as the stored checkpoint can tell).
+ *
+ * The one reading for every store that lists, so a sidebar never badges a
+ * pause the doors would not offer for an answer as "awaiting you". A store
+ * that keeps the format in a column or a field writes this when it persists,
+ * and reads a row that still says `'flowchart-v1'` again when it lists
+ * ({@link listedFormatOfRow}); one that reads its envelopes at list time calls
+ * it there. The envelope itself is unchanged: `hydrate` hands back what was
+ * stored.
+ *
+ * Lenient, as a listing must be — it never throws. A value that is not an
+ * envelope lists as `'unknown'`, and a pause the readers would refuse lists
+ * as stored, so `hydrate` refuses it by name. An ask whose later rules a
+ * redeploy changed is told by the serving agent, not by the stored pause: it
+ * lists as waiting until a door closes it.
+ *
+ * @example
+ *   // A store's listByUser — or its persist, when the format is a column:
+ *   const format = listedFormatOf(envelope);
+ */
+function listedFormatOf(envelope) {
+    const format = typeof envelope === 'object' && envelope !== null
+        ? envelope.format
+        : undefined;
+    if (typeof format !== 'string')
+        return 'unknown';
+    if (format !== 'flowchart-v1')
+        return format;
+    try {
+        const { waiting } = readStoredSession(envelope);
+        return waiting !== undefined && unanswerablePause(waiting) === undefined
+            ? format
+            : 'conversation-v1';
+    }
+    catch {
+        return format;
+    }
+}
+exports.listedFormatOf = listedFormatOf;
+/**
+ * The listed format of a row that KEEPS one beside its envelope (a SQLite
+ * column, a Firestore field): what the row says — except a stored
+ * `'flowchart-v1'`, which is read again from the envelope ({@link listedFormatOf}).
+ *
+ * A row written before the kept format was the listed one (an earlier
+ * release, or an older replica still writing) holds the envelope's own
+ * format, so a pause stored then says `'flowchart-v1'` whether or not anyone
+ * can still answer it. Only that value can be stale: a row that says
+ * anything else is not a pause still waiting, and nothing makes it one
+ * without a write. Never throws — text this runtime cannot read keeps what
+ * the row says (`hydrate` refuses it by name).
+ *
+ * @param stored       the format the row keeps.
+ * @param envelopeJson the envelope stored beside it, as JSON text.
+ */
+function listedFormatOfRow(stored, envelopeJson) {
+    if (stored !== 'flowchart-v1' || typeof envelopeJson !== 'string')
+        return stored;
+    let envelope;
+    try {
+        envelope = JSON.parse(envelopeJson);
+    }
+    catch {
+        return stored;
+    }
+    const listed = listedFormatOf(envelope);
+    return listed === 'unknown' ? stored : listed;
+}
+exports.listedFormatOfRow = listedFormatOfRow;
+/**
+ * What an answer to an answered pause is refused with: `'already-answered'`,
+ * whose message says the earlier resume's outcome is not known here.
+ */
+function answeredRefusal(answered) {
+    return new pause_js_1.ResumeDecisionError('already-answered', answered.pending.ask !== undefined ? 'ask' : 'checkIn');
+}
+exports.answeredRefusal = answeredRefusal;
+/** The request a stored consent pause asked, by id — `undefined` for any other pause. */
+function askedRequestOf(paused) {
+    return paused.pending.checkIn?.id ?? paused.pending.ask?.id;
+}
+/**
+ * The watch a door opens BEFORE it hands an answer to its runner, and releases
+ * once {@link afterFailedAnswer} has decided — `undefined` for a pause no
+ * decision answers. Keyed by the pause's request, never by the answer object.
+ */
+function watchAnswer(paused) {
+    const asked = askedRequestOf(paused);
+    return asked === undefined ? undefined : (0, consentRequest_js_1.watchDecisionUse)(asked);
+}
+exports.watchAnswer = watchAnswer;
+/**
+ * After a resume of a consent gate — or what followed it, storing its result
+ * included — FAILED, at any door that keeps the pause: when the watch says
+ * its decision may have been used (`DecisionUseWatch.mayHaveBeenUsed`),
+ * persist the pause marked answered; otherwise nothing of it was used and the
+ * pause stays answerable.
+ *
+ * Read first, to leave alone what must not be overwritten — but only when the
+ * read SUCCEEDS: a newer pause the run stored before the failure (this pause
+ * is gone, and a decision for it is refused as another request's) or a mark
+ * already there. A store that cannot be read, or holds what this runtime
+ * cannot read, is marked anyway: failing to read is no proof the decision was
+ * unused. A store that holds NOTHING is left so — the session expired or was
+ * forgotten while the answer ran, and a mark would bring it back. The
+ * conversation the mark goes on from is what the run kept for this session (a
+ * durable writer's conversation) when the read shows one, else the
+ * conversation as of the pause — never the runner's own state, which on a
+ * shared agent may be another session's run.
+ *
+ * A declined decision never runs its call — but a decline is recorded only
+ * when it is what the ledger spent: when the answer that failed was a decline
+ * AND the watch saw the request spent for a decline, with no approval taken
+ * to a ledger (`DecisionUseWatch.spentAsDecline`), the paused call is
+ * settled as declined. A decline refused because the request was already
+ * spent — an approval, here or in another process, may have run the call —
+ * is settled as unknown, like any other.
+ *
+ * Unused, and refused for a reason no decision can change (`error` is a
+ * `'request-not-recorded'`, `'call-changed'`, `'chain-changed'` or
+ * `'ledger-changed'` refusal):
+ * the pause is CLOSED instead — it could only ever hold the session. Read
+ * from the refusal's own code, which is safe only because THIS resume used
+ * nothing. An earlier one may have — a resume that ran the call and then
+ * could not mark the pause answered — so the calls it leaves open are
+ * recorded as not run only on proof ({@link closedConversation}, asked of
+ * `runner`'s ledger), else as not known.
+ *
+ * Only a failure of the WRITE itself is swallowed — the run's failure is the
+ * one the caller is told, and the ledger still refuses the decision in this
+ * process — and it is reported on the console, never silent.
+ *
+ * @param watch  the door's {@link watchAnswer}, opened before the resume.
+ * @param answer the answer as the door handed it over — read only to tell a
+ *   decline, and only from its own data properties.
+ * @param settle writes still in flight for this session (a durable writer),
+ *   drained first so none lands on top of the mark.
+ * @param runner the runner the answer was handed to — whose ledger can prove
+ *   that a closed pause's calls never ran.
+ */
+async function afterFailedAnswer(input) {
+    const { store, sessionId, paused, watch } = input;
+    const asked = askedRequestOf(paused);
+    // Only a consent gate's pause is answered by a decision.
+    if (asked === undefined || watch === undefined)
+        return 'kept';
+    if (!(await watch.mayHaveBeenUsed())) {
+        const reason = unanswerableRefusalOf(input.error);
+        return reason === undefined ? 'kept' : closeUnanswerable(store, sessionId, asked, input.runner);
+    }
+    // A request a host already closed with the proof that its call never ran —
+    // its closed conversation stored nowhere (the write, or the run after it,
+    // failed): closed again here as not run, never marked as possibly run. Read
+    // from the ledger's close marker, never from what the error calls itself.
+    if (await (0, consentRequest_js_1.closedByAHost)(neverRanQuestion(paused, { runner: input.runner, store }))) {
+        return closeUnanswerable(store, sessionId, asked, input.runner);
+    }
+    try {
+        await input.settle?.();
+    }
+    catch {
+        // a write that would not drain does not stop the mark
+    }
+    let current;
+    try {
+        current = await store.hydrate(sessionId);
+    }
+    catch {
+        current = UNREAD; // marked from the pause's own conversation
+    }
+    if (current === undefined)
+        return 'kept';
+    let kept;
+    if (current !== UNREAD) {
+        try {
+            if (current.format === 'conversation-v1') {
+                kept = (0, envelope_js_1.readEnvelope)(current);
+            }
+            else {
+                const stored = (0, envelope_js_1.readPausedRun)(current);
+                if (stored.answered !== undefined || askedRequestOf(stored) !== asked)
+                    return 'kept';
+            }
+        }
+        catch {
+            kept = undefined; // what the store holds cannot be read — marked anyway
+        }
+    }
+    try {
+        await store.persist(sessionId, (0, envelope_js_1.toPausedEnvelope)(markAnswered(paused, kept, Date.now(), watch.spentAsDecline() ? declinedCallOf(paused, input.answer) : undefined)));
+        return 'marked';
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.warn('[hosting] a paused request whose decision may have been used could not be marked ' +
+            "answered in the session store; only this process's ledger refuses that decision " +
+            '— give every process one shared decisionLedger. Store error:', err instanceof Error ? err.name : typeof err);
+        return 'kept';
+    }
+}
+exports.afterFailedAnswer = afterFailedAnswer;
+/** A read of the store that threw — told apart from a store that holds nothing. */
+const UNREAD = Symbol('unread');
+/** The reason a refusal no decision can change names, read from its code and reason. */
+function unanswerableRefusalOf(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const { code, reason } = error;
+    return code === 'ERR_RESUME_DECISION' &&
+        (reason === 'request-not-recorded' ||
+            reason === 'call-changed' ||
+            reason === 'chain-changed' ||
+            reason === 'ledger-changed')
+        ? reason
+        : undefined;
+}
+/**
+ * Close the stored pause for `asked` — only over that same pause, still
+ * waiting, read back from the store: never over a newer pause, a mark, or a
+ * store that cannot be read. A store that refuses the write leaves it held,
+ * and that is said on the console.
+ */
+async function closeUnanswerable(store, sessionId, asked, runner) {
+    let stored;
+    try {
+        const current = await store.hydrate(sessionId);
+        if (current === undefined || current.format !== 'flowchart-v1')
+            return 'kept';
+        stored = (0, envelope_js_1.readPausedRun)(current);
+    }
+    catch {
+        return 'kept';
+    }
+    if (stored.answered !== undefined || askedRequestOf(stored) !== asked)
+        return 'kept';
+    try {
+        await store.persist(sessionId, (0, envelope_js_1.toEnvelope)(await closedConversation(stored, { runner, store })));
+        return 'closed';
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.warn('[hosting] a paused request no decision can answer could not be closed in the session ' +
+            'store; the session keeps refusing new messages until it is. Store error:', err instanceof Error ? err.name : typeof err);
+        return 'kept';
+    }
+}
+/**
+ * What the model reads for a call whose question no answer can reach any more
+ * — its pause was closed, and the call PROVABLY did not run: the ledger its
+ * request was minted under spent the request itself, so no decision for it
+ * had been handed over and none ever can be (`consentRequest.ts` ·
+ * `proveNeverRan`).
+ */
+exports.NOT_RUN_UNANSWERABLE = 'That call did not run: the question it waited on could no longer be answered.';
+/** What every notice whose call may have run ends with: what to do about it. */
+const ASK_THE_PERSON = 'Tell the person it may already have happened and ask them to check.';
+/**
+ * What the model reads for each call a pause no answer can reach left open,
+ * when it cannot be proven that the call never ran: a decision for the pause
+ * may have been used — by a resume whose failure the host could not record —
+ * so the call may have run. Never "did not run" without proof, and never an
+ * invitation to try again: a model told a refund did not run may issue it
+ * again. The same words for every open call — the paused one and a sibling
+ * that never needed an approval alike — so none of them names an approval.
+ */
+exports.OUTCOME_UNKNOWN_UNANSWERABLE = `This call may have run; no result was kept. Do not run it again. ${ASK_THE_PERSON}`;
+/**
+ * Why the stored pause can never be answered by `runner` — `undefined` when it
+ * can, or when that cannot be told (`core/consentRequest.ts` ·
+ * `unanswerableReason`). Without a runner, or with one whose rules and
+ * ledger a host cannot see (a composition, an app's own), an ask's chain and
+ * the ledger binding (`'ledger-changed'`) are not checked.
+ */
+function unanswerablePause(paused, runner) {
+    let gate;
+    try {
+        gate = (0, pause_js_1.pauseDemandsDecision)(paused.checkpoint.pauseData);
+    }
+    catch {
+        return undefined;
+    }
+    if (gate === undefined)
+        return undefined;
+    return (0, consentRequest_js_1.unanswerableReason)(paused.checkpoint, gate.kind, (0, consentRequest_js_1.consentRulesOf)(runner), (0, consentRequest_js_1.consentLedgerOf)(runner));
+}
+exports.unanswerablePause = unanswerablePause;
+/**
+ * The conversation a pause no answer can reach goes on from: every call it
+ * left open settled by the host's notice — none of them can run from here.
+ *
+ * "Did not run" ({@link NOT_RUN_UNANSWERABLE}) ONLY when non-execution is
+ * proven: the ledger the request was minted under — the serving agent's,
+ * and only when it is the same one — spends the request itself, atomically
+ * (`consentRequest.ts` · `proveNeverRan`). That both proves no decision had
+ * reached it and makes sure none ever will: closing CONSUMES the request. The
+ * record alone cannot say it — a resume may have run the call and then failed
+ * to mark the stored pause answered, before a redeploy made the pause one no
+ * answer can reach. Otherwise, and whenever the proof cannot be had, every
+ * open call is recorded as possibly run ({@link OUTCOME_UNKNOWN_UNANSWERABLE}).
+ * Every notice is marked as the library's (`toolResultOrigin`).
+ */
+async function closedConversation(paused, door = {}) {
+    const { history } = paused.conversation;
+    const neverRan = await (0, consentRequest_js_1.proveNeverRan)(neverRanQuestion(paused, door));
+    return {
+        ...paused.conversation,
+        history: [
+            ...history,
+            ...openToolCalls(history).map((call) => neverRan
+                ? noticeFor(call, exports.NOT_RUN_UNANSWERABLE, 'not-entered')
+                : noticeFor(call, exports.OUTCOME_UNKNOWN_UNANSWERABLE, 'outcome-unknown')),
+        ],
+    };
+}
+exports.closedConversation = closedConversation;
+/** What the proof asks about `paused`, closed by `door`. */
+function neverRanQuestion(paused, door) {
+    return {
+        requestIds: requestIdsOf(paused),
+        mintedUnder: (0, consentRequest_js_1.pausedRequestLedgerOf)(paused.checkpoint),
+        runner: door.runner,
+        storeIsProcessLocal: (0, processLocalStore_js_1.isProcessLocalStore)(door.store),
+    };
+}
+/**
+ * Every id the stored pause knows its request by — the question's and the
+ * paused state's — once each. Empty for a pause that names none (one stored
+ * before requests were named), which no ledger can answer for.
+ */
+function requestIdsOf(paused) {
+    const ids = [askedRequestOf(paused), (0, consentRequest_js_1.pausedRequestIdOf)(paused.checkpoint)];
+    return [...new Set(ids.filter((id) => typeof id === 'string' && id.length > 0))];
+}
+/**
+ * The paused call, when the answer that failed declined it: `approved` is
+ * `false`, read from the answer's own data — a getter is never invoked. Asked
+ * only once the watch says a decline is what the ledger spent.
+ */
+function declinedCallOf(paused, answer) {
+    if (typeof answer !== 'object' || answer === null)
+        return undefined;
+    const toolCallId = (0, consentRequest_js_1.pausedCallIdOf)(paused.checkpoint);
+    if (toolCallId === undefined || ownData(answer, 'approved') !== false)
+        return undefined;
+    const note = ownData(answer, 'note');
+    return { toolCallId, ...(typeof note === 'string' && note.length > 0 && { note }) };
+}
+/** `record[key]` when it is an own DATA property — never a getter's answer. */
+function ownData(record, key) {
+    try {
+        const field = Object.getOwnPropertyDescriptor(record, key);
+        return field !== undefined && 'value' in field ? field.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * What the model reads for a call the run left open: a past fact about that
+ * call, and a notice rather than its result.
+ */
+exports.OUTCOME_NOT_RECORDED = 'No result was kept for that call: the run that took it up stopped before it finished, so ' +
+    `whether it ran is not known. ${ASK_THE_PERSON}`;
+/**
+ * The stored pause, marked answered: a decision for it is refused from here
+ * on, and the conversation it goes on from has every call left open settled
+ * as unknown — the call a person declined, as declined: it did not run.
+ *
+ * @param progressed this session's conversation as the run kept it, or
+ *   `undefined` to go on from the conversation as of the pause.
+ * @param declined the paused call, when the answer declined it.
+ */
+function markAnswered(paused, progressed, now = Date.now(), declined) {
+    const conversation = progressed ?? paused.conversation;
+    return {
+        ...paused,
+        conversation: {
+            ...conversation,
+            history: settleOpenCalls(conversation.history, declined),
+        },
+        answered: { at: now },
+    };
+}
+exports.markAnswered = markAnswered;
+/**
+ * The tool calls in `history` that no tool message answered, in the order the
+ * model made them.
+ */
+function openToolCalls(history) {
+    const open = new Map();
+    for (const message of history) {
+        if (message.role === 'tool' && message.toolCallId !== undefined)
+            open.delete(message.toolCallId);
+        if (message.role === 'assistant') {
+            for (const call of message.toolCalls ?? [])
+                open.set(call.id, { id: call.id, name: call.name });
+        }
+    }
+    return [...open.values()];
+}
+exports.openToolCalls = openToolCalls;
+/**
+ * `history` with every open tool call settled by the host's notice — the same
+ * history when none is open. Each notice is marked as the library's
+ * (`toolResultOrigin`: `'outcome-unknown'`, or `'not-entered'` for a declined
+ * call), whether or not the run served findings.
+ *
+ * @param declined the call a person declined, settled as declined — the
+ *   result the dispatch loop records for a decline — instead of as unknown.
+ */
+function settleOpenCalls(history, declined) {
+    return [
+        ...history,
+        ...openToolCalls(history).map((call) => call.id === declined?.toolCallId
+            ? noticeFor(call, (0, checkin_js_1.declinedResult)(declined.note), 'not-entered')
+            : noticeFor(call, exports.OUTCOME_NOT_RECORDED, 'outcome-unknown')),
+    ];
+}
+exports.settleOpenCalls = settleOpenCalls;
+/**
+ * The host's notice for an open call — never its result — always marked as
+ * the library's (`toolResultOrigin`): a reader tells it from a result by the
+ * marker, never by its words. The marker never reaches a provider
+ * (`stripFrameworkFields`).
+ */
+function noticeFor(call, content, origin) {
+    return {
+        role: 'tool',
+        toolName: call.name,
+        toolCallId: call.id,
+        toolResultOrigin: origin,
+        content,
+    };
+}
+//# sourceMappingURL=answeredPause.js.map

package/dist/hosting/answeredPause.js.map

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

package/dist/hosting/conformance/cases.js

@@ -43,6 +43,34 @@ function textOf(envelope) {
     const first = history[0];
     return typeof first?.content === 'string' ? first.content : undefined;
 }
+/**
+ * A stored PAUSE around one of the kit's conversations: still waiting on a
+ * person, or — with `answeredAt` — marked answered, which is what a door
+ * writes when a resume may have used the pause's decision
+ * (`PausedRun.answered`). Its `savedAt` is the conversation's.
+ *
+ * The checkpoint carries only what a reader validates (`checkEnvelope`): the
+ * engine's other halves are not a store's business, which is why the shape is
+ * asserted rather than typed.
+ */
+function pausedEnvelope(conversation, answeredAt) {
+    return {
+        format: 'flowchart-v1',
+        savedAt: conversation.savedAt,
+        data: {
+            checkpoint: { pausedStageId: 'ask-a-person', sharedState: {}, subflowPath: [] },
+            conversation: conversation.data,
+            pending: { question: 'Go ahead?', pauseData: { question: 'Go ahead?' } },
+            ...(answeredAt !== undefined && { answered: { at: answeredAt } }),
+        },
+    };
+}
+/** The `answered` mark a stored pause carries, read the way a door reads it. */
+function answeredMarkOf(envelope) {
+    return envelope === undefined ? undefined : (0, envelope_js_1.readPausedRun)(envelope).answered?.at;
+}
+/** When the conformance cases mark a pause answered. */
+const MARKED_AT = 1_700_000_500_000;
 /** Read every page of a listing, so a paging bug shows up as a wrong SET. */
 async function allPages(store, userId, limit) {
     const ids = [];
@@ -98,6 +126,27 @@ const roundTrip = {
             'conversation at one exchange.');
     },
 };
+const answeredPauseRoundTrip = {
+    name: 'answered-pause-round-trips',
+    law: 'A stored pause comes back as it went in — still waiting, or with the `answered` mark a door wrote over it.',
+    async run(store, kit) {
+        const id = kit.id('answered');
+        const conversation = kit.envelope('approve the refund?', 'alice');
+        // The door's own sequence: the pause is stored, and later marked.
+        await store.persist(id, pausedEnvelope(conversation));
+        const waiting = await store.hydrate(id);
+        check(waiting?.format === 'flowchart-v1' && answeredMarkOf(waiting) === undefined, `a stored pause came back as format='${String(waiting?.format)}' with answered mark ` +
+            `${JSON.stringify(answeredMarkOf(waiting))}. A pause still waiting on a person has to ` +
+            `come back as one, and with no mark nobody wrote — a mark there hides the question.`);
+        await store.persist(id, pausedEnvelope(conversation, MARKED_AT));
+        const marked = await store.hydrate(id);
+        check(marked?.format === 'flowchart-v1' && answeredMarkOf(marked) === MARKED_AT, `the \`answered\` mark did not survive the round trip (came back as ` +
+            `${JSON.stringify(answeredMarkOf(marked))}). A door marks a pause answered when a ` +
+            `resume may have used its decision, so the call may have run. A store that drops the ` +
+            `mark offers that request for an answer again — a retry, a restart or another host ` +
+            `would answer it twice.`);
+    },
+};
 const unreadableIsNotAbsent = {
     name: 'unreadable-is-not-absent',
     law: 'A stored conversation this runtime cannot read is never answered as absent.',
@@ -385,6 +434,35 @@ const listNewestFirst = {
         }
     },
 };
+const listAnsweredAsConversation = {
+    name: 'list-by-user-shows-an-answered-pause-as-a-conversation',
+    law: 'A listing reports `flowchart-v1` only for a pause still waiting on an answer; an answered pause lists as `conversation-v1`, like a finished turn.',
+    members: ['listByUser'],
+    async run(store, kit) {
+        const at = 1_700_000_000_000;
+        const waiting = kit.id('still-waiting');
+        const answered = kit.id('answered');
+        const finished = kit.id('finished');
+        await store.persist(waiting, pausedEnvelope(kit.envelope('still waiting', 'alice', at)));
+        // Stored as a pause first, then marked — so a store that writes the
+        // listed format when it persists has to write it again.
+        await store.persist(answered, pausedEnvelope(kit.envelope('answered', 'alice', at + 1)));
+        await store.persist(answered, pausedEnvelope(kit.envelope('answered', 'alice', at + 2), MARKED_AT));
+        await store.persist(finished, kit.envelope('finished', 'alice', at + 3));
+        const { pages } = await allPages(store, 'alice', 10);
+        const listed = new Map(pages.flatMap((page) => page.sessions).map((row) => [row.sessionId, row.format]));
+        check(listed.get(waiting) === 'flowchart-v1', `a pause still waiting on a person was listed as ` +
+            `${JSON.stringify(listed.get(waiting))}. 'flowchart-v1' is what a sidebar badges ` +
+            `"awaiting you" — the one row it must not miss.`);
+        check(listed.get(answered) === 'conversation-v1', `an ANSWERED pause was listed as ${JSON.stringify(listed.get(answered))}. A resume ` +
+            `already used its decision and no door offers it for an answer again, so a sidebar ` +
+            `that badges it "awaiting you" shows a question nobody can answer. List it as ` +
+            `'conversation-v1' — \`listedFormatOf(envelope)\` from 'agentfootprint/hosting' is the ` +
+            `one reading, at persist for a store that keeps the format in a column (and again at ` +
+            `list time for a row that still says 'flowchart-v1'), else at list time.`);
+        check(listed.get(finished) === 'conversation-v1', `a finished conversation was listed as ${JSON.stringify(listed.get(finished))}.`);
+    },
+};
 /** Long enough to cross any plausible key-length ceiling. */
 const PAST_ANY_CEILING = 1000;
 const FOLD_PAIRS = [
@@ -651,6 +729,7 @@ const featureDetected = {
 exports.sessionLifecycleConformance = [
     absentHydratesUndefined,
     roundTrip,
+    answeredPauseRoundTrip,
     unreadableIsNotAbsent,
     forgetRemoves,
     ownershipDerived,
@@ -661,6 +740,7 @@ exports.sessionLifecycleConformance = [
     ownerOfAmbiguity,
     listPages,
     listNewestFirst,
+    listAnsweredAsConversation,
     handedBackIdIsNotASecondAddress,
     awkwardIds,
     retentionHonesty,