salmon-loop 0.2.13 → 0.2.16

package/dist/core/llm/request-envelope.js

@@ -0,0 +1,334 @@
+import { createHash } from 'crypto';
+import { getPromptCachingManager } from '../context/cache/prompt-caching.js';
+function isArtifactHandle(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (typeof candidate.handle === 'string' &&
+        typeof candidate.mimeType === 'string' &&
+        typeof candidate.sha256 === 'string' &&
+        typeof candidate.size === 'number');
+}
+function mergeArtifactHandles(existing, incoming, limit = 4) {
+    const merged = [];
+    const seen = new Set();
+    for (const artifact of [...(existing ?? []), ...(incoming ?? [])]) {
+        if (!artifact || seen.has(artifact.handle))
+            continue;
+        seen.add(artifact.handle);
+        merged.push(artifact);
+    }
+    if (merged.length === 0)
+        return undefined;
+    return merged.slice(-limit);
+}
+function mergeReadArtifactRefs(existing, incoming, limit = 6) {
+    const merged = [];
+    const seen = new Set();
+    for (const item of [...(existing ?? []), ...(incoming ?? [])]) {
+        if (!item?.path || !item.artifact?.handle)
+            continue;
+        const key = `${item.path}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(item);
+    }
+    if (merged.length === 0)
+        return undefined;
+    return merged.slice(-limit);
+}
+function mergePreviewArtifactRefs(existing, incoming, limit = 6) {
+    const merged = [];
+    const seen = new Set();
+    for (const item of [...(existing ?? []), ...(incoming ?? [])]) {
+        if (!item?.label || !item.artifact?.handle)
+            continue;
+        const key = `${item.label}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(item);
+    }
+    if (merged.length === 0)
+        return undefined;
+    return merged.slice(-limit);
+}
+export function resolveRequestArtifactHints(params) {
+    const direct = params.artifactHints;
+    const auditEntries = params.toolCallingAudit ?? [];
+    const auditPatchArtifacts = [];
+    const auditAuditArtifacts = [];
+    const auditReadArtifacts = [];
+    const auditPreviewArtifacts = [];
+    for (const entry of auditEntries) {
+        if (entry?.toolResultStatus === 'ok' && entry.toolName === 'agent_dispatch') {
+            if (isArtifactHandle(entry.toolResultPatchArtifact)) {
+                auditPatchArtifacts.push(entry.toolResultPatchArtifact);
+            }
+            if (isArtifactHandle(entry.toolResultAuditArtifact)) {
+                auditAuditArtifacts.push(entry.toolResultAuditArtifact);
+            }
+        }
+        if (typeof entry.toolResultReadArtifactPath === 'string' &&
+            isArtifactHandle(entry.toolResultReadArtifact)) {
+            auditReadArtifacts.push({
+                path: entry.toolResultReadArtifactPath,
+                artifact: entry.toolResultReadArtifact,
+            });
+        }
+        if (typeof entry.toolResultPreviewLabel === 'string' &&
+            isArtifactHandle(entry.toolResultPreviewArtifact)) {
+            auditPreviewArtifacts.push({
+                label: entry.toolResultPreviewLabel,
+                artifact: entry.toolResultPreviewArtifact,
+            });
+        }
+    }
+    const resolved = {
+        verifyArtifact: direct?.verifyArtifact,
+        subAgentPatchArtifacts: mergeArtifactHandles(direct?.subAgentPatchArtifacts, auditPatchArtifacts),
+        subAgentAuditArtifacts: mergeArtifactHandles(direct?.subAgentAuditArtifacts, auditAuditArtifacts),
+        recentReadArtifacts: mergeReadArtifactRefs(direct?.recentReadArtifacts, auditReadArtifacts),
+        toolResultPreviewArtifacts: mergePreviewArtifactRefs(params.previewProvider?.getPreviewHints(), auditPreviewArtifacts),
+    };
+    if (!resolved.verifyArtifact &&
+        !resolved.subAgentPatchArtifacts?.length &&
+        !resolved.subAgentAuditArtifacts?.length &&
+        !resolved.recentReadArtifacts?.length &&
+        !resolved.toolResultPreviewArtifacts?.length) {
+        return undefined;
+    }
+    return resolved;
+}
+function toSafeMessage(message) {
+    if (!message || typeof message !== 'object')
+        return null;
+    if (message.role !== 'system' && message.role !== 'user' && message.role !== 'assistant') {
+        return null;
+    }
+    if (typeof message.content !== 'string')
+        return null;
+    const content = message.content.trimEnd();
+    if (!content)
+        return null;
+    return {
+        role: message.role,
+        content,
+    };
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function resolvePromptCacheMode(mode) {
+    return mode === 'strict_full_prompt' ? 'strict_full_prompt' : 'cache_safe_only';
+}
+function serializeAttachmentForFingerprint(item) {
+    return [
+        item.key,
+        item.kind,
+        item.label ?? '',
+        item.content ?? '',
+        item.artifactHandle ?? '',
+        item.mimeType ?? '',
+        typeof item.size === 'number' ? String(item.size) : '',
+    ].join('\u001f');
+}
+function createFingerprint(parts) {
+    if (parts.length === 0)
+        return undefined;
+    const hash = createHash('sha256');
+    for (const [index, part] of parts.entries()) {
+        hash.update(`part:${index}:${part.length}\n`);
+        hash.update(part);
+        hash.update('\n');
+    }
+    return hash.digest('hex');
+}
+function toArtifactAttachment(args) {
+    return {
+        key: args.key,
+        kind: 'artifact',
+        label: args.label,
+        content: '',
+        artifactHandle: args.artifact.handle,
+        mimeType: args.artifact.mimeType,
+        size: args.artifact.size,
+    };
+}
+export function buildArtifactHintAttachments(hints) {
+    if (!hints)
+        return [];
+    const attachments = [];
+    if (hints.verifyArtifact) {
+        attachments.push(toArtifactAttachment({
+            key: 'previous-verify-output',
+            label: 'Previous verify output',
+            artifact: hints.verifyArtifact,
+        }));
+    }
+    for (const [index, artifact] of (hints.subAgentPatchArtifacts ?? []).entries()) {
+        attachments.push(toArtifactAttachment({
+            key: `previous-subagent-patch-${index}`,
+            label: `Previous sub-agent patch artifact ${index + 1}`,
+            artifact,
+        }));
+    }
+    for (const [index, artifact] of (hints.subAgentAuditArtifacts ?? []).entries()) {
+        attachments.push(toArtifactAttachment({
+            key: `previous-subagent-audit-${index}`,
+            label: `Previous sub-agent audit artifact ${index + 1}`,
+            artifact,
+        }));
+    }
+    for (const [index, item] of (hints.recentReadArtifacts ?? []).entries()) {
+        attachments.push(toArtifactAttachment({
+            key: `recent-read-${index}`,
+            label: `Recent file read: ${item.path}`,
+            artifact: item.artifact,
+        }));
+    }
+    for (const [index, item] of (hints.toolResultPreviewArtifacts ?? []).entries()) {
+        attachments.push(toArtifactAttachment({
+            key: `tool-result-preview-${index}`,
+            label: item.label,
+            artifact: item.artifact,
+        }));
+    }
+    return attachments;
+}
+function buildPromptCachingHints(surface) {
+    const policy = {
+        mode: surface.mode,
+        eligibility: surface.cacheEligibility,
+        namespace: surface.namespace,
+        contextHash: surface.contextHash,
+        cacheSafeFingerprint: surface.cacheSafeFingerprint,
+        lateInjectionFingerprint: surface.lateInjectionFingerprint,
+    };
+    if (surface.cacheEligibility !== 'eligible' ||
+        !surface.contextHash ||
+        !surface.cacheSafeFingerprint) {
+        return {
+            openAICachePolicy: policy,
+        };
+    }
+    const components = [surface.contextHash, `stable:${surface.cacheSafeFingerprint}`];
+    if (surface.mode === 'strict_full_prompt' && surface.lateInjectionFingerprint) {
+        components.push(`late:${surface.lateInjectionFingerprint}`);
+    }
+    const manager = getPromptCachingManager();
+    return {
+        openAICacheHint: manager.generateOpenAICacheHint(surface.namespace ?? 'request-envelope', components),
+        openAICachePolicy: policy,
+    };
+}
+export function buildRequestEnvelope(params) {
+    const systemSections = (Array.isArray(params.system) ? params.system : [params.system]).map((item) => String(item ?? '').trimEnd());
+    const attachments = Array.isArray(params.attachments)
+        ? params.attachments
+            .filter((item) => item && (typeof item.content === 'string' || typeof item.artifactHandle === 'string'))
+            .map((item) => ({
+            ...item,
+            content: typeof item.content === 'string' ? item.content.trimEnd() : '',
+        }))
+            .filter((item) => item.content.length > 0 || typeof item.artifactHandle === 'string')
+        : [];
+    const userMetaMessages = [];
+    const conversationMessages = [];
+    if (Array.isArray(params.conversationContext)) {
+        for (const message of params.conversationContext) {
+            const safe = toSafeMessage(message);
+            if (!safe)
+                continue;
+            if (safe.role === 'system') {
+                userMetaMessages.push(safe);
+                continue;
+            }
+            conversationMessages.push(safe);
+        }
+    }
+    const cacheMode = resolvePromptCacheMode(params.cacheSafeSurface?.mode);
+    const cacheSafeAttachments = attachments.filter((item) => item.cacheSafe);
+    const lateInjectionAttachments = attachments.filter((item) => !item.cacheSafe);
+    const cacheSafeFingerprint = createFingerprint([
+        ...systemSections.map((section, index) => `system:${index}\u001f${section}`),
+        ...cacheSafeAttachments.map((item, index) => `attachment:${index}\u001f${serializeAttachmentForFingerprint(item)}`),
+    ]);
+    const lateInjectionFingerprint = createFingerprint([
+        `userPrompt\u001f${String(params.user ?? '').trimEnd()}`,
+        ...userMetaMessages.map((message, index) => `meta:${index}\u001f${message.content}`),
+        ...conversationMessages.map((message, index) => `conversation:${index}\u001f${message.role}\u001f${message.content}`),
+        ...lateInjectionAttachments.map((item, index) => `late-attachment:${index}\u001f${serializeAttachmentForFingerprint(item)}`),
+    ]);
+    const cacheSafeText = [...systemSections, ...cacheSafeAttachments.map((item) => item.content)]
+        .filter(Boolean)
+        .join('\n\n');
+    const manager = getPromptCachingManager();
+    const cacheEligibility = !params.cacheSafeSurface?.contextHash
+        ? 'missing_context_hash'
+        : !cacheSafeText.trim()
+            ? 'empty_cache_safe_surface'
+            : !manager.shouldCache(estimateTokens(cacheSafeText))
+                ? 'below_min_tokens'
+                : 'eligible';
+    const cacheSafeSurface = {
+        systemSections,
+        attachments: cacheSafeAttachments,
+        contextHash: params.cacheSafeSurface?.contextHash,
+        namespace: params.cacheSafeSurface?.namespace,
+        mode: cacheMode,
+        cacheEligibility,
+        cacheSafeFingerprint,
+        lateInjectionFingerprint,
+    };
+    return {
+        systemSections,
+        userPrompt: String(params.user ?? ''),
+        userMetaMessages,
+        conversationMessages,
+        attachments,
+        providerHints: {
+            ...buildPromptCachingHints(cacheSafeSurface),
+            ...(params.providerHints ?? {}),
+        },
+        cacheSafeSurface,
+    };
+}
+export function materializeRequestEnvelope(envelope) {
+    const artifactSection = (() => {
+        const artifactAttachments = envelope.attachments.filter((item) => item.kind === 'artifact' && typeof item.artifactHandle === 'string' && item.artifactHandle);
+        if (artifactAttachments.length === 0)
+            return '';
+        const lines = [
+            '# Available Artifacts',
+            'Use `artifact.read` with these handles when you need the full artifact contents.',
+        ];
+        for (const item of artifactAttachments) {
+            const suffix = [
+                item.mimeType ? `mime=${item.mimeType}` : undefined,
+                typeof item.size === 'number' ? `size=${item.size}` : undefined,
+            ]
+                .filter(Boolean)
+                .join(', ');
+            lines.push(`- ${item.label ?? item.key}: ${item.artifactHandle}${suffix ? ` (${suffix})` : ''}`);
+        }
+        return lines.join('\n');
+    })();
+    const out = [
+        {
+            role: 'system',
+            content: envelope.systemSections.filter(Boolean).join('\n\n'),
+        },
+    ];
+    out.push(...envelope.userMetaMessages);
+    out.push(...envelope.conversationMessages);
+    out.push({
+        role: 'user',
+        content: artifactSection.trim().length > 0
+            ? `${String(envelope.userPrompt ?? '')}\n\n${artifactSection}`
+            : String(envelope.userPrompt ?? ''),
+    });
+    return out;
+}
+//# sourceMappingURL=request-envelope.js.map

package/dist/core/llm/shared-request-assembly.js

@@ -0,0 +1,35 @@
+import { buildArtifactHintAttachments, buildRequestEnvelope, materializeRequestEnvelope, resolveRequestArtifactHints, } from './request-envelope.js';
+export function buildSharedRequestEnvelope(args) {
+    const cacheSurface = {
+        namespace: args.defaultNamespace,
+        contextHash: args.contextHash,
+    };
+    const resolvedArtifactHints = resolveRequestArtifactHints({
+        artifactHints: args.artifactHints,
+        toolCallingAudit: args.toolCallingAudit,
+        previewProvider: args.previewProvider,
+    });
+    const envelope = buildRequestEnvelope({
+        system: args.systemPrompt,
+        user: args.userPrompt,
+        conversationContext: args.conversationContext,
+        attachments: [
+            ...(args.attachments ?? []),
+            ...buildArtifactHintAttachments(resolvedArtifactHints),
+        ],
+        providerHints: args.providerHints,
+        cacheSafeSurface: {
+            contextHash: cacheSurface.contextHash,
+            namespace: cacheSurface.namespace,
+            mode: 'cache_safe_only',
+        },
+    });
+    const baseMessages = materializeRequestEnvelope(envelope);
+    return {
+        cacheSurface,
+        resolvedArtifactHints,
+        envelope,
+        baseMessages,
+    };
+}
+//# sourceMappingURL=shared-request-assembly.js.map

package/dist/core/llm/stream-utils.js

@@ -33,12 +33,20 @@ export function mapAiSdkStreamPartToChunk(part) {
         return null;
     }
     switch (part.type) {
-        case 'text-delta':
-        case 'reasoning-delta':
-            if (typeof part.text === 'string' && part.text) {
-                return { role: 'assistant', source: 'provider', contentDelta: part.text };
+        case 'text-delta': {
+            const text = typeof part.text === 'string' ? part.text : part.delta;
+            if (typeof text === 'string' && text) {
+                return { role: 'assistant', source: 'provider', contentDelta: text };
             }
             return null;
+        }
+        case 'reasoning-delta': {
+            const text = typeof part.text === 'string' ? part.text : part.delta;
+            if (typeof text === 'string' && text) {
+                return { role: 'assistant', source: 'provider', reasoningDelta: text };
+            }
+            return null;
+        }
         case 'tool-call':
             return {
                 role: 'assistant',
@@ -51,6 +59,7 @@ export function mapAiSdkStreamPartToChunk(part) {
                             name: part.toolName || 'unknown',
                             arguments: JSON.stringify(normalizeToolInput(part.input ?? {})),
                         },
+                        ...(part.providerMetadata ? { providerMetadata: part.providerMetadata } : {}),
                     },
                 ],
             };

package/dist/core/llm/utils.js

@@ -10,32 +10,22 @@ export function formatContextForPrompt(context, options = {}) {
     }
     return formatContextForXmlPrompt(context);
 }
