@openacp/cli 2026.331.1 → 2026.331.2

package/dist/chunk-FPKQYCQS.js

@@ -1,776 +0,0 @@
-import {
-  ContextManager,
-  EntireProvider
-} from "./chunk-BYCJQPMN.js";
-import {
-  DEFAULT_MAX_TOKENS,
-  TOKENS_PER_TURN_ESTIMATE
-} from "./chunk-NJX75BLK.js";
-
-// src/plugins/context/index.ts
-import * as path2 from "path";
-
-// src/plugins/context/history/history-context-builder.ts
-function selectLevel(turnCount) {
-  if (turnCount <= 10) return "full";
-  if (turnCount <= 25) return "balanced";
-  return "compact";
-}
-function estimateTokens(text) {
-  return Math.floor(text.length / 4);
-}
-function buildHistoryMarkdown(turns, mode) {
-  if (turns.length === 0) return "";
-  switch (mode) {
-    case "full":
-      return buildFull(turns);
-    case "balanced":
-      return buildBalanced(turns);
-    case "compact":
-      return buildCompact(turns);
-  }
-}
-function buildFull(turns) {
-  const out = [];
-  let userIndex = 0;
-  for (const turn of turns) {
-    if (turn.role === "user") {
-      userIndex++;
-      out.push(`**User [${userIndex}]:**`);
-      out.push(turn.content ?? "");
-      if (turn.attachments?.length) {
-        out.push(turn.attachments.map((a) => `[${a.type}: ${a.fileName}]`).join(" "));
-      }
-      out.push("");
-    } else if (turn.role === "assistant" && turn.steps?.length) {
-      out.push("**Assistant:**");
-      for (const step of turn.steps) {
-        out.push(renderStepFull(step));
-      }
-      if (turn.usage) {
-        const parts = [];
-        if (turn.usage.tokensUsed) parts.push(`${turn.usage.tokensUsed.toLocaleString()} tokens`);
-        if (turn.usage.cost) parts.push(`$${turn.usage.cost.amount.toFixed(4)}`);
-        if (parts.length) out.push(`**Usage**: ${parts.join(", ")}`);
-      }
-      out.push("");
-      out.push("---");
-      out.push("");
-    }
-  }
-  return out.join("\n");
-}
-function renderStepFull(step) {
-  switch (step.type) {
-    case "thinking":
-      return `> **Thinking**: ${step.content}
-`;
-    case "text":
-      return `${step.content}
-`;
-    case "tool_call":
-      return renderToolCallFull(step);
-    case "plan":
-      return renderPlan(step.entries);
-    case "image":
-      return `[Image: ${step.mimeType}]
-`;
-    case "audio":
-      return `[Audio: ${step.mimeType}]
-`;
-    case "resource":
-      return `[Resource: ${step.name}] ${step.uri}
-`;
-    case "resource_link":
-      return `[Resource Link: ${step.name}] ${step.uri}
-`;
-    case "mode_change":
-      return `*Mode changed to: ${step.modeId}*
-`;
-    case "config_change":
-      return `*Config ${step.configId} set to: ${step.value}*
-`;
-  }
-}
-function renderToolCallFull(step) {
-  const lines = [];
-  const loc = step.locations?.[0];
-  const locStr = loc ? loc.line ? `${loc.path}:${loc.line}` : loc.path : "";
-  if (step.diff) {
-    lines.push(`**[${step.name}]** \`${locStr || step.diff.path}\``);
-    lines.push("```diff");
-    if (step.diff.oldText) {
-      for (const line of step.diff.oldText.split("\n")) lines.push(`- ${line}`);
-    }
-    for (const line of step.diff.newText.split("\n")) lines.push(`+ ${line}`);
-    lines.push("```");
-  } else {
-    lines.push(`**[${step.name}]** \`${locStr}\``);
-  }
-  if (step.permission) {
-    lines.push(`*Permission: ${step.permission.outcome}*`);
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function renderPlan(entries) {
-  const lines = ["**Plan:**"];
-  for (const e of entries) {
-    const icon = e.status === "completed" || e.status === "done" ? "\u2705" : e.status === "in_progress" ? "\u{1F504}" : "\u2B1C";
-    lines.push(`${icon} ${e.content} (${e.priority})`);
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function buildBalanced(turns) {
-  const out = [];
-  let userIndex = 0;
-  for (const turn of turns) {
-    if (turn.role === "user") {
-      userIndex++;
-      out.push(`**User [${userIndex}]:**`);
-      out.push(turn.content ?? "");
-      out.push("");
-    } else if (turn.role === "assistant" && turn.steps?.length) {
-      out.push("**Assistant:**");
-      for (const step of turn.steps) {
-        if (step.type === "thinking") continue;
-        if (step.type === "text") {
-          out.push(step.content);
-        } else if (step.type === "tool_call") {
-          out.push(renderToolCallBalanced(step));
-        } else if (step.type === "plan") {
-          out.push(renderPlan(step.entries));
-        } else {
-          out.push(renderStepFull(step));
-        }
-      }
-      out.push("");
-      out.push("---");
-      out.push("");
-    }
-  }
-  return out.join("\n");
-}
-function renderToolCallBalanced(step) {
-  const loc = step.locations?.[0];
-  const locStr = loc ? loc.line ? `${loc.path}:${loc.line}` : loc.path : "";
-  if (step.diff) {
-    const oldLines = step.diff.oldText?.split("\n").length ?? 0;
-    const newLines = step.diff.newText.split("\n").length;
-    return `- ${step.name} \`${locStr || step.diff.path}\` (-${oldLines}/+${newLines} lines)`;
-  }
-  return `- ${step.name} \`${locStr}\``;
-}
-function buildCompact(turns) {
-  const out = [];
-  let i = 0;
-  while (i < turns.length) {
-    const turn = turns[i];
-    if (turn.role === "user") {
-      const userText = (turn.content ?? "").slice(0, 100);
-      const nextTurn = turns[i + 1];
-      if (nextTurn?.role === "assistant" && nextTurn.steps?.length) {
-        const tools = nextTurn.steps.filter((s) => s.type === "tool_call").map((s) => s.name);
-        const texts = nextTurn.steps.filter((s) => s.type === "text").map((s) => s.content.slice(0, 80));
-        const parts = [];
-        if (tools.length) parts.push(tools.join(", "));
-        if (texts.length) parts.push(texts.join(" "));
-        out.push(`User: ${userText} \u2192 Assistant: ${parts.join(" | ")}`);
-        i += 2;
-      } else {
-        out.push(`User: ${userText}`);
-        i++;
-      }
-    } else {
-      i++;
-    }
-  }
-  return out.join("\n");
-}
-
-// src/plugins/context/history/history-provider.ts
-var EMPTY_RESULT = {
-  markdown: "",
-  tokenEstimate: 0,
-  sessionCount: 0,
-  totalTurns: 0,
-  mode: "full",
-  truncated: false,
-  timeRange: { start: "", end: "" }
-};
-var HistoryProvider = class {
-  constructor(store, getSessionRecords) {
-    this.store = store;
-    this.getSessionRecords = getSessionRecords;
-  }
-  name = "local";
-  async isAvailable(_repoPath) {
-    return true;
-  }
-  async listSessions(query) {
-    if (!this.isSupportedType(query.type)) {
-      return { sessions: [], estimatedTokens: 0 };
-    }
-    const candidates = await this.resolveCandidates(query);
-    const sessions = [];
-    let estimatedTokens = 0;
-    for (const record of candidates) {
-      const history = await this.store.read(record.sessionId);
-      if (!history) continue;
-      const turnCount = history.turns.length;
-      const tokenEstimate = turnCount * TOKENS_PER_TURN_ESTIMATE;
-      sessions.push(this.toSessionInfo(record, turnCount));
-      estimatedTokens += tokenEstimate;
-    }
-    return { sessions, estimatedTokens };
-  }
-  async buildContext(query, options) {
-    if (!this.isSupportedType(query.type)) {
-      return { ...EMPTY_RESULT };
-    }
-    const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
-    const candidates = await this.resolveCandidates(query, options?.limit);
-    const loaded = [];
-    for (const record of candidates) {
-      const history = await this.store.read(record.sessionId);
-      if (history) {
-        loaded.push({ record, history });
-      }
-    }
-    if (loaded.length === 0) {
-      return { ...EMPTY_RESULT };
-    }
-    const totalTurns = loaded.reduce((sum, s) => sum + s.history.turns.length, 0);
-    const labelAgent = options?.labelAgent ?? false;
-    let mode = selectLevel(totalTurns);
-    let markdown = this.buildMergedMarkdown(loaded, mode, query, labelAgent);
-    let tokenEstimate = estimateTokens(markdown);
-    if (tokenEstimate > maxTokens && mode !== "compact") {
-      mode = "compact";
-      markdown = this.buildMergedMarkdown(loaded, mode, query, labelAgent);
-      tokenEstimate = estimateTokens(markdown);
-    }
-    let truncated = false;
-    let activeSessions = [...loaded];
-    while (tokenEstimate > maxTokens && activeSessions.length > 1) {
-      activeSessions = activeSessions.slice(0, activeSessions.length - 1);
-      markdown = this.buildMergedMarkdown(activeSessions, mode, query, labelAgent);
-      tokenEstimate = estimateTokens(markdown);
-      truncated = true;
-    }
-    const timeRange = this.computeTimeRange(activeSessions.map((s) => s.record));
-    return {
-      markdown,
-      tokenEstimate,
-      sessionCount: activeSessions.length,
-      totalTurns: activeSessions.reduce((sum, s) => sum + s.history.turns.length, 0),
-      mode,
-      truncated,
-      timeRange
-    };
-  }
-  // ─── Private helpers ─────────────────────────────────────────────────────────
-  isSupportedType(type) {
-    return type === "session" || type === "latest";
-  }
-  async resolveCandidates(query, limit) {
-    const all = this.getSessionRecords();
-    if (query.type === "session") {
-      const found = all.find((r) => r.sessionId === query.value);
-      return found ? [found] : [];
-    }
-    const n = limit ?? (parseInt(query.value, 10) || 5);
-    const sorted = [...all].sort(
-      (a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime()
-    );
-    return sorted.slice(0, n);
-  }
-  toSessionInfo(record, turnCount) {
-    return {
-      checkpointId: "",
-      sessionIndex: "",
-      transcriptPath: "",
-      createdAt: record.createdAt,
-      endedAt: record.lastActiveAt,
-      branch: "",
-      agent: record.agentName,
-      turnCount,
-      filesTouched: [],
-      sessionId: record.sessionId
-    };
-  }
-  buildMergedMarkdown(sessions, mode, query, labelAgent = false) {
-    if (sessions.length === 0) return "";
-    const totalTurns = sessions.reduce((sum, s) => sum + s.history.turns.length, 0);
-    const title = query.type === "session" ? query.value : `latest ${sessions.length} sessions`;
-    const parts = [];
-    parts.push(`# Conversation History \u2014 ${title}`);
-    parts.push(`${sessions.length} sessions | ${totalTurns} turns | mode: ${mode}`);
-    parts.push("");
-    for (let i = 0; i < sessions.length; i++) {
-      const { record, history } = sessions[i];
-      parts.push(`## Session ${i + 1} \u2014 ${record.agentName} \xB7 ${record.sessionId} (${history.turns.length} turns)`);
-      parts.push("");
-      if (labelAgent && history.turns.length > 0) {
-        const agentTimeline = this.buildAgentTimeline(record);
-        const labeledMd = this.buildLabeledHistoryMarkdown(history.turns, mode, agentTimeline);
-        if (labeledMd) {
-          parts.push(labeledMd);
-        }
-      } else {
-        const sessionMd = buildHistoryMarkdown(history.turns, mode);
-        if (sessionMd) {
-          parts.push(sessionMd);
-        }
-      }
-    }
-    parts.push(
-      "> **Note:** This conversation history may contain outdated information. Verify current state before acting on past context."
-    );
-    return parts.join("\n");
-  }
-  /**
-   * Build a timeline of agent boundaries from the session record.
-   * Returns sorted entries: [{ agentName, startedAt }] where startedAt is the
-   * ISO timestamp when that agent started handling the session.
-   *
-   * The first agent runs from session creation until the first switch.
-   * Each agentSwitchHistory entry records when the *previous* agent was switched away,
-   * so the next agent starts at that switchedAt timestamp.
-   */
-  buildAgentTimeline(record) {
-    const timeline = [];
-    const firstAgentName = record.firstAgent ?? record.agentName;
-    timeline.push({ agentName: firstAgentName, switchedAt: 0 });
-    if (record.agentSwitchHistory && record.agentSwitchHistory.length > 0) {
-      for (let i = 0; i < record.agentSwitchHistory.length; i++) {
-        const entry = record.agentSwitchHistory[i];
-        const switchTime = new Date(entry.switchedAt).getTime();
-        const nextAgent = i < record.agentSwitchHistory.length - 1 ? record.agentSwitchHistory[i + 1].agentName : record.agentName;
-        timeline.push({ agentName: nextAgent, switchedAt: switchTime });
-      }
-    }
-    return timeline;
-  }
-  /**
-   * Determine which agent produced a turn based on its timestamp and the agent timeline.
-   */
-  resolveAgentForTurn(turnTimestamp, timeline) {
-    const turnTime = new Date(turnTimestamp).getTime();
-    for (let i = timeline.length - 1; i >= 0; i--) {
-      if (turnTime >= timeline[i].switchedAt) {
-        return timeline[i].agentName;
-      }
-    }
-    return timeline[0].agentName;
-  }
-  /**
-   * Build history markdown with agent labels inserted at agent boundaries.
-   */
-  buildLabeledHistoryMarkdown(turns, mode, agentTimeline) {
-    if (agentTimeline.length <= 1) {
-      const label = `### [${agentTimeline[0]?.agentName ?? "unknown"}]
-`;
-      const md = buildHistoryMarkdown(turns, mode);
-      return md ? label + "\n" + md : label;
-    }
-    const segments = [];
-    let currentAgent = "";
-    for (const turn of turns) {
-      const agent = this.resolveAgentForTurn(turn.timestamp, agentTimeline);
-      if (agent !== currentAgent) {
-        segments.push({ agentName: agent, turns: [] });
-        currentAgent = agent;
-      }
-      segments[segments.length - 1].turns.push(turn);
-    }
-    const parts = [];
-    for (const segment of segments) {
-      parts.push(`### [${segment.agentName}]`);
-      parts.push("");
-      const md = buildHistoryMarkdown(segment.turns, mode);
-      if (md) {
-        parts.push(md);
-      }
-    }
-    return parts.join("\n");
-  }
-  computeTimeRange(records) {
-    if (records.length === 0) return { start: "", end: "" };
-    const dates = records.map((r) => r.createdAt).filter(Boolean);
-    const ends = records.map((r) => r.lastActiveAt).filter(Boolean);
-    const start = dates.sort()[0] ?? "";
-    const end = ends.sort().reverse()[0] ?? "";
-    return { start, end };
-  }
-};
-
-// src/plugins/context/history/history-recorder.ts
-function toHistoryAttachment(att) {
-  return {
-    type: att.type,
-    fileName: att.fileName,
-    mimeType: att.mimeType,
-    size: att.size
-  };
-}
-function extractDiff(content) {
-  if (!Array.isArray(content)) return null;
-  for (const item of content) {
-    if (item && typeof item === "object" && item.type === "diff") {
-      const d = item;
-      if (typeof d.path === "string" && typeof d.newText === "string") {
-        const result = {
-          path: d.path,
-          newText: d.newText
-        };
-        if (typeof d.oldText === "string") result.oldText = d.oldText;
-        return result;
-      }
-    }
-  }
-  return null;
-}
-function extractLocations(locations) {
-  if (!Array.isArray(locations)) return void 0;
-  const result = [];
-  for (const loc of locations) {
-    if (loc && typeof loc === "object" && typeof loc.path === "string") {
-      const entry = { path: loc.path };
-      if (typeof loc.line === "number") entry.line = loc.line;
-      result.push(entry);
-    }
-  }
-  return result.length > 0 ? result : void 0;
-}
-var IGNORED_TYPES = /* @__PURE__ */ new Set([
-  "session_end",
-  "error",
-  "system_message",
-  "commands_update",
-  "session_info_update",
-  "model_update",
-  "user_message_chunk",
-  "tts_strip"
-]);
-var HistoryRecorder = class {
-  constructor(store) {
-    this.store = store;
-  }
-  states = /* @__PURE__ */ new Map();
-  onBeforePrompt(sessionId, text, attachments) {
-    let state = this.states.get(sessionId);
-    if (!state) {
-      state = {
-        history: { version: 1, sessionId, turns: [] },
-        currentAssistantTurn: null
-      };
-      this.states.set(sessionId, state);
-    }
-    const userTurn = {
-      index: state.history.turns.length,
-      role: "user",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      content: text
-    };
-    if (attachments && attachments.length > 0) {
-      userTurn.attachments = attachments.map(toHistoryAttachment);
-    }
-    state.history.turns.push(userTurn);
-    const assistantTurn = {
-      index: state.history.turns.length,
-      role: "assistant",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      steps: []
-    };
-    state.history.turns.push(assistantTurn);
-    state.currentAssistantTurn = assistantTurn;
-  }
-  onAfterEvent(sessionId, event) {
-    const state = this.states.get(sessionId);
-    if (!state || !state.currentAssistantTurn) return;
-    const turn = state.currentAssistantTurn;
-    const steps = turn.steps;
-    if (IGNORED_TYPES.has(event.type)) return;
-    switch (event.type) {
-      case "text": {
-        const last = steps[steps.length - 1];
-        if (last && last.type === "text") {
-          last.content += event.content;
-        } else {
-          steps.push({ type: "text", content: event.content });
-        }
-        break;
-      }
-      case "thought": {
-        const last = steps[steps.length - 1];
-        if (last && last.type === "thinking") {
-          last.content += event.content;
-        } else {
-          steps.push({ type: "thinking", content: event.content });
-        }
-        break;
-      }
-      case "tool_call": {
-        const step = {
-          type: "tool_call",
-          id: event.id,
-          name: event.name,
-          status: event.status
-        };
-        if (event.kind) step.kind = event.kind;
-        steps.push(step);
-        break;
-      }
-      case "tool_update": {
-        const existing = this.findToolCall(steps, event.id);
-        if (!existing) break;
-        existing.status = event.status;
-        if (event.rawInput !== void 0) existing.input = event.rawInput;
-        if (event.rawOutput !== void 0) existing.output = event.rawOutput;
-        if (event.content !== void 0) {
-          const diff = extractDiff(event.content);
-          if (diff) existing.diff = diff;
-        }
-        if (event.locations !== void 0) {
-          const locs = extractLocations(event.locations);
-          if (locs) existing.locations = locs;
-        }
-        break;
-      }
-      case "plan": {
-        steps.push({
-          type: "plan",
-          entries: event.entries.map((e) => ({
-            content: e.content,
-            priority: e.priority,
-            status: e.status
-          }))
-        });
-        break;
-      }
-      case "usage": {
-        turn.usage = {};
-        if (event.tokensUsed !== void 0) turn.usage.tokensUsed = event.tokensUsed;
-        if (event.contextSize !== void 0) turn.usage.contextSize = event.contextSize;
-        if (event.cost) turn.usage.cost = event.cost;
-        break;
-      }
-      case "image_content": {
-        steps.push({
-          type: "image",
-          mimeType: event.mimeType,
-          filePath: ""
-        });
-        break;
-      }
-      case "audio_content": {
-        steps.push({
-          type: "audio",
-          mimeType: event.mimeType,
-          filePath: ""
-        });
-        break;
-      }
-      case "resource_content": {
-        const step = {
-          type: "resource",
-          uri: event.uri,
-          name: event.name
-        };
-        if (event.text !== void 0) step.text = event.text;
-        steps.push(step);
-        break;
-      }
-      case "resource_link": {
-        const step = {
-          type: "resource_link",
-          uri: event.uri,
-          name: event.name
-        };
-        if (event.title !== void 0) step.title = event.title;
-        if (event.description !== void 0)
-          step.description = event.description;
-        steps.push(step);
-        break;
-      }
-      case "current_mode_update": {
-        steps.push({ type: "mode_change", modeId: event.modeId });
-        break;
-      }
-      case "config_option_update": {
-        for (const opt of event.options) {
-          steps.push({
-            type: "config_change",
-            configId: opt.id,
-            value: String(opt.currentValue)
-          });
-        }
-        break;
-      }
-    }
-  }
-  onPermissionResolved(sessionId, requestId, decision) {
-    const state = this.states.get(sessionId);
-    if (!state || !state.currentAssistantTurn) return;
-    const step = this.findToolCall(state.currentAssistantTurn.steps, requestId);
-    if (!step) return;
-    step.permission = { requested: true, outcome: decision };
-  }
-  async onTurnEnd(sessionId, stopReason) {
-    const state = this.states.get(sessionId);
-    if (!state || !state.currentAssistantTurn) return;
-    state.currentAssistantTurn.stopReason = stopReason;
-    state.currentAssistantTurn = null;
-    await this.store.write(state.history);
-  }
-  finalize(sessionId) {
-    this.states.delete(sessionId);
-  }
-  getState(sessionId) {
-    return this.states.get(sessionId);
-  }
-  findToolCall(steps, id) {
-    for (let i = steps.length - 1; i >= 0; i--) {
-      const s = steps[i];
-      if (s.type === "tool_call" && s.id === id) return s;
-    }
-    return void 0;
-  }
-};
-
-// src/plugins/context/history/history-store.ts
-import fs from "fs";
-import path from "path";
-var HistoryStore = class {
-  constructor(dir) {
-    this.dir = dir;
-  }
-  async write(history) {
-    await fs.promises.mkdir(this.dir, { recursive: true });
-    const filePath = this.filePath(history.sessionId);
-    await fs.promises.writeFile(filePath, JSON.stringify(history, null, 2));
-  }
-  async read(sessionId) {
-    const filePath = this.filePath(sessionId);
-    try {
-      const raw = await fs.promises.readFile(filePath, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-      return null;
-    }
-  }
-  async exists(sessionId) {
-    try {
-      await fs.promises.access(this.filePath(sessionId));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async list() {
-    try {
-      const files = await fs.promises.readdir(this.dir);
-      return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
-    } catch {
-      return [];
-    }
-  }
-  async delete(sessionId) {
-    try {
-      await fs.promises.unlink(this.filePath(sessionId));
-    } catch {
-    }
-  }
-  filePath(sessionId) {
-    return path.join(this.dir, `${sessionId}.json`);
-  }
-};
-
-// src/plugins/context/index.ts
-var contextPlugin = {
-  name: "@openacp/context",
-  version: "1.0.0",
-  description: "Conversation context management with pluggable providers",
-  essential: false,
-  permissions: ["services:register", "middleware:register", "kernel:access"],
-  async install(ctx) {
-    const { settings, terminal } = ctx;
-    await settings.setAll({ enabled: true });
-    terminal.log.success("Context defaults saved");
-  },
-  async configure(ctx) {
-    const { terminal, settings } = ctx;
-    const current = await settings.getAll();
-    const toggle = await terminal.confirm({
-      message: `Context service is ${current.enabled !== false ? "enabled" : "disabled"}. Toggle?`,
-      initialValue: false
-    });
-    if (toggle) {
-      const newState = current.enabled === false;
-      await settings.set("enabled", newState);
-      terminal.log.success(`Context service ${newState ? "enabled" : "disabled"}`);
-    }
-  },
-  async uninstall(ctx, opts) {
-    if (opts.purge) {
-      await ctx.settings.clear();
-      ctx.terminal.log.success("Context settings cleared");
-    }
-  },
-  async setup(ctx) {
-    const historyDir = path2.join(ctx.instanceRoot, "history");
-    const store = new HistoryStore(historyDir);
-    const recorder = new HistoryRecorder(store);
-    const sessionManager = ctx.sessions;
-    const getRecords = () => sessionManager.listRecords();
-    const cachePath = path2.join(ctx.instanceRoot, "cache", "entire");
-    const manager = new ContextManager(cachePath);
-    manager.register(new HistoryProvider(store, getRecords));
-    manager.register(new EntireProvider());
-    ctx.registerService("context", manager);
-    ctx.registerMiddleware("agent:beforePrompt", {
-      priority: 200,
-      handler: async (payload, next) => {
-        recorder.onBeforePrompt(payload.sessionId, payload.text, payload.attachments);
-        return next();
-      }
-    });
-    ctx.registerMiddleware("agent:afterEvent", {
-      priority: 200,
-      handler: async (payload, next) => {
-        recorder.onAfterEvent(payload.sessionId, payload.event);
-        return next();
-      }
-    });
-    ctx.registerMiddleware("turn:end", {
-      priority: 200,
-      handler: async (payload, next) => {
-        await recorder.onTurnEnd(payload.sessionId, payload.stopReason);
-        return next();
-      }
-    });
-    ctx.registerMiddleware("permission:afterResolve", {
-      priority: 200,
-      handler: async (payload, next) => {
-        recorder.onPermissionResolved(payload.sessionId, payload.requestId, payload.decision);
-        return next();
-      }
-    });
-    ctx.registerMiddleware("session:afterDestroy", {
-      priority: 200,
-      handler: async (payload, next) => {
-        recorder.finalize(payload.sessionId);
-        return next();
-      }
-    });
-    ctx.log.info("Context service ready (local history + entire providers)");
-  }
-};
-var context_default = contextPlugin;
-
-export {
-  context_default
-};
-//# sourceMappingURL=chunk-FPKQYCQS.js.map