@duckmind/dm-windows-x64 0.63.4 → 0.63.9

package/extensions/dm-context/src/index.js

@@ -1,9 +1,36 @@
-import { Type } from "@sinclair/typebox";
+import {
+  Type
+} from "@duckmind/dm-ai";
 import { formatTokens } from "./utils.js";
-const InternalTools = ["context_tag", "context_log", "context_checkout"];
+const InternalTools = ["context_checkpoint", "context_timeline", "context_compact"];
+const DmContextCustomMessageType = "dm-context";
+const AcmEnableFollowUp = "Agentic context management is now enabled";
 let CommandCtx = null;
-let CheckoutParams = null;
+let CompactParams = null;
 const isInternal = (name) => InternalTools.includes(name);
+const formatContextUsage = (usage, includeTokens = false) => {
+  if (usage?.percent == null)
+    return "Unknown";
+  const percent = `${usage.percent.toFixed(1)}%`;
+  if (!includeTokens || usage.tokens == null)
+    return percent;
+  return `${percent} (${formatTokens(usage.tokens)}/${formatTokens(usage.contextWindow)})`;
+};
+const PassiveCompactionEntryTypes = new Set([
+  "custom",
+  "label",
+  "session_info",
+  "model_change",
+  "thinking_level_change"
+]);
+export const didConversationAdvance = (branch, compactTurnLeaf) => {
+  if (!compactTurnLeaf)
+    return true;
+  const compactTurnIndex = branch.findIndex((entry) => entry.id === compactTurnLeaf);
+  if (compactTurnIndex === -1)
+    return true;
+  return branch.slice(compactTurnIndex + 1).some((entry) => !PassiveCompactionEntryTypes.has(entry.type));
+};
 const resolveTargetId = (sm, target) => {
   if (target.toLowerCase() === "root") {
     const tree = sm.getTree();
@@ -21,18 +48,21 @@ const resolveTargetId = (sm, target) => {
   }
   return target;
 };
-const ContextLogParams = Type.Object({
-  limit: Type.Optional(Type.Number({ description: "History limit for visible entries (default: 50)." })),
-  verbose: Type.Optional(Type.Boolean({ description: "If true, show ALL messages. If false (default), collapses intermediate AI steps and only shows 'milestones': User messages, Tags, Branch Points, and Summaries." }))
+const ContextTimelineDescription = "Inspect the active conversation path as a structural map: checkpoints, summaries/compactions, branch points, user turns, and current position. Use when orientation or compact target selection depends on the shape of history.";
+const ContextTimelineParams = Type.Object({
+  limit: Type.Optional(Type.Number({ description: "Maximum visible timeline entries (default: 50)." })),
+  verbose: Type.Optional(Type.Boolean({ description: "If true, show all messages including internal context-tool traffic. If false (default), collapse to structural milestones." }))
 });
-const ContextCheckoutParams = Type.Object({
-  target: Type.String({ description: "Where to jump/squash to. Can be a tag name (e.g., 'task-start'), a commit ID, or 'root'. This is the base for your new branch." }),
-  message: Type.String({ description: "The 'Carryover Message' for the new branch. A summary of your *current* progress/lessons that you want to bring with you to the new state. This ensures you don't lose key information when switching contexts. Good summary message: '[Status] + [Reason] + [Important Changes] + [Carryover Data]'" }),
-  backupTag: Type.Optional(Type.String({ description: "Optional tag name to apply to the CURRENT state before checking out. Use this to create an automatic backup of the history you are about to leave/squash." }))
+const ContextCompactDescription = "Create a summarized continuation branch from an earlier checkpoint or history node. The selected target is the branch point; the summary must restore the useful state from the compacted path after that target. This changes conversation history only; it does not modify or roll back disk files or external systems.";
+const ContextCompactParams = Type.Object({
+  target: Type.String({ description: "Checkpoint name, history node ID, or root to use as the branch point for the summarized continuation." }),
+  summary: Type.String({ description: "Handoff summary injected into the new continuation branch. Restore current task/state, decisions/constraints, important external side effects (changed files, processes, browser/tickets/remote state), validation status, source anchors/evidence/open questions likely needed soon, and explicit next step. Do not rely on backupCheckpoint for details needed in the next phase." }),
+  backupCheckpoint: Type.Optional(Type.String({ description: "Optional checkpoint name to label the current conversation state before branching. This is only a recovery pointer; the summary must still contain the state needed to continue." }))
 });
-const ContextTagParams = Type.Object({
-  name: Type.String({ description: "The tag/milestone name. Use meaningful names." }),
-  target: Type.Optional(Type.String({ description: "The commit ID to tag. Defaults to HEAD (current state)." }))
+const ContextCheckpointDescription = "Create a named anchor by labeling a conversation history node. This does not branch, summarize, or affect external state; it only makes the point easy to find later in timeline or compact target selection.";
+const ContextCheckpointParams = Type.Object({
+  name: Type.String({ description: "Unique semantic anchor name that encodes the task and phase/purpose, e.g. parser-fix-start or timeout-investigation-search. Avoid generic names like start, checkpoint-1, or retry." }),
+  target: Type.Optional(Type.String({ description: "Optional history node ID or checkpoint name to label. Defaults to the current meaningful position near the conversation head." }))
 });
 export default function src_default(pi) {
   pi.registerCommand("acm", {
@@ -40,41 +70,38 @@ export default function src_default(pi) {
     handler: async (args, ctx) => {
       CommandCtx = ctx;
       ctx.ui.notify("Agentic Context Management enabled.", "info");
-      pi.sendMessage({
-        customType: "dm-context",
-        content: "use context-management skill",
-        display: false
-      }, {
-        deliverAs: "followUp"
-      });
       if (args) {
-        pi.sendUserMessage(args);
+        pi.sendUserMessage(args, { deliverAs: "followUp" });
       }
     }
   });
-  const findTagInTree = (sm, nodes, tagName) => {
-    for (const n of nodes) {
-      if (sm.getLabel(n.entry.id) === tagName)
+  const findCheckpointInTree = (sm, nodes, checkpointName) => {
+    const stack = [...nodes].reverse();
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (sm.getLabel(n.entry.id) === checkpointName)
         return n.entry.id;
-      const r = findTagInTree(sm, n.children, tagName);
-      if (r)
-        return r;
+      if (n.children?.length) {
+        for (let i = n.children.length - 1;i >= 0; i--) {
+          stack.push(n.children[i]);
+        }
+      }
     }
     return null;
   };
   pi.registerTool({
-    name: "context_tag",
-    label: "Context Tag",
-    description: "Creates a 'Save Point' (Bookmark) in the history. Use this before trying risky changes or when a feature is stable. 'Untagged progress is risky'.",
-    parameters: ContextTagParams,
+    name: "context_checkpoint",
+    label: "Context Checkpoint",
+    description: ContextCheckpointDescription,
+    parameters: ContextCheckpointParams,
     async execute(_id, params, _signal, _onUpdate, ctx) {
       const sm = ctx.sessionManager;
-      const existingTagId = findTagInTree(sm, sm.getTree(), params.name);
-      if (existingTagId) {
+      const existingCheckpointId = findCheckpointInTree(sm, sm.getTree(), params.name);
+      if (existingCheckpointId) {
         return {
           content: [{
             type: "text",
-            text: `Error: Tag '${params.name}' already exists at ${existingTagId}. Tag names must be unique. Use a different name or delete the existing tag first.`
+            text: `Error: Checkpoint '${params.name}' already exists at ${existingCheckpointId}. Checkpoint names must be unique. Use a different name or remove the existing one first.`
           }],
           details: {}
         };
@@ -106,14 +133,20 @@ export default function src_default(pi) {
           id = sm.getLeafId() ?? "";
       }
       pi.setLabel(id, params.name);
-      return { content: [{ type: "text", text: `Created tag '${params.name}' at ${id}` }], details: {} };
+      return {
+        content: [{
+          type: "text",
+          text: `Created checkpoint '${params.name}' at ${id}.`
+        }],
+        details: {}
+      };
     }
   });
   pi.registerTool({
-    name: "context_log",
-    label: "Context Log",
-    description: "Show the entire history structure (status, message, tags, milestones). Analogous to 'git log --graph --oneline --decorate'",
-    parameters: ContextLogParams,
+    name: "context_timeline",
+    label: "Context Timeline",
+    description: ContextTimelineDescription,
+    parameters: ContextTimelineParams,
     async execute(_id, params, _signal, _onUpdate, ctx) {
       const sm = ctx.sessionManager;
       const branch = sm.getBranch();
@@ -137,7 +170,7 @@ export default function src_default(pi) {
           return e.summary || "[No summary provided]";
         }
         if (entry.type === "label") {
-          return `tag: ${entry.label}`;
+          return `checkpoint: ${entry.label}`;
         }
         if (entry.type === "message") {
           const msg = entry.message;
@@ -234,7 +267,7 @@ export default function src_default(pi) {
         }
         const id = entry.id;
         const isRoot = branch.length > 0 && entry.id === branch[0].id;
-        const meta = [isRoot ? "ROOT" : null, isHead ? "HEAD" : null, label ? `tag: ${label}` : null].filter(Boolean).join(", ");
+        const meta = [isRoot ? "ROOT" : null, isHead ? "HEAD" : null, label ? `checkpoint: ${label}` : null].filter(Boolean).join(", ");
         const body = content.length > 100 ? content.slice(0, 100) + "..." : content;
         const marker = isHead ? "*" : role === "USER" ? "•" : "|";
         lines.push(`${marker} ${id}${meta ? ` (${meta})` : ""} [${role}] ${body}`);
@@ -242,26 +275,24 @@ export default function src_default(pi) {
       if (hiddenCount > 0) {
         lines.push(`  :  ... (${hiddenCount} hidden messages) ...`);
       }
-      const usage = await ctx.getContextUsage();
-      let usageStr = "Unknown";
-      if (usage) {
-        usageStr = `${usage.percent.toFixed(1)}% (${formatTokens(usage.tokens)}/${formatTokens(usage.contextWindow)})`;
-      }
-      let stepsSinceTag = 0;
-      let nearestTagName = "None";
+      const usageStr = formatContextUsage(ctx.getContextUsage(), true);
+      let stepsSinceCheckpoint = 0;
+      let nearestCheckpointName = "None";
       for (let i = branch.length - 1;i >= 0; i--) {
         const id = branch[i].id;
         const label = sm.getLabel(id);
         if (label) {
-          nearestTagName = label;
+          nearestCheckpointName = label;
           break;
         }
-        stepsSinceTag++;
+        stepsSinceCheckpoint++;
       }
+      const compactCue = nearestCheckpointName === "None" ? "create a checkpoint before the next noisy phase" : `if this segment has produced a stable result and another phase remains, compact to '${nearestCheckpointName}' with a handoff summary before continuing`;
       const hud = [
         `[Context Dashboard]`,
         `• Context Usage:    ${usageStr}`,
-        `• Segment Size:     ${stepsSinceTag} steps since last tag '${nearestTagName}'`,
+        `• Segment Size:     ${stepsSinceCheckpoint} steps since last checkpoint '${nearestCheckpointName}'`,
+        `• Compact Cue:      ${compactCue}`,
         `---------------------------------------------------`
       ].join(`
 `);
@@ -271,13 +302,16 @@ export default function src_default(pi) {
     }
   });
   pi.registerTool({
-    name: "context_checkout",
-    label: "Context Checkout",
-    description: "Navigate to ANY point in the conversation history. This checkout only resets *conversation history*, NOT disk files. ALWAYS provide a detailed 'message' to bridge context.",
-    parameters: ContextCheckoutParams,
+    name: "context_compact",
+    label: "Context Compact",
+    description: ContextCompactDescription,
+    parameters: ContextCompactParams,
     async execute(_id, params, _signal, _onUpdate, ctx) {
       if (!CommandCtx) {
-        ctx.ui.setEditorText(`/acm ${ctx.ui.getEditorText() || "continue"}`);
+        const editorText = ctx.ui.getEditorText();
+        const followUp = editorText ? `${AcmEnableFollowUp}
+${editorText}` : AcmEnableFollowUp;
+        ctx.ui.setEditorText(`/acm ${followUp}`);
         return {
           content: [{
             type: "text",
@@ -287,52 +321,102 @@ export default function src_default(pi) {
         };
       }
       const sm = ctx.sessionManager;
+      const usageBeforeText = formatContextUsage(ctx.getContextUsage());
       const tid = resolveTargetId(sm, params.target);
       const currentLeaf = sm.getLeafId();
       if (currentLeaf === tid) {
         return { content: [{ type: "text", text: `Already at target ${tid}` }], details: {} };
       }
-      if (params.backupTag && currentLeaf) {
-        pi.setLabel(currentLeaf, params.backupTag);
+      if (params.backupCheckpoint && currentLeaf) {
+        pi.setLabel(currentLeaf, params.backupCheckpoint);
       }
       const currentLabel = currentLeaf ? sm.getLabel(currentLeaf) : undefined;
-      const origin = currentLabel ? `tag: ${currentLabel}` : currentLeaf || "unknown";
-      const enrichedMessage = `(summary from ${origin})
-${params.message}`;
-      const nid = await sm.branchWithSummary(tid, enrichedMessage);
-      CheckoutParams = params;
-      CheckoutParams.nid = nid;
-      CheckoutParams.tid = tid;
-      CheckoutParams.enrichedMessage = enrichedMessage;
-      return { content: [{ type: "text", text: "checkout start" }], details: {} };
+      const origin = currentLabel ? `checkpoint: ${currentLabel}` : currentLeaf || "unknown";
+      const enrichedMessage = `(handoff summary from ${origin})
+${params.summary}`;
+      CompactParams = params;
+      CompactParams.tid = tid;
+      CompactParams.enrichedMessage = enrichedMessage;
+      CompactParams.usageBeforeText = usageBeforeText;
+      return { content: [{ type: "text", text: "compact start" }], details: {} };
     }
   });
-  pi.on("turn_end", async (event, ctx) => {
-    if (!CheckoutParams) {
+  pi.on("turn_end", async (_event, ctx) => {
+    if (!CompactParams) {
       return;
     }
     ctx.abort();
   });
   pi.on("agent_end", async (_event, ctx) => {
-    if (!CheckoutParams) {
+    if (!CompactParams) {
       return;
     }
     if (!CommandCtx) {
       return;
     }
-    await CommandCtx.navigateTree(CheckoutParams.nid, {
-      summarize: false
-    });
-    ctx.ui.notify(`Checked out ${CheckoutParams.target}${CheckoutParams.target === CheckoutParams.tid ? "" : `(${CheckoutParams.tid})`}
-Backup tag created: ${CheckoutParams.backupTag || "none"}
-message: ${CheckoutParams.enrichedMessage}`, "info");
-    CheckoutParams = null;
-    pi.sendMessage({
-      customType: "dm-context",
-      content: "context_checkout complete. A summary of your previous branch was injected above. Read it to understand your new state. Execute the 'Next Step' from the summary",
-      display: false
-    }, {
-      triggerTurn: true
-    });
+    const sm = ctx.sessionManager;
+    const compactParams = CompactParams;
+    const commandCtx = CommandCtx;
+    CompactParams = null;
+    const compactTurnLeaf = sm.getLeafId();
+    setTimeout(async () => {
+      try {
+        await commandCtx.waitForIdle();
+        const branch = sm.getBranch();
+        if (didConversationAdvance(branch, compactTurnLeaf)) {
+          commandCtx.ui.notify("context_compact cancelled: conversation advanced before compaction completed.", "warning");
+          pi.sendMessage({
+            customType: DmContextCustomMessageType,
+            content: [
+              "context_compact cancelled: conversation advanced before the summary branch was created.",
+              "No compaction was applied; continue from the current path. If still useful, inspect timeline and retry with an updated summary."
+            ].join(`
+`),
+            display: false
+          }, {
+            triggerTurn: true,
+            deliverAs: "followUp"
+          });
+          return;
+        }
+        const nid = sm.branchWithSummary(compactParams.tid, compactParams.enrichedMessage);
+        compactParams.nid = nid;
+        sm.branch(compactParams.tid);
+        await commandCtx.navigateTree(compactParams.nid, {
+          summarize: false
+        });
+        const usageAfter = commandCtx.getContextUsage();
+        commandCtx.ui.notify([
+          `Compacted to ${compactParams.target}${compactParams.target === compactParams.tid ? "" : `(${compactParams.tid})`}`,
+          `Context Usage: ${compactParams.usageBeforeText} -> ${formatContextUsage(usageAfter)}`,
+          `Backup checkpoint created: ${compactParams.backupCheckpoint || "none"}`,
+          `Summary: ${compactParams.enrichedMessage}`
+        ].join(`
+`), "info");
+        pi.sendMessage({
+          customType: DmContextCustomMessageType,
+          content: "context_compact complete. A handoff summary of your previous conversation path was injected above. Read it to understand your new state. Execute the Next Step from the summary",
+          display: false
+        }, {
+          triggerTurn: true,
+          deliverAs: "followUp"
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        commandCtx.ui.notify(`context_compact failed: ${message}`, "error");
+        pi.sendMessage({
+          customType: DmContextCustomMessageType,
+          content: [
+            `context_compact failed: ${message}`,
+            "No compaction was applied; continue from the current path. Retry only with a fresh timeline/summary."
+          ].join(`
+`),
+          display: false
+        }, {
+          triggerTurn: true,
+          deliverAs: "followUp"
+        });
+      }
+    }, 0);
   });
 }

package/extensions/dm-mcp-adapter/OAUTH.md

@@ -0,0 +1,3 @@
+# DM MCP Adapter OAuth
+
+Complete the provider authorization flow shown by DM, then return to the active DM session.

package/extensions/dm-mcp-adapter/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,4 @@
+# Third-party notice
+
+This managed extension is adapted from `nicobailon/pi-mcp-adapter` at `10a45367e033a32026987a75d6f401e37340c86f` (upstream tag `v2.32.1`) under MIT.
+The upstream package name and repository are retained solely as technical provenance.

package/extensions/dm-mcp-adapter/abort.js

@@ -0,0 +1,35 @@
+export function throwIfAborted(signal) {
+  if (!signal?.aborted)
+    return;
+  throw signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason ?? "MCP request aborted"));
+}
+export async function abortable(promise, signal) {
+  if (!signal)
+    return promise;
+  throwIfAborted(signal);
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason ?? "MCP request aborted")));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(error);
+    });
+  });
+}

package/extensions/dm-mcp-adapter/agent-dir.js

@@ -0,0 +1,45 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export function getConfigDirName() {
+  const configDir = readPiConfig()?.configDir;
+  return typeof configDir === "string" && configDir.trim() ? configDir.trim() : ".dm";
+}
+export function getAgentDir() {
+  const piConfig = readPiConfig();
+  const name = piConfig?.name;
+  const appName = typeof name === "string" && name.trim() ? name.trim() : "pi";
+  const configured = process.env[`${appName.toUpperCase()}_CODING_AGENT_DIR`]?.trim();
+  if (!configured) {
+    return join(homedir(), getConfigDirName(), "agent");
+  }
+  if (configured === "~") {
+    return homedir();
+  }
+  if (configured.startsWith("~/")) {
+    return resolve(homedir(), configured.slice(2));
+  }
+  return resolve(configured);
+}
+export function getAgentPath(...segments) {
+  return join(getAgentDir(), ...segments);
+}
+function readPiConfig() {
+  const dir = process.env.PI_PACKAGE_DIR?.trim();
+  if (!dir)
+    return;
+  try {
+    const manifest = JSON.parse(readFileSync(join(resolve(dir), "package.json"), "utf8"));
+    return manifest.piConfig;
+  } catch {
+    return;
+  }
+}
+export function getAppName() {
+  const name = readPiConfig()?.name;
+  return typeof name === "string" && name.trim() ? name.trim() : "pi";
+}
+export function getAppClientUri() {
+  const uri = readPiConfig()?.clientUri;
+  return typeof uri === "string" && uri.trim() ? uri.trim() : undefined;
+}