@winkjs/composer 0.5.1 → 0.7.0

package/src/core/partition-manager/update.js

@@ -1,6 +1,7 @@
 import nodeTypeToModule from '../wiring/node-type-to-module.js';
 
 import { ENV_VARS } from '../env-vars.js';
+import { logger } from '../logger/index.js';
 
 /**
  * This function transforms trigger specifications that reference nodes by name
@@ -44,12 +45,12 @@ const resolveTriggers = function ( stateStore, triggers, scopedFlow ) {
         // Resolve first target to establish reference node type
         const firstTargetName = targets[ 0 ];
         if ( typeof firstTargetName !== 'string' || firstTargetName.length === 0 ) {
-            throw new TypeError( `Target name at trigger ${i}, target 0 must be a non-empty string; found '${firstTargetName}'` );
+            throw new TypeError( `winkComposer/partitionManager: Target name at trigger ${i}, target 0 must be a non-empty string; found '${firstTargetName}'` );
         }
 
         const firstTargetIndex = scopedFlow.specs.findIndex( ( spec ) => spec.name === firstTargetName );
         if ( firstTargetIndex === -1 ) {
-            throw new Error( `Target node '${firstTargetName}' not found in flow specs for trigger ${i}` );
+            throw new Error( `winkComposer/partitionManager: Target node '${firstTargetName}' not found in flow specs for trigger ${i}` );
         }
 
         // Get reference node module and validate control method exists
@@ -58,11 +59,11 @@ const resolveTriggers = function ( stateStore, triggers, scopedFlow ) {
         const referenceNode = scopedFlow.nodeModules[ moduleName ];
 
         if ( !referenceNode ) {
-            throw new Error( `Node module '${moduleName}' not found for nodeType '${firstSpec.nodeType}' in trigger ${i}` );
+            throw new Error( `winkComposer/partitionManager: Node module '${moduleName}' not found for nodeType '${firstSpec.nodeType}' in trigger ${i}` );
         }
 
         if ( typeof referenceNode[ control ] !== 'function' ) {
-            throw new Error( `Control method '${control}' not found on node type '${referenceNode.getNodeType?.() || firstSpec.nodeType}' for trigger ${i}` );
+            throw new Error( `winkComposer/partitionManager: Control method '${control}' not found on node type '${referenceNode.getNodeType?.() || firstSpec.nodeType}' for trigger ${i}` );
         }
 
         // Store first resolved target
@@ -73,12 +74,12 @@ const resolveTriggers = function ( stateStore, triggers, scopedFlow ) {
             const targetName = targets[ j ];
 
             if ( typeof targetName !== 'string' || targetName.length === 0 ) {
-                throw new TypeError( `Target name at trigger ${i}, target ${j} must be a non-empty string; found '${targetName}'` );
+                throw new TypeError( `winkComposer/partitionManager: Target name at trigger ${i}, target ${j} must be a non-empty string; found '${targetName}'` );
             }
 
             const targetIndex = scopedFlow.specs.findIndex( ( spec ) => spec.name === targetName );
             if ( targetIndex === -1 ) {
-                throw new Error( `Target node '${targetName}' not found in flow specs for trigger ${i}, target ${j}` );
+                throw new Error( `winkComposer/partitionManager: Target node '${targetName}' not found in flow specs for trigger ${i}, target ${j}` );
             }
 
             // Ensure all targets are homogeneous (same node type)
@@ -89,7 +90,7 @@ const resolveTriggers = function ( stateStore, triggers, scopedFlow ) {
             if ( targetNode !== referenceNode ) {
                 const refNodeType = referenceNode.getNodeType?.() || firstSpec.nodeType;
                 const targetNodeType = targetNode.getNodeType?.() || targetSpec.nodeType;
-                throw new Error( `Target node '${targetName}' (type: ${targetNodeType}) is incompatible with reference node type '${refNodeType}' for trigger ${i}` );
+                throw new Error( `winkComposer/partitionManager: Target node '${targetName}' (type: ${targetNodeType}) is incompatible with reference node type '${refNodeType}' for trigger ${i}` );
             }
 
             resolvedTargets[ j ] = stateStore[ targetIndex ];
@@ -104,6 +105,102 @@ const resolveTriggers = function ( stateStore, triggers, scopedFlow ) {
     return resolvedTriggers;
 }; // resolveTriggers()
 
+/**
+ * Builds one specialization's graph: node states, per-partition
+ * injections, and resolved triggers. Extracted from update() so the
+ * creation attempt is one guardable unit — a throw from any node's
+ * init, a missing module, or trigger resolution leaves no partial
+ * graph published (the caller publishes only on success).
+ *
+ * @param {Object} flow - Flow specification with nodeModules
+ * @param {Array} specs - This specialization's node specs
+ * @param {*} partitionId - Partition key, for topic/storage injection
+ * @param {*} specializationType - Specialization key, for topic injection
+ * @returns {Array} Initialized node state array with resolved triggers
+ */
+const buildGraph = function ( flow, specs, partitionId, specializationType ) {
+    const graph = new Array( specs.length );
+
+    for ( let k = 0; k < specs.length; k += 1 ) {
+        const spec = specs[ k ];
+
+        // Look up node module using nodeTypeToModule
+        const moduleName = nodeTypeToModule( spec.nodeType );
+        const node = flow.nodeModules[ moduleName ];
+
+        if ( !node ) {
+            throw new Error( `winkComposer/partitionManager: Node module '${moduleName}' not found for nodeType '${spec.nodeType}' at index ${k}` );
+        }
+
+        // Initialize node state
+        graph[ k ] = node.init( spec );
+
+        // ====================================================================
+        // MQTT TOPIC INJECTION IN EMIT IF NODE
+        // ====================================================================
+        // Precompute partition-specific MQTT topic at initialization to avoid
+        // reconstruction on every emission (performance optimization).
+        //
+        // Topic structure: edgeDeviceId/partitionId/specialization/insightType
+        // Example: "edge-001/sensor-42/temperature/changeDetected"
+        //
+        // The edgeDeviceId can encode ISA-95 hierarchy for Unified Namespace:
+        // - Simple: "edge-001"
+        // - UNS: "northwind/riverton/plant2/line3" (enterprise/site/area/cell)
+        //
+        // Enables powerful MQTT subscription patterns:
+        // - All from edge: "edge-001/#" or "northwind/riverton/#"
+        // - Specific sensor: "+/sensor-42/#"
+        if ( spec.nodeType === 'Emit If' && ( graph[ k ].target === 'mqtt' || graph[ k ].target === 'terminal' ) ) {
+            graph[ k ].topic = `${ENV_VARS.edgeDeviceId}/${partitionId}/${specializationType}/${graph[ k ].insightType}`;
+        }
+
+        // ====================================================================
+        // STORAGE AND PARTITION INJECTION IN PERSIST IF NODE
+        // ====================================================================
+        // Inject the storage singleton and partition ID at initialization.
+        // Storage reference is set during wiring (spec.storage), but partition
+        // ID is partition-specific and must be injected here.
+        //
+        // Zero hot-path overhead: All references are pre-resolved.
+        if ( spec.nodeType === 'Persist If' && spec.storage ) {
+            graph[ k ].storage = spec.storage;
+            graph[ k ].partitionId = partitionId;
+        }
+
+        // Resolve triggers with specialization-scoped data
+        graph[ k ].resolvedTriggers = resolveTriggers( graph, spec.triggers, {
+            specs: specs,
+            nodeModules: flow.nodeModules
+        });
+    } // for ( let k = 0; k < specs.length; k += 1 )
+
+    // Special handling for Controller nodes with nested triggers
+    // Only controller node allows FORWARD node control.
+    // That is why it has to be performed only after all nodes have
+    // been initialized.
+    for ( let k = 0; k < specs.length; k += 1 ) {
+        const spec = specs[ k ];
+        if ( spec.nodeType === 'Controller' && graph[ k ].logic ) {
+            // Resolve triggers for each condition in the logic array
+            for ( let j = 0; j < graph[ k ].logic.length; j += 1 ) {
+                graph[ k ].logic[ j ].resolvedTriggers = resolveTriggers(
+                    graph,
+                    graph[ k ].logic[ j ].triggers,
+                    {
+                        specs: specs,
+                        nodeModules: flow.nodeModules
+                    }
+                );
+            }
+            // No top-level resolvedTriggers for controller
+            graph[ k ].resolvedTriggers = null;
+        }
+    } // for ( let k = 0; k < specs.length; k += 1 )
+
+    return graph;
+};
+
 /**
  * Partition state manager's update with integrated trigger resolution and specialization support.
  * Resolved triggers are co-located with each node's state for zero hot-path overhead.
@@ -137,9 +234,10 @@ const update = function ( composerState, msg ) {
         const specs = flow.specsBySpecialization[ specializationType ];
 
         if ( !specs ) {
-            // Log error and skip message - no default fallback
+            // Count, log, and skip the message - no default fallback
             // Note: Do NOT create partition entry for unknown specialization
-            console.error( `[PartitionManager] Unknown specialization '${specializationType}' for partition '${partitionId}'. Message dropped.` );
+            composerState.droppedUnknownSpecialization += 1;
+            logger.error( `winkComposer/partitionManager: Unknown specialization '${specializationType}' for partition '${partitionId}'. Message dropped.` );
             return null;
         }
 
@@ -152,8 +250,8 @@ const update = function ( composerState, msg ) {
         if ( !specializedGraphs ) {
             composerState.totalPartitionsCreated += 1;
             if ( composerState.totalPartitionsCreated > ENV_VARS.maxPartitionsAllowed ) {
-                console.error(
-                    `[PartitionManager] Partition creation for assetId '${partitionId}' ` +
+                logger.error(
+                    `winkComposer/partitionManager: Partition creation for assetId '${partitionId}' ` +
                     `failed — maxPartitionsAllowed (${ENV_VARS.maxPartitionsAllowed}) reached. ` +
                     'Message dropped.'
                 );
@@ -163,85 +261,43 @@ const update = function ( composerState, msg ) {
             partitionSpecializations.set( partitionId, specializedGraphs );
         }
 
-        // Create state array sized for this specialization
-        graph = new Array( specs.length );
-
-        for ( let k = 0; k < specs.length; k += 1 ) {
-            const spec = specs[ k ];
-
-            // Look up node module using nodeTypeToModule
-            const moduleName = nodeTypeToModule( spec.nodeType );
-            const node = flow.nodeModules[ moduleName ];
-
-            if ( !node ) {
-                throw new Error( `Node module '${moduleName}' not found for nodeType '${spec.nodeType}' at index ${k}` );
-            }
-
-            // Initialize node state
-            graph[ k ] = node.init( spec );
-
-            // ====================================================================
-            // MQTT TOPIC INJECTION IN EMIT IF NODE
-            // ====================================================================
-            // Precompute partition-specific MQTT topic at initialization to avoid
-            // reconstruction on every emission (performance optimization).
-            //
-            // Topic structure: edgeDeviceId/partitionId/specialization/insightType
-            // Example: "edge-001/sensor-42/temperature/changeDetected"
-            //
-            // The edgeDeviceId can encode ISA-95 hierarchy for Unified Namespace:
-            // - Simple: "edge-001"
-            // - UNS: "northwind/riverton/plant2/line3" (enterprise/site/area/cell)
-            //
-            // Enables powerful MQTT subscription patterns:
-            // - All from edge: "edge-001/#" or "northwind/riverton/#"
-            // - Specific sensor: "+/sensor-42/#"
-            if ( spec.nodeType === 'Emit If' && ( graph[ k ].target === 'mqtt' || graph[ k ].target === 'terminal' ) ) {
-                graph[ k ].topic = `${ENV_VARS.edgeDeviceId}/${partitionId}/${specializationType}/${graph[ k ].insightType}`;
-            }
+        // Quarantine check. A partition with no failure history (a
+        // fresh entry, or a healthy one adding a new specialization)
+        // has no ledger and passes through. A quarantined partition's
+        // messages drop here, before any node init runs — creation is
+        // blocked, not re-attempted. One WeakMap read on this cold
+        // path; the healthy hot path (graph exists) never reaches it.
+        const priorLedger = composerState.creationFailures.get( specializedGraphs );
+        if ( priorLedger && priorLedger.quarantined ) {
+            return null;
+        }
 
-            // ====================================================================
-            // STORAGE AND PARTITION INJECTION IN PERSIST IF NODE
-            // ====================================================================
-            // Inject the storage singleton and partition ID at initialization.
-            // Storage reference is set during wiring (spec.storage), but partition
-            // ID is partition-specific and must be injected here.
-            //
-            // Zero hot-path overhead: All references are pre-resolved.
-            if ( spec.nodeType === 'Persist If' && spec.storage ) {
-                graph[ k ].storage = spec.storage;
-                graph[ k ].partitionId = partitionId;
+        // Build the graph under the quarantine ledger. A throw anywhere
+        // in the build (a node init, trigger resolution, a missing
+        // module) counts one consecutive creation failure for this
+        // partition and RETHROWS — the dispatch guard owns reporting.
+        // At the shared threshold the partition is quarantined with one
+        // classified report. A successful build clears the ledger.
+        try {
+            graph = buildGraph( flow, specs, partitionId, specializationType );
+        } catch ( creationError ) {
+            let ledger = composerState.creationFailures.get( specializedGraphs );
+            if ( !ledger ) {
+                ledger = { failures: 0, quarantined: false };
+                composerState.creationFailures.set( specializedGraphs, ledger );
             }
-
-            // Resolve triggers with specialization-scoped data
-            graph[ k ].resolvedTriggers = resolveTriggers( graph, spec.triggers, {
-                specs: specs,
-                nodeModules: flow.nodeModules
-            });
-        } // for ( let k = 0; k < specs.length; k += 1 )
-
-        // Special handling for Controller nodes with nested triggers
-        // Only controller node allows FORWARD node control.
-        // That is why it has to be performed only after all nodes have
-        // been initialized.
-        for ( let k = 0; k < specs.length; k += 1 ) {
-            const spec = specs[ k ];
-            if ( spec.nodeType === 'Controller' && graph[ k ].logic ) {
-                // Resolve triggers for each condition in the logic array
-                for ( let j = 0; j < graph[ k ].logic.length; j += 1 ) {
-                    graph[ k ].logic[ j ].resolvedTriggers = resolveTriggers(
-                        graph,
-                        graph[ k ].logic[ j ].triggers,
-                        {
-                            specs: specs,
-                            nodeModules: flow.nodeModules
-                        }
-                    );
-                }
-                // No top-level resolvedTriggers for controller
-                graph[ k ].resolvedTriggers = null;
+            ledger.failures += 1;
+            if ( ledger.failures >= ENV_VARS.messageFailureThreshold ) {
+                ledger.quarantined = true;
+                logger.error(
+                    `winkComposer/partitionManager: Partition '${partitionId}' quarantined after ` +
+                    `${ledger.failures} consecutive creation failures ` +
+                    `(last: ${creationError.message}). Later messages for it are dropped.`
+                );
             }
-        } // for ( let k = 0; k < specs.length; k += 1 )
+            throw creationError;
+        }
+        composerState.creationFailures.delete( specializedGraphs );
 
         specializedGraphs[ specializationType ] = graph;
     }

package/src/core/partition-manager/validate-flow.js

@@ -145,7 +145,7 @@ const validateFlow = function ( flow ) {
             actualType = typeof flow;
         }
         throw new TypeError(
-            `WinkComposer/partitionManager validation failed:\n  flow: Expected object, got ${actualType}`
+            `winkComposer/partitionManager: validation failed:\n  flow: Expected object, got ${actualType}`
         );
     }
 

package/src/core/semantics/loader.js

@@ -27,7 +27,7 @@ import { readFile } from 'node:fs/promises';
 import { basename } from 'node:path';
 
 // Standard error prefix for all semantic loader errors
-const ERR_PREFIX = 'WinkComposer/semantics: ';
+const ERR_PREFIX = 'winkComposer/semantics: ';
 import { glob } from 'glob';
 import { validateWithSchema } from '../utils/validate/index.js';
 import {

package/src/core/semantics/warnings.js

@@ -16,6 +16,8 @@
  * @see core/storage-manager/questdb/persist-plan.js for onWarning callback pattern
  */
 
