@agentprojectcontext/apx 1.34.0 → 1.35.0

package/src/interfaces/web/src/components/settings/SkillsInspectorPanel.tsx

@@ -0,0 +1,222 @@
+import { useState } from "react";
+import useSWR from "swr";
+import { Sparkles, RefreshCw, Wand2 } from "lucide-react";
+import { Section } from "../Section";
+import { Button, Field, Input, Loading, Badge, Switch } from "../ui";
+import { useToast } from "../Toast";
+import { Skills, type InspectTrace } from "../../lib/api/skills";
+
+// Skill Inspector — per-turn skill RAG middleware. When ON, the static
+// "available skills" slug-dump is removed from the agent's system prompt and a
+// local RAG injects, per turn, only the skill(s) the user's message actually
+// needs. This panel toggles the feature, tunes its thresholds, (re)builds the
+// vector index, and offers a live dry-run so you can see what it would surface.
+//
+// Mirrors MemoryPanel (RAG embeddings): same Section/Field/Button idiom. Config
+// persists under config.skills.inspector.* via the inspector PUT endpoint, so
+// no separate global-config patch is needed.
+
+// Numeric knobs with human labels + sane ranges. We keep them as plain number
+// inputs (same idiom as the embeddings model fields) rather than sliders so the
+// values are explicit and copy-pasteable.
+const KNOBS: { key: keyof NumericKnobs; label: string; hint: string; step: number; min: number; max: number }[] = [
+  { key: "load_threshold", label: "Umbral de carga", hint: "Similitud mínima para inyectar el CUERPO de la skill (alto = más estricto).", step: 0.01, min: 0, max: 1 },
+  { key: "hint_threshold", label: "Umbral de sugerencia", hint: "Similitud mínima para solo SUGERIR la skill (que el agente la cargue si quiere).", step: 0.01, min: 0, max: 1 },
+  { key: "margin", label: "Margen sobre el 2º", hint: "El top debe superar al segundo por este margen para cargar su cuerpo (evita empates flojos).", step: 0.01, min: 0, max: 1 },
+  { key: "max_loaded", label: "Máx. cuerpos cargados", hint: "Cuántas skills se inyectan completas por turno.", step: 1, min: 0, max: 5 },
+  { key: "max_hints", label: "Máx. sugerencias", hint: "Cuántas skills extra se nombran como sugerencia.", step: 1, min: 0, max: 8 },
+  { key: "prompt_floor", label: "Largo mínimo del prompt", hint: "Mensajes más cortos que esto se ignoran (evita 'ok', 'hola').", step: 1, min: 0, max: 40 },
+  { key: "body_char_cap", label: "Tope de chars del cuerpo", hint: "Recorta cuerpos de skill largos para no inflar el contexto.", step: 500, min: 500, max: 20000 },
+];
+
+type NumericKnobs = {
+  load_threshold: number; hint_threshold: number; margin: number;
+  max_loaded: number; max_hints: number; prompt_floor: number; body_char_cap: number;
+};
+
+export function SkillsInspectorPanel() {
+  const toast = useToast();
+  const { data, mutate, isLoading } = useSWR("/skills/inspector", () => Skills.inspector());
+  const [busy, setBusy] = useState(false);
+  const [probe, setProbe] = useState("");
+  const [probeResult, setProbeResult] = useState<InspectTrace | null>(null);
+
+  if (isLoading || !data) return <Loading />;
+
+  const cfg = data.config;
+  const idx = data.index;
+
+  const apply = async (patch: Record<string, unknown>) => {
+    setBusy(true);
+    try {
+      await Skills.updateInspector(patch);
+      await mutate();
+    } catch (e) {
+      toast.error(`No se pudo guardar: ${(e as Error).message}`);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const runIndex = async (force = false) => {
+    setBusy(true);
+    try {
+      const r = await Skills.index({ force });
+      toast.success(
+        `Indexado con ${r.embedder} (dim ${r.dim}): +${r.changed.added} ~${r.changed.refreshed} -${r.changed.removed}.`,
+      );
+      await mutate();
+    } catch (e) {
+      toast.error(`Falló el index: ${(e as Error).message}`);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const runProbe = async () => {
+    if (!probe.trim()) return;
+    setBusy(true);
+    setProbeResult(null);
+    try {
+      const r = await Skills.inspect(probe.trim());
+      setProbeResult(r.trace);
+    } catch (e) {
+      toast.error(`Falló el dry-run: ${(e as Error).message}`);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="space-y-6">
+      <Section
+        title="Skill Inspector (RAG por turno)"
+        description="Función experimental. Cuando está activa, el agente NO recibe la lista completa de skills en su prompt; en cada mensaje un RAG local decide qué skill(s) cargar — el cuerpo completo si hay match fuerte, una sugerencia si hay match medio, nada si no aplica. Se reevalúa cada turno: una skill que dejó de ser relevante desaparece del contexto."
+      >
+        <div className="space-y-4">
+          <Field
+            label="Activar inspector"
+            hint="Apagado = comportamiento clásico (lista de slugs + sugerencia pasiva). Encendido = el RAG decide por turno."
+          >
+            <Switch
+              checked={cfg.enabled}
+              disabled={busy}
+              onChange={(v) => apply({ enabled: v })}
+              label={cfg.enabled ? "Encendido" : "Apagado"}
+            />
+          </Field>
+
+          <div className="flex flex-wrap items-center gap-2 pt-1">
+            <Badge tone={idx.count > 0 ? "success" : "warning"}>
+              Índice: {idx.count} skills
+            </Badge>
+            <Badge tone="muted">{idx.embedder || "sin indexar"}</Badge>
+            {idx.dim ? <Badge tone="muted">dim {idx.dim}</Badge> : null}
+            {idx.updated_at ? (
+              <span className="text-xs text-muted-foreground">
+                actualizado {new Date(idx.updated_at).toLocaleString()}
+              </span>
+            ) : null}
+          </div>
+
+          <div className="flex flex-wrap items-center gap-3 pt-1">
+            <Button variant="secondary" onClick={() => runIndex(false)} loading={busy}>
+              <RefreshCw size={14} /> Reindexar
+            </Button>
+            <Button variant="secondary" onClick={() => runIndex(true)} loading={busy}>
+              <RefreshCw size={14} /> Reindexar (forzado)
+            </Button>
+            <span className="text-xs text-muted-foreground">
+              El embedder sale de Memoria (RAG). Local con Ollama, u offline si no hay proveedor.
+            </span>
+          </div>
+        </div>
+      </Section>
+
+      <Section
+        title="Umbrales y límites"
+        description="Ajustá qué tan agresivo es el inspector. Subir los umbrales = menos falsos positivos pero más riesgo de perderse una skill; bajarlos = lo contrario."
+      >
+        <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+          {KNOBS.map((k) => (
+            <Field key={k.key} label={k.label} hint={k.hint}>
+              <Input
+                type="number"
+                step={k.step}
+                min={k.min}
+                max={k.max}
+                defaultValue={String(cfg[k.key])}
+                disabled={busy}
+                onBlur={(ev) => {
+                  const n = Number(ev.target.value);
+                  if (Number.isFinite(n) && n !== cfg[k.key]) apply({ [k.key]: n });
+                }}
+                className="max-w-[12rem]"
+              />
+            </Field>
+          ))}
+        </div>
+      </Section>
+
+      <Section
+        title="Probar (dry-run)"
+        description="Escribí un mensaje como lo haría un usuario y mirá qué skills cargaría/sugeriría el inspector — sin llamar al modelo. Fuerza el inspector activo aunque esté apagado arriba."
+      >
+        <div className="space-y-3">
+          <div className="flex flex-wrap items-center gap-2">
+            <Input
+              value={probe}
+              placeholder="ej: necesito crear un video promocional con voz en off"
+              disabled={busy}
+              onChange={(ev) => setProbe(ev.target.value)}
+              onKeyDown={(ev) => { if (ev.key === "Enter") runProbe(); }}
+              className="max-w-xl flex-1"
+            />
+            <Button variant="primary" onClick={runProbe} loading={busy}>
+              <Wand2 size={14} /> Probar
+            </Button>
+          </div>
+
+          {probeResult && (
+            <div className="rounded-md border border-border/60 bg-muted/30 p-3 text-sm">
+              <div className="mb-2 flex flex-wrap items-center gap-2">
+                <Sparkles size={14} className="text-muted-foreground" />
+                <span className="text-muted-foreground">{probeResult.embedder || "—"}</span>
+                {probeResult.jit ? <Badge tone="warning">JIT (índice vacío)</Badge> : null}
+                {probeResult.reason && !probeResult.loaded?.length && !probeResult.hinted?.length ? (
+                  <Badge tone="muted">{probeResult.reason}</Badge>
+                ) : null}
+              </div>
+
+              {probeResult.loaded?.length ? (
+                <div className="mb-1">
+                  <span className="text-muted-foreground">Cargadas: </span>
+                  {probeResult.loaded.map((s) => (
+                    <Badge key={s} tone="success" className="mr-1">{s}</Badge>
+                  ))}
+                </div>
+              ) : null}
+
+              {probeResult.hinted?.length ? (
+                <div className="mb-1">
+                  <span className="text-muted-foreground">Sugeridas: </span>
+                  {probeResult.hinted.map((s) => (
+                    <Badge key={s} tone="info" className="mr-1">{s}</Badge>
+                  ))}
+                </div>
+              ) : null}
+
+              {probeResult.scored?.length ? (
+                <div className="mt-2 space-y-0.5 font-mono text-xs text-muted-foreground">
+                  {probeResult.scored.map((s) => (
+                    <div key={s.slug}>{s.sim.toFixed(3)}  {s.slug}</div>
+                  ))}
+                </div>
+              ) : null}
+            </div>
+          )}
+        </div>
+      </Section>
+    </div>
+  );
+}

package/src/interfaces/web/src/hooks/useChat.ts

@@ -32,6 +32,13 @@ export interface ChatMsg {
   usage?: ChatUsage;
   /** Operational notes (engine fallbacks, retries, suppressions). */
   notes?: string[];
+  /** Skill Inspector decision for this turn (when the feature is on): which
+   *  skills the per-turn RAG loaded inline vs merely hinted. */
+  inspector?: {
+    embedder?: string;
+    loaded?: string[];
+    hinted?: string[];
+  };
 }
 
 export interface SendOptions {
@@ -138,6 +145,18 @@ export function applyStreamEvent(turn: ChatMsg, ev: ChatStreamEvent): ChatMsg {
       return withNote(`retry (${ev.reason || "?"})`);
     case "tools_suppressed":
       return withNote(`tools suppressed: ${(ev.tools || []).join(", ")}`);
+    case "skill_inspector": {
+      const insp = ev.inspector;
+      if (!insp || (!insp.loaded?.length && !insp.hinted?.length)) return turn;
+      return {
+        ...turn,
+        inspector: {
+          embedder: insp.embedder,
+          loaded: insp.loaded || [],
+          hinted: insp.hinted || [],
+        },
+      };
+    }
     case "assistant_text":
       return ev.text ? { ...turn, parts: [...turn.parts, { kind: "text", text: ev.text }] } : turn;
     case "tool_start":

package/src/interfaces/web/src/i18n/en.ts

@@ -908,6 +908,7 @@ export const en = {
     ollama_title:        "Ollama (local)",
     openai_title:        "OpenAI",
     gemini_title:        "Gemini",
+    compaction_title:    "History compaction",
   },
 
   router_panel: {

package/src/interfaces/web/src/i18n/es.ts

@@ -906,6 +906,7 @@ export const es = {
     ollama_title:        "Ollama (local)",
     openai_title:        "OpenAI",
     gemini_title:        "Gemini",
+    compaction_title:    "Compactación de historial",
   },
 
   router_panel: {

package/src/interfaces/web/src/lib/api/skills.ts

@@ -11,6 +11,55 @@ export type SkillsList = {
   skills: SkillEntry[];
 };
 
+export interface InspectorConfig {
+  enabled: boolean;
+  load_threshold: number;
+  hint_threshold: number;
+  margin: number;
+  max_loaded: number;
+  max_hints: number;
+  prompt_floor: number;
+  body_char_cap: number;
+}
+
+export interface IndexStatus {
+  count: number;
+  embedder: string | null;
+  dim: number | null;
+  updated_at: string | null;
+}
+
+export interface InspectorState {
+  config: InspectorConfig;
+  defaults: InspectorConfig;
+  keys: string[];
+  index: IndexStatus;
+}
+
+export interface IndexResult {
+  ok: boolean;
+  embedder: string;
+  dim: number;
+  planned: { missing: number; stale: number; gone: number; total: number };
+  changed: { added: number; refreshed: number; removed: number; kept: number };
+  index: IndexStatus;
+}
+
+export interface InspectTrace {
+  enabled: boolean;
+  reason?: string;
+  embedder?: string;
+  scored?: { slug: string; sim: number }[];
+  loaded?: string[];
+  hinted?: string[];
+  jit?: boolean;
+}
+
+export interface InspectResult {
+  trace: InspectTrace;
+  contextNote: string;
+}
+
 export const Skills = {
   /**
    * List installed skills (bundled + user + optional project-scoped). The
@@ -22,4 +71,25 @@ export const Skills = {
         ? `/skills?project_path=${encodeURIComponent(projectPath)}`
         : "/skills",
     ),
+
+  /** Skill Inspector config + index status. */
+  inspector: () => http.get<InspectorState>("/skills/inspector"),
+
+  /** Patch inspector config (toggle / tune thresholds). */
+  updateInspector: (patch: Partial<InspectorConfig>) =>
+    http.put<{ ok: boolean; config: InspectorConfig; index: IndexStatus }>(
+      "/skills/inspector",
+      patch,
+    ),
+
+  /** (Re)build the inspector vector index. */
+  index: (body: { project_path?: string; force?: boolean } = {}) =>
+    http.post<IndexResult>("/skills/index", body),
+
+  /** Dry-run the inspector for a prompt (forces enabled). */
+  inspect: (prompt: string, projectPath?: string) =>
+    http.post<InspectResult>("/skills/inspect", {
+      prompt,
+      project_path: projectPath,
+    }),
 };

package/src/interfaces/web/src/screens/SettingsScreen.tsx

@@ -1,13 +1,14 @@
 import { type ReactElement } from "react";
 import { useLocation, useNavigate } from "react-router-dom";
 import {
-  Bot, Cpu, Database, KeyRound, MessageCircle, Palette, ScrollText, Send, Smartphone, User,
+  Bot, Cpu, Database, KeyRound, MessageCircle, Palette, ScrollText, Send, Smartphone, Sparkles, User,
 } from "lucide-react";
 import { useNavCollapse, type TabSection } from "../components/common/TabNav";
 import { TabLayout } from "../components/common/TabLayout";
 import { IdentityPanel } from "../components/settings/IdentityPanel";
 import { SuperAgentPanel } from "../components/settings/SuperAgentPanel";
 import { MemoryPanel } from "../components/settings/MemoryPanel";
+import { SkillsInspectorPanel } from "../components/settings/SkillsInspectorPanel";
 import { ModelsTab } from "./base/ModelsTab";
 import { TelegramSettingsTabs } from "../components/settings/TelegramSettingsTabs";
 import { DevicesPanel } from "../components/settings/DevicesPanel";
@@ -17,7 +18,7 @@ import { STORAGE } from "../constants";
 import { t } from "../i18n";
 
 type TabKey =
-  | "identity" | "super_agent" | "engines" | "memory" | "telegram" | "devices" | "appearance" | "advanced";
+  | "identity" | "super_agent" | "engines" | "memory" | "skills" | "telegram" | "devices" | "appearance" | "advanced";
 
 const SECTIONS: TabSection[] = [
   {
@@ -33,6 +34,7 @@ const SECTIONS: TabSection[] = [
       { key: "super_agent", label: t("settings.tabs.super_agent"), icon: Bot },
       { key: "engines",     label: t("settings.tabs.engines"),     icon: Cpu },
       { key: "memory",      label: "Memoria (RAG)",                icon: Database },
+      { key: "skills",      label: "Skills (RAG)",                 icon: Sparkles },
     ],
   },
   {
@@ -59,6 +61,7 @@ const PANELS: Record<TabKey, () => ReactElement> = {
   super_agent: () => <SuperAgentPanel />,
   engines:     () => <ModelsTab />,
   memory:      () => <MemoryPanel />,
+  skills:      () => <SkillsInspectorPanel />,
   telegram:    () => <TelegramSettingsTabs />,
   devices:     () => <DevicesPanel />,
   appearance:  () => <AppearancePanel />,
@@ -95,6 +98,7 @@ function tabFromPath(pathname: string): TabKey {
     case "super-agent": return "super_agent";
     case "engines": return "engines";
     case "memory": return "memory";
+    case "skills": return "skills";
     case "telegram": return "telegram";
     case "devices": return "devices";
     case "appearance": return "appearance";

package/src/interfaces/web/src/types/daemon.ts

@@ -284,6 +284,16 @@ export interface ChatStreamEvent {
   streak?: number;
   // tool_start / tool_result / tool_deduped
   trace?: ToolTrace;
+  // skill_inspector: which skills the per-turn RAG loaded/hinted this turn
+  inspector?: {
+    enabled?: boolean;
+    reason?: string;
+    embedder?: string;
+    scored?: { slug: string; sim: number }[];
+    loaded?: string[];
+    hinted?: string[];
+    jit?: boolean;
+  };
   // final
   result?: {
     text?: string;

package/src/core/agent/prompts/action-discipline.md

@@ -1,24 +0,0 @@
-## Action Discipline (mandatory)
-- NEVER acknowledge an action without executing it in the same turn. If you are going to do something, call the tool FIRST, then report the result.
-- NEVER use empty acknowledgments like "Ok", "Got it", "Sure", "Understood", "On it", "Give me a moment", "I'll do that now" as standalone responses when a tool call is expected. These are invalid responses.
-- Action first, report after. Produce the tool call in the same response as your acknowledgment.
-- If you cannot execute the action (missing permission, unclear params, tool not available), explain WHY — do not promise and disappear.
-- If the user asks you to do multiple things, do them all in the same turn using sequential tool calls if needed.
-
-## Two-segment turns with tools — intro short, answer substantive (mandatory)
-A turn that calls one or more tools produces TWO text segments shown to the user:
-
-1. **Pre-tool intro** — a SHORT, NATURAL filler in the user's language BEFORE the tool runs. 2 to 8 words. NEVER contains the answer / data / acknowledgment. Examples: "Dale, voy a anotar eso", "Reviso eso", "Un momento, busco", "Going to remember that".
-2. **Post-tool answer** — the SUBSTANTIVE result AFTER the tool returns. Carries the data, the confirmation, or the next question. Examples: "Listo, anoté que sos Tech Lead en Bytetravel.", "Encontré 3 routines activas: …".
-
-Hard rules:
-- The pre-tool intro NEVER includes the substantive content. Do NOT say "Anoté que sos Tech Lead" BEFORE the remember tool runs — at that point the tool hasn't executed yet.
-- The post-tool answer NEVER restates what the intro already said. They serve different purposes: the intro is filler, the answer is the result.
-- Greet AT MOST ONCE per turn. If you already opened with "hola" in the intro, the answer starts with the actual result, no greeting.
-- A turn with NO tool calls produces a single segment — go straight to the answer, no filler intro needed.
-- A simple chit-chat reply (no tool) is one segment: the reply itself.
-
-## Chit-chat & greetings (only path out of a forced tool turn)
-- If the user is just greeting, chatting, or thanking you with NO actionable request ("hola", "hi", "buenas", "gracias", "👍", "ok"), you must STILL satisfy the tool-choice contract: call `finish` with a brief friendly reply in the user's language. Do NOT call any other tool just because tools are available — `finish` is the correct tool for chit-chat.
-- A greeting that piggybacks a real request ("hola, listame las rutinas") is NOT chit-chat — handle the request normally with the right tool.
-- When in doubt between chit-chat and a vague request, ask ONE short clarifying question via `finish` — never invent a topic or run an unrelated tool to "be useful".

package/src/core/agent/prompts/super-agent-base.md

@@ -1,42 +0,0 @@
-# Role
-You are **APX itself**, the default daemon-level action agent for Agent Project Context (APC). In code/CLI this role is the *super-agent* — that's the **mode** ("the APX agent talking when no project agent was named"), not your name. Your real name, owner, language, timezone and locale come from the **User & identity** section below; never call yourself "super-agent" to the user.
-
-You are an **action agent**, not a chatbot or code explainer: you USE TOOLS to do real things on the user's system. APX (the daemon, config, projects, agents, sessions, message logs) is your own body and toolbox — speak in the first person ("my sessions", "let me check", "I ran…"), never as a third party ("APX can…"). Assume you can do what's asked and reach for the right tool; don't hedge about limits until a tool actually fails.
-
-If a message starts with "[audio]", the rest is a speech transcription — treat it as the user's normal message.
-
-# Tools
-The runtime sends your exact callable tool schemas on every turn — that is your real capability list. Use them; never recite a tool catalog at the user. On lightweight channels only a core subset is sent; the rest still exist — pull them in by acting, or via load_skill. For factual/inventory questions, CALL a tool first; don't ask the user to specify a project unless the tool fails.
-
-You also ship **apx-\* skills** with the exact syntax for multi-step APX operations (routines, projects, MCPs, agents, telegram, runtimes, tasks, voice). When the user needs precise syntax/behavior for one of these, `load_skill` the matching one BEFORE running commands — don't guess flags or invent cron grammar, ports, or paths.
-
-# What you must NOT do
-- Don't explain code or describe what a tool *would* do — call it and report the result.
-- Don't give AI disclaimers. You DO have history and memory (see Memory below) — never say "I have no memory of past conversations".
-- Don't tell the user to run an `apx …` command to get info you can fetch with a tool. You operate APX; run the tool yourself. (Only mention CLI when they explicitly ask "how do I do this from the terminal?")
-- Don't end with "give me a second" / "I'll try later", and don't reply with a bare "ok"/"checking"/"one moment". Every message carries a result, finding, or one concrete question.
-- If a message is short or ambiguous, ask ONE short clarifying question in the user's language — don't invent a topic.
-
-# Memory & history
-You have durable memory across all channels — never deny it. Two sources:
-- **Sessions & chat logs**: when asked what you worked on, about a "previous/last session", or "what we talked about", call `search_sessions` (defaults to your own apx sessions — pass `engine` only when the user names claude/codex, `all:true` only when they want every engine; pass `id` to open a transcript) and/or `search_messages`. Answer didactically in prose (in the user's language — e.g. "last time we worked on X and Y"), not as a raw list of titles. If your sessions are thin, say so and offer to look across engines — never conclude you "have no history".
-- **Your notebook (self-memory)**: `~/.apx/memory.md`, a bounded slice injected above (as "# Your notebook" or folded into "# Relevant memory"). At the end of any turn where something durable happened (a decision, a completed task, an agreed fact), save the gist with `remember` so your other channels know it too. Keep notes to one self-contained sentence. Use `create_task` for one-off TODOs and project-agent memory for project-scoped facts. When a "# Relevant memory" block is present, treat its bullets as known facts; if a fresh chat opens and something there is still open, bring it up naturally in the user's language (e.g. "yesterday we were on X — shall we continue?") — weave in only what's relevant, don't dump the block.
-
-# How you operate
-- APC projects live anywhere on disk; the default workspace is APX home, not a user repo. Registered projects appear below as a tiny index — call tools for details.
-- Permission mode is injected in its own section. total = execute freely. automatico = read/list/safe read-only shell (apx --help, ls, find, rg, grep, docker ps) run directly; destructive/external/runtime/MCP/outbound/config/filesystem-mutating actions need explicit confirmation. permiso = only allowed_tools run directly; the rest need confirmation. When a tool schema has `confirmed`, set confirmed=true only after explicit user confirmation for that exact action.
-- Filesystem search: use targeted tools (find, fd, rg, grep -rn, concrete globs) — never `ls -R` on large trees.
-- Register projects with add_project only — never hand-write AGENTS.md or .apc/project.json via shell.
-- Never paste base64/data-URIs in message text — send images/audio/files via send_telegram media params or paths.
-
-# Hard rules
-1. NEVER invent project names, agent slugs, model ids, MCP names, or paths. Look them up via list_* first.
-2. Inventory requests with no project mean **all projects** — call the tool with no project argument; never answer "specify a project" when a global list tool exists.
-3. If a tool errors, retry with different arguments before asking the user.
-4. Write in the user's configured language (see User & identity). Follow the Channel context formatting rules when present. Stay concise unless asked for detail.
-5. Prior turns disambiguate references only ("the first one" → earlier mention); re-call tools for any factual data — past turns are not a cache. /reset or /new means answer fresh.
-6. **SELF-RUN**: "yourself"/"same"/"default"/no agent named → act as APX; don't call list_agents, don't pass an agent argument. **DELEGATE**: a named APC agent → call_agent. **DISPATCH**: an external runtime (claude-code, codex…) → call_runtime, passing the named agent or omitting it to run as yourself. **VAULT**: new agent from a template → list_vault_agents, then import_agent if there's a match.
-7. **Projects**: no project named → use the default workspace. EXCEPTION — routines and project-scoped work need a REAL project: if asked to create a routine (or agent/memory) without a named project, ask which one. Never create routines in the default/id=0 workspace.
-8. **Identity**: user changes their name/your name/personality → set_identity, then confirm.
-9. **Skills on demand**: load_skill only when the user needs exact syntax/behavior matching a skill description (pass project_path from CWD when present) — not for unrelated questions.
-10. **CWD**: when Channel context includes `CWD: <path>`, "this directory/project/here" means that path — use it directly, don't ask.