@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/telemetry/chat-telemetry.js

@@ -0,0 +1,247 @@
+import { createHash } from "node:crypto";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { toErrorDetail as _unifiedToErrorDetail } from "../errors.js";
+// Use the canonical toErrorDetail from errors.ts
+const toErrorDetail = _unifiedToErrorDetail;
+export function createChatTelemetryStore(args) {
+    const buffer = [];
+    const pendingWrites = [];
+    let flushTimer = null;
+    function promptExcerpt(message) {
+        return message.replace(/\s+/g, " ").trim().slice(0, 180);
+    }
+    function promptHash(message) {
+        return createHash("sha256").update(message).digest("hex").slice(0, 16);
+    }
+    async function flushNow() {
+        if (!args.persistEnabled)
+            return;
+        if (pendingWrites.length === 0)
+            return;
+        const pending = pendingWrites.splice(0, pendingWrites.length);
+        const lines = pending.map((item) => JSON.stringify(item)).join("\n");
+        await mkdir(resolve(args.filePath, ".."), { recursive: true });
+        await appendFile(args.filePath, `${lines}\n`, "utf8");
+    }
+    function scheduleFlush() {
+        if (flushTimer)
+            clearTimeout(flushTimer);
+        flushTimer = setTimeout(() => {
+            void flushNow().catch((error) => {
+                args.logger.error({ err: toErrorDetail(error), file: args.filePath }, "Failed to flush chat telemetry");
+            });
+        }, 150);
+    }
+    async function loadFromDisk() {
+        if (!args.persistEnabled)
+            return;
+        if (!existsSync(args.filePath))
+            return;
+        try {
+            const raw = await readFile(args.filePath, "utf8");
+            const lines = raw
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean);
+            const tail = lines.slice(-Math.max(args.limit, 100));
+            buffer.length = 0;
+            for (const line of tail) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (!parsed || typeof parsed !== "object")
+                        continue;
+                    if (typeof parsed.id !== "string" || typeof parsed.phase !== "string")
+                        continue;
+                    buffer.push(parsed);
+                }
+                catch {
+                    // Ignore malformed telemetry lines.
+                }
+            }
+            args.logger.info({ file: args.filePath, loaded: buffer.length }, "Loaded chat telemetry");
+        }
+        catch (error) {
+            args.logger.error({ err: toErrorDetail(error), file: args.filePath }, "Failed to load chat telemetry");
+        }
+    }
+    function push(entry) {
+        buffer.push(entry);
+        if (buffer.length > args.limit) {
+            buffer.splice(0, buffer.length - args.limit);
+        }
+        if (args.persistEnabled) {
+            pendingWrites.push(entry);
+            scheduleFlush();
+        }
+        if (args.onPush) {
+            try {
+                args.onPush(entry);
+            }
+            catch (error) {
+                args.logger.error({ err: toErrorDetail(error) }, "chat-telemetry onPush hook failed");
+            }
+        }
+        args.logger.info({
+            event: "chat_telemetry",
+            id: entry.id,
+            phase: entry.phase,
+            session: entry.session,
+            requestedSlug: entry.requestedSlug,
+            effectiveSlug: entry.effectiveSlug,
+            plannerSource: entry.plannerSource,
+            modelKey: entry.modelKey,
+            modelUsed: entry.modelUsed,
+            promptHash: entry.promptHash,
+            promptLength: entry.promptLength,
+            outcome: entry.outcome,
+            timelineStage: entry.timelineStage,
+            reasonCategory: entry.reasonCategory,
+            opCount: entry.opCount,
+            opTypes: entry.opTypes,
+            skippedOpCount: entry.skippedOpCount,
+            inputTokens: entry.inputTokens,
+            outputTokens: entry.outputTokens,
+            totalTokens: entry.totalTokens,
+            cacheCreationInputTokens: entry.cacheCreationInputTokens,
+            cacheReadInputTokens: entry.cacheReadInputTokens,
+            estimatedUsd: entry.estimatedUsd,
+            totalDurationMs: entry.totalDurationMs,
+            planningDurationMs: entry.planningDurationMs,
+            firstPlanningTokenMs: entry.firstPlanningTokenMs,
+            applyDurationMs: entry.applyDurationMs,
+            imageResolutionDurationMs: entry.imageResolutionDurationMs,
+            planningAttempts: entry.planningAttempts,
+            contextPackBytes: entry.contextPackBytes,
+            contractMode: entry.contractMode,
+            contractBytes: entry.contractBytes,
+            contractBlockCount: entry.contractBlockCount,
+            strictJsonEnabled: entry.strictJsonEnabled,
+            schemaRetryUsed: entry.schemaRetryUsed,
+            plannerRefusal: entry.plannerRefusal,
+            plannerIncomplete: entry.plannerIncomplete,
+            compactContextEnabled: entry.compactContextEnabled,
+            minimalContextEnabled: entry.minimalContextEnabled,
+            plannerTier: entry.plannerTier,
+            toolName: entry.toolName,
+            toolOk: entry.toolOk,
+            toolLatencyMs: entry.toolLatencyMs,
+            toolAttempts: entry.toolAttempts,
+            toolErrorCode: entry.toolErrorCode,
+            correlationId: entry.correlationId
+        }, "Chat telemetry event");
+    }
+    function list(args) {
+        const limitRaw = Number(args.limit ?? 100);
+        const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? Math.min(Math.trunc(limitRaw), 1000) : 100;
+        let rows = buffer;
+        if (args.outcome)
+            rows = rows.filter((row) => row.outcome === args.outcome);
+        if (args.phase)
+            rows = rows.filter((row) => row.phase === args.phase);
+        if (args.session)
+            rows = rows.filter((row) => row.session === args.session);
+        const recent = rows.slice(Math.max(0, rows.length - limit));
+        const byOutcome = {};
+        const byReasonCategory = {};
+        for (const row of recent) {
+            if (row.outcome)
+                byOutcome[row.outcome] = (byOutcome[row.outcome] ?? 0) + 1;
+            if (row.reasonCategory)
+                byReasonCategory[row.reasonCategory] = (byReasonCategory[row.reasonCategory] ?? 0) + 1;
+        }
+        return {
+            totalBuffered: buffer.length,
+            returned: recent.length,
+            byOutcome,
+            byReasonCategory,
+            rows: recent
+        };
+    }
+    function review(args) {
+        const limitRaw = Number(args.limit ?? 300);
+        const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? Math.min(Math.trunc(limitRaw), 2000) : 300;
+        let rows = buffer;
+        if (args.session)
+            rows = rows.filter((row) => row.session === args.session);
+        const recent = rows.slice(Math.max(0, rows.length - limit));
+        const failureOutcomes = new Set([
+            "guardrail_failure",
+            "apply_failed",
+            "repair_failed",
+            "planner_exception",
+            "planning_exhausted",
+            "planning_refusal",
+            "planning_incomplete",
+            "planning_missing"
+        ]);
+        const failures = recent.filter((row) => row.phase === "result" && row.outcome && failureOutcomes.has(row.outcome));
+        const success = recent.filter((row) => row.phase === "result" && row.outcome === "applied");
+        const failureByReasonCategory = {};
+        const failureByOutcome = {};
+        let plannerRefusalCount = 0;
+        let plannerIncompleteCount = 0;
+        const byPromptHash = new Map();
+        for (const row of failures) {
+            if (row.plannerRefusal)
+                plannerRefusalCount += 1;
+            if (row.plannerIncomplete)
+                plannerIncompleteCount += 1;
+            if (row.reasonCategory)
+                failureByReasonCategory[row.reasonCategory] = (failureByReasonCategory[row.reasonCategory] ?? 0) + 1;
+            if (row.outcome)
+                failureByOutcome[row.outcome] = (failureByOutcome[row.outcome] ?? 0) + 1;
+            const current = byPromptHash.get(row.promptHash) ??
+                { promptExcerpt: row.promptExcerpt, count: 0, outcomes: {}, reasonCategories: {}, lastAt: row.at };
+            current.count += 1;
+            if (row.outcome)
+                current.outcomes[row.outcome] = (current.outcomes[row.outcome] ?? 0) + 1;
+            if (row.reasonCategory)
+                current.reasonCategories[row.reasonCategory] = (current.reasonCategories[row.reasonCategory] ?? 0) + 1;
+            if (row.at > current.lastAt)
+                current.lastAt = row.at;
+            byPromptHash.set(row.promptHash, current);
+        }
+        const topFailedPrompts = Array.from(byPromptHash.entries())
+            .map(([promptHash, value]) => ({ promptHash, ...value }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 12);
+        const recommendations = [];
+        if ((failureByReasonCategory.schema_violation ?? 0) > 0) {
+            recommendations.push("Schema violations are frequent: add stricter pre-apply normalization for missing required fields and alias keys.");
+        }
+        if ((failureByReasonCategory.not_found ?? 0) > 0) {
+            recommendations.push("Not-found failures detected: improve slug/block resolution using active selection and current page context.");
+        }
+        if ((failureByReasonCategory.ambiguity ?? 0) > 0) {
+            recommendations.push("Ambiguity is high: improve follow-up question templates with explicit selectable options.");
+        }
+        if ((failureByOutcome.planning_exhausted ?? 0) > 0) {
+            recommendations.push("Planner retries are exhausting: add deterministic fallback plans for the top failed prompt families.");
+        }
+        if (recommendations.length === 0) {
+            recommendations.push("No dominant failure mode detected in this sample. Review top failed prompts and add targeted tests for each.");
+        }
+        return {
+            analyzed: recent.length,
+            appliedCount: success.length,
+            failedCount: failures.length,
+            failureRate: recent.length > 0 ? Number((failures.length / recent.length).toFixed(4)) : 0,
+            plannerRefusalCount,
+            plannerIncompleteCount,
+            failureByOutcome,
+            failureByReasonCategory,
+            topFailedPrompts,
+            recommendations
+        };
+    }
+    return {
+        promptExcerpt,
+        promptHash,
+        push,
+        loadFromDisk,
+        list,
+        review
+    };
+}

