@kabmo-labs/kabmo 0.0.0-stage → 0.0.1

package/src/server/lib/omp/config/scope.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The discovery scope a skills/commands read is answered for.
+ *
+ * omp resolves project-scope skills and commands from the process cwd: a child
+ * started in a workspace reports that workspace's `.omp/skills`,
+ * `.omp/commands`, `.claude/commands`, `.agents/*` and `.github/*` entries,
+ * while a child started elsewhere reports only the user-level ones. So the
+ * scope is never a filter applied after the fact — it is which directory omp
+ * is asked about, and which roots a write may land in.
+ *
+ * Verified against omp 18.4.0:
+ * - `omp skill list <repo>` reports `native:project` entries (`pr-review`,
+ *   `issue-intake` in this repository) that `omp skill list ~/.omp/agent` does
+ *   not, and both report the `native:user`/`agents:user` ones.
+ * - `get_available_commands` in a workspace reports its `.omp/commands` files
+ *   (`projprobe`) plus the user-level ones (`userprobe`, `~/.claude/commands`),
+ *   while a child in `~/.omp/agent` reports only the latter — and a child in
+ *   `$HOME` reports neither the workspace's nor `~/.omp/agent/commands`, which
+ *   is why the USER scope has a cwd of its own instead of "no cwd".
+ * - A duplicate name in both roots resolves to the PROJECT file (measured:
+ *   `dupe.md` in `~/.omp/agent/commands` and the workspace ran the project
+ *   body), which is why a managed-file lookup checks the workspace first.
+ *
+ * `resolveRoot` gates a client-supplied path (the app root, a path beneath it,
+ * or an exact registered `project_path`). The user scope bypasses it because
+ * its cwd is server-derived, never client-supplied, and an unresolvable root
+ * falls back to the user scope rather than answering with a directory the
+ * caller never asked about.
+ */
+
+import { getAgentDir } from '@/server/lib/omp/core/paths';
+import { resolveRoot } from '@/server/lib/fs/root';
+
+export interface DiscoveryScope {
+  /** Workspace root a write/delete may target, or null for the user scope. */
+  workspace: string | null;
+  /** The cwd omp is asked about: the workspace, the agent dir (user scope),
+   *  or the app root for an unscoped read. */
+  cwd: string;
+}
+
+/**
+ * Resolve the `?root=` / `?scope=` a skills/commands request carries.
+ *
+ * - `scope=user` → the user scope: the agent dir as cwd, no workspace.
+ * - `root=<path>` → that workspace (gated by `resolveRoot`).
+ * - neither → the app root, which is what an unscoped request has always meant
+ *   (the composer's fallback for a session with no workspace folder, where omp
+ *   itself spawns in the server's cwd). It stays a workspace because the app
+ *   root is a registered root Kabmo may write in.
+ */
+export async function resolveDiscoveryScope(
+  rawRoot: string | null | undefined,
+  rawScope?: string | null,
+): Promise<DiscoveryScope> {
+  if (rawScope === 'user') return { workspace: null, cwd: getAgentDir() };
+  if (!rawRoot || !rawRoot.trim()) return { workspace: process.cwd(), cwd: process.cwd() };
+  const resolved = await resolveRoot(rawRoot, '');
+  return resolved ? { workspace: resolved, cwd: resolved } : { workspace: null, cwd: getAgentDir() };
+}

package/src/server/lib/omp/config/skills-catalog.ts

