dsh-continual-evolve 0.11.0 → 0.12.0

package/lib/listener.js

@@ -1,199 +0,0 @@
-import { goalServiceOf } from "./goal.js";
-import { isGateEnabled } from "./runtime.js";
-import { createReviewScheduler } from "./review-scheduler.js";
-import { captureTurnSnapshot } from "./turn-snapshot.js";
-import { appendReviewRecord, writeArmedMarker } from "./audit-log.js";
-import { runMemoryExtractionPhase, stateFor, } from "./extraction-phase.js";
-/** Default session-close drain budget: an in-flight extraction gets 15s to settle. */
-export const SESSION_CLOSE_DRAIN_MS_DEFAULT = 15000;
-/**
- * Resolve the session-close drain budget: absent/invalid → default, 0 →
- * immediate abort (legacy). Negative or non-finite values fail back to the
- * default rather than silently disabling the drain.
- */
-export function resolveSessionCloseDrainMs(raw) {
-    if (raw === undefined)
-        return SESSION_CLOSE_DRAIN_MS_DEFAULT;
-    if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0)
-        return SESSION_CLOSE_DRAIN_MS_DEFAULT;
-    return Math.floor(raw);
-}
-/**
- * Bounded session-close drain for one scheduler: wait for in-flight work up
- * to drainMs, then abort the owner signal and drop pending captures. Never
- * rejects — disposal must not hang the host on a stuck model call, and the
- * abort below is idempotent when the drain already settled.
- */
-export function drainSchedulerOnDispose(scheduler, drainMs) {
-    if (drainMs <= 0) {
-        try {
-            scheduler.shutdown();
-        }
-        catch {
-            // shutdown is flag-setting plus abort: nothing observable to do
-        }
-        return Promise.resolve();
-    }
-    let timer;
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(resolve, drainMs);
-    });
-    const settle = () => {
-        if (timer !== undefined)
-            clearTimeout(timer);
-        try {
-            scheduler.shutdown();
-        }
-        catch {
-            // same as above — the abort is best-effort by design
-        }
-    };
-    return Promise.race([scheduler.drain(), timeout]).then(settle, settle);
-}
-export function registerAutoReview(ctx, engine, config) {
-    const perSession = new Map();
-    const schedulers = new Map();
-    const captureTails = new Map();
-    const disposedSessions = new Set();
-    const logger = ctx.logger("continual-evolve");
-    const defaultEnabled = config.enabledByDefault ?? true;
-    const record = (entry) => {
-        appendReviewRecord(engine.baseDir, entry, config.reviewsRetain, (cause) => logger.warn(`failed to record auto-review: ${cause instanceof Error ? cause.message : String(cause)}`));
-    };
-    const schedulerFor = (agent, state) => {
-        const existing = schedulers.get(agent.id);
-        if (existing)
-            return existing;
-        const scheduler = createReviewScheduler(async ({ snapshot, signal }) => {
-            if (!isGateEnabled(engine.baseDir, defaultEnabled))
-                return "aborted";
-            if (!snapshot.eligible) {
-                record({
-                    sessionId: snapshot.sessionId,
-                    reason: snapshot.reason,
-                    turnsSinceLastReview: state.turns - state.lastReviewAt,
-                    outcome: "skipped",
-                    rationale: `snapshot ${snapshot.cursor} skipped: ${snapshot.skipReason ?? "not eligible"}`,
-                });
-                return "no-op";
-            }
-            try {
-                await runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, record, signal);
-                return "success";
-            }
-            catch (cause) {
-                const message = cause instanceof Error ? cause.message : String(cause);
-                logger.warn(`memory extraction failed for ${agent.id}: ${message}`);
-                record({
-                    sessionId: agent.id,
-                    reason: snapshot.reason,
-                    turnsSinceLastReview: state.turns - state.lastReviewAt,
-                    outcome: "failed",
-                    rationale: `extraction error: ${message}`,
-                });
-                return "error";
-            }
-        }, (snapshot) => snapshot.cursor);
-        schedulers.set(agent.id, scheduler);
-        return scheduler;
-    };
-    const captureAndSchedule = (agent, state, reason) => {
-        if (disposedSessions.has(agent.id) || !isGateEnabled(engine.baseDir, defaultEnabled))
-            return;
-        const previousCapture = captureTails.get(agent.id) ?? Promise.resolve();
-        const captureTask = previousCapture.then(async () => {
-            if (disposedSessions.has(agent.id) || !isGateEnabled(engine.baseDir, defaultEnabled))
-                return;
-            const cursor = schedulerFor(agent, state).getCursor();
-            const snapshot = await captureTurnSnapshot(ctx, agent, {
-                turn: state.completedTurn,
-                reason,
-                ...(cursor !== undefined ? { cursor } : {}),
-                maxChars: config.maxInputChars,
-                ...(config.memoryMinUserWords !== undefined ? { minUserWords: config.memoryMinUserWords } : {}),
-            });
-            if (!disposedSessions.has(agent.id))
-                schedulerFor(agent, state).schedule(snapshot);
-        }).catch((cause) => {
-            const message = cause instanceof Error ? cause.message : String(cause);
-            logger.warn(`memory snapshot failed for ${agent.id}: ${message}`);
-            record({
-                sessionId: agent.id,
-                reason,
-                turnsSinceLastReview: state.turns - state.lastReviewAt,
-                outcome: "failed",
-                rationale: `snapshot error: ${message}`,
-            });
-        });
-        captureTails.set(agent.id, captureTask);
-    };
-    // DSH emits this awaited boundary when a turn is about to close. It only
-    // advances the mechanical counters — extraction is moment-driven, so a
-    // successful turn never costs an LLM call by itself.
-    ctx.on("agent/turn-stopping", (payload) => {
-        const agent = payload.agent;
-        if (!agent) {
-            logger.warn(`memory extraction listener: agent/turn-stopping payload missing agent; skipping count`);
-            return;
-        }
-        const state = stateFor(perSession, agent.id);
-        state.turns += 1;
-        if (typeof payload.turn === "number")
-            state.completedTurn = Math.max(state.completedTurn, payload.turn);
-    });
-    // The idle transition is the safe point at which to read the durable
-    // surface. It probes the goal phase (mechanical, zero LLM) and fires the
-    // goal-blocked moment when the streak reaches the threshold.
-    ctx.on("agent/status", (payload) => {
-        const agent = payload.agent;
-        if (!agent || payload.status !== "idle")
-            return;
-        if (config.goalBlockedWrapupTurns <= 0)
-            return;
-        const state = stateFor(perSession, agent.id);
-        const goal = goalServiceOf(ctx)?.get(agent);
-        if (goal?.phase !== "blocked") {
-            state.goalBlockStreak = 0;
-            return;
-        }
-        state.goalBlockStreak += 1;
-        if (state.goalBlockStreak < config.goalBlockedWrapupTurns)
-            return;
-        state.goalBlockStreak = 0; // one moment per streak; declines re-arm after the next full streak
-        logger.info(`goal-blocked moment [${agent.id}]: ${config.goalBlockedWrapupTurns} consecutive blocked rounds → memory extraction`);
-        captureAndSchedule(agent, state, "goal_blocked");
-    });
-    // Boot-time diagnostic: proves the listener was registered even when its
-    // runtime default is off, distinguishing "not registered" from "off".
-    writeArmedMarker(engine.baseDir, `automatic evolution listener registered (mode=memory-only; default=${defaultEnabled ? "on" : "off"}; moments=compaction/goal-blocked/session-close-drain/manual-wrapup)`, (cause) => logger.warn(`failed to write armed marker: ${cause instanceof Error ? cause.message : String(cause)}`));
-    ctx.on("agent/disposed", (payload) => {
-        const agent = payload.agent;
-        if (!agent)
-            return;
-        disposedSessions.add(agent.id);
-        const scheduler = schedulers.get(agent.id);
-        schedulers.delete(agent.id);
-        captureTails.delete(agent.id);
-        perSession.delete(agent.id);
-        if (scheduler) {
-            // Bounded session-close drain: an in-flight extraction gets drainMs
-            // to settle so its result is not lost on session close; afterwards
-            // the owner signal aborts. Fire-and-forget — disposal must never
-            // hang the host, and the helper never rejects.
-            void drainSchedulerOnDispose(scheduler, resolveSessionCloseDrainMs(config.sessionCloseDrainMs));
-        }
-    });
-    ctx.on("session/event", (session, event) => {
-        // Compaction moment: extract before the pre-compaction trajectory is
-        // summarized away. Cold sessions (no live agent) are ignored.
-        if (event.type !== "compaction/start")
-            return;
-        const agents = ctx.agents;
-        const agent = agents?.get(session.id);
-        if (!agent)
-            return;
-        const state = stateFor(perSession, agent.id);
-        captureAndSchedule(agent, state, "compact");
-    });
-}
-//# sourceMappingURL=listener.js.map