package/dist/telemetry/eval-candidate-store.d.ts

@@ -0,0 +1,50 @@
+import type { PageDoc } from "@avocadostudio-ai/shared";
+export type EvalCandidate = {
+    id: string;
+    at: string;
+    session: string;
+    slug: string;
+    activeBlockId?: string;
+    activeEditablePath?: string;
+    prompt: string;
+    fixture: PageDoc[];
+    outcome?: string;
+    reasonCategory?: string;
+    plannerTier?: string;
+    opTypes?: string[];
+    opCount?: number;
+    provider?: string;
+    modelKey?: string;
+    modelUsed?: string;
+};
+export type EvalCandidateOpen = Omit<EvalCandidate, "at" | "outcome" | "reasonCategory" | "plannerTier" | "opTypes" | "opCount">;
+export type EvalCandidateFinalize = Partial<Pick<EvalCandidate, "outcome" | "reasonCategory" | "plannerTier" | "opTypes" | "opCount">>;
+type Logger = {
+    info: (payload: Record<string, unknown>, message?: string) => void;
+    error: (payload: Record<string, unknown>, message?: string) => void;
+};
+type CreateEvalCandidateStoreArgs = {
+    filePath: string;
+    limit: number;
+    persistEnabled: boolean;
+    ttlDays: number;
+    logger: Logger;
+};
+export declare function createEvalCandidateStore(args: CreateEvalCandidateStoreArgs): {
+    start: (entry: EvalCandidateOpen) => void;
+    finalize: (id: string, patch: EvalCandidateFinalize) => EvalCandidate | undefined;
+    get: (id: string) => EvalCandidate | undefined;
+    list: (filters: {
+        limit?: number;
+        session?: string;
+        outcome?: string;
+    }) => {
+        total: number;
+        rows: EvalCandidate[];
+    };
+    cancel: (id: string) => void;
+    loadFromDisk: () => Promise<void>;
+    flushNow: () => Promise<void>;
+};
+export type EvalCandidateStore = ReturnType<typeof createEvalCandidateStore>;
+export {};

