interference-agent 0.1.0

package/src/agent/subagent.ts

@@ -0,0 +1,64 @@
+import type { ToolSet } from "ai";
+import { readonlyTools, allToolsWithoutTask } from "../tools/registry.ts";
+
+// I subagent girano in autonomia: niente todowrite (stato globale condiviso, sovrascriverebbe
+// la lista del turno principale) né question (non hanno una UI per interpellare l'utente).
+const { todowrite: _roTodo, question: _roQ, ...readonlyForSub } = readonlyTools;
+const { todowrite: _allTodo, question: _allQ, ...allForSub } = allToolsWithoutTask;
+
+export type SubagentType = "explore" | "general";
+
+export interface SubagentDef {
+  name: string;
+  description: string;
+  systemPrompt: string;
+  tools: ToolSet;
+}
+
+export const SUBAGENTS: Record<SubagentType, SubagentDef> = {
+  explore: {
+    name: "explore",
+    description:
+      "Fast agent specialized for exploring codebases. Use when you need to quickly find files by patterns, " +
+      "search code for keywords, or answer questions about the codebase.",
+    systemPrompt: `You are a specialized code exploration subagent. Your purpose is to investigate the codebase and answer questions.
+
+You have ONLY read-only tools (read, ls, glob, grep). You CANNOT write, edit, or execute commands.
+
+Rules:
+- Be fast and thorough — search broadly, then narrow down
+- When you find the answer, summarize it clearly with file:line references
+- Do NOT suggest edits, create files, or run commands
+- If you can't find something after reasonable search, say so explicitly
+- Return your findings as a concise report`,
+    tools: readonlyForSub,
+  },
+
+  general: {
+    name: "general",
+    description:
+      "General-purpose agent for researching complex questions and executing multi-step tasks. " +
+      "Has full access to all tools.",
+    systemPrompt: `You are a general-purpose subagent. Execute the given task using all available tools.
+
+Rules:
+- Be thorough — explore, read, write, edit, and run commands as needed
+- Summarize your approach before executing
+- Report results clearly with file:line references
+- If you encounter errors, try to correct them before giving up
+- Do NOT spawn other subagents (the task tool is not available to you)`,
+    tools: allForSub,
+  },
+};
+
+export function getSubagent(type: string): SubagentDef | null {
+  const t = type as SubagentType;
+  return SUBAGENTS[t] ?? null;
+}
+
+export function listSubagents(): { type: string; description: string }[] {
+  return Object.entries(SUBAGENTS).map(([type, def]) => ({
+    type,
+    description: def.description,
+  }));
+}

package/src/auth.ts

@@ -0,0 +1,50 @@
+import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
+import * as path from "node:path";
+
+const AUTH_DIR = path.join(
+  process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
+  ".interference",
+);
+
+interface ProviderAuth {
+  label: string;
+  envKey: string;
+}
+
+const AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+
+export async function loadAuth(): Promise<Record<string, string>> {
+  try {
+    const raw = await readFile(AUTH_FILE, "utf-8");
+    return JSON.parse(raw) as Record<string, string>;
+  } catch {
+    return {};
+  }
+}
+
+export async function saveAuth(auth: Record<string, string>): Promise<void> {
+  await mkdir(AUTH_DIR, { recursive: true });
+  await writeFile(AUTH_FILE, JSON.stringify(auth, null, 2));
+  try { await chmod(AUTH_FILE, 0o600); } catch {}
+}
+
+export function applyAuthToEnv(auth: Record<string, string>, providers: Record<string, ProviderAuth>): void {
+  for (const [pid, def] of Object.entries(providers)) {
+    const key = auth[pid];
+    if (key && !process.env[def.envKey]) {
+      process.env[def.envKey] = key;
+    }
+  }
+}
+
+export async function setProviderKey(providerId: string, key: string): Promise<void> {
+  const auth = await loadAuth();
+  auth[providerId] = key;
+  await saveAuth(auth);
+}
+
+export async function removeProviderKey(providerId: string): Promise<void> {
+  const auth = await loadAuth();
+  delete auth[providerId];
+  await saveAuth(auth);
+}

package/src/cli-plain.ts

