comisai 1.0.42 → 1.0.44

package/node_modules/@comis/daemon/dist/observability/delivery-queue-logger.js

@@ -2,15 +2,19 @@
 /**
  * Delivery queue observability: structured logging subscriber for queue
  * lifecycle events.
- * Subscribes to all 7 delivery queue events (delivery:enqueued, delivery:acked,
- * delivery:nacked, delivery:failed, delivery:queue_drained, delivery:hook_cancelled,
- * delivery:aborted) and logs with
+ * Subscribes to the 8 delivery queue / reply-binding events (delivery:enqueued,
+ * delivery:acked, delivery:nacked, delivery:failed, delivery:queue_drained,
+ * delivery:hook_cancelled, delivery:aborted, delivery:reply_bound) and logs with
  * canonical fields per the project logging rules.
  * Logging levels follow the boundary-event convention:
  * - INFO for boundary events: enqueue (message enters queue), ack (delivery
  *   confirmed), queue_drained (startup drain complete).
  * - WARN for degraded states: nack (transient failure, will retry) and fail
  *   (permanent failure). WARN events include hint and errorKind as required.
+ * - DEBUG for the reply->trajectory binding breadcrumb (delivery:reply_bound,
+ *   WR-01): a high-frequency per-reply positive signal, kept at DEBUG so it does
+ *   not flood INFO, but present so a reaction map-miss is one-call diagnosable
+ *   (the bind fired vs never fired) from the log trail alongside the bus event.
  * @module
  */
 /**
@@ -96,4 +100,20 @@ export function setupDeliveryQueueLogging(deps) {
             origin: data.origin,
         }, "Delivery aborted");
     });
+    // 8. Reply bound: the agent-reply messageId was bound to its trajectory scope
+    // on the primary inbound-reply path (WR-01). DEBUG, not INFO — this is a
+    // per-reply positive signal that would flood INFO, but the breadcrumb is
+    // load-bearing for diagnosing a reaction map-miss (a `delivery:reply_bound`
+    // for the messageId means the bind fired → a later miss is an eviction; its
+    // absence means the bind never fired). Counts/ids only (the event payload is
+    // already content-free); shares the messageId with the delivery:acked INFO.
+    eventBus.on("delivery:reply_bound", (data) => {
+        log.debug({
+            messageId: data.messageId,
+            channelType: data.channelType,
+            channelId: data.channelId,
+            traceId: data.traceId,
+            agentId: data.agentId,
+        }, "Agent reply bound to trajectory for reaction attribution");
+    });
 }

package/node_modules/@comis/daemon/dist/observability/index.d.ts

@@ -10,8 +10,6 @@ export { createLogLevelManager } from "./log-infra.js";
 export type { LogLevelManager } from "./log-infra.js";
 export { createTokenTracker } from "./token-tracker.js";
 export type { TokenTracker, TokenUsageEntry, TokenAggregation } from "./token-tracker.js";
-export { createLatencyRecorder } from "./latency-recorder.js";
-export type { LatencyRecorder, LatencyRecord, LatencyStats, OperationType, } from "./latency-recorder.js";
 export { createBillingEstimator } from "./billing-estimator.js";
 export type { BillingEstimator, BillingSnapshot, ProviderBilling, TokenUsagePoint, } from "./billing-estimator.js";
 export { createDiagnosticCollector } from "./diagnostic-collector.js";

package/node_modules/@comis/daemon/dist/observability/index.js

@@ -1,13 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
-// @comis/daemon/observability - trace logging, token tracking, latency metrics, log level control
+// @comis/daemon/observability - trace logging, token tracking, log level control
 // Trace logger: Pino mixin for AsyncLocalStorage context injection
 export { createTracingLogger } from "./trace-logger.js";
 // Log level manager: per-module runtime log level control
 export { createLogLevelManager } from "./log-infra.js";
 // Token tracker: LLM usage with provider/model attribution
 export { createTokenTracker } from "./token-tracker.js";
-// Latency recorder: operation timing with percentile statistics
-export { createLatencyRecorder } from "./latency-recorder.js";
 // Billing estimator: CostTracker aggregation with time-windowed queries
 export { createBillingEstimator } from "./billing-estimator.js";
 // Diagnostic collector: EventBus subscriber with queryable ring buffer

package/node_modules/@comis/daemon/dist/observability/log-infra.d.ts

@@ -52,6 +52,14 @@ export declare function isPm2Managed(): boolean;
  * @param config - Logging config from DaemonConfigSchema.logging
  * @param level - Log level to apply to each target (Pino multi-transport
  *   targets default to "info" unless explicitly set)
+ * @param logRotation - Optional cross-stream rotation policy from
+ *   AppConfig.observability.logRotation. When provided, overrides
+ *   config.maxSize + config.maxFiles for the pino-roll transport.
+ *   IMPORTANT: pino-roll `size` treats bare numbers as MB, NOT bytes. Always
+ *   convert maxSizeBytes → "${Math.round(maxSizeBytes / (1024 * 1024))}m".
  * @returns Transport config to pass as LoggerOptions.transport
  */