package/dist/telemetry/eval-candidate-store.js

@@ -0,0 +1,120 @@
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { toErrorDetail as _unifiedToErrorDetail } from "../errors.js";
+const toErrorDetail = _unifiedToErrorDetail;
+export function createEvalCandidateStore(args) {
+    const open = new Map();
+    const finalized = [];
+    const pendingWrites = [];
+    let flushTimer = null;
+    async function flushNow() {
+        if (!args.persistEnabled)
+            return;
+        if (pendingWrites.length === 0)
+            return;
+        const pending = pendingWrites.splice(0, pendingWrites.length);
+        const lines = pending.map((item) => JSON.stringify(item)).join("\n");
+        await mkdir(resolve(args.filePath, ".."), { recursive: true });
+        await appendFile(args.filePath, `${lines}\n`, "utf8");
+    }
+    function scheduleFlush() {
+        if (flushTimer)
+            clearTimeout(flushTimer);
+        flushTimer = setTimeout(() => {
+            void flushNow().catch((error) => {
+                args.logger.error({ err: toErrorDetail(error), file: args.filePath }, "Failed to flush eval candidates");
+            });
+        }, 150);
+    }
+    function isWithinTtl(isoAt, now, ttlMs) {
+        const t = Date.parse(isoAt);
+        if (!Number.isFinite(t))
+            return false;
+        return now - t <= ttlMs;
+    }
+    async function loadFromDisk() {
+        if (!args.persistEnabled)
+            return;
+        if (!existsSync(args.filePath))
+            return;
+        try {
+            const raw = await readFile(args.filePath, "utf8");
+            const lines = raw.split("\n").map((line) => line.trim()).filter(Boolean);
+            const now = Date.now();
+            const ttlMs = args.ttlDays * 24 * 60 * 60 * 1000;
+            finalized.length = 0;
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (!parsed || typeof parsed !== "object")
+                        continue;
+                    if (typeof parsed.id !== "string" || typeof parsed.prompt !== "string")
+                        continue;
+                    if (!isWithinTtl(parsed.at, now, ttlMs))
+                        continue;
+                    finalized.push(parsed);
+                }
+                catch {
+                    // ignore malformed lines
+                }
+            }
+            if (finalized.length > args.limit) {
+                finalized.splice(0, finalized.length - args.limit);
+            }
+            args.logger.info({ file: args.filePath, loaded: finalized.length }, "Loaded eval candidates");
+        }
+        catch (error) {
+            args.logger.error({ err: toErrorDetail(error), file: args.filePath }, "Failed to load eval candidates");
+        }
+    }
+    function start(entry) {
+        open.set(entry.id, entry);
+    }
+    function finalize(id, patch) {
+        const opened = open.get(id);
+        if (!opened)
+            return undefined;
+        open.delete(id);
+        const record = { ...opened, ...patch, at: new Date().toISOString() };
+        finalized.push(record);
+        if (finalized.length > args.limit) {
+            finalized.splice(0, finalized.length - args.limit);
+        }
+        if (args.persistEnabled) {
+            pendingWrites.push(record);
+            scheduleFlush();
+        }
+        args.logger.info({
+            event: "eval_candidate",
+            id: record.id,
+            session: record.session,
+            slug: record.slug,
+            outcome: record.outcome,
+            opTypes: record.opTypes,
+            opCount: record.opCount,
+            plannerTier: record.plannerTier
+        }, "Eval candidate finalized");
+        return record;
+    }
+    function get(id) {
+        for (let i = finalized.length - 1; i >= 0; i--) {
+            if (finalized[i].id === id)
+                return finalized[i];
+        }
+        return undefined;
+    }
+    function list(filters) {
+        const max = Math.min(Math.max(Number(filters.limit) || 100, 1), 1000);
+        let rows = finalized;
+        if (filters.session)
+            rows = rows.filter((r) => r.session === filters.session);
+        if (filters.outcome)
+            rows = rows.filter((r) => r.outcome === filters.outcome);
+        return { total: rows.length, rows: rows.slice(-max) };
+    }
+    function cancel(id) {
+        open.delete(id);
+    }
+    return { start, finalize, get, list, cancel, loadFromDisk, flushNow };
+}