@@ -0,0 +1,274 @@
+#!/usr/bin/env bun
+import * as readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { currentModel, currentProvider, currentMode, setMode } from "./config.ts";
+import { runTurn } from "./agent/loop.ts";
+import type { Chunk } from "./agent/loop.ts";
+import { MissingApiKeyError } from "./provider.ts";
+import { setConfirmHandler } from "./permissions.ts";
+import { setAnswerHandler, type Answers } from "./tools/question.ts";
+import { saveSession, loadSession, listSessions } from "./session/store.ts";
+import type { Session } from "./session/store.ts";
+import { nextTurn, undo, redo, finalizeSnapshots } from "./session/snapshot.ts";
+import { dispatch, isSlashCommand } from "./commands/index.ts";
+import { matchSkills, getCachedRegistry, loadSkillBody } from "./skills.ts";
+import { shouldCompact, compactMessages, getUsagePercent } from "./agent/compaction.ts";
+import { computeDiff, formatDiff } from "./tui/DiffView.tsx";
+import { estimateCost, formatCost } from "./cost.ts";
+import { estimateMessagesTokens } from "./agent/compaction.ts";
+
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+
+export default async function plain(session: Session): Promise<void> {
+  const provider = currentProvider();
+  const mode = currentMode();
+  const modeLabel = mode === "plan" ? "Plan" : "Build";
+  const modeSymbol = mode === "plan" ? "⬡" : "⬢";
+
+  stdout.write(`\n${BOLD}  interference${RESET}  ${DIM}the open-source coding agent${RESET}\n`);
+  stdout.write(`${DIM}  ______________________________${RESET}\n`);
+  stdout.write(`\n`);
+  stdout.write(
+    `${DIM}  ${modeSymbol} ${modeLabel}${RESET}  ${DIM}·${RESET}  ${provider.label}  ${DIM}·${RESET}  ${currentModel()}  ${DIM}·${RESET}  ${getUsagePercent(session.messages)}% ctx  ${DIM}·${RESET}  ${formatCost(estimateCost(estimateMessagesTokens(session.messages)))}${RESET}\n`,
+  );
+  stdout.write(`\n`);
+
+  if (session.messages.length > 0) {
+    stdout.write(`${DIM}  ↳ Resumed ${session.meta.id.slice(0, 12)} (${session.meta.turnCount} turns)${RESET}\n\n`);
+  }
+
+  stdout.write(`  ${DIM}Type a message · /help · /build · /sessions · Ctrl-C${RESET}\n\n`);
+
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  const messages = session.messages;
+  let aborter: AbortController | null = null;
+
+  setConfirmHandler(async (toolName, preview) => {
+    stdout.write(`\n${YELLOW}${preview}${RESET}\n${YELLOW}  Allow ${toolName}?${RESET} [y/N] `);
+    let ans: string;
+    try { ans = (await rl.question("")).trim().toLowerCase(); } catch { ans = "n"; }
+    const ok = ans === "y" || ans === "yes";
+    stdout.write(ok ? `${DIM}  → executing…${RESET}\n` : `${DIM}  → refused${RESET}\n`);
+    return ok;
+  });
+
+  setAnswerHandler(async (qs) => {
+    const answers: Answers = [];
+    for (const q of qs) {
+      stdout.write(`\n${BOLD}${q.header ? `[${q.header}] ` : ""}${q.question}${RESET}\n`);
+      q.options.forEach((o, i) => {
+        stdout.write(`  ${i + 1}. ${o.label}${o.description ? `${DIM} — ${o.description}${RESET}` : ""}\n`);
+      });
+      const hint = q.multiple ? "numbers separated by comma (e.g. 1,3)" : "a number";
+      let raw: string;
+      try { raw = (await rl.question(`${DIM}  choose ${hint} (Enter to skip): ${RESET}`)).trim(); } catch { raw = ""; }
+      const idxs = raw
+        .split(",")
+        .map((s) => parseInt(s.trim(), 10) - 1)
+        .filter((n) => Number.isInteger(n) && n >= 0 && n < q.options.length);
+      const picked = (q.multiple ? idxs : idxs.slice(0, 1)).map((n) => q.options[n]!.label);
+      answers.push(picked);
+    }
+    return answers;
+  });
+
+  rl.on("SIGINT", () => {
+    if (aborter) { aborter.abort(); aborter = null; stdout.write(`\n${DIM}[interrupted]${RESET}\n`); }
+    else { stdout.write("\n"); rl.close(); }
+  });
+
+  try {
+    while (true) {
+      let input: string;
+      try { input = (await rl.question(`${BOLD}›${RESET} `)).trim(); } catch { break; }
+      if (input.length === 0) continue;
+      if (input === "/exit" || input === "/quit") break;
+
+      if (isSlashCommand(input)) {
+        const result = await dispatch(input, {
+          setMode: (m) => { setMode(m); session.meta.mode = m; },
+          clearMessages: () => { messages.length = 0; },
+          doInit: async (args) => {
+            // /init delegates to the agent — run a turn with the init template
+            const template = `Generate or update the AGENTS.md file at the project root.
+
+Follow the bundled agents-setup skill (see system prompt). Key sections:
+- Project overview, stack, directory structure
+- Build/test commands, code conventions  
+- Agent skills and triggers
+- Non-negotiable rules
+
+How to proceed:
+1. Use ls, glob, grep, and read to explore the project thoroughly
+2. Identify languages, frameworks, build system, test setup, conventions
+3. Write AGENTS.md at the project root using the write tool
+4. Confirm the file was created and summarize its contents
+
+${args ? `Additional context: ${args}` : ""}`;
+            nextTurn();
+            messages.push({ role: "user", content: template });
+            aborter = new AbortController();
+            try {
+              await consumeTurn(runTurn(messages, aborter.signal));
+              session.meta.turnCount++;
+              await finalizeSnapshots();
+              await saveSession(session);
+              return "AGENTS.md generated successfully.";
+            } catch (err) {
+              messages.pop();
+              return `Init failed: ${err instanceof Error ? err.message : String(err)}`;
+            } finally { aborter = null; }
+          },
+          doSkill: async (name, body) => {
+            nextTurn();
+            messages.push({ role: "user", content: input });
+            aborter = new AbortController();
+            try {
+              await consumeTurn(runTurn(messages, aborter.signal, undefined, [body]));
+              session.meta.turnCount++;
+              await finalizeSnapshots();
+              await saveSession(session);
+              return `Skill '${name}' executed.`;
+            } catch (err) {
+              messages.pop();
+              return `Skill failed: ${err instanceof Error ? err.message : String(err)}`;
+            } finally { aborter = null; }
+          },
+          doSessions: async () => {
+            const list = await listSessions();
+            if (list.length === 0) return "No sessions found.";
+            stdout.write(`\n${DIM}Sessions:${RESET}\n`);
+            for (let i = 0; i < Math.min(list.length, 15); i++) {
+              const s = list[i]!;
+              stdout.write(`  ${DIM}${i + 1}.${RESET} ${s.id.slice(0, 12)} ${DIM}· ${s.mode} · ${s.turnCount}t · ${s.updatedAt.slice(0, 10)}${RESET}\n`);
+            }
+            stdout.write(`${DIM}Enter number to resume or 0 to cancel: ${RESET}`);
+            let choice: string;
+            try { choice = (await rl.question("")).trim(); } catch { return "Cancelled."; }
+            const idx = parseInt(choice) - 1;
+            if (idx >= 0 && idx < list.length && list[idx]) {
+              const loaded = await loadSession(list[idx]!.id);
+              if (loaded) {
+                messages.length = 0;
+                messages.push(...loaded.messages);
+                session.meta = loaded.meta;
+                session.messages = loaded.messages;
+                return `Resumed session ${list[idx]!.id.slice(0, 12)} (${loaded.meta.turnCount} turns).`;
+              }
+              return "Session not found.";
+            }
+            return "Cancelled.";
+          },
+          doRename: async (name) => {
+            session.meta.id = name;
+            await saveSession(session);
+            return `Session renamed to '${name}'.`;
+          },
+        });
+        if (result) stdout.write(`${DIM}${result}${RESET}\n\n`);
+        continue;
+      }
+
+      const matchedSkills = matchSkills(input, getCachedRegistry());
+      const skillBodies: string[] = [];
+      for (const name of matchedSkills) {
+        const body = await loadSkillBody(name);
+        if (body) skillBodies.push(body);
+      }
+      if (skillBodies.length > 0) {
+        stdout.write(`${DIM}Skills matched: ${matchedSkills.join(", ")}${RESET}\n`);
+      }
+
+      nextTurn();
+      messages.push({ role: "user", content: input });
+      aborter = new AbortController();
+      try {
+        await consumeTurn(runTurn(messages, aborter.signal, undefined, skillBodies.length > 0 ? skillBodies : undefined));
+        stdout.write("\n\n");
+        session.meta.turnCount++;
+        await finalizeSnapshots();
+        await saveSession(session);
+
+        if (shouldCompact(messages)) {
+          const pct = getUsagePercent(messages);
+          stdout.write(`${DIM}Context at ${pct}%, compacting...${RESET}\n`);
+          const compacted = await compactMessages(messages);
+          messages.length = 0;
+          messages.push(...compacted);
+          session.messages = messages;
+          await saveSession(session);
+          stdout.write(`${DIM}Compacted. ${getUsagePercent(messages)}% context used.${RESET}\n`);
+        }
+      } catch (err) {
+        messages.pop();
+        if (err instanceof MissingApiKeyError) {
+          stdout.write(`\n${err.message}\n\n`);
+        } else if (aborter === null) {
+          // abort
+        } else {
+          const msg = err instanceof Error ? err.message : String(err);
+          stdout.write(`\n${DIM}[error]${RESET} ${msg}\n\n`);
+        }
+      } finally { aborter = null; }
+    }
+  } finally { rl.close(); }
+}
+
+async function consumeTurn(chunks: AsyncGenerator<Chunk>): Promise<void> {
+  let sawReasoning = false;
+  let inText = false;
+  let activeTool: { name: string; args: string; input: unknown } | null = null;
+
+  for await (const chunk of chunks) {
+    switch (chunk.type) {
+      case "reasoning":
+        if (!sawReasoning) { stdout.write(`${DIM}┄ thinking${RESET}\n`); sawReasoning = true; }
+        stdout.write(`${DIM}${chunk.text}${RESET}`);
+        break;
+      case "text":
+        if (activeTool) { stdout.write("\n"); activeTool = null; }
+        if (sawReasoning && !inText) { stdout.write(`\n${DIM}┄${RESET}\n\n`); inText = true; }
+        else if (!inText) { inText = true; }
+        stdout.write(chunk.text);
+        break;
+      case "tool-call": {
+        const args = typeof chunk.input === "string" ? chunk.input : JSON.stringify(chunk.input);
+        if (sawReasoning && !inText) { stdout.write(`\n${DIM}┄${RESET}\n\n`); inText = true; }
+        else if (activeTool || !inText) { stdout.write("\n"); }
+        stdout.write(`${DIM}· ${chunk.toolName}${RESET}(${args})`);
+        activeTool = { name: chunk.toolName, args, input: chunk.input };
+        break;
+      }
+      case "tool-result":
+        if (chunk.isError) {
+          stdout.write(`\n${RED}  → error${RESET}: ${chunk.output.slice(0, 200)}`);
+        } else if (activeTool && (activeTool.name === "write" || activeTool.name === "edit")) {
+          const input = activeTool.input as Record<string, unknown> | undefined;
+          let diffText = "";
+          if (activeTool.name === "edit" && input && typeof input.oldString === "string" && typeof input.newString === "string") {
+            diffText = formatDiff(computeDiff(
+              (input.oldString as string).split("\n"),
+              (input.newString as string).split("\n"),
+            ));
+          } else if (activeTool.name === "write" && input && typeof input.content === "string") {
+            diffText = formatDiff(computeDiff([], (input.content as string).split("\n")));
+          }
+          if (diffText) {
+            stdout.write(`\n${DIM}  → diff:${RESET}\n${diffText}`);
+          } else {
+            const p = chunk.output.length > 120 ? chunk.output.slice(0, 120).replace(/\n/g, " ") + "…" : chunk.output.replace(/\n/g, " ");
+            stdout.write(`\n${DIM}  →${RESET} ${p}`);
+          }
+        } else {
+          const p = chunk.output.length > 120 ? chunk.output.slice(0, 120).replace(/\n/g, " ") + "…" : chunk.output.replace(/\n/g, " ");
+          stdout.write(`\n${DIM}  →${RESET} ${p}`);
+        }
+        activeTool = null;
+        break;
+    }
+  }
+}

