- Status: accepted 2026-11-02, by Alessandro Prandini, the text first. Proposed 2026-11-02. Its decisions were ruled before it was written, by Alessandro Prandini on 2026-11-02, in a design discussion that produced ten numbered decisions, and three of them were corrected by him the same evening. They are stated here as ruled, in this record's own words: the discussion's notes cite material that is not public, so they are not transcribed, as ADR 0048 did not transcribe its own. What this record adds is marked decided here, so that acceptance can rule on it item by item: the names, the recording's version, the order of the work, and what it learnt from measuring. Nothing in it is implemented
- Shipped: unreleased
- Date: 2026-11-02
- Opens: nothing in the run schema. This record writes no
SCHEMA_VERSION, no step of_STEPS, noOUTPUT_VERSIONand noJOURNAL_VERSION. Schema 23 is already travelling, with ADR 0057's code on pull request #869, and this record neither rides it nor needs it to move again (§11). A recording is a new document with a version of its own,RECORDING_VERSION, born at implementation and not here (§11) - Requires, at implementation: two new entries in the tenant's layout,
recordings/andrecorder.toml(§4, §10). The sentence atsrc/digline/store/file_store.py:145-146extended, or it becomes false: "Nothing digline writes can land here, because every other path in the layout goes throughbaselines/,runs/orregister/." The generated.gitignore(file_store.py:117-123) ignores*/recordings/and*/recorder.toml - Assumes: ADR 0002 §1 (the tenant is the perimeter), §2 (the payload stays where it is born) and §5 (a case born outside world 1 gets a generated id); ADR 0015 §1 and §3 (input beside output, whole or nothing); ADR 0018 §1 (the recorded tool call); ADR 0023 §2, §4, §6, §8 and §11 (a person's explicit label, elected by a person, the generated id, the payload regime, what capture never does); ADR 0034 §1 (the store lives in the end company's perimeter); ADR 0036 §2 and ADR 0048 §6 (an entry added to fixed decision 2's list); ADR 0057 (one trajectory, recorded as the live run read it)
- Amends, at acceptance:
CLAUDE.md's fixed decision 2, by an addition to the list of what.digline/<tenant>/holds, in the shape of "Added to the list 2026-09-29 (ADR 0036 §2)": the recordings of a tenant, one subdirectory per process, and the file that switches the recorder on for that tenant (§4, §10). Both are ignored by git, asruns/is, and neither is versioned the waybaselines/is. It is an addition and not an exception: both sit inside the layout, and the decision's reason stays whole - Names, and does not amend: ADR 0023. The import of §4 elects cases under its
rules, and where the import this record foresees would go further than they
allow, that is declared Not decided here rather than ruled. ADR 0034 §1 and
the planned bridge (
CLAUDE.md, Structure,bridge/), which §4's refusal applies and does not change - Touches, in
CLAUDE.md's fixed section: decision 2 gets an addition to its list (Amends). Decision 8 is upheld: a recording is filed under the tenant it was made for, and the import refuses a recording whose tenant is not the suite's (§4). Decision 9 is upheld and not edited: a recording is payload, whole, and nothing indigline.wirelearns its name. Decision 5 is upheld: the recorder writes files and makes no call of its own. Decision 7 is what makes the narrow piece possible: a single call is a recording - Number: 0058. Swept on 2026-11-02 before a line was written, across every ref of this repository, local and remote, and every worktree. The highest number taken anywhere is 0057
Lines cited here are at 9536a52a, unless a line names another commit.
Context¶
A test set made by hand lags the application it tests. While an application is being developed, the calls it makes to a model are the material a suite is made of: on one day of development, tens of calls, a handful of distinct inputs, several prompts in turn. Today none of it reaches digline. A case is written by hand, from a memory of what the application did.
The recorder is the piece that keeps that material, at the place where the application makes the call, in the shape a suite reads. It is designed now and built in 1.1. Three facts about the code decide its shape.
What an assertion reads is not persisted. A provider target builds the
Response an assertion sees, and its metadata carries finish, tools and
tool_calls from the plugin's Completion.as_metadata
(src/digline/targets/completion.py:191). It is not written anywhere: the
comment at src/digline/targets/provider.py:262-264 says so. ADR 0057 is the
defect this produced in a replay, and its repair is the shape a recording's
response takes. A recorder with a serializer of its own would make the same
defect a second time (§11).
Case, set-up and response are already apart in the run document, and in
three different places. The case is Case.vars (src/digline/run/suite.py:165).
The set-up is Run.target_config (src/digline/core/run.py:1551), the named
scalar parameters, and the declared files the prompt lives in. The response is
RecordedResponse (core/run.py:1032). A call recorded inside an
application has all three in one place, the call, and must separate them as it
records, or nothing later can.
The label a person gives already has a home. Case.label
(run/suite.py:172, of type Label, src/digline/core/aggregate.py:48) is
the human calibration label the driver reads (src/digline/run/driver.py:1100).
A person who says yes or no to a recorded response gives that label, before the
case it will belong to exists.
Decision¶
1. Three levels: tenant, app, suite¶
The tenant exists and keeps its meaning (decision 8). The suite exists: one prompt is one suite, with its own cases, baseline and noise floor. The app is the level between them, the application that makes the calls, and the place where the verdicts of many suites will one day be composed.
In 1.1 the app is a field of the recording, not a directory. It is written on every recording and read by the import and by the status command (§10), and it does not enter the layout. A directory would change the address of every baseline and every run, which is fixed decision 2's subject; a field changes nothing that exists. Whether the app becomes a level of the layout is left to the release that composes verdicts across suites.
2. The suite is named at the call site¶
Each call site names its suite: suite= on the wrapped call. Explicit,
stable from development to production, and never derived from the code, because
a name derived from a module or a function changes when the code is moved, and
the suite's history would break with it.
The wrapper carries the tenant and the app; the call carries the suite.
A call that names no suite is recorded in the app's collecting suite,
_unassigned, with the module and the function of the call site. It enters
no gate until a person assigns it. Decided here, the name: the working name
said unlabelled, which already means a case without a Label
(core/aggregate.py:97 and :160). What is missing here is a suite, not a
label.
3. Three compartments, from the first day¶
A recording separates what it records into three compartments:
| Compartment | What it holds | What it becomes |
|---|---|---|
case |
the messages sent, or the variables the call declares | Case.vars |
setup |
system prompt, model, parameters, the tools offered | the set-up of a run: target_config and the declared prompt |
response |
text, finish, tools, tool calls, usage | a RecordedResponse |
The setup is digested: setup_digest, so that the import can tell the same
set-up answered differently, which is noise, from a different set-up, which
is a change.
The default for a single call is decided by the provider's plugin: the
messages are the case, everything else is the setup. Where the user message
mixes a template and the data, the call may pass the template's variables as the
case with digline_vars={...}, which the wrapper takes out before the call
reaches the provider's SDK.
One format for two sources. A reader of trace files, planned after 1.1, fills the same three compartments from a file. If the format serves both, there is nothing for a later major release to break here.
Decided here, the names:
- setup, not system. System collides with the system argument of
Anthropic's API, which is a field inside this compartment, and with
SystemConfig, which is only part of it. setup is the word
SystemConfig's own docstring uses for what it records ("a single set-up to
record", core/run.py:533-534).
- setup_digest, not a fingerprint: fingerprint is already
Completion.fingerprint, the provider's system_fingerprint, and digest is
the word this repository uses for its own (cases_digest, the declared-price
digest).
- digline_vars, because it becomes Case.vars. The prefix stays because the
keyword travels among the SDK's own.
4. Where a recording lives, and the import that refuses another tenant¶
A recording is filed under the tenant it was made for:
.digline/<tenant>/recordings/<process>/. In development the tenant is the
suite's, fixed on the wrapper. In production it is resolved per call, from a
string or a function the wrapper is given, so that each customer's material is
filed in its own tenant's directory and nowhere else.
The suite lives in the development tenant. The baseline is one per suite,
not one per customer. A production tenant names where a recording came from,
on the recording, as source_tenant, and never reaches the gate: being many
tenants is a property of the material, not of the measurement.
The import refuses a recording whose source_tenant is not the suite's
tenant, by name, until the bridge exists. Bringing a production recording
into a suite that is developed elsewhere is the production-to-repository bridge,
which CLAUDE.md's Structure lists as bridge/, planned and not built. Where
the cases are the end company's, ADR 0034 §1 puts the store, and the cases in
it, inside the end company's perimeter, and fixed decision 2 records that
widening. An import that crossed tenants before the bridge would be the bridge,
without its rules.
The import elects cases under ADR 0023. A person's yes or no on a recorded
response is an explicit label (0023 §2); the person names what is written
(0023 §4); the id is generated from the case's input (0023 §6, which ADR 0002
§5 was amended for); the regime of 0023 §8 decides whether the input may be
written to a committed file. In 1.1 the yes or no becomes Case.label at
promotion (§7).
Redaction is foreseen in the format and implemented at deployment, not in
1.1: the format has room for a response withheld as RecordedResponse already
writes one (withheld), and §10 refuses to start without a declared redaction.
So in 1.1, in production, the recorder starts only where redact = "none" is
written: no other declaration has an implementation behind it to honour.
Amended 2026-11-05, by Alessandro Prandini's ruling (P-1520, its parameters
confirmed in P-1523): the gate is not traffic.** A digline run against an
application that records itself in another process — behind digline record
proxy, or through recorders/java — would file the run's own calls as the
application's, and the import would then offer the gate's questions as cases.
In one process running() already keeps the recorder from writing them
(#910); out of it, nothing could tell. So:
- while it runs,
digline run(host.measure) keeps a marker at.digline/<tenant>/runs/.gate/<pid>-<run_id>.json, holding the run's key asrun_id, its pid,started_atand the suite. Touched every 30 seconds, removed when the run ends, in error too; one untouched for 120 seconds is ignored anddigline record statusnames it. Underruns/, ignored by git as everything a run leaves is, and in a dot-directory no listing of suites reads, as.pending/is (ADR 0017 §2).measuretakes the root it writes under as a required argument,Noneonly where the caller says no application can be recording; - every writer that finds a live marker still records, and writes
origin: "gate"and the marker'srun_id:originalone where more than one run is live or the marker cannot be read. The rule errs towards the gate: a call of the application's made during a run is kept apart, and never deleted; - every reader keeps those recordings apart: no list, import,
whereor compare reads them, since the last import does not count them, and the import cannot elect them (ADR 0023: the gate does not elect).digline record statuscounts them as from gate runs.
RECORDING_VERSION stays 1: two optional keys, absent meaning the
application. The marker is a new entry in the tenant's directory, and fixed
decision 2 records it.
5. The episode, and nesting¶
digline.episode is in 1.1, with nesting. It is a context around one turn
of an agent or one pass through a chain. The single calls made inside it are
attached to it. An episode is a recording with the same three compartments:
the case is the message that started it; the setup is the digest of its
children's setups (§8); the response is the final output, with the trajectory
derived from the children in ADR 0057's form.
Noted 2026-11-03: the public names are digline.recorder.wrap, around the
provider's client, and digline.recorder.episode, with digline.recorder.attach
beside it. digline.episode, as this record writes it, does not exist: the
top-level package does not import the recorder, so that importing digline
costs nothing while the recorder is off.
It is compared by ToolsCalled, which exists. No new assertion on the
trajectory comes with it.
An episode delimits a case. In code, an episode does it; in a file, the reader of trace files will do it after the fact, applying the same notion and not inventing it. A chain seen node by node is a set of single calls; the episode is the case that matters.
Decided here, what the code taught:
- The episode's id is propagated explicitly. It lives in a
ContextVar, and a context variable reaches an asyncio task andasyncio.to_thread, but not a thread started withthreading.Threadnor aThreadPoolExecutorworker. That was observed on 2026-11-02 on CPython 3.14.5, with a command that was not saved; the implementation owes it as a test. A framework that runs synchronous nodes in a pool would leave the children outside the episode without a sign. So the episode exposes its id, and a call made in another thread or another process attaches to it by passing that id. - A child the recorder cannot attach is an orphan, and is declared as one. It is recorded with the episode id it was given, or with none, and the import says how many it found. It never disappears into the collecting suite, and it is never attached by guessing from timing.
- Processes. Each process writes its own subdirectory (§10), so an episode whose children run in another process has recordings in two subdirectories, and the import joins them by the episode id. The subdirectory is chosen at the first write, not at import, so that a process forked after importing the wrapper does not write into its parent's.
Noted 2026-11-03 (ADR 0060 §3), and the section above kept as written. A run of
digline collects the calls a wrapped client makes inside the target's call,
recorder on or off, through a context variable that host sets around that
call alone. An episode the application opens there hands its calls to the
collection as well: off, it stays the empty context this section describes;
on, it records as it does here. The collection meets the same limit as the
episode's id: it does not cross a threading.Thread or a ThreadPoolExecutor
worker, and attach(id) is the way across.
6. Where the code lives¶
The format, the three compartments, the episode, nesting and the import are
digline's. Each provider plugin — digline-anthropic, digline-openai,
digline-bedrock — adds two things: the map of which field of its provider's
request is case and which is setup, and the reading of finish, tools and usage
from the reply. The second is code the plugins already have: they read finish at
packages/digline-anthropic/src/digline_anthropic/client.py:444,
packages/digline-bedrock/src/digline_bedrock/client.py:365, and
packages/digline-openai/src/digline_openai/client.py:333 and :379. The
first is new: today the request is built by ProviderTarget.__call__
(targets/provider.py:207-218), not by the plugin. Each plugin ships a minor
with 1.1. Without digline a plugin has nothing to write to, and without a
plugin digline cannot separate a provider's call.
Noted 2026-11-04, and the paragraph above kept as written: one map shipped
before 1.1. digline-anthropic 0.8.0, published on 2026-11-03, carries its
recording map, declared under digline.recording_maps. It is inert until
digline itself has digline.recorder: 1.0.3, the latest release on PyPI when
this note was written, has none, so no released digline loads the map before
1.1. digline-openai 0.6.0 and digline-bedrock 0.7.0 carry no map, and
their minors still come with 1.1.
In the layers, the wrapper reads files and the clock (§10), so it sits with
digline.host, the one layer allowed to. digline.core gains nothing that
does I/O, and tests/test_layering.py stays as it is.
Decided here: the openai plugin assembles its Completion inside
complete() (client.py:283-345), and has no function from a reply to a
Completion the way the other two do (completion_of, anthropic :435,
bedrock :350). It gains one, so that the wrapper reads a reply with the code
the target already uses.
7. Foreseen in the format now, built later¶
- Every step of a trajectory carries its index, for the order assertions planned after 1.1 will read.
- Finish belongs to the steps where a model answered. A model step carries
the finish its reply reported; a tool step has none, because a tool does not
end a reply. A single call is one model step, and
RecordedResponse.finishis its finish.
Noted 2026-11-03 (ADR 0060 §1): confirmed, and built on. One function makes
the steps of a trajectory, a single call's and an episode's alike: one
model step per call, with its finish, then one tool step per call it
asked for.
- A canonicalised argument carries the type it came from beside it.
canonical reduces a value it does not know to "<TypeName>"
(core/types.py:382), so a datetime and the string "<datetime>" become
the same value. The type beside it ("datetime") is what a later repair will
read. Written as an absent-is-not-recorded key, it is additive when it comes.
- Every recording carries a label compartment, empty. It is
Case.label before the case exists: the person's yes or no at the import in
1.1, a label given downstream later, or a labelled archive someone already
has. At promotion it becomes Case.label. Labels are consumed, never
collected by digline. The yes or no at the import is not a collection: it is
the person's own label, given once, by the person, and digline never infers
a label from anything else.
Decided here, the name: label, singular, of type Label | None: the same
name and the same type as the field it becomes. The collision between the
working name and Case.label was what showed that they were one datum.
Noted 2026-11-03 (ADR 0059),
and the section above kept as written. The yes or no at the import is not
Case.label. Label is the class of the input where a suite has ground
truth, and the person at the import judges the recorded answer. So the yes
or no makes a case of a kind of its own, a reviewed answer, judged by the
named check and failing where the judge contradicts the person. The import
no longer writes Case.label, and the label compartment of a recording
stays what it is: a label given downstream, or a labelled archive.
Noted 2026-11-04 (ADR 0062
§2), and the section and the note above kept as written. The label
compartment is out of the recording's contract, and is gone from the
recording with it: no reader read it, and a writer in another language is not
asked to fill a field nobody reads. A file written with one is still read,
and the key ignored. A label given downstream, or a labelled archive, has no
place in a recording in 1.1.
8. The setup of an episode¶
An episode's setup_digest is the digest of its children's setups and the
repository's git_commit (src/digline/host/environment.py:64). It may be
declared by hand with setup= on digline.episode.
The commit is there because a chain may run steps that call no model. When one of those changes, no prompt moves; with the children's setups alone, the import would see the same setup, different responses, and report as noise what is a change.
Noted 2026-11-05, and the section above kept as written: the children's
setups are a set. The order the calls were made in does not count, and a
setup met twice is one. So a turn that asks two models has a setup of its own,
unlike either of its calls', and the same turn recorded with its calls in
another order has the same setup. A setup declared with setup= wins whole:
nothing is added to it. Measured on main at 700c6345, before this note, with
the Python recorder: two episodes that asked the same two models in opposite
orders were written under one digest. Java's recorder builds the same set, its
collector's digests being a sorted set. What was not written down is now one
function, digline.core.recording.episode_setup, which the Python recorder
writes with. setup_digest, the setup in force per form, where's answers
from a new setup and the page's marks read the digest of what it returned, and
nothing else decides an episode's identity. A digest says nothing of an
episode's shape, so record compare and the page's Across setups show,
beside an episode's setup, how many model calls its episodes made and the
models its child setups name; --show-setup resolves child_setups one per
line. A list: no setup is ranked above another.
9. A step, and who acted¶
A step of a trajectory is a RecordedStep, and it carries an actor:
model or tool, and engine when someone declares one by hand in a later
release. 1.1 produces model and tool only. A step that runs no model and is
no tool call is invisible to the wrapper: it is part of the setup until someone
declares it.
Decided here, the names: RecordedStep, because Step is already
digline.store.migrate.Step (src/digline/store/migrate.py:140), and the
prefix puts it beside RecordedResponse and RecordedToolCall. actor,
because kind is already RecordedResponse.kind, the branch of Output a
response's text came from, one level up from where a step sits.
10. How it is switched on¶
Wired once, in code. The wrapper goes around the provider's client, with
app=, and suite= goes on each call. There is no automatic hooking of the
provider's library: every call would land in _unassigned, and the suite is
the one thing §2 says must be explicit.
Switched outside the code, and off by default. Off, the wrapper passes the
call through. On, it records. It is switched on by a file,
.digline/<tenant>/recorder.toml, or by an environment variable. The file
is ignored by git, in the generated .gitignore, like */recordings/: a
switch that was committed would switch recording on for everyone who clones the
repository.
A status command says whether the recorder is recording, where, and how many recordings each suite has gained since the last import.
Amended 2026-11-03, by Alessandro Prandini's decision, at implementation:
how "since the last import" is known. Not from a ledger: ADR 0023 §9 allows
the import no memory but the draft. Each case the import writes carries
examined_through, the newest recorded_at among the suite's recordings the
person was shown, and each recording now carries recorded_at, the system
time it was written at. The count is the suite's recordings written after the
newest examined_through in its draft. The status reads it only when it is
given the suite, because only the suite says where its draft is. A suite whose
draft holds no case from the recordings is never imported, said with its
total. A recording with no recorded_at is never counted as after the
watermark.
In production:
- it is switched on by a command, per tenant, which writes the file;
- the wrapper re-reads the file at an interval, so no restart is needed;
- it refuses to start, loudly, in three cases: no declared redaction
(redact = "none" is allowed, and must be written), no declared sampling,
and no writable directory with a ceiling on its size;
- at the ceiling it stops recording and says so in the status. It does not
rotate and it does not delete;
- one subdirectory per process, and the import joins them;
- recordings already imported are deleted only by an explicit command.
The wrapper is Python. An application in another language is not served by it in 1.1.
Noted 2026-11-04 (ADR 0062),
and the sentence above kept as written: it stays true of the wrapper, and is
no longer the whole of the recorder. An application in another language is
served in 1.1 by two other doors that write the same recording: a proxy,
digline record proxy, between its SDK and the provider, and an interceptor
copied into a Java project. The recording's format becomes a public contract.
Decided here, what off costs, and how it is held:
- Off must not import
digline.core. Importing it is not cheap: measured once on 2026-11-02 atcd71a383on CPython 3.14.5, about 50 ms warm with 274 modules loaded, with a command that was not saved, so the figure is indicative and the implementation owes the saved measurement. Off, the wrapper's module imports nothing of digline's beyond itself, and everything else is imported at the first recording.
Amended 2026-11-03, decided in the conversation of the session that
implemented it, after a pass as a user measured the first recording holding
an asynchronous client's event loop for about 90 ms: where the recorder is
on when the client is wrapped, wrap() imports what the first recording
would, at the application's start. Off, nothing changes, and the test that
digline.core is not in sys.modules holds as written. Switched on later
from the file, the first recording still imports it, once.
- The cost per call off is measured, not declared. It is a test that
imports the wrapper off and asserts that digline.core is not in
sys.modules; a benchmark of a client injected without network, called bare
and wrapped off, against a threshold the implementation states; and the
interval check, which is one comparison of a monotonic clock per call, with
the file read only when the interval has passed.
Noted 2026-11-03 (ADR 0060 §3), and the cost off kept as written for every process
that is not a run of digline. The wrapper reads one context variable per call
before it asks whether recording is on, and hands the reply to a collection
where one is open. Only host opens one, around the target's call in a run,
and never the wrapper on its own, so production never does. The two tests
above hold as written: the variable lives in digline.recorder, and the read
is inside the stated threshold.
11. One serializer, and the recording's own version¶
Decided here:
- The response compartment is written by the function that writes a recorded response into a run document, not by a second one. Two serializers of one fact are how a trajectory came to have three forms (ADR 0057).
- A recording carries
RECORDING_VERSION. It is a document of its own, beside the run document'sSCHEMA_VERSIONand the journal'sJOURNAL_VERSION, and it moves on its own schedule. A reader older than a recording refuses it by name, saying which version it read and which it knows, and never reads a newer recording as an older one. - The run schema does not move for this record. A recording's response
compartment holds what
RecordedResponseholds at the schema the writing digline writes. Schema 23 bringsfinishandtools, and is enough.
12. A finish no plugin normalised¶
Decided here: the vocabulary of Finish is applied by the provider plugins,
and only there. A recording made without a plugin, or by a function, carries
the text it was given, the way a recorded response already does on the branch
of #869. A finish nobody normalised is not read as one of Finish's words.
13. The order of the work¶
Ruled by Alessandro Prandini on 2026-11-02: 1.1 carries all three pieces below, and they are built in this order. The order is the declared limit, not the boundary of 1.1: whatever is built, is built after what comes before it in the list.
- The narrow piece: the wrapper around the synchronous, non-streaming client of each of the three plugins; the episode with nesting inside one thread and across asyncio, with explicit propagation and declared orphans; the switch, its three refusals and its ceiling; the status command; and the narrow import, the person's yes or no under ADR 0023.
- Streaming and asynchronous clients. None of the three plugins uses either today; a wrapper around an application's client meets both.
- The rich import: proposing an assertion from the shape of the output and sampling by output (Not decided here).
Noted 2026-11-06 (ADR 0063,
accepted), and the item above kept as written: its first half is
digline suggest, and its second is still open.
At the end of November 2026 what exists is looked at, and whether anything of it moves to a later release is decided then, not here.
Consequences¶
No run document changes. No step, no key, no reader of runs is touched.
Noted 2026-11-03 (ADR 0060 §5), and the sentence above kept as written: it no
longer holds for 1.1. The steps of a trajectory enter the run document in
1.1, as steps on a recorded response, on schema 23's step, which still
writes nothing. This record foresaw it in Alternatives considered: "Steps
enter the run document when assertions read them live, so that the live form
and the document move together". In 1.1 four assertions read them live, so
the document moves with them. In a recording, the steps move into the
response, and Recording.steps goes (ADR 0060 §6).
The layout gains two entries per tenant, recordings/ and
recorder.toml, and the generated .gitignore gains both: */recordings/,
because a recording is payload and is never committed, and */recorder.toml,
because a switch that was committed would switch recording on for whoever
clones.
Three plugin minors ride 1.1, one per provider.
A person who imports records labels: the import is where a recorded response becomes a case, by a person's yes or no, under ADR 0023's rules.
Why one record, and not three¶
Decided here. The refusal of another tenant (§4) and the app as a field (§1) could each have been an amendment of its own, to ADR 0034 and to fixed decision 2. Neither changes either. The refusal applies ADR 0034 §1: it refuses what that section already keeps inside the end company's perimeter, until the bridge gives a way across. The app as a field adds nothing to the layout. The one change to the fixed section is the two new entries of §4 and §10, and the precedent for that change is that the record which adds an entry amends the list itself (ADR 0036 §2, ADR 0048 §6). Three records would have given two of them nothing to decide.
Alternatives considered¶
Reform schema 23 before it ships, into steps. It would replace
tool_calls, tools and finish with a list of steps. Rejected:
- ADR 0057 records tools beside tool_calls so that a target whose two lists
disagree is replayed as it was judged, and one list of steps cannot hold the
disagreement;
- the live form an assertion reads would stay the three keys, and the document
would hold a fourth form, which is the defect ADR 0057 closes;
- the migration would stop writing nothing: it would rewrite every stored
document that holds tool_calls;
- a journal written by 1.0 and read back in a resume would meet a shape it did
not write, and JOURNAL_VERSION does not move with the schema.
A single recorded response is one model step and its tool steps, so the schema 23 fields read as steps without loss. Steps enter the run document when assertions read them live, so that the live form and the document move together.
The app as a directory. Rejected for 1.1: it moves every address in the layout to compose verdicts nobody composes yet.
Hooking the provider's library automatically. Rejected: every call would
land in _unassigned (§10).
system for the setup compartment. Rejected: §3.
The recorder's own serializer, shaped to the recording. Rejected: §11.
Not decided here¶
- A label from more than one source.
Case.labelholds one value. The person's yes or no at the import, a label given downstream and a labelled archive may disagree about one case, and which one wins is not ruled. - The rich import against ADR 0023. Proposing an assertion from the shape of the output and sampling by output go beyond what 0023 §4 allows a listing to do (nothing ranked, scored, starred or pre-selected), and an expected read from the recorded response may be what 0023 §11 item 1 forbids. Built third (§13), and ruled before it is.
Noted 2026-11-06 (ADR 0063,
accepted), and the item above kept as written. The half that proposes
checks is ruled there: digline suggest proposes checks from the shape
of the output and the steps, in a file no command reads until a person
adopts its lines, and chooses no case. The half that samples recordings
into cases stays open: ADR 0023 §4 is not amended, and nothing is
pre-selected.
- How a suite declares recordings as its source. ADR 0023 §3 declares a
source in Python with a reader; recordings are read by digline. Whether the
declaration still has to be code is 0023 §3's question, asked again.
- The bridge. §4's refusal lasts until it exists, and this record does not
design it.
- How redaction is implemented, at deployment.
- An application in another language.
Noted 2026-11-04 (ADR 0062), and the item above kept as written. Decided there for 1.1: the proxy for any SDK that takes a base URL, and an interceptor for Java. .NET, Node and Go interceptors are left after it. - A review interface over recordings, and recording a response flagged from inside the application. Neither is part of this record.
Noted 2026-11-03 (ADR 0061),
and the item above kept as written. The first half is decided there: a
local page over .digline/, served by digline view, reads the
recordings and writes two things, the switch and an imported case, through
the host functions digline record calls. The second half, recording a
response flagged from inside the application, is not decided there.