-export function extractJson(content) {
-    // 1. Try to find JSON block
-    const jsonBlockMatch = content.match(/```json\s*\n([\s\S]*?)\n```/);
-    if (jsonBlockMatch) {
-        try {
-            return JSON.parse(jsonBlockMatch[1]);
-        }
-        catch (__e) {
-            // Fallback to raw content if block is invalid
-        }
+export function parsePlanFromLLMContent(content) {
+    const trimmed = String(content ?? '').trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+        throw new Error(text.llm.planInvalidJson);
     }
-    // 2. Try to find anything that looks like a JSON object
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (jsonMatch) {
-        try {
-            return JSON.parse(jsonMatch[0]);
-        }
-        catch (__e) {
-            // Fallback
-        }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
     }
-    // 3. Final fallback: try parsing the whole content
-    return JSON.parse(content);
-}
-export function parsePlanFromLLMContent(content) {
-    const plan = extractJson(content);
+    catch {
+        throw new Error(text.llm.planInvalidJson);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(text.llm.planInvalidJson);
+    }
+    const plan = parsed;
     if (!plan.goal || !Array.isArray(plan.files) || !Array.isArray(plan.changes) || !plan.verify) {
         throw new Error(text.llm.planInvalid);
     }
@@ -46,10 +36,9 @@ export function extractUnifiedDiffFromLLMContent(content) {
         throw wrapPatchEmpty();
     }
     const looksLikeUnifiedDiff = (text) => {
-        return /^\s*(diff --git |--- a\/)/m.test(text);
+        return /^\s*diff --git /m.test(text);
     };
-    // 1) Prefer fenced code blocks and always pick the LAST diff-like block (LLM may generate multiple attempts).
-    // Accept both git-style (`diff --git`) and minimal unified diffs (`--- a/...` + `+++ b/...`).
+    // 1) Prefer fenced code blocks and always pick the LAST canonical diff block (LLM may generate multiple attempts).
     const fencedBlocks = [];
     const fenceRegex = /```(?:diff)?\s*\n([\s\S]*?)\n```/gi;
     let fenceMatch = null;
@@ -62,10 +51,10 @@ export function extractUnifiedDiffFromLLMContent(content) {
     if (fencedBlocks.length > 0) {
         return fencedBlocks[fencedBlocks.length - 1].trim();
     }
-    // 2) Raw diff without markdown: keep the first diff-like section.
+    // 2) Raw diff without markdown: keep the first canonical diff section.
     // In "pure diff" mode, LLMs typically return only the patch, so selecting the first marker
     // avoids accidentally dropping the leading `diff --git` header.
-    const rawStart = content.search(/^\s*(diff --git |--- a\/)/m);
+    const rawStart = content.search(/^\s*diff --git /m);
     if (rawStart !== -1)
         return content.slice(rawStart).trim();
     // Final fallback: original simple cleanup

package/dist/core/memory/relevant-retrieval.js

@@ -0,0 +1,144 @@
+import { extractKeywords } from '../context/keywords.js';
+const DEFAULT_MAX_ITEMS = 3;
+const DEFAULT_MAX_SUMMARY_CHARS = 220;
+function trimToUndefined(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function clampText(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+function normalizeCandidate(candidate, maxSummaryChars) {
+    const path = trimToUndefined(candidate.path);
+    const title = trimToUndefined(candidate.title);
+    const summary = trimToUndefined(candidate.summary);
+    if (!path || !title || !summary)
+        return undefined;
+    const tags = Array.isArray(candidate.tags)
+        ? candidate.tags
+            .map((tag) => trimToUndefined(tag)?.toLowerCase())
+            .filter((tag) => Boolean(tag))
+        : undefined;
+    return {
+        path,
+        title,
+        summary: clampText(summary, maxSummaryChars),
+        tags,
+    };
+}
+function buildAlreadySurfacedHaystack(values) {
+    return (values ?? []).join('\n').toLowerCase();
+}
+function hasToolConflict(candidate, activeToolNames) {
+    const toolTags = (candidate.tags ?? []).filter((tag) => tag.startsWith('tool:'));
+    if (toolTags.length === 0)
+        return false;
+    const active = new Set(activeToolNames.map((name) => name.trim().toLowerCase()).filter(Boolean));
+    if (active.size === 0)
+        return false;
+    return toolTags.some((tag) => active.has(tag.slice('tool:'.length)));
+}
+function computeCandidateScore(candidate, keywords) {
+    if (keywords.length === 0)
+        return 0;
+    const pathLower = candidate.path.toLowerCase();
+    const titleLower = candidate.title.toLowerCase();
+    const summaryLower = candidate.summary.toLowerCase();
+    const tagsLower = candidate.tags ?? [];
+    let score = 0;
+    for (const keyword of keywords) {
+        const normalized = keyword.trim().toLowerCase();
+        if (!normalized)
+            continue;
+        if (pathLower.includes(normalized))
+            score += 6;
+        if (titleLower.includes(normalized))
+            score += 5;
+        if (summaryLower.includes(normalized))
+            score += 4;
+        if (tagsLower.some((tag) => tag.includes(normalized)))
+            score += 3;
+    }
+    return score;
+}
+export function buildRelevantMemoryCandidates(context) {
+    const candidates = [];
+    const knowledge = context.knowledgeBase;
+    const metadata = context.projectMetadata;
+    if (Array.isArray(knowledge?.project_rules) && knowledge.project_rules.length > 0) {
+        candidates.push({
+            path: '.salmonloop/knowledge/project_rules',
+            title: 'Project rules',
+            summary: knowledge.project_rules.join('; '),
+            tags: ['rules', 'project'],
+        });
+    }
+    if (trimToUndefined(knowledge?.user_preferences)) {
+        candidates.push({
+            path: '.salmonloop/knowledge/user_preferences',
+            title: 'User preferences',
+            summary: knowledge.user_preferences,
+            tags: ['preferences', 'user'],
+        });
+    }
+    for (const [index, decision] of (knowledge?.architectural_decisions ?? []).entries()) {
+        const summary = trimToUndefined(decision?.decision);
+        if (!summary)
+            continue;
+        candidates.push({
+            path: `.salmonloop/knowledge/architectural_decisions/${index + 1}`,
+            title: `Architectural decision ${index + 1}`,
+            summary,
+            tags: ['architecture', ...(decision.related_files ?? []).map((file) => file.toLowerCase())],
+        });
+    }
+    if (trimToUndefined(metadata?.aiInstructions)) {
+        candidates.push({
+            path: '.salmonloop/project/ai-instructions',
+            title: 'Project AI instructions',
+            summary: metadata.aiInstructions,
+            tags: ['instructions', 'project'],
+        });
+    }
+    return candidates;
+}
+export function selectRelevantMemory(args) {
+    const maxItems = Math.max(1, Math.floor(args.maxItems ?? DEFAULT_MAX_ITEMS));
+    const maxSummaryChars = Math.max(48, Math.floor(args.maxSummaryChars ?? DEFAULT_MAX_SUMMARY_CHARS));
+    const haystack = buildAlreadySurfacedHaystack(args.alreadySurfacedText);
+    const activeToolNames = args.activeToolNames ?? [];
+    const keywords = extractKeywords(args.instruction ?? '');
+    const deduped = new Map();
+    for (const rawCandidate of args.candidates) {
+        const candidate = normalizeCandidate(rawCandidate, maxSummaryChars);
+        if (!candidate)
+            continue;
+        if (deduped.has(candidate.path))
+            continue;
+        if (haystack.includes(candidate.path.toLowerCase()) ||
+            haystack.includes(candidate.title.toLowerCase()) ||
+            haystack.includes(candidate.summary.toLowerCase())) {
+            continue;
+        }
+        if (hasToolConflict(candidate, activeToolNames))
+            continue;
+        deduped.set(candidate.path, candidate);
+    }
+    const scored = [...deduped.values()].map((candidate) => ({
+        candidate,
+        score: computeCandidateScore(candidate, keywords),
+    }));
+    const ranked = scored
+        .filter((entry) => entry.score > 0 || keywords.length === 0)
+        .sort((left, right) => {
+        if (left.score !== right.score)
+            return right.score - left.score;
+        return left.candidate.path.localeCompare(right.candidate.path);
+    });
+    return ranked.slice(0, maxItems).map((entry) => entry.candidate);
+}
+//# sourceMappingURL=relevant-retrieval.js.map

package/dist/core/observability/logger.js

@@ -3,6 +3,17 @@ import { FileAdapter } from '../adapters/fs/index.js';
 import { sanitizeObject, sanitizeErrorMessage } from '../utils/sanitizer.js';
 import { recordAuditEvent } from './audit-trail.js';
 import { mapErrorForDisplay } from './error-mapping.js';
+/**
+ * Reporter for machine-readable modes where stdout/stderr are protocol channels.
+ */
+export class SilentReporter {
+    log(_level, _message, _metadata) {
+        // Intentionally empty.
+    }
+    clear() {
+        // Intentionally empty.
+    }
+}
 /**
  * Standard Console Reporter
  */
@@ -418,8 +429,6 @@ export class Logger {
         const auditMeta = typeof meta === 'string' ? { source: meta } : meta;
         recordAuditEvent(action, sanitizedDetails, auditMeta);
         this.writeToLog('audit', formatted);
-        if (!this.silent)
-            this.reporter.log('audit', formatted);
     }
     sanitizeLogMessage(message) {
         let result = '';

package/dist/core/patch/diff.js

@@ -31,6 +31,7 @@ const cleanPath = (path) => {
                 'src',
                 'lib',
                 'app',
+                'scripts',
                 'tests',
                 'test',
                 'packages',