package/dist/telemetry/feedback-store.d.ts

@@ -0,0 +1,34 @@
+export type FeedbackRating = "up" | "down";
+export type FeedbackEntry = {
+    id: string;
+    at: string;
+    traceId: string;
+    session: string;
+    rating: FeedbackRating;
+    note?: string;
+};
+type Logger = {
+    info: (payload: Record<string, unknown>, message?: string) => void;
+    error: (payload: Record<string, unknown>, message?: string) => void;
+};
+type CreateFeedbackStoreArgs = {
+    filePath: string;
+    limit: number;
+    logger: Logger;
+};
+export declare function createFeedbackStore(args: CreateFeedbackStoreArgs): {
+    push: (entry: FeedbackEntry) => void;
+    list: (filters: {
+        session?: string;
+        rating?: string;
+        traceId?: string;
+        limit?: number;
+    }) => {
+        total: number;
+        rows: FeedbackEntry[];
+    };
+    loadFromDisk: () => Promise<void>;
+    flushNow: () => Promise<void>;
+};
+export type FeedbackStore = ReturnType<typeof createFeedbackStore>;
+export {};

package/dist/telemetry/feedback-store.js

@@ -0,0 +1,76 @@
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+export function createFeedbackStore(args) {
+    const buffer = [];
+    const pendingWrites = [];
+    let flushTimer = null;
+    async function flushNow() {
+        if (pendingWrites.length === 0)
+            return;
+        const pending = pendingWrites.splice(0, pendingWrites.length);
+        const lines = pending.map((item) => JSON.stringify(item)).join("\n");
+        await mkdir(resolve(args.filePath, ".."), { recursive: true });
+        await appendFile(args.filePath, `${lines}\n`, "utf8");
+    }
+    function scheduleFlush() {
+        if (flushTimer)
+            clearTimeout(flushTimer);
+        flushTimer = setTimeout(() => {
+            void flushNow().catch((error) => {
+                args.logger.error({ err: String(error), file: args.filePath }, "Failed to flush feedback");
+            });
+        }, 150);
+    }
+    async function loadFromDisk() {
+        if (!existsSync(args.filePath))
+            return;
+        try {
+            const raw = await readFile(args.filePath, "utf8");
+            const lines = raw.split("\n").map((line) => line.trim()).filter(Boolean);
+            const tail = lines.slice(-args.limit);
+            buffer.length = 0;
+            for (const line of tail) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (!parsed || typeof parsed !== "object")
+                        continue;
+                    if (typeof parsed.id !== "string" || typeof parsed.rating !== "string")
+                        continue;
+                    buffer.push(parsed);
+                }
+                catch {
+                    // Ignore malformed lines.
+                }
+            }
+            args.logger.info({ file: args.filePath, loaded: buffer.length }, "Loaded feedback entries");
+        }
+        catch (error) {
+            args.logger.error({ err: String(error), file: args.filePath }, "Failed to load feedback");
+        }
+    }
+    function push(entry) {
+        buffer.push(entry);
+        if (buffer.length > args.limit) {
+            buffer.splice(0, buffer.length - args.limit);
+        }
+        pendingWrites.push(entry);
+        scheduleFlush();
+        args.logger.info({ event: "feedback", id: entry.id, traceId: entry.traceId, session: entry.session, rating: entry.rating }, "Feedback recorded");
+    }
+    function list(filters) {
+        const max = Math.min(Math.max(Number(filters.limit) || 200, 1), 1000);
+        let rows = buffer;
+        if (filters.session)
+            rows = rows.filter((r) => r.session === filters.session);
+        if (filters.rating)
+            rows = rows.filter((r) => r.rating === filters.rating);
+        if (filters.traceId)
+            rows = rows.filter((r) => r.traceId === filters.traceId);
+        return {
+            total: rows.length,
+            rows: rows.slice(-max)
+        };
+    }
+    return { push, list, loadFromDisk, flushNow };
+}