package/lib/llm-text.d.ts

@@ -1,104 +0,0 @@
-/**
- * Unified LLM text call: a shared streaming-text helper used by the review
- * gate, planner, and wrap-up assessor. Eliminates ~120 lines of duplicated
- * BlockAssembler + finish-state-check + text-extraction boilerplate.
- *
- * Every caller needs the same sequence:
- *   provider/model validation → stream → assemble → check finish → extract text
- * This module owns that sequence; callers keep only their prompt construction
- * and JSON parsing.
- */
-import type { Context } from "@deepseek-ai/cordis";
-import { type ContentBlock, type GenerateOptions, type LlmResolvedModelInfo, type Message, type ReasoningEffortId, type RequestMessage, type TokenUsage, type ToolSchema } from "@deepseek-ai/dsh-llm";
-/** Terminal outcome of one shared direct LLM call. */
-export type StreamTextOutcome = "success" | "max-tokens" | "error" | "aborted" | "empty";
-/** Host-owned session identity type used by provider routing metadata. */
-export type LlmSessionId = NonNullable<GenerateOptions["sessionId"]>;
-/** Carry the host Agent id across the plugin's direct-call boundary. */
-export declare function asLlmSessionId(value: string): LlmSessionId;
-/** Provider usage and terminal result observed after the stream settles. */
-export interface StreamTextObservation {
-    usage?: TokenUsage;
-    outcome: StreamTextOutcome;
-    /** Exact capability-derived effort used for this call; absent when no metadata was exposed. */
-    reasoningEffort?: ReasoningEffortId;
-}
-/** Diagnostic observer invoked before streamText returns or throws. */
-export type StreamTextUsageObserver = (observation: StreamTextObservation) => void;
-export interface StreamTextOptions {
-    provider: string;
-    model: string;
-    system: string;
-    prompt: string;
-    maxTokens?: number;
-    signal?: AbortSignal | undefined;
-    /** Host session identity forwarded to adapters for request routing. */
-    sessionId?: LlmSessionId;
-    /**
-     * Route A session prefix: session-derived messages sent before the
-     * trailing caller message so providers with prompt caching can serve
-     * the shared context at cache-read price. Empty/omitted keeps the
-     * legacy single-message request.
-     */
-    prefixMessages?: readonly Message[];
-    /**
-     * Observe the provider-reported usage and terminal outcome after the
-     * stream settles. The callback runs before success/error return and is
-     * diagnostic-only: throwing from it never changes the model call result.
-     */
-    onUsage?: StreamTextUsageObserver;
-}
-/** One provider request for a bounded internal agent/tool loop. */
-export interface StreamModelTurnOptions {
-    provider: string;
-    model: string;
-    messages: readonly RequestMessage[];
-    /** One-shot system slot. Omit when messages already carry the system prompt. */
-    system?: string;
-    /** Closed tool schemas for this request; omitted means no tools. */
-    tools?: readonly ToolSchema[];
-    maxTokens?: number;
-    signal?: AbortSignal | undefined;
-    /** Host session identity forwarded to adapters for request routing. */
-    sessionId?: LlmSessionId;
-    /** Require at least one text block; tool-only turns must leave this false. */
-    requireText?: boolean;
-    /** Require visible text or a tool call; reasoning-only agent turns are empty. */
-    requireTextOrToolCall?: boolean;
-    /** Same diagnostic observer contract as {@link StreamTextOptions.onUsage}. */
-    onUsage?: StreamTextUsageObserver;
-}
-/**
- * Select the lowest reasoning effort an exact model advertises.
- *
- * An enabled effort wins over a declared closing effort. The adapter-preferred
- * first enabled effort is the lowest enabled level it exposes; a closing effort
- * is only a fallback when the model publishes no enabled level. No capability
- * list means no caller-supplied effort.
- *
- * @param modelInfo - exact resolved-model metadata, when the provider exposes it.
- * @returns The selected provider-owned effort id, or `undefined` when unknown.
- */
-export declare function selectLowestReasoningEffort(modelInfo: Pick<LlmResolvedModelInfo, "reasoning"> | undefined): ReasoningEffortId | undefined;
-/**
- * Stream a single-turn text completion through `ctx.llm`. The request uses the
- * exact provider/model's lowest advertised reasoning effort, omitting the field
- * when the model exposes no reasoning metadata.
- *
- * @returns The concatenated text blocks from the response.
- * @throws On provider error, abort, max-token truncation, or empty output.
- */
-/**
- * Stream one provider/model turn and return its assembled content blocks.
- * This is the shared primitive for text callers and bounded tool loops; finish
- * state, capability-derived effort, cancellation, and usage observation stay
- * inside this boundary.
- *
- * @param ctx - DSH context providing the LLM runtime.
- * @param opts - Exact route, messages, optional tools, and output requirements.
- * @returns The assembled content blocks; caller decides how to interpret them.
- * @throws On provider error, abort, max-token truncation, or capability lookup failure.
- */
-export declare function streamModelTurn(ctx: Context, opts: StreamModelTurnOptions): Promise<ContentBlock[]>;
-export declare function streamText(ctx: Context, opts: StreamTextOptions): Promise<string>;
-//# sourceMappingURL=llm-text.d.ts.map

