@namzu/sdk 2.0.0 → 3.0.0

package/src/store/schema.ts

@@ -0,0 +1,135 @@
+/**
+ * Versioning for anything this SDK writes to disk and reads back.
+ *
+ * Every persisted read was `JSON.parse(raw) as T` — an unchecked cast with
+ * no idea which version of the shape it was looking at. Three things
+ * followed, all of them silent:
+ *
+ *  - A file written by an OLDER build was read as the current shape.
+ *    Fields added since simply arrived as `undefined` and flowed into the
+ *    runtime as though they had been there.
+ *  - A file written by a NEWER build was read by an older one, which
+ *    understood some of the fields and dropped the rest. Write it back and
+ *    the rest are gone — the only one of these that destroys data.
+ *  - Neither case produced an error, a warning, or a log line, so a
+ *    resumed session that quietly lost half its state looked exactly like
+ *    a session that never had it.
+ *
+ * The version is stamped as a field on the record rather than wrapping it
+ * in an envelope, so every file already on disk stays readable: a record
+ * with no version IS version 1, which is exactly what those files are.
+ */
+
+/** Records written without a stamp predate this and are that version. */
+export const INITIAL_SCHEMA_VERSION = 1
+
+/** Reserved key. Domain records must not use it. */
+export const SCHEMA_VERSION_KEY = 'schemaVersion'
+
+/** A step from one version to the next. Pure; runs on the parsed record. */
+export type Migration = (record: Record<string, unknown>) => Record<string, unknown>
+
+export interface SchemaDefinition {
+	/** What this record is, for error messages. */
+	readonly kind: string
+	/** The version this build writes. */
+	readonly current: number
+	/**
+	 * `migrations[n]` upgrades a version-`n` record to version `n+1`.
+	 * Every step from {@link INITIAL_SCHEMA_VERSION} to `current` must be
+	 * present, and that is checked when the schema is declared rather than
+	 * when a stale file finally shows up — a gap discovered at read time is
+	 * discovered in production, by a user whose session will not open.
+	 */
+	readonly migrations: Readonly<Record<number, Migration>>
+}
+
+export class SchemaVersionError extends Error {
+	readonly kind: string
+	readonly found: number
+	readonly supported: number
+
+	constructor(init: { kind: string; found: number; supported: number; message: string }) {
+		super(init.message)
+		this.name = 'SchemaVersionError'
+		this.kind = init.kind
+		this.found = init.found
+		this.supported = init.supported
+	}
+}
+
+export function defineSchema(definition: SchemaDefinition): SchemaDefinition {
+	if (!Number.isInteger(definition.current) || definition.current < INITIAL_SCHEMA_VERSION) {
+		throw new Error(
+			`Schema "${definition.kind}": current version must be an integer >= ${INITIAL_SCHEMA_VERSION}, got ${definition.current}`,
+		)
+	}
+	for (let from = INITIAL_SCHEMA_VERSION; from < definition.current; from++) {
+		if (typeof definition.migrations[from] !== 'function') {
+			throw new Error(
+				`Schema "${definition.kind}": no migration from version ${from} to ${from + 1}. Every step must be present, or a record at version ${from} can never be read.`,
+			)
+		}
+	}
+	return definition
+}
+
+/**
+ * Stamp a record with the version this build writes.
+ *
+ * An array is returned untouched: there is nowhere on it to put a field
+ * that survives `JSON.stringify`, and wrapping it would change the shape
+ * of every file already written. A file whose top level is an array is
+ * therefore unversioned, which is a real limitation — a store that needs
+ * to migrate one has to move it under an object first.
+ */
+export function stamp<T>(schema: SchemaDefinition, record: T): T {
+	if (record === null || typeof record !== 'object' || Array.isArray(record)) return record
+	return { ...(record as object), [SCHEMA_VERSION_KEY]: schema.current } as T
+}
+
+/**
+ * Bring a parsed record up to the current version, or refuse.
+ *
+ * A record from the FUTURE is refused rather than read. Reading it with
+ * today's parser means silently dropping the fields this build does not
+ * know about — and if the caller writes it back, they are gone. A refusal
+ * is recoverable by upgrading; a partial read that overwrites is not.
+ */
+export function migrate<T>(schema: SchemaDefinition, parsed: unknown): T {
+	if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+		return parsed as T
+	}
+
+	const record = parsed as Record<string, unknown>
+	const stamped = record[SCHEMA_VERSION_KEY]
+	// A record with no stamp predates this mechanism, which makes it
+	// version 1 by definition rather than by assumption.
+	const found =
+		typeof stamped === 'number' && Number.isInteger(stamped) ? stamped : INITIAL_SCHEMA_VERSION
+
+	if (found > schema.current) {
+		throw new SchemaVersionError({
+			kind: schema.kind,
+			found,
+			supported: schema.current,
+			message: `Refusing to read a "${schema.kind}" record written at schema version ${found}; this build understands up to ${schema.current}. Reading it would silently drop the fields this build does not know about, and writing it back would lose them. Upgrade to read this data.`,
+		})
+	}
+
+	let migrated = record
+	for (let from = found; from < schema.current; from++) {
+		const step = schema.migrations[from]
+		if (!step) {
+			throw new SchemaVersionError({
+				kind: schema.kind,
+				found,
+				supported: schema.current,
+				message: `No migration from "${schema.kind}" schema version ${from} to ${from + 1}.`,
+			})
+		}
+		migrated = step(migrated)
+	}
+
+	return { ...migrated, [SCHEMA_VERSION_KEY]: schema.current } as T
+}