@@ -0,0 +1,127 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Skills.sh catalog bridge — real search via https://skills.sh/api/search and
+ * install via `bunx skills add <package>` (same surfaces ompweb uses).
+ * Search failures degrade to an empty list so the catalog tab still renders.
+ */
+
+import { isMockMode } from '@/server/mock.server';
+import type { CatalogSkillItem } from '@/shared/types';
+import { childEnv } from '@/server/lib/fs/child-env';
+
+const SEARCH_API_BASE = Bun.env.SKILLS_API_URL || 'https://skills.sh';
+const SEARCH_TIMEOUT_MS = 15_000;
+const INSTALL_TIMEOUT_MS = 180_000;
+
+export interface CatalogSearchResult {
+  package: string;
+  name: string;
+  source: string;
+  installs: number;
+}
+
+/** Search the skills.sh catalog; returns [] on any failure. */
+export async function searchSkillCatalog(query: string, limit = 24): Promise<CatalogSearchResult[]> {
+  if (isMockMode()) return [];
+  const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=${Math.min(50, Math.max(1, limit))}`;
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS) });
+    if (!response.ok) return [];
+    const data = (await response.json()) as { skills?: Array<{ id?: string; name?: string; source?: string; installs?: number }> };
+    return (data.skills ?? [])
+      .filter((skill) => typeof skill.id === 'string' && skill.id.length > 0)
+      .map((skill) => ({
+        package: skill.id as string,
+        name: typeof skill.name === 'string' ? skill.name : (skill.id as string),
+        source: typeof skill.source === 'string' ? skill.source : '',
+        installs: typeof skill.installs === 'number' ? skill.installs : 0,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+/** Map catalog search results into the CatalogSkillItem contract of the UI.
+ * instructions carries the package name so a later install POST can resolve
+ * it back to a skills.sh package without extra component fields. */
+export function toCatalogSkills(results: CatalogSearchResult[], sourceId: string): CatalogSkillItem[] {
+  return results.map((result) => ({
+    id: `catalog-${result.package}`,
+    sourceId,
+    name: result.name,
+    description: result.source ? `From ${result.source}` : '',
+    repoTag: result.package,
+    githubUrl: result.source ? `https://github.com/${result.source}` : undefined,
+    instructions: result.package,
+  }));
+}
+
+async function runBunxSkills(args: string[]): Promise<string> {
+  const proc = Bun.spawn({
+    env: childEnv(),
+    cmd: ['bunx', 'skills', ...args],
+    stdout: 'pipe',
+    stderr: 'pipe',
+    timeout: INSTALL_TIMEOUT_MS,
+    maxBuffer: 4 * 1024 * 1024,
+    windowsHide: true,
+  });
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) throw new Error(stderr.trim() || `bunx skills ${args[0]} exited with code ${exitCode}`);
+  return stdout;
+}
+
+/**
+ * Install a catalog skill into the omp agent skill root.
+ *
+ * `--skill` is what keeps the install scoped to the entry the user clicked:
+ * the catalog lists individual skills, and a repository can hold twenty of
+ * them, so an unscoped `skills add <repo>` installs every skill in the repo
+ * (measured: 20 directories landed for one "Install" on a single-skill row).
+ * `--agent universal` writes to `~/.agents/skills`, which is the root omp's
+ * `agents` provider reads.
+ */
+export async function installCatalogSkill(pkg: string, skillName?: string | null): Promise<{ output: string }> {
+  if (!/^[\w.\-]+\/[\w.\-@:]+$/.test(pkg)) throw new Error('Invalid skill package');
+  if (isMockMode()) throw new Error('Skill install is unavailable in mock mode');
+  const name = skillName?.trim();
+  if (name && !/^[\w.\-]+$/.test(name)) throw new Error('Invalid skill name');
+  const output = await runBunxSkills([
+    'add',
+    pkg,
+    '--agent',
+    'universal',
+    ...(name ? ['--skill', name] : []),
+    '-g',
+    '-y',
+  ]);
+  return { output: output.slice(-4000) };
+}
+
+/**
+ * Uninstall a catalog skill by name. `skills remove` is the counterpart of the
+ * `skills add` above and clears the symlink/copy the install created, which is
+ * what a catalog "Uninstall" has to undo — deleting the entry from Kabmo's
+ * own store would leave the skill running in omp.
+ */
+export async function uninstallCatalogSkill(name: string): Promise<{ output: string }> {
+  if (!/^[\w.\-@/]+$/.test(name)) throw new Error('Invalid skill name');
+  if (isMockMode()) throw new Error('Skill uninstall is unavailable in mock mode');
+  const output = await runBunxSkills(['remove', name, '-g', '-y']);
+  return { output: output.slice(-4000) };
+}
+
+/** Check for updates on an installed catalog skill. */
+export async function checkCatalogSkillUpdate(pkg: string): Promise<{ output: string }> {
+  if (!/^[\w.\-]+\/[\w.\-@:]+$/.test(pkg)) throw new Error('Invalid skill package');
+  const output = await runBunxSkills(['check', pkg]);
+  return { output: output.slice(-4000) };
+}