package/lib/llm-text.js

@@ -1,140 +0,0 @@
-import { BlockAssembler, createUserMessage, } from "@deepseek-ai/dsh-llm";
-import { EVOLVE_MESSAGE_SOURCE } from "./message-source.js";
-/** Carry the host Agent id across the plugin's direct-call boundary. */
-export function asLlmSessionId(value) {
-    return value;
-}
-const CLOSED_REASONING_EFFORTS = new Set(["disabled", "off", "none"]);
-/**
- * Select the lowest reasoning effort an exact model advertises.
- *
- * An enabled effort wins over a declared closing effort. The adapter-preferred
- * first enabled effort is the lowest enabled level it exposes; a closing effort
- * is only a fallback when the model publishes no enabled level. No capability
- * list means no caller-supplied effort.
- *
- * @param modelInfo - exact resolved-model metadata, when the provider exposes it.
- * @returns The selected provider-owned effort id, or `undefined` when unknown.
- */
-export function selectLowestReasoningEffort(modelInfo) {
-    const efforts = modelInfo?.reasoning?.efforts;
-    if (efforts !== undefined && !Array.isArray(efforts)) {
-        throw new Error("evolve: invalid model reasoning metadata");
-    }
-    if (!efforts || efforts.length === 0)
-        return undefined;
-    for (const effort of efforts) {
-        if (typeof effort?.id !== "string") {
-            throw new Error("evolve: invalid model reasoning metadata");
-        }
-    }
-    return efforts.find((effort) => !CLOSED_REASONING_EFFORTS.has(effort.id))?.id ?? efforts[0]?.id;
-}
-async function resolveReasoningEffort(ctx, opts) {
-    // The current DSH host exposes this method. Keep a capability-less test or
-    // older host usable by treating the absent query as unknown metadata.
-    if (typeof ctx.llm.resolveModelInfo !== "function")
-        return undefined;
-    const modelInfo = await ctx.llm.resolveModelInfo(opts.provider, opts.model);
-    return selectLowestReasoningEffort(modelInfo);
-}
-/**
- * Stream a single-turn text completion through `ctx.llm`. The request uses the
- * exact provider/model's lowest advertised reasoning effort, omitting the field
- * when the model exposes no reasoning metadata.
- *
- * @returns The concatenated text blocks from the response.
- * @throws On provider error, abort, max-token truncation, or empty output.
- */
-/**
- * Stream one provider/model turn and return its assembled content blocks.
- * This is the shared primitive for text callers and bounded tool loops; finish
- * state, capability-derived effort, cancellation, and usage observation stay
- * inside this boundary.
- *
- * @param ctx - DSH context providing the LLM runtime.
- * @param opts - Exact route, messages, optional tools, and output requirements.
- * @returns The assembled content blocks; caller decides how to interpret them.
- * @throws On provider error, abort, max-token truncation, or capability lookup failure.
- */
-export async function streamModelTurn(ctx, opts) {
-    const assembler = new BlockAssembler();
-    let outcome = "error";
-    let reasoningEffort;
-    try {
-        reasoningEffort = await resolveReasoningEffort(ctx, opts);
-        for await (const chunk of ctx.llm.stream({
-            provider: opts.provider,
-            model: opts.model,
-            messages: [...opts.messages],
-            ...(opts.system === undefined ? {} : { system: opts.system }),
-            ...(opts.tools === undefined ? {} : { tools: [...opts.tools] }),
-            ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
-            maxTokens: opts.maxTokens ?? 8000,
-            ...(opts.signal ? { signal: opts.signal } : {}),
-            ...(opts.sessionId ? { sessionId: opts.sessionId } : {}),
-        })) {
-            assembler.push(chunk);
-        }
-        const finish = assembler.finish;
-        if (finish.kind === "error") {
-            outcome = "error";
-            throw new Error(`evolve: LLM call failed: ${finish.failure?.message ?? "unknown"}`);
-        }
-        if (finish.kind === "aborted") {
-            outcome = "aborted";
-            throw new Error("evolve: LLM call aborted");
-        }
-        if (finish.kind === "max-tokens") {
-            outcome = "max-tokens";
-            throw new Error("evolve: LLM output budget exhausted (max-tokens)");
-        }
-        const blocks = assembler.blocks();
-        const hasText = blocks.some((block) => block.type === "text" && block.text.length > 0);
-        const hasToolCall = blocks.some((block) => block.type === "tool-call");
-        const missingRequiredOutput = (opts.requireText === true && !hasText)
-            || (opts.requireTextOrToolCall === true && !hasText && !hasToolCall);
-        outcome = blocks.length === 0 || missingRequiredOutput ? "empty" : "success";
-        return blocks;
-    }
-    finally {
-        try {
-            opts.onUsage?.({
-                ...(assembler.usage ? { usage: assembler.usage } : {}),
-                outcome,
-                ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
-            });
-        }
-        catch {
-            // Usage observation is diagnostic; its failure must not alter the model call.
-        }
-    }
-}
-export async function streamText(ctx, opts) {
-    const blocks = await streamModelTurn(ctx, {
-        provider: opts.provider,
-        model: opts.model,
-        system: opts.system,
-        messages: [
-            ...(opts.prefixMessages ?? []),
-            createUserMessage({
-                content: [{ type: "text", text: opts.prompt }],
-                source: EVOLVE_MESSAGE_SOURCE,
-            }),
-        ],
-        requireText: true,
-        ...(opts.maxTokens === undefined ? {} : { maxTokens: opts.maxTokens }),
-        ...(opts.signal ? { signal: opts.signal } : {}),
-        ...(opts.sessionId ? { sessionId: opts.sessionId } : {}),
-        ...(opts.onUsage ? { onUsage: opts.onUsage } : {}),
-    });
-    const text = blocks
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join("\n");
-    if (text.length === 0) {
-        throw new Error("evolve: LLM produced no text output");
-    }
-    return text;
-}
-//# sourceMappingURL=llm-text.js.map

