@agentprojectcontext/apx 1.33.0 → 1.34.0

package/src/host/daemon/routines-scheduler.js

@@ -0,0 +1,64 @@
+// Polling timer that fires due routines. Process-state — needs the daemon
+// alive, has no business being in core/. Delegates the actual work to
+// core/routines/runner.js so CLI / HTTP / web / mcp-server / scripts can
+// invoke the same runner without depending on this file.
+import { getDueRoutines } from "#core/stores/routines.js";
+import { runRoutineNow } from "#core/routines/runner.js";
+import { nowIso } from "#core/util/time.js";
+
+const TICK_MS = 5_000;
+
+export class RoutineScheduler {
+  constructor({ projects, plugins, registries, globalConfig, log }) {
+    this.projects = projects;
+    this.plugins = plugins;
+    this.registries = registries;
+    this.globalConfig = globalConfig;
+    this.log = log || (() => {});
+    this._timer = null;
+    this._running = false;
+  }
+
+  start() {
+    if (this._timer) return;
+    this._timer = setInterval(
+      () => this._tick().catch((e) => this.log(`routines tick error: ${e.message}`)),
+      TICK_MS
+    );
+    this._timer.unref?.();
+  }
+
+  stop() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+
+  async _tick() {
+    if (this._running) return;
+    this._running = true;
+    try {
+      const nowStr = nowIso();
+      for (const proj of this.projects.list().map((p) => this.projects.get(p.id))) {
+        if (!proj) continue;
+        const due = getDueRoutines(proj.storagePath, nowStr);
+        for (const r of due) {
+          this.log(`routine ${r.name} (${r.kind}) firing in project #${proj.id}`);
+          await runRoutineNow(
+            {
+              project: proj,
+              projects: this.projects,
+              plugins: this.plugins,
+              registries: this.registries,
+              globalConfig: this.globalConfig,
+            },
+            r
+          );
+        }
+      }
+    } finally {
+      this._running = false;
+    }
+  }
+}

package/src/host/daemon/smoke.js

@@ -9,6 +9,7 @@ import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { ProjectManager } from "./db.js";
 import { McpRegistry } from "#core/mcp/runner.js";