package/src/cli.ts

@@ -0,0 +1,87 @@
+#!/usr/bin/env bun
+import { stdin, stdout } from "node:process";
+import { currentModel, currentProvider } from "./config.ts";
+import { MissingApiKeyError } from "./provider.ts";
+import { createSession, latestSession, loadSession, saveSession, initStore } from "./session/store.ts";
+import { initSnapshot } from "./session/snapshot.ts";
+import { initInstructions } from "./agent/prompt.ts";
+import { bootstrapSkills } from "./skills.ts";
+import { initSkillCommands } from "./commands/index.ts";
+import { loadConfig, applyConfig } from "./config-file.ts";
+import { loadAuth, applyAuthToEnv } from "./auth.ts";
+import { PROVIDERS } from "./config.ts";
+import type { Session } from "./session/store.ts";
+
+async function main(): Promise<void> {
+  // Titolo + nome-icona della tab del terminale (come Claude Code), solo in TTY
+  // (in pipe/non-TTY le sequenze OSC sporcherebbero l'output).
+  // OSC 1 = icon/tab name, OSC 2 = window title.
+  if (stdout.isTTY) {
+    stdout.write("\x1b]1;◉ interference\x07\x1b]2;◉ interference\x07");
+  }
+
+  const provider = currentProvider();
+
+  if (!process.env[provider.envKey]) {
+    stdout.write(`\n${new MissingApiKeyError(provider).message}\n`);
+    process.exit(1);
+  }
+
+  await initStore();
+  await bootstrapSkills();
+
+  const auth = await loadAuth();
+  applyAuthToEnv(auth, Object.fromEntries(
+    Object.entries(PROVIDERS).map(([pid, def]) => [pid, { label: def.label, envKey: def.envKey }])
+  ));
+
+  const config = await loadConfig();
+  if (config) applyConfig(config);
+
+  await initInstructions();
+  await initSkillCommands();
+
+  const args = Bun.argv.slice(2);
+  const resumeId = args.includes("--continue")
+    ? args[args.indexOf("--continue") + 1] ?? null
+    : null;
+
+  let session: Session;
+  if (resumeId) {
+    const s = await loadSession(resumeId);
+    if (!s) {
+      stdout.write(`Session ${resumeId} not found\n`);
+      process.exit(1);
+    }
+    session = s;
+  } else if (args.includes("--continue")) {
+    const s = await latestSession();
+    if (!s) {
+      stdout.write("No previous session found\n");
+      process.exit(1);
+    }
+    session = s;
+  } else {
+    session = createSession({
+      mode: "build",
+      provider: provider.label,
+      model: currentModel(),
+    });
+  }
+
+  initSnapshot(session.meta.id);
+
+  if (stdin.isTTY) {
+    const { default: App } = await import("./tui/App.tsx");
+    const { createElement } = await import("react");
+    const { render } = await import("ink");
+    const { waitUntilExit } = render(createElement(App, { session }));
+    await waitUntilExit;
+    return;
+  }
+
+  const { default: plain } = await import("./cli-plain.ts");
+  await plain(session);
+}
+
+main();