package/lib/logfile.d.ts

@@ -1,71 +0,0 @@
-/**
- * Plugin-owned file logging: a cordis logger exporter that appends every
- * log message — from this plugin or any other — to a JSONL file under the
- * evolve store. Logging becomes a property of the plugin itself: no extra
- * component to install, and it works no matter how `dsh web` is launched
- * (foreground terminal, nohup, restart scripts, ...). The official
- * `cordis-plugin-logger-console` remains an optional add-on for live
- * terminal output; this file exporter is the baseline that always exists.
- *
- * - file: `<baseDir>/evolve/plugin.log` (0600, JSONL)
- * - rotation: when the file exceeds `logMaxBytes` it is renamed to
- *   `plugin.log.1` (replacing the previous `.1`)
- * - level: `levels.default` = logLevel (0=error, 1=info, 2=warn, 3=debug)
- * - failure containment: a write error is swallowed — logging never
- *   disturbs the agent loop
- */
-import type { Context } from "@deepseek-ai/cordis";
-/** Name of the plugin log file under `<baseDir>/evolve/`. */
-export declare const PLUGIN_LOG_FILE_NAME = "plugin.log";
-/** Default rotation threshold (5 MiB). */
-export declare const DEFAULT_LOG_MAX_BYTES: number;
-export interface FileLoggerConfig {
-    /** 0=error, 1=info, 2=warn, 3=debug. */
-    logLevel?: number;
-    /** Rotate the log when it exceeds this many bytes. */
-    logMaxBytes?: number;
-}
-/** Full path of the plugin log file. */
-export declare function pluginLogFilePath(baseDir: string): string;
-/** JSON-safe rendering of a log message's arguments. */
-export declare function renderArgs(args: readonly unknown[]): unknown[];
-/** One JSONL record as written to the log file. */
-export declare function logRecord(message: {
-    ts: number;
-    type: string;
-    name: string;
-    args: readonly unknown[];
-}): string;
-/** Human-readable rendering of one stored JSONL line (unparseable lines pass through). */
-export declare function formatLogLine(line: string): string;
-/**
- * The distinct session ids mentioned in one stored log line, drawn from the
- * rendered message and the raw args (unparseable lines fall back to a raw
- * text scan). Exact-token matching, so `session-abc` never matches
- * `session-abcd`.
- */
-export declare function sessionIdsInLine(line: string): string[];
-/**
- * Keep only the lines mentioning the given session id (exact token match).
- * An empty/whitespace session id filters everything out — the caller should
- * validate the argument before calling.
- */
-export declare function filterLogBySession(lines: readonly string[], sessionId: string): string[];
-/** Append one line, rotating the file first when it exceeds maxBytes. */
-export declare function appendOrRotate(path: string, maxBytes: number, line: string): void;
-/**
- * Register the file exporter on the context. Returns the exporter so tests
- * can drive it directly. The exporter is disposed with the plugin's scope.
- */
-export declare function registerFileLogger(ctx: Context, baseDir: string, config?: FileLoggerConfig): {
-    levels: {
-        default: number;
-    };
-    export(message: {
-        ts: number;
-        type: string;
-        name: string;
-        args: readonly unknown[];
-    }): void;
-};
-//# sourceMappingURL=logfile.d.ts.map