package/src/server/lib/omp/config/skills.test.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Chamber-managed SKILL.md authoring: which root a scope writes into, what a
+ * move between roots leaves behind, and what a save does to the file body.
+ *
+ * The move is the case worth locking: a rename or a user⇄project move once left
+ * the source directory in place, so one skill existed twice and omp could load
+ * whichever it walked into first. A save is the other: the body is read back
+ * with the frontmatter's blank separator removed and written with trailing
+ * whitespace trimmed, so reading and re-saving must be a no-op.
+ *
+ * `PI_CODING_AGENT_DIR` is redirected to a temp dir, so the real
+ * `~/.omp/agent/skills` is never written.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import { readSkillFile, writeSkillFile } from '@/server/lib/omp/config/skills';
+
+let projectDir = '';
+let agentDir = '';
+let realAgentDir: string | undefined;
+
+beforeAll(() => {
+  projectDir = fs.mkdtempSync(join(tmpdir(), 'kabmo-skill-project-'));
+  agentDir = fs.mkdtempSync(join(tmpdir(), 'kabmo-skill-agent-'));
+  realAgentDir = Bun.env.PI_CODING_AGENT_DIR;
+  Bun.env.PI_CODING_AGENT_DIR = agentDir;
+});
+
+afterAll(() => {
+  if (realAgentDir === undefined) delete Bun.env.PI_CODING_AGENT_DIR;
+  else Bun.env.PI_CODING_AGENT_DIR = realAgentDir;
+  fs.rmSync(projectDir, { recursive: true, force: true });
+  fs.rmSync(agentDir, { recursive: true, force: true });
+});
+
+const body = `---
+description: "a skill"
+---
+
+do the thing
+`;
+
+describe('writeSkillFile', () => {
+  test('a project write lands under the workspace .omp/skills', async () => {
+    const { filePath } = await writeSkillFile({
+      scope: 'project',
+      projectDir,
+      name: 'proj-skill',
+      description: 'a skill',
+      hidden: false,
+      body,
+    });
+    expect(filePath).toBe(join(projectDir, '.omp', 'skills', 'proj-skill', 'SKILL.md'));
+    expect(await readSkillFile(filePath)).toEqual({ description: 'a skill', body: body, hidden: false });
+  });
+
+  test('re-saving what was read does not grow the file', async () => {
+    // Written here, not taken from the case above: the file this re-saves must
+    // not depend on which case ran first.
+    const filePath = join(projectDir, '.omp', 'skills', 'proj-skill', 'SKILL.md');
+    await writeSkillFile({ scope: 'project', projectDir, name: 'proj-skill', description: 'a skill', hidden: false, body: 'the body\n' });
+    const first = fs.readFileSync(filePath, 'utf8');
+    const parsed = await readSkillFile(filePath);
+    await writeSkillFile({
+      scope: 'project',
+      projectDir,
+      name: 'proj-skill',
+      description: parsed!.description,
+      hidden: parsed!.hidden,
+      body: parsed!.body,
+    });
+    expect(fs.readFileSync(filePath, 'utf8')).toBe(first);
+  });
+
+  test('a move between scopes removes the source, leaving one skill', async () => {
+    const moved = await writeSkillFile({
+      scope: 'user',
+      projectDir,
+      previousDir: join(projectDir, '.omp', 'skills', 'proj-skill'),
+      name: 'proj-skill',
+      description: 'a skill',
+      hidden: false,
+      body,
+    });
+    expect(moved.filePath).toBe(join(agentDir, 'skills', 'proj-skill', 'SKILL.md'));
+    expect(fs.existsSync(join(projectDir, '.omp', 'skills', 'proj-skill'))).toBe(false);
+    expect(fs.existsSync(moved.filePath)).toBe(true);
+  });
+
+  test('a project write with no workspace is refused', () => {
+    expect(writeSkillFile({ scope: 'project', name: 'lost', description: 'd', hidden: false, body: 'b' }))
+      .rejects.toThrow('workspace root is required to write a project skill');
+  });
+
+  test('a name that is not a single directory is refused', () => {
+    expect(writeSkillFile({ scope: 'project', projectDir, name: '../escape', description: 'd', hidden: false, body: 'b' }))
+      .rejects.toThrow('path separator');
+  });
+});

