@agentprojectcontext/apx 1.33.1 → 1.35.0

package/src/core/apc/context-copy.js

@@ -0,0 +1,27 @@
+// Snapshot a project's read-aloud context — AGENTS.md + .apc/memory.md —
+// into a single labelled markdown string. Used by /deck/context/copy and
+// (potentially) any other "give me the context" surface.
+import fs from "node:fs/promises";
+import { AGENTS_MD, apcMemoryFile } from "./paths.js";
+import path from "node:path";
+
+const CONTEXT_FILES = [
+  { rel: AGENTS_MD,              label: AGENTS_MD },
+  { rel: `.apc/${"memory.md"}`,  label: ".apc/memory.md", abs: (root) => apcMemoryFile(root) },
+];
+
+export async function readProjectContext(projectPath) {
+  const chunks = [];
+  for (const entry of CONTEXT_FILES) {
+    const abs = entry.abs ? entry.abs(projectPath) : path.join(projectPath, entry.rel);
+    try {
+      const content = await fs.readFile(abs, "utf8");
+      if (content.trim()) {
+        chunks.push(`# ${entry.label}\n\n${content.trim()}\n`);
+      }
+    } catch {
+      // missing file is fine; we just skip it.
+    }
+  }
+  return chunks.join("\n---\n\n");
+}

package/src/core/apc/notes.js

@@ -0,0 +1,19 @@
+// Append-only project notes under .apc/notes/YYYY-MM-DD.md. Each note is a
+// timestamped markdown block; the file is append-only so no UID management
+// is required.
+import fs from "node:fs/promises";
+import path from "node:path";
+import { apcNotesDir } from "./paths.js";
+
+export async function appendProjectNote(projectPath, { title, body }) {
+  const notesDir = apcNotesDir(projectPath);
+  await fs.mkdir(notesDir, { recursive: true });
+  const today = new Date().toISOString().slice(0, 10);
+  const file = path.join(notesDir, `${today}.md`);
+  const ts = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+  const block = title
+    ? `\n## ${title}\n_${ts}_\n\n${body}\n`
+    : `\n### ${ts}\n\n${body}\n`;
+  await fs.appendFile(file, block, "utf8");
+  return file;
+}

package/src/core/apc/parser.js

@@ -1,6 +1,13 @@
 // Core parsers for APC — pure ESM, no deps.
 import fs from "node:fs";
 import path from "node:path";
+import {
+  apcAgentsDir,
+  apcAgentFile,
+  apcProjectFile,
+  agentsMdFile,
+  isApcProject,
+} from "./paths.js";
 
 export const SLUG_RE = /^[a-z][a-z0-9_-]*$/;
 const H1_RE = /^#\s+Agents\s*$/i;
