niahere 0.2.62 → 0.2.64

package/src/commands/backup.ts

@@ -49,6 +49,7 @@ export async function createBackup(silent = false): Promise<string> {
   if (existsSync(join(home, "self"))) includes.push("self");
   if (existsSync(join(home, "agents"))) includes.push("agents");
   if (existsSync(join(home, "skills"))) includes.push("skills");
+  if (existsSync(join(home, "employees"))) includes.push("employees");
 
   // Database dump
   const config = getConfig();
@@ -65,10 +66,7 @@ export async function createBackup(silent = false): Promise<string> {
     if (url.port) pgArgs.push("-p", url.port);
     if (url.username) pgArgs.push("-U", decodeURIComponent(url.username));
     if (dbName) pgArgs.push("-d", dbName);
-    const pgEnv: Record<string, string> = { ...process.env } as Record<
-      string,
-      string
-    >;
+    const pgEnv: Record<string, string> = { ...process.env } as Record<string, string>;
     if (url.password) pgEnv.PGPASSWORD = decodeURIComponent(url.password);
     const sslmode = url.searchParams.get("sslmode");
     if (sslmode) pgEnv.PGSSLMODE = sslmode;
@@ -87,9 +85,7 @@ export async function createBackup(silent = false): Promise<string> {
       dbDumped = true;
     } else if (!silent) {
       const stderr = await new Response(pg.stderr).text();
-      console.log(
-        `  ⚠ db dump skipped: ${stderr.trim() || `exit ${exitCode}`}`,
-      );
+      console.log(`  ⚠ db dump skipped: ${stderr.trim() || `exit ${exitCode}`}`);
     }
   }
 

package/src/core/agents.ts

@@ -34,7 +34,8 @@ export function scanAgents(): AgentInfo[] {
   for (const { dir, source } of getAgentDirs()) {
     if (!existsSync(dir)) continue;
 
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
 
       const agentFile = join(dir, entry.name, "AGENT.md");
@@ -48,14 +49,10 @@ export function scanAgents(): AgentInfo[] {
       try {
         meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
       } catch (err) {
-        log.warn(
-          { err, agent: entry.name, path: agentFile },
-          "failed to parse agent metadata, skipping",
-        );
+        log.warn({ err, agent: entry.name, path: agentFile }, "failed to parse agent metadata, skipping");
         continue;
       }
-      const name =
-        (typeof meta.name === "string" ? meta.name : "") || entry.name;
+      const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
 
       const key = name.toLowerCase();
       if (seen.has(key)) continue;
@@ -65,8 +62,7 @@ export function scanAgents(): AgentInfo[] {
 
       agents.push({
         name,
-        description:
-          typeof meta.description === "string" ? meta.description : "",
+        description: typeof meta.description === "string" ? meta.description : "",
         body,
         model: typeof meta.model === "string" ? meta.model : undefined,
         source,
@@ -80,21 +76,13 @@ export function scanAgents(): AgentInfo[] {
 export function getAgentsSummary(): string {
   const agents = scanAgents();
   if (agents.length === 0) return "";
-  const lines = agents.map((a) =>
-    a.description ? `- @${a.name}: ${a.description}` : `- @${a.name}`,
-  );
+  const lines = agents.map((a) => (a.description ? `- @${a.name}: ${a.description}` : `- @${a.name}`));
   return `Available agents:\n${lines.join("\n")}`;
 }
 
-export function getAgentDefinitions(): Record<
-  string,
-  { description: string; prompt: string; model?: string }
-> {
+export function getAgentDefinitions(): Record<string, { description: string; prompt: string; model?: string }> {
   const agents = scanAgents();
-  const defs: Record<
-    string,
-    { description: string; prompt: string; model?: string }
-  > = {};
+  const defs: Record<string, { description: string; prompt: string; model?: string }> = {};
 
   for (const agent of agents) {
     defs[agent.name] = {

package/src/core/consolidator.ts

@@ -1,27 +1,13 @@
 /**
- * Memory consolidator — stage 1 of a two-stage memory architecture.
+ * Memory consolidator — stage 1 of the two-stage memory pipeline.
  *
- * After a chat session goes idle, this module reflects on the transcript
- * and writes CANDIDATE memories to ~/.niahere/self/staging.md. It never
- * writes directly to memory.md or rules.md — the nightly memory-promoter
- * job handles promotion once candidates are reinforced (count >= 2) and
- * pass durability review.
+ * After a chat session goes idle, reflects on the transcript and appends
+ * CANDIDATE memories to ~/.niahere/self/staging.md. The nightly
+ * memory-promoter job handles promotion from staging to memory.md/rules.md.
+ * The write-path restriction is enforced by the consolidator prompt, not
+ * by tool sandboxing.
  *
- * Architecture:
- *   chat idle → consolidator → staging.md (candidate log, TTL 14d)
- *                                    ↓  nightly promoter (3am)
- *                                    ↓  - count >= 2 required
- *                                    ↓  - durability review
- *                              memory.md / rules.md
- *
- * Jobs do NOT flow through this path — job-local learnings live in each
- * job's state.md (see runner.ts:buildWorkingMemory). Routing job output
- * into global persona memory caused layer violations (transient incidents
- * promoted to durable facts).
- *
- * The consolidator uses the same agent loop as cron jobs — full Nia system
- * prompt, full tool access. The write-path restriction is enforced by the
- * prompt (the agent is told to only edit staging.md), not by tool sandboxing.
+ * See AGENTS.md > "Two-stage memory" for the full architecture.
  */
 
 import { Message } from "../db/models";
@@ -138,12 +124,16 @@ Report a one-line summary of what you did: "staged N new / reinforced M /
 skipped (trivial session)". No preamble.`;
 }
 
-/** Run the consolidation agent loop. */
 async function runConsolidation(transcript: string, source: string): Promise<void> {
-  await runTask({
+  const output = await runTask({
     name: "consolidator",
     prompt: buildConsolidationPrompt(transcript, source),
   });
+  // runTask returns {error} on failure instead of throwing; escalate so
+  // consolidateSession doesn't mark the session processed on a failed run.
+  if (output.error) {
+    throw new Error(`consolidator task failed: ${output.error}`);
+  }
 }
 
 /**
@@ -178,12 +168,8 @@ export async function consolidateSession(sessionId: string, room: string): Promi
     }
   } catch (err) {
     log.error({ err, sessionId, room }, "consolidator: chat extraction failed");
+    throw err;
   } finally {
     inFlight.delete(sessionId);
   }
 }
-
-// Job runs no longer flow through the global memory consolidator. Each job
-// maintains its own working memory in state.md (see buildWorkingMemory() in
-// runner.ts). This separation prevents transient job-local incidents from
-// being promoted to durable persona memory.

package/src/core/daemon.ts

@@ -1,9 +1,10 @@
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from "fs";
 import { dirname, resolve as pathResolve } from "path";
 import { fileURLToPath } from "url";
 import { getPaths } from "../utils/paths";
 import { getConfig, resetConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { isRunning, readPid, removePid, writePid } from "../utils/pid";
 import { ActiveEngine, Job } from "../db/models";
 import { runMigrations } from "../db/migrate";
 import { closeDb, getSql } from "../db/connection";
@@ -15,45 +16,7 @@ import { createNiaMcpServer } from "../mcp/server";
 import { setMcpFactory } from "../mcp";
 import { processPending, cleanupOldRequests } from "./finalizer";
 
-export function writePid(pid: number): void {
-  const { pid: pidPath } = getPaths();
-  mkdirSync(dirname(pidPath), { recursive: true });
-  writeFileSync(pidPath, String(pid));
-}
-
-export function readPid(): number | null {
-  const { pid: pidPath } = getPaths();
-  if (!existsSync(pidPath)) return null;
-
-  try {
-    return parseInt(readFileSync(pidPath, "utf8").trim(), 10);
-  } catch {
-    return null;
-  }
-}
-
-export function removePid(): void {
-  const { pid: pidPath } = getPaths();
-  try {
-    unlinkSync(pidPath);
-  } catch {
-    // Already gone
-  }
-}
-
-export function isRunning(): boolean {
-  const pid = readPid();
-  if (pid === null) return false;
-
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    log.warn({ stalePid: pid }, "removing stale pid file (process not running)");
-    removePid();
-    return false;
-  }
-}
+export { isRunning, readPid, removePid, writePid };
 
 export function startDaemon(): number {
   const { daemonLog } = getPaths();
@@ -125,7 +88,7 @@ function waitForExit(timeoutMs: number): void {
 /** Return PIDs of running daemon processes (excluding ourselves). */
 export function findDaemonPids(): number[] {
   try {
-    const result = Bun.spawnSync(["pgrep", "-f", "src/cli\\.ts run$"]);
+    const result = Bun.spawnSync(["pgrep", "-f", "src/cli/index\\.ts run$"]);
     const stdout = new TextDecoder().decode(result.stdout).trim();
     if (!stdout) return [];
     return stdout

package/src/core/employees.ts

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import yaml from "js-yaml";
+import { getNiaHome } from "../utils/paths";
+import { log } from "../utils/log";
+import type { EmployeeInfo } from "../types/employee";
+
+function getEmployeesDir(): string {
+  return join(getNiaHome(), "employees");
+}
+
+export function scanEmployees(): EmployeeInfo[] {
+  const employees: EmployeeInfo[] = [];
+  const dir = getEmployeesDir();
+  if (!existsSync(dir)) return employees;
+
+  const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+
+    const empFile = join(dir, entry.name, "EMPLOYEE.md");
+    if (!existsSync(empFile)) continue;
+
+    const content = readFileSync(empFile, "utf8");
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) continue;
+
+    let meta: Record<string, unknown> = {};
+    try {
+      meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
+    } catch (err) {
+      log.warn({ err, employee: entry.name, path: empFile }, "failed to parse employee metadata, skipping");
+      continue;
+    }
+
+    const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
+    const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
+
+    employees.push({
+      name,
+      dirName: entry.name,
+      project: typeof meta.project === "string" ? meta.project : "",
+      repo: typeof meta.repo === "string" ? meta.repo : "",
+      role: typeof meta.role === "string" ? meta.role : "Employee",
+      model: typeof meta.model === "string" ? meta.model : undefined,
+      status:
+        meta.status === "onboarding" || meta.status === "active" || meta.status === "paused"
+          ? meta.status
+          : "onboarding",
+      maxSubEmployees: typeof meta.maxSubEmployees === "number" ? meta.maxSubEmployees : 3,
+      body,
+      created: typeof meta.created === "string" ? meta.created : new Date().toISOString().slice(0, 10),
+      parent: typeof meta.parent === "string" ? meta.parent : undefined,
+      source: "nia",
+    });
+  }
+
+  return employees;
+}
+
+export function getEmployee(name: string): EmployeeInfo | undefined {
+  return scanEmployees().find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+
+export function getEmployeeDir(name: string): string {
+  // Look up actual directory — name in frontmatter may differ from dir name
+  const emp = scanEmployees().find((e) => e.name.toLowerCase() === name.toLowerCase());
+  if (emp) return join(getEmployeesDir(), emp.dirName);
+  // Fallback for new employees being created (not yet on disk)
+  return join(getEmployeesDir(), name);
+}
+
+export function getEmployeesSummary(): string {
+  const employees = scanEmployees();
+  if (employees.length === 0) return "";
+  const lines = employees.map((e) => `- @${e.name}: ${e.role} — ${e.project || "(no project)"} [${e.status}]`);
+  return `Available employees:\n${lines.join("\n")}`;
+}
+
+export function listEmployeesForMcp(): string {
+  const employees = scanEmployees();
+  if (employees.length === 0) return "No employees found.";
+  return JSON.stringify(
+    employees.map((e) => ({
+      name: e.name,
+      role: e.role,
+      project: e.project,
+      repo: e.repo,
+      status: e.status,
+      model: e.model,
+    })),
+    null,
+    2,
+  );
+}
+
+/** Injected into employee prompt only when status=onboarding. */
+export const ONBOARDING_INSTRUCTIONS = `## Onboarding
+
+You are in onboarding status. Be proactive — don't wait for the user to drive. You're a co-founder getting up to speed, not an assistant being briefed.
+
+IMPORTANT: One thing at a time. Each message should focus on ONE step. Don't dump all steps on the user at once. Move to the next step only after the current one is resolved.
+
+During the brief, don't just record — challenge. Ask follow-up questions. If the vision sounds vague, say so. If the goals are unrealistic, push back. If something sounds like it matters more than what the user is focused on, flag it.
+
+### Steps (do these in order, one per message)
+1. **Identity** — If your name is a placeholder (starts with "new-employee"), suggest 3-4 real names and ask the user to pick. Update the name field in your EMPLOYEE.md frontmatter. Do NOT rename the directory — the system resolves it from frontmatter.
+2. **Project & Repo** — If project or repo are empty, ask what you'll be working on. Get the repo path. Update your EMPLOYEE.md.
+3. **Brief** — Ask the user about the project: goals, what's working, what's not, their vision. Save to onboarding/brief.md.
+4. **Self-Discovery** — Explore the repo autonomously. Read code, README, recent commits, deployment config. Save findings to onboarding/discovery.md. Report back to user for corrections.
+5. **Initial Plan** — Propose top 3-5 priorities with first actions for each. Save to onboarding/plan.md. Get user approval.
+
+After all steps are done, update your EMPLOYEE.md status from "onboarding" to "active".
+
+Skip any step where the info is already filled in.`;

package/src/core/finalizer.ts

@@ -78,15 +78,32 @@ async function processOne(sessionId: string, room: string, messageCount: number)
   const requestId = claimed[0].id;
 
   try {
-    await Promise.allSettled([consolidateSession(sessionId, room), summarizeSession(sessionId, room)]);
+    const [consolidateResult, summarizeResult] = await Promise.allSettled([
+      consolidateSession(sessionId, room),
+      summarizeSession(sessionId, room),
+    ]);
+
+    const errors: string[] = [];
+    if (consolidateResult.status === "rejected") {
+      errors.push(`consolidate: ${formatRejection(consolidateResult.reason)}`);
+    }
+    if (summarizeResult.status === "rejected") {
+      errors.push(`summarize: ${formatRejection(summarizeResult.reason)}`);
+    }
+
+    const finalStatus = errors.length === 0 ? "done" : "failed";
 
     await sql`
       UPDATE finalization_requests
-      SET status = 'done', updated_at = NOW()
+      SET status = ${finalStatus}, updated_at = NOW()
       WHERE id = ${requestId}
     `;
 
-    log.info({ sessionId, room, messageCount }, "finalizer: completed");
+    if (errors.length === 0) {
+      log.info({ sessionId, room, messageCount }, "finalizer: completed");
+    } else {
+      log.error({ sessionId, room, messageCount, errors }, "finalizer: completed with task failures");
+    }
   } catch (err) {
     await sql`
       UPDATE finalization_requests
@@ -98,6 +115,17 @@ async function processOne(sessionId: string, room: string, messageCount: number)
   }
 }
 
+/** Normalize a Promise rejection reason into a loggable string. */
+function formatRejection(reason: unknown): string {
+  if (reason instanceof Error) return reason.message;
+  if (typeof reason === "string") return reason;
+  try {
+    return JSON.stringify(reason);
+  } catch {
+    return String(reason);
+  }
+}
+
 /** Drain all pending finalization requests. Called by daemon on startup and on NOTIFY. */
 export async function processPending(): Promise<void> {
   const sql = getSql();

package/src/core/health.ts

@@ -2,7 +2,7 @@ import { existsSync, statSync } from "fs";
 import { join } from "path";
 import { getConfig, readRawConfig } from "../utils/config";
 import { getPaths } from "../utils/paths";
-import { isRunning, readPid } from "./daemon";
+import { isRunning, readPid } from "../utils/pid";
 import { errMsg } from "../utils/errors";
 import { localTime } from "../utils/time";
 import { withRetry } from "../utils/retry";
@@ -123,11 +123,7 @@ export async function runHealthChecks(): Promise<Check[]> {
           }),
         );
         const data = (await resp.json()) as { ok: boolean; error?: string };
-        results.push(
-          data.ok
-            ? "slack: connected"
-            : `slack: ${data.error || "auth failed"}`,
-        );
+        results.push(data.ok ? "slack: connected" : `slack: ${data.error || "auth failed"}`);
         if (!data.ok)
           checks.push({
             name: "slack",
@@ -159,10 +155,7 @@ export async function runHealthChecks(): Promise<Check[]> {
   // API keys
   const geminiKey = config.gemini_api_key;
   const rawConfig = readRawConfig();
-  const openaiKey =
-    typeof rawConfig.openai_api_key === "string"
-      ? rawConfig.openai_api_key
-      : null;
+  const openaiKey = typeof rawConfig.openai_api_key === "string" ? rawConfig.openai_api_key : null;
   const apiKeys: string[] = [];
   if (geminiKey) apiKeys.push("gemini");
   if (openaiKey) apiKeys.push("openai");
@@ -174,16 +167,11 @@ export async function runHealthChecks(): Promise<Check[]> {
 
   // Persona files
   const personaFiles = ["identity.md", "owner.md", "soul.md"];
-  const missing = personaFiles.filter(
-    (f) => !existsSync(join(paths.selfDir, f)),
-  );
+  const missing = personaFiles.filter((f) => !existsSync(join(paths.selfDir, f)));
   checks.push({
     name: "persona",
     status: missing.length === 0 ? "ok" : "warn",
-    detail:
-      missing.length === 0
-        ? "all files present"
-        : "missing: " + missing.join(", "),
+    detail: missing.length === 0 ? "all files present" : "missing: " + missing.join(", "),
   });
 
   // Daemon log

package/src/core/runner.ts

@@ -8,6 +8,8 @@ import { appendAudit, readState, writeState } from "../utils/logger";
 import type { AuditEntry, JobState } from "../types";
 import { getConfig } from "../utils/config";
 import { buildSystemPrompt } from "../chat/identity";
+import { buildEmployeePrompt } from "../chat/employee-prompt";
+import { getEmployee } from "./employees";
 import { scanAgents } from "./agents";
 import { truncate, formatToolUse } from "../utils/format-activity";
 import { getMcpServers } from "../mcp";
@@ -300,13 +302,23 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
   writeState(state);
 
   try {
-    const cwd = homedir();
+    let cwd = homedir();
     let output: RunnerOutput;
 
-    // Resolve system prompt: use agent body if job references an agent, else default
+    // Resolve system prompt: employee > agent > default
     let systemPrompt: string;
     let agentModel: string | undefined;
-    if (job.agent) {
+    if (job.employee) {
+      const empPrompt = buildEmployeePrompt(job.employee);
+      if (empPrompt) {
+        systemPrompt = empPrompt;
+      } else {
+        systemPrompt = buildSystemPrompt("job");
+      }
+      const emp = getEmployee(job.employee);
+      if (emp?.model) agentModel = emp.model;
+      if (emp?.repo && existsSync(emp.repo)) cwd = emp.repo;
+    } else if (job.agent) {
       const agents = scanAgents();
       const agentDef = agents.find((a) => a.name === job.agent);
       if (agentDef) {
@@ -372,12 +384,6 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     };
     writeState(freshState);
 
-    // Job-local learnings live in state.md (injected into the next run's
-    // prompt), not in global self/memory.md. The global memory consolidator
-    // only processes chat sessions — routing job output through it created
-    // layer violations (transient incidents promoted to durable memory).
-    // See src/core/consolidator.ts and AGENTS.md memory architecture notes.
-
     return result;
   } catch (err) {
     const duration_ms = Math.round(performance.now() - startMs);

package/src/core/scheduler.ts

@@ -1,50 +1,10 @@
-import { CronExpressionParser } from "cron-parser";
-import { parseDuration } from "../utils/duration";
-import type { ScheduleType } from "../types";
 import { Job } from "../db/models";
 import { runJob } from "./runner";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { computeInitialNextRun, computeNextRun } from "../utils/schedule";
 
-export function computeNextRun(
-  scheduleType: ScheduleType,
-  schedule: string,
-  timezone: string,
-  lastRunAt?: Date,
-): Date | null {
-  switch (scheduleType) {
-    case "cron": {
-      const expr = CronExpressionParser.parse(schedule, { tz: timezone });
-      return expr.next().toDate();
-    }
-    case "interval": {
-      const ms = parseDuration(schedule);
-      const base = lastRunAt || new Date();
-      return new Date(base.getTime() + ms);
-    }
-    case "once":
-      return null;
-  }
-}
-
-export function computeInitialNextRun(
-  scheduleType: ScheduleType,
-  schedule: string,
-  timezone: string,
-): Date {
-  switch (scheduleType) {
-    case "cron": {
-      const expr = CronExpressionParser.parse(schedule, { tz: timezone });
-      return expr.next().toDate();
-    }
-    case "interval": {
-      const ms = parseDuration(schedule);
-      return new Date(Date.now() + ms);
-    }
-    case "once":
-      return new Date(schedule);
-  }
-}
+export { computeInitialNextRun, computeNextRun };
 
 function isWithinActiveHours(): boolean {
   const config = getConfig();
@@ -96,13 +56,16 @@ async function tick(): Promise<void> {
     log.info({ job: job.name, type: job.scheduleType }, "scheduler: running job");
     runningJobs.add(job.name);
 
-    runJob(job).then((result) => {
-      log.info({ job: job.name, status: result.status, duration: result.duration_ms }, "scheduler: job completed");
-    }).catch((err) => {
-      log.error({ err, job: job.name }, "scheduler: job failed");
-    }).finally(() => {
-      runningJobs.delete(job.name);
-    });
+    runJob(job)
+      .then((result) => {
+        log.info({ job: job.name, status: result.status, duration: result.duration_ms }, "scheduler: job completed");
+      })
+      .catch((err) => {
+        log.error({ err, job: job.name }, "scheduler: job failed");
+      })
+      .finally(() => {
+        runningJobs.delete(job.name);
+      });
 
     let nextRun: Date | null = null;
     try {

package/src/core/skills.ts

@@ -26,7 +26,8 @@ export function scanSkills(): SkillInfo[] {
   for (const { dir, source } of SKILL_DIRS) {
     if (!existsSync(dir)) continue;
 
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
 
       const skillFile = join(dir, entry.name, "SKILL.md");
@@ -40,14 +41,10 @@ export function scanSkills(): SkillInfo[] {
       try {
         meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
       } catch (err) {
-        log.warn(
-          { err, skill: entry.name, path: skillFile },
-          "failed to parse skill metadata, skipping",
-        );
+        log.warn({ err, skill: entry.name, path: skillFile }, "failed to parse skill metadata, skipping");
         continue;
       }
-      const name =
-        (typeof meta.name === "string" ? meta.name : "") || entry.name;
+      const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
 
       const key = name.toLowerCase();
       if (seen.has(key)) continue;
@@ -55,8 +52,7 @@ export function scanSkills(): SkillInfo[] {
 
       skills.push({
         name,
-        description:
-          typeof meta.description === "string" ? meta.description : "",
+        description: typeof meta.description === "string" ? meta.description : "",
         source,
       });
     }
@@ -72,8 +68,6 @@ export function getSkillNames(): string[] {
 export function getSkillsSummary(): string {
   const skills = scanSkills();
   if (skills.length === 0) return "";
-  const lines = skills.map((s) =>
-    s.description ? `- /${s.name}: ${s.description}` : `- /${s.name}`,
-  );
+  const lines = skills.map((s) => (s.description ? `- /${s.name}: ${s.description}` : `- /${s.name}`));
   return `Available skills:\n${lines.join("\n")}`;
 }