package/dist/telemetry/jira-telemetry.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Jira ticket telemetry — persists per-run traces to JSONL so each ticket
+ * can be reviewed end-to-end after a test (instruction → tool calls → summary).
+ * Follows the append-flush pattern of chat-telemetry.ts / migration-telemetry.ts.
+ *
+ * Location: ~/.data/telemetry/jira-telemetry.jsonl
+ */
+export type JiraToolCallTrace = {
+    name: string;
+    /** Redacted/truncated input — see redactToolInput */
+    input: unknown;
+    durationMs: number;
+    /** First ~400 chars of the tool's string result, for quick scan */
+    resultExcerpt: string;
+    isError: boolean;
+};
+export type JiraTelemetryEntry = {
+    timestamp: string;
+    issueKey: string;
+    mode: "review" | "execute" | "publish";
+    siteId: string;
+    session: string;
+    status: "success" | "error";
+    durationMs: number;
+    model?: string;
+    provider?: string;
+    /** Full instruction string sent to the agent (after comment history is appended) */
+    instruction?: string;
+    /** Review-mode only: parsed JSON verdict */
+    reviewDecision?: {
+        decision: "proceed" | "questions";
+        plan: string[];
+        questions?: string[];
+    };
+    /** Execute-mode only: tool-by-tool trace */
+    toolCalls?: JiraToolCallTrace[];
+    /** Number of `tool_done` events the loop saw (matches pino log totals) */
+    toolCallCount?: number;
+    /** Final summary text the agent returned (execute mode) */
+    summary?: string;
+    /** Changes array (execute mode) — one string per applied op group */
+    changes?: string[];
+    /** Slugs touched (execute mode) */
+    touchedSlugs?: string[];
+    /** True when auto-publish or publish mode succeeded */
+    published?: boolean;
+    /** Status transitions attempted during the run */
+    transitions?: string[];
+    /** Error message (status=error) */
+    error?: string;
+};
+export declare function pushJiraTelemetry(entry: JiraTelemetryEntry): void;
+/**
+ * Make an object safe for JSONL — shallow clone and truncate large string
+ * values. Preserves structure so analysis scripts can still inspect shape.
+ */
+export declare function redactToolInput(input: unknown, maxStringChars?: number): unknown;