+import { agentsMdFile, apcProjectFile } from "#core/apc/paths.js";
 import { readAgents } from "#core/apc/parser.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -23,8 +24,8 @@ const EXAMPLE_CANDIDATES = [
   path.resolve(__dirname, "..", "..", "..", "..", "apc", "examples", "my-first-project"),
 ];
 const EXAMPLE = EXAMPLE_CANDIDATES.find((p) =>
-  fs.existsSync(path.join(p, "AGENTS.md")) &&
-  fs.existsSync(path.join(p, ".apc", "project.json"))
+  fs.existsSync(agentsMdFile(p)) &&
+  fs.existsSync(apcProjectFile(p))
 );
 
 function assert(cond, msg) {

package/src/host/daemon/whisper-server.js

@@ -0,0 +1,225 @@
+// Subprocess lifecycle for the persistent whisper-server.py.
+//
+// Owns:
+//   - the Python child process (spawn, health-watch, kill on shutdown)
+//   - port collision recovery (kill an orphan listener and retry)
+//   - daemon-boot preload + warmup + graceful teardown
+//
+// Does NOT do the actual transcription — that's an HTTP call to localhost
+// and lives in core/voice/transcription.js. The port number is the single
+// piece of shared state and is exported from core; this file imports it.
+import { spawn, exec } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  WHISPER_LOCAL_PORT,
+  DEFAULT_LOCAL,
+  getConfig,
+} from "#core/voice/transcription.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const WHISPER_SERVER = path.join(__dirname, "whisper-server.py");
+
+let _serverProcess = null;
+let _serverModel = null;
+
+function _sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function _isServerHealthy() {
+  try {
+    const res = await fetch(`http://127.0.0.1:${WHISPER_LOCAL_PORT}/health`, {
+      signal: AbortSignal.timeout(800),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function _serverModelName() {
+  try {
+    const res = await fetch(`http://127.0.0.1:${WHISPER_LOCAL_PORT}/health`, {
+      signal: AbortSignal.timeout(800),
+    });
+    if (!res.ok) return null;
+    const j = await res.json();
+    return j?.model || null;
+  } catch {
+    return null;
+  }
+}
+
+async function _findListenerPid() {
+  return new Promise((resolve) => {
+    exec(`lsof -ti tcp:${WHISPER_LOCAL_PORT} -sTCP:LISTEN`, (err, stdout) => {
+      if (err || !stdout) return resolve(null);
+      const candidates = stdout.trim().split("\n")
+        .map(s => parseInt(s, 10))
+        .filter(n => Number.isFinite(n) && n !== process.pid);
+      resolve(candidates[0] || null);
+    });
+  });
+}
+
+async function _killOrphanWhisper() {
+  try {
+    await fetch(`http://127.0.0.1:${WHISPER_LOCAL_PORT}/shutdown`, {
+      method: "POST", signal: AbortSignal.timeout(1000),
+    });
+    await _sleep(600);
+  } catch {}
+  const pid = await _findListenerPid();
+  if (pid && pid !== process.pid) {
+    try { process.kill(pid, "SIGTERM"); } catch {}
+    await _sleep(400);
+    try { process.kill(pid, 0); try { process.kill(pid, "SIGKILL"); } catch {} } catch {}
+    await _sleep(300);
+  }
+}
+
+export async function ensureWhisperServer(opts) {
+  const model = opts.model || DEFAULT_LOCAL.model;
+
+  if (_serverProcess && _serverModel === model) {
+    if (await _isServerHealthy()) return;
+    _serverProcess = null;
+    _serverModel = null;
+  }
+
+  if (!_serverProcess) {
+    const existing = await _serverModelName();
+    if (existing === model) {
+      _serverModel = model;
+      return;
+    }
+    if (existing) {
+      await _killOrphanWhisper();
+    }
+  }
+
+  if (_serverProcess) {
+    try { _serverProcess.kill(); } catch {}
+    _serverProcess = null;
+    _serverModel = null;
+    await _sleep(300);
+  }
+
+  await _spawnWhisper(opts, model, /* retried */ false);
+}
+
+async function _spawnWhisper(opts, model, retried) {
+  const args = [
+    WHISPER_SERVER,
+    "--port", String(WHISPER_LOCAL_PORT),
+    "--model", model,
+    "--device", String(opts.device || DEFAULT_LOCAL.device),
+    "--compute-type", String(opts.compute_type || DEFAULT_LOCAL.compute_type),
+    "--idle-minutes", String(opts.idle_minutes ?? DEFAULT_LOCAL.idle_minutes),
+  ];
+
+  const proc = spawn("python3", args, {
+    stdio: ["ignore", "pipe", "inherit"],
+    detached: false,
+  });
+
+  _serverProcess = proc;
+  _serverModel = model;
+
+  proc.on("exit", () => {
+    if (_serverProcess === proc) {
+      _serverProcess = null;
+      _serverModel = null;
+    }
+  });
+
+  try {
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error("whisper-server startup timed out (15s)")),
+        15_000
+      );
+      let buf = "";
+      proc.stdout.on("data", (chunk) => {
+        buf += chunk.toString();
+        const nl = buf.indexOf("\n");
+        if (nl === -1) return;
+        const line = buf.slice(0, nl).trim();
+        buf = buf.slice(nl + 1);
+        clearTimeout(timeout);
+        try {
+          const msg = JSON.parse(line);
+          if (msg.status === "error") return reject(new Error(msg.error || "whisper-server error"));
+          resolve();
+        } catch {
+          resolve();
+        }
+      });
+      proc.on("exit", (code) => {
+        clearTimeout(timeout);
+        reject(new Error(`whisper-server exited (code ${code}) before becoming ready`));
+      });
+    });
+  } catch (e) {
+    const msg = e.message || "";
+    if (!retried && /address already in use|errno 48|eaddrinuse/i.test(msg)) {
+      _serverProcess = null;
+      _serverModel = null;
+      await _killOrphanWhisper();
+      return _spawnWhisper(opts, model, /* retried */ true);
+    }
+    throw e;
+  }
+}
+
+export async function preloadWhisperServer(log = console.log) {
+  try {
+    const cfg = await getConfig();
+    if (cfg.provider === "openai") return;
+    log(`whisper: preloading model "${cfg.local.model}" on port ${WHISPER_LOCAL_PORT}…`);
+    await ensureWhisperServer(cfg.local);
+    log(`whisper: ready on port ${WHISPER_LOCAL_PORT} (model: ${_serverModel})`);
+  } catch (e) {
+    log(`whisper: preload failed — ${e.message} (will retry lazily on first request)`);
+  }
+}
+
+export async function warmupWhisper() {
+  try {
+    const cfg = await getConfig();
+    if (cfg.provider === "openai") return { ok: true, provider: "openai", loaded: false };
+    await ensureWhisperServer(cfg.local);
+    let loaded = false;
+    try {
+      const r = await fetch(`http://127.0.0.1:${WHISPER_LOCAL_PORT}/warmup`, {
+        signal: AbortSignal.timeout(40_000),
+      });
+      const j = await r.json().catch(() => ({}));
+      loaded = !!j.loaded;
+    } catch {}
+    return { ok: true, provider: "local", model: _serverModel, loaded };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+export async function shutdownWhisperServer() {
+  if (_serverProcess) {
+    try { _serverProcess.kill(); } catch {}
+    _serverProcess = null;
+    _serverModel = null;
+  } else {
+    try {
+      await fetch(`http://127.0.0.1:${WHISPER_LOCAL_PORT}/shutdown`, {
+        method: "POST", signal: AbortSignal.timeout(500),
+      });
+    } catch {}
+  }
+}
+
+export const WHISPER_PATHS = {
+  whisper_server: WHISPER_SERVER,
+  port: WHISPER_LOCAL_PORT,
+};

package/src/interfaces/cli/commands/agent.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { findApfRoot, readAgents, readVaultAgents, readVaultAgent, VAULT_DIR, SLUG_RE } from "#core/apc/parser.js";
+import { apcAgentFile } from "#core/apc/paths.js";
 import { writeAgentFile, writeVaultAgentFile, removeVaultAgent, restoreVaultAgent, addImportedAgent, ensureAgentDir } from "#core/apc/scaffold.js";
 import { ensureAgentRuntimeDir, agentMemoryPath } from "#core/agent/memory.js";
 import { http } from "../http.js";
@@ -194,7 +195,7 @@ export async function cmdAgentImport(args) {
     throw new Error(`"${slug}" not found in vault. Available: ${available}`);
   }
 
-  const alreadyLocal = fs.existsSync(path.join(root, ".apc", "agents", `${slug}.md`));
+  const alreadyLocal = fs.existsSync(apcAgentFile(root, slug));
   if (alreadyLocal && !args.flags.force) {
     console.log(dim(`  "${slug}" already has a local definition. Use --force to overwrite.`));
     return;
@@ -202,7 +203,7 @@ export async function cmdAgentImport(args) {
 
   if (args.flags.copy) {
     // Copy .md into project so user can edit locally
-    fs.copyFileSync(vaultPath, path.join(root, ".apc", "agents", `${slug}.md`));
+    fs.copyFileSync(vaultPath, apcAgentFile(root, slug));
     console.log(`\n  ${bold(slug)} copied from vault to project (now local)\n`);
   } else {
     // Just register as imported — reads from vault at runtime

package/src/interfaces/cli/commands/command.js

@@ -2,12 +2,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { findApfRoot } from "#core/apc/parser.js";
+import { apcCommandsDir } from "#core/apc/paths.js";
 import { http } from "../http.js";
 import { resolveProjectId } from "./project.js";
 
-function commandsDir(root) {
-  return path.join(root, ".apc", "commands");
-}
+const commandsDir = apcCommandsDir;
 
 function listCommandFiles(root) {
   const dir = commandsDir(root);

package/src/interfaces/cli/commands/messages.js

@@ -1,9 +1,13 @@
 import { http } from "../http.js";
 import { resolveProjectId } from "./project.js";
+import { CHANNELS } from "#core/constants/channels.js";
 
 // Channels that live in ~/.apx/messages/<channel>/ (global, cross-project).
 // Everything else is project-scoped.
-const GLOBAL_CHANNELS = new Set(["telegram", "direct", "whatsapp"]);
+// DIRECT and WHATSAPP are still placeholders (no plugin lives behind them
+// yet) but they're real channel ids — when those plugins land, message
+// lookup already routes them as project-less / global.
+const GLOBAL_CHANNELS = new Set([CHANNELS.TELEGRAM, CHANNELS.DIRECT, CHANNELS.WHATSAPP]);
 
 function isGlobalChannel(channel) {
   return channel && GLOBAL_CHANNELS.has(channel);
@@ -71,7 +75,7 @@ function printChatRows(rows) {
 }
 
 export async function cmdMessagesChat(args) {
-  const channel = args.flags.channel && args.flags.channel !== true ? args.flags.channel : "telegram";
+  const channel = args.flags.channel && args.flags.channel !== true ? args.flags.channel : CHANNELS.TELEGRAM;
   const n = args.flags.n || args.flags.last || "50";
   const isGlobal = args.flags.global || isGlobalChannel(channel);
 

package/src/interfaces/cli/commands/pair.js

@@ -8,6 +8,7 @@
 import os from "node:os";
 import qrcode from "qrcode-terminal";
 import { http } from "../http.js";
+import { CHANNELS } from "#core/constants/channels.js";
 
 const c = {
   reset:  "\x1b[0m",
@@ -88,10 +89,10 @@ async function runPairing(args, channel) {
   // 2. QR payload differs per channel — no mixing.
   //    deck: JSON {v,url,pid,fp} that the Deck app parses.
   //    web : the scan-to-login URL the browser understands.
-  const qrData = channel === "web"
+  const qrData = channel === CHANNELS.WEB
     ? webLink
     : JSON.stringify({ v: 1, url: baseUrl, pid: init.pairing_id, fp: init.fingerprint });
-  const title = channel === "web" ? "APX pairing (web)" : "APX pairing (deck)";
+  const title = channel === CHANNELS.WEB ? "APX pairing (web)" : "APX pairing (deck)";
 
   console.log("");
   console.log(`  ${fmt.bold(title)}  ${fmt.gray("·")}  ${fmt.dim(`expires in ${ttlSec}s`)}`);
@@ -100,7 +101,7 @@ async function runPairing(args, channel) {
     console.log(qr);
   });
 
-  if (channel === "web") {
+  if (channel === CHANNELS.WEB) {
     console.log(`  ${fmt.gray("scan with the phone camera — opens the web already linked")}`);
     console.log(`  ${fmt.gray("link:")} ${fmt.cyan(webLink)}`);
     console.log(`  ${fmt.gray("code:")} ${fmt.bold(init.pairing_id)}  ${fmt.dim("(or paste it in the web pairing screen)")}`);
@@ -111,7 +112,7 @@ async function runPairing(args, channel) {
   console.log("");
 
   // 3. Poll /pair/status until confirmed or expired.
-  const reRun = channel === "web" ? "apx pair web" : "apx pair";
+  const reRun = channel === CHANNELS.WEB ? "apx pair web" : "apx pair";
   const deadline = Date.now() + (init.ttl_ms || 90_000) + 5_000;
   while (Date.now() < deadline) {
     await sleep(1500);

package/src/interfaces/cli/commands/search.js

@@ -3,7 +3,7 @@
 // Uses the daemon's tools/search.js module directly (no HTTP roundtrip,
 // no need to have `apx daemon start` running).
 
-import { webSearch } from "#core/tools/search.js";
+import { webSearch } from "#core/http-tools/search.js";
 
 const DIM   = "\x1b[2m";
 const BOLD  = "\x1b[1m";

package/src/interfaces/cli/commands/sessions.js

@@ -5,6 +5,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { apcProjectFile } from "#core/apc/paths.js";
 
 // ── shared helpers ───────────────────────────────────────────────────────────
 
@@ -124,7 +125,7 @@ function readApxProjects(opts) {
       const proj = { path: path.resolve(e.path), name: null, apxId: null };
       try {
         const pj = JSON.parse(
-          fs.readFileSync(path.join(proj.path, ".apc", "project.json"), "utf8")
+          fs.readFileSync(apcProjectFile(proj.path), "utf8")
         );
         if (pj.name) proj.name = pj.name;
         if (pj.apx_id) proj.apxId = pj.apx_id;
@@ -608,7 +609,7 @@ const apxEngine = {
     let apxId = null;
     try {
       const pj = JSON.parse(
-        fs.readFileSync(path.join(dir, ".apc", "project.json"), "utf8")
+        fs.readFileSync(apcProjectFile(dir), "utf8")
       );
       apxId = pj.apx_id || null;
     } catch {}

package/src/interfaces/cli/commands/skills.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import os from "node:os";
 import readline from "node:readline";
 import { findApfRoot } from "#core/apc/parser.js";
+import { apcSkillsDir } from "#core/apc/paths.js";
 import { http } from "../http.js";
 import {
   IDE_TARGETS,
@@ -11,6 +12,8 @@ import {
   installGlobalSkills,
   listBundledSkillSlugs,
   listBundledSkills,
+  listEngineSkills,
+  listLegacyPruneSlugs,
 } from "#core/apc/scaffold.js";
 
 // ---------------------------------------------------------------------------
@@ -100,37 +103,27 @@ export async function cmdSkillsAdd(args) {
 // ---------------------------------------------------------------------------
 
 export async function cmdSkillsSync(args) {
-  const includeOptional = !!args?.flags?.["include-optional"] || !!args?.flags?.optional;
-  const includeInternal = !!args?.flags?.["include-internal"] || !!args?.flags?.internal;
   const prune = args?.flags?.["no-prune"] ? false : true;
 
-  const results = installGlobalSkills({ includeOptional, includeInternal, prune });
+  const results = installGlobalSkills({ prune });
   const home = os.homedir();
 
-  // Group by skill so the output is dense and scannable.
   const bySkill = {};
-  const scopeOf = {};
   for (const r of results) {
     if (!bySkill[r.skill]) bySkill[r.skill] = [];
-    bySkill[r.skill].push({ dir: r.dir.replace(home, "~"), status: r.status });
-    scopeOf[r.skill] = r.scope;
+    bySkill[r.skill].push({ dir: r.dir.replace(home, "~"), status: r.status, scope: r.scope });
   }
 
-  const slugs = Object.keys(bySkill).sort();
-  if (slugs.length === 0) {
-    console.log("(no bundled skills found in skills/)");
+  const engineSet = listEngineSkills().map((s) => s.slug);
+  if (engineSet.length === 0) {
+    console.log("(no engine skills found in skills/engines/)");
     return;
   }
 
-  const filters = [];
-  if (includeOptional) filters.push("+optional");
-  if (includeInternal) filters.push("+internal");
-  console.log(
-    `Syncing ${slugs.length} bundled skill(s) to global skill dirs` +
-      (filters.length ? ` [${filters.join(" ")}]` : "") + ":\n"
-  );
+  console.log(`Syncing engine skill set (${engineSet.join(", ")}) to global dirs:\n`);
 
-  const sw = Math.max(...slugs.map((s) => s.length));
+  const slugs = Object.keys(bySkill).sort();
+  const sw = Math.max(...slugs.map((s) => s.length), 8);
   const totals = { unchanged: 0, updated: 0, created: 0, pruned: 0 };
   for (const slug of slugs) {
     const entries = bySkill[slug];
@@ -141,9 +134,8 @@ export async function cmdSkillsSync(args) {
     for (const k of ["created", "updated", "unchanged", "pruned"]) {
       if (counts[k]) parts.push(`${counts[k]} ${k}`);
     }
-    const scope = scopeOf[slug];
-    const tag = scope === "public" ? "" : ` [${scope}]`;
-    console.log(`  ${slug.padEnd(sw)}${tag.padEnd(11)}  ${parts.join(", ")}`);
+    const tag = entries[0]?.scope === "legacy" ? " [legacy]" : "";
+    console.log(`  ${slug.padEnd(sw)}${tag.padEnd(10)}  ${parts.join(", ")}`);
   }
   console.log("");
   console.log(`Targets: .claude/skills, .cursor/skills, .codex/skills, .agents/skills`);
@@ -153,21 +145,6 @@ export async function cmdSkillsSync(args) {
   }
   console.log(`Totals:  ${totalParts.join(", ") || "(no changes)"}`);
 
-  // Hint about non-default tiers.
-  const skipped = listBundledSkills().filter(
-    (s) =>
-      (s.scope === "internal" && !includeInternal) ||
-      (s.scope === "optional" && !includeOptional)
-  );
-  if (skipped.length > 0) {
-    console.log("");
-    console.log("Skipped (not pushed by default):");
-    for (const s of skipped) console.log(`  ${s.slug.padEnd(sw)}  scope=${s.scope}`);
-    console.log("");
-    console.log("Re-run with --include-optional / --include-internal to push them too,");
-    console.log("or `apx skills add <slug> --global` for one-off install.");
-  }
-
   if (args?.flags?.verbose) {
     console.log("");
     for (const slug of slugs) {
@@ -184,8 +161,8 @@ export async function cmdSkillsSync(args) {
 // ---------------------------------------------------------------------------
 
 export async function cmdSkillsList(args = {}) {
-  // --all queries the daemon, which returns project + global + bundled +
-  // runtime-skills (same catalog the super-agent sees and the web picker uses).
+  // --all queries the daemon, which returns project + global + bundled
+  // (the same catalog the super-agent sees and the web picker uses).
   // Without --all we only list `.apc/skills/` (what the user installed in
   // THIS project), matching the historical behaviour.
   if (args?.flags?.all) {
@@ -205,7 +182,7 @@ export async function cmdSkillsList(args = {}) {
   }
 
   const root = findApfRoot();
-  const skillsDir = root ? path.join(root, ".apc", "skills") : null;
+  const skillsDir = root ? apcSkillsDir(root) : null;
   const files = skillsDir && fs.existsSync(skillsDir)
     ? fs.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))
     : [];
@@ -224,17 +201,15 @@ export async function cmdSkillsList(args = {}) {
 export async function cmdSkillsStatus() {
   const root = findApfRoot();
 
-  // Global — discovered list of every bundled skill with its scope.
-  const bundled = listBundledSkills();
-  const byScope = {
-    public: bundled.filter((s) => s.scope === "public"),
-    optional: bundled.filter((s) => s.scope === "optional"),
-    internal: bundled.filter((s) => s.scope === "internal"),
-  };
+  const engineSet = listEngineSkills();        // what we publish to engines
+  const bundled = listBundledSkills();          // what stays in-repo for the super-agent
+  const legacy = listLegacyPruneSlugs();        // slugs APX shipped historically — pruned on sync
+
   console.log(
-    `Bundled skills: ${bundled.length} total (${byScope.public.length} public, ` +
-      `${byScope.optional.length} optional, ${byScope.internal.length} internal)`
+    `Engine skill set (replicated to global dirs): ${engineSet.length} ` +
+      `(${engineSet.map((s) => s.slug).join(", ") || "—"})`
   );
+  console.log(`In-repo bundled skills (super-agent only): ${bundled.length}`);
   console.log("");
   console.log(`Global skill dirs:`);
   const GLOBAL_DIRS = [
@@ -243,17 +218,23 @@ export async function cmdSkillsStatus() {
     { label: "Codex",                       dir: path.join(os.homedir(), ".codex",  "skills") },
     { label: "Antigravity / others",        dir: path.join(os.homedir(), ".agents", "skills") },
   ];
-  const sw = Math.max(...bundled.map((s) => s.slug.length));
+  const allSlugs = [...engineSet.map((s) => s.slug), ...legacy];
+  const sw = Math.max(...allSlugs.map((s) => s.length), 8);
   for (const { label, dir } of GLOBAL_DIRS) {
     console.log(`\n  ${label} — ${dir.replace(os.homedir(), "~")}`);
-    for (const { slug, scope } of bundled) {
+    for (const { slug } of engineSet) {
       const dest = path.join(dir, slug, "SKILL.md");
       const present = fs.existsSync(dest);
-      const tag = scope === "public" ? "" : ` [${scope}]`;
-      const state = present
-        ? "✓ installed"
-        : (scope === "public" ? "✗ MISSING (run `apx skills sync`)" : "—");
-      console.log(`    ${slug.padEnd(sw)}${tag.padEnd(11)}  ${state}`);
+      const state = present ? "✓ installed" : "✗ MISSING (run `apx skills sync`)";
+      console.log(`    ${slug.padEnd(sw)}             ${state}`);
+    }
+    const stale = legacy.filter((slug) =>
+      fs.existsSync(path.join(dir, slug, "SKILL.md"))
+    );
+    if (stale.length) {
+      for (const slug of stale) {
+        console.log(`    ${slug.padEnd(sw)} [legacy]    ⚠ stale (run \`apx skills sync\` to prune)`);
+      }
     }
   }