@agentprojectcontext/apx 1.32.2 → 1.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.32.2",
+  "version": "1.33.0",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"

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

@@ -5,11 +5,18 @@
 - 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.
 
-## One reply per turn — no repeated greetings (mandatory)
-- A single turn can produce SEVERAL text segments: a short narration you write BEFORE calling a tool, and the final answer that comes AFTER the tool runs. On some surfaces each segment is shown separately.
-- Greet AT MOST ONCE per turn. If you already said "hola"/"hi" in an early segment, do NOT greet again in the final answer — start it with the actual content.
-- NEVER repeat the same sentence, greeting, or summary across segments of the same turn. Each segment is shown in full.
-- On simple requests, SKIP the intro entirely: go straight to the work, then give the result once. Only add a short intro when the work will clearly take more than a single quick tool call, and keep it to a few words ("un momento…", "reviso eso…").
+## 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.

package/src/core/agent/prompts/channels/telegram.md

@@ -6,9 +6,13 @@ Formatting:
 - Keep replies brief (~6 sentences unless user asks for more)
 - Previous turns are conversational context only; re-call tools for facts
 
-What the user sees here: ONLY your final text reply. They do NOT see your tool calls, args, or intermediate results — those never reach Telegram. So if a request needs real work (running something, searching, editing, a multi-step task), the channel sends a short "on it" heads-up for you; you still must report what you actually did in plain words at the end. Never assume they saw what you ran.
+What the user sees here: only your text segments. They do NOT see your tool calls, args, or intermediate results — those never reach Telegram.
 
