salmon-loop 0.3.1 → 0.4.1

package/dist/core/grizzco/engine/pipeline/pipeline.js

@@ -2,6 +2,7 @@ import { recordAuditEvent, setAuditContext } from '../../../observability/audit-
 import { getLogger } from '../../../observability/logger.js';
 import { appendPlanNote } from '../../../plan/index.js';
 import { EXECUTION_PHASES, } from '../../../types/runtime.js';
+import { isRecord } from '../../../utils/serialize.js';
 /**
  * Typed Async Pipeline Container
  */
@@ -28,271 +29,179 @@ export class Pipeline {
      * Add a step to the pipeline
      */
     step(name, action) {
-        const nextPromise = this.promise.then(async (ctx) => {
-            const start = Date.now();
-            let phaseStarted = false;
-            let errorStr;
-            let errorMeta;
-            let result;
-            const emit = ctx.emit;
-            const isPhase = (value) => EXECUTION_PHASES.includes(value);
-            const planRuntime = ctx?.planRuntime;
-            const persistenceRoot = ctx?.workspace?.baseRepoPath || ctx?.workspace?.workPath;
-            const attempt = ctx?.attempt ?? 1;
-            const tryAppendPlanNote = async (note) => {
-                if (!planRuntime || !persistenceRoot)
-                    return;
-                try {
-                    await appendPlanNote({
-                        persistenceRoot,
-                        sessionId: planRuntime.sessionId,
-                        note,
-                    });
-                    recordAuditEvent('plan.runtime.note.append', { note, ok: true }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
-                    return true;
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    recordAuditEvent('plan.runtime.note.append.failed', { note, error: msg }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
-                    getLogger().debug(`[PlanRuntime] Failed to append note: ${msg}`);
-                    return false;
-                }
-            };
-            try {
-                this.ctxRef.current = ctx;
-                const signal = ctx?.options?.signal;
-                const strategy = ctx?.workspace?.strategy ?? ctx?.options?.strategy;
-                if (signal?.aborted && strategy === 'worktree') {
-                    throw new Error('Operation cancelled by user');
-                }
-                setAuditContext({ phase: name });
-                if (emit && isPhase(name)) {
-                    emit({ type: 'phase.start', phase: name, timestamp: new Date() });
-                    phaseStarted = true;
-                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.start ${name}`);
-                    if (planRuntime && ok !== undefined) {
-                        emit({
-                            type: 'plan.runtime.journal',
-                            sessionId: planRuntime.sessionId,
-                            phase: name,
-                            kind: 'start',
-                            attempt,
-                            ok,
-                            timestamp: new Date(),
-                        });
-                    }
-                }
-                result = await action(ctx);
-                this.ctxRef.current = result;
-                // APPLY_BACK failure is represented as a structured result (not an exception) to preserve context.
-                // The pipeline must still treat it as a phase failure for progress reporting and plan journaling.
-                if (name === 'APPLY_BACK' &&
-                    result &&
-                    typeof result === 'object' &&
-                    result.applyBackResult &&
-                    typeof result.applyBackResult === 'object') {
-                    const applyBackResult = result.applyBackResult;
-                    if (applyBackResult.success === false && !applyBackResult.skipped) {
-                        errorStr = applyBackResult.safeMessage || applyBackResult.error || 'Apply-back failed';
-                        errorMeta = {
+        const nextPromise = this.executeStep(name, action, async () => {
+            // No recovery for plain steps — check for APPLY_BACK structured failure
+            const result = this.ctxRef.current;
+            if (name === 'APPLY_BACK' && isRecord(result) && isRecord(result.applyBackResult)) {
+                const applyBackResult = result.applyBackResult;
+                if (applyBackResult.success === false && !applyBackResult.skipped) {
+                    return {
+                        errorStr: applyBackResult.safeMessage || applyBackResult.error || 'Apply-back failed',
+                        errorMeta: {
                             name: 'ApplyBackFailure',
                             code: applyBackResult.errorCode || 'APPLY_BACK_FAILED',
-                        };
-                    }
+                        },
+                    };
                 }
-                return result;
             }
-            catch (error) {
-                errorStr = error instanceof Error ? error.message : String(error);
-                errorMeta =
-                    typeof error === 'object' && error !== null
-                        ? {
-                            name: error.name,
-                            code: error.code,
-                            llmCode: error.llmCode,
-                        }
-                        : undefined;
-                throw error;
+            return null;
+        });
+        return new Pipeline(nextPromise, this.startTime, name, this.traces, this.ctxRef);
+    }
+    /**
+     * Add a step with error recovery
+     */
+    stepWithRecovery(name, action, recovery) {
+        const nextPromise = this.executeStep(name, action, async (ctx, errorStr) => {
+            // Only run recovery when the step actually failed
+            if (!errorStr)
+                return null;
+            const recStart = Date.now();
+            try {
+                await recovery(ctx);
+                this.traces.push({
+                    name: `${name}:recovery`,
+                    start: recStart,
+                    end: Date.now(),
+                    duration: Date.now() - recStart,
+                    metadata: { success: true },
+                });
             }
-            finally {
-                if (emit && isPhase(name) && phaseStarted) {
-                    emit({
-                        type: 'phase.end',
-                        phase: name,
-                        success: !errorStr,
-                        timestamp: new Date(),
-                    });
-                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.end ${name} (success=${String(!errorStr)})`);
-                    if (planRuntime && ok !== undefined) {
-                        emit({
-                            type: 'plan.runtime.journal',
-                            sessionId: planRuntime.sessionId,
-                            phase: name,
-                            kind: 'end',
-                            attempt,
-                            ok,
-                            timestamp: new Date(),
-                        });
-                    }
-                }
-                setAuditContext({ phase: undefined });
-                const end = Date.now();
+            catch (recError) {
+                const recEnd = Date.now();
+                const errorDetail = recError instanceof Error ? recError.message : String(recError);
                 this.traces.push({
-                    name,
-                    start,
-                    end,
-                    duration: end - start,
-                    error: errorStr,
-                    metadata: errorMeta,
+                    name: `${name}:recovery`,
+                    start: recStart,
+                    end: recEnd,
+                    duration: recEnd - recStart,
+                    error: errorDetail,
+                    metadata: { success: false, phase: 'RECOVERY_FAILURE' },
                 });
+                getLogger().audit('PIPELINE_RECOVERY_FAILED', { step: name, originalError: errorStr, recoveryError: errorDetail }, { source: 'system', severity: 'high', scope: 'session' });
             }
+            return null; // Always re-throw original error
         });
         return new Pipeline(nextPromise, this.startTime, name, this.traces, this.ctxRef);
     }
     /**
-     * Add a step with error recovery
+     * Core step execution shared by step() and stepWithRecovery().
+     * Handles: abort check, phase events, plan journaling, tracing.
+     * The onError callback runs recovery/post-processing; return non-null to inject error metadata.
      */
-    stepWithRecovery(name, action, recovery) {
-        const nextPromise = this.promise.then(async (ctx) => {
-            const start = Date.now();
-            let phaseStarted = false;
-            let abortedBeforeAction = false;
-            let errorStr;
-            let errorMeta;
-            let result;
-            const emit = ctx.emit;
-            const isPhase = (value) => EXECUTION_PHASES.includes(value);
-            const planRuntime = ctx?.planRuntime;
-            const persistenceRoot = ctx?.workspace?.baseRepoPath || ctx?.workspace?.workPath;
-            const attempt = ctx?.attempt ?? 1;
-            const tryAppendPlanNote = async (note) => {
-                if (!planRuntime || !persistenceRoot)
-                    return;
-                try {
-                    await appendPlanNote({
-                        persistenceRoot,
-                        sessionId: planRuntime.sessionId,
-                        note,
-                    });
-                    recordAuditEvent('plan.runtime.note.append', { note, ok: true }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
-                    return true;
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    recordAuditEvent('plan.runtime.note.append.failed', { note, error: msg }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
-                    getLogger().debug(`[PlanRuntime] Failed to append note: ${msg}`);
-                    return false;
-                }
-            };
+    async executeStep(name, action, onError) {
+        const start = Date.now();
+        let phaseStarted = false;
+        let errorStr;
+        let errorMeta;
+        let result;
+        const ctx = await this.promise;
+        const emit = ctx.emit;
+        const isPhase = (value) => EXECUTION_PHASES.includes(value);
+        const ctxObj = isRecord(ctx) ? ctx : null;
+        const planRuntime = ctxObj?.planRuntime;
+        const workspace = isRecord(ctxObj?.workspace) ? ctxObj.workspace : null;
+        const persistenceRoot = (typeof workspace?.baseRepoPath === 'string' ? workspace.baseRepoPath : undefined) ||
+            (typeof workspace?.workPath === 'string' ? workspace.workPath : undefined);
+        const attempt = typeof ctxObj?.attempt === 'number' ? ctxObj.attempt : 1;
+        const tryAppendPlanNote = async (note) => {
+            if (!planRuntime || !persistenceRoot)
+                return;
             try {
-                this.ctxRef.current = ctx;
-                const signal = ctx?.options?.signal;
-                const strategy = ctx?.workspace?.strategy ?? ctx?.options?.strategy;
-                if (signal?.aborted && strategy === 'worktree') {
-                    abortedBeforeAction = true;
-                    throw new Error('Operation cancelled by user');
-                }
-                setAuditContext({ phase: name });
-                if (emit && isPhase(name)) {
-                    emit({ type: 'phase.start', phase: name, timestamp: new Date() });
-                    phaseStarted = true;
-                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.start ${name}`);
-                    if (planRuntime && ok !== undefined) {
-                        emit({
-                            type: 'plan.runtime.journal',
-                            sessionId: planRuntime.sessionId,
-                            phase: name,
-                            kind: 'start',
-                            attempt,
-                            ok,
-                            timestamp: new Date(),
-                        });
-                    }
-                }
-                result = await action(ctx);
-                this.ctxRef.current = result;
-                return result;
+                await appendPlanNote({ persistenceRoot, sessionId: planRuntime.sessionId, note });
+                recordAuditEvent('plan.runtime.note.append', { note, ok: true }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
+                return true;
             }
-            catch (error) {
-                errorStr = error instanceof Error ? error.message : String(error);
-                errorMeta =
-                    typeof error === 'object' && error !== null
-                        ? {
-                            name: error.name,
-                            code: error.code,
-                            llmCode: error.llmCode,
-                        }
-                        : undefined;
-                if (abortedBeforeAction) {
-                    throw error;
-                }
-                // Trigger Recovery
-                const recStart = Date.now();
-                try {
-                    await recovery(ctx);
-                    this.traces.push({
-                        name: `${name}:recovery`,
-                        start: recStart,
-                        end: Date.now(),
-                        duration: Date.now() - recStart,
-                        metadata: { success: true },
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                recordAuditEvent('plan.runtime.note.append.failed', { note, error: msg }, { source: 'plan', severity: 'low', scope: 'session', phase: name });
+                getLogger().debug(`[PlanRuntime] Failed to append note: ${msg}`);
+                return false;
+            }
+        };
+        try {
+            this.ctxRef.current = ctx;
+            const options = isRecord(ctxObj?.options) ? ctxObj.options : null;
+            const signal = options?.signal;
+            const strategy = (workspace?.strategy ?? options?.strategy);
+            if (signal?.aborted && strategy === 'worktree') {
+                throw new Error('Operation cancelled by user');
+            }
+            setAuditContext({ phase: name });
+            if (emit && isPhase(name)) {
+                emit({ type: 'phase.start', phase: name, timestamp: new Date() });
+                phaseStarted = true;
+                const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.start ${name}`);
+                if (planRuntime && ok !== undefined) {
+                    emit({
+                        type: 'plan.runtime.journal',
+                        sessionId: planRuntime.sessionId,
+                        phase: name,
+                        kind: 'start',
+                        attempt,
+                        ok,
+                        timestamp: new Date(),
                     });
                 }
-                catch (recError) {
-                    const recEnd = Date.now();
-                    const errorDetail = recError instanceof Error ? recError.message : String(recError);
-                    // 1. Record recovery failure to internal traces
-                    this.traces.push({
-                        name: `${name}:recovery`,
-                        start: recStart,
-                        end: recEnd,
-                        duration: recEnd - recStart,
-                        error: errorDetail,
-                        metadata: { success: false, phase: 'RECOVERY_FAILURE' },
-                    });
-                    // 2. Force audit log to disk (persistent storage)
-                    getLogger().audit('PIPELINE_RECOVERY_FAILED', {
-                        step: name,
-                        originalError: errorStr,
-                        recoveryError: errorDetail,
-                    }, { source: 'system', severity: 'high', scope: 'session' });
+            }
+            result = await action(ctx);
+            this.ctxRef.current = result;
+            // Check for structured failures (e.g., APPLY_BACK)
+            const postResult = await onError(ctx, '');
+            if (postResult) {
+                errorStr = postResult.errorStr;
+                errorMeta = postResult.errorMeta;
+            }
+            return result;
+        }
+        catch (error) {
+            errorStr = error instanceof Error ? error.message : String(error);
+            errorMeta =
+                typeof error === 'object' && error !== null
+                    ? {
+                        name: error.name,
+                        code: error.code,
+                        llmCode: error.llmCode,
+                    }
+                    : undefined;
+            // Skip recovery on abort - the operation was cancelled, not failed
+            if (errorStr !== 'Operation cancelled by user') {
+                // Run recovery/post-processing
+                const postResult = await onError(ctx, errorStr);
+                if (postResult?.errorStr) {
+                    errorStr = postResult.errorStr;
+                    errorMeta = postResult.errorMeta;
                 }
-                throw error; // Propagate original error
             }
-            finally {
-                if (emit && isPhase(name) && phaseStarted) {
+            throw error;
+        }
+        finally {
+            if (emit && isPhase(name) && phaseStarted) {
+                emit({ type: 'phase.end', phase: name, success: !errorStr, timestamp: new Date() });
+                const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.end ${name} (success=${String(!errorStr)})`);
+                if (planRuntime && ok !== undefined) {
                     emit({
-                        type: 'phase.end',
+                        type: 'plan.runtime.journal',
+                        sessionId: planRuntime.sessionId,
                         phase: name,
-                        success: !errorStr,
+                        kind: 'end',
+                        attempt,
+                        ok,
                         timestamp: new Date(),
                     });
-                    const ok = await tryAppendPlanNote(`Attempt ${attempt}: phase.end ${name} (success=${String(!errorStr)})`);
-                    if (planRuntime && ok !== undefined) {
-                        emit({
-                            type: 'plan.runtime.journal',
-                            sessionId: planRuntime.sessionId,
-                            phase: name,
-                            kind: 'end',
-                            attempt,
-                            ok,
-                            timestamp: new Date(),
-                        });
-                    }
                 }
-                setAuditContext({ phase: undefined });
-                const end = Date.now();
-                this.traces.push({
-                    name,
-                    start,
-                    end,
-                    duration: end - start,
-                    error: errorStr,
-                    metadata: errorMeta,
-                });
             }
-        });
-        return new Pipeline(nextPromise, this.startTime, name, this.traces, this.ctxRef);
+            setAuditContext({ phase: undefined });
+            const end = Date.now();
+            this.traces.push({
+                name,
+                start,
+                end,
+                duration: end - start,
+                error: errorStr,
+                metadata: errorMeta,
+            });
+        }
     }
     /**
      * Execute the pipeline and get the final result

package/dist/core/grizzco/engine/transaction/attempt-failure.js

@@ -5,6 +5,7 @@ import { mapErrorForDisplay } from '../../../observability/error-mapping.js';
 import { resolveExecutionProfile } from '../../../runtime/execution-profile.js';
 import { isRecoverableToolInputErrorCode } from '../../../tools/recoverable-tool-errors.js';
 import { EXECUTION_PHASES } from '../../../types/runtime.js';
+import { isRecord } from '../../../utils/serialize.js';
 import { classifyError, isRetryable } from '../../../verification/runner.js';
 const RETRYABLE_PHASES = new Set([
     'CONTEXT',
@@ -49,20 +50,20 @@ function sanitizeReason(value) {
     return mapErrorForDisplay({ message: sanitized }).message;
 }
 function extractInputRequired(error) {
-    if (!error || typeof error !== 'object')
+    if (!isRecord(error))
         return undefined;
     const value = 'inputRequired' in error ? error.inputRequired : error;
-    if (!value || typeof value !== 'object')
+    if (!isRecord(value))
         return undefined;
     if (typeof value.prompt !== 'string' || typeof value.type !== 'string')
         return undefined;
     return value;
 }
 function extractInterrupt(error) {
-    if (!error || typeof error !== 'object')
+    if (!isRecord(error))
         return undefined;
     const value = error.interrupt;
-    if (!value || typeof value !== 'object')
+    if (!isRecord(value))
         return undefined;
     if (typeof value.type !== 'string')
         return undefined;

package/dist/core/grizzco/engine/transaction/authorization-summary.js

@@ -1,3 +1,4 @@
+import { isRecord } from '../../../utils/serialize.js';
 export function buildAuthorizationSummary(logs) {
     if (!logs || logs.length === 0)
         return null;
@@ -11,7 +12,7 @@ export function buildAuthorizationSummary(logs) {
     };
     let hasEntries = false;
     for (const entry of logs) {
-        if (!entry || entry.eventType !== 'authorization')
+        if (!isRecord(entry) || entry.eventType !== 'authorization')
             continue;
         const source = entry.authSource;
         if (source === 'auto') {

package/dist/core/grizzco/runtime/apply-back-runtime.js

@@ -2,6 +2,7 @@ import { text } from '../../../locales/index.js';
 import { recordAuditEvent } from '../../observability/audit-trail.js';
 import { writeDebugArtifact } from '../../observability/debug-artifacts.js';
 import { buildErrorEnvelope, toSafeErrorSummary } from '../../observability/error-envelope.js';
+import { isRecord } from '../../utils/serialize.js';
 import { collectSidecarPaths } from './apply-back-utils.js';
 export async function runApplyBackPhase(params) {
     const { checkpointRef, initialSnapshotHash, options, synchronizer, activeRepoPath, shadowTaskId, attempt, emit, } = params;
@@ -89,7 +90,7 @@ export async function runApplyBackPhase(params) {
                     `safeTelemetry=${JSON.stringify(toSafeTelemetry(applyBackTelemetry), null, 2)}`,
                     '',
                     `errorType=${error instanceof Error ? error.name : typeof error}`,
-                    `errorCode=${error?.code ?? error?.llmCode ?? ''}`,
+                    `errorCode=${isRecord(error) ? (error.code ?? error.llmCode ?? '') : ''}`,
                     `errorMessage=${error instanceof Error ? error.message : String(error)}`,
                 ].join('\n'),
             });

package/dist/core/grizzco/services/registry.js

@@ -26,5 +26,23 @@ export const registry = {
     has(id) {
         return services.has(id);
     },
+    /**
+     * Unregister a data service by its identifier
+     */
+    unregister(id) {
+        return services.delete(id);
+    },
+    /**
+     * Clear all registered services (for testing or shutdown)
+     */
+    clear() {
+        services.clear();
+    },
+    /**
+     * List all registered service IDs
+     */
+    list() {
+        return Array.from(services.keys());
+    },
 };
 //# sourceMappingURL=registry.js.map

package/dist/core/grizzco/steps/audit.js

@@ -8,6 +8,8 @@ import { mapErrorForDisplay } from '../../observability/error-mapping.js';
 import { getLogger } from '../../observability/logger.js';
 import { getAuditDir } from '../../runtime/paths.js';
 import { SalmonError } from '../../types/errors.js';
+import { errorMessage } from '../../utils/error.js';
+import { isRecord } from '../../utils/serialize.js';
 function replaceRedactedTokens(value) {
     if (value === null || value === undefined)
         return value;
@@ -43,7 +45,7 @@ export async function saveAudit(report, _options) {
             });
         }
         catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
+            const msg = errorMessage(error);
             getLogger().warn(`[Audit] Failed to externalize verify output: ${msg}`);
             recordAuditEvent('audit.blob.externalize.failed', { target: 'verifyResult.output', error: msg.slice(0, 500) }, { source: 'saveAudit', severity: 'low', scope: 'session', phase: 'AUDIT' });
         }
@@ -55,7 +57,7 @@ export async function saveAudit(report, _options) {
             });
         }
         catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
+            const msg = errorMessage(error);
             getLogger().warn(`[Audit] Failed to externalize tool audit summaries: ${msg}`);
             recordAuditEvent('audit.blob.externalize.failed', { target: 'toolAuditLogs.*', error: msg.slice(0, 500) }, { source: 'saveAudit', severity: 'low', scope: 'session', phase: 'AUDIT' });
         }
@@ -70,7 +72,12 @@ export async function saveAudit(report, _options) {
                     : errorInfo?.code || errorInfo?.llmCode,
             }
             : report.error
-                ? { name: 'UnknownError', message: String(report.error), stack: undefined }
+                ? {
+                    name: 'UnknownError',
+                    message: String(report.error),
+                    stack: undefined,
+                    code: undefined,
+                }
                 : undefined;
         const mappedErrorMeta = replaceRedactedTokens(errorMeta);
         const errorDisplay = mapErrorForDisplay({
@@ -130,7 +137,7 @@ export async function saveAudit(report, _options) {
         return `${auditDir}/${filename}`;
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = errorMessage(error);
         getLogger().error(`[Audit] Failed to save audit log: ${msg}`);
         return undefined;
     }
@@ -162,7 +169,7 @@ async function writeBlobBestEffort(args) {
         return { path: path.join('blobs', blobName), sha256, chars: content.length };
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = errorMessage(error);
         getLogger().warn(`[Audit] Failed to write blob ${blobName}: ${msg}`);
         recordAuditEvent('audit.blob.write.failed', {
             target: auditTarget,
@@ -179,7 +186,7 @@ async function externalizeVerifyOutput(args) {
     if (!sanitizedContext)
         return;
     const verifyResult = sanitizedContext.verifyResult;
-    if (!verifyResult || typeof verifyResult !== 'object')
+    if (!isRecord(verifyResult))
         return;
     const output = verifyResult.output;
     if (typeof output !== 'string')
@@ -292,15 +299,18 @@ function sanitizeContext(ctx) {
     if (typed.applyBackResult)
         safe.applyBackResult = typed.applyBackResult;
     if (typed.toolCallingAudit && Array.isArray(typed.toolCallingAudit)) {
+        const KEYS_TO_STRIP = new Set([
+            'rawArgsPreview',
+            'parsedArgsPreview',
+            'toolResultErrorMessage',
+        ]);
         safe.toolCallingAudit = typed.toolCallingAudit.map((entry) => {
             if (!entry || typeof entry !== 'object')
                 return entry;
-            const typedEntry = entry;
-            const keepArgsPreview = typedEntry.toolResultErrorCode === 'INVALID_INPUT';
+            const keepArgsPreview = entry.toolResultErrorCode === 'INVALID_INPUT';
             if (keepArgsPreview)
                 return entry;
-            const { rawArgsPreview: _rawArgsPreview, parsedArgsPreview: _parsedArgsPreview, toolResultErrorMessage: _toolResultErrorMessage, ...rest } = typedEntry;
-            return rest;
+            return Object.fromEntries(Object.entries(entry).filter(([k]) => !KEYS_TO_STRIP.has(k)));
         });
     }
     if (typed.toolAuditLogger?.getLogs) {

package/dist/core/grizzco/steps/display-report.js

@@ -1,18 +1,11 @@
 import { text } from '../../../locales/index.js';
 import { SalmonError } from '../../types/errors.js';
+import { safeStringify } from '../../utils/serialize.js';
 export class ReportContextMissingError extends SalmonError {
     constructor(message) {
         super(message, 'REPORT_CONTEXT_MISSING');
     }
 }
-function safeStringify(value) {
-    try {
-        return JSON.stringify(value, null, 2);
-    }
-    catch {
-        return String(value);
-    }
-}
 function removeLeadingSpaces(content) {
     const lines = content.split('\n');
     const minIndent = lines
@@ -40,7 +33,7 @@ function normalizeSuggestions(input) {
             }
             if (isReviewSuggestion(item)) {
                 const type = typeof item.type === 'string' ? item.type : 'note';
-                const content = typeof item.content === 'string' ? item.content : safeStringify(item);
+                const content = typeof item.content === 'string' ? item.content : safeStringify(item, { indent: 2 });
                 return { type, content };
             }
             return { type: 'note', content: String(item) };
@@ -51,10 +44,10 @@ function normalizeSuggestions(input) {
     }
     if (isReviewSuggestion(input)) {
         const type = typeof input.type === 'string' ? input.type : 'note';
-        const content = typeof input.content === 'string' ? input.content : safeStringify(input);
+        const content = typeof input.content === 'string' ? input.content : safeStringify(input, { indent: 2 });
         return [{ type, content }];
     }
-    return [{ type: 'note', content: safeStringify(input) }];
+    return [{ type: 'note', content: safeStringify(input, { indent: 2 }) }];
 }
 export async function displayReport(ctx) {
     if (!ctx.report || !ctx.report.kind) {