comisai 1.0.19 → 1.0.22

package/node_modules/@comis/core/dist/ports/media-ports.d.ts

@@ -1,278 +0,0 @@
-import type { Result } from "@comis/shared";
-import type { Attachment } from "../domain/normalized-message.js";
-/**
- * Options for audio transcription.
- */
-export interface TranscriptionOptions {
-    /** MIME type of the audio buffer (e.g. "audio/ogg", "audio/mp3") */
-    readonly mimeType: string;
-    /** BCP-47 language hint (e.g. "en", "es"). Provider may auto-detect if omitted. */
-    readonly language?: string;
-    /** Optional prompt/context to guide transcription accuracy. */
-    readonly prompt?: string;
-}
-/**
- * Result of a successful transcription.
- */
-export interface TranscriptionResult {
-    /** Transcribed text. */
-    readonly text: string;
-    /** Detected or confirmed language (BCP-47). */
-    readonly language?: string;
-    /** Duration of the audio in milliseconds. */
-    readonly durationMs?: number;
-}
-/**
- * TranscriptionPort: Hexagonal boundary for speech-to-text services.
- *
- * Adapters (OpenAI Whisper, local whisper.cpp, etc.) implement this
- * interface to convert audio buffers into text.
- */
-export interface TranscriptionPort {
-    /**
-     * Transcribe an audio buffer to text.
-     *
-     * @param audio - Raw audio data
-     * @param options - MIME type, language hint, optional prompt
-     * @returns Transcription result or an error (e.g. file too large, API failure)
-     */
-    transcribe(audio: Buffer, options: TranscriptionOptions): Promise<Result<TranscriptionResult, Error>>;
-}
-/**
- * Options for text-to-speech synthesis.
- */
-export interface TTSOptions {
-    /** Voice identifier (provider-specific, e.g. "alloy", "nova"). */
-    readonly voice?: string;
-    /** Output audio format (e.g. "mp3", "opus", "aac", "flac"). */
-    readonly format?: string;
-    /** Playback speed multiplier (0.25 to 4.0). */
-    readonly speed?: number;
-}
-/**
- * Result of a successful TTS synthesis.
- */
-export interface TTSResult {
-    /** Raw audio data. */
-    readonly audio: Buffer;
-    /** MIME type of the audio (e.g. "audio/mpeg", "audio/opus"). */
-    readonly mimeType: string;
-}
-/**
- * TTSPort: Hexagonal boundary for text-to-speech services.
- *
- * Adapters (OpenAI TTS, ElevenLabs, local Piper, etc.) implement this
- * interface to synthesize audio from text.
- */
-export interface TTSPort {
-    /**
-     * Synthesize text into audio.
-     *
-     * @param text - Text content to convert to speech
-     * @param options - Voice, format, and speed configuration
-     * @returns Audio buffer with MIME type, or an error
-     */
-    synthesize(text: string, options?: TTSOptions): Promise<Result<TTSResult, Error>>;
-}
-/**
- * Options for image analysis.
- */
-export interface ImageAnalysisOptions {
-    /** MIME type of the image buffer (e.g. "image/png", "image/jpeg"). */
-    readonly mimeType: string;
-    /** Maximum tokens in the analysis response. */
-    readonly maxTokens?: number;
-}
-/**
- * ImageAnalysisPort: Hexagonal boundary for multimodal image analysis.
- *
- * Adapters (Anthropic Claude, OpenAI GPT-4o, etc.) implement this
- * interface to analyze images using vision-capable LLMs.
- */
-export interface ImageAnalysisPort {
-    /**
-     * Analyze an image given a prompt.
-     *
-     * @param image - Raw image data
-     * @param prompt - Question or instruction about the image
-     * @param options - MIME type and response length configuration
-     * @returns Analysis text or an error (e.g. file too large, unsupported format)
-     */
-    analyze(image: Buffer, prompt: string, options: ImageAnalysisOptions): Promise<Result<string, Error>>;
-}
-/**
- * Request payload for image vision analysis.
- */
-export interface VisionRequest {
-    /** Raw image data. */
-    readonly image: Buffer;
-    /** Question or instruction about the image. */
-    readonly prompt: string;
-    /** MIME type of the image (e.g. "image/png", "image/jpeg"). */
-    readonly mimeType: string;
-    /** Maximum tokens in the response. */
-    readonly maxTokens?: number;
-}
-/**
- * Request payload for video vision analysis.
- */
-export interface VideoRequest {
-    /** Raw video data. */
-    readonly video: Buffer;
-    /** Question or instruction about the video. */
-    readonly prompt: string;
-    /** MIME type of the video (e.g. "video/mp4", "video/webm"). */
-    readonly mimeType: string;
-    /** Maximum tokens in the response. */
-    readonly maxTokens?: number;
-}
-/**
- * Result of a vision analysis (image or video).
- */
-export interface VisionResult {
-    /** Analysis text. */
-    readonly text: string;
-    /** Provider that produced the result (e.g. "openai", "anthropic", "google"). */
-    readonly provider: string;
-    /** Model used for analysis. */
-    readonly model: string;
-    /** Tokens used (if available from the provider). */
-    readonly tokensUsed?: number;
-}
-/**
- * VisionProvider: Multi-capability vision analysis provider.
- *
- * Each provider declares which media types it supports (image, video, or both).
- * The registry uses capabilities to route requests to the right provider.
- */
-export interface VisionProvider {
-    /** Unique provider identifier (e.g. "openai", "anthropic", "google"). */
-    readonly id: string;
-    /** Media types this provider can analyze. */
-    readonly capabilities: ReadonlyArray<"image" | "video">;
-    /** Analyze an image. */
-    describeImage(req: VisionRequest): Promise<Result<VisionResult, Error>>;
-    /** Analyze a video (optional — only providers with "video" capability). */
-    describeVideo?(req: VideoRequest): Promise<Result<VisionResult, Error>>;
-}
-/**
- * Result of resolving a media attachment to a buffer.
- */
-export interface ResolvedMedia {
-    /** Downloaded file content. */
-    readonly buffer: Buffer;
-    /** Verified MIME type (sniffed, not declared). */
-    readonly mimeType: string;
-    /** File size in bytes. */
-    readonly sizeBytes: number;
-}
-/**
- * MediaResolverPort: Hexagonal boundary for media resolution.
- *
- * Per-platform adapters implement this interface to download attachments
- * from platform-specific URLs (e.g., tg-file:// for Telegram, https://
- * for public URLs). The resolver registry routes to the correct adapter
- * based on the URI scheme.
- */
-export interface MediaResolverPort {
-    /** URI schemes this resolver handles (e.g., ["tg-file", "https"]). */
-    readonly schemes: ReadonlyArray<string>;
-    /**
-     * Resolve an attachment URL to a downloaded buffer.
-     *
-     * Implementations MUST validate URLs through validateUrl() from
-     * @comis/core/security before any HTTP request to prevent SSRF.
-     * Private, loopback, link-local, and cloud-metadata IPs are blocked.
-     * DNS rebinding protection is mandatory: resolve hostname to IP,
-     * check blocklist, then connect using pinned IP.
-     *
-     * Implementations MUST check Content-Length against the configured
-     * maxRemoteFetchBytes limit and abort before streaming the body
-     * if exceeded.
-     *
-     * @param attachment - The attachment to resolve
-     * @returns Resolved media buffer with MIME type and size, or an error
-     */
-    resolve(attachment: Attachment): Promise<Result<ResolvedMedia, Error>>;
-}
-/**
- * Classification of a file based on its MIME type.
- *
- * - `"document"`: Extractable text content in the MIME whitelist (PDF, plain text, CSV, etc.)
- * - `"binary"`: Known binary format (images, audio, video, archives) — not text-extractable
- * - `"unknown"`: Unrecognized MIME type — classification cannot be determined
- */
-export type FileClassification = "document" | "binary" | "unknown";
-/**
- * Error categories for file extraction failures.
- */
-export type FileExtractionErrorKind = "timeout" | "encrypted" | "size_exceeded" | "unsupported_mime" | "encoding_error" | "corrupt" | "download_failed" | "internal";
-/**
- * Structured error returned by FileExtractionPort on failure.
- */
-export interface FileExtractionError {
-    readonly kind: FileExtractionErrorKind;
-    readonly message: string;
-    readonly mimeType?: string;
-    readonly fileName?: string;
-}
-/**
- * Input for file extraction. Discriminated union on the `source` field.
- *
- * - `"buffer"`: Extract from an in-memory buffer (mimeType required).
- * - `"url"`: Extract from a remote URL (mimeType optional, may need detection).
- */
-export type FileExtractionInput = {
-    readonly source: "buffer";
-    readonly buffer: Buffer;
-    readonly mimeType: string;
-    readonly fileName?: string;
-    readonly sizeBytes?: number;
-} | {
-    readonly source: "url";
-    readonly url: string;
-    readonly mimeType?: string;
-    readonly fileName?: string;
-    readonly sizeBytes?: number;
-};
-/**
- * Result of a successful file extraction.
- */
-export interface FileExtractionResult {
-    /** Extracted text content. */
-    readonly text: string;
-    /** File name (original or detected). */
-    readonly fileName: string;
-    /** MIME type of the source file. */
-    readonly mimeType: string;
-    /** Number of characters in the extracted text. */
-    readonly extractedChars: number;
-    /** Whether the text was truncated to fit maxChars. */
-    readonly truncated: boolean;
-    /** Time taken for extraction in milliseconds. */
-    readonly durationMs: number;
-    /** Original file buffer for downstream re-use. */
-    readonly buffer: Buffer;
-    /** Number of pages extracted (for paginated formats like PDF). */
-    readonly pageCount?: number;
-    /** Total pages in the document (may differ from pageCount if maxPages limit applied). */
-    readonly totalPages?: number;
-}
-/**
- * FileExtractionPort: Hexagonal boundary for document text extraction services.
- *
- * Adapters implement this interface to extract text content from document files
- * (PDF, plain text, CSV, etc.). The port accepts both in-memory buffers and
- * remote URLs as input sources.
- */
-export interface FileExtractionPort {
-    /**
-     * Extract text content from a document file.
-     *
-     * @param input - File source (buffer or URL) with metadata
-     * @returns Extraction result with text and metrics, or a structured error
-     */
-    extract(input: FileExtractionInput): Promise<Result<FileExtractionResult, FileExtractionError>>;
-    /** MIME types this adapter can extract text from. */
-    readonly supportedMimes: ReadonlyArray<string>;
-}

