killeros 2.0.8 → 2.0.10

package/killeros/commands.ts

@@ -30,6 +30,19 @@ interface CommandInfo {
   syntaxHint?: string;
 }
 
+export interface SlashCommandToken {
+  name: string;
+  start: number;
+  end: number;
+}
+
+export interface SlashCommandResolver {
+  clearFallbackCommands(): void;
+  updateFallbackCommands(items: readonly AutocompleteItem[]): void;
+  getCommandCatalog(baseSuggestions?: readonly AutocompleteItem[]): ReadonlyMap<string, CommandInfo>;
+  isValidCommand(name: string): boolean;
+}
+
 const BUILTIN_COMMANDS: ReadonlyArray<{ name: string; description: string }> = [
   { name: "settings", description: "Open settings menu" },
   { name: "model", description: "Select model" },
@@ -70,6 +83,87 @@ interface TaggedAutocompleteItem extends AutocompleteItem {
   killerosCommand?: string;
 }
 
+const SLASH_COMMAND_PREFIX_PATTERN = /(?:^|[ \t])\/([^\s/]*)$/u;
+const SLASH_COMMAND_TOKEN_PATTERN = /(?:^|[ \t])\/([^\s/]+)(?=$|[ \t])/gu;
+
+export function getSlashCommandPrefix(line: string): { prefix: string; slashIndex: number } | undefined {
+  const match = SLASH_COMMAND_PREFIX_PATTERN.exec(line);
+  if (!match || match.index === undefined) return undefined;
+  const prefix = match[1] ?? "";
+  const slashIndex = match.index + (match[0].startsWith("/") ? 0 : 1);
+  return { prefix, slashIndex };
+}
+
+export function findSlashCommandTokens(line: string): SlashCommandToken[] {
+  const tokens: SlashCommandToken[] = [];
+  for (const match of line.matchAll(SLASH_COMMAND_TOKEN_PATTERN)) {
+    const name = match[1];
+    if (name === undefined || match.index === undefined) continue;
+    const start = match.index + (match[0].startsWith("/") ? 0 : 1);
+    tokens.push({ name, start, end: start + name.length + 1 });
+  }
+  return tokens;
+}
+
+function commandNameFromAutocompleteItem(item: AutocompleteItem): string {
+  return (item.value || item.label).replace(/^\//u, "").trim().split(/\s+/u)[0] ?? "";
+}
+
+export function createSlashCommandResolver(
+  pi: Pick<ExtensionAPI, "getCommands">,
+): SlashCommandResolver {
+  let fallbackCommands = new Map<string, string | undefined>();
+
+  const getCommandCatalog = (baseSuggestions: readonly AutocompleteItem[] = []): ReadonlyMap<string, CommandInfo> => {
+    const commands = new Map<string, CommandInfo>();
+    BUILTIN_COMMANDS.forEach((command) => commands.set(command.name, {
+      ...command,
+      category: "Built-in",
+      syntaxHint: COMMAND_SYNTAX_HINTS[command.name],
+    }));
+
+    for (const command of pi.getCommands()) {
+      const category: CommandInfo["category"] = command.source === "skill"
+        ? "Skill"
+        : command.source === "prompt"
+          ? "Prompt"
+          : "Extension";
+      commands.set(command.name, {
+        name: command.name,
+        description: command.description,
+        category,
+        syntaxHint: COMMAND_SYNTAX_HINTS[command.name],
+      });
+    }
+
+    const baseCommands = baseSuggestions.length > 0
+      ? new Map(baseSuggestions.map((item) => [commandNameFromAutocompleteItem(item), item.description] as const))
+      : fallbackCommands;
+    for (const [name, description] of baseCommands) {
+      if (name && !commands.has(name)) {
+        commands.set(name, { name, description, category: "Built-in" });
+      }
+    }
+    return commands;
+  };
+
+  return {
+    clearFallbackCommands() {
+      fallbackCommands = new Map<string, string | undefined>();
+    },
+    updateFallbackCommands(items) {
+      fallbackCommands = new Map(
+        items.map((item) => [commandNameFromAutocompleteItem(item), item.description] as const)
+          .filter(([name]) => Boolean(name)),
+      );
+    },
+    getCommandCatalog,
+    isValidCommand(name) {
+      return getCommandCatalog().has(name);
+    },
+  };
+}
+
 function scoreCommandMatch(name: string, prefix: string): number {
   if (!prefix) return 1;
   const normalizedName = name.toLocaleLowerCase();
@@ -80,47 +174,26 @@ function scoreCommandMatch(name: string, prefix: string): number {
   return 0;
 }
 
-export function registerSlashAutocomplete(pi: ExtensionAPI): void {
+export function registerSlashAutocomplete(
+  pi: ExtensionAPI,
+  resolver: SlashCommandResolver = createSlashCommandResolver(pi),
+): SlashCommandResolver {
   const usage = new Map<string, number>();
   pi.on("session_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
+    resolver.clearFallbackCommands();
     ctx.ui.addAutocompleteProvider((current) => ({
       triggerCharacters: ["/"],
       async getSuggestions(lines, cursorLine, cursorCol, options) {
         const line = lines[cursorLine] ?? "";
         const beforeCursor = line.slice(0, cursorCol);
-        const match = beforeCursor.match(/(?:^|[ \t])\/([^\s/]*)$/);
-        if (!match) return current.getSuggestions(lines, cursorLine, cursorCol, options);
+        const prefixMatch = getSlashCommandPrefix(beforeCursor);
+        if (!prefixMatch) return current.getSuggestions(lines, cursorLine, cursorCol, options);
 
-        const prefix = (match[1] ?? "").toLocaleLowerCase();
+        const prefix = prefixMatch.prefix.toLocaleLowerCase();
         const baseSuggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
-        const commands = new Map<string, CommandInfo>();
-        BUILTIN_COMMANDS.forEach((command) => commands.set(command.name, {
-          ...command,
-          category: "Built-in",
-          syntaxHint: COMMAND_SYNTAX_HINTS[command.name],
-        }));
-
-        for (const command of pi.getCommands()) {
-          const category: CommandInfo["category"] = command.source === "skill"
-            ? "Skill"
-            : command.source === "prompt"
-              ? "Prompt"
-              : "Extension";
-          commands.set(command.name, {
-            name: command.name,
-            description: command.description,
-            category,
-            syntaxHint: COMMAND_SYNTAX_HINTS[command.name],
-          });
-        }
-
-        for (const item of baseSuggestions?.items ?? []) {
-          const name = (item.value || item.label).replace(/^\//, "").trim().split(/\s+/)[0] ?? "";
-          if (name && !commands.has(name)) {
-            commands.set(name, { name, description: item.description, category: "Built-in" });
-          }
-        }
+        resolver.updateFallbackCommands(baseSuggestions?.items ?? []);
+        const commands = resolver.getCommandCatalog(baseSuggestions?.items ?? []);
 
         const ranked = [...commands.values()]
           .map((command) => ({
@@ -151,9 +224,9 @@ export function registerSlashAutocomplete(pi: ExtensionAPI): void {
         const line = lines[cursorLine] ?? "";
         const beforeCursor = line.slice(0, cursorCol);
         const afterCursor = line.slice(cursorCol);
-        const match = beforeCursor.match(/(?:^|[ \t])\/([^\s/]*)$/);
-        if (!match || match.index === undefined) return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
-        const slashIndex = match.index + (match[0].startsWith("/") ? 0 : 1);
+        const prefixMatch = getSlashCommandPrefix(beforeCursor);
+        if (!prefixMatch) return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+        const slashIndex = prefixMatch.slashIndex;
         const newBefore = beforeCursor.slice(0, slashIndex) + item.value;
         const nextLines = [...lines];
         nextLines[cursorLine] = newBefore + afterCursor;
@@ -164,4 +237,5 @@ export function registerSlashAutocomplete(pi: ExtensionAPI): void {
       },
     }));
   });
+  return resolver;
 }

package/killeros/goals.ts

@@ -264,7 +264,10 @@ function transitionGoal(
     resumeAfterManualCompaction: options.resumeAfterManualCompaction,
   };
   persistGoalState(pi, runtime, event, next);
-  if (status !== "active") runtime.continuationScheduled = false;
+  if (status !== "active") {
+    runtime.continuationScheduled = false;
+    runtime.automaticCompaction = undefined;
+  }
   return next;
 }
 
@@ -272,6 +275,7 @@ function clearGoalExecutionFlags(runtime: GoalRuntime): void {
   runtime.continuationScheduled = false;
   runtime.goalTurnInFlight = false;
   runtime.agentEndObserved = false;
+  runtime.automaticCompaction = undefined;
   runtime.lastStopReason = undefined;
   runtime.lastError = undefined;
 }
@@ -333,6 +337,7 @@ export function pauseGoalAfterFailure(
     syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
+    runtime.automaticCompaction = undefined;
     runtime.requestRender?.();
   }
   if (notify) ctx.ui.notify(`Goal paused: ${reason}\n${recoveryInstruction}`, "error");
@@ -359,6 +364,7 @@ function pauseGoalForPossibleManualCompaction(
     syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
+    runtime.automaticCompaction = undefined;
     runtime.requestRender?.();
   }
   ctx.ui.notify(
@@ -384,6 +390,7 @@ function recoverGoalAfterManualCompaction(
     return false;
   }
   runtime.continuationScheduled = false;
+  runtime.automaticCompaction = undefined;
   ctx.ui.notify("Manual compaction complete. Goal resumed.", "info");
   setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
   return true;
@@ -450,6 +457,42 @@ function scheduleGoalContinuation(
   }
 }
 
+function completeAutomaticCompaction(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  initState: InitRuntime,
+  ctx: ExtensionContext,
+): void {
+  if (runtime.automaticCompaction === undefined) return;
+  if (runtime.state?.status !== "active" || initState.active) {
+    runtime.automaticCompaction = undefined;
+    return;
+  }
+  runtime.automaticCompaction = "completed";
+  if (runtime.goalTurnInFlight || !ctx.isIdle()) return;
+  runtime.automaticCompaction = undefined;
+  setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
+}
+
+function failAutomaticCompaction(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  ctx: ExtensionContext,
+  error: unknown,
+): void {
+  if (runtime.automaticCompaction === undefined) return;
+  runtime.automaticCompaction = undefined;
+  if (runtime.state?.status !== "active") return;
+  const reason = error instanceof Error ? error.message : String(error);
+  pauseGoalAfterFailure(
+    pi,
+    runtime,
+    ctx,
+    `automatic compaction failed: ${reason}`,
+    "Automatic continuation is stopped. Run /goal resume after resolving the compaction problem.",
+  );
+}
+
 function goalInstructions(state: GoalState, heading: string): string {
   return [
     `# ${heading}`,
@@ -598,6 +641,7 @@ export function registerGoal(
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
     runtime.agentEndObserved = false;
+    runtime.automaticCompaction = undefined;
     runtime.persistenceRetryNeeded = false;
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
@@ -630,6 +674,7 @@ export function registerGoal(
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
     runtime.agentEndObserved = false;
+    runtime.automaticCompaction = undefined;
     runtime.persistenceRetryNeeded = false;
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
@@ -983,7 +1028,12 @@ export function registerGoalSettlement(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
   initState: InitRuntime,
-): void {
+): {
+  isActive(ctx: ExtensionContext): boolean;
+  onRequested(): void;
+  onCompleted(ctx: ExtensionContext): void;
+  onFailed(ctx: ExtensionContext, error: unknown): void;
+} {
   pi.on("agent_settled", (_event, ctx) => {
     const wasGoalTurn = runtime.goalTurnInFlight;
     const continuationWasScheduled = runtime.continuationScheduled;
@@ -1000,6 +1050,7 @@ export function registerGoalSettlement(
       return;
     }
     if (!agentEndObserved) {
+      if (runtime.automaticCompaction !== undefined) return;
       pauseGoalAfterFailure(pi, runtime, ctx, "the goal turn ended without an agent result");
       return;
     }
@@ -1007,6 +1058,12 @@ export function registerGoalSettlement(
       const reason = runtime.lastError || "the agent turn was aborted";
       runtime.lastStopReason = undefined;
       runtime.lastError = undefined;
+      if (runtime.automaticCompaction !== undefined) {
+        if (runtime.automaticCompaction === "completed") {
+          completeAutomaticCompaction(pi, runtime, initState, ctx);
+        }
+        return;
+      }
       pauseGoalForPossibleManualCompaction(pi, runtime, ctx, reason);
       return;
     }
@@ -1023,7 +1080,23 @@ export function registerGoalSettlement(
   });
 
   pi.on("session_compact", (event, ctx) => {
+    if (runtime.automaticCompaction !== undefined) {
+      completeAutomaticCompaction(pi, runtime, initState, ctx);
+      return;
+    }
     if (event.reason !== "manual") return;
     recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
   });
+
+  return {
+    isActive: (ctx: ExtensionContext): boolean => isGoalModeSupported(ctx)
+      && isSavedSession(ctx)
+      && runtime.state?.status === "active"
+      && !initState.active,
+    onRequested: (): void => {
+      if (runtime.state?.status === "active") runtime.automaticCompaction = "pending";
+    },
+    onCompleted: (ctx: ExtensionContext): void => completeAutomaticCompaction(pi, runtime, initState, ctx),
+    onFailed: (ctx: ExtensionContext, error: unknown): void => failAutomaticCompaction(pi, runtime, ctx, error),
+  };
 }

package/killeros/notifications.ts

@@ -1,12 +1,10 @@
-import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { basename } from "node:path";
 import type { StopReason } from "@earendil-works/pi-ai";
 import {
-  getAgentDir,
   type ExtensionAPI,
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import { createKillerosSettingsStore } from "./settings.ts";
 
 export interface NotificationPreferenceStore {
   load(): boolean;
@@ -20,42 +18,14 @@ export interface CompletionNotificationDependencies {
 
 export const COMPLETION_BELL_GLYPH = "󰂚";
 
-const defaultSettingsPath = (): string => join(getAgentDir(), "killeros.json");
-
-type StoredSettings = Record<string, unknown>;
-
-function readStoredSettings(settingsPath: string): StoredSettings {
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(settingsPath, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("KillerOS settings must contain a JSON object");
-    }
-    return parsed as StoredSettings;
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
-    throw error;
-  }
-}
-
 export function createNotificationPreferenceStore(
-  settingsPath = defaultSettingsPath(),
+  settingsPath?: string,
 ): NotificationPreferenceStore {
+  const settings = createKillerosSettingsStore(settingsPath);
   return {
-    load: () => readStoredSettings(settingsPath).completionSound === true,
+    load: () => settings.load().completionSound === true,
     save: (enabled) => {
-      const current = readStoredSettings(settingsPath);
-      mkdirSync(dirname(settingsPath), { recursive: true });
-      const temporaryPath = `${settingsPath}.${process.pid}.${randomUUID()}.tmp`;
-      try {
-        writeFileSync(
-          temporaryPath,
-          `${JSON.stringify({ ...current, completionSound: enabled }, null, 2)}\n`,
-          { encoding: "utf8", mode: 0o600 },
-        );
-        renameSync(temporaryPath, settingsPath);
-      } finally {
-        rmSync(temporaryPath, { force: true });
-      }
+      settings.update({ completionSound: enabled });
     },
   };
 }

package/killeros/runtime.ts

@@ -57,6 +57,7 @@ export interface GoalRuntime {
   continuationHeld: boolean;
   goalTurnInFlight: boolean;
   agentEndObserved: boolean;
+  automaticCompaction?: "pending" | "completed";
   persistenceRetryNeeded: boolean;
   lastStopReason?: string;
   lastError?: string;
@@ -73,6 +74,7 @@ export function createGoalRuntime(): GoalRuntime {
     continuationHeld: false,
     goalTurnInFlight: false,
     agentEndObserved: false,
+    automaticCompaction: undefined,
     persistenceRetryNeeded: false,
   };
 }

package/killeros/settings.ts

@@ -0,0 +1,47 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export type KillerosSettings = Record<string, unknown>;
+
+export interface KillerosSettingsStore {
+  load(): KillerosSettings;
+  update(patch: Readonly<Record<string, unknown>>): void;
+}
+
+function readStoredSettings(settingsPath: string): KillerosSettings {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("KillerOS settings must contain a JSON object");
+    }
+    return parsed as KillerosSettings;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+export function createKillerosSettingsStore(
+  settingsPath = join(getAgentDir(), "killeros.json"),
+): KillerosSettingsStore {
+  return {
+    load: () => readStoredSettings(settingsPath),
+    update: (patch) => {
+      const current = readStoredSettings(settingsPath);
+      mkdirSync(dirname(settingsPath), { recursive: true });
+      const temporaryPath = `${settingsPath}.${process.pid}.${randomUUID()}.tmp`;
+      try {
+        writeFileSync(
+          temporaryPath,
+          `${JSON.stringify({ ...current, ...patch }, null, 2)}\n`,
+          { encoding: "utf8", mode: 0o600 },
+        );
+        renameSync(temporaryPath, settingsPath);
+      } finally {
+        rmSync(temporaryPath, { force: true });
+      }
+    },
+  };
+}

package/killeros/shell-ui.ts

@@ -10,6 +10,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
   CURSOR_MARKER,
+  stripTerminalSequences,
   truncateToWidth,
   visibleWidth,
   wrapTextWithAnsi,
@@ -17,6 +18,11 @@ import {
   type TUI,
 } from "@earendil-works/pi-tui";
 import { formatCwd, padRight } from "./display.ts";
+import {
+  createSlashCommandResolver,
+  findSlashCommandTokens,
+  type SlashCommandResolver,
+} from "./commands.ts";
 import { reportError } from "./errors.ts";
 import { formatModel } from "./footer.ts";
 import { LEVEL_COLORS, type ThinkingLevel } from "./variants.ts";
@@ -166,10 +172,8 @@ class PiStartupHeader {
   }
 }
 
-const ANSI_REGEX = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-
 function stripAnsi(text: string): string {
-  return text.replace(ANSI_REGEX, "").trim();
+  return stripTerminalSequences(text).trim();
 }
 
 function isBorderLine(line: string): boolean {
@@ -182,10 +186,98 @@ function isScrolledTopBorder(line: string): boolean {
   return unstyled.includes("↑");
 }
 
+interface RenderChunk {
+  text: string;
+  plainStart: number;
+  isAnsi: boolean;
+}
+
+function extractTerminalSequence(text: string, position: number): { code: string; length: number } | undefined {
+  if (text[position] !== "\x1B") return undefined;
+  const next = text[position + 1];
+  if (next === "[") {
+    let end = position + 2;
+    while (end < text.length && !/[\x40-\x7E]/u.test(text[end] ?? "")) end += 1;
+    if (end < text.length) return { code: text.slice(position, end + 1), length: end + 1 - position };
+    return undefined;
+  }
+  if (next === "]" || next === "_") {
+    let end = position + 2;
+    while (end < text.length) {
+      if (text[end] === "\x07") return { code: text.slice(position, end + 1), length: end + 1 - position };
+      if (text[end] === "\x1B" && text[end + 1] === "\\") {
+        return { code: text.slice(position, end + 2), length: end + 2 - position };
+      }
+      end += 1;
+    }
+    return undefined;
+  }
+  if (next !== undefined) return { code: text.slice(position, position + 2), length: 2 };
+  return undefined;
+}
+
+export function highlightSlashCommands(
+  line: string,
+  isValidCommand: (name: string) => boolean,
+  styleCommand: (token: string) => string,
+): string {
+  const chunks: RenderChunk[] = [];
+  let plain = "";
+  let index = 0;
+  while (index < line.length) {
+    const ansi = extractTerminalSequence(line, index);
+    if (ansi) {
+      chunks.push({ text: ansi.code, plainStart: plain.length, isAnsi: true });
+      index += ansi.length;
+      continue;
+    }
+
+    const start = index;
+    const plainStart = plain.length;
+    while (index < line.length && !extractTerminalSequence(line, index)) {
+      plain += line[index] ?? "";
+      index += 1;
+    }
+    chunks.push({
+      text: line.slice(start, index),
+      plainStart,
+      isAnsi: false,
+    });
+  }
+
+  const tokens = findSlashCommandTokens(plain).filter((token) => isValidCommand(token.name));
+  if (tokens.length === 0) return line;
+
+  return chunks.map((chunk) => {
+    if (chunk.isAnsi) return chunk.text;
+    let output = "";
+    let offset = 0;
+    while (offset < chunk.text.length) {
+      const plainIndex = chunk.plainStart + offset;
+      const token = tokens.find(({ start, end }) => plainIndex >= start && plainIndex < end);
+      if (!token) {
+        const nextTokenStart = tokens.find(({ start }) => start > plainIndex)?.start;
+        const end = nextTokenStart === undefined
+          ? chunk.text.length
+          : Math.min(chunk.text.length, nextTokenStart - chunk.plainStart);
+        output += chunk.text.slice(offset, end);
+        offset = end;
+        continue;
+      }
+
+      const tokenEnd = Math.min(chunk.text.length, token.end - chunk.plainStart);
+      output += styleCommand(chunk.text.slice(offset, tokenEnd));
+      offset = tokenEnd;
+    }
+    return output;
+  }).join("");
+}
+
 class PiCodeEditor extends CustomEditor {
   private readonly appKeybindings: KeybindingsManager;
   private readonly runtimeTheme: Theme;
   private readonly suggestion: string;
+  private readonly commandResolver: SlashCommandResolver;
 
   constructor(
     tui: TUI,
@@ -193,11 +285,13 @@ class PiCodeEditor extends CustomEditor {
     appKeybindings: KeybindingsManager,
     runtimeTheme: Theme,
     suggestion: string,
+    commandResolver: SlashCommandResolver,
   ) {
     super(tui, theme, appKeybindings);
     this.appKeybindings = appKeybindings;
     this.runtimeTheme = runtimeTheme;
     this.suggestion = suggestion;
+    this.commandResolver = commandResolver;
   }
 
   override handleInput(data: string): void {
@@ -248,6 +342,13 @@ class PiCodeEditor extends CustomEditor {
         const cursorMarker = this.focused ? CURSOR_MARKER : "";
         content = `${cursorMarker}\x1B[7m${dim(first)}\x1B[27m${dim(rest)}`;
       }
+      if (this.getText() !== "") {
+        content = highlightSlashCommands(
+          content,
+          (name) => this.commandResolver.isValidCommand(name),
+          (token) => this.runtimeTheme.fg("mdLink", token),
+        );
+      }
       rendered.push(`${prefix}${padRight(content, innerWidth)}`);
     }
 
@@ -272,7 +373,10 @@ const ACTIVITY_FRAME_INTERVAL_MS = 120;
 
 let killerosEditorFactory: ReturnType<ExtensionContext["ui"]["getEditorComponent"]>;
 
-export function registerShellUi(pi: ExtensionAPI): void {
+export function registerShellUi(
+  pi: ExtensionAPI,
+  commandResolver: SlashCommandResolver = createSlashCommandResolver(pi),
+): void {
   let activeHeader: PiStartupHeader | undefined;
 
   pi.on("session_start", (_event, ctx) => {
@@ -294,7 +398,7 @@ export function registerShellUi(pi: ExtensionAPI): void {
       if (!existingEditorFactory || existingEditorFactory === killerosEditorFactory) {
         const editorSuggestion = nextEditorSuggestion();
         killerosEditorFactory = (tui, editorTheme, keybindings) =>
-          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme, editorSuggestion);
+          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme, editorSuggestion, commandResolver);
         ctx.ui.setEditorComponent(killerosEditorFactory);
       }
     } catch (error) {