package/src/server/lib/omp/config/skills.ts

@@ -0,0 +1,333 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Skill discovery and SKILL.md authoring for Kabmo's Skills settings.
+ *
+ * Discovery is delegated to `omp skill list <dir> --json` rather than
+ * re-implemented here. omp's own resolver is the only thing that knows every
+ * root it reads — `.omp/skills` (project walk-up), `~/.omp/agent/skills`,
+ * `.claude`, `.agents`, `.codex`, `.github`, `.opencode`, plugin packages, the
+ * skillshare store — plus the `skills.*` settings gates and the frontmatter
+ * rules (`enabled: false`, a missing `description`, `hide`). A hand-rolled scan
+ * of two directories silently disagreed with the agent: it listed skills the
+ * agent could not run and hid the ones it could (measured: 6 shown vs 9 loaded
+ * in this repository, and a catalog install into `~/.agents/skills` was
+ * invisible to Kabmo while omp ran it happily).
+ *
+ * `omp skill list` is cheap (measured 0.38-0.42s, no session, no model) and is
+ * cached per directory for a few seconds so a panel read or a settings reload
+ * does not spawn a process per request.
+ *
+ * Writing is deliberately narrow: only the two roots Kabmo owns as
+ * omp-native skills (`~/.omp/agent/skills` and `<workspace>/.omp/skills`) can
+ * be created in, edited or deleted. A skill from another provider (a Claude
+ * plugin, a registry package) is read-only here — Kabmo is not its
+ * owner, and deleting a file another tool manages is not a "delete skill".
+ */
+
+import fs from 'fs';
+import { join, resolve } from 'path';
+import { getAgentDir, pathExists } from '@/server/lib/omp/core/paths';
+import { resolveOmpBin } from '@/server/lib/omp/core/cli';
+import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+import { parseFrontmatter } from '@/server/lib/omp/config/yaml';
+import { childEnv } from '@/server/lib/fs/child-env';
+
+const MAX_SKILL_MD_BYTES = 512 * 1024;
+const SKILL_LIST_TIMEOUT_MS = 30_000;
+/** Discovery spawns a process, so a short cache absorbs the panel read and the
+ *  composer's own fetch without ever serving a stale list for long. */
+const CACHE_TTL_MS = 5_000;
+
+export interface DiscoveredSkill {
+  /** Stable id: `omp-<user|project>-<name>`. */
+  id: string;
+  name: string;
+  description: string;
+  /** omp's provider:level source, e.g. `native:user`, `agents:project`. */
+  source: string;
+  sourceRoot: 'user' | 'project';
+  filePath: string;
+  baseDir: string;
+  /** Excluded from the model's skill listing (`hide` / disableModelInvocation). */
+  hidden: boolean;
+  /** True when Kabmo owns the files and may rewrite or remove them. */
+  managed: boolean;
+}
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompSkillListCache: Map<string, { at: number; skills: DiscoveredSkill[] }> | undefined;
+}
+
+function getCache(): Map<string, { at: number; skills: DiscoveredSkill[] }> {
+  if (!globalThis.__ompSkillListCache) globalThis.__ompSkillListCache = new Map();
+  return globalThis.__ompSkillListCache;
+}
+
+/** Drop the discovery cache so the next read reflects a write just made. */
+export function invalidateSkillCache(): void {
+  getCache().clear();
+}
+
+/**
+ * The omp-native roots Kabmo may create, edit and delete in — and the
+ * only directories a `delete` may touch. A skill folder sits directly under one
+ * of these.
+ */
+export function managedSkillRoots(projectDir?: string | null): string[] {
+  const roots = [join(getAgentDir(), 'skills')];
+  if (projectDir) roots.push(join(projectDir, '.omp', 'skills'));
+  return roots;
+}
+
+/** A skill Kabmo owns: omp-native AND sitting directly under a managed
+ *  root. Everything else (a Claude plugin, a registry package) is read-only. */
+function isManagedSkill(skill: { source: string; baseDir: string }, projectDir?: string | null): boolean {
+  if (!skill.source.startsWith('native:')) return false;
+  const parent = resolve(skill.baseDir, '..');
+  return managedSkillRoots(projectDir).some((root) => resolve(root) === parent);
+}
+
+interface CliSkill {
+  name?: unknown;
+  description?: unknown;
+  filePath?: unknown;
+  baseDir?: unknown;
+  source?: unknown;
+  hide?: unknown;
+}
+
+/**
+ * Enumerate the skills an omp session in `cwd` would load, through omp itself.
+ * `projectDir` is the workspace the list is being shown for — it decides which
+ * roots count as Kabmo-managed, and is NOT the same thing as `cwd` for the
+ * user scope (whose cwd is the agent dir, which is not a workspace).
+ * Returns [] when omp is not installed or the directory is unreadable; a
+ * discovery failure must never surface as "you have no skills" being fatal.
+ */
+export async function discoverSkills(
+  cwd?: string | null,
+  projectDir?: string | null,
+): Promise<DiscoveredSkill[]> {
+  const bin = resolveOmpBin();
+  if (!bin) return [];
+
+  // A missing cwd falls back to the agent dir — the user scope — because that
+  // is the only cwd whose inventory is a real scope rather than the server's
+  // own working directory.
+  const target = cwd && (await pathExists(cwd)) ? cwd : getAgentDir();
+  const cache = getCache();
+  const cached = cache.get(target);
+  if (cached && Date.now() - cached.at < CACHE_TTL_MS) return cached.skills;
+
+  const skills = await runSkillList(bin, target, projectDir ?? null);
+  cache.set(target, { at: Date.now(), skills });
+  return skills;
+}
+
+async function runSkillList(bin: string, cwd: string, projectDir: string | null): Promise<DiscoveredSkill[]> {
+  let stdout: string;
+  try {
+    const proc = Bun.spawn({
+      env: childEnv(),
+      cmd: [bin, 'skill', 'list', cwd, '--json'],
+      stdout: 'pipe',
+      stderr: 'pipe',
+      timeout: SKILL_LIST_TIMEOUT_MS,
+      maxBuffer: 8 * 1024 * 1024,
+      windowsHide: true,
+    });
+    const [out, err] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      console.error(`omp skill list failed (${exitCode}): ${err.trim().slice(0, 400)}`);
+      return [];
+    }
+    stdout = out;
+  } catch (error) {
+    console.error(`omp skill list failed: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+
+  let parsed: { skills?: unknown };
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed.skills)) return [];
+
+  const result: DiscoveredSkill[] = [];
+  for (const raw of parsed.skills as CliSkill[]) {
+    const name = typeof raw.name === 'string' ? raw.name.trim() : '';
+    const filePath = typeof raw.filePath === 'string' ? raw.filePath : '';
+    if (!name || !filePath) continue;
+    const source = typeof raw.source === 'string' ? raw.source : 'native:user';
+    const baseDir = typeof raw.baseDir === 'string' && raw.baseDir ? raw.baseDir : resolve(filePath, '..');
+    result.push({
+      id: `omp-${source.endsWith(':project') ? 'project' : 'user'}-${name}`,
+      name,
+      description: typeof raw.description === 'string' ? raw.description : '',
+      source,
+      sourceRoot: source.endsWith(':project') ? 'project' : 'user',
+      filePath,
+      baseDir,
+      hidden: raw.hide === true,
+      managed: isManagedSkill({ source, baseDir }, projectDir),
+    });
+  }
+  return result;
+}
+
+/** Read one skill's SKILL.md, split into frontmatter data and body. */
+export async function readSkillFile(
+  filePath: string,
+): Promise<{ description: string; body: string; hidden: boolean } | null> {
+  try {
+    const file = Bun.file(filePath);
+    if (!(await file.exists()) || (await file.stat()).size > MAX_SKILL_MD_BYTES) return null;
+    const text = await file.text();
+    const { data, body } = parseFrontmatter(text);
+    return {
+      description: data.description ?? '',
+      body: body.replace(/^\r?\n/, ''),
+      hidden: data.disableModelInvocation === 'true' || data.hide === 'true',
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** A skill name that is safe as a single directory component. */
+function assertSafeName(name: string): string {
+  const trimmed = name.trim();
+  if (!trimmed) throw new Error('Skill name is required');
+  if (/[\\/]/.test(trimmed) || trimmed === '.' || trimmed === '..') {
+    throw new Error('Skill name may not contain a path separator');
+  }
+  return trimmed;
+}
+
+/** Serialize a SKILL.md from its parts. `description` is mandatory for omp to
+ *  load the skill at all, so it is always written as a frontmatter field. */
+function serializeSkillMd(input: { name: string; description: string; hidden: boolean; body: string }): string {
+  const lines = ['---', `name: ${JSON.stringify(input.name)}`, `description: ${JSON.stringify(input.description)}`];
+  if (input.hidden) lines.push('disableModelInvocation: true');
+  lines.push('---', '', input.body.replace(/\r\n/g, '\n').replace(/\s*$/, ''), '');
+  return lines.join('\n');
+}
+
+export interface WriteSkillInput {
+  /** Target root: `user` writes to the agent dir, `project` to the workspace. */
+  scope: 'user' | 'project';
+  /** Workspace root, required for `project`. */
+  projectDir?: string | null;
+  /** Base directory of the skill being edited, when it already exists. */
+  previousDir?: string | null;
+  name: string;
+  description: string;
+  hidden: boolean;
+  body: string;
+}
+
+/** Create or overwrite a Kabmo-managed SKILL.md. Refuses a scope it cannot
+ *  own (a project write with no workspace) rather than writing somewhere else. */
+export async function writeSkillFile(input: WriteSkillInput): Promise<{ filePath: string }> {
+  const name = assertSafeName(input.name);
+  if (input.scope === 'project' && !input.projectDir) {
+    throw new Error('A workspace root is required to write a project skill');
+  }
+  const root = input.scope === 'project' ? join(input.projectDir!, '.omp', 'skills') : join(getAgentDir(), 'skills');
+
+  const dir = join(root, name);
+  const filePath = join(dir, 'SKILL.md');
+
+  // A rename or a scope move is a move: the old directory must not linger as a
+  // second skill. It is removed only when it is a DIFFERENT directory inside a
+  // managed root, so an edit in place never deletes the file just written and a
+  // move across scopes cleans up the source.
+  const previous = input.previousDir?.trim();
+  if (previous) {
+    const oldDir = resolve(previous);
+    if (oldDir !== resolve(dir)) {
+      const parent = resolve(oldDir, '..');
+      if (managedSkillRoots(input.projectDir).some((candidate) => resolve(candidate) === parent)) {
+        if (await pathExists(oldDir)) await fs.promises.rm(oldDir, { recursive: true, force: true });
+      }
+    }
+  }
+
+  await fs.promises.mkdir(dir, { recursive: true });
+  await writeFileAtomic(
+    filePath,
+    serializeSkillMd({ name, description: input.description, hidden: input.hidden, body: input.body }),
+    { createMode: 0o644 },
+  );
+  invalidateSkillCache();
+  return { filePath };
+}
+
+/**
+ * Delete a Kabmo-managed skill directory. Refused unless the target is an
+ * omp-native skill sitting directly under a managed root, so a delete can never
+ * reach a skill another tool installed.
+ */
+export async function deleteSkillDir(id: string, projectDir?: string | null): Promise<boolean> {
+  // A user-scope delete (no workspace) is discovered from the agent dir, which
+  // is also the only managed root that applies there.
+  const found = (await discoverSkills(projectDir ?? getAgentDir(), projectDir)).find((skill) => skill.id === id);
+  if (!found) return false;
+  if (!found.managed) throw new Error(`"${found.name}" is managed by ${found.source}; Kabmo cannot delete it`);
+
+  const dir = resolve(found.baseDir);
+  const parent = resolve(dir, '..');
+  if (!managedSkillRoots(projectDir).some((root) => resolve(root) === parent)) {
+    throw new Error(`Refusing to delete outside the managed skill roots: ${dir}`);
+  }
+  if (!(await pathExists(dir))) return false;
+  await fs.promises.rm(dir, { recursive: true, force: true });
+  invalidateSkillCache();
+  return true;
+}
+
+/**
+ * Atomically toggle `disableModelInvocation` in a SKILL.md frontmatter —
+ * read-modify-write via temp+rename, preserving the rest of the file. The
+ * skill stays loadable through `skill://` and `/skill:<name>`; it only drops
+ * out of the model's `<skills>` listing.
+ */
+export async function setSkillModelInvocation(filePath: string, disable: boolean): Promise<boolean> {
+  try {
+    const file = Bun.file(filePath);
+    if (!(await file.exists()) || (await file.stat()).size > MAX_SKILL_MD_BYTES) return false;
+    const text = await file.text();
+    const flag = `disableModelInvocation: ${disable}`;
+    let next: string;
+    if (/^---\r?\n[\s\S]*?\r?\n---/.test(text)) {
+      if (/^disableModelInvocation:/m.test(text)) {
+        next = text.replace(/^disableModelInvocation:.*$/m, flag);
+      } else {
+        // Insert before the closing --- of the frontmatter.
+        next = text.replace(/^---\r?\n([\s\S]*?)\r?\n---/, (full, front) => {
+          void full;
+          return `---\n${front}\n${flag}\n---`;
+        });
+      }
+    } else {
+      next = `---\n${flag}\n---\n\n${text}`;
+    }
+    if (next === text) return false;
+    await writeFileAtomic(filePath, next);
+    invalidateSkillCache();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/server/lib/omp/config/yaml.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Shared YAML/config helpers for the native OMP config files: the canonical
+ * `~/.omp/agent/config.yml` path, a top-level-mapping assertion, and the minimal
+ * frontmatter parser used by agent and skill markdown files.
+ */
+
+import { join } from 'path';
+import { getAgentDir } from '@/server/lib/omp/core/paths';
+import { isRecord } from '@/shared/lib/util/guards';
+
+/** Native OMP user config path: ~/.omp/agent/config.yml. */
+export function getOmpConfigPath(): string {
+  return join(getAgentDir(), 'config.yml');
+}
+
+/** Parses a YAML file that must be a top-level mapping; throws otherwise. */
+export function asMapping(parsed: unknown, path: string): Record<string, unknown> {
+  if (!isRecord(parsed)) throw new Error(`${path} must contain a YAML mapping`);
+  return parsed;
+}
+
+/**
+ * Minimal YAML frontmatter (---\nkey: value\n---) parser for agent/skill files.
+ * Only top-level keys belong to the map; indented lines are nested block
+ * content (e.g. an `output:` JSON schema) and must not override top-level keys.
+ */
+export function parseFrontmatter(text: string): { data: Record<string, string>; body: string } {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+  if (!match) return { data: {}, body: text };
+  const data: Record<string, string> = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    if (/^\s/.test(line)) continue;
+    const idx = line.indexOf(':');
+    if (idx <= 0) continue;
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (key) data[key] = value;
+  }
+  return { data, body: text.slice(match[0].length) };
+}