package/node_modules/@comis/core/dist/ports/media-ports.js

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/core/dist/security/input-guard.d.ts

@@ -1,46 +0,0 @@
-/**
- * InputGuard — Semantic jailbreak detection with weighted 0.0-1.0 threat scoring.
- *
- * Factory function that creates a guard object with a `scan()` method. Detects
- * jailbreak attempts using weighted compound phrase patterns imported from
- * `injection-patterns.ts`, typoglycemia detection for 8 key terms, and code
- * block exclusion to minimize false positives on technical content.
- *
- * Returns scored results that PiExecutor uses for policy decisions:
- * - low risk (< mediumThreshold) -> action "pass"
- * - medium risk (>= mediumThreshold, < highThreshold) -> action "reinforce"
- * - high risk (>= highThreshold) -> action "warn" (default) or "block" (config)
- *
- * @module input-guard
- * @since Phase 283 (INPUT-03 through INPUT-06)
- */
-export interface InputGuardConfig {
-    /** Threat score threshold for "medium" risk (triggers reinforcement). Default: 0.4. */
-    readonly mediumThreshold: number;
-    /** Threat score threshold for "high" risk (triggers warn/block). Default: 0.7. */
-    readonly highThreshold: number;
-    /** Action for high-risk detections. Default: "warn". "block" requires explicit config. */
-    readonly action: "warn" | "block";
-}
-export interface InputGuardResult {
-    /** Threat score clamped to 0.0-1.0. */
-    readonly score: number;
-    /** Risk level derived from score vs thresholds. */
-    readonly riskLevel: "low" | "medium" | "high";
-    /** Matched pattern category names. */
-    readonly patterns: string[];
-    /** Recommended policy action. */
-    readonly action: "pass" | "warn" | "reinforce" | "block";
-}
-export interface InputGuard {
-    scan(text: string): InputGuardResult;
-}
-/**
- * Create an InputGuard that scores user input text for jailbreak risk.
- *
- * Configuration is optional; all fields have sensible defaults:
- * - mediumThreshold: 0.4
- * - highThreshold: 0.7
- * - action: "warn" (operator must explicitly set "block" to enable blocking)
- */
-export declare function createInputGuard(config?: Partial<InputGuardConfig>): InputGuard;