-export declare function createFileTransport(config: LoggingConfig, level?: string): pino.TransportMultiOptions;
+export declare function createFileTransport(config: LoggingConfig, level?: string, logRotation?: {
+    maxSizeBytes: number;
+    maxFiles: number;
+}): pino.TransportMultiOptions;

package/node_modules/@comis/daemon/dist/observability/log-infra.js

@@ -73,33 +73,66 @@ export function isPm2Managed() {
  * @param config - Logging config from DaemonConfigSchema.logging
  * @param level - Log level to apply to each target (Pino multi-transport
  *   targets default to "info" unless explicitly set)
+ * @param logRotation - Optional cross-stream rotation policy from
+ *   AppConfig.observability.logRotation. When provided, overrides
+ *   config.maxSize + config.maxFiles for the pino-roll transport.
+ *   IMPORTANT: pino-roll `size` treats bare numbers as MB, NOT bytes. Always
+ *   convert maxSizeBytes → "${Math.round(maxSizeBytes / (1024 * 1024))}m".
  * @returns Transport config to pass as LoggerOptions.transport
  */
-export function createFileTransport(config, level) {
+export function createFileTransport(config, level, logRotation) {
     const expandedPath = expandTilde(config.filePath);
     const pm2Detected = isPm2Managed();
+    // Compute size string and file count from logRotation policy when present.
+    // pino-roll `size` semantics: bare numbers = MB (NOT bytes). Always use string form.
+    const sizeStr = logRotation
+        ? `${Math.round(logRotation.maxSizeBytes / (1024 * 1024))}m` // pino-roll treats bare numbers as MB, NOT bytes
+        : config.maxSize;
+    const countLimit = logRotation ? logRotation.maxFiles : config.maxFiles;
+    // Each destination is expressed as a TransportPipelineOptions entry:
+    //   pipeline[0] = upstream redact stage (Transform)
+    //   pipeline[1] = final destination (Writable)
+    //
+    // This is the correct pino pattern for chaining a transform before a writable:
+    // targets[] may contain TransportPipelineOptions (pipeline array, no `target` property)
+    // OR TransportTargetOptions (target string, no `pipeline` property) — pino's worker
+    // routes them differently. A pipeline entry runs as a chain:
+    //   source → redact-stage → file-destination
+    //
+    // IMPORTANT: `target + pipeline` on the same object is NOT supported — pino's transport.js
+    // adds such entries to BOTH `options.targets` (raw write) AND `options.pipelines` (stage-only,
+    // no final dest). Using TransportPipelineOptions (pipeline-only, no target) is the correct API.
     const targets = [];
     // File transport: always active -- ~/.comis/logs/ is the canonical log location
+    // The redact stage runs upstream of pino-roll so every line is scrubbed before disk write
     targets.push({
-        target: "pino-roll",
-        options: {
-            file: expandedPath,
-            size: config.maxSize,
-            mkdir: true,
-            limit: {
-                count: config.maxFiles,
-                removeOtherLogFiles: true,
+        pipeline: [
+            { target: "@comis/infra/dist/logging/pipeline-redact-stage.js" },
+            {
+                target: "pino-roll",
+                options: {
+                    file: expandedPath,
+                    size: sizeStr,
+                    mkdir: true,
+                    limit: {
+                        count: countLimit,
+                        removeOtherLogFiles: true,
+                    },
+                },
             },
-        },
+        ],
         ...(level ? { level } : {}),
     });
     // Stdout: skip under pm2 (pm2 captures stdout to ~/.pm2/logs/, so it would be a duplicate)
+    // The redact stage runs upstream of pino/file so every line is scrubbed before stdout write
     if (!pm2Detected) {
         targets.push({
-            target: "pino/file",
-            options: { destination: 1 }, // stdout
+            pipeline: [
+                { target: "@comis/infra/dist/logging/pipeline-redact-stage.js" },
+                { target: "pino/file", options: { destination: 1 } }, // stdout
+            ],
             ...(level ? { level } : {}),
         });
     }
-    return { targets };
+    return { targets: targets };
 }

package/node_modules/@comis/daemon/dist/observability/obs-audit-sink.d.ts

@@ -0,0 +1,119 @@
+/**
+ * AUDIT-01/02/04 — the durable security-audit sink (row-builders + the buffer +
+ * the per-event subscribers + the three sinks per event).
+ *
+ * Every audit-source event maps to an {@link AuditEventRow}. The `audit:event`
+ * `metadata` free-map (the ONE escape hatch) is routed through
+ * `sanitizeForPersistence` before it lands in `refs` (AUDIT-04). The other
+ * events are structurally content-free (the truncated prefixes / closed labels)
+ * but STILL re-apply the scrub uniformly — one chokepoint, defense-in-depth.
+ *
+ * Each event produces THREE artifacts: an `obs_audit_events` SQLite row (via the
+ * dedicated audit buffer), a scrubbed 0600 `security-audit.jsonl` line (the 6th
+ * stream under the shared `observability.logRotation`), and a `.audit()` (level
+ * 35) log line. Tenant-less events resolve `(tenant, agent, traceId)` from the
+ * AsyncLocalStorage trace context when present, else persist `tenant_id=''`
+ * (system-scoped) — NEVER dropped (decision #2).
+ *
+ * Extracted from `obs-persistence-wiring.ts` to keep that file under the
+ * 800-line cap (the Plan-01/02 row-shapes extraction precedent).
+ *
+ * @module
+ */
+import type { EventMap, AuditKind, TypedEventBus } from "@comis/core";
+import type { AuditEventRow } from "@comis/memory";
+import type { ComisLogger } from "@comis/infra";
+/**
+ * Rotation fallback for the security-audit.jsonl stream when an older caller
+ * omits `logRotation`. Aligned to `LogRotationConfigSchema`'s defaults
+ * (`packages/core/src/config/schema-observability.ts` — 50 MB / 5 files) so the
+ * two can't drift (the AUDIT-01/L1 review found the prior 10 MB literal here
+ * disagreed with the 50 MB schema default). NOT imported from the schema to
+ * avoid a daemon→core schema-coupling for two scalars; the doc-comment + this
+ * note are the binding.
+ */
+export declare const AUDIT_JSONL_DEFAULT_MAX_SIZE_BYTES: number;
+export declare const AUDIT_JSONL_DEFAULT_MAX_FILES = 5;
+/**
+ * Minimal write-buffer surface the audit sink needs (`push` only) — declared
+ * locally to avoid importing the full `ObsWriteBuffer` from
+ * `obs-persistence-wiring.ts`, which would form a wiring↔sink import cycle. The
+ * wiring file creates the concrete buffer (its `ObsWriteBuffer<AuditEventRow>`
+ * is structurally assignable) and owns its drain in `drainAll()`.
+ */
+export interface AuditRowSink {
+    push(row: AuditEventRow): void;
+}
+/**
+ * Severity mapping for an audit kind. Security signals → "warning"; routine
+ * audit / auth-mutation → "info". Mirrors `kindIsSecuritySignal` but kept local
+ * (a string label, not a boolean) so the row carries an operator-readable
+ * severity without importing the exhaustiveness guard into the wiring layer.
+ */
+export declare function kindToSeverity(kind: string): string;
+/**
+ * Derive an `AuditKind` from an `actionType` when an un-migrated emit omits
+ * `payload.kind` (defense-in-depth fallback — Plan 02's WIRE SHAPE: read
+ * `payload.kind` when present, derive from `actionType` only as a fallback).
+ * Unknown actionTypes fall back to the generic `audit` family.
+ */
+export declare function deriveKindFromActionType(actionType: string): AuditKind;
+/**
+ * Build a content-free AuditEventRow from an `audit:event` payload (AUDIT-01/04).
+ * The `metadata` free-map is routed through `sanitizeForPersistence` (keys +
+ * scalar counts/ids/digests only) and packed into `refs` — NEVER the raw
+ * metadata. `kind` comes from the wire shape (`payload.kind`) or is derived from
+ * `actionType` as a fallback. `classification` is carried only when it is a
+ * genuine read|mutate|destructive (else null). The caller resolves
+ * `(tenant, agent, traceId)` and passes them in (audit:event carries its own
+ * tenantId; tenant-less events resolve from the trace context).
+ */
+export declare function auditEventToRow(payload: EventMap["audit:event"], resolvedTenant: string, resolvedAgent: string | null, resolvedTraceId: string | undefined): AuditEventRow;
+/** Args for {@link buildAuditRow}. */
+export interface BuildAuditRowArgs {
+    kind: AuditKind;
+    ts: number;
+    tenant: string;
+    agent: string | null;
+    traceId: string | undefined;
+    action: string | null;
+    actor: string | null;
+    outcome: string | null;
+    refs: Record<string, unknown>;
+}
+/**
+ * Shared content-free row factory for the tenant-less audit-source events
+ * (secret:accessed / the security:* / critic.isolation.* / command:blocked).
+ * The `refs` map carries CLOSED LABELS / NAMES / COUNTS only — already
+ * content-free at the emit site — but is STILL routed through
+ * `sanitizeForPersistence` uniformly (one chokepoint). `(tenant, agent,
+ * traceId)` are resolved by the caller from the trace context (else the `''`
+ * system-scope sentinel; the event is NEVER dropped — decision #2).
+ */
+export declare function buildAuditRow(args: BuildAuditRowArgs): AuditEventRow;
+/** Dependencies for {@link wireAuditSink}. */
+export interface WireAuditSinkDeps {
+    eventBus: TypedEventBus;
+    /** The dedicated audit buffer (the SQLite half — its flushFn calls insertAuditEvent). */
+    auditBuffer: AuditRowSink;
+    logger?: ComisLogger;
+    /** Data directory (`~/.comis`); the JSONL lives at `<dataDir>/logs/security-audit.jsonl`. */
+    dataDir?: string;
+    /** The shared `observability.logRotation` bounds (the 6th stream). */
+    logRotation?: {
+        maxSizeBytes: number;
+        maxFiles: number;
+    };
+    /** The `observability.audit` policy (defaults: persist on, both sinks). */
+    auditConfig?: {
+        persist: boolean;
+        sink: "sqlite" | "jsonl" | "both";
+    };
+}
+/**
+ * Subscribe the durable security-audit sink: every audit-source event →
+ * an obs_audit_events row (the buffer) + a scrubbed 0600 security-audit.jsonl
+ * line + a `.audit()` (level 35) log line. Returns nothing — the caller owns the
+ * buffer's lifecycle (it is drained in `drainAll()`).
+ */
+export declare function wireAuditSink(deps: WireAuditSinkDeps): void;