-Segments policy: when you write any prose BEFORE calling a tool (an intro like "voy a revisar…") it lands as its OWN Telegram message — separate from the final answer that comes AFTER the tool runs. So:
-- Greet at most ONCE per turn. If you already said "Hola" in the intro segment, do NOT greet again in the final answer. Start the final answer with the actual content.
-- Prefer to skip the intro entirely on simple requests — go straight to the work, then answer. Only add an intro when the work will take noticeably longer than a single tool call.
-- Never repeat the same sentence across segments — each message is shown in full to the user.
+Two-segment turn (intro + answer):
+- When you call a tool, write a SHORT natural intro BEFORE the tool runs (2–8 words in the user's language: "Dale, voy a anotar eso", "Reviso eso", "Un momento, busco esos datos"). That lands as a Telegram message of its own so the user sees you're working.
+- AFTER the tool returns, write the substantive answer with the actual result or confirmation. That is the second Telegram message.
+- The intro NEVER contains the substantive content — at that point the tool hasn't run yet, so you don't know the result. Wrong: "¡Anotado! Sos Tech Lead en Bytetravel" BEFORE remember runs. Right: "Dale, voy a anotar eso" before, then "Listo, anoté que sos Tech Lead." after.
+- The answer NEVER restates the intro. They're complementary: filler + result, not the same content twice.
+- Greet at most ONCE per turn. If the intro opened with "Hola", the answer starts with the result, no second greeting.
+
+Turns without tools (small talk, "hola", "gracias"): a single message — the reply itself, no intro filler.

package/src/core/stores/code-sessions.js

@@ -49,6 +49,7 @@ function toRow(s) {
     title: s.title,
     mode: s.mode,
     model: s.model || null,
+    agentSlug: s.agentSlug || null,
     createdAt: s.createdAt,
     updatedAt: s.updatedAt,
     messageCount: Array.isArray(s.messages) ? s.messages.length : 0,
@@ -78,7 +79,7 @@ export function getCodeSession(storagePath, id) {
 
 /**
  * Create a new session.
- * fields: { projectId, title?, model?, mode?, git? }
+ * fields: { projectId, title?, model?, mode?, git?, agentSlug? }
  */
 export function createCodeSession(storagePath, fields = {}) {
   const id = shortId();
@@ -91,6 +92,7 @@ export function createCodeSession(storagePath, fields = {}) {
     updatedAt: ts,
     model: fields.model || null,
     mode: fields.mode === "plan" ? "plan" : "build",
+    agentSlug: fields.agentSlug || null,
     git: fields.git && typeof fields.git === "object" ? fields.git : null,
     messages: [],
   };
@@ -108,6 +110,7 @@ export function updateCodeSession(storagePath, id, patch = {}) {
   if (patch.title != null) session.title = String(patch.title).trim() || session.title;
   if (patch.model !== undefined) session.model = patch.model || null;
   if (patch.mode === "plan" || patch.mode === "build") session.mode = patch.mode;
+  if (patch.agentSlug !== undefined) session.agentSlug = patch.agentSlug || null;
   if (patch.git !== undefined) session.git = patch.git;
   session.updatedAt = nowIso();
   writeJson(sessionFile(storagePath, id), session);

package/src/host/daemon/api/artifacts.js

@@ -119,6 +119,31 @@ export function register(app, { project }) {
     }
   });
 
+  app.patch("/projects/:pid/artifacts/:name", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const name = decodeURIComponent(req.params.name);
+    const { content, newName } = req.body || {};
+    try {
+      const absPath = artifactPath(p.storagePath, name);
+      if (!fs.existsSync(absPath)) {
+        return res.status(404).json({ error: `artifact "${name}" not found` });
+      }
+      if (typeof content === "string") {
+        fs.writeFileSync(absPath, content, "utf8");
+      }
+      let finalName = name;
+      if (newName && newName !== name) {
+        const newAbsPath = artifactPath(p.storagePath, newName);
+        fs.renameSync(absPath, newAbsPath);
+        finalName = newName;
+      }
+      res.json({ ok: true, name: finalName });
+    } catch (e) {
+      res.status(400).json({ error: e.message });
+    }
+  });
+
   app.delete("/projects/:pid/artifacts/:name", (req, res) => {
     const p = project(req, res);
     if (!p) return;

package/src/host/daemon/api/code.js

@@ -26,6 +26,7 @@ import {
 } from "#core/stores/code-sessions.js";
 import { captureBaseline, diffAgainstBaseline, initGitRepo } from "#core/git-baseline.js";
 import { loggerFor } from "#core/logging.js";
+import { readAgents } from "#core/apc/parser.js";
 
 const log = loggerFor("code");
 
@@ -212,7 +213,7 @@ export function register(app, { projects, project, config, registries, plugins }
   app.post("/projects/:pid/code/sessions", (req, res) => {
     const p = findProject(req, res);
     if (!p) return;
-    const { title, model, mode } = req.body || {};
+    const { title, model, mode, agentSlug } = req.body || {};
     let git = captureBaseline(p.path);
     // No baseline because the project isn't a git repo yet. For real projects
     // (not the default apx home, id 0) init one so the "changes" diff works —
@@ -230,6 +231,7 @@ export function register(app, { projects, project, config, registries, plugins }
       title,
       model,
       mode,
+      agentSlug: agentSlug || null,
       git,
     });
     res.status(201).json(session);
@@ -291,6 +293,15 @@ export function register(app, { projects, project, config, registries, plugins }
     const mode = session.mode === "plan" ? "plan" : "build";
     const previousMessages = historyFrom(session);
 
+    // If a project agent is selected, inject its system prompt as a suffix so
+    // the super-agent's tool loop runs with the agent's personality/context.
+    let agentSystemSuffix = "";
+    if (session.agentSlug) {
+      const agents = readAgents(p.path);
+      const agent = agents.find((a) => a.slug === session.agentSlug);
+      if (agent?.body) agentSystemSuffix = `\n\n## Agente seleccionado: ${session.agentSlug}\n${agent.body}`;
+    }
+
     // Persist the user turn immediately so a crash mid-stream still records it.
     appendTurn(p.storagePath, session.id, {
       role: "user",
@@ -324,8 +335,10 @@ export function register(app, { projects, project, config, registries, plugins }
           projectPath: p.path,
           mode,
           modeGuidance: modeGuidanceFor(mode),
+          agentSlug: session.agentSlug || null,
         },
         previousMessages,
+        systemSuffix: agentSystemSuffix,
         overrideModel: session.model || undefined,
         allowedTools: mode === "plan" ? PLAN_TOOLS : "*",
         // Coding tasks are multi-step: give the loop a high safety ceiling so it

package/src/host/daemon/api/exec.js

@@ -7,6 +7,7 @@
 import { callEngine } from "#core/engines/index.js";
 import { readAgents } from "#core/apc/parser.js";
 import { buildAgentSystem } from "#core/agent/build-agent-system.js";
+import { resolveActiveModel } from "#core/agent/model-router.js";
 import {
   startConversation,
   appendTurn,
@@ -14,6 +15,20 @@ import {
   setStatus,
 } from "../conversations.js";
 
+// Pick a model for a direct agent chat: explicit override → agent's own model →
+// super-agent default (resolved via the same router the super-agent uses, so
+// it walks the fallback chain when the primary is empty/unhealthy).
+async function pickAgentModel({ modelOverride, agent, config }) {
+  if (modelOverride) return modelOverride;
+  if (agent.fields?.Model) return agent.fields.Model;
+  try {
+    const routing = await resolveActiveModel(config);
+    return routing?.modelId || null;
+  } catch {
+    return null;
+  }
+}
+
 export function register(app, { projects, project, config }) {
   app.post("/projects/:pid/agents/:slug/exec", async (req, res) => {
     const p = project(req, res);
@@ -28,7 +43,7 @@ export function register(app, { projects, project, config }) {
     const agents = readAgents(p.path);
     const agent = agents.find((a) => a.slug === req.params.slug);
     if (!agent) return res.status(404).json({ error: "agent not found" });
-    const modelId = modelOverride || agent.fields.Model;
+    const modelId = await pickAgentModel({ modelOverride, agent, config });
     if (!modelId)
       return res
         .status(400)
@@ -106,7 +121,7 @@ export function register(app, { projects, project, config }) {
     const agents = readAgents(p.path);
     const agent = agents.find((a) => a.slug === req.params.slug);
     if (!agent) return res.status(404).json({ error: "agent not found" });
-    const modelId = modelOverride || agent.fields.Model;
+    const modelId = await pickAgentModel({ modelOverride, agent, config });
     if (!modelId)
       return res
         .status(400)

package/src/host/daemon/plugins/telegram/index.js

@@ -44,7 +44,6 @@ 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 { isLikelyDuplicate } from "#core/util/text-similarity.js";
 import { createTelegramConfirmAdapter } from "#core/confirmation/adapters/telegram.js";
 import * as askFlow from "./ask.js";
 
@@ -645,12 +644,6 @@ class ChannelPoller {
           if (ev.type === "assistant_text" && ev.text) {
             const piece = stripThinking(ev.text).trim();
             if (!piece) return;
-            // Skip post-tool segments that just restate the pre-tool intro —
-            // weaker models (gemini-flash et al.) frequently paraphrase the
-            // same content twice within a single turn.
-            if (lastStreamedText && isLikelyDuplicate(piece, lastStreamedText)) {
-              return;
-            }
             await this._send({ chat_id, text: piece });
             lastStreamedText = piece;
             streamedCount += 1;
@@ -798,13 +791,8 @@ class ChannelPoller {
     // turn isn't silently empty.
     const finalClean = replyText ? stripThinking(replyText).trim() : "";
     let toSend = "";
-    // Fuzzy dedupe against the last streamed segment: catches paraphrases
-    // (Jaccard ≥ 0.4 or short-mostly-inside-long), not just exact matches.
-    if (finalClean && !isLikelyDuplicate(finalClean, lastStreamedText) && finalClean !== lastStreamedText) {
-      toSend = finalClean;
-    } else if (!finalClean && streamedCount === 0) {
-      toSend = "Listo.";
-    }
+    if (finalClean && finalClean !== lastStreamedText) toSend = finalClean;
+    else if (!finalClean && streamedCount === 0) toSend = "Listo.";
 
     stopTyping();
     if (!toSend) return; // everything was already streamed — nothing left to send