package/src/store/session/disk.ts

@@ -21,16 +21,7 @@
  * path lives in Phase 7 of the overall roadmap.
  */
 
-import {
-	appendFile,
-	mkdir,
-	readFile,
-	readdir,
-	rename,
-	rm,
-	unlink,
-	writeFile,
-} from 'node:fs/promises'
+import { appendFile, mkdir, readFile, readdir, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import { TenantIsolationError } from '../../session/errors.js'
 import { SessionAlreadySummarizedError } from '../../session/summary/errors.js'
@@ -54,15 +45,27 @@ import type {
 	SessionSummaryOutcome,
 	SessionSummaryRef,
 } from '../../types/summary/ref.js'
+import { atomicWriteFile } from '../../utils/atomic-write.js'
 import {
 	generateMessageId,
 	generateProjectId,
 	generateSessionId,
 	generateSubSessionId,
 } from '../../utils/id.js'
+import { defineSchema, migrate, stamp } from '../schema.js'
 import { getAncestry, getChildren, orderChildren } from './linkage.js'
 import type { LinkageView } from './linkage.js'
 
+/**
+ * This store's on-disk format, versioned as a unit — which is how a
+ * migration would actually be written and shipped, and it keeps every call
+ * site free of schema plumbing.
+ *
+ * Bump `current` and add the migration for the step you are leaving when
+ * the shape changes.
+ */
+const SCHEMA = defineSchema({ kind: 'session-store', current: 1, migrations: {} })
+
 /**
  * Config for {@link DiskSessionStore}. `rootDir` is absolute; all files live
  * under it per the layout documented in the module header.
@@ -503,7 +506,14 @@ export class DiskSessionStore implements SessionStore {
 			message,
 			at: new Date().toISOString(),
 		}
-		await appendFile(join(located.path, 'messages.jsonl'), `${JSON.stringify(entry)}\n`, 'utf-8')
+		// Each line is a whole record, so each line carries its own stamp: an
+		// append-only log is written by many builds over its lifetime and its
+		// lines can legitimately differ in version.
+		await appendFile(
+			join(located.path, 'messages.jsonl'),
+			`${JSON.stringify(stamp(SCHEMA, entry))}\n`,
+			'utf-8',
+		)
 		return id
 	}
 
@@ -534,7 +544,7 @@ export class DiskSessionStore implements SessionStore {
 		}
 		const lines = raw.split('\n').filter((l) => l.length > 0)
 		return lines.map((line) => {
-			const persisted = JSON.parse(line) as PersistedMessageLine
+			const persisted = migrate<PersistedMessageLine>(SCHEMA, JSON.parse(line))
 			return {
 				id: persisted.id,
 				sessionId: persisted.sessionId,
@@ -949,7 +959,11 @@ function deserializeSummary(s: PersistedSummary): SessionSummaryRef {
 async function readJson<T>(path: string): Promise<T | null> {
 	try {
 		const raw = await readFile(path, 'utf-8')
-		return JSON.parse(raw) as T
+		// Through the schema rather than a bare cast: a record from an older
+		// build is brought forward, and one from a NEWER build is refused
+		// instead of read partially and written back with the difference
+		// gone.
+		return migrate<T>(SCHEMA, JSON.parse(raw))
 	} catch (err) {
 		const code = (err as NodeJS.ErrnoException).code
 		if (code === 'ENOENT') return null
@@ -958,14 +972,9 @@ async function readJson<T>(path: string): Promise<T | null> {
 }
 
 async function atomicWriteJson(filePath: string, value: unknown): Promise<void> {
-	const tempPath = `${filePath}.tmp`
-	try {
-		await writeFile(tempPath, JSON.stringify(value, null, 2), 'utf-8')
-		await rename(tempPath, filePath)
-	} catch (err) {
-		await unlink(tempPath).catch(() => undefined)
-		throw err
-	}
+	// Through the shared writer: the sidecar name has to be private to this
+	// write, and a fixed `.tmp` is shared by every writer of the record.
+	await atomicWriteFile(filePath, JSON.stringify(stamp(SCHEMA, value), null, 2))
 }
 
 // Note: messages are append-only `messages.jsonl` (not write-tmp-rename).

package/src/store/task/__tests__/lookup-across-runs.test.ts

@@ -0,0 +1,77 @@
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import type { RunId } from '../../../types/ids/index.js'
+import { DiskTaskStore } from '../disk.js'
+
+/**
+ * A task is WRITTEN under the run that created it and was READ under the
+ * store's default run, so every lookup missed as soon as the two differed
+ * — which is the normal case, not an edge one: the tools are built with
+ * the live run id (`buildTaskTools(store, ctx.runId)`) while a long-lived
+ * host constructs the store once with a fixed default.
+ *
+ * The symptom is that `create` succeeds, `list` succeeds — it takes the
+ * run id as a filter and falls back to the same default — and then
+ * `update`, `delete`, `claim` and every dependency link answer "not
+ * found" for a task the caller can see.
+ *
+ * The in-memory store keys by task id alone, so nothing caught it.
+ */
+
+const DEFAULT = 'run_default' as RunId
+const OTHER = 'run_actual' as RunId
+
+describe('a task created under a different run than the store default', () => {
+	let dir: string
+	let store: DiskTaskStore
+
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), 'namzu-tasks-'))
+		store = new DiskTaskStore({ baseDir: dir, defaultRunId: DEFAULT })
+	})
+
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true })
+	})
+
+	it('can be fetched by id', async () => {
+		const task = await store.create({ subject: 'ship it', runId: OTHER })
+
+		expect(await store.get(task.id)).toMatchObject({ id: task.id, runId: OTHER })
+	})
+
+	it('can be updated', async () => {
+		const task = await store.create({ subject: 'ship it', runId: OTHER })
+
+		const updated = await store.update(task.id, { status: 'in_progress' })
+		expect(updated).toMatchObject({ id: task.id, status: 'in_progress' })
+	})
+
+	it('can be claimed', async () => {
+		const task = await store.create({ subject: 'ship it', runId: OTHER })
+
+		expect(await store.claim(task.id, 'worker-1')).toMatchObject({ owner: 'worker-1' })
+	})
+
+	it('can be deleted', async () => {
+		const task = await store.create({ subject: 'ship it', runId: OTHER })
+
+		expect(await store.delete(task.id)).toBe(true)
+		expect(await store.get(task.id)).toBeUndefined()
+	})
+
+	it('is still not found when it genuinely does not exist', async () => {
+		// The lookup widened to every run; it must not start inventing
+		// tasks, or "not found" stops meaning anything.
+		expect(await store.get('task_nope' as never)).toBeUndefined()
+	})
+
+	it('is found under the default run too', async () => {
+		const task = await store.create({ subject: 'ship it', runId: DEFAULT })
+
+		expect(await store.get(task.id)).toMatchObject({ id: task.id, runId: DEFAULT })
+	})
+})

