@duckmind/dm-windows-x64 0.63.4 → 0.63.6

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-skills-manager/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,27 @@
+# Third-party notices
+
+This package is based on ideas and portions of [`@kmiyh/pi-skills-menu`](https://github.com/Kmiyh/pi-skills-menu), which is licensed under the MIT License.
+
+```text
+MIT License
+
+Copyright (c) 2025 Kmiyh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```

package/extensions/dm-skills-manager/extensions/skills-manager/components.js

@@ -0,0 +1,265 @@
+import {
+  Container,
+  Editor,
+  Key,
+  Markdown,
+  matchesKey,
+  Spacer,
+  Text,
+  truncateToWidth,
+  visibleWidth
+} from "@duckmind/dm-tui";
+import { getMarkdownTheme } from "@duckmind/dm-coding-agent";
+import { buildFrontmatterBlock } from "./format.js";
+import { glyphs } from "./glyphs.js";
+import { isDeletableSkill } from "./registry.js";
+import {
+  getEditorTheme,
+  inlineLine,
+  packageLabel,
+  padAnsi,
+  scopeLabel,
+  skillEntityTitle,
+  skillKeyHints,
+  skillLocation,
+  skillSelectedLine,
+  toneText,
+  renderFrame
+} from "./ui.js";
+
+export class SingleLineText {
+  text;
+  ellipsis;
+  constructor(text, ellipsis = "...") {
+    this.text = text;
+    this.ellipsis = ellipsis;
+  }
+  render(width) {
+    return [truncateToWidth(inlineLine(this.text), width, this.ellipsis)];
+  }
+  invalidate() {}
+}
+
+export class ListLineText {
+  text;
+  selected;
+  theme;
+  ellipsis;
+  constructor(text, selected, theme, ellipsis = "...") {
+    this.text = text;
+    this.selected = selected;
+    this.theme = theme;
+    this.ellipsis = ellipsis;
+  }
+  render(width) {
+    const line = truncateToWidth(inlineLine(this.text), width, this.ellipsis);
+    return [this.selected ? skillSelectedLine(this.theme, line, width) : line];
+  }
+  invalidate() {}
+}
+
+export class PrefixedEditor {
+  editor;
+  prefix;
+  constructor(editor, prefix = "> ") {
+    this.editor = editor;
+    this.prefix = prefix;
+  }
+  render(width) {
+    const rendered = this.editor.render(Math.max(1, width - this.prefix.length));
+    const lines = rendered.length >= 2 ? rendered.slice(1, -1) : rendered;
+    return lines.length === 0 ? [this.prefix] : lines.map((line, index) => `${index === 0 ? this.prefix : "  "}${line}`);
+  }
+  invalidate() {
+    this.editor.invalidate();
+  }
+}
+
+export class SearchInputLine {
+  input;
+  theme;
+  prefix;
+  constructor(input, theme, prefix = " ") {
+    this.input = input;
+    this.theme = theme;
+    this.prefix = prefix;
+  }
+  render(width) {
+    const inputWidth = Math.max(1, width - visibleWidth(this.prefix));
+    const line = truncateToWidth(`${this.prefix}${this.input.render(inputWidth)[0] ?? ""}`, width, "");
+    return [this.theme.bg("toolPendingBg", padAnsi(line, width))];
+  }
+  invalidate() {
+    this.input.invalidate();
+  }
+}
+
+export class ScrollableSkillPreview {
+  scrollOffset = 0;
+  lastInnerWidth = 1;
+  lastContentLines = [];
+  skill;
+  theme;
+  getTerminalRows;
+  constructor(skill, theme, getTerminalRows) {
+    this.skill = skill;
+    this.theme = theme;
+    this.getTerminalRows = getTerminalRows;
+  }
+  setSkill(skill) {
+    this.skill = skill;
+    this.scrollOffset = 0;
+    this.lastContentLines = [];
+  }
+  invalidate() {
+    this.lastContentLines = [];
+  }
+  maxHeight() {
+    return Math.max(10, Math.floor(this.getTerminalRows() * 0.78));
+  }
+  buildContentLines(innerWidth) {
+    const content = new Container;
+    const status = this.skill.enabled ? this.theme.fg("success", "enabled") : this.theme.fg("warning", "disabled");
+    const source = packageLabel(this.skill) ? `${packageLabel(this.skill)}` : this.skill.path;
+    content.addChild(new Text(skillEntityTitle(this.theme, this.skill.name), 0, 0));
+    content.addChild(new Text(`${this.theme.fg("muted", scopeLabel(this.skill))}${this.theme.fg("dim", ` ${glyphs().bullet.trim()} `)}${this.theme.fg("muted", source)}${this.theme.fg("dim", ` ${glyphs().bullet.trim()} `)}${status}`, 0, 0));
+    content.addChild(new Spacer(1));
+    content.addChild(new Text(this.theme.fg("muted", this.theme.bold("Description")), 0, 0));
+    content.addChild(new Text(this.skill.description, 0, 0));
+    content.addChild(new Spacer(1));
+    content.addChild(new Text(this.theme.fg("muted", this.theme.bold("Metadata")), 0, 0));
+    content.addChild(new Text(this.theme.fg("dim", buildFrontmatterBlock(this.skill)), 0, 0));
+    content.addChild(new Spacer(1));
+    content.addChild(new Text(this.theme.fg("muted", this.theme.bold("Content")), 0, 0));
+    content.addChild(new Spacer(1));
+    content.addChild(new Markdown(this.skill.content || this.theme.fg("dim", "(empty skill body)"), 0, 0, getMarkdownTheme()));
+    const lines = content.render(innerWidth);
+    this.lastInnerWidth = innerWidth;
+    this.lastContentLines = lines;
+    return lines;
+  }
+  footer(innerWidth, visibleHeight, totalLines) {
+    const maxScroll = Math.max(0, totalLines - visibleHeight);
+    const scroll = maxScroll > 0 ? this.theme.fg("dim", ` ${glyphs().bullet.trim()} ${this.scrollOffset + 1}-${Math.min(totalLines, this.scrollOffset + visibleHeight)}/${totalLines}`) : "";
+    const hints = [["-/=", "page"]];
+    hints.push(["ctrl+x", "enable/disable"]);
+    if (isDeletableSkill(this.skill))
+      hints.push(["alt+e", "edit"], ["alt+r", "rename"], ["backspace", "delete"]);
+    return truncateToWidth(`${skillKeyHints(this.theme, hints)}${scroll}`, innerWidth, this.theme.fg("dim", "..."));
+  }
+  render(width) {
+    if (width < 8)
+      return [];
+    const innerWidth = Math.max(1, width - 4);
+    const visibleHeight = Math.max(1, this.maxHeight() - 3);
+    const contentLines = this.buildContentLines(innerWidth);
+    const maxScroll = Math.max(0, contentLines.length - visibleHeight);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxScroll));
+    const visible = contentLines.slice(this.scrollOffset, this.scrollOffset + visibleHeight);
+    return renderFrame(this.theme, width, [...visible, this.footer(innerWidth, visibleHeight, contentLines.length)]);
+  }
+  handleInput(data) {
+    const visibleHeight = Math.max(1, this.maxHeight() - 3);
+    const total = this.lastContentLines.length || this.buildContentLines(this.lastInnerWidth).length;
+    const maxScroll = Math.max(0, total - visibleHeight);
+    if (matchesKey(data, Key.up))
+      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+    else if (matchesKey(data, Key.down))
+      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
+    else if (matchesKey(data, "-") || matchesKey(data, Key.pageUp))
+      this.scrollOffset = Math.max(0, this.scrollOffset - visibleHeight);
+    else if (matchesKey(data, "=") || matchesKey(data, Key.pageDown))
+      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + visibleHeight);
+    else if (matchesKey(data, Key.home))
+      this.scrollOffset = 0;
+    else if (matchesKey(data, Key.end))
+      this.scrollOffset = maxScroll;
+  }
+}
+
+export class SkillEditorView {
+  editor;
+  initialText;
+  proxyTui;
+  skill;
+  theme;
+  realTui;
+  onSave;
+  onCancel;
+  virtualRows = 24;
+  _focused = false;
+  message;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value;
+    this.editor.focused = value;
+  }
+  constructor(skill, theme, realTui, initialText, onSave, onCancel) {
+    this.skill = skill;
+    this.theme = theme;
+    this.realTui = realTui;
+    this.onSave = onSave;
+    this.onCancel = onCancel;
+    this.initialText = initialText;
+    const self = this;
+    this.proxyTui = { requestRender: () => realTui.requestRender(), get terminal() {
+      return { ...realTui.terminal, rows: Math.max(1, self.virtualRows) };
+    } };
+    this.editor = new Editor(this.proxyTui, getEditorTheme(theme), { autocompleteMaxVisible: 6 });
+    this.editor.setText(initialText);
+  }
+  setSkill(skill) {
+    this.skill = skill;
+  }
+  setMessage(text, tone) {
+    this.message = { text, tone };
+  }
+  isDirty() {
+    return this.editor.getText() !== this.initialText;
+  }
+  invalidate() {
+    this.editor.invalidate();
+  }
+  targetHeight() {
+    return Math.max(10, Math.floor(this.realTui.terminal.rows * 0.78));
+  }
+  rowsForVisibleEditorLines(targetVisibleLines) {
+    let rows = 5;
+    while (Math.max(5, Math.floor(rows * 0.3)) < targetVisibleLines && rows < 1000)
+      rows += 1;
+    return rows;
+  }
+  render(width) {
+    const innerWidth = Math.max(1, width - 4);
+    const lines = [
+      skillEntityTitle(this.theme, `Edit ${this.skill.name}`),
+      this.theme.fg("muted", skillLocation(this.skill)),
+      this.theme.fg("dim", `Name is immutable here: ${this.skill.name}`)
+    ];
+    if (this.message)
+      lines.push("", toneText(this.theme, this.message.tone, this.message.text));
+    const targetInnerLines = Math.max(1, this.targetHeight() - 2);
+    const staticLineCount = lines.length + 3;
+    const editorBlockLines = Math.max(7, targetInnerLines - staticLineCount);
+    this.virtualRows = this.rowsForVisibleEditorLines(Math.max(5, editorBlockLines - 2));
+    lines.push("", ...this.editor.render(innerWidth), "", truncateToWidth(skillKeyHints(this.theme, [["alt+s", "save"]]), innerWidth, this.theme.fg("dim", "...")));
+    while (lines.length < targetInnerLines)
+      lines.splice(Math.max(0, lines.length - 1), 0, "");
+    return renderFrame(this.theme, width, lines.slice(0, targetInnerLines));
+  }
+  handleInput(data) {
+    if (matchesKey(data, Key.escape)) {
+      this.onCancel();
+      return;
+    }
+    if (matchesKey(data, Key.alt("s")) || matchesKey(data, Key.ctrl("s"))) {
+      this.onSave(this.editor.getText());
+      return;
+    }
+    if (this.message?.tone === "error")
+      this.message = undefined;
+    this.editor.handleInput(data);
+  }
+}