@agentprojectcontext/apx 1.31.2 → 1.32.2

package/src/core/agent/self-memory.js

@@ -1,21 +1,31 @@
-// Roby's own notebook — the super-agent's personal, persistent memory.
+// The super-agent's personal, persistent notebook.
 //
-// This is distinct from:
-//   - identity.json   → who Roby is (name, personality, owner)
+// Distinct from:
+//   - identity.json   → who the super-agent is (name, personality, owner)
 //   - project agents' ~/.apx/projects/<apx_id>/agents/<slug>/memory.md → per-agent, per-project
 //   - sessions        → raw transcripts of past work (search_sessions)
 //
-// It is a single free-form markdown file at ~/.apx/memory.md that Roby keeps
+// A single free-form markdown file at ~/.apx/memory.md kept by the super-agent
 // itself: durable facts about the owner, ongoing threads, decisions, and the
-// gist of what it has been working on (which it refreshes by skimming its own
-// recent sessions). A bounded slice is injected into every super-agent prompt;
-// the `remember` / `read_self_memory` tools write and read it.
+// gist of what it has been working on (refreshed by skimming its own recent
+// sessions). A bounded slice is injected into every super-agent prompt; the
+// `remember` / `read_self_memory` tools write and read it.
+//
+// The header inside the file picks up the current persona name from identity
+// (resolveAgentName) — never hardcode the agent name here.
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { resolveAgentName } from "../identity/index.js";
 
 export const SELF_MEMORY_PATH = path.join(os.homedir(), ".apx", "memory.md");
 
+function notebookHeader() {
+  let name = "";
+  try { name = resolveAgentName(); } catch { /* identity missing */ }
+  return name ? `# ${name}'s notebook` : "# Self-memory";
+}
+
 // How much of the notebook to inline into the system prompt. The full file is
 // always readable via read_self_memory; this only bounds the always-on slice
 // so a long notebook can't blow the token budget on cheap channels.
