@namzu/sdk 29.0.0 → 30.0.0

package/dist/utils/log/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/utils/log/types.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,EAAE;AACF,mEAAmE;AACnE,4EAA4E;AAC5E,4EAA4E;AAC5E,wEAAwE;AACxE,2EAA2E;AAC3E,4BAA4B;AAyF5B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,kBAAkB,CAAA;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,CAAA;AAEhD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAA"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/utils/log/types.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,EAAE;AACF,4EAA4E;AAC5E,6EAA6E;AAC7E,6EAA6E;AAC7E,wEAAwE;AACxE,8EAA8E;AAC9E,8DAA8D;AAyF9D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,kBAAkB,CAAA;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,CAAA;AAEhD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAA"}

package/dist/utils/logger.d.ts

@@ -9,28 +9,17 @@ export interface Logger {
     child(context: LogContext): Logger;
 }
 /**
- * @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 declare function getRootLogger(): Logger;
-/**
- * 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 declare function resolveLogger(logger: Logger | undefined): Logger;
 /**
@@ -38,21 +27,12 @@ export declare 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 declare function getLogCounters(): LogSinkCounters | undefined;
-/**
- * @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 declare function configureLogger(options: {
-    level?: LogLevel;
-}): void;
 //# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAGrD,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAchD,MAAM,WAAW,MAAM;IACtB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC/C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC9C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC9C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC/C,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAAA;CAClC;AAuCD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAkBtC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAEhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,IAAI,eAAe,GAAG,SAAS,CAE5D;AAqDD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE;IAAE,KAAK,CAAC,EAAE,QAAQ,CAAA;CAAE,GAAG,IAAI,CAEnE"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEhD,MAAM,WAAW,MAAM;IACtB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC/C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC9C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC9C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC/C,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAAA;CAClC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAEhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,IAAI,eAAe,GAAG,SAAS,CAE5D"}

package/dist/utils/logger.js

@@ -1,152 +1,34 @@
-import { createLogger } from './log/create-logger.js';
-import { getProcessSink, getProcessSinkCounters } from './log/process-sink.js';
-import { SCOPE_ATTRIBUTE } from './log/types.js';
-const LOG_LEVELS = {
-    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,
-};
-function createLoggerImpl(name, minLevel, parentContext) {
-    const minLevelNum = LOG_LEVELS[minLevel];
-    function log(level, message, data) {
-        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) {
-        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 = 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() {
-    // 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;
-}
+import { NOOP_LOGGER } from './log/create-logger.js';
+import { getProcessSink } from './log/process-sink.js';
 /**
- * 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) {
-    return logger ?? getRootLogger();
+    return logger ?? NOOP_LOGGER;
 }
 /**
  * What the record pipeline did to the records it was given, or `undefined`
  * 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() {
     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, level, bound = {}, scope = 'namzu') {
-    // 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) => (message, data) => {
-        created[severity](message, { ...bound, ...data });
-    };
-    return {
-        debug: write('debug'),
-        info: write('info'),
-        warn: write('warn'),
-        error: write('error'),
-        child: (context) => {
-            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) {
-    _rootLogger = createLoggerImpl('namzu', options.level ?? 'info', {});
-}
 //# sourceMappingURL=logger.js.map

package/dist/utils/logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAetD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAAC,MAA0B;IACvD,OAAO,MAAM,IAAI,WAAW,CAAA;AAC7B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc;IAC7B,OAAO,cAAc,EAAE,EAAE,QAAQ,CAAA;AAClC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@namzu/sdk",
-  "version": "29.0.0",
+  "version": "30.0.0",
   "description": "Open-source AI agent SDK with a built-in runtime. Nothing between you and your agents.",
   "license": "FSL-1.1-MIT",
   "type": "module",

package/src/plugin/loader.ts

@@ -15,18 +15,16 @@ import { type Logger, resolveLogger } from '../utils/logger.js'
  * Returns an array of absolute paths to plugin directories.
  */
 export async function discoverPlugins(parentDir: string, log?: Logger): Promise<string[]> {
-	// 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 a caller has one, wins over the process default — LOG-10:
-	// this was the module's own remaining getRootLogger() call site.
+	// 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`, discovery 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]: 'plugin/loader' })
 	const dirs: string[] = []
 

package/src/public-runtime.ts

@@ -81,7 +81,20 @@ export {
 // model list, so that check lives in the driver and needs this.
 export { normaliseModelId, resolveModelPricing, VENDOR_RATES } from './pricing/index.js'
 export { toErrorMessage } from './utils/error.js'
-export { configureLogger, getLogCounters, getRootLogger, Logger } from './utils/logger.js'
+export { getLogCounters, Logger } from './utils/logger.js'
+/**
+ * The process sink's own counter set, for a host that installs a sink and
+ * then builds its own logger from it.
+ *
+ * Exported by LOG-20 out of necessity rather than design. Removing
+ * `getRootLogger` removed `fromSink`, which was the only thing passing this
+ * set into a `createLogger`. Without it every host-written record counts into
+ * a private set, `getLogCounters()` reports a permanently zeroed one, and
+ * `namzu doctor`'s `logging.pipeline` check reads health it never measured —
+ * a check that cannot fail, introduced by the removal that was supposed to
+ * end them.
+ */
+export { getProcessSinkCounters } from './utils/log/process-sink.js'
 
 // The LogSink seam — additive. `Logger`/`getRootLogger`/`configureLogger`
 // above are unchanged; this is the new seam that replaces them going

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/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