package/src/commands/index.ts

@@ -0,0 +1,184 @@
+import type { AgentMode, ThinkingLevel } from "../config.ts";
+import { currentProvider, currentThinking, setThinking, currentModel, setModel } from "../config.ts";
+import { undo, redo } from "../session/snapshot.ts";
+import { loadSkillBody, getCachedRegistry, type SkillInfo } from "../skills.ts";
+
+export interface CommandInfo {
+  name: string;
+  description: string;
+  delegate?: boolean;
+  template?: string;
+  isSkill?: boolean;
+}
+
+export type CommandHandler = (
+  args: string,
+  ctx: {
+    setMode?: (m: AgentMode) => void;
+    clearMessages?: () => void;
+    doInit?: (args: string) => Promise<string>;
+    doSkill?: (name: string, body: string) => Promise<string>;
+    doSessions?: () => Promise<string>;
+    doRename?: (name: string) => Promise<string>;
+    doCompact?: () => Promise<string>;
+  },
+) => string | void | Promise<string | void>;
+
+const registry = new Map<string, CommandInfo>();
+const handlers = new Map<string, CommandHandler>();
+
+export function register(
+  name: string,
+  description: string,
+  handler: CommandHandler,
+  opts?: { delegate?: boolean; template?: string; isSkill?: boolean },
+) {
+  registry.set(name, { name, description, delegate: opts?.delegate, template: opts?.template });
+  handlers.set(name, handler);
+}
+
+export function getCommand(name: string): CommandInfo | undefined {
+  return registry.get(name);
+}
+
+export function listCommands(): CommandInfo[] {
+  return [...registry.values()];
+}
+
+/** Comandi che matchano un filtro (nome o descrizione). Usato da CLI + autocomplete. */
+export function matchCommands(filter: string): CommandInfo[] {
+  const f = filter.toLowerCase();
+  return listCommands().filter(
+    (c) => c.name.includes(f) || c.description.toLowerCase().includes(f),
+  );
+}
+
+export async function dispatch(
+  input: string,
+  ctx: Parameters<CommandHandler>[1],
+): Promise<string | null> {
+  const match = input.match(/^\/(\w+)(?:\s+(.*))?$/);
+  if (!match) return null;
+
+  const name = match[1]!;
+  const args = match[2] ?? "";
+
+  const handler = handlers.get(name);
+  if (!handler) return `Unknown command: /${name}. Type /help for available commands.`;
+
+  const result = await handler(args, ctx);
+  return result ?? null;
+}
+
+export function isSlashCommand(input: string): boolean {
+  return /^\//.test(input);
+}
+
+register("help", "Show available commands", () => {
+  const lines = ["Available commands:"];
+  for (const cmd of listCommands()) {
+    lines.push(`  /${cmd.name.padEnd(8)} ${cmd.description}`);
+  }
+  return lines.join("\n");
+});
+
+register("clear", "Clear conversation history", (_args, ctx) => {
+  ctx.clearMessages?.();
+  return "Conversation cleared.";
+});
+
+register("plan", "Switch to Plan mode (read-only)", (_args, ctx) => {
+  ctx.setMode?.("plan");
+  return "Switched to Plan mode (read-only).";
+});
+
+register("build", "Switch to Build mode (full access)", (_args, ctx) => {
+  ctx.setMode?.("build");
+  return "Switched to Build mode (full access).";
+});
+
+register(
+  "init",
+  "Generate or update AGENTS.md for this project",
+  (_args, ctx) => ctx.doInit?.(_args) ?? "Init command requires agent context.",
+  { delegate: true },
+);
+
+register("model", "Change the model (usage: /model <model-id>)", (args, _ctx) => {
+  if (!args.trim()) return `Usage: /model <model-id>\nCurrent model: ${currentModel()}`;
+  setModel(args.trim());
+  return `Model set to '${args.trim()}'. Effective on next turn.`;
+});
+
+register(
+  "thinking",
+  "Set reasoning/thinking level for the current model (usage: /thinking <level>)",
+  (args) => {
+    const p = currentProvider();
+    const levels = p.thinkingLevels;
+    const arg = args.trim().toLowerCase();
+    if (!arg) {
+      return (
+        `Thinking: ${currentThinking()} · model: ${p.label}\n` +
+        `Available levels: ${levels.join(", ")}\n` +
+        `Usage: /thinking <level>`
+      );
+    }
+    if (!levels.includes(arg as ThinkingLevel)) {
+      return `Invalid level '${arg}' for ${p.label}. Available: ${levels.join(", ")}`;
+    }
+    setThinking(arg as ThinkingLevel);
+    return `Thinking set to '${arg}' (effective next turn).`;
+  },
+);
+
+register("undo", "Undo last file modifications", async () => {
+  const files = await undo();
+  if (files.length > 0) return `Undo: restored ${files.join(", ")}`;
+  return "Nothing to undo.";
+});
+
+register("redo", "Redo previously undone file modifications", async () => {
+  const files = await redo();
+  if (files.length > 0) return `Redo: restored ${files.join(", ")}`;
+  return "Nothing to redo.";
+});
+
+register("compact", "Compact conversation context to save tokens", (args, ctx) => {
+  if (ctx.doCompact) return ctx.doCompact();
+  return "Compaction will run at the end of this turn if context is > 90% full.";
+});
+
+register("provider", "Manage connected AI providers and API keys", () => {
+  return "Opening provider settings...";
+});
+
+register("sessions", "List and resume previous sessions", (_args, ctx) => {
+  if (ctx.doSessions) return ctx.doSessions();
+  return "Session list not available in this context.";
+});
+
+register("rename", "Rename the current session (usage: /rename <new-name>)", (args, ctx) => {
+  if (!args.trim()) return "Usage: /rename <new-name>";
+  if (ctx.doRename) return ctx.doRename(args.trim());
+  return `Session would be renamed to '${args.trim()}'.`;
+});
+
+export async function initSkillCommands(): Promise<void> {
+  const skills = getCachedRegistry();
+  for (const skill of skills) {
+    register(
+      skill.name,
+      skill.description,
+      async (args, ctx) => {
+        const body = await loadSkillBody(skill.name);
+        if (!body) return `Skill '${skill.name}' not found.`;
+        if (ctx.doSkill) {
+          return ctx.doSkill(skill.name, body);
+        }
+        return `Skill '${skill.name}' loaded.`;
+      },
+      { delegate: true, isSkill: true },
+    );
+  }
+}