@tarquinen/opencode-dcp 3.1.12 → 3.1.14

package/README.md

@@ -17,6 +17,17 @@ opencode plugin @tarquinen/opencode-dcp@latest --global
 
 This installs the package and adds it to your global OpenCode config.
 
+## Project Status
+
+Development on DCP has slowed because most new context-management work has moved to [Sleev](https://sleev.ai) and the `sleev` CLI. Sleev is a local proxy for Claude Code, Codex, and OpenCode that builds on DCP's core ideas with newer context-management features and will work with any harness/client.
+
+DCP remains available for OpenCode plugin users, but new features are landing in Sleev first. If you are starting fresh, we recommend trying Sleev:
+
+```bash
+npm i -g sleev
+sleev
+```
+
 ## How It Works
 
 DCP reduces context size through a compress tool and automatic cleanup. Your session history is never modified — DCP replaces pruned content with placeholders before sending requests to your LLM.
@@ -176,16 +187,10 @@ Each level overrides the previous, so project settings take priority over global
 
 ### Commands
 
-DCP provides a `/dcp` slash command:
+DCP provides a TUI panel and one prompt-producing slash command:
 
-- `/dcp` — Shows available DCP commands
-- `/dcp context` — Shows a breakdown of your current session's token usage by category (system, user, assistant, tools, etc.) and how much has been saved through pruning.
-- `/dcp stats` — Shows cumulative pruning statistics across all sessions.
-- `/dcp sweep` — Prunes all tools since the last user message. Accepts an optional count: `/dcp sweep 10` prunes the last 10 tools. Respects `commands.protectedTools`.
-- `/dcp manual [on|off]` — Toggle manual mode or set explicit state. When on, the AI will not autonomously use context management tools.
-- `/dcp compress [focus]` — Trigger a single compress tool execution. Optional focus text directs what content to compress, following the active `compress.mode`.
-- `/dcp decompress <n>` — Restore a specific active compression by ID (for example `/dcp decompress 2`). Running without an argument shows available compression IDs, token sizes, and topics.
-- `/dcp recompress <n>` — Re-apply a user-decompressed compression by ID (for example `/dcp recompress 2`). Running without an argument shows recompressible IDs, token sizes, and topics.
+- `/dcp` — Opens the DCP panel with context, stats, and manual-mode controls.
+- `/dcp-compress [focus]` — Asks the model to run one compression pass. Optional focus text directs what content to compress, following the active `compress.mode`.
 
 ### Prompt Overrides
 

package/dist/index.js

@@ -2387,6 +2387,8 @@ var SoftIssue = class extends Error {
     this.kind = kind;
     this.messageId = messageId;
   }
+  kind;
+  messageId;
 };
 function validateArgs(args) {
   if (typeof args.topic !== "string" || args.topic.trim().length === 0) {
@@ -2851,6 +2853,7 @@ async function saveSessionState(sessionState, logger, sessionName) {
     }
     const state = {
       sessionName,
+      manualMode: !!sessionState.manualMode,
       prune: {
         tools: Object.fromEntries(sessionState.prune.tools),
         messages: serializePruneMessagesState(sessionState.prune.messages)
@@ -2939,6 +2942,43 @@ async function loadSessionState(sessionId, logger) {
     return null;
   }
 }
+function emptyPersistedState(manualMode) {
+  return {
+    manualMode,
+    prune: {
+      tools: {},
+      messages: {
+        byMessageId: {},
+        blocksById: {},
+        activeBlockIds: [],
+        activeByAnchorMessageId: {},
+        nextBlockId: 1,
+        nextRunId: 1
+      }
+    },
+    nudges: {
+      contextLimitAnchors: [],
+      turnNudgeAnchors: [],
+      iterationNudgeAnchors: []
+    },
+    stats: {
+      pruneTokenCounter: 0,
+      totalPruneTokens: 0
+    },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function loadManualModeSetting(sessionId, logger) {
+  const state = await loadSessionState(sessionId, logger);
+  return typeof state?.manualMode === "boolean" ? state.manualMode : void 0;
+}
+async function saveManualModeSetting(sessionId, manualMode, logger) {
+  const existing = await loadSessionState(sessionId, logger);
+  const state = existing ?? emptyPersistedState(manualMode);
+  state.manualMode = manualMode;
+  state.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await writePersistedSessionState(sessionId, state, logger);
+}
 async function loadAllSessionStats(logger) {
   const result = {
     totalTokens: 0,
@@ -3047,6 +3087,7 @@ var checkSession = async (client, state, logger, messages, manualModeDefault) =>
     });
   }
   state.currentTurn = countTurns(state, messages);
+  await refreshManualMode(state, lastSessionId, logger, manualModeDefault);
 };
 function createSessionState() {
   return {
@@ -3134,6 +3175,9 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   if (persisted === null) {
     return;
   }
+  if (typeof persisted.manualMode === "boolean") {
+    state.manualMode = persisted.manualMode ? "active" : false;
+  }
   state.prune.tools = loadPruneMap(persisted.prune.tools);
   state.prune.messages = loadPruneMessagesState(persisted.prune.messages);
   state.nudges.contextLimitAnchors = new Set(persisted.nudges.contextLimitAnchors || []);
@@ -3153,6 +3197,14 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
     await saveSessionState(state, logger);
   }
 }
+async function refreshManualMode(state, sessionId, logger, manualModeDefault) {
+  if (state.manualMode === "compress-pending") {
+    return;
+  }
+  const persisted = await loadManualModeSetting(sessionId, logger);
+  const enabled = persisted ?? manualModeDefault;
+  state.manualMode = enabled ? "active" : false;
+}
 
 // lib/state/tool-cache.ts
 var MAX_TOOL_CACHE_SIZE = 1e3;
@@ -3866,6 +3918,7 @@ async function sendIgnoredMessage(client, sessionID, text, params, logger) {
 
 // lib/compress/pipeline.ts
 async function prepareSession(ctx, toolCtx, title) {
+  await refreshManualMode(ctx.state, toolCtx.sessionID, ctx.logger, ctx.config.manualMode.enabled);
   if (ctx.state.manualMode && ctx.state.manualMode !== "compress-pending") {
     throw new Error(
       "Manual mode: compress blocked. Do not retry until `<compress triggered manually>` appears in user context."
@@ -6341,7 +6394,7 @@ function renderSystemPrompt(prompts, protectedToolsExtension, manual, subagent)
 }
 
 // lib/commands/context.ts
-function analyzeTokens(state, messages) {
+function analyzeContextTokens(state, messages) {
   const breakdown = {
     system: 0,
     user: 0,
@@ -6520,7 +6573,7 @@ function formatContextMessage(breakdown) {
 }
 async function handleContextCommand(ctx) {
   const { client, state, logger, sessionId, messages } = ctx;
-  const breakdown = analyzeTokens(state, messages);
+  const breakdown = analyzeContextTokens(state, messages);
   const message = formatContextMessage(breakdown);
   const params = getCurrentParams(state, messages, logger);
   await sendIgnoredMessage(client, sessionId, message, params, logger);
@@ -6824,23 +6877,20 @@ async function handleDecompressCommand(ctx) {
 }
 
 // lib/commands/help.ts
-var BASE_COMMANDS = [
-  ["/dcp context", "Show token usage breakdown for current session"],
-  ["/dcp stats", "Show DCP pruning statistics"],
-  ["/dcp sweep [n]", "Prune tools since last user message, or last n tools"],
-  ["/dcp manual [on|off]", "Toggle manual mode or set explicit state"]
+var TUI_COMMANDS = [
+  ["DCP Context", "Show token usage breakdown for current session"],
+  ["DCP Stats", "Show DCP pruning statistics"],
+  ["DCP Help", "Show this help in a modal"]
 ];
 var TOOL_COMMANDS = {
-  compress: ["/dcp compress [focus]", "Trigger manual compress tool execution"],
+  compress: ["/dcp-compress [focus]", "Trigger manual compress tool execution"],
   decompress: ["/dcp decompress <n>", "Restore selected compression"],
   recompress: ["/dcp recompress <n>", "Re-apply a user-decompressed compression"]
 };
 function getVisibleCommands(state, config) {
-  const commands = [...BASE_COMMANDS];
+  const commands = [...TUI_COMMANDS];
   if (compressPermission(state, config) !== "deny") {
     commands.push(TOOL_COMMANDS.compress);
-    commands.push(TOOL_COMMANDS.decompress);
-    commands.push(TOOL_COMMANDS.recompress);
   }
   return commands;
 }
@@ -6854,6 +6904,9 @@ function formatHelpMessage(state, config) {
   lines.push("");
   lines.push(`  ${"Manual mode:".padEnd(colWidth)}${state.manualMode ? "ON" : "OFF"}`);
   lines.push("");
+  lines.push("  Open the command palette for DCP modal commands.");
+  lines.push("  Use /dcp-compress [focus] when you want DCP to ask the model to run compression.");
+  lines.push("");
   for (const [cmd, desc] of commands) {
     lines.push(`  ${cmd.padEnd(colWidth)}${desc}`);
   }
@@ -6870,7 +6923,7 @@ async function handleHelpCommand(ctx) {
 }
 
 // lib/commands/manual.ts
-var MANUAL_MODE_ON = "Manual mode is now ON. Use /dcp compress to trigger context tools manually.";
+var MANUAL_MODE_ON = "Manual mode is now ON. Use /dcp-compress to trigger context tools manually.";
 var MANUAL_MODE_OFF = "Manual mode is now OFF.";
 var COMPRESS_TRIGGER_PROMPT = [
   "<compress triggered manually>",
@@ -6906,6 +6959,7 @@ async function handleManualToggleCommand(ctx, modeArg) {
     params,
     logger
   );
+  await saveManualModeSetting(sessionId, !!state.manualMode, logger);
   logger.info("Manual mode toggled", { manualMode: state.manualMode });
 }
 async function handleManualTriggerCommand(ctx, tool3, userFocus) {
@@ -7154,6 +7208,29 @@ function formatCompressionTime(ms) {
 }
 async function handleStatsCommand(ctx) {
   const { client, state, logger, sessionId, messages } = ctx;
+  const report = await buildStatsReport(state, logger);
+  const message = formatStatsMessage(
+    report.sessionTokens,
+    report.sessionSummaryTokens,
+    report.sessionTools,
+    report.sessionMessages,
+    report.sessionDurationMs,
+    report.allTime
+  );
+  const params = getCurrentParams(state, messages, logger);
+  await sendIgnoredMessage(client, sessionId, message, params, logger);
+  logger.info("Stats command executed", {
+    sessionTokens: report.sessionTokens,
+    sessionSummaryTokens: report.sessionSummaryTokens,
+    sessionTools: report.sessionTools,
+    sessionMessages: report.sessionMessages,
+    sessionDurationMs: report.sessionDurationMs,
+    allTimeTokens: report.allTime.totalTokens,
+    allTimeTools: report.allTime.totalTools,
+    allTimeMessages: report.allTime.totalMessages
+  });
+}
+async function buildStatsReport(state, logger) {
   const sessionTokens = state.stats.totalPruneTokens;
   const sessionSummaryTokens = Array.from(state.prune.messages.blocksById.values()).reduce(
     (total, block) => block.active ? total + block.summaryTokens : total,
@@ -7179,26 +7256,14 @@ async function handleStatsCommand(ctx) {
     }
   }
   const allTime = await loadAllSessionStats(logger);
-  const message = formatStatsMessage(
+  return {
     sessionTokens,
     sessionSummaryTokens,
     sessionTools,
     sessionMessages,
     sessionDurationMs,
     allTime
-  );
-  const params = getCurrentParams(state, messages, logger);
-  await sendIgnoredMessage(client, sessionId, message, params, logger);
-  logger.info("Stats command executed", {
-    sessionTokens,
-    sessionSummaryTokens,
-    sessionTools,
-    sessionMessages,
-    sessionDurationMs,
-    allTimeTokens: allTime.totalTokens,
-    allTimeTools: allTime.totalTools,
-    allTimeMessages: allTime.totalMessages
-  });
+  };
 }
 
 // lib/commands/sweep.ts
@@ -7478,7 +7543,7 @@ function createCommandExecuteHandler(client, state, logger, config, workingDirec
     if (!config.commands.enabled) {
       return;
     }
-    if (input.command === "dcp") {
+    if (input.command === "dcp" || input.command === "dcp-compress") {
       const messagesResponse = await client.session.messages({
         path: { id: input.sessionID }
       });
@@ -7497,8 +7562,9 @@ function createCommandExecuteHandler(client, state, logger, config, workingDirec
         return;
       }
       const args = (input.arguments || "").trim().split(/\s+/).filter(Boolean);
-      const subcommand = args[0]?.toLowerCase() || "";
-      const subArgs = args.slice(1);
+      const isCompressCommand = input.command === "dcp-compress";
+      const subcommand = isCompressCommand ? "compress" : args[0]?.toLowerCase() || "";
+      const subArgs = isCompressCommand ? args : args.slice(1);
       const commandCtx = {
         client,
         state,
@@ -7509,11 +7575,11 @@ function createCommandExecuteHandler(client, state, logger, config, workingDirec
       };
       if (subcommand === "context") {
         await handleContextCommand(commandCtx);
-        throw new Error("__DCP_CONTEXT_HANDLED__");
+        return;
       }
       if (subcommand === "stats") {
         await handleStatsCommand(commandCtx);
-        throw new Error("__DCP_STATS_HANDLED__");
+        return;
       }
       if (subcommand === "sweep") {
         await handleSweepCommand({
@@ -7521,11 +7587,11 @@ function createCommandExecuteHandler(client, state, logger, config, workingDirec
           args: subArgs,
           workingDirectory
         });
-        throw new Error("__DCP_SWEEP_HANDLED__");
+        return;
       }
       if (subcommand === "manual") {
         await handleManualToggleCommand(commandCtx, subArgs[0]?.toLowerCase());
-        throw new Error("__DCP_MANUAL_HANDLED__");
+        return;
       }
       if (subcommand === "compress") {
         const userFocus = subArgs.join(" ").trim();
@@ -7542,7 +7608,7 @@ function createCommandExecuteHandler(client, state, logger, config, workingDirec
         output.parts.length = 0;
         output.parts.push({
           type: "text",
-          text: rawArgs ? `/dcp ${rawArgs}` : `/dcp ${subcommand}`
+          text: isCompressCommand ? rawArgs ? `/dcp-compress ${rawArgs}` : "/dcp-compress" : rawArgs ? `/dcp ${rawArgs}` : `/dcp ${subcommand}`
         });
         return;
       }
@@ -7551,17 +7617,17 @@ function createCommandExecuteHandler(client, state, logger, config, workingDirec
           ...commandCtx,
           args: subArgs
         });
-        throw new Error("__DCP_DECOMPRESS_HANDLED__");
+        return;
       }
       if (subcommand === "recompress") {
         await handleRecompressCommand({
           ...commandCtx,
           args: subArgs
         });
-        throw new Error("__DCP_RECOMPRESS_HANDLED__");
+        return;
       }
       await handleHelpCommand(commandCtx);
-      throw new Error("__DCP_HELP_HANDLED__");
+      return;
     }
   };
 }
@@ -7872,9 +7938,9 @@ var server = (async (ctx) => {
       }
       if (config.commands.enabled && config.compress.permission !== "deny") {
         opencodeConfig.command ??= {};
-        opencodeConfig.command["dcp"] = {
+        opencodeConfig.command["dcp-compress"] = {
           template: "",
-          description: "Show available DCP commands"
+          description: "Trigger DCP manual compression with: /dcp-compress [focus]"
         };
       }
       const toolsToAdd = [];