package/node_modules/@comis/core/dist/security/input-guard.js

@@ -1,166 +0,0 @@
-/**
- * InputGuard — Semantic jailbreak detection with weighted 0.0-1.0 threat scoring.
- *
- * Factory function that creates a guard object with a `scan()` method. Detects
- * jailbreak attempts using weighted compound phrase patterns imported from
- * `injection-patterns.ts`, typoglycemia detection for 8 key terms, and code
- * block exclusion to minimize false positives on technical content.
- *
- * Returns scored results that PiExecutor uses for policy decisions:
- * - low risk (< mediumThreshold) -> action "pass"
- * - medium risk (>= mediumThreshold, < highThreshold) -> action "reinforce"
- * - high risk (>= highThreshold) -> action "warn" (default) or "block" (config)
- *
- * @module input-guard
- * @since Phase 283 (INPUT-03 through INPUT-06)
- */
-import { IGNORE_PREV_INSTRUCTIONS, IGNORE_INSTRUCTIONS_BROAD, DISREGARD_PREVIOUS, DISREGARD_INSTRUCTIONS, FORGET_EVERYTHING, FORGET_INSTRUCTIONS_BROAD, YOU_ARE_NOW, YOU_ARE_NOW_ARTICLE, NEW_INSTRUCTIONS, NEW_INSTRUCTIONS_COLON, IMPORTANT_OVERRIDE, OVERRIDE_SAFETY, ACT_AS_ROLE, CONTEXT_RESET, RULE_REPLACEMENT, SYSTEM_TAG, SYSTEM_BRACKET, SYSTEM_COMMAND, SPECIAL_TOKEN_DELIMITERS, ROLE_BOUNDARY, ASSISTANT_ROLE_MARKER, } from "./injection-patterns.js";
-// ---------------------------------------------------------------------------
-// Weighted pattern categories (Pattern 6 from research)
-// ---------------------------------------------------------------------------
-/**
- * Each category groups related regex patterns with a single weight.
- * If ANY pattern in a category matches, the weight is added once (boolean per category).
- * Multiple matches within the same category do NOT multiply the weight.
- */
-const PATTERN_WEIGHTS = [
-    { patterns: [IGNORE_PREV_INSTRUCTIONS, IGNORE_INSTRUCTIONS_BROAD], weight: 0.6, name: "ignore_instructions" },
-    { patterns: [DISREGARD_PREVIOUS, DISREGARD_INSTRUCTIONS], weight: 0.5, name: "disregard_previous" },
-    { patterns: [FORGET_EVERYTHING, FORGET_INSTRUCTIONS_BROAD], weight: 0.5, name: "forget_instructions" },
-    { patterns: [YOU_ARE_NOW, YOU_ARE_NOW_ARTICLE], weight: 0.4, name: "role_assumption" },
-    { patterns: [NEW_INSTRUCTIONS, NEW_INSTRUCTIONS_COLON], weight: 0.5, name: "new_instructions" },
-    { patterns: [IMPORTANT_OVERRIDE], weight: 0.5, name: "important_override" },
-    { patterns: [OVERRIDE_SAFETY], weight: 0.6, name: "override_safety" },
-    { patterns: [ACT_AS_ROLE], weight: 0.4, name: "act_as_role" },
-    { patterns: [CONTEXT_RESET], weight: 0.4, name: "context_reset" },
-    { patterns: [RULE_REPLACEMENT], weight: 0.4, name: "rule_replacement" },
-    { patterns: [SYSTEM_TAG, SYSTEM_BRACKET, SYSTEM_COMMAND], weight: 0.3, name: "system_markers" },
-    { patterns: [SPECIAL_TOKEN_DELIMITERS], weight: 0.3, name: "special_tokens" },
-    { patterns: [ROLE_BOUNDARY, ASSISTANT_ROLE_MARKER], weight: 0.2, name: "role_markers" },
-];
-// ---------------------------------------------------------------------------
-// Code block exclusion (INPUT-06)
-// ---------------------------------------------------------------------------
-/**
- * Regex to match fenced code blocks (triple backtick) and inline code (single backtick).
- * ReDoS-safe: [\s\S]*? is non-greedy character class without alternation.
- */
-const CODE_BLOCK_REGEX = /```[\s\S]*?```|`[^`\n]+`/g;
-function stripCodeBlocks(text) {
-    CODE_BLOCK_REGEX.lastIndex = 0;
-    return text.replace(CODE_BLOCK_REGEX, " ");
-}
-// ---------------------------------------------------------------------------
-// Typoglycemia detection (INPUT-05)
-// ---------------------------------------------------------------------------
-/**
- * The 8 key jailbreak terms to check for scrambled-middle variants.
- * All are 5+ characters long, ensuring sufficient middle-letter entropy
- * to avoid false positives on short words.
- */
-const TYPOGLYCEMIA_TERMS = [
-    "ignore",
-    "previous",
-    "instructions",
-    "system",
-    "bypass",
-    "override",
-    "forget",
-    "delete",
-];
-/**
- * Check whether a word is a typoglycemia variant of a target term.
- *
- * A word is a variant if:
- * 1. Same length as target
- * 2. Same first character (case-insensitive)
- * 3. Same last character (case-insensitive)
- * 4. NOT an exact match (exact matches are handled by regex patterns)
- * 5. Same sorted middle characters
- *
- * This implements the "Cambridge University effect" where human readers
- * can understand words with scrambled middle letters.
- */
-function isTypoglycemiaVariant(word, target) {
-    if (word.length !== target.length)
-        return false;
-    const w = word.toLowerCase();
-    const t = target.toLowerCase();
-    if (w[0] !== t[0] || w[w.length - 1] !== t[t.length - 1])
-        return false;
-    if (w === t)
-        return false; // Exact match is NOT a variant
-    const wMiddle = [...w.slice(1, -1)].sort().join("");
-    const tMiddle = [...t.slice(1, -1)].sort().join("");
-    return wMiddle === tMiddle;
-}
-// ---------------------------------------------------------------------------
-// Factory function
-// ---------------------------------------------------------------------------
-/**
- * Create an InputGuard that scores user input text for jailbreak risk.
- *
- * Configuration is optional; all fields have sensible defaults:
- * - mediumThreshold: 0.4
- * - highThreshold: 0.7
- * - action: "warn" (operator must explicitly set "block" to enable blocking)
- */
-export function createInputGuard(config) {
-    const mediumThreshold = config?.mediumThreshold ?? 0.4;
-    const highThreshold = config?.highThreshold ?? 0.7;
-    const action = config?.action ?? "warn";
-    return {
-        scan(text) {
-            const stripped = stripCodeBlocks(text);
-            const matched = [];
-            let score = 0;
-            // 1. Weighted pattern category matching
-            for (const category of PATTERN_WEIGHTS) {
-                let categoryMatched = false;
-                for (const pattern of category.patterns) {
-                    // Reset lastIndex before each test() call (patterns have /g or /gi flags)
-                    pattern.lastIndex = 0;
-                    if (pattern.test(stripped)) {
-                        categoryMatched = true;
-                        break; // Category is boolean -- one match suffices
-                    }
-                }
-                if (categoryMatched) {
-                    score += category.weight;
-                    matched.push(category.name);
-                }
-            }
-            // 2. Typoglycemia detection
-            const words = stripped.split(/\s+/);
-            for (const word of words) {
-                if (word.length === 0)
-                    continue;
-                for (const term of TYPOGLYCEMIA_TERMS) {
-                    if (isTypoglycemiaVariant(word, term)) {
-                        matched.push(`typoglycemia:${term}`);
-                        score += 0.3;
-                        break; // One word matches at most one term
-                    }
-                }
-            }
-            // 3. Clamp score to [0.0, 1.0]
-            score = Math.min(score, 1.0);
-            // 4. Determine risk level
-            const riskLevel = score >= highThreshold ? "high"
-                : score >= mediumThreshold ? "medium"
-                    : "low";
-            // 5. Determine action
-            let resultAction;
-            if (riskLevel === "high") {
-                resultAction = action === "block" ? "block" : "warn";
-            }
-            else if (riskLevel === "medium") {
-                resultAction = "reinforce";
-            }
-            else {
-                resultAction = "pass";
-            }
-            return { score, riskLevel, patterns: matched, action: resultAction };
-        },
-    };
-}

package/node_modules/@comis/core/dist/security/scoped-secret-manager.d.ts

@@ -1,38 +0,0 @@
-/**
- * ScopedSecretManager — per-agent SecretManager decorator with glob filtering.
- *
- * Wraps a base SecretManager and restricts access to secrets matching
- * the agent's allow patterns. Every access attempt (get, has, require)
- * emits a `secret:accessed` audit event through the optional TypedEventBus.
- *
- * Design decisions:
- * - Decorator pattern: callers cannot distinguish from a plain SecretManager
- * - Empty allowPatterns = unrestricted access (backward compat for existing agents)
- * - eventBus is optional: if omitted, no audit events are emitted (unit-test friendly)
- * - keys() filters but does not emit (listing operation, not access)
- */
-import type { SecretManager } from "./secret-manager.js";
-import type { TypedEventBus } from "../event-bus/index.js";
-/**
- * Options for creating a scoped (per-agent) SecretManager.
- */
-export interface ScopedSecretManagerOptions {
-    /** The agent this scoped manager belongs to. Included in all audit events. */
-    agentId: string;
-    /** Glob patterns that grant access. Empty array = unrestricted (backward compat). */
-    allowPatterns: string[];
-    /** Optional event bus for audit event emission. No-op if omitted. */
-    eventBus?: TypedEventBus;
-}
-/**
- * Create a SecretManager that filters access by glob patterns and emits audit events.
- *
- * The returned object implements the SecretManager interface exactly — same 4 methods
- * (get, has, require, keys), same return types. This is the decorator pattern:
- * callers cannot distinguish a ScopedSecretManager from a plain SecretManager.
- *
- * @param base - The underlying SecretManager to delegate allowed accesses to
- * @param options - Agent ID, allow patterns, and optional event bus
- * @returns A SecretManager that enforces per-agent access control
- */
-export declare function createScopedSecretManager(base: SecretManager, options: ScopedSecretManagerOptions): SecretManager;

package/node_modules/@comis/core/dist/security/scoped-secret-manager.js

@@ -1,94 +0,0 @@
-/**
- * ScopedSecretManager — per-agent SecretManager decorator with glob filtering.
- *
- * Wraps a base SecretManager and restricts access to secrets matching
- * the agent's allow patterns. Every access attempt (get, has, require)
- * emits a `secret:accessed` audit event through the optional TypedEventBus.
- *
- * Design decisions:
- * - Decorator pattern: callers cannot distinguish from a plain SecretManager
- * - Empty allowPatterns = unrestricted access (backward compat for existing agents)
- * - eventBus is optional: if omitted, no audit events are emitted (unit-test friendly)
- * - keys() filters but does not emit (listing operation, not access)
- */
-import { isSecretAccessible } from "./secret-access.js";
-/**
- * Create a SecretManager that filters access by glob patterns and emits audit events.
- *
- * The returned object implements the SecretManager interface exactly — same 4 methods
- * (get, has, require, keys), same return types. This is the decorator pattern:
- * callers cannot distinguish a ScopedSecretManager from a plain SecretManager.
- *
- * @param base - The underlying SecretManager to delegate allowed accesses to
- * @param options - Agent ID, allow patterns, and optional event bus
- * @returns A SecretManager that enforces per-agent access control
- */
-export function createScopedSecretManager(base, options) {
-    const { agentId, allowPatterns, eventBus } = options;
-    let warnedNoAllow = false;
-    /**
-     * Emit a one-time security:warn event when an agent accesses secrets
-     * without explicit secrets.allow configuration (CORE-02).
-     */
-    function warnUnrestrictedAccess(secretName) {
-        if (warnedNoAllow || allowPatterns.length > 0 || !eventBus)
-            return;
-        warnedNoAllow = true;
-        eventBus.emit("security:warn", {
-            category: "secret_access",
-            agentId,
-            message: `Agent "${agentId}" accessed secret "${secretName}" without explicit secrets.allow configuration. ` +
-                `Configure secrets.allow patterns to restrict access.`,
-            timestamp: Date.now(),
-        });
-    }
-    function emitAccess(secretName, outcome) {
-        eventBus?.emit("secret:accessed", {
-            secretName,
-            agentId,
-            outcome,
-            timestamp: Date.now(),
-        });
-    }
-    return {
-        get(key) {
-            warnUnrestrictedAccess(key);
-            if (!isSecretAccessible(key, allowPatterns)) {
-                emitAccess(key, "denied");
-                return undefined;
-            }
-            const value = base.get(key);
-            emitAccess(key, value !== undefined ? "success" : "not_found");
-            return value;
-        },
-        has(key) {
-            warnUnrestrictedAccess(key);
-            if (!isSecretAccessible(key, allowPatterns)) {
-                emitAccess(key, "denied");
-                return false;
-            }
-            const exists = base.has(key);
-            emitAccess(key, exists ? "success" : "not_found");
-            return exists;
-        },
-        require(key) {
-            warnUnrestrictedAccess(key);
-            if (!isSecretAccessible(key, allowPatterns)) {
-                emitAccess(key, "denied");
-                throw new Error(`Agent "${agentId}" is not allowed to access secret "${key}". ` +
-                    `Check the agent's secrets.allow configuration.`);
-            }
-            const value = base.get(key);
-            if (value === undefined) {
-                emitAccess(key, "not_found");
-                throw new Error(`Required secret "${key}" is not set. ` +
-                    `Check that this key is defined in your .env file or encrypted store.`);
-            }
-            emitAccess(key, "success");
-            return value;
-        },
-        keys() {
-            return base.keys().filter((k) => isSecretAccessible(k, allowPatterns));
-        },
-    };
-}