@@ -67,7 +77,7 @@ export function appendSelfMemory(note, opts = {}) {
 
   let next;
   if (!existing.trim()) {
-    next = `# Roby's notebook\n\n${heading}\n${bullet}\n`;
+    next = `${notebookHeader()}\n\n${heading}\n${bullet}\n`;
   } else if (existing.includes(heading)) {
     // Append the bullet under today's existing heading.
     const lines = existing.split("\n");
@@ -100,7 +110,7 @@ export function ensureSelfMemoryFile() {
   try {
     if (fs.existsSync(SELF_MEMORY_PATH)) return false;
     fs.mkdirSync(path.dirname(SELF_MEMORY_PATH), { recursive: true });
-    fs.writeFileSync(SELF_MEMORY_PATH, "# Roby's notebook\n");
+    fs.writeFileSync(SELF_MEMORY_PATH, `${notebookHeader()}\n`);
     return true;
   } catch {
     return false;

package/src/core/agent/skills/catalog.js

@@ -0,0 +1,65 @@
+// Helpers for working with the skills catalog in the agent prompt.
+//
+// Two consumers:
+//   1. The system-prompt builder injects a short HINT block (slugs only, no
+//      bodies, no descriptions) so the model knows skills exist and how to
+//      reach them — see buildSkillsHintBlock(). The full catalog (slug +
+//      condensed description) is reached via the `list_skills` tool.
+//   2. The `list_skills` tool itself renders descriptions using
+//      condenseSkillDescription() — keeps the trigger-list tails out of the
+//      tool result, same way the legacy catalog did.
+//
+// Skill descriptions are authored for Claude Code's skill matcher, so many end
+// with verbose "Trigger on: …" / "Activate when …" / "Activa cuando…" lists.
+// Inside the super-agent prompt those tails are pure noise (it matches
+// semantically, not by trigger string). Keep the first sentence only, drop
+// the trigger/activation tail, and cap length.
+
+const TRIGGER_MARKER =
+  /\s*(?:Trigger(?:s)? on|Triggers|TRIGGER|Activate (?:on|when|only)|Use this skill (?:whenever|when)|Use (?:it )?when|Triggers include|SKIP|Also (?:use|triggers)|Activa(?:r)? (?:cuando|en)|Disparadores|Usar cuando|Usá cuando|Se activa cuando)\b/i;
+
+export function condenseSkillDescription(desc) {
+  if (!desc) return "(no description)";
+  const full = String(desc).replace(/\s+/g, " ").trim();
+  // Prefer the gist before any trigger/activation marker; but if a skill leads
+  // straight into "Activate ONLY when…" (no gist first), that head is empty —
+  // fall back to the first sentence of the full text so we keep real info.
+  let d = full.split(TRIGGER_MARKER)[0].trim();
+  if (d.length < 15) d = full;
+  // First sentence only, then cap length.
+  const firstStop = d.search(/\.(\s|$)/);
+  if (firstStop > 0) d = d.slice(0, firstStop + 1);
+  d = d.trim();
+  if (d.length > 160) d = d.slice(0, 157).trimEnd() + "…";
+  return d || "(no description)";
+}
+
+/**
+ * Compact "skills exist, here's how to reach them" block injected into every
+ * super-agent system prompt. Lists slugs only (no descriptions, no bodies) so
+ * the agent knows which slugs are reachable without paying the full catalog's
+ * token cost. The model calls `list_skills` to see descriptions and
+ * `load_skill` to load a body.
+ *
+ * Returns "" when there are no skills.
+ */
+export function buildSkillsHintBlock(listSkills) {
+  let list = [];
+  try {
+    list = listSkills();
+  } catch {
+    /* empty */
+  }
+  if (!list.length) return "";
+  const slugs = list.map((s) => s.slug).filter(Boolean);
+  return [
+    "# Available skills (catalog on demand)",
+    `${slugs.length} skills are available. Bodies are NOT loaded. For details,`,
+    "call `list_skills` (catalog with one-line descriptions) and then",
+    "`load_skill({slug})` to load the body of the matching one. Match",
+    "semantically — never by trigger string. Don't load a skill unless the",
+    "current user request actually needs its exact syntax.",
+    "",
+    "Slugs: " + slugs.join(", "),
+  ].join("\n");
+}

package/src/core/agent/skills/index.js

@@ -0,0 +1,6 @@
+// Public entrypoint for skills.
+export { condenseSkillDescription, buildSkillsHintBlock } from "./catalog.js";
+export { tryResolveSkillCommand } from "./trigger.js";
+export { suggestSkillForPrompt, clearSkillVectorCache } from "./rag.js";
+export { listSkills, loadSkill, SKILL_LOCATIONS } from "./loader.js";
+

package/src/{host/daemon/skills-loader.js → core/agent/skills/loader.js}

@@ -31,9 +31,9 @@ import { fileURLToPath } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname  = path.dirname(__filename);
-// Three levels up: __dirname = src/host/daemon/ → src/host/ → src/ → repo root.
-// Used to find the bundled skills/ folder at the repo root.
-const PACKAGE_ROOT = path.resolve(__dirname, "..", "..", "..");
+// Four levels up: __dirname = src/core/agent/skills/ → agent/ → core/ → src/
+// → repo root. Used to find the bundled skills/ folder at the repo root.
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..", "..", "..");
 
 const RUNTIME_SKILLS_DIR = path.join(PACKAGE_ROOT, "src", "core", "runtime-skills");
 const BUNDLED_SKILLS_DIR = path.join(PACKAGE_ROOT, "skills");

package/src/core/agent/skills/rag.js

@@ -0,0 +1,91 @@
+// Suggest a skill semantically when the user prompt looks like it would
+// benefit from one — without paying the catalog's token cost every turn.
+//
+// On every turn we:
+//   1. Embed the user prompt.
+//   2. Embed each skill's condensed description (cached per-process by slug).
+//   3. Pick the top match if its cosine ≥ THRESHOLD AND noticeably better
+//      than the runner-up (so a vague prompt doesn't drag a random skill in).
+//   4. Return a SOFT HINT block — not a full skill body — that nudges the
+//      model to call `load_skill({slug})` if the gist matches.
+//
+// Soft, not hard:
+//   - We never inject the body; the model still has to decide and call.
+//   - We never block the request: any embedding error → "" return.
+//   - We never re-call the indexer; the embedder is the same one already
+//     selected by core/memory/embeddings.js.
+//
+// Costs: one extra embedOne(promptText) per turn. Skill description
+// embeddings are cached in-process by (slug, source) so the cold cost is
+// O(skills) once per process start.
+import { embedOne, cosineSim } from "#core/memory/embeddings.js";
+import { condenseSkillDescription } from "#core/agent/skills/index.js";
+import { listSkills } from "./loader.js";
+
+const SIM_THRESHOLD = 0.45;        // below this, no suggestion
+const MARGIN = 0.05;               // top must beat runner-up by at least this
+const PROMPT_LEN_FLOOR = 8;        // skip "hola" / "ok" / single-word prompts
+
+const cache = new Map();           // slug -> { vector, descHash }
+
+function descHash(text) {
+  let h = 0;
+  const s = String(text || "");
+  for (let i = 0; i < s.length; i++) h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+  return h;
+}
+
+async function ensureSkillVector(skill, opts) {
+  const desc = condenseSkillDescription(skill.description);
+  const h = descHash(desc);
+  const hit = cache.get(skill.slug);
+  if (hit && hit.descHash === h) return hit.vector;
+  const vector = await embedOne(desc, opts);
+  if (vector) cache.set(skill.slug, { vector, descHash: h });
+  return vector;
+}
+
+/**
+ * Returns "" when no confident match exists, or a one-paragraph hint that
+ * names the slug + the matched description. Callers append it to contextNote.
+ */
+export async function suggestSkillForPrompt(prompt, { projectPath, embedOpts } = {}) {
+  try {
+    const p = String(prompt || "").trim();
+    if (p.length < PROMPT_LEN_FLOOR) return "";
+
+    const skills = listSkills({ projectPath });
+    if (!skills.length) return "";
+
+    const promptVec = await embedOne(p, embedOpts);
+    if (!promptVec) return "";
+
+    const scored = [];
+    for (const skill of skills) {
+      const v = await ensureSkillVector(skill, embedOpts);
+      if (!v) continue;
+      scored.push({ slug: skill.slug, sim: cosineSim(promptVec, v) });
+    }
+    if (scored.length === 0) return "";
+    scored.sort((a, b) => b.sim - a.sim);
+
+    const top = scored[0];
+    const runner = scored[1] || { sim: 0 };
+    if (top.sim < SIM_THRESHOLD) return "";
+    if (top.sim - runner.sim < MARGIN) return "";
+
+    return [
+      "# Skill semantically relevant to this prompt",
+      `The skill \`${top.slug}\` matches what the user is asking about (sim ${top.sim.toFixed(2)}).`,
+      "If exact syntax/behaviour for that skill is needed, call `load_skill({slug:\"" + top.slug + "\"})`",
+      "BEFORE answering. If the user's question is actually about something else, ignore this hint.",
+    ].join("\n");
+  } catch {
+    return "";
+  }
+}
+
+// Exposed for tests / cache hygiene if a caller wants to reset between runs.
+export function clearSkillVectorCache() {
+  cache.clear();
+}

package/src/core/agent/skills/trigger.js

@@ -0,0 +1,71 @@
+// Interface-agnostic skill trigger.
+//
+// When a user message starts with `/<slug>` (e.g. "/apx-routine help me add one"),
+// this helper resolves the slug against the skill catalog and pulls the body
+// into a structured block to inject into the next turn — so the model has the
+// exact syntax without paying for the catalog every turn.
+//
+// Returns:
+//   { handled: false }            — message had no slash command
+//   { handled: true, prompt, contextNote, skill, rest }
+//     prompt:      the user's text minus the slash command (or "tell me how to use <skill>"
+//                  when only the slash command was sent)
+//     contextNote: a multi-line block ready to pass as `contextNote` to runSuperAgent
+//     skill:       { slug, body, source } — the loaded skill
+//     rest:        the user's text without the `/<slug>` prefix (handy for callers
+//                  that want to render or transform it themselves)
+//
+// Resolution rules:
+//   - The first whitespace-separated token must start with `/`.
+//   - The slug after the slash is matched case-insensitively against listSkills().
+//   - Project-scoped skills (.apc/skills/) win when projectPath is provided.
+//   - An unknown slug falls through ({ handled: false }) so callers can choose
+//     to surface a "no such skill" message or pass through unchanged.
+import { listSkills, loadSkill } from "./loader.js";
+
+const SLASH_RE = /^\/([A-Za-z][A-Za-z0-9_-]*)\b/;
+
+export function tryResolveSkillCommand(message, { projectPath } = {}) {
+  if (typeof message !== "string") return { handled: false };
+  const trimmed = message.replace(/^\s+/, "");
+  const m = trimmed.match(SLASH_RE);
+  if (!m) return { handled: false };
+
+  const slug = m[1].toLowerCase();
+  const rest = trimmed.slice(m[0].length).trimStart();
+
+  let skills = [];
+  try {
+    skills = listSkills({ projectPath });
+  } catch {
+    return { handled: false };
+  }
+  const match = skills.find((s) => s.slug.toLowerCase() === slug);
+  if (!match) return { handled: false };
+
+  let body = "";
+  try {
+    const loaded = loadSkill(match.slug, { projectPath });
+    body = loaded.body || "";
+  } catch {
+    body = "";
+  }
+
+  const prompt = rest || `Use the **${match.slug}** skill to help me.`;
+  const contextNote = [
+    `# Skill loaded on demand: \`${match.slug}\``,
+    "The user invoked this skill explicitly with a `/slug` prefix. Use the",
+    "instructions below for this turn instead of guessing. Don't re-call",
+    "load_skill for the same slug — its body is right here.",
+    "",
+    body,
+  ].join("\n");
+
+  return {
+    handled: true,
+    prompt,
+    contextNote,
+    skill: { slug: match.slug, body, source: match.source },
+    rest,
+  };
+}

package/src/{host/daemon → core/agent}/super-agent.js

@@ -1,15 +1,15 @@
 // Super-agent: daemon-level action agent for Telegram, TUI, desktop, routines.
-import { createToolSession, buildLazyToolsBlock, makeToolHandlers } from "./super-agent-tools/index.js";
-import { listSkills } from "./skills-loader.js";
+import { createToolSession, buildLazyToolsBlock, makeToolHandlers } from "#core/agent/tools/registry.js";
+import { listSkills } from "#core/agent/skills/loader.js";
 import {
   runAgent,
   buildSuperAgentSystem,
   isSuperAgentEnabled,
   buildIdentityBlock,
   loadDefaultSystemPrompt,
-} from "../../core/agent/index.js";
-import { resolveAgentName } from "../../core/identity.js";
-import { memoryBlockFor } from "../../core/memory/index.js";
+} from "#core/agent/index.js";
+import { resolveAgentName } from "#core/identity/index.js";
+import { memoryBlockFor } from "#core/memory/index.js";
 
 export {
   buildIdentityBlock,

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/add-project.js

@@ -1,8 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { readConfig, addProject as addProjectInConfig } from "../../../../core/config.js";
-import { initApf } from "../../../../core/scaffold.js";
-import { confirmedProperty, projectMeta } from "../helpers.js";
+import { readConfig, addProject as addProjectInConfig } from "#core/config/index.js";
+import { initApf } from "#core/apc/scaffold.js";
+import { projectMeta } from "../helpers.js";
 
 function isApcProject(absPath) {
   return (
@@ -25,7 +25,6 @@ export default {
           path: { type: "string", description: "absolute or relative filesystem path to add" },
           name: { type: "string", description: "optional project name (used only when initializing a new APC project)" },
           init: { type: "boolean", description: "auto-create AGENTS.md and .apc/project.json if missing (default true)" },
-          confirmed: confirmedProperty("true only after explicit user confirmation for this exact project registration"),
         },
         required: ["path"],
       },

package/src/core/agent/tools/handlers/ask-questions.js

@@ -0,0 +1,115 @@
+// Normalize a raw question entry into the canonical shape rendered by every
+// surface (web InlineAskPanel, future desktop/telegram/CLI). The model can
+// pass either a plain string (legacy) or a rich object with options.
+function normalizeQuestion(q) {
+  if (typeof q === "string") {
+    return { question: q, options: [], multiSelect: false, allowText: true };
+  }
+  if (!q || typeof q !== "object") return null;
+  const text = typeof q.question === "string" ? q.question : "";
+  if (!text) return null;
+  const options = Array.isArray(q.options)
+    ? q.options
+        .map((o) => {
+          if (typeof o === "string") return { label: o };
+          if (o && typeof o === "object" && typeof o.label === "string") {
+            return {
+              label: o.label,
+              description: typeof o.description === "string" ? o.description : undefined,
+            };
+          }
+          return null;
+        })
+        .filter(Boolean)
+    : [];
+  return {
+    question: text,
+    header: typeof q.header === "string" ? q.header : undefined,
+    options,
+    multiSelect: q.multiSelect === true,
+    // Free-text fallback: on by default. Set false explicitly to force a
+    // pick from `options`. Has no effect when options is empty.
+    allowText: q.allowText === false ? false : true,
+  };
+}
+
+export default {
+  name: "ask_questions",
+  schema: {
+    // type: "function" is REQUIRED at the top level — OpenAI and Groq reject
+    // schemas without it (Groq → 400 'tools.N.type': property 'type' is missing).
+    // Anthropic / Ollama tolerate its absence but the contract is clearer with it.
+    type: "function",
+    function: {
+      name: "ask_questions",
+      description:
+        "Ask the user one or more questions when you genuinely need input to proceed. " +
+        "Each question can be free-text OR a selectable list of options (single- or multi-select). " +
+        "Call this ONCE per turn — the loop hands control back to the user immediately.",
+      parameters: {
+        type: "object",
+        properties: {
+          questions: {
+            type: "array",
+            description:
+              "Questions for the user. Each item is an object with the question text " +
+              "and optional `options` for selectable answers (single- or multi-select). " +
+              "Leave `options` empty for free-text questions.",
+            items: {
+              type: "object",
+              properties: {
+                question: { type: "string", description: "The question text." },
+                header: {
+                  type: "string",
+                  description: "Optional short chip (≤12 chars) shown next to the question.",
+                },
+                options: {
+                  type: "array",
+                  description:
+                    "Selectable answers. Omit or leave empty for a free-text question. " +
+                    "Prefer 2–4 distinct, mutually-exclusive choices.",
+                  items: {
+                    type: "object",
+                    properties: {
+                      label: { type: "string", description: "Visible label." },
+                      description: {
+                        type: "string",
+                        description: "Optional explanation shown under the label.",
+                      },
+                    },
+                    required: ["label"],
+                  },
+                },
+                multiSelect: {
+                  type: "boolean",
+                  description:
+                    "true → user can pick several options (checkboxes). Default false (single-select).",
+                },
+                allowText: {
+                  type: "boolean",
+                  description:
+                    "When options is non-empty, also show an 'Otro' free-text field. Default true.",
+                },
+              },
+              required: ["question"],
+            },
+          },
+        },
+        required: ["questions"],
+      },
+    },
+  },
+  makeHandler: () => async ({ questions }) => {
+    // Normalize so downstream code (UI panels, persistence) always sees the
+    // canonical shape. The agent loop treats this tool as turn-ending
+    // (see TURN_ENDING_TOOLS in src/core/agent/constants.js).
+    const normalized = Array.isArray(questions)
+      ? questions.map(normalizeQuestion).filter(Boolean)
+      : [];
+    return {
+      status: "Questions presented to user. Waiting for input.",
+      count: normalized.length,
+      questions: normalized,
+    };
+  },
+};

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/call-agent.js

@@ -1,5 +1,5 @@
-import { callEngine } from "../../../../core/engines/index.js";
-import { readAgents } from "../../../../core/parser.js";
+import { callEngine } from "#core/engines/index.js";
+import { readAgents } from "#core/apc/parser.js";
 import { buildAgentSystem, resolveProject } from "../helpers.js";
 
 export default {

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/call-mcp.js

@@ -1,4 +1,4 @@
-import { confirmedProperty, resolveProject } from "../helpers.js";
+import { resolveProject } from "../helpers.js";
 
 export default {
   name: "call_mcp",
@@ -14,7 +14,6 @@ export default {
           mcp: { type: "string", description: "MCP server name" },
           tool: { type: "string", description: "tool name on that MCP" },
           args: { type: "object", description: "arguments object" },
-          confirmed: confirmedProperty("true only after explicit user confirmation for this exact MCP call"),
         },
         required: ["mcp", "tool"],
       },

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/call-runtime.js

@@ -1,21 +1,21 @@
 import fs from "node:fs";
 import path from "node:path";
-import { loggerFor } from "../../../../core/logging.js";
-import { readAgents } from "../../../../core/parser.js";
+import { loggerFor } from "#core/logging.js";
+import { readAgents } from "#core/apc/parser.js";
 import {
-  buildApfHint,
   closeRuntimeSession,
   createRuntimeSession,
-  extractApfResult,
-} from "../../apc-runtime-context.js";
-import { detectAll } from "../../env-detect.js";
+  extractRuntimeResult as extractApfResult,
+} from "#core/stores/runtime-sessions.js";
+import { buildRuntimeBridgeHint as buildApfHint } from "#core/agent/runtime-bridge.js";
+import { detectAll } from "#host/daemon/env-detect.js";
 import {
   findEngineSessionById,
   readEngineSessionContext,
-} from "../../engine-sessions.js";
-import { runProcess } from "../../runtimes/_spawn.js";
-import { getRuntime, RUNTIME_IDS } from "../../runtimes/index.js";
-import { buildAgentSystem, confirmedProperty, resolveProject } from "../helpers.js";
+} from "#core/stores/engine-sessions.js";
+import { runProcess } from "#host/daemon/runtimes/_spawn.js";
+import { getRuntime, RUNTIME_IDS } from "#host/daemon/runtimes/index.js";
+import { buildAgentSystem, resolveProject } from "../helpers.js";
 
 const log = loggerFor("call_runtime");
 
@@ -167,7 +167,6 @@ export default {
             description: "Optional prior session id (claude/codex/apx) — APX prepends that session's title + last prompt to the prompt so the runtime has context.",
           },
           timeout_s: { type: "integer", description: "seconds before SIGTERM; default 300" },
-          confirmed: confirmedProperty("true only after explicit user confirmation for this exact runtime command"),
         },
         required: ["runtime", "prompt"],
       },

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/create-task.js

@@ -1,4 +1,4 @@
-import { createTask } from "../../../../core/tasks-store.js";
+import { createTask } from "#core/stores/tasks.js";
 
 export default {
   name: "create_task",

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/discover-tools.js

@@ -1,6 +1,6 @@
 // discover_tools — lazy tool discovery + activation.
 //
-// Roby (and any super-agent surface) only carries a small "base" set of tool
+// The super-agent only carries a small "base" set of tool
 // schemas on lightweight channels (Telegram/desktop/deck) to stay under
 // cheap-tier TPM caps. The rest (browser/Puppeteer, fetch, web_search, runtime,
 // voice, …) exist but are NOT sent to the model by default. This tool is how

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/edit-file.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { confirmedProperty, resolveProject, safePathJoin } from "../helpers.js";
+import { resolveProject, safePathJoin } from "../helpers.js";
 
 export default {
   name: "edit_file",
@@ -16,7 +16,6 @@ export default {
           search: { type: "string", description: "exact text to replace" },
           replace: { type: "string", description: "replacement text" },
           all: { type: "boolean", description: "replace all matches; default false replaces one match" },
-          confirmed: confirmedProperty("true only after explicit user confirmation for this exact file edit"),
         },
         required: ["path", "search", "replace"],
       },

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/import-agent.js

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { readVaultAgents, VAULT_DIR } from "../../../../core/parser.js";
-import { addImportedAgent, ensureAgentDir } from "../../../../core/scaffold.js";
-import { ensureAgentRuntimeDir } from "../../../../core/agent-memory.js";
-import { confirmedProperty, projectMeta, resolveProject } from "../helpers.js";
+import { readVaultAgents, VAULT_DIR } from "#core/apc/parser.js";
+import { addImportedAgent, ensureAgentDir } from "#core/apc/scaffold.js";
+import { ensureAgentRuntimeDir } from "#core/agent/memory.js";
+import { projectMeta, resolveProject } from "../helpers.js";
 
 export default {
   name: "import_agent",
@@ -17,7 +17,6 @@ export default {
         properties: {
           project: { type: "string", description: "project id/name/path; omit or use 'default' for ~/.apx/projects/default" },
           agent: { type: "string", description: "agent slug from list_vault_agents" },
-          confirmed: confirmedProperty("true only after explicit user confirmation for this exact import"),
         },
         required: ["agent"],
       },

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/list-agents.js

@@ -1,4 +1,4 @@
-import { readAgents } from "../../../../core/parser.js";
+import { readAgents } from "#core/apc/parser.js";
 import { agentRow, resolveProject } from "../helpers.js";
 
 export default {

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/list-skills.js

@@ -1,4 +1,5 @@
-import { listSkills, SKILL_LOCATIONS } from "../../skills-loader.js";
+import { listSkills, SKILL_LOCATIONS } from "#core/agent/skills/loader.js";
+import { condenseSkillDescription } from "#core/agent/skills/index.js";
 
 export default {
   name: "list_skills",
@@ -26,7 +27,11 @@ export default {
       count: skills.length,
       locations: SKILL_LOCATIONS,
       project_path: project_path || null,
-      skills: skills.map(({ slug, source, description }) => ({ slug, source, description })),
+      skills: skills.map(({ slug, source, description }) => ({
+        slug,
+        source,
+        description: condenseSkillDescription(description),
+      })),
     };
   },
 };

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/list-tasks.js

@@ -1,4 +1,4 @@
-import { listTasks } from "../../../../core/tasks-store.js";
+import { listTasks } from "#core/stores/tasks.js";
 
 export default {
   name: "list_tasks",

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/list-vault-agents.js

@@ -1,4 +1,4 @@
-import { readVaultAgents, VAULT_DIR } from "../../../../core/parser.js";
+import { readVaultAgents, VAULT_DIR } from "#core/apc/parser.js";
 import { agentRow } from "../helpers.js";
 
 export default {

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/load-skill.js

@@ -1,4 +1,4 @@
-import { loadSkill } from "../../skills-loader.js";
+import { loadSkill } from "#core/agent/skills/loader.js";
 
 export default {
   name: "load_skill",

package/src/{host/daemon/super-agent-tools/tools → core/agent/tools/handlers}/read-agent-memory.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { resolveProject } from "../helpers.js";
-import { agentMemoryPath, readAgentMemory } from "../../../../core/agent-memory.js";
+import { agentMemoryPath, readAgentMemory } from "#core/agent/memory.js";
 
 export default {
   name: "read_agent_memory",