package/dist/telemetry/jira-telemetry.js

@@ -0,0 +1,68 @@
+/**
+ * Jira ticket telemetry — persists per-run traces to JSONL so each ticket
+ * can be reviewed end-to-end after a test (instruction → tool calls → summary).
+ * Follows the append-flush pattern of chat-telemetry.ts / migration-telemetry.ts.
+ *
+ * Location: ~/.data/telemetry/jira-telemetry.jsonl
+ */
+import { appendFile, mkdir } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+const TELEMETRY_FILE = resolve(homedir(), ".data/telemetry/jira-telemetry.jsonl");
+const pendingWrites = [];
+let flushTimer = null;
+async function flushNow() {
+    if (pendingWrites.length === 0)
+        return;
+    const pending = pendingWrites.splice(0, pendingWrites.length);
+    const lines = pending.map((item) => JSON.stringify(item)).join("\n");
+    await mkdir(dirname(TELEMETRY_FILE), { recursive: true });
+    await appendFile(TELEMETRY_FILE, `${lines}\n`, "utf8");
+}
+function scheduleFlush() {
+    if (flushTimer)
+        clearTimeout(flushTimer);
+    flushTimer = setTimeout(() => {
+        void flushNow().catch((err) => {
+            console.error("[jira-telemetry] flush failed:", err instanceof Error ? err.message : String(err));
+        });
+    }, 150);
+    flushTimer.unref();
+}
+process.on("beforeExit", () => { void flushNow().catch(() => { }); });
+export function pushJiraTelemetry(entry) {
+    pendingWrites.push(entry);
+    scheduleFlush();
+    // Console summary so tail -f on stdout reads well during live testing.
+    const toolPart = entry.toolCalls && entry.toolCalls.length > 0
+        ? ` | tools: ${entry.toolCalls.map((t) => t.name).join(",")}`
+        : "";
+    const decisionPart = entry.reviewDecision ? ` | ${entry.reviewDecision.decision}` : "";
+    console.log(`[jira-telemetry] ${entry.issueKey} ${entry.mode} ${entry.status} ` +
+        `| ${(entry.durationMs / 1000).toFixed(1)}s${decisionPart}${toolPart}` +
+        (entry.error ? ` | err: ${entry.error.slice(0, 120)}` : ""));
+}
+/**
+ * Make an object safe for JSONL — shallow clone and truncate large string
+ * values. Preserves structure so analysis scripts can still inspect shape.
+ */
+export function redactToolInput(input, maxStringChars = 1000) {
+    if (input == null || typeof input !== "object")
+        return input;
+    if (Array.isArray(input)) {
+        return input.slice(0, 50).map((v) => redactToolInput(v, maxStringChars));
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+        if (typeof v === "string" && v.length > maxStringChars) {
+            out[k] = `${v.slice(0, maxStringChars)}… [truncated ${v.length - maxStringChars} chars]`;
+        }
+        else if (typeof v === "object" && v !== null) {
+            out[k] = redactToolInput(v, maxStringChars);
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}