+import { logger } from '../logger/index.js';
+
 // ============================================================================
 // CONSTANTS
 // ============================================================================
@@ -24,7 +26,7 @@
  * Standard warning prefix for semantic validation warnings.
  * @type {string}
  */
-const WARNING_PREFIX = 'WinkComposer/semantics';
+const WARNING_PREFIX = 'winkComposer/semantics';
 
 // ============================================================================
 // DEFAULT WARNING HANDLER
@@ -32,12 +34,12 @@ const WARNING_PREFIX = 'WinkComposer/semantics';
 
 /**
  * Default warning handler for semantic validation issues.
- * Logs to console in WinkComposer format.
+ * Logs to console in winkComposer format.
  *
  * @param {string} message - Warning message describing the issue
  */
 const defaultOnWarning = function ( message ) {
-    console.warn( `${WARNING_PREFIX}: ${message}` );
+    logger.warn( `${WARNING_PREFIX}: ${message}` );
 };
 
 // ============================================================================

package/src/core/shutdown-manager/index.js

@@ -21,6 +21,15 @@
  *   wider scope: the per-adapter `{ timeout }` (one adapter's drain),
  *   the per-flow stage budget, and this process-level ceiling on the
  *   whole exit.
+ * - **Exit 1 on a data-losing stop** (the 2026-08-29 ruling). A drain
+ *   that rejects means that flow lost data at shutdown; the adapter
+ *   said so with a classified error. Each rejection prints one
+ *   classified console line, and the process exits 1 — a supervisor
+ *   (systemd, Docker, Kubernetes, a batch script) must never read a
+ *   data-losing stop as clean. This extends ADR-018's delivery
+ *   invariant to the process boundary. Callers who invoke
+ *   `handle.shutdown()` directly are unaffected: they receive the
+ *   rejection themselves and own their own response.
  *
  * This layer owns NO storage. The storage-directory cleanup it used to
  * run (an `fs.rm` of STORAGE_DIR at dev/test shutdown) was removed
@@ -57,6 +66,7 @@
 
 import { emitters } from '../wiring/index.js';
 import { ENV_VARS } from '../env-vars.js';
+import { logger } from '../logger/index.js';
 
 /**
  * Factory that produces a fresh shutdown-manager instance with isolated
@@ -120,15 +130,24 @@ const createShutdownManager = function () {
     /**
      * Iterate every registered flow handle, calling `handle.shutdown()`
      * on each in parallel via `Promise.allSettled`. Race the whole drain
-     * against `timeoutMs`; if the timeout wins, return false so the
-     * caller can log + force-exit with code 1.
+     * against `timeoutMs`.
      *
-     * Returns true when no handles are registered (e.g., the legacy
-     * code path with no modern flows in process).
+     * A drain that REJECTS means that flow lost data at shutdown — the
+     * adapter said so with a classified error (`DELIVERY_FAILED` or
+     * `SHUTDOWN_TIMEOUT`, per ADR-018 a shutdown never resolves cleanly
+     * over a loss). Each rejection prints one classified console line
+     * and counts in `failedDrains`, so the caller can refuse the clean
+     * exit code (the 2026-08-29 exit-1 ruling).
+     *
+     * @param {number} timeoutMs - Ceiling for the whole drain
+     * @returns {Promise<{timedOut: boolean, failedDrains: number}>}
+     *   `timedOut` — the race hit the ceiling; the drains are still in
+     *   flight, so their outcomes are unknown and `failedDrains` stays 0.
+     *   `failedDrains` — how many drains rejected (0 with no handles).
      */
     const drainHandles = async function ( timeoutMs ) {
         if ( handles.size === 0 ) {
-            return true;
+            return { timedOut: false, failedDrains: 0 };
         }
 
         const drainAll = Promise.allSettled(
@@ -153,7 +172,25 @@ const createShutdownManager = function () {
         // that runs the manager and then expects to exit cleanly.
         // Same canonical pattern used by every source `stopFn`.
         clearTimeout( timerHandle );
-        return winner !== TIMED_OUT;
+        if ( winner === TIMED_OUT ) {
+            return { timedOut: true, failedDrains: 0 };
+        }
+
+        // The drain settled in time: read every outcome. The reads are
+        // null-safe because a rejection reason can be anything.
+        let failedDrains = 0;
+        for ( let i = 0; i < winner.length; i += 1 ) {
+            if ( winner[ i ].status === 'rejected' ) {
+                failedDrains += 1;
+                const reason = winner[ i ].reason;
+                const code = ( reason && reason.code ) || 'UNKNOWN';
+                const detail = ( reason && reason.message ) || String( reason );
+                const count = reason && reason.dropped && reason.dropped.count;
+                const droppedNote = ( typeof count === 'number' ) ? ` — ${count} message(s) dropped` : '';
+                logger.error( `winkComposer/shutdownManager: Flow drain failed [${code}]: ${detail}${droppedNote}` );
+            }
+        }
+        return { timedOut: false, failedDrains };
     };
 
     // ========================================================================
@@ -167,11 +204,16 @@ const createShutdownManager = function () {
      * 1. Drain registered flow handles (modern path).
      * 2. Run the legacy path block (clustered for retirement; warns once
      *    when actually doing work).
-     * 3. Return graceful (true) / forced (false) — the caller decides
-     *    the exit code.
+     * 3. Return graceful (true) / not-graceful (false) — the caller
+     *    decides the exit code.
+     *
+     * Graceful means BOTH: the drain finished inside the timeout, AND
+     * every drain resolved clean. A drain that rejected lost data, so
+     * it must not read as a clean stop (the 2026-08-29 exit-1 ruling;
+     * ADR-018's delivery invariant, extended to the process boundary).
      *
-     * @returns {Promise<boolean>} true on graceful completion, false on
-     *   forced timeout
+     * @returns {Promise<boolean>} true on graceful completion; false on
+     *   forced timeout or on any rejected drain
      */
     const shutdown = async function () {
         if ( isShuttingDown ) {
@@ -180,17 +222,23 @@ const createShutdownManager = function () {
         isShuttingDown = true;
 
         const timestamp = new Date().toISOString();
-        console.log( `\n[${timestamp}] Shutdown initiated` );
+        logger.info( `\nwinkComposer/shutdownManager: [${timestamp}] Shutdown initiated` );
 
         // Phase 1 (modern path): drain registered flow handles, racing
         // against the forced-shutdown timeout.
-        const graceful = await drainHandles( ENV_VARS.shutdownForceTimeoutMs );
-        if ( !graceful ) {
-            console.warn(
-                `  ⚠ Forced shutdown — flow drain exceeded ${ENV_VARS.shutdownForceTimeoutMs}ms; ` +
+        const drain = await drainHandles( ENV_VARS.shutdownForceTimeoutMs );
+        if ( drain.timedOut ) {
+            logger.warn(
+                `winkComposer/shutdownManager: Forced shutdown — flow drain exceeded ${ENV_VARS.shutdownForceTimeoutMs}ms; ` +
                 'some adapters may not have completed cleanly'
             );
         }
+        if ( drain.failedDrains > 0 ) {
+            logger.warn(
+                `winkComposer/shutdownManager: ${drain.failedDrains} flow drain(s) lost data (lines above) — shutdown is not clean`
+            );
+        }
+        const graceful = !drain.timedOut && ( drain.failedDrains === 0 );
 
         try {
             // ================================================================
@@ -219,9 +267,9 @@ const createShutdownManager = function () {
             const failedEmitters = emitterResults.filter( ( r ) => r.status === 'rejected' );
             if ( emitterResults.length > 0 ) {
                 if ( failedEmitters.length > 0 ) {
-                    console.warn( `  ⚠ Warning: ${failedEmitters.length} legacy emitter(s) failed to shutdown cleanly` );
+                    logger.warn( `winkComposer/shutdownManager: ${failedEmitters.length} legacy emitter(s) failed to shutdown cleanly` );
                 } else {
-                    console.log( '  ✓ Legacy message queues flushed' );
+                    logger.info( 'winkComposer/shutdownManager: Legacy message queues flushed' );
                 }
             }
 
@@ -229,12 +277,12 @@ const createShutdownManager = function () {
             // END LEGACY PATH
             // ================================================================
 
-            console.log( `[${new Date().toISOString()}] Shutdown complete\n` );
+            logger.info( `winkComposer/shutdownManager: [${new Date().toISOString()}] Shutdown complete\n` );
 
             return graceful;
 
         } catch ( error ) {
-            console.error( '✗ Shutdown error:', error );
+            logger.error( 'winkComposer/shutdownManager: Shutdown error: ' + ( ( error && error.stack ) || String( error ) ) );
             process.exitCode = 1;
             return false;
         }
@@ -251,7 +299,9 @@ const createShutdownManager = function () {
      * process regardless of caller.
      *
      * On signal: runs `shutdown()`, then `process.exit(0)` on graceful
-     * or `process.exit(1)` on forced timeout.
+     * completion. Exit is 1 on a forced timeout or when any flow's
+     * drain rejected — a rejected drain lost data, and the exit code
+     * must say so (the 2026-08-29 exit-1 ruling).
      */
     const attachHandlers = function () {
         if ( attached ) {
@@ -260,7 +310,7 @@ const createShutdownManager = function () {
         attached = true;
 
         const signalHandler = async function ( signalName ) {
-            console.log( `\ncomposer: Received ${signalName}` );
+            logger.info( `\nwinkComposer/shutdownManager: Received ${signalName}` );
             const graceful = await shutdown();
 
             /* c8 ignore next 2 -- fundamentally untestable: invoking the signal handler from a test would call process.exit and kill the test runner. The graceful/forced exit-code mapping is verified by the shutdown() return-value tests above. */