@feasibleone/blong-gogo 1.35.0 → 1.37.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [1.37.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.36.0...blong-gogo-v1.37.0) (2026-09-26)
+
+
+### Features
+
+* progress points in test reports ([fb73036](https://github.com/feasibleone/blong/commit/fb730360877eb371ab3d1603ae7bf35976c170dc))
+
+
+### Bug Fixes
+
+* chain dynamic import ([7db222f](https://github.com/feasibleone/blong/commit/7db222f0a6469b624fa1935027f63b0593585ee6))
+* misc CI failures ([950289d](https://github.com/feasibleone/blong/commit/950289d65e6187d10658dd0fd76361bd4d3d56e8))
+
+## [1.36.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.35.0...blong-gogo-v1.36.0) (2026-09-24)
+
+
+### Features
+
+* add from property to leg ([4925e76](https://github.com/feasibleone/blong/commit/4925e76a7d69000e83804cd9a5fa1ea58ab26d81))
+* docs screenshots and diagrams ([65e37d9](https://github.com/feasibleone/blong/commit/65e37d93ef3e71d65b340541e14b50a25f14e3c8))
+* sequence diagram progress points ([dc5b153](https://github.com/feasibleone/blong/commit/dc5b15327f31698a26a75ec73bdf9a0956a43dd9))
+
+
+### Bug Fixes
+
+* build errors ([145a424](https://github.com/feasibleone/blong/commit/145a424ffc2dc4dfc14801f1002c7fa1e7a543ce))
+
 ## [1.35.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.34.0...blong-gogo-v1.35.0) (2026-09-21)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.35.0",
+  "version": "1.37.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
@@ -20,7 +20,6 @@
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
-    "@modelcontextprotocol/sdk": "^1.0.0",
     "@aws-sdk/client-s3": "^3.1037.0",
     "@fastify/basic-auth": "^6.2.0",
     "@fastify/bearer-auth": "^10.1.2",
@@ -33,6 +32,7 @@
     "@fastify/swagger-ui": "^5.2.5",
     "@fastify/type-provider-typebox": "^6.1.0",
     "@feasibleone/blong": "^1.0.0",
+    "@feasibleone/blong-allure": "^1.0.0",
     "@feasibleone/blong-chain": "^1.0.0",
     "@feasibleone/blong-config": "^1.0.0",
     "@feasibleone/blong-lib": "^1.0.0",
@@ -41,6 +41,7 @@
     "@feasibleone/semantic-log": "^1.0.0",
     "@keycloak/keycloak-admin-client": "^26.6.2",
     "@kubernetes/client-node": "^1.4.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
     "@octokit/rest": "^22.0.1",
     "@sinclair/typebox-codegen": "^0.11.1",
     "@slack/webhook": "^7.0.7",
@@ -91,7 +92,7 @@
     "tap": "^21.6.3",
     "typescript": "^6.0.3",
     "vite": "^8.2.1",
-    "@feasibleone/blong-dev": "1.5.0"
+    "@feasibleone/blong-dev": "1.7.0"
   },
   "scripts": {
     "browser-check": "node scripts/browser-compat-check.mjs",

package/src/AdapterBase.ts

@@ -15,7 +15,14 @@ import PQueue from 'p-queue';
 import ConfigRuntime from './ConfigRuntime.ts';
 import {isExpectedError, portLogCalls} from './lib.ts';
 import loop from './loop.ts';
-import {adoptInbound, inboundIdentities, isFlowId} from './semanticContext.ts';
+import {
+    adoptInbound,
+    attachProgress,
+    beginProgress,
+    inboundIdentities,
+    isFlowId,
+    takeProgress,
+} from './semanticContext.ts';
 
 const errorMap: IErrorMap = {
     'adapter.configValidation': 'Adapter config validation:\r\n{message}',
@@ -376,15 +383,36 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
             // leg that arrived: that is what turns the caller's declaration into a receipt
             // the ledger can match, and it happens only when a flow was traced at all, so an
             // untraced request still pays nothing.
-            const answered = (): unknown => {
+            const answered = async (): Promise<unknown> => {
                 const inbound = inboundIdentities($meta as IMeta);
-                if (isFlowId(inbound.flow) && inbound.leg !== undefined) {
+                const traced = isFlowId(inbound.flow) && inbound.leg !== undefined;
+                if (traced) {
                     // The receipt is the receiver's record for the leg it was handed. It carries
                     // no declared target - the caller named the ends - so the ledger can tell a
                     // receipt from a declaration by the leg alone, in one process or many.
-                    portLogCalls(this)?.received(inbound.leg);
+                    portLogCalls(this)?.received(inbound.leg as string);
+                    // And the collection starts *before* the handler runs, because the boxes it will
+                    // read are installed with `enterWith`: one created after the handler's first wait
+                    // never reaches the frame that answers for the call (T-136).
+                    beginProgress();
                 }
-                return run();
+                const result = await run();
+                // What the handler announced while it ran (`$meta.checkpoint`, `$meta.decide`) is
+                // staged in the scope around it and written on no record of its own: the records
+                // of a call are the framework's, written before the handler starts and after it
+                // returns. Reading the progress here — inside that scope, once the handler is
+                // done — is what lets the call answer with its own work: a point becomes a note
+                // beside this hop, and a branch becomes the alternative that was taken
+                // (PRD R26/R27). Nothing is written when a handler announced nothing, so an
+                // uninstrumented call still costs one scope read.
+                if (traced) {
+                    const progress = takeProgress();
+                    if (progress !== undefined) {
+                        attachProgress(progress);
+                        portLogCalls(this)?.answered(inbound.leg as string);
+                    }
+                }
+                return result;
             };
             // The callee adopts the identity its caller declared, so the records its
             // handler writes belong to the caller's execution and its own calls are

package/src/Gateway.ts

@@ -462,7 +462,7 @@ export default class Gateway extends Internal implements IGateway {
                                                           Type.Number(),
                                                       ]),
                                                       result: value.result,
-                                                      checkpoints: Type.Optional(
+                                                      progress: Type.Optional(
                                                           Type.Array(Type.Any()),
                                                       ),
                                                   }),
@@ -592,17 +592,17 @@ export default class Gateway extends Internal implements IGateway {
                                     // Declare the hop this route is making. The caller is
                                     // **`public`** - the surface that answered the request,
                                     // named apart from the namespace it calls. The gateway realm
-                                    // is a namespace called `gateway`, so a leg whose caller was
-                                    // also called `gateway` drew the public surface and that
-                                    // namespace as one participant, and a realm answering a call
-                                    // to its own namespace read as a self-call. A leg id names a
-                                    // unit, and the API surface is a unit of its own - not the
-                                    // process either: one process hosts a whole suite, so naming
-                                    // the process here would draw every flow of a monolith as the
-                                    // same participant.
-                                    // `methodName` is already the dotted wire name the leg
-                                    // grammar wants, so the leg names the method the request
-                                    // asked for. The callee's receipt then carries the same leg,
+                                    // is a namespace called `gateway`, so a caller that was also
+                                    // called `gateway` drew the public surface and that namespace
+                                    // as one participant, and a realm answering a call to its own
+                                    // namespace read as a self-call. The API surface is a unit of
+                                    // its own - not the process either: one process hosts a whole
+                                    // suite, so naming the process here would draw every flow of a
+                                    // monolith as the same participant.
+                                    // `methodName` is the wire name the request asked for, and it
+                                    // is the leg: the caller is declared beside it, so a diagram
+                                    // labels the arrow with the method and draws its source from
+                                    // the unit. The callee's receipt then carries the same leg,
                                     // which is what makes the drawing a call rather than a
                                     // participation.
                                     declareCall(
@@ -643,10 +643,8 @@ export default class Gateway extends Internal implements IGateway {
                                 jsonrpc: '2.0',
                                 id,
                                 result,
-                                ...((resultMeta as {checkpoints?: unknown[]})?.checkpoints
-                                    ?.length && {
-                                    checkpoints: (resultMeta as {checkpoints?: unknown[]})
-                                        .checkpoints,
+                                ...((resultMeta as {progress?: unknown[]})?.progress?.length && {
+                                    progress: (resultMeta as {progress?: unknown[]}).progress,
                                 }),
                             };
                         }

package/src/Registry.ts

@@ -25,6 +25,7 @@ import merge from 'ut-function.merge';
 
 import * as blongLib from '@feasibleone/blong-lib';
 import {renderAll} from '@feasibleone/blong-template';
+import {vocabulary} from '@feasibleone/semantic-log/attachable';
 import {createAttachCheckpoint} from './checkpoint.ts';
 import {methodId, methodParts} from './lib.ts';
 import type {IResolution} from './Resolution.ts';
@@ -369,13 +370,25 @@ export default class Registry extends Internal implements IRegistry {
         port: object | undefined,
     ): Promise<{local: object; literals: object[]}> {
         const attachCheckpoint = this.#attachCheckpoint;
+        const recording = (this.#config.checkpointMode ?? 'production') !== 'production';
         const lib = {
+            // The library's own surface first, so an injected handle can never be silently
+            // overwritten by a name it happens to share: `blongLib` exports `checkpoint`
+            // for the snapshot marker, and the spread used to sit *after* these members.
+            ...blongLib,
             error: this.#error.register.bind(this.#error),
-            assert: attachCheckpoint ? nodeAssert : undefined,
+            assert: recording ? nodeAssert : undefined,
+            // The progress-point pair (PRD R26). `checkpoint` reports a milestone from code that
+            // has no `$meta` — it is the emitter's own `point` reached through the attachable
+            // facade, and it is `undefined` in production for the same reason `$meta.checkpoint`
+            // is: a note nobody records must cost nothing. `decide` selects, so it is always
+            // there, and it is the same function in every mode — what the mode decides is whether
+            // a record carries the rationale, not whether the branch is taken.
+            checkpoint: recording ? vocabulary.point : undefined,
+            decide: vocabulary.decide,
             render: (what: object[] | object) =>
                 renderAll(Array.isArray(what) ? merge(...what) : what, this.#platform.context),
             timing: this.#platform.timing,
-            ...blongLib,
             // The runtime services a `library()` function needs, mirroring the
             // port API (`registry: this`, `platform: …`).
             //

package/src/RpcClient.ts

@@ -195,9 +195,9 @@ export default class RpcClientImpl extends RemoteImpl implements IRpcClient {
                         const result = await decode(body.result);
                         if (/\.service\.get$/.test(method!))
                             Object.assign((result as Record<string, unknown>[])[0], requestParams);
-                        if ((body as unknown as {checkpoints?: unknown[]}).checkpoints?.length) {
-                            ((callerMeta as {checkpoints?: unknown[]}).checkpoints ??= []).push(
-                                ...(body as unknown as {checkpoints: unknown[]}).checkpoints,
+                        if ((body as unknown as {progress?: unknown[]}).progress?.length) {
+                            ((callerMeta as {progress?: unknown[]}).progress ??= []).push(
+                                ...(body as unknown as {progress: unknown[]}).progress,
                             );
                         }
                         return result;

package/src/RpcServer.ts

@@ -85,8 +85,8 @@ export default class RpcServer extends Internal implements IRpcServer {
                 jsonrpc: '2.0',
                 id,
                 result,
-                ...((newMeta as {checkpoints?: unknown[]}).checkpoints?.length && {
-                    checkpoints: (newMeta as {checkpoints?: unknown[]}).checkpoints,
+                ...((newMeta as {progress?: unknown[]}).progress?.length && {
+                    progress: (newMeta as {progress?: unknown[]}).progress,
                 }),
             };
         }

package/src/SemanticLog.test.ts

@@ -52,6 +52,54 @@ t.test('a cache configured without a bound takes the default', async t => {
     t.equal(log.store.stats().size, 1, 'the default bound retains a record comfortably');
 });
 
+t.test('a record carries the branch and the points of the scope that wrote it', async t => {
+    // PRD R26/R27: the framework's logger must not have to know about progress points for them to
+    // reach a record — they ride the emitter's ambient scope, and what this pins is that the
+    // framework's own path (`semanticRecord.ts`, `LogBase`, the call channel that goes through the
+    // same logger) reads that scope rather than writing a record of its own.
+    const dir = await mkdtemp(join(tmpdir(), 'blong-semantic-log-'));
+    t.teardown(() => rm(dir, {recursive: true, force: true}));
+    const log = new SemanticLog({level: 'info', cache: {dir}});
+    await log.init();
+    const at = log.logger('info', {name: 'progress'});
+
+    const chosen = vocabulary.decide('route-selection', {corridor: 'EUR-USD'}, [
+        {name: 'hold', when: () => false, run: () => 'hold'},
+        {
+            name: 'hubB',
+            when: () => true,
+            run: () => {
+                vocabulary.point('corridor-resolved', {hub: 'B'});
+                at.info?.('routing to the far ecosystem');
+                return 'hubB';
+            },
+        },
+    ]);
+    t.equal(chosen, 'hubB', 'the branch ran');
+    await log.stop();
+
+    let record: {msg?: string; progress?: {regions?: unknown[]; points?: unknown[]}} | undefined;
+    for (const id of await cacheRecordIds(dir)) {
+        const candidate = await log.store.get(id);
+        if (candidate?.msg === 'routing to the far ecosystem') {
+            record = candidate;
+        }
+    }
+    t.ok(record, 'the record the branch wrote was retained');
+    t.same(
+        (record?.progress?.regions as Array<{discriminator: string; chosen: string}>).map(
+            region => [region.discriminator, region.chosen],
+        ),
+        [['route-selection', 'hubB']],
+        'it was emitted inside the branch, which is what a diagram draws as an alt block',
+    );
+    t.same(
+        (record?.progress?.points as Array<{name: string}>).map(point => point.name),
+        ['corridor-resolved'],
+        'and the point announced in that scope rides the same record',
+    );
+});
+
 t.test('the home-relative cache path the framework uses is expanded', t => {
     // The framework's own configuration names the shared log cache as
     // `~/.blong/log-cache`, and the pino transport expands that itself — so a
@@ -276,7 +324,17 @@ t.test('every level is bound, and emits at its own level', async t => {
     // `fatal` is written synchronously, so it is staged rather than stored: it is
     // the one level whose record survives an exit that drains no I/O, and it
     // reaches the store on the next open. The other five take the queued path.
-    t.same(levels.sort(), ['debug', 'error', 'info', 'trace', 'warn']);
+    //
+    // An error appears twice, and that is the tenant model rather than a duplicate
+    // write: every record is stored once under its **shape** (keyed by the shape
+    // reference, standing for every occurrence of it), and a record whose denoise
+    // would hide something — an error, or one that withheld a payload — is stored
+    // under its own id as well, because that occurrence is what is being diagnosed.
+    t.same(
+        levels.sort(),
+        ['debug', 'error', 'error', 'info', 'trace', 'warn'],
+        'every level is stored, and the error under its shape and its own id',
+    );
     const staged = readFileSync(cachePaths.sidecarFile(dir), 'utf8')
         .trim()
         .split('\n')
@@ -284,8 +342,8 @@ t.test('every level is bound, and emits at its own level', async t => {
         .map(entry => JSON.parse(entry.json) as {levelName: string});
     t.same(
         staged.map(entry => entry.levelName),
-        ['fatal'],
-        'the fatal record is staged, not stored',
+        ['fatal', 'fatal'],
+        'the fatal record is staged under its shape and its own id, and never stored',
     );
     await cache.close();
 });
@@ -329,13 +387,14 @@ t.test('a record made inside a flow names the flow, the call and the position',
     );
     const [id] = await cacheRecordIds(dir);
     const record = (await log.store.get(id ?? '')) as unknown as {
-        flow?: {id?: string; leg?: string; legTo?: string; legSeq?: string};
+        flow?: {id?: string; leg?: string; legFrom?: string; legTo?: string; legSeq?: string};
     };
     t.equal(
         record.flow?.leg,
-        'access.db.party.subject.find',
-        'the record names the call it was made in',
+        'party.subject.find',
+        'the record names the call it was made in, by the method it was made by',
     );
+    t.equal(record.flow?.legFrom, 'access.db', 'and the unit that made it, beside the method');
     t.equal(record.flow?.legTo, 'party', 'and the participant the caller aimed at');
     t.match(String(record.flow?.legSeq), /^[0-9]+$/, 'and its position in the execution');
     t.equal(isFlowId(record.flow?.id), true, 'and the execution it is part of');
@@ -382,8 +441,8 @@ t.test('the records of a flow reach the cluster service and come back as a diagr
     t.equal(diagram?.statusCode, 200, 'the execution can be drawn from the records alone');
     t.match(
         diagram?.body ?? '',
-        /access\.db\.party\.subject\.find/,
-        'and the drawing names the call the caller declared',
+        /party\.subject\.find/,
+        'and the drawing names the call the caller declared, by its method',
     );
 });
 

package/src/SemanticLog.ts

@@ -85,7 +85,7 @@ export interface SemanticLogConfig {
     /**
      * Retain records on disk so a printed reference resolves later. The directory is
      * the framework's log cache, which the pino transport also writes — one store,
-     * shared, so a `semantic-log://record/<id>` reference resolves whichever
+     * shared, so a `semlog://r/<id>` reference resolves whichever
      * implementation emitted it.
      */
     cache?: RetentionOptions;

package/src/Watch.ts

@@ -22,6 +22,12 @@ import type {Dirent} from 'node:fs';
 import merge from 'ut-function.merge';
 
 import layerProxy from './layerProxy.ts';
+// The chain is server-side code — it pulls `node:assert` and the event emitter the test
+// executor is built on — so only its types may be imported statically: a value import
+// puts the chain in the browser's eager module graph, where linking its `node:events`
+// import fails before a single handler runs. The Allure session is ended through a
+// dynamic import for the same reason.
+import type {IAllureRunOptions} from './chain.ts';
 import {runInFlow, withStep} from './semanticContext.ts';
 
 export interface IWatch {
@@ -82,6 +88,8 @@ interface IConfig {
     ignored: string[];
     configs: string[];
     logLevel: Parameters<ILog['logger']>[0];
+    /** Allure reporting options, as the framework config supplies them. */
+    allure?: IAllureRunOptions;
 }
 
 // ---------------------------------------------------------------------------
@@ -115,6 +123,7 @@ export default class Watch extends Internal implements IWatch {
         ignored: [],
         configs: [],
         logLevel: 'debug',
+        allure: undefined,
     };
 
     #handlerFolders: Map<string, {name: string; pkg: IModuleConfig['pkg']; base: string}> =
@@ -739,10 +748,6 @@ export default class Watch extends Internal implements IWatch {
                     test?: unknown;
                 };
                 try {
-                    const chain = await (
-                        await import('./chain.ts')
-                    ).default(test as ITestContext, this.log);
-
                     const groups = ([] as string[]).concat(this.#config.test);
                     let executed = 0;
                     await withProgress(
@@ -763,6 +768,22 @@ export default class Watch extends Internal implements IWatch {
                                 // were then made in no flow at all, and the observed flow the
                                 // run was supposed to leave behind never existed.
                                 const meta: IMeta = {mtid: 'event', method};
+                                // The chain is built per group because it carries the
+                                // group's wire name: Allure labels come from it, and the
+                                // result's own name is the group's display name, which is
+                                // set on the steps just below.
+                                const chain = await (
+                                    await import('./chain.ts')
+                                ).default(test as ITestContext, this.log, {
+                                    method,
+                                    allure: this.#config.allure,
+                                    // The Allure integration writes files, which a browser
+                                    // platform has nowhere to do: the platform is handed over
+                                    // so the chain can explain the report a browser run asked
+                                    // for and cannot have, instead of failing to import its
+                                    // way to the same end once per group.
+                                    platform: this.#platform.platform,
+                                });
                                 await runInFlow(meta, method, async () => {
                                     const steps = await remote.remote(method)({}, meta);
                                     if (Array.isArray(steps) && !('name' in steps)) {
@@ -795,6 +816,14 @@ export default class Watch extends Internal implements IWatch {
                     this.log?.error?.(error);
                     done?.(error);
                     return;
+                } finally {
+                    // The results directory belongs to the run, not to any one group,
+                    // so the session closes once every group has reported. The chain is
+                    // imported here rather than at the top of the file so that a
+                    // platform which never runs a group never links it.
+                    await (await import('./chain.ts'))
+                        .endAllureSession()
+                        .catch(error => this.log?.error?.(error));
                 }
                 done?.();
             });

package/src/adapterProgress.test.ts

@@ -0,0 +1,190 @@
+/**
+ * What a handler announced, on the answer of the call it handled (PRD R26/R27).
+ *
+ * The gap this closes, measured before it was closed: a realm handler announced five points and
+ * one branch through `$meta.checkpoint` / `$meta.decide`, and **no record carried any of them** —
+ * 0 of 5056 retained records. The handles work; the records do not. A call's records are written
+ * by the framework *around* the handler (the receipt before it runs, the answer from the caller's
+ * end), so the ambient scope the handler staged into never emits one, and everything it announced
+ * is dropped with that scope.
+ *
+ * What is pinned here is the receiver's half: the adapter reads what its handler announced once
+ * the handler returns and reports it on the leg it answered, which is a record the ledger already
+ * matches. Two properties matter and both are asserted below — the progress is *re-announced* (so
+ * the logger's own facet machinery puts it on the record, rather than a second way of writing
+ * records being invented), and nothing is written when the handler announced nothing.
+ */
+import type {IMeta} from '@feasibleone/blong/types';
+import {attachSemanticVocabulary} from '@feasibleone/semantic-log/attachable';
+import * as vocabulary from '@feasibleone/semantic-log/emitter';
+import t from 'tap';
+import {AdapterBase} from './AdapterBase.ts';
+import {createAttachCheckpoint} from './checkpoint.ts';
+
+// The framework reaches the vocabulary by attachment (the emitter's scope is Node-only, and the
+// browser bootstrap loads this module too), so a tap process attaches it exactly as `loadServer.ts`
+// does. Without it the handles degrade and there is nothing to report.
+attachSemanticVocabulary(vocabulary);
+
+/** A canonical flow ULID. */
+const FLOW = '01ARZ3NDEKTSV4RRFFQ69G5FAV';
+
+/** The leg the caller declared for the call this adapter answers. */
+const LEG = 'gateway.bundle.merge';
+
+/**
+ * The `$meta` a receiver is handed, built the way the wire builds it: the identities travel in
+ * the header bag, and the leg is in it because the caller declared one.
+ */
+function inboundMeta(): IMeta {
+    const forward = vocabulary.withFlow({id: FLOW, kind: 'transfer.single'}, () =>
+        vocabulary.bindLeg({id: LEG, from: 'public', to: 'gateway'}, () =>
+            vocabulary.identityHeaders(),
+        ),
+    );
+    return {mtid: 'event', method: 'exec', forward};
+}
+
+/** What the fake call channel saw, with the progress staged at the moment it was asked. */
+interface ISeen {
+    phase: string;
+    leg: string;
+    points?: unknown;
+    regions?: unknown;
+}
+
+/**
+ * The adapter under test: the real `handle`, on an instance built without a constructor.
+ *
+ * `handle` reads exactly three things — the imported handler table, the checkpoint attach hook and
+ * the call channel — so those are the three that are set. The alternative, going through
+ * `adapterFactory`, would drag in the registry, the schema and the config runtime to test a
+ * twenty-line method.
+ */
+function receiver(handler: (params: unknown[]) => unknown, seen: ISeen[]) {
+    const adapter = Object.create(AdapterBase.prototype) as AdapterBase<unknown, never>;
+    adapter.imported = {exec: handler as never};
+    adapter._attachCheckpoint = createAttachCheckpoint('debug');
+    // The method-id hook is the constructor's, and it is asked before the handler is found. Identity
+    // is the honest stub for a test: the real one names a method the way its realm does.
+    adapter._methodId = (name: string) => name;
+    (adapter as unknown as {log: unknown}).log = {
+        calls: {
+            enabled: () => true,
+            start: () => undefined,
+            end: () => undefined,
+            error: () => undefined,
+            received: (leg: string) => void seen.push({phase: 'received', leg}),
+            // Read at the moment the answer is written, which is the whole point: what the
+            // framework staged onto the scope is what the record will carry.
+            answered: (leg: string) => {
+                const points = vocabulary.takePoints();
+                const regions = vocabulary.currentRegions();
+                seen.push({
+                    phase: 'answered',
+                    leg,
+                    ...(points ? {points} : {}),
+                    ...(regions ? {regions} : {}),
+                });
+            },
+        },
+    };
+    return adapter;
+}
+
+t.test('the answer of a call carries what its handler announced', async t => {
+    const seen: ISeen[] = [];
+    const meta = inboundMeta();
+    const adapter = receiver(() => {
+        meta.checkpoint?.('merge-started', {bundles: 1});
+        return meta.decide?.('role-bit', {declared: null}, [
+            {name: 'allocated', when: () => true, run: () => 'allocated'},
+            {name: 'declared', when: () => false, run: () => 'declared'},
+        ]);
+    }, seen);
+
+    const result = await adapter.handle({}, meta);
+    t.equal(result, 'allocated', 'the handler answered');
+
+    t.same(
+        seen.map(event => event.phase),
+        ['received', 'answered'],
+        'the receiver writes a receipt when the call arrives and an answer when its work is done',
+    );
+    t.equal(seen[1]?.leg, LEG, 'and the answer names the leg it was handed');
+    t.same(
+        seen[1]?.points,
+        [{name: 'merge-started', data: {bundles: 1}}],
+        'the point the handler announced is staged for the answer',
+    );
+    t.same(
+        (
+            seen[1]?.regions as Array<{
+                discriminator: string;
+                chosen: string;
+                candidates: string[];
+            }>
+        ).map(region => [region.discriminator, region.chosen, region.candidates]),
+        [['role-bit', 'allocated', ['allocated', 'declared']]],
+        'and so is the branch it took, so the block can be drawn around this hop',
+    );
+});
+
+t.test('a handler that waits before it announces is still answered for', async t => {
+    // The regression this pins: the collection's boxes are installed with `enterWith`, which
+    // reaches the current context and what follows it — never a frame that is already suspended.
+    // A handler that awaits before it announces anything resumes in a context whose boxes were
+    // created after the receiver's continuation was bound, so without installing them first the
+    // branch mark (and every point staged after the wait) reached no record: measured live, the
+    // points survived and the branch did not.
+    const seen: ISeen[] = [];
+    const meta = inboundMeta();
+    const adapter = receiver(async () => {
+        await new Promise(resolve => setTimeout(resolve, 1));
+        meta.checkpoint?.('after-the-wait');
+        return meta.decide?.('role-bit', {declared: null}, [
+            {name: 'allocated', when: () => true, run: () => 'allocated'},
+            {name: 'declared', when: () => false, run: () => 'declared'},
+        ]);
+    }, seen);
+
+    await adapter.handle({}, meta);
+    t.same(
+        seen.map(event => event.phase),
+        ['received', 'answered'],
+        'the answer is still written after a wait',
+    );
+    t.same(seen[1]?.points, [{name: 'after-the-wait'}], 'with the point announced after it');
+    t.same(
+        (
+            seen[1]?.regions as Array<{
+                discriminator: string;
+                chosen: string;
+                candidates: string[];
+            }>
+        ).map(region => [region.discriminator, region.chosen, region.candidates]),
+        [['role-bit', 'allocated', ['allocated', 'declared']]],
+        'and the branch it took, which is what the alt block is drawn from',
+    );
+});
+
+t.test('a handler that announced nothing writes no answer', async t => {
+    const seen: ISeen[] = [];
+    const meta = inboundMeta();
+    const adapter = receiver(() => ({success: true}), seen);
+    await adapter.handle({}, meta);
+    t.same(
+        seen.map(event => event.phase),
+        ['received'],
+        'an uninstrumented call still pays nothing beyond its receipt',
+    );
+});
+
+t.test('an untraced call records nothing at all', async t => {
+    const seen: ISeen[] = [];
+    const adapter = receiver(() => {
+        return {success: true};
+    }, seen);
+    await adapter.handle({}, {mtid: 'event', method: 'exec'});
+    t.same(seen, [], 'no flow on the call, so no records — the gate is asked first');
+});