package/src/store/task/disk.ts

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, rename, unlink, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, readdir, unlink } from 'node:fs/promises'
 import { join } from 'node:path'
 import type { RunId, TaskId, TenantId } from '../../types/ids/index.js'
 import type {
@@ -10,8 +10,20 @@ import type {
 	TaskStore,
 	UpdateTaskParams,
 } from '../../types/task/index.js'
+import { atomicWriteFile } from '../../utils/atomic-write.js'
 import { generateTaskId } from '../../utils/id.js'
 import { type Logger, getRootLogger } from '../../utils/logger.js'
+import { defineSchema, migrate, stamp } from '../schema.js'
+
+/**
+ * This store's on-disk format, versioned as a unit — which is how a
+ * migration would actually be written and shipped, and it keeps every call
+ * site free of schema plumbing.
+ *
+ * Bump `current` and add the migration for the step you are leaving when
+ * the shape changes.
+ */
+const SCHEMA = defineSchema({ kind: 'task-store', current: 1, migrations: {} })
 
 export interface DiskTaskStoreConfig {
 	baseDir: string
@@ -301,7 +313,7 @@ export class DiskTaskStore implements TaskStore {
 			if (!file.endsWith('.json')) continue
 			try {
 				const raw = await readFile(join(dir, file), 'utf-8')
-				const task = JSON.parse(raw) as Task
+				const task = migrate<Task>(SCHEMA, JSON.parse(raw))
 				tasks.push(task)
 			} catch (err) {
 				this.log.warn('Failed to read task file', {
@@ -417,7 +429,7 @@ export class DiskTaskStore implements TaskStore {
 		}
 
 		try {
-			return JSON.parse(raw) as Task
+			return migrate<Task>(SCHEMA, JSON.parse(raw))
 		} catch (err) {
 			this.log.error('Corrupt task JSON on disk', {
 				taskId,
@@ -428,23 +440,55 @@ export class DiskTaskStore implements TaskStore {
 		}
 	}
 
+	/**
+	 * Locate a task by id, whichever run wrote it.
+	 *
+	 * A task is written under `params.runId ?? defaultRunId` and this read
+	 * only the default, so every lookup missed as soon as the two differed
+	 * — the normal case rather than an edge one: the task tools are built
+	 * with the LIVE run id while a long-lived host constructs the store
+	 * once with a fixed default. `create` then succeeded, `list` succeeded
+	 * (it takes the run id as a filter), and `update`, `delete`, `claim`
+	 * and every dependency link answered "not found" for a task the caller
+	 * could see. The in-memory store keys by task id alone, so nothing
+	 * caught it.
+	 *
+	 * The default is tried first because it is right whenever the two
+	 * agree, which keeps the common path one stat rather than a scan.
+	 */
 	private async findTask(id: TaskId): Promise<Task | undefined> {
-		const task = await this.readTask(this.defaultRunId, id)
-		return task ?? undefined
+		const direct = await this.readTask(this.defaultRunId, id)
+		if (direct) return direct
+
+		for (const runId of await this.knownRunIds()) {
+			if (runId === this.defaultRunId) continue
+			const task = await this.readTask(runId, id)
+			if (task) return task
+		}
+		return undefined
 	}
-}
 
-async function atomicWriteFile(filePath: string, content: string): Promise<void> {
-	const tempPath = `${filePath}.tmp`
-	try {
-		await writeFile(tempPath, content, 'utf-8')
-		await rename(tempPath, filePath)
-	} catch (err) {
-		await unlink(tempPath).catch(() => undefined)
-		throw err
+	/** Run directories that exist on disk, or none when the tree is absent. */
+	private async knownRunIds(): Promise<RunId[]> {
+		const root = this.tenantId
+			? join(this.baseDir, 'tenants', this.tenantId, 'tasks')
+			: join(this.baseDir, 'tasks')
+		try {
+			const entries = await readdir(root, { withFileTypes: true })
+			return entries.filter((e) => e.isDirectory()).map((e) => e.name as RunId)
+		} catch (err) {
+			const code = (err as NodeJS.ErrnoException).code
+			if (code !== 'ENOENT') {
+				this.log.warn('Failed to enumerate task run directories', {
+					root,
+					error: err instanceof Error ? err.message : String(err),
+				})
+			}
+			return []
+		}
 	}
 }
 
 async function atomicWriteJson(filePath: string, value: unknown): Promise<void> {
-	await atomicWriteFile(filePath, JSON.stringify(value, null, 2))
+	await atomicWriteFile(filePath, JSON.stringify(stamp(SCHEMA, value), null, 2))
 }

package/src/store/thread/disk.ts

@@ -19,14 +19,26 @@
  * {@link TenantIsolationError} (Convention #17).
  */
 
-import { mkdir, readFile, readdir, rename, rm, unlink, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, readdir, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import { StaleThreadError, TenantIsolationError } from '../../session/errors.js'
 import type { TenantId } from '../../types/ids/index.js'
 import type { ProjectId, ThreadId } from '../../types/session/ids.js'
 import type { Thread, ThreadStatus } from '../../types/thread/entity.js'
 import type { CreateThreadParams, ThreadStore } from '../../types/thread/store.js'
+import { atomicWriteFile } from '../../utils/atomic-write.js'
 import { generateThreadId } from '../../utils/id.js'
+import { defineSchema, migrate, stamp } from '../schema.js'
+
+/**
+ * This store's on-disk format, versioned as a unit — which is how a
+ * migration would actually be written and shipped, and it keeps every call
+ * site free of schema plumbing.
+ *
+ * Bump `current` and add the migration for the step you are leaving when
+ * the shape changes.
+ */
+const SCHEMA = defineSchema({ kind: 'thread-store', current: 1, migrations: {} })
 
 /** Config for {@link DiskThreadStore}. `rootDir` is absolute. */
 export interface DiskThreadStoreConfig {
@@ -241,7 +253,11 @@ function deserializeThread(raw: PersistedThread): Thread {
 async function readJson<T>(path: string): Promise<T | null> {
 	try {
 		const raw = await readFile(path, 'utf-8')
-		return JSON.parse(raw) as T
+		// Through the schema rather than a bare cast: a record from an older
+		// build is brought forward, and one from a NEWER build is refused
+		// instead of read partially and written back with the difference
+		// gone.
+		return migrate<T>(SCHEMA, JSON.parse(raw))
 	} catch (err) {
 		const code = (err as NodeJS.ErrnoException).code
 		if (code === 'ENOENT') return null
@@ -250,12 +266,7 @@ async function readJson<T>(path: string): Promise<T | null> {
 }
 
 async function atomicWriteJson(filePath: string, value: unknown): Promise<void> {
-	const tempPath = `${filePath}.tmp`
-	try {
-		await writeFile(tempPath, JSON.stringify(value, null, 2), 'utf-8')
-		await rename(tempPath, filePath)
-	} catch (err) {
-		await unlink(tempPath).catch(() => undefined)
-		throw err
-	}
+	// Through the shared writer: the sidecar name has to be private to this
+	// write, and a fixed `.tmp` is shared by every writer of the record.
+	await atomicWriteFile(filePath, JSON.stringify(stamp(SCHEMA, value), null, 2))
 }

package/src/streaming/coalesce.ts

@@ -19,7 +19,7 @@ interface CoalesceOptions {
  * The orchestrator does NOT use this — it emits raw deltas. SSE adapters
  * and other slow consumers opt in. A 16ms window roughly aligns with one
  * UI animation frame at 60fps, which is the empirically derived default
- * for cowork's stream route.
+ * for a live stream route.
  *
  * Backpressure semantics: this helper does not drop events. If the
  * upstream produces faster than the consumer drains, the helper still

package/src/telemetry/__tests__/latency-instruments.test.ts

@@ -0,0 +1,120 @@
+import { type Attributes, type Meter, metrics } from '@opentelemetry/api'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { recordTimeToFirstToken, recordToolCall, resetRuntimeMetrics } from '../metrics.js'
+
+/**
+ * namzu streams, so perceived latency is dominated by time to first token
+ * — and the only latency histogram measured the whole request, which
+ * cannot distinguish a fast-first-token long generation from a stalled
+ * one. No host could recover the difference from namzu's data in any form.
+ *
+ * The tool half is milder: the wall clock WAS measured and emitted per
+ * call on `tool_completed`, so a p95 was computable from events. What was
+ * missing was the instrument — with the value already in scope one frame
+ * above the call site.
+ */
+
+interface Written {
+	instrument: string
+	value: number
+	attributes: Attributes
+}
+
+function fakeMeterProvider(written: Written[]) {
+	const instrument = (name: string) => ({
+		add: (value: number, attributes: Attributes = {}) =>
+			written.push({ instrument: name, value, attributes }),
+		record: (value: number, attributes: Attributes = {}) =>
+			written.push({ instrument: name, value, attributes }),
+	})
+	const meter = {
+		createCounter: (name: string) => instrument(name),
+		createHistogram: (name: string) => instrument(name),
+		createUpDownCounter: (name: string) => instrument(name),
+		createObservableGauge: (name: string) => instrument(name),
+		createObservableCounter: (name: string) => instrument(name),
+		createObservableUpDownCounter: (name: string) => instrument(name),
+		addBatchObservableCallback: () => {},
+		removeBatchObservableCallback: () => {},
+	} as unknown as Meter
+	return { getMeter: () => meter }
+}
+
+let written: Written[]
+
+beforeEach(() => {
+	written = []
+	resetRuntimeMetrics()
+	metrics.setGlobalMeterProvider(fakeMeterProvider(written))
+})
+
+afterEach(() => {
+	metrics.disable()
+	resetRuntimeMetrics()
+})
+
+const writesTo = (name: string) => written.filter((w) => w.instrument === name)
+
+const TTFT = 'gen_ai.client.time_to_first_token'
+const TOOL_DURATION = 'gen_ai.tool.call.duration'
+
+describe('time to first token', () => {
+	it('is recorded in seconds, like every other duration here', async () => {
+		recordTimeToFirstToken('m-1', 250)
+
+		// A histogram that silently used milliseconds would look right and
+		// aggregate wrong next to the request-duration one.
+		expect(writesTo(TTFT)[0]?.value).toBeCloseTo(0.25)
+	})
+
+	it('is keyed by model, so a slow model is attributable', () => {
+		recordTimeToFirstToken('fast', 100)
+		recordTimeToFirstToken('slow', 4_000)
+
+		expect(writesTo(TTFT).map((w) => w.attributes['gen_ai.request.model'])).toEqual([
+			'fast',
+			'slow',
+		])
+	})
+
+	it('is a separate instrument from the whole-request duration', () => {
+		// The point of the gap: one number cannot answer both questions.
+		recordTimeToFirstToken('m-1', 250)
+		expect(writesTo('gen_ai.client.operation.duration')).toHaveLength(0)
+		expect(writesTo(TTFT)).toHaveLength(1)
+	})
+})
+
+describe('tool duration', () => {
+	it('is recorded when the caller supplies it', () => {
+		recordToolCall('read', true, undefined, 1_500)
+		expect(writesTo(TOOL_DURATION)[0]?.value).toBeCloseTo(1.5)
+	})
+
+	it('shares the attributes of the count, so slow and failing join up', () => {
+		recordToolCall('fetch', false, 'ETIMEDOUT', 2_000)
+
+		expect(writesTo(TOOL_DURATION)[0]?.attributes).toMatchObject({
+			'gen_ai.tool.name': 'fetch',
+			'namzu.tool.success': false,
+			'namzu.tool.error': 'ETIMEDOUT',
+		})
+	})
+
+	it('still counts the call when no duration is supplied', () => {
+		recordToolCall('read', true)
+
+		expect(writesTo('gen_ai.tool.call.count')).toHaveLength(1)
+		// No duration write rather than a fabricated zero, which would drag
+		// every percentile down.
+		expect(writesTo(TOOL_DURATION)).toHaveLength(0)
+	})
+
+	it('counts and times in one call, not two that could diverge', () => {
+		recordToolCall('read', true, undefined, 900)
+
+		expect(writesTo('gen_ai.tool.call.count')).toHaveLength(1)
+		expect(writesTo(TOOL_DURATION)).toHaveLength(1)
+	})
+})