@agentprojectcontext/apx 1.34.0 → 1.36.0

package/src/interfaces/web/src/screens/project/ChatTab.tsx

@@ -4,11 +4,11 @@ import useSWR from "swr";
 import { Plus, Trash2 } from "lucide-react";
 import { Agents } from "../../lib/api";
 import { Badge, Button, Dialog, Empty, Field, Input, Loading, Switch } from "../../components/ui";
-import { UiSelect } from "../../components/UiSelect";
 import { Composer } from "../../components/chat/Composer";
 import { MessageList } from "../../components/chat/MessageList";
 import { ContextBar } from "../../components/chat/ContextBar";
 import { InlineAskPanel, pendingAskQuestions } from "../../components/chat/InlineAskPanel";
+import { ChatList, type ChatKey } from "../../components/chat/ChatList";
 import { useChat } from "../../hooks/useChat";
 import { useToast } from "../../components/Toast";
 import { t } from "../../i18n";
@@ -24,48 +24,56 @@ export function ChatTab({ pid }: { pid: string }) {
   const toast = useToast();
   const [params] = useSearchParams();
   const agents = useSWR(`/projects/${pid}/agents`, () => Agents.list(pid));
-  const [activeSlug, setActiveSlug] = useState(params.get("agent") || "");
   const [creating, setCreating] = useState(false);
   const [model, setModel] = useState("");
   const [dismissedAskKey, setDismissedAskKey] = useState<string | null>(null);
-  const { msgs, send: sendChat, stop, clear, streaming } = useChat(pid, (m) => toast.error(m));
+  const { msgs, send: sendChat, stop, clear, load, streaming, conversationId } =
+    useChat(pid, (m) => toast.error(m));
   const persona = usePersonaName();
 
+  // Selection state — drives both the sidebar highlight and the right-pane
+  // header. Defaults to a live session with the super-agent so the chat works
+  // even on a brand-new project with zero agents and zero conversations.
+  const initialFromUrl = params.get("agent");
+  const [selected, setSelected] = useState<ChatKey>(
+    initialFromUrl
+      ? { kind: "live", agentSlug: initialFromUrl }
+      : { kind: "live", agentSlug: ROBY_SLUG },
+  );
+
   const agentList = agents.data || [];
-  // Virtual options shown in the dropdown — the super-agent is always first,
-  // then the real project agents. It works on every project (calls
-  // /projects/:pid/super-agent/chat) so we expose it everywhere, not just /base.
   const isRoby = (slug: string | null | undefined) => slug === ROBY_SLUG;
-  const dropdownOptions = useMemo(
-    () => [
-      { value: ROBY_SLUG, label: `${persona} (super-agent)` },
-      ...agentList.map((a) => ({ value: a.slug, label: a.slug })),
-    ],
-    [agentList, persona],
-  );
+
+  // The agent whose dropdown badge / model we show on the right header.
   const activeAgent = useMemo(
-    () => agentList.find((a) => a.slug === activeSlug) || agentList[0],
-    [agentList, activeSlug],
+    () =>
+      selected.kind === "live"
+        ? agentList.find((a) => a.slug === selected.agentSlug)
+        : agentList.find((a) => a.slug === selected.agentSlug),
+    [agentList, selected],
   );
-  // Effective slug we'll send with: Roby if explicitly selected, or the first
-  // real agent, or Roby when the project has no agents at all.
-  const effectiveSlug = isRoby(activeSlug)
-    ? ROBY_SLUG
-    : (activeAgent?.slug || ROBY_SLUG);
-  const activeIsRoby = effectiveSlug === ROBY_SLUG;
+  const activeIsRoby = isRoby(selected.agentSlug);
 
+  // Whenever the user picks a stored conversation, reload the in-memory chat
+  // with its persisted history. The hook itself binds the conversation_id so
+  // subsequent sends append to the same file.
   useEffect(() => {
-    if (!activeSlug && activeAgent?.slug) setActiveSlug(activeAgent.slug);
-  }, [activeAgent?.slug, activeSlug]);
-
-  const resetConversation = () => clear();
+    if (selected.kind === "conv") {
+      void load(selected.agentSlug, selected.convId);
+    } else {
+      // Switching to a live session = drop any previously bound conversation.
+      if (conversationId) clear();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [selected.kind, selected.kind === "conv" ? selected.convId : selected.agentSlug]);
 
   const send = async (text: string) => {
-    if (!activeIsRoby && !activeAgent) return;
-    await sendChat(text, {
-      model: model || undefined,
-      agentSlug: activeIsRoby ? undefined : activeAgent!.slug,
-    });
+    if (activeIsRoby) {
+      await sendChat(text, { model: model || undefined });
+      return;
+    }
+    if (!activeAgent) return;
+    await sendChat(text, { model: model || undefined, agentSlug: activeAgent.slug });
   };
 
   const copyToClipboard = async (text: string) => {
@@ -73,72 +81,97 @@ export function ChatTab({ pid }: { pid: string }) {
     catch { /* ignore */ }
   };
 
-  if (agents.isLoading) return <Loading />;
+  const onNewChat = () => {
+    setSelected({ kind: "live", agentSlug: ROBY_SLUG });
+    clear();
+  };
 
+  const headerTitle = activeIsRoby
+    ? t("project.chat.superagent_title", { persona })
+    : selected.kind === "conv"
+      ? selected.convId
+      : t("project.chat.title");
   const headerSubtitle = activeIsRoby
     ? t("project.chat.superagent_subtitle", { persona })
-    : t("project.chat.subtitle");
+    : selected.kind === "conv"
+      ? t("project.chat.loaded_subtitle", { slug: selected.agentSlug })
+      : t("project.chat.subtitle");
+
+  if (agents.isLoading) return <Loading />;
 
   return (
-    <div className="flex h-full flex-col overflow-hidden rounded-xl border border-border bg-card/40">
-      <header className="flex shrink-0 items-center justify-between gap-3 border-b border-border px-4 py-3">
-        <div className="min-w-0">
-          <h2 className="text-sm font-semibold">
-            {activeIsRoby ? t("project.chat.superagent_title", { persona }) : t("project.chat.title")}
-          </h2>
-          <p className="truncate text-[11px] text-muted-fg">{headerSubtitle}</p>
-        </div>
-        <div className="flex items-center gap-2">
-          <div className="w-52">
-            <UiSelect
-              value={effectiveSlug}
-              onChange={(v) => { setActiveSlug(v); resetConversation(); }}
-              options={dropdownOptions}
-            />
+    <div className="flex h-full overflow-hidden rounded-xl border border-border bg-card/40">
+      <ChatList
+        pid={pid}
+        agents={agentList}
+        superAgentSlug={ROBY_SLUG}
+        superAgentLabel={`${persona} (super-agent)`}
+        selected={selected}
+        onSelect={setSelected}
+        onNewChat={onNewChat}
+      />
+
+      <section className="flex min-w-0 flex-1 flex-col">
+        <header className="flex shrink-0 items-center justify-between gap-3 border-b border-border px-4 py-3">
+          <div className="min-w-0">
+            <h2 className="truncate text-sm font-semibold">{headerTitle}</h2>
+            <p className="truncate text-[11px] text-muted-fg">{headerSubtitle}</p>
           </div>
-          {activeIsRoby
-            ? <Badge tone="success">super-agent</Badge>
-            : activeAgent?.model && <Badge tone="info">{activeAgent.model}</Badge>}
-          {!agentList.length && !activeIsRoby && (
-            <Button variant="primary" size="sm" onClick={() => setCreating(true)}>
-              <Plus size={14} /> {t("project.chat.create_agent")}
+          <div className="flex items-center gap-2">
+            {activeIsRoby ? (
+              <Badge tone="success">super-agent</Badge>
+            ) : (
+              activeAgent?.model && <Badge tone="info">{activeAgent.model}</Badge>
+            )}
+            {selected.kind === "conv" && <Badge tone="info">{conversationId || "…"}</Badge>}
+            {!agentList.length && !activeIsRoby && (
+              <Button variant="primary" size="sm" onClick={() => setCreating(true)}>
+                <Plus size={14} /> {t("project.chat.create_agent")}
+              </Button>
+            )}
+            <Button
+              variant="ghost"
+              size="sm"
+              disabled={streaming || msgs.length === 0}
+              onClick={onNewChat}
+            >
+              <Trash2 size={13} /> {t("project.chat.clear")}
             </Button>
+          </div>
+        </header>
+
+        <div className="flex-1 overflow-y-auto">
+          {msgs.length ? (
+            <MessageList msgs={msgs} onCopy={copyToClipboard} />
+          ) : (
+            <div className="flex h-full items-center justify-center p-8">
+              <p className="text-sm text-muted-fg">{t("project.chat.empty")}</p>
+            </div>
           )}
-          <Button variant="ghost" size="sm" disabled={streaming || msgs.length === 0} onClick={resetConversation}>
-            <Trash2 size={13} /> {t("project.chat.clear")}
-          </Button>
         </div>
-      </header>
-      <div className="flex-1 overflow-y-auto">
-        {msgs.length ? (
-          <MessageList msgs={msgs} onCopy={copyToClipboard} />
-        ) : (
-          <div className="flex h-full items-center justify-center p-8">
-            <p className="text-sm text-muted-fg">{t("project.chat.empty")}</p>
-          </div>
-        )}
-      </div>
-      <ContextBar msgs={msgs} />
-      {(() => {
-        const pending = !streaming ? pendingAskQuestions(msgs) : null;
-        if (!pending || pending.turnKey === dismissedAskKey) return null;
-        return (
-          <InlineAskPanel
-            turnKey={pending.turnKey}
-            questions={pending.questions}
-            onSubmit={(compiled) => void send(compiled)}
-            onDismiss={() => setDismissedAskKey(pending.turnKey)}
-            disabled={streaming}
-          />
-        );
-      })()}
-      <Composer
-        onSend={send}
-        onStop={stop}
-        streaming={streaming}
-        model={model}
-        onModelChange={setModel}
-      />
+        <ContextBar msgs={msgs} />
+        {(() => {
+          const pending = !streaming ? pendingAskQuestions(msgs) : null;
+          if (!pending || pending.turnKey === dismissedAskKey) return null;
+          return (
+            <InlineAskPanel
+              turnKey={pending.turnKey}
+              questions={pending.questions}
+              onSubmit={(compiled) => void send(compiled)}
+              onDismiss={() => setDismissedAskKey(pending.turnKey)}
+              disabled={streaming}
+            />
+          );
+        })()}
+        <Composer
+          onSend={send}
+          onStop={stop}
+          streaming={streaming}
+          model={model}
+          onModelChange={setModel}
+        />
+      </section>
+
       <CreateAgentDialog
         open={creating}
         pid={pid}

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.