package/node_modules/@comis/daemon/dist/observability/delivery-context.d.ts

@@ -1,37 +0,0 @@
-/**
- * DeliveryContext: metadata captured per message delivery for tracing (OBS-04).
- *
- * Records source/target channel identifiers, delivery timing, success status,
- * and optional attribution (agent, session). Downstream consumers use this
- * for delivery tracing dashboards and latency analysis.
- */
-export interface DeliveryContext {
-    /** Source channel that originated the message */
-    sourceChannelId: string;
-    sourceChannelType: string;
-    /** Delivery target */
-    targetChannelId: string;
-    targetChannelType: string;
-    /** Timestamp when delivery was initiated */
-    deliveredAt: number;
-    /** Time from message receipt to delivery completion in ms */
-    latencyMs: number;
-    /** Whether delivery succeeded */
-    success: boolean;
-    /** Error message if delivery failed */
-    error?: string;
-    /** Agent that processed the message */
-    agentId?: string;
-    /** Session key string */
-    sessionKey?: string;
-    /** Execution timeline steps synthesized from timing data */
-    steps?: Array<{
-        name: string;
-        timestamp: number;
-        durationMs: number;
-        status: "ok" | "error";
-        error?: string;
-    }>;
-    /** Additional metadata (retry count, parse mode fallback, etc.) */
-    metadata?: Record<string, unknown>;
-}

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

@@ -1 +0,0 @@
-export {};