package/lib/logfile.js

@@ -1,159 +0,0 @@
-import { Logger } from "@deepseek-ai/cordis";
-import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-/** Name of the plugin log file under `<baseDir>/evolve/`. */
-export const PLUGIN_LOG_FILE_NAME = "plugin.log";
-/** Default rotation threshold (5 MiB). */
-export const DEFAULT_LOG_MAX_BYTES = 5 * 1024 * 1024;
-/** Full path of the plugin log file. */
-export function pluginLogFilePath(baseDir) {
-    return join(baseDir, "evolve", PLUGIN_LOG_FILE_NAME);
-}
-/** JSON-safe rendering of a log message's arguments. */
-export function renderArgs(args) {
-    return args.map((arg) => {
-        if (arg instanceof Error) {
-            return { name: arg.name, message: arg.message, stack: arg.stack };
-        }
-        if (typeof arg === "object" && arg !== null) {
-            try {
-                return JSON.parse(JSON.stringify(arg));
-            }
-            catch {
-                return String(arg);
-            }
-        }
-        return arg;
-    });
-}
-/** One JSONL record as written to the log file. */
-export function logRecord(message) {
-    // `message` is the printf-rendered text (cordis handles %s/%o/...), so
-    // humans and machines both get a usable line; `args` keeps the raw
-    // payload for tooling. Errors render as their stack (JSON.stringify of
-    // an Error is just {}).
-    const rendered = Logger.format({
-        formatters: {
-            o: (value) => (value instanceof Error ? value.stack ?? value.message : JSON.stringify(value)),
-        },
-        maxLength: 10240,
-        export: () => { },
-    }, {
-        sn: 0,
-        ts: message.ts,
-        name: message.name,
-        type: message.type,
-        level: 0,
-        args: message.args,
-    });
-    return JSON.stringify({
-        ts: new Date(message.ts).toISOString(),
-        type: message.type,
-        name: message.name,
-        args: renderArgs(message.args),
-        message: rendered,
-    });
-}
-/** Human-readable rendering of one stored JSONL line (unparseable lines pass through). */
-export function formatLogLine(line) {
-    try {
-        const record = JSON.parse(line);
-        const ts = record.ts ?? "";
-        const type = record.type ? `[${record.type[0]?.toUpperCase() ?? "?"}]` : "[?]";
-        const name = record.name ?? "";
-        const body = typeof record.message === "string" && record.message.length > 0 ? record.message : "";
-        const args = body
-            ? ""
-            : Array.isArray(record.args)
-                ? record.args.map((arg) => (typeof arg === "object" && arg !== null ? JSON.stringify(arg) : String(arg))).join(" ")
-                : "";
-        return `${ts} ${type} ${name} ${body || args}`.trimEnd();
-    }
-    catch {
-        return line;
-    }
-}
-/** A session id as it appears in log text (dsh `session-<hex-uuid>` ids). */
-const SESSION_TOKEN_RE = /\bsession-[0-9a-fA-F-]+\b/g;
-/**
- * The distinct session ids mentioned in one stored log line, drawn from the
- * rendered message and the raw args (unparseable lines fall back to a raw
- * text scan). Exact-token matching, so `session-abc` never matches
- * `session-abcd`.
- */
-export function sessionIdsInLine(line) {
-    const ids = [];
-    const collect = (text) => {
-        for (const match of text.matchAll(SESSION_TOKEN_RE)) {
-            ids.push(match[0]);
-        }
-    };
-    try {
-        const record = JSON.parse(line);
-        if (typeof record.message === "string")
-            collect(record.message);
-        if (Array.isArray(record.args)) {
-            for (const arg of record.args) {
-                collect(typeof arg === "object" && arg !== null ? JSON.stringify(arg) : String(arg));
-            }
-        }
-    }
-    catch {
-        collect(line);
-    }
-    return [...new Set(ids)];
-}
-/**
- * Keep only the lines mentioning the given session id (exact token match).
- * An empty/whitespace session id filters everything out — the caller should
- * validate the argument before calling.
- */
-export function filterLogBySession(lines, sessionId) {
-    const needle = sessionId.trim();
-    if (!needle) {
-        return [];
-    }
-    return lines.filter((line) => sessionIdsInLine(line).includes(needle));
-}
-/** Append one line, rotating the file first when it exceeds maxBytes. */
-export function appendOrRotate(path, maxBytes, line) {
-    const dir = dirname(path);
-    if (!existsSync(path)) {
-        mkdirSync(dir, { recursive: true });
-        // 0600: the log can carry session context and must not be world-readable
-        writeFileSync(path, "", { encoding: "utf8", mode: 0o600 });
-    }
-    if (maxBytes > 0) {
-        try {
-            if (statSync(path).size > maxBytes) {
-                renameSync(path, `${path}.1`);
-            }
-        }
-        catch {
-            // stat/rename failures fall through to the append attempt
-        }
-    }
-    appendFileSync(path, `${line}\n`, "utf8");
-}
-/**
- * Register the file exporter on the context. Returns the exporter so tests
- * can drive it directly. The exporter is disposed with the plugin's scope.
- */
-export function registerFileLogger(ctx, baseDir, config = {}) {
-    const path = pluginLogFilePath(baseDir);
-    const maxBytes = config.logMaxBytes ?? DEFAULT_LOG_MAX_BYTES;
-    const exporter = {
-        levels: { default: config.logLevel ?? 1 },
-        export(message) {
-            try {
-                appendOrRotate(path, maxBytes, logRecord(message));
-            }
-            catch {
-                // logging must never disturb the agent loop
-            }
-        },
-    };
-    ctx.logger.exporter(exporter);
-    return exporter;
-}
-//# sourceMappingURL=logfile.js.map