@namzu/sdk 28.0.0 → 30.0.0

package/src/session/retention/archive.ts

@@ -115,24 +115,11 @@ export type WorkspaceResolver = (
  */
 const ARCHIVABLE: ReadonlySet<SubSessionDelegationStatus> = new Set(['idle', 'failed'])
 
-/**
- * Values no code path in this package can write, kept archivable anyway.
- *
- * `merged` and `merge_rejected` sat in the one set above, and nothing has
- * ever produced either — so that membership described a match that could
- * not happen. The temptation is to delete them, and that would be wrong:
- * `SubSessionStore.updateSubSession` takes a whole `SubSession`, so a HOST
- * could have persisted one of these while the wide union permitted it, and
- * dropping them here would strand exactly those records as permanently
- * un-archivable. The union stays wide for one release precisely so such a
- * host can migrate; this set is the other half of that promise.
- *
- * It goes when the six deprecated members go.
- */
-const ARCHIVABLE_LEGACY: ReadonlySet<SubSessionStatus> = new Set(['merged', 'merge_rejected'])
-
 function isArchivable(status: SubSessionStatus): boolean {
-	return ARCHIVABLE.has(status as SubSessionDelegationStatus) || ARCHIVABLE_LEGACY.has(status)
+	// No cast any more. `SubSessionStatus` narrowed to the driven variants in
+	// NZ-RUNREC-14, so the set and the argument are the same type and a value
+	// outside it cannot be constructed to ask about.
+	return ARCHIVABLE.has(status)
 }
 
 export interface ArchivalManagerDeps {

package/src/skills/loader.ts

@@ -167,18 +167,16 @@ export async function loadSkill(
 	const metadataTokens = estimateTokens(`${metadata.name}: ${metadata.description}`)
 	const bodyTokens = skill.body ? estimateTokens(skill.body) : 0
 
-	// Resolved here, not at module scope. A module-scope
-	// `getRootLogger().child(...)` ran once, at import time — before any
-	// host's `configureLogger()` call had a chance to run — and `child()`
-	// bakes `minLevel` into the closure `log()` reads from forever after
-	// (`utils/logger.ts`), so whatever level was live at that one moment
-	// was permanent. `configureLogger` replaces the `_rootLogger` binding
-	// rather than mutating the object it points at, so caching the CHILD
-	// (as this loader did) survives no later call at all — including the
-	// CLI's own `configureLogger({ level: 'silent' })`.
-	//
-	// `log`, when the caller has one (`SkillRegistry` now does), wins over
-	// the process default.
+	// Resolved here, not at module scope, and the reason outlived the defect
+	// it was written for. A module-scope `child(...)` of a process-wide logger
+	// ran once at IMPORT time and baked that moment's level in forever, which
+	// no later host call could undo. LOG-20 removed the process-wide logger
+	// altogether, so that particular trap is gone — and per-call resolution
+	// matters more now, not less: the logger this function uses comes from its
+	// own `log` parameter, and anything resolved at module scope could not see
+	// it. Without a `log`, this loader emits nothing (`resolveLogger` is
+	// `NOOP_LOGGER`), which is the deliberate default rather than a fallback
+	// to somebody else's stream.
 	const logger = resolveLogger(log).child({ [SCOPE_ATTRIBUTE]: 'skills/loader' })
 	logger.debug('Loaded skill', {
 		'namzu.skills.name': metadata.name,

package/src/store/topic/memory.ts

@@ -9,10 +9,10 @@
  * cross-tenant access throws `TenantIsolationError` with no fallback.
  *
  * NZ-TOPIC-01 renamed this from `InMemoryThreadStore` (moved from
- * `store/thread/memory.ts`). `InMemoryThreadStore` keeps working, unaliased
- * — `public-runtime.ts` re-exports it as a literal identity binding to this
- * class, so `instanceof`/`===` both still hold for a caller who has not
- * migrated.
+ * `store/thread/memory.ts`) and re-exported the old name as an identity
+ * binding. NZ-TOPIC-05 removed that re-export, once 28.0.0 had carried the
+ * deprecation to the registry — the class is reachable only as
+ * `InMemoryTopicStore` now.
  */
 
 import { StaleThreadError, TenantIsolationError } from '../../session/errors.js'

package/src/types/agent/reactive.ts

@@ -51,11 +51,6 @@ export interface ReactiveAgentConfig extends BaseAgentConfig {
 	 * canonical brick patterns hard-deny instead of executing
 	 * silently.
 	 */
-	/**
-	 * @deprecated Renamed to `authorizationGate`. Removed in the next major.
-	 * Setting both to different configs throws.
-	 */
-	verificationGate?: AuthorizationGateConfig
 
 	authorizationGate?: AuthorizationGateConfig
 

package/src/types/agent/scheduler.ts

@@ -143,14 +143,3 @@ export interface TaskScheduler {
 	 */
 	onTaskProgress?(callback: (taskId: TaskId) => void): () => void
 }
-
-/**
- * @deprecated Renamed to {@link TaskScheduler}. Removed in the next major.
- *
- * "Gateway" names an object that sits at a system boundary and faces
- * outward — Fowler's POEAA Gateway, an API gateway, a payment gateway. This
- * one faces inward: it creates, waits on, continues, cancels and lists
- * in-process agent tasks. A reader who trusted the name expected a facade
- * over something external and found a scheduler.
- */
-export type TaskGateway = TaskScheduler

package/src/types/agent/supervisor.ts

@@ -48,12 +48,6 @@ export interface SupervisorAgentConfig extends BaseAgentConfig {
 	 */
 	allowDelegation?: boolean
 
-	/**
-	 * @deprecated Renamed to {@link SupervisorAgentConfig.scheduler}. Removed
-	 * in the next major. Setting both to different instances throws.
-	 */
-	gateway?: TaskScheduler
-
 	scheduler?: TaskScheduler
 
 	/**
@@ -167,11 +161,6 @@ export interface SupervisorAgentConfig extends BaseAgentConfig {
 	 * review") so the resumeHandler only fires for the truly
 	 * non-deterministic cases.
 	 */
-	/**
-	 * @deprecated Renamed to `authorizationGate`. Removed in the next major.
-	 * Setting both to different configs throws.
-	 */
-	verificationGate?: AuthorizationGateConfig
 
 	authorizationGate?: AuthorizationGateConfig
 

package/src/types/authorization/index.ts

@@ -187,13 +187,3 @@ export type AuthorizationGateConfig = z.infer<typeof AuthorizationGateConfigSche
  * Declared as `const` rather than `type` on purpose: a `type` alias would
  * break `typeof`, which is the only way these were ever usable.
  */
-
-/** @deprecated Renamed to {@link AuthorizationRuleSchema}. Removed in the next major. */
-export const VerificationRuleSchema = AuthorizationRuleSchema
-/** @deprecated Renamed to {@link AuthorizationGateConfigSchema}. Removed in the next major. */
-export const VerificationGateConfigSchema = AuthorizationGateConfigSchema
-
-/** @deprecated Renamed to {@link AuthorizationRule}. Removed in the next major. */
-export type VerificationRule = AuthorizationRule
-/** @deprecated Renamed to {@link AuthorizationGateConfig}. Removed in the next major. */
-export type VerificationGateConfig = AuthorizationGateConfig

package/src/types/common/index.ts

@@ -15,15 +15,6 @@ export type RunExecutionStatus =
 	| 'failed'
 	| 'cancelled'
 
-/**
- * @deprecated Use {@link RunExecutionStatus}. Removal is a later major.
- *
- * The union is unchanged -- this is a rename, and the alias is here so
- * code written against the old name still compiles and warns for one
- * release, per SemVer's deprecate-before-remove.
- */
-export type AgentStatus = RunExecutionStatus
-
 export function isTerminalStatus(status: RunExecutionStatus): boolean {
 	return status === 'completed' || status === 'failed' || status === 'cancelled'
 }

package/src/types/ids/index.ts

@@ -102,21 +102,6 @@ export type ProjectId = Id<'prj', 'ProjectId'>
  * gone (Convention #0, no silent long-lived compat).
  */
 export type TopicId = Id<'top', 'TopicId'>
-/**
- * @deprecated Use {@link TopicId}. Removal is NZ-TOPIC-05.
- *
- * NZ-TOPIC-01 introduced `TopicId` as an alias OF this name; NZ-TOPIC-04
- * reverses the direction. So this alias now follows `TopicId` to the `top_`
- * prefix instead of keeping `thd_` — a consumer still compiling against the
- * old name gets the new prefix, which is exactly what the major announces.
- *
- * It is kept rather than deleted because the deprecation NZ-TOPIC-01 wrote
- * has never reached a registry: `@namzu/sdk` on npm is 27.1.0, and the
- * changeset that would publish it is still unconsumed in `.changeset/`. A
- * removal here would be a rename with no alias wearing a major's clothes.
- * This release is the one that carries the warning; the next may remove it.
- */
-export type ThreadId = TopicId
 export type SubSessionId = Id<'sub', 'SubSessionId'>
 export type HandoffId = Id<'hof', 'HandoffId'>
 export type WorkspaceId = Id<'wsp', 'WorkspaceId'>

package/src/types/run/checkpoint-store.ts

@@ -281,13 +281,6 @@ export interface LeaseSummary {
  * no reading gain — the opposite of the point.
  */
 
-/** @deprecated Renamed to {@link RunLease}. Removed in the next major. */
-export type RunClaim = RunLease
-/** @deprecated Renamed to {@link FencingToken}. Removed in the next major. */
-export type ClaimFence = FencingToken
-/** @deprecated Renamed to {@link LeaseSummary}. Removed in the next major. */
-export type ClaimSummary = LeaseSummary
-
 /** What a caller asks for when taking a run. */
 export interface ClaimRunOptions {
 	/** Who is taking it. Recorded so an operator can see what holds a stuck run. */

package/src/types/session/ids.ts

@@ -8,8 +8,6 @@
 
 export type {
 	ProjectId,
-	/** @deprecated Use `TopicId`. */
-	ThreadId,
 	TopicId,
 	SubSessionId,
 	HandoffId,

package/src/types/session/index.ts

@@ -4,8 +4,6 @@
 
 export type {
 	ProjectId,
-	/** @deprecated Use `TopicId`. */
-	ThreadId,
 	SubSessionId,
 	HandoffId,
 	WorkspaceId,

package/src/types/session/sub-session.ts

@@ -26,35 +26,23 @@ import type { SubSessionId, SummaryId, WorkspaceId } from './ids.js'
 export type SubSessionDelegationStatus = 'pending' | 'active' | 'idle' | 'failed' | 'archived'
 
 /**
- * @deprecated Use {@link SubSessionDelegationStatus}. Removal is a later
- * major, and the six extra members go with it.
+ * @deprecated Use {@link SubSessionDelegationStatus}. This is now an alias of
+ * it and carries no members of its own; the name goes in a later major.
  *
  * The merge half of this union was declared and never driven. Grepping
  * `packages/sdk` and `packages/cli` for each of `awaiting_merge`,
  * `pending_merge`, `merging`, `merged`, `merge_conflict` and
- * `merge_rejected` AS A SUB-SESSION STATUS finds no writer at all — the
- * many hits on `awaiting_merge` are `SessionStatus`, which is the shadowing
- * this type's replacement exists to end. Two of them (`merged`,
- * `merge_rejected`) had a READER: they sat in `ARCHIVABLE_STATUSES`, a set
- * that could never match on them.
+ * `merge_rejected` AS A SUB-SESSION STATUS found no writer at all — the many
+ * hits on `awaiting_merge` are `SessionStatus`, which is the shadowing this
+ * type's replacement exists to end. Two of them (`merged`, `merge_rejected`)
+ * had a READER: they sat in `ARCHIVABLE_STATUSES`, a set that could never
+ * match on them.
  *
- * The union stays this wide for one release so a host that persisted one of
- * these values still typechecks while it migrates.
+ * The union stayed wide for one release so a host that had persisted one of
+ * those values still typechecked while it migrated. 28.0.0 carried that
+ * window to the registry and NZ-RUNREC-14 closed it.
  */
-export type SubSessionStatus =
-	| SubSessionDelegationStatus
-	/** @deprecated no producer since ratification */
-	| 'awaiting_merge'
-	/** @deprecated no producer since ratification */
-	| 'pending_merge'
-	/** @deprecated no producer since ratification */
-	| 'merging'
-	/** @deprecated no producer since ratification */
-	| 'merged'
-	/** @deprecated no producer since ratification */
-	| 'merge_conflict'
-	/** @deprecated no producer since ratification */
-	| 'merge_rejected'
+export type SubSessionStatus = SubSessionDelegationStatus
 
 /**
  * Discriminator for how a sub-session was created. Pattern doc §4.4

package/src/utils/id.ts

@@ -89,15 +89,6 @@ export function generateTopicId(): TopicId {
 	return generateId('top_')
 }
 
-/**
- * @deprecated Use {@link generateTopicId}. Removal is NZ-TOPIC-05.
- *
- * Mints `top_` from NZ-TOPIC-04 on — an alias that kept minting `thd_`
- * would hand two different id spaces to one program depending on which
- * name the caller happened to import.
- */
-export const generateThreadId = generateTopicId
-
 export function generateRunId(): RunId {
 	return generateId('run_')
 }

package/src/utils/log/create-logger.ts

@@ -10,7 +10,8 @@
 // unwrapping, while a caller that wants to observe the pipeline reads
 // `.counters` off the same reference. That caller is now real: LOG-06's
 // `logging.pipeline` doctor check. It could not have been while every
-// `getRootLogger()` built a logger with its own counters — see `shared`
+// the removed process-wide accessor built a logger with its own counters
+// on every call — see `shared`
 // below and `utils/__tests__/log-counters-are-process-wide.test.ts`.
 
 import { getActiveSpanContext } from '../../telemetry/runtime-accessors.js'
@@ -49,9 +50,9 @@ export function newCounters(): MutableLogSinkCounters {
 /**
  * `shared` lets several loggers write through ONE counter set.
  *
- * Without it the counters answer a question nobody asks. `getRootLogger()`
- * resolves per call and builds a fresh logger each time, so every count it
- * accumulated died with the expression that read it -- the five fields were
+ * Without it the counters answer a question nobody asks. The process-wide
+ * accessor this seam replaced resolved per call and built a fresh logger each
+ * time, so every count it accumulated died with the expression that read it -- the five fields were
  * incremented on every record in the process and read by nothing, which is
  * `declared-but-undriven` with a comment above it promising `namzu doctor`
  * would read them. `installProcessSink` now owns one set for the process,
@@ -71,10 +72,11 @@ function build(
 ): CreatedLogger {
 	function emit(severityText: Severity, body: string, data?: LogContext): void {
 		// Read per record, off the shared mutable holder — never resolved once
-		// and captured in this closure. Today's `Logger.child()` bakes its level
-		// in exactly that way, which is why three module-scope loggers in the
-		// skills/plugin loaders are frozen at `info` forever and unreachable by
-		// any later `configureLogger` call.
+		// and captured in this closure. That is what lets a host retune a
+		// logger it has already handed out: assign `level.current` and the next
+		// record honours it. The alternative, resolving once at construction,
+		// is what froze three module-scope loggers in the skills and plugin
+		// loaders at `info` for the life of the process, reachable by nothing.
 		if (SEVERITY_RANK[severityText] < LEVEL_RANK[options.level.current]) return
 
 		const now = Date.now()

package/src/utils/log/process-sink.ts

@@ -1,13 +1,16 @@
-// The replacement for `configureLogger`'s "one process, one global" model —
-// still one process-wide destination (a CLI genuinely owns the whole
-// process), but a destination, not only a threshold: `configureLogger` could
-// only raise or lower a level against a fixed `process.stderr.write`.
+// One process-wide DESTINATION, and nothing else process-wide.
 //
-// `getRootLogger` reads this: when a sink is installed, the deprecated
-// accessor routes through it instead of writing straight to stderr. That
-// bridge is what makes the seam reachable without rewriting the ~39 existing
-// `getRootLogger()` call sites in one commit — they keep the old shape and
-// gain the new destination.
+// This replaced a "one process, one global logger" model that could only
+// raise or lower a level against a fixed `process.stderr.write` — a
+// threshold, never a destination. A CLI genuinely does own its whole process,
+// so a single installed sink is the right shape for that half.
+//
+// What it deliberately is NOT is a logger. Installing a sink does not reroute
+// anything on its own: it sets where records go and owns the counter set, and
+// the host builds a logger over it (`createLogger`, passing
+// `getProcessSinkCounters()`) and hands that down. LOG-20 removed the global
+// accessor that used to bridge the two automatically, because "automatically"
+// meant a library nobody handed a logger wrote to the host's stderr.
 
 import { newCounters } from './create-logger.js'
 import type { LevelFilter, LogSink, LogSinkCounters, MutableLogSinkCounters } from './types.js'
@@ -55,10 +58,13 @@ export function getProcessSink():
 /**
  * The mutable counter set the installed destination writes through.
  *
- * Internal: a reader wants {@link getProcessSink}'s readonly view. This
- * exists so `getRootLogger`'s bridge can hand the SAME object to every
- * logger it builds, which is what makes the totals process-wide rather
- * than per-call.
+ * Internal in spirit, exported in fact: a mere reader wants
+ * {@link getProcessSink}'s readonly view. A HOST needs this one, because it
+ * is what makes the totals describe the process rather than one logger — it
+ * hands the same object to every logger it builds, so `getLogCounters()` and
+ * `namzu doctor`'s `logging.pipeline` check see one set of numbers. A global
+ * accessor used to do that on the host's behalf; with it gone, the host does
+ * it, which is why this is reachable from `@namzu/sdk` at all.
  */
 export function getProcessSinkCounters(): MutableLogSinkCounters | undefined {
 	return _processSink?.counters

package/src/utils/log/types.ts

@@ -1,11 +1,11 @@
 // The LogSink seam's record and pipeline types.
 //
-// `../logger.ts` keeps `Logger`, `LogContext`, `getRootLogger` and
-// `configureLogger` completely unchanged — `Logger` is in INPUT position on
-// the public surface (`logger?: Logger` on `RunConfig` and tool config), so
-// every host's existing implementation must keep satisfying it forever.
-// Everything here is additive: a new, structurally separate seam that does
-// not touch that interface.
+// `../logger.ts` keeps `Logger` and `LogContext` unchanged — `Logger` is in
+// INPUT position on the public surface (`logger?: Logger` on `RunConfig` and
+// tool config), so every host's existing implementation must keep satisfying
+// it forever. This seam was additive when it landed and stayed that way
+// through LOG-20, which removed the two process-global accessors that used to
+// sit beside those types without touching either type itself.
 
 /**
  * The severity vocabulary Namzu actually emits. `trace` and `fatal` are
@@ -157,13 +157,18 @@ export interface LoggerOptions {
 	readonly sink: LogSink
 	/**
 	 * A mutable holder, read per record inside `createLogger`'s dispatch —
-	 * never captured in a closure at construction. `child()` on today's
-	 * `Logger` bakes its level in exactly that way, which is why the
-	 * module-scope loggers in `skills/loader.ts`, `skills/registry.ts` and
-	 * `plugin/loader.ts` are frozen at `info` forever and unreachable by any
-	 * later `configureLogger` call — verified live: `skills/loader.ts:12`,
-	 * `skills/registry.ts:10` and `plugin/loader.ts:12` all call
-	 * `getRootLogger().child({...})` at module load time.
+	 * never captured in a closure at construction. Assigning `level.current`
+	 * therefore retunes a logger already handed out, which is the whole reason
+	 * this is a box and not a value.
+	 *
+	 * The defect it was designed against: a `child()` that baked its level in
+	 * at construction, combined with module-scope loggers built at IMPORT
+	 * time, froze three loaders at `info` for the life of the process and no
+	 * later call could reach them. Those loaders resolve their logger per call
+	 * now, and the process-wide accessor they resolved it FROM no longer
+	 * exists — so this box is what remains of that fix, and the named
+	 * line numbers that used to be quoted here are deliberately gone: they
+	 * were a claim about the tree that the tree stopped honouring.
 	 */
 	readonly level: { current: LevelFilter }
 	readonly resource: Resource

package/src/utils/logger.ts

@@ -1,24 +1,11 @@
-import { createLogger } from './log/create-logger.js'
-import { getProcessSink, getProcessSinkCounters } from './log/process-sink.js'
+import { NOOP_LOGGER } from './log/create-logger.js'
+import { getProcessSink } from './log/process-sink.js'
 import type { LogSinkCounters } from './log/types.js'
-import { type LevelFilter, type LogSink, SCOPE_ATTRIBUTE } from './log/types.js'
 
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent'
 
 export type LogContext = Record<string, unknown>
 
-const LOG_LEVELS: Record<LogLevel, number> = {
-	debug: 0,
-	info: 1,
-	warn: 2,
-	error: 3,
-	// `silent` sits above every emit level so the `level < minLevelNum`
-	// guard in `log()` always short-circuits when configured. Used by
-	// test harnesses to suppress unmocked `getRootLogger()` stderr
-	// writes; see packages/sdk/src/test-setup.ts.
-	silent: 4,
-}
-
 export interface Logger {
 	debug(message: string, data?: LogContext): void
 	info(message: string, data?: LogContext): void
@@ -27,88 +14,21 @@ export interface Logger {
 	child(context: LogContext): Logger
 }
 
-function createLoggerImpl(name: string, minLevel: LogLevel, parentContext: LogContext): Logger {
-	const minLevelNum = LOG_LEVELS[minLevel]
-
-	function log(level: LogLevel, message: string, data?: LogContext): void {
-		if (LOG_LEVELS[level] < minLevelNum) return
-
-		const timestamp = new Date().toISOString()
-		const prefix = `[${timestamp}] [${level.toUpperCase()}] [${name}]`
-		const merged = { ...parentContext, ...data }
-		const hasContext = Object.keys(merged).length > 0
-
-		if (hasContext) {
-			process.stderr.write(`${prefix} ${message} ${JSON.stringify(merged)}\n`)
-		} else {
-			process.stderr.write(`${prefix} ${message}\n`)
-		}
-	}
-
-	function child(context: LogContext): Logger {
-		const { [SCOPE_ATTRIBUTE]: scopeOverride, ...rest } = context
-		return createLoggerImpl(typeof scopeOverride === 'string' ? scopeOverride : name, minLevel, {
-			...parentContext,
-			...rest,
-		})
-	}
-
-	return {
-		debug: (msg, data) => log('debug', msg, data),
-		info: (msg, data) => log('info', msg, data),
-		warn: (msg, data) => log('warn', msg, data),
-		error: (msg, data) => log('error', msg, data),
-		child,
-	}
-}
-
-let _rootLogger: Logger | null = null
-
 /**
- * @deprecated Prefer `installProcessSink` (own the process's log
- * destination) or `createLogger` (build a logger scoped to a run, tenant or
- * subsystem) from `packages/sdk/src/utils/log/`. `getRootLogger` and
- * `configureLogger` read and write one process-wide global with no
- * destination lever beyond a level threshold — the reason every CLI entry
- * point historically had only one option: switch it off entirely.
- * Unchanged behaviour; this JSDoc is the only edit.
- */
-export function getRootLogger(): Logger {
-	// A process sink, when one is installed, wins over both the cached logger
-	// and the stderr default. Resolved per CALL rather than cached, for the
-	// same reason the new pipeline reads its level per record: a logger handed
-	// out before `installProcessSink` ran would otherwise keep writing to
-	// stderr forever, which is the exact shape of the three frozen loaders
-	// this migration just fixed.
-	//
-	// This bridge is what lets the ~39 existing `getRootLogger()` call sites
-	// reach a host's sink without being rewritten in one commit. They keep the
-	// old interface and gain the new destination.
-	const installed = getProcessSink()
-	if (installed) return fromSink(installed.sink, installed.level)
-
-	if (!_rootLogger) {
-		_rootLogger = createLoggerImpl('namzu', 'info', {})
-	}
-	return _rootLogger
-}
-
-/**
- * Fall back to the process root only when nobody supplied their own. Kept
- * here rather than inlined at each call site so a boundary that threads a
- * host-supplied logger can stay entirely free of `getRootLogger()` itself.
- * `RunContextFactory.buildLogger` was the first caller (LOG-07); LOG-10
- * moved every remaining constructor across `packages/sdk/src` onto this
- * same seam, so this function's own fallback is now the ONLY place in the
- * package that reads the process-wide global outside a host's direct call
- * to `getRootLogger()` itself. `getRootLoggerCount` in
- * `scripts/log-standard.json` measures exactly that: it cannot reach zero
- * while an optional, non-breaking fallback exists at all — removing the
- * fallback (flipping the default to `NOOP_LOGGER`) is LOG-20's major, not
- * this seam's.
+ * A logger that discards, when nobody supplied one.
+ *
+ * The fallback used to be a process-wide global, so a construction with no
+ * logger silently wrote to stderr — from a library, on a stream the host may
+ * be using for its own protocol. LOG-20 flipped it: a component given no
+ * logger produces nothing, and the drop is counted where `getLogCounters()`
+ * can read it.
+ *
+ * The seam stays rather than being inlined at each call site, so every
+ * constructor in the package expresses "logger optional" the same way and one
+ * line decides what optional means.
  */
 export function resolveLogger(logger: Logger | undefined): Logger {
-	return logger ?? getRootLogger()
+	return logger ?? NOOP_LOGGER
 }
 
 /**
@@ -116,74 +36,13 @@ export function resolveLogger(logger: Logger | undefined): Logger {
  * when no host has claimed the process's log destination.
  *
  * `undefined` is the honest answer for that case, not a zeroed set. With no
- * sink installed `getRootLogger` falls back to the legacy stderr writer,
- * which has no pipeline and therefore no redaction pass, no size caps and
- * nothing to count -- reporting five zeros there would read as "nothing was
- * dropped, nothing was redacted", which is a stronger claim than "this was
- * never measured" and happens to be the claim a reader most wants to trust.
+ * sink installed there is no pipeline, and therefore no redaction pass, no
+ * size caps and nothing to count -- reporting five zeros would read as
+ * "nothing was dropped, nothing was redacted", a stronger claim than "this
+ * was never measured" and the one a reader most wants to trust.
  * `namzu doctor`'s `logging.pipeline` check turns the absence into its own
  * row rather than into a clean bill of health.
  */
 export function getLogCounters(): LogSinkCounters | undefined {
 	return getProcessSink()?.counters
 }
-
-/**
- * Adapts the record pipeline back to the legacy `Logger` shape. `scope`
- * threads through recursive `child()` calls the same way `bound` does.
- * Previously fixed at `'namzu'` on every recursive call regardless of what
- * a caller bound — meaning every `getRootLogger()`-derived child logger
- * (the majority of call sites in this package) reported the SAME
- * `scope.name` no matter what `SCOPE_ATTRIBUTE` it was given. This is the
- * single highest-leverage line in the LOG-09 migration: see the direct
- * regression test in `runtime/query/__tests__/context.test.ts` and
- * `utils/__tests__/log-scope-attribute.test.ts`.
- */
-function fromSink(
-	sink: LogSink,
-	level: LevelFilter,
-	bound: LogContext = {},
-	scope = 'namzu',
-): Logger {
-	// The process's counter set, not a fresh one. `getRootLogger` resolves
-	// PER CALL and lands here every time, so a logger built with its own
-	// counters would throw the totals away between one log line and the
-	// next -- which is what made `LogSinkCounters` unreadable by anything.
-	const created = createLogger(
-		{
-			sink,
-			level: { current: level },
-			resource: { 'service.name': 'namzu' },
-			scope,
-		},
-		getProcessSinkCounters(),
-	)
-	const write =
-		(severity: 'debug' | 'info' | 'warn' | 'error') => (message: string, data?: LogContext) => {
-			created[severity](message, { ...bound, ...data })
-		}
-	return {
-		debug: write('debug'),
-		info: write('info'),
-		warn: write('warn'),
-		error: write('error'),
-		child: (context: LogContext) => {
-			const { [SCOPE_ATTRIBUTE]: scopeOverride, ...rest } = context
-			return fromSink(
-				sink,
-				level,
-				{ ...bound, ...rest },
-				typeof scopeOverride === 'string' ? scopeOverride : scope,
-			)
-		},
-	}
-}
-
-/**
- * @deprecated See `getRootLogger`'s deprecation note. `installProcessSink`
- * is the strictly more capable replacement — it picks a destination, not
- * only a threshold. Unchanged behaviour; this JSDoc is the only edit.
- */
-export function configureLogger(options: { level?: LogLevel }): void {
-	_rootLogger = createLoggerImpl('namzu', options.level ?? 'info', {})
-}