@@ -91,7 +98,7 @@ export function parseAgentFile(slug, text) {
 
 // Read all .apc/agents/<slug>.md files. Returns [] if none exist.
 export function readAgentsFromDir(root) {
-  const dir = path.join(root, ".apc", "agents");
+  const dir = apcAgentsDir(root);
   if (!fs.existsSync(dir)) return [];
   return fs
     .readdirSync(dir)
@@ -189,7 +196,7 @@ function readVaultAgent(slug, { includeRemoved = false } = {}) {
 
 // Resolve a single agent for a project: local file → vault (layered) → null.
 export function resolveAgent(root, slug) {
-  const localPath = path.join(root, ".apc", "agents", `${slug}.md`);
+  const localPath = apcAgentFile(root, slug);
   if (fs.existsSync(localPath)) {
     const agent = parseAgentFile(slug, fs.readFileSync(localPath, "utf8"));
     return { ...agent, source: "local" };
@@ -203,7 +210,7 @@ export { readVaultAgent };
 
 // Return slugs imported from vault in this project (from project.json)
 export function importedVaultSlugs(root) {
-  const p = path.join(root, ".apc", "project.json");
+  const p = apcProjectFile(root);
   if (!fs.existsSync(p)) return [];
   try {
     const cfg = JSON.parse(fs.readFileSync(p, "utf8"));
@@ -235,7 +242,7 @@ export function readAgents(root) {
   const all = [...fromFiles, ...vaultAgents];
   const allSlugs = new Set(all.map((a) => a.slug));
 
-  const agentsMdPath = path.join(root, "AGENTS.md");
+  const agentsMdPath = agentsMdFile(root);
   if (!fs.existsSync(agentsMdPath)) return all;
 
   const mdText = fs.readFileSync(agentsMdPath, "utf8");
@@ -255,7 +262,7 @@ export function readAgents(root) {
 export function findApfRoot(start = process.cwd()) {
   let cur = path.resolve(start);
   while (true) {
-    if (fs.existsSync(path.join(cur, ".apc", "project.json"))) return cur;
+    if (isApcProject(cur)) return cur;
     const parent = path.dirname(cur);
     if (parent === cur) return null;
     cur = parent;

package/src/core/apc/paths.js

@@ -0,0 +1,87 @@
+// Filesystem layout of an APC project. The `.apc/` folder is APX's footprint
+// inside someone else's repo — everything that the daemon writes to a
+// user-checked-out project lives here, plus the top-level AGENTS.md spec.
+//
+// Use the helpers below instead of joining the literal names yourself. A typo
+// in `".apc"` or `"project.json"` will silently create an orphan tree instead
+// of failing loud, which is exactly the bug class these constants prevent.
+import fs from "node:fs";
+import path from "node:path";
+
+// Raw names — exported for the rare caller that needs to glob/match by name.
+export const APC_DIR = ".apc";
+export const APC_PROJECT_FILE = "project.json";
+export const APC_PROJECT_CONFIG_FILE = "config.json";
+export const APC_PROJECT_MEMORY_FILE = "memory.md";
+export const APC_AGENTS_DIR = "agents";
+export const APC_SKILLS_DIR = "skills";
+export const APC_COMMANDS_DIR = "commands";
+export const APC_NOTES_DIR = "notes";
+export const APC_MCPS_FILE = "mcps.json";
+export const APC_REMOVED_FILE = ".removed.json";
+export const AGENTS_MD = "AGENTS.md";
+
+// Path builders. `root` is the project root (the directory that contains
+// `.apc/` and `AGENTS.md`).
+export function apcDir(root) {
+  return path.join(root, APC_DIR);
+}
+
+export function apcProjectFile(root) {
+  return path.join(root, APC_DIR, APC_PROJECT_FILE);
+}
+
+export function apcProjectConfigFile(root) {
+  return path.join(root, APC_DIR, APC_PROJECT_CONFIG_FILE);
+}
+
+export function apcAgentsDir(root) {
+  return path.join(root, APC_DIR, APC_AGENTS_DIR);
+}
+
+export function apcAgentFile(root, slug) {
+  return path.join(root, APC_DIR, APC_AGENTS_DIR, `${slug}.md`);
+}
+
+export function apcAgentMemoryFile(root, slug) {
+  return path.join(root, APC_DIR, APC_AGENTS_DIR, slug, "memory.md");
+}
+
+export function apcRemovedFile(root) {
+  return path.join(root, APC_DIR, APC_AGENTS_DIR, APC_REMOVED_FILE);
+}
+
+export function apcSkillsDir(root) {
+  return path.join(root, APC_DIR, APC_SKILLS_DIR);
+}
+
+export function apcSkillFile(root, slug) {
+  return path.join(root, APC_DIR, APC_SKILLS_DIR, `${slug}.md`);
+}
+
+export function apcCommandsDir(root) {
+  return path.join(root, APC_DIR, APC_COMMANDS_DIR);
+}
+
+export function apcNotesDir(root) {
+  return path.join(root, APC_DIR, APC_NOTES_DIR);
+}
+
+// Project-level memory (super-agent / project-wide), distinct from the
+// per-agent memory.md that lives under .apc/agents/<slug>/.
+export function apcMemoryFile(root) {
+  return path.join(root, APC_DIR, APC_PROJECT_MEMORY_FILE);
+}
+
+export function apcMcpsFile(root) {
+  return path.join(root, APC_DIR, APC_MCPS_FILE);
+}
+
+export function agentsMdFile(root) {
+  return path.join(root, AGENTS_MD);
+}
+
+// True when `root` looks like an initialized APC project (has the marker file).
+export function isApcProject(root) {
+  return fs.existsSync(apcProjectFile(root));
+}

package/src/core/apc/scaffold.js

@@ -11,14 +11,22 @@ import {
 } from "./parser.js";
 import { readApcContextSkill } from "./skill-sync.js";
 import { nowIso } from "../util/time.js";
+import {
+  apcDir,
+  apcProjectFile,
+  apcAgentsDir,
+  apcAgentFile,
+  agentsMdFile,
+} from "./paths.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Now under src/core/apc/ — one more "../" to escape than before.
 const PACKAGE_ROOT = path.resolve(__dirname, "..", "..", "..");
+// <packageRoot>/skills/<slug>/SKILL.md — the SLIM engine-side set: every skill
+// here is replicated verbatim into project IDE rule files (`apx skills add`) and
+// into ~/.<host>/skills/ (`apx skills sync`). The rich super-agent catalog lives
+// at src/core/runtime-skills/ and is intentionally NOT copied out.
 const BUNDLED_SKILLS_DIR = path.join(PACKAGE_ROOT, "skills");
-// runtime-skills lives at src/core/runtime-skills/, one level up from this
-// file's new home in src/core/apc/ (was a sibling before the Phase 3 move).
-const RUNTIME_SKILLS_DIR = path.join(__dirname, "..", "runtime-skills");
 
 export const SPEC_VERSION = "0.1.0";
 
@@ -28,12 +36,12 @@ export const SPEC_VERSION = "0.1.0";
 // install/update from the canonical APC repo (see src/interfaces/cli/postinstall.js).
 // ---------------------------------------------------------------------------
 
-// Bundled skills — apx lives in skills/apx/. apc-context is synced from
-// the canonical APC repo (../apc or GitHub) — never edited in APX.
+// Read one slim skill from <packageRoot>/skills/<slug>/SKILL.md. `apc-context`
+// is special-cased to refresh from the canonical APC repo if available.
 function readBundledSkill(slug) {
   if (slug === "apc-context") {
     const synced = readApcContextSkill();
-    return synced?.text || null;
+    if (synced?.text) return synced.text;
   }
   const file = path.join(BUNDLED_SKILLS_DIR, slug, "SKILL.md");
   if (!fs.existsSync(file)) return null;
@@ -134,19 +142,11 @@ const GLOBAL_SKILL_DIRS = [
   path.join(os.homedir(), ".agents", "skills"),    // Antigravity/other skills.sh adopters
 ];
 
-function readRuntimeSkillFiles() {
-  if (!fs.existsSync(RUNTIME_SKILLS_DIR)) return [];
-  return fs.readdirSync(RUNTIME_SKILLS_DIR)
-    .filter((name) => name.endsWith(".md"))
-    .sort()
-    .map((name) => ({
-      slug: path.basename(name, ".md"),
-      md: fs.readFileSync(path.join(RUNTIME_SKILLS_DIR, name), "utf8").trim(),
-    }));
-}
-
 // Install APX + APC context skills into IDE rule files. Returns an array of result objects.
 // targetIds: array of target ids to install; null = all project targets.
+// Writes the slim engine-side skill from <packageRoot>/skills/. The rich
+// super-agent set in src/core/runtime-skills/ is intentionally never written
+// into project IDE files.
 export function installIdeSkills(root, targetIds = null) {
   const apxRaw = readBundledSkill("apx");
   const apcRaw = readBundledSkill("apc-context");
@@ -197,36 +197,27 @@ export function installIdeSkills(root, targetIds = null) {
 // on the user's machine after `npm install -g .` (or `npm update -g apx`)
 // without anyone having to touch this file.
 //
-// Excluded: directory names starting with "." (e.g. .DS_Store), and any
-// runtime-only CLI skill that lives under src/core/runtime-skills/ — those
-// are loaded in-process at daemon startup and are NOT for IDE consumption.
-// Public: bundled skill slugs grouped by scope.
-//   public   → pushed to every global skill dir on install / sync (default).
-//   optional → not pushed by default; user opts in with --include-optional
-//              or `apx skills add <slug> --global` for one-off install.
-//   internal → APX-developer skills (mcp-builder, skill-builder, etc.); never
-//              pushed globally, only available to APX itself via the bundled
-//              copy. Avoids cluttering other IDEs with stuff their users won't
-//              run.
+// Excluded: directory names starting with "." (e.g. .DS_Store).
+// Every slug under <packageRoot>/skills/ is part of the slim engine set and
+// gets pushed to global dirs on `apx skills sync`. No scope filtering — the
+// dir IS the contract.
 export function listBundledSkillSlugs() {
   return discoverBundledSkills().map((s) => s.slug);
 }
 
 export function listBundledSkills() {
-  return discoverBundledSkills().map(({ slug, scope }) => ({ slug, scope }));
+  return discoverBundledSkills().map(({ slug }) => ({ slug }));
+}
+
+// Backwards-compat alias — every bundled slug here IS an engine slug now.
+export function listEngineSkills() {
+  return listBundledSkills();
 }
 
-// Tiny frontmatter peek — we only need the `scope:` field. Avoids pulling in
-// a full YAML parser for one optional line.
-function parseFrontmatterScope(md) {
-  if (!md.startsWith("---\n")) return "public";
-  const end = md.indexOf("\n---", 4);
-  if (end === -1) return "public";
-  const m = md.slice(4, end).match(/^scope:\s*(\w+)/m);
-  if (!m) return "public";
-  const s = m[1].toLowerCase();
-  if (s === "internal" || s === "optional" || s === "public") return s;
-  return "public";
+// Legacy slugs APX used to ship to global dirs but no longer does — exposed so
+// the CLI can report what `installGlobalSkills` will prune.
+export function listLegacyPruneSlugs() {
+  return [...PRUNE_LEGACY_SLUGS];
 }
 
 function discoverBundledSkills() {
@@ -239,65 +230,80 @@ function discoverBundledSkills() {
     const skillFile = path.join(root, entry.name, "SKILL.md");
     if (!fs.existsSync(skillFile)) continue;
     const md = fs.readFileSync(skillFile, "utf8");
-    out.push({ slug: entry.name, md, scope: parseFrontmatterScope(md) });
+    out.push({ slug: entry.name, md });
   }
   return out.sort((a, b) => a.slug.localeCompare(b.slug));
 }
 
-// Install bundled skills to every global ~/.../skills/ dir so Claude Code,
-// Cursor, Codex, and other IDEs see them.
+// Install the slim engine skill set to every global ~/.../skills/ dir
+// (Claude Code, Cursor, Codex, Antigravity/skills.sh). External engines only
+// need to know how to talk TO apx — not the full APX sub-skill catalog. The
+// rich bundled set in skills/<slug>/ stays in-repo for the APX super-agent.
+//
+// The set lives at skills/engines/<slug>/SKILL.md and is currently:
+//   apx, apx-mcp, apc-context.
 //
-// By default only `scope: public` skills land globally. Pass
-// includeOptional / includeInternal to push the other tiers (or call
-// `apx skills add <slug> --global` for a single one).
+// `includeOptional` / `includeInternal` are kept as no-op flags for backward
+// compatibility with `apx skills sync --include-…`; the slim set has no tiers.
 //
-// Pruning: if a slug that was previously installed has since been demoted to
-// internal/optional (or marked as non-public for the current call), we remove
-// the stale global copy unless prune=false. Keeps IDE skill lists clean.
+// Pruning: removes stale APX-shipped slugs that are no longer in the engine
+// set (the catalog of slugs APX has ever published, see PRUNE_LEGACY_SLUGS).
+// Skills the user installed themselves are NOT touched.
 //
 // Returns an array of { dir, skill, file, status, scope }.
-//   status ∈ {created, updated, unchanged, pruned, skipped}
+//   status ∈ {created, updated, unchanged, pruned}
+const PRUNE_LEGACY_SLUGS = [
+  "apx-agency-agents",
+  "apx-agent",
+  "apx-mcp-builder",
+  "apx-project",
+  "apx-routine",
+  "apx-runtime",
+  "apx-sessions",
+  "apx-skill-builder",
+  "apx-task",
+  "apx-telegram",
+  "apx-voice",
+  // Runtime CLI docs that previously leaked into global dirs — these are
+  // loaded in-process by the daemon and should NOT live on disk in IDE skill
+  // dirs.
+  "claude-code",
+  "codex-cli",
+  "opencode-cli",
+  "openrouter",
+];
+
 export function installGlobalSkills({
-  includeOptional = false,
-  includeInternal = false,
   prune = true,
+  // No-ops kept for CLI backward compatibility (the slim engine set has no tiers).
+  includeOptional: _includeOptional = false,
+  includeInternal: _includeInternal = false,
 } = {}) {
-  const all = discoverBundledSkills();
-  const wanted = all.filter((s) => {
-    if (s.scope === "internal") return includeInternal;
-    if (s.scope === "optional") return includeOptional;
-    return true; // public
-  });
+  const wanted = discoverBundledSkills();
   const wantedSlugs = new Set(wanted.map((s) => s.slug));
-  const knownSlugs = new Set(all.map((s) => s.slug));
 
   const results = [];
   for (const base of GLOBAL_SKILL_DIRS) {
-    // Push the wanted set.
-    for (const { slug, md, scope } of wanted) {
+    for (const { slug, md } of wanted) {
       const dest = path.join(base, slug, "SKILL.md");
       fs.mkdirSync(path.dirname(dest), { recursive: true });
       const existed = fs.existsSync(dest);
       const previous = existed ? fs.readFileSync(dest, "utf8") : null;
       if (previous === md) {
-        results.push({ dir: base, skill: slug, file: dest, status: "unchanged", scope });
+        results.push({ dir: base, skill: slug, file: dest, status: "unchanged", scope: "engine" });
         continue;
       }
       fs.writeFileSync(dest, md, "utf8");
-      results.push({ dir: base, skill: slug, file: dest, status: existed ? "updated" : "created", scope });
+      results.push({ dir: base, skill: slug, file: dest, status: existed ? "updated" : "created", scope: "engine" });
     }
-    // Prune anything WE shipped previously but should no longer be there
-    // (slug exists in the bundle but isn't `wanted` this run).
     if (prune) {
-      for (const { slug, scope } of all) {
+      for (const slug of PRUNE_LEGACY_SLUGS) {
         if (wantedSlugs.has(slug)) continue;
-        if (!knownSlugs.has(slug)) continue;
         const dest = path.join(base, slug, "SKILL.md");
         if (!fs.existsSync(dest)) continue;
         fs.unlinkSync(dest);
-        // Best-effort: drop the now-empty <slug>/ dir too.
         try { fs.rmdirSync(path.dirname(dest)); } catch {}
-        results.push({ dir: base, skill: slug, file: dest, status: "pruned", scope });
+        results.push({ dir: base, skill: slug, file: dest, status: "pruned", scope: "legacy" });
       }
     }
   }
@@ -423,7 +429,7 @@ function writeMigrateMd(apfDir, found) {
 // Get the stable APX storage ID for a project, generating one if it doesn't exist.
 // Called by the daemon when registering a project.
 export function getOrCreateApxId(root) {
-  const p = path.join(root, ".apc", "project.json");
+  const p = apcProjectFile(root);
   if (!fs.existsSync(p)) return null;
   let cfg;
   try { cfg = JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
@@ -439,7 +445,7 @@ export function initApf(directory, { name } = {}) {
   const root = path.resolve(directory);
   fs.mkdirSync(root, { recursive: true });
 
-  const apfDir = path.join(root, ".apc");
+  const apfDir = apcDir(root);
   fs.mkdirSync(path.join(apfDir, "agents"), { recursive: true });
   fs.mkdirSync(path.join(apfDir, "skills"), { recursive: true });
   fs.mkdirSync(path.join(apfDir, "commands"), { recursive: true });
@@ -469,7 +475,7 @@ export function initApf(directory, { name } = {}) {
     fs.writeFileSync(gitignore, APC_GITIGNORE);
   }
 
-  const agentsMd = path.join(root, "AGENTS.md");
+  const agentsMd = agentsMdFile(root);
   if (!fs.existsSync(agentsMd)) {
     fs.writeFileSync(agentsMd, AGENTS_MD_TEMPLATE);
   }
@@ -485,13 +491,13 @@ export function initApf(directory, { name } = {}) {
 }
 
 export function ensureAgentDir(root, slug) {
-  fs.mkdirSync(path.join(root, ".apc", "agents"), { recursive: true });
-  return path.join(root, ".apc", "agents");
+  fs.mkdirSync(apcAgentsDir(root), { recursive: true });
+  return apcAgentsDir(root);
 }
 
 // Write .apc/agents/<slug>.md — the canonical agent definition file.
 export function writeAgentFile(root, slug, fields, body = "") {
-  const dest = path.join(root, ".apc", "agents", `${slug}.md`);
+  const dest = apcAgentFile(root, slug);
   const lines = ["---"];
   const order = ["role", "model", "language", "description", "skills", "tools"];
   const written = new Set();
@@ -579,7 +585,7 @@ export function restoreVaultAgent(slug) {
 
 // Add a slug to the project's agents.imported list in project.json
 export function addImportedAgent(root, slug) {
-  const p = path.join(root, ".apc", "project.json");
+  const p = apcProjectFile(root);
   let cfg = {};
   try { cfg = JSON.parse(fs.readFileSync(p, "utf8")); } catch {}
   if (!cfg.agents) cfg.agents = {};

package/src/core/apc/skill-sync.js

@@ -8,7 +8,10 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Repo root is three levels up, not two.
 export const PACKAGE_ROOT = path.resolve(__dirname, "..", "..", "..");
 
+// Engine-side slim copy (replicated to ~/.<host>/skills/ by apx skills sync).
 export const APC_SKILL_REL = path.join("skills", "apc-context", "SKILL.md");
+// Runtime-internal copy (loaded by the super-agent — never published outside).
+export const APC_BUILTIN_SKILL_REL = path.join("src", "core", "runtime-skills", "apc-context", "SKILL.md");
 export const APC_SKILL_REMOTE =
   "https://raw.githubusercontent.com/agentprojectcontext/agentprojectcontext/main/skills/apc-context/SKILL.md";
 
@@ -95,5 +98,12 @@ export async function refreshApcContextSkill({ packageRoot = PACKAGE_ROOT, timeo
 
   fs.mkdirSync(path.dirname(dest), { recursive: true });
   fs.writeFileSync(dest, text, "utf8");
+
+  // Keep the runtime-internal copy (src/core/runtime-skills/apc-context/) in
+  // sync — that's where the super-agent loads it from.
+  const builtinDest = path.join(packageRoot, APC_BUILTIN_SKILL_REL);
+  fs.mkdirSync(path.dirname(builtinDest), { recursive: true });
+  fs.writeFileSync(builtinDest, text, "utf8");
+
   return { ok: true, source, refreshed: true };
 }

package/src/{host/daemon/plugins → core/channels}/telegram/dispatch.js

@@ -1,10 +1,38 @@
 // Inbound Telegram update dispatcher.
 //
-// Extracted from the ChannelPoller class so the index.js stays under ~800
-// lines and the routing logic for text/photo/voice/document updates lives in
-// its own module. The function takes the poller instance as `self`; every
-// `this.X` in the original method becomes `self.X` here. The poller exposes
-// _handleUpdate as a thin facade that delegates to this function.
+// Extracted from the ChannelPoller class so index.js stays under ~800 lines
+// and the routing logic for text/photo/voice/document updates lives on its
+// own. Takes the poller instance as `self`; every `this.X` in the original
+// method becomes `self.X` here. The poller exposes _handleUpdate as a thin
+// facade that delegates to handleUpdate(this, u).
+//
+// IMPORTANT: this module needs the same imports the original index.js had
+// in module scope, because the extracted body references identifiers like
+// `appendGlobalMessage`, `CHANNELS`, `nowIso`, etc. Top-level imports here
+// keep that scope intact — earlier splits forgot them and the bug only
+// surfaced when a real telegram update arrived (ReferenceError at runtime).
+import path from "node:path";
+import { callEngine } from "#core/engines/index.js";
+import { runSuperAgent, isSuperAgentEnabled } from "#core/agent/super-agent.js";
+import { stripThinking } from "#core/util/thinking.js";
+import { getRecentTelegramTurnsFromFs, appendGlobalMessage } from "#core/stores/messages.js";
+import { compactChannelIfNeeded } from "#core/memory/index.js";
+import { readAgents } from "#core/apc/parser.js";
+import { buildAgentSystem } from "#core/agent/build-agent-system.js";
+import { transcribe as transcribeAudioFile } from "#core/voice/transcription.js";
+import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
+import { registerSender, resolveAllowedTools } from "#core/identity/telegram.js";
+import { buildRelationshipBlock } from "#core/agent/index.js";
+import { getConfirmationStore as getConfirmStore } from "#core/confirmation/pending-store.js";
+import { CHANNELS } from "#core/constants/channels.js";
+import { tryResolveSkillCommand } from "#core/agent/skills/trigger.js";
+import { createTelegramConfirmAdapter } from "#core/confirmation/adapters/telegram.js";
+import * as askFlow from "./ask.js";
+import { buildTelegramMeta, resolveBotToken, sleep } from "./helpers.js";
+import { sendPhoto, sendVoice, sendDocument, sendAudio, downloadTelegramFile, API_BASE } from "./media.js";
+import { t, resolveLang } from "#core/i18n/index.js";
+
+const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
 export async function handleUpdate(self, u) {
     self.lastUpdateAt = nowIso();
@@ -259,7 +287,7 @@ export async function handleUpdate(self, u) {
     // honor it for future messages.
     if (isReset) {
       try {
-        const ack = "Done, context cleared. Starting fresh. What do you need?";
+        const ack = t("telegram.reset_ack", { lang: resolveLang(self.globalConfig) });
         await self._send({ chat_id, text: ack });
         appendGlobalMessage({
           channel: CHANNELS.TELEGRAM,
@@ -343,15 +371,7 @@ export async function handleUpdate(self, u) {
     // short localized heads-up the moment real work starts (first tool_start),
     // but only if the agent didn't already write its own "on it" line.
     let sentHeadsUp = false;
-    const headsUpPhrase = () => {
-      const lang = (self.globalConfig?.user?.language || "es").slice(0, 2);
-      const byLang = {
-        es: "Dale, estoy con eso… 🛠️",
-        en: "On it — working on that… 🛠️",
-        pt: "Já estou nisso… 🛠️",
-      };
-      return byLang[lang] || byLang.es;
-    };
+    const headsUpPhrase = () => t("telegram.heads_up", { lang: resolveLang(self.globalConfig) });
     if (!replyText && isSuperAgentEnabled(self.globalConfig)) {
       const onEvent = async (ev) => {
         try {
@@ -523,7 +543,9 @@ export async function handleUpdate(self, u) {
     const finalClean = replyText ? stripThinking(replyText).trim() : "";
     let toSend = "";
     if (finalClean && finalClean !== lastStreamedText) toSend = finalClean;
-    else if (!finalClean && streamedCount === 0) toSend = "Listo.";
+    else if (!finalClean && streamedCount === 0) {
+      toSend = t("telegram.fallback_listo", { lang: resolveLang(self.globalConfig) });
+    }
 
     stopTyping();
     if (!toSend) return; // everything was already streamed — nothing left to send

package/src/core/config/index.js

@@ -6,6 +6,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { APX_HOME, CONFIG_PATH } from "./paths.js";
 import { PERMISSION_MODES, DEFAULT_PERMISSION_MODE } from "../constants/permissions.js";
+import { agentsMdFile, apcProjectFile } from "../apc/paths.js";
 
 export {
   APX_HOME,
@@ -116,6 +117,27 @@ const DEFAULT_CONFIG = {
     compact_model: "ollama:gemma4:31b-cloud", // light LLM for compaction (Ollama, local endpoint)
     compact_fallback_model: "",        // "" → falls back to super_agent.model (APX default)
   },
+  skills: {
+    // Skill Inspector — opt-in test feature. When enabled, the static
+    // "Available skills" hint block (slug dump) is removed from the system
+    // prompt; instead a local RAG inspects each turn's user prompt and
+    // injects either the matching skill's body (high confidence) or a hint
+    // to call load_skill (mid confidence). Below threshold → nothing.
+    // Re-evaluated every turn → natural decay (a skill that stopped matching
+    // disappears next turn).
+    // Embedding provider is whatever memory.embeddings resolves to (defaults
+    // to local: ollama → gemini → openai → offline TF). No paid keys needed.
+    inspector: {
+      enabled: false,
+      load_threshold: 0.55,
+      hint_threshold: 0.40,
+      margin: 0.04,
+      max_loaded: 1,
+      max_hints: 2,
+      prompt_floor: 8,
+      body_char_cap: 6000,
+    },
+  },
   voice: {
     // Text-to-speech configuration. Selector reads voice.tts.provider; "auto"
     // probes engines in preference order (piper → elevenlabs → openai →
@@ -395,10 +417,10 @@ export function effectiveHost(cfg) {
 
 export function addProject(cfg, projectPath) {
   const abs = path.resolve(projectPath);
-  if (!fs.existsSync(path.join(abs, "AGENTS.md"))) {
+  if (!fs.existsSync(agentsMdFile(abs))) {
     throw new Error(`not an APC project: ${abs} (no AGENTS.md)`);
   }
-  if (!fs.existsSync(path.join(abs, ".apc", "project.json"))) {
+  if (!fs.existsSync(apcProjectFile(abs))) {
     throw new Error(`not an APC project: ${abs} (no .apc/project.json)`);
   }
   const exists = cfg.projects.find((p) => path.resolve(p.path) === abs);