@namzu/sdk 27.1.0 → 29.0.0

package/src/manager/connector/environment.ts

@@ -1,6 +1,6 @@
 import type { BaseConnector } from '../../connector/BaseConnector.js'
-import { ExecutionContextFactory } from '../../connector/execution/factory.js'
 import type { BaseExecutionContext } from '../../execution/base.js'
+import { ExecutionContextFactory } from '../../execution/factory.js'
 import type { ConnectorRegistry } from '../../registry/connector/definitions.js'
 import type { ScopedConnectorRegistry } from '../../registry/connector/scoped.js'
 import type {
@@ -18,7 +18,8 @@ import type {
 } from '../../types/connector/index.js'
 import type { ConnectorId, EnvironmentId } from '../../types/ids/index.js'
 import { toErrorMessage } from '../../utils/error.js'
-import { type Logger, getRootLogger } from '../../utils/logger.js'
+import { SCOPE_ATTRIBUTE } from '../../utils/log/types.js'
+import { type Logger, resolveLogger } from '../../utils/logger.js'
 import { ConnectorManager } from './lifecycle.js'
 
 export interface EnvironmentConnectorSetup {
@@ -37,6 +38,8 @@ export interface EnvironmentConnectorManagerConfig {
 	scopedRegistry: ScopedConnectorRegistry
 
 	credentialVault?: CredentialVault
+
+	log?: Logger
 }
 
 interface EnvironmentState {
@@ -59,17 +62,21 @@ export class EnvironmentConnectorManager {
 		this.connectorRegistry = config.connectorRegistry
 		this.scopedRegistry = config.scopedRegistry
 		this.credentialVault = config.credentialVault
-		this.log = getRootLogger().child({ component: 'EnvironmentConnectorManager' })
+		this.log = resolveLogger(config.log).child({
+			[SCOPE_ATTRIBUTE]: 'manager/connector/environment',
+		})
 	}
 
 	registerEnvironment(setup: EnvironmentConnectorSetup): void {
 		const envId = setup.environment.id
 		if (this.environments.has(envId)) {
-			this.log.warn(`Environment "${envId}" already registered, skipping.`)
+			this.log.warn('Environment already registered, skipping', {
+				'namzu.environment.id': envId,
+			})
 			return
 		}
 
-		const manager = new ConnectorManager({ registry: this.connectorRegistry })
+		const manager = new ConnectorManager({ registry: this.connectorRegistry, log: this.log })
 
 		manager.on((event) => this.emit(event))
 
@@ -86,16 +93,20 @@ export class EnvironmentConnectorManager {
 			connectorOverrides: setup.connectorOverrides ?? {},
 		})
 
-		this.log.info(
-			`Environment registered: ${envId} (${setup.environment.name}, tier=${setup.environment.tier})`,
-		)
+		this.log.info('Environment registered', {
+			'namzu.environment.id': envId,
+			'namzu.environment.name': setup.environment.name,
+			'namzu.environment.tier': setup.environment.tier,
+		})
 	}
 
 	async initializeEnvironment(envId: EnvironmentId): Promise<void> {
 		const state = this.getEnvironmentOrThrow(envId)
 		if (state.executionContext) {
 			await state.executionContext.initialize()
-			this.log.info(`Environment "${envId}" execution context initialized`)
+			this.log.info('Environment execution context initialized', {
+				'namzu.environment.id': envId,
+			})
 		}
 	}
 
@@ -108,7 +119,7 @@ export class EnvironmentConnectorManager {
 			await state.executionContext.teardown()
 		}
 		this.environments.delete(envId)
-		this.log.info(`Environment unregistered: ${envId}`)
+		this.log.info('Environment unregistered', { 'namzu.environment.id': envId })
 	}
 
 	getEnvironment(envId: EnvironmentId): EnvironmentDescriptor | undefined {
@@ -245,7 +256,7 @@ export class EnvironmentConnectorManager {
 				listener(event)
 			} catch (err) {
 				this.log.error('Environment event listener error', {
-					error: toErrorMessage(err),
+					'exception.message': toErrorMessage(err),
 				})
 			}
 		}

package/src/manager/connector/lifecycle.ts

@@ -12,10 +12,20 @@ import type {
 import type { ConnectorId, ConnectorInstanceId } from '../../types/ids/index.js'
 import { toErrorMessage } from '../../utils/error.js'
 import { generateConnectorInstanceId } from '../../utils/id.js'
-import { type Logger, getRootLogger } from '../../utils/logger.js'
+import { SCOPE_ATTRIBUTE } from '../../utils/log/types.js'
+import { type Logger, resolveLogger } from '../../utils/logger.js'
 
 export interface ConnectorManagerConfig {
 	registry: ConnectorRegistry
+	/**
+	 * A pre-built, already-correlated logger. A caller that already knows
+	 * something this manager cannot derive on its own — which tenant it was
+	 * constructed for, most concretely (see `TenantConnectorManager`) —
+	 * supplies one here so every record this manager's connectors log
+	 * carries that correlation. Falls back to `getRootLogger()` when absent,
+	 * same as before this field existed.
+	 */
+	log?: Logger
 }
 
 export class ConnectorManager {
@@ -27,7 +37,7 @@ export class ConnectorManager {
 
 	constructor(config: ConnectorManagerConfig) {
 		this.registry = config.registry
-		this.log = getRootLogger().child({ component: 'ConnectorManager' })
+		this.log = resolveLogger(config.log).child({ [SCOPE_ATTRIBUTE]: 'manager/connector' })
 	}
 
 	on(listener: ConnectorEventListener): void {
@@ -65,7 +75,10 @@ export class ConnectorManager {
 		this.instances.set(instanceId, instance)
 		this.liveConnectors.set(instanceId, connector)
 		this.emit({ type: 'instance_created', instanceId, connectorId: config.connectorId })
-		this.log.info(`Connector instance created: ${instanceId} (${config.connectorId})`)
+		this.log.info('Connector instance created', {
+			'namzu.connector.instance_id': instanceId,
+			'namzu.connector.id': config.connectorId,
+		})
 
 		return instance
 	}
@@ -84,12 +97,15 @@ export class ConnectorManager {
 			this.updateStatus(instanceId, 'connected')
 			instance.connectedAt = Date.now()
 			this.emit({ type: 'instance_connected', instanceId })
-			this.log.info(`Connector connected: ${instanceId}`)
+			this.log.info('Connector connected', { 'namzu.connector.instance_id': instanceId })
 		} catch (err) {
 			const message = toErrorMessage(err)
 			this.updateStatus(instanceId, 'error', message)
 			this.emit({ type: 'instance_error', instanceId, error: message })
-			this.log.error(`Connector connection failed: ${instanceId}`, { error: message })
+			this.log.error('Connector connection failed', {
+				'namzu.connector.instance_id': instanceId,
+				'exception.message': message,
+			})
 			throw err
 		}
 	}
@@ -101,10 +117,13 @@ export class ConnectorManager {
 			await connector.disconnect()
 			this.updateStatus(instanceId, 'disconnected')
 			this.emit({ type: 'instance_disconnected', instanceId })
-			this.log.info(`Connector disconnected: ${instanceId}`)
+			this.log.info('Connector disconnected', { 'namzu.connector.instance_id': instanceId })
 		} catch (err) {
 			const message = toErrorMessage(err)
-			this.log.error(`Connector disconnect failed: ${instanceId}`, { error: message })
+			this.log.error('Connector disconnect failed', {
+				'namzu.connector.instance_id': instanceId,
+				'exception.message': message,
+			})
 			throw err
 		}
 	}
@@ -170,8 +189,8 @@ export class ConnectorManager {
 		if (instance.status === 'connected') {
 			await this.disconnect(instanceId).catch((err) => {
 				this.log.warn('Disconnect failed during removal', {
-					instanceId,
-					error: toErrorMessage(err),
+					'namzu.manager.instance_id': instanceId,
+					'exception.message': toErrorMessage(err),
 				})
 			})
 		}
@@ -179,7 +198,7 @@ export class ConnectorManager {
 		this.instances.delete(instanceId)
 		this.liveConnectors.delete(instanceId)
 		this.emit({ type: 'instance_removed', instanceId })
-		this.log.info(`Connector instance removed: ${instanceId}`)
+		this.log.info('Connector instance removed', { 'namzu.connector.instance_id': instanceId })
 	}
 
 	getRegistry(): ConnectorRegistry {
@@ -245,7 +264,7 @@ export class ConnectorManager {
 				listener(event)
 			} catch (err) {
 				this.log.error('Connector event listener error', {
-					error: toErrorMessage(err),
+					'exception.message': toErrorMessage(err),
 				})
 			}
 		}

package/src/manager/connector/tenant.ts

@@ -1,4 +1,5 @@
 import type { BaseConnector } from '../../connector/BaseConnector.js'
+import { NAMZU } from '../../constants/telemetry/index.js'
 import type { ConnectorRegistry } from '../../registry/connector/definitions.js'
 import type {
 	ConnectorConfig,
@@ -18,7 +19,8 @@ import type {
 	TenantId,
 } from '../../types/ids/index.js'
 import { toErrorMessage } from '../../utils/error.js'
-import { type Logger, getRootLogger } from '../../utils/logger.js'
+import { SCOPE_ATTRIBUTE } from '../../utils/log/types.js'
+import { type Logger, resolveLogger } from '../../utils/logger.js'
 import { ConnectorManager } from './lifecycle.js'
 
 interface RateWindow {
@@ -31,6 +33,15 @@ export interface TenantConnectorManagerConfig {
 	credentialVault?: CredentialVault
 
 	defaultRateLimit?: TenantRateLimitConfig
+
+	/**
+	 * A pre-built logger. `registerTenant` already builds a per-tenant CHILD
+	 * of `this.log` (bound with `namzu.tenant.id`) and hands it to each
+	 * tenant's `ConnectorManager` — this field was the one remaining gap: the
+	 * manager's OWN construction-time logger still had no injection point at
+	 * all. Falls back to the process logger when absent.
+	 */
+	log?: Logger
 }
 
 interface TenantState {
@@ -52,16 +63,17 @@ export class TenantConnectorManager {
 		this.registry = config.registry
 		this.credentialVault = config.credentialVault
 		this.defaultRateLimit = config.defaultRateLimit
-		this.log = getRootLogger().child({ component: 'TenantConnectorManager' })
+		this.log = resolveLogger(config.log).child({ [SCOPE_ATTRIBUTE]: 'manager/connector' })
 	}
 
 	registerTenant(descriptor: TenantDescriptor, rateLimit?: TenantRateLimitConfig): void {
 		if (this.tenants.has(descriptor.id)) {
-			this.log.warn(`Tenant "${descriptor.id}" already registered, skipping.`)
+			this.log.warn('Tenant already registered, skipping', { [NAMZU.TENANT_ID]: descriptor.id })
 			return
 		}
 
-		const manager = new ConnectorManager({ registry: this.registry })
+		const tenantLog = this.log.child({ [NAMZU.TENANT_ID]: descriptor.id })
+		const manager = new ConnectorManager({ registry: this.registry, log: tenantLog })
 
 		manager.on((event) => {
 			this.emitTenantEvent(descriptor.id, event)
@@ -74,7 +86,10 @@ export class TenantConnectorManager {
 			rateWindows: new Map(),
 		})
 
-		this.log.info(`Tenant registered: ${descriptor.id} (${descriptor.name})`)
+		this.log.info('Tenant registered', {
+			[NAMZU.TENANT_ID]: descriptor.id,
+			'namzu.tenant.name': descriptor.name,
+		})
 	}
 
 	async unregisterTenant(tenantId: TenantId): Promise<void> {
@@ -83,7 +98,7 @@ export class TenantConnectorManager {
 
 		await state.manager.disconnectAll()
 		this.tenants.delete(tenantId)
-		this.log.info(`Tenant unregistered: ${tenantId}`)
+		this.log.info('Tenant unregistered', { [NAMZU.TENANT_ID]: tenantId })
 	}
 
 	getTenant(tenantId: TenantId): TenantDescriptor | undefined {
@@ -141,9 +156,11 @@ export class TenantConnectorManager {
 					const auth = await this.credentialVault.retrieve(credId)
 					if (auth) {
 						instance.config.auth = auth
-						this.log.info(
-							`Auto-resolved credential "${credId}" for instance "${instanceId}" (tenant: ${tenantId})`,
-						)
+						this.log.info('Auto-resolved credential for instance', {
+							[NAMZU.CREDENTIAL_ID]: credId,
+							'namzu.connector.instance_id': instanceId,
+							[NAMZU.TENANT_ID]: tenantId,
+						})
 					}
 				}
 			}
@@ -173,9 +190,11 @@ export class TenantConnectorManager {
 		}
 
 		instance.config.auth = auth
-		this.log.info(
-			`Credential "${credentialId}" applied to instance "${instanceId}" (tenant: ${tenantId})`,
-		)
+		this.log.info('Credential applied to instance', {
+			[NAMZU.CREDENTIAL_ID]: credentialId,
+			'namzu.connector.instance_id': instanceId,
+			[NAMZU.TENANT_ID]: tenantId,
+		})
 		return state.manager.connect(instanceId)
 	}
 
@@ -284,8 +303,8 @@ export class TenantConnectorManager {
 				listener(event)
 			} catch (err) {
 				this.log.error('Tenant event listener error', {
-					tenantId,
-					error: toErrorMessage(err),
+					'namzu.manager.tenant_id': tenantId,
+					'exception.message': toErrorMessage(err),
 				})
 			}
 		}

package/src/manager/index.ts

@@ -16,10 +16,23 @@ export type {
 export { PlanManager } from './plan/lifecycle.js'
 export type { PlanEvent, PlanEventListener, PlanApprovalHandler } from './plan/lifecycle.js'
 
-export { ThreadManager } from './thread/lifecycle.js'
-export type { ThreadManagerDeps } from './thread/lifecycle.js'
+export {
+	TopicManager,
+	/** @deprecated Use {@link TopicManager}. Literal identity re-export -- instanceof/=== still hold. Removal is NZ-TOPIC-05. */
+} from './topic/lifecycle.js'
+export type { TopicManagerDeps } from './topic/lifecycle.js'
 
 export { AgentManager } from './agent/lifecycle.js'
 
 export { ProjectManager, requireOpenProject } from './project/lifecycle.js'
 export type { ProjectManagerDeps } from './project/lifecycle.js'
+
+// One round of an objective, from debit to verdict. The store holds the
+// rules; these hold the sequence, so a host writes the work and not the
+// bookkeeping.
+export {
+	ObjectiveNotProgressingError,
+	advanceObjective,
+	driveObjective,
+} from './topic/objective.js'
+export type { AdvanceObjectiveParams, DriveObjectiveParams } from './topic/objective.js'

package/src/manager/project/lifecycle.ts

@@ -2,7 +2,7 @@
  * ProjectManager — open/close a workspace, and the gate the ingress paths read.
  *
  * This is the Thread archival model moved to the level that survives. Thread
- * carried `status` and `ThreadManager.requireOpen`; Project — the thing a
+ * carried `status` and `TopicManager.requireOpen`; Project — the thing a
  * tenant actually owns, configures, and closes — carried nothing, so archiving
  * a workspace meant nothing to the code. See the hierarchy plan.
  *

package/src/manager/run/emergency.ts

@@ -13,7 +13,9 @@ import {
 	EMERGENCY_EVENTS,
 	EMERGENCY_SIGNALS,
 } from '../../constants/emergency.js'
+import { NAMZU } from '../../constants/telemetry/index.js'
 import type { EmergencySaveData } from '../../types/run/emergency.js'
+import { SCOPE_ATTRIBUTE } from '../../utils/log/types.js'
 import type { Logger } from '../../utils/logger.js'
 import type { RunPersistence } from './persistence.js'
 
@@ -42,7 +44,7 @@ export class EmergencySaveManager {
 		this.detach()
 		this.runRef = new WeakRef(runMgr)
 		this.outputDir = outputDir
-		this.log = log.child({ component: 'EmergencySaveManager' })
+		this.log = log.child({ [SCOPE_ATTRIBUTE]: 'manager/run/emergency' })
 
 		// Attaching a listener for SIGINT/SIGTERM/uncaughtException suppresses
 		// Node's default termination behavior. After saving state we MUST
@@ -67,7 +69,7 @@ export class EmergencySaveManager {
 			process.on(event, handler)
 		}
 
-		this.log.info('Emergency save handlers attached', { outputDir })
+		this.log.info('Emergency save handlers attached', { 'namzu.manager.output_dir': outputDir })
 	}
 
 	detach(): void {
@@ -100,9 +102,9 @@ export class EmergencySaveManager {
 			tmpPath = undefined
 
 			this.log.warn('Emergency save completed', {
-				runId: snapshot.runId,
-				signal,
-				path: finalPath,
+				[NAMZU.RUN_ID]: snapshot.runId,
+				'namzu.manager.signal': signal,
+				'namzu.manager.path': finalPath,
 			})
 		} catch (err) {
 			if (tmpPath) {
@@ -115,8 +117,8 @@ export class EmergencySaveManager {
 			}
 			try {
 				this.log.error('Emergency save failed', {
-					signal,
-					error: err instanceof Error ? err.message : String(err),
+					'namzu.manager.signal': signal,
+					'exception.message': err instanceof Error ? err.message : String(err),
 				})
 			} catch {
 				// Logger itself failed — nothing more we can safely do.

package/src/manager/run/persistence.ts

@@ -1,24 +1,27 @@
 import { AUTO_CONTINUATION_USER_MESSAGE } from '../../constants/continuation.js'
 import { EMPTY_TOKEN_USAGE } from '../../constants/limits.js'
+import { NAMZU } from '../../constants/telemetry/index.js'
 import { resolveModelPricing } from '../../pricing/index.js'
 import { DiskCheckpointStore } from '../../store/run/checkpoint-disk.js'
 import { RunDiskStore } from '../../store/run/disk.js'
+import { getActiveSpanContext } from '../../telemetry/runtime-accessors.js'
 import { type CostInfo, type TokenUsage, accumulateTokenUsage } from '../../types/common/index.js'
 import type { RunId, SessionId, TenantId } from '../../types/ids/index.js'
 import type { Message } from '../../types/message/index.js'
 import type { ProviderErrorInfo } from '../../types/provider/index.js'
+import type { AuditEvent, AuditEventInput } from '../../types/run/audit.js'
 import type { CheckpointRunScope, CheckpointStore } from '../../types/run/checkpoint-store.js'
 import type { EmergencySaveData } from '../../types/run/emergency.js'
 import type { Run, RunPersistenceConfig, StepResult, StopReason } from '../../types/run/index.js'
 import type { RunStore } from '../../types/run/store.js'
-import type { ProjectId, ThreadId } from '../../types/session/ids.js'
+import type { ProjectId, TopicId } from '../../types/session/ids.js'
 import {
 	type ModelPricing,
 	ZERO_COST,
 	accumulateCost,
 	accumulateUnpricedCost,
 } from '../../utils/cost.js'
-import { generateEmergencySaveId } from '../../utils/id.js'
+import { generateAuditEventId, generateEmergencySaveId } from '../../utils/id.js'
 import type { Logger } from '../../utils/logger.js'
 
 /**
@@ -46,7 +49,7 @@ export class RunPersistence {
 	private _lastPromptMessageCount?: number
 	private log: Logger
 	private readonly _sessionId: SessionId
-	private readonly _threadId: ThreadId
+	private readonly _topicId: TopicId
 	private readonly _tenantId: TenantId
 	private readonly _projectId: ProjectId
 
@@ -54,7 +57,7 @@ export class RunPersistence {
 		this.pricing = config.pricing
 		this.log = config.log
 		this._sessionId = config.sessionId
-		this._threadId = config.threadId
+		this._topicId = config.topicId
 		this._tenantId = config.tenantId
 		this._projectId = config.projectId
 
@@ -120,8 +123,8 @@ export class RunPersistence {
 		return this._sessionId
 	}
 
-	get threadId(): ThreadId {
-		return this._threadId
+	get topicId(): TopicId {
+		return this._topicId
 	}
 
 	get tenantId(): TenantId {
@@ -209,6 +212,24 @@ export class RunPersistence {
 		return this._lastEventSeq
 	}
 
+	/**
+	 * Own counter for the audit trail's `seq` — a SEPARATE sequence space
+	 * from {@link _lastEventSeq}. See `types/run/audit.ts`'s doc on
+	 * `AuditEvent.seq`: the operational RunEvent transcript and the audit
+	 * trail are two logs, and forcing them to share one counter just because
+	 * both happen to be monotonic would make an unrelated burst on one trail
+	 * move the other's cursor.
+	 *
+	 * Not chain-serialized against concurrent writers the way
+	 * `EventTranslator.emitEvent` serializes `RunEvent.seq` (see
+	 * `runtime/query/events.ts`'s `appendChain`) — every call site that
+	 * exists today awaits each `recordAudit` before the next one starts for
+	 * the same run. A future call site that fires audits concurrently would
+	 * need the same serialization; add it there when that call site exists,
+	 * not speculatively here.
+	 */
+	private _lastAuditSeq = 0
+
 	async init(): Promise<void> {
 		await this.runStore.initRun(this.run.id, this.run.parentRunId)
 		// A resume reuses the run id and therefore the same log, so the counter
@@ -218,6 +239,12 @@ export class RunPersistence {
 		// that there is nothing above it.
 		const existing = await this.runStore.readEvents()
 		this._lastEventSeq = existing.at(-1)?.seq ?? 0
+		// Same reasoning, for the audit trail's OWN sequence space. Safe to
+		// degrade to `[]` when the bound store never implements it —
+		// `recordAudit` refuses on such a store regardless (see its own doc),
+		// so seeding at zero here costs nothing a later write would have used.
+		const existingAudit = (await this.runStore.readAuditEvents?.()) ?? []
+		this._lastAuditSeq = existingAudit.at(-1)?.seq ?? 0
 		await this.runStore.writeRunMeta(this.run)
 	}
 
@@ -565,6 +592,81 @@ export class RunPersistence {
 		}
 	}
 
+	/**
+	 * Append one entry to this run's audit trail, and — only once that write
+	 * has actually landed — emit the bridge pointer to the operational log.
+	 * See ses_020's logging design §5.
+	 *
+	 * **Durability is unconditional and the failure mode is asymmetric with
+	 * logging on purpose.** `RunStore.appendAuditEvent` is OPTIONAL on the
+	 * contract (a host's custom store may not implement it, same as
+	 * `addToIndex`), but silently running without an audit trail is exactly
+	 * the degradation `refuse-do-not-degrade` forbids — so a bound store that
+	 * lacks it is a THROWN error here, not a skipped write. Because this is
+	 * called from every run's terminal path (see `runtime/query/result.ts`),
+	 * a store lacking it will throw on the FIRST run against it — this is a
+	 * major-version compatibility break for any host with a custom RunStore,
+	 * documented as such in this release's changeset. When the store DOES
+	 * implement it, a rejection from `appendAuditEvent` is NOT caught: it
+	 * propagates to the caller, because an audit write failing must fail the
+	 * operation it was recording — unlike `createLogger`'s `dispatch`, which
+	 * swallows a throwing sink and counts it. See
+	 * `manager/run/__tests__/audit-durability.test.ts`, which pins both
+	 * halves of that asymmetry against ONE call, including the bridge log
+	 * record below going through a throwing sink.
+	 */
+	async recordAudit(input: AuditEventInput): Promise<AuditEvent> {
+		const span = getActiveSpanContext()
+		const event: AuditEvent = {
+			id: generateAuditEventId(),
+			runId: this.run.id,
+			seq: this._lastAuditSeq + 1,
+			timestamp: Date.now(),
+			who: {
+				agentId: this.run.metadata.agentId,
+				tenantId: this._tenantId,
+				...(input.persona !== undefined ? { persona: input.persona } : {}),
+			},
+			what: input.what,
+			outcome: input.outcome,
+			// The run's cumulative total AT THIS MOMENT — matching `Run.costInfo`'s
+			// own semantics (see `accumulateCost`: the field IS the running total,
+			// not a delta, so "last write wins" is already how the derived summary
+			// treats it).
+			cost: this.run.costInfo,
+			...(input.reason !== undefined ? { reason: input.reason } : {}),
+			...(span ? { traceId: span.traceId, spanId: span.spanId } : {}),
+		}
+
+		if (!this.runStore.appendAuditEvent) {
+			throw new Error(
+				"This run's RunStore does not implement appendAuditEvent. A backend that cannot " +
+					'durably record the audit trail must refuse rather than run with one silently ' +
+					'absent — implement RunStore.appendAuditEvent (and readAuditEvents), or bind this ' +
+					'run to a store that does.',
+			)
+		}
+		await this.runStore.appendAuditEvent(event)
+		// Advanced only once the write actually landed — same discipline
+		// `commitEventSeq` applies to the RunEvent stream. The append above
+		// already threw before this line is reached on a failed write, so there
+		// is no phantom claim on a `seq` no entry occupies.
+		if (event.seq > this._lastAuditSeq) this._lastAuditSeq = event.seq
+
+		// The bridge, one direction only (design §5): AT MOST ONE operational
+		// record per audit write, carrying a POINTER — id and seq — never the
+		// event's own content. Never caught: this is an ordinary logger call
+		// and `createLogger`'s own dispatch already swallows a throwing sink,
+		// which is the asymmetry this method exists to preserve rather than
+		// reimplement.
+		this.log.info('namzu.audit.written', {
+			'namzu.audit.event_id': event.id,
+			'namzu.audit.seq': event.seq,
+		})
+
+		return event
+	}
+
 	async persist(): Promise<void> {
 		await this.runStore.writeRunMeta(this.run)
 		await this.runStore.writeMessages(this.run)
@@ -577,8 +679,8 @@ export class RunPersistence {
 		}
 
 		this.log.info('Run persisted to disk', {
-			runId: this.run.id,
-			dir: this.runStore.getRunDir(),
+			[NAMZU.RUN_ID]: this.run.id,
+			'namzu.manager.dir': this.runStore.getRunDir(),
 		})
 	}
 }