@agentprojectcontext/apx 1.32.2 → 1.33.1

package/package.json

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

package/skills/apc-context/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: apc-context
-description: "Activate whenever the project has a .apc/ directory or AGENTS.md — read .apc/ before assuming anything about agents, memory, or structure. If .apc/migrate.md exists, open with a migration offer first; if the user declines, delete it. Triggers: .apc/, AGENTS.md, 'which agents', 'list agents', 'agent context', 'who are the agents'."
+description: "ALWAYS activate when the project has a .apc/ directory or AGENTS.md file. Do not wait to be asked. Read .apc/ before making any assumption about agents, memory, or project structure. Activate on: .apc/, AGENTS.md, 'which agents', 'list agents', 'agent context', 'who are the agents', any question about agents or memory in this project. IMPORTANT: if .apc/migrate.md exists, open the conversation with a migration offer before answering anything else. If the user declines, delete .apc/migrate.md immediately so it is not shown again."
 homepage: https://github.com/agentprojectcontext/agentprojectcontext
 ---
 
@@ -66,13 +66,11 @@ After migration:
 ```text
 AGENTS.md                        ← root project contract
 .apc/
-  project.json                   ← project metadata (may carry an `apx` field)
-  config.json                    ← project-only config overrides (e.g. super_agent.model)
+  project.json                   ← project metadata
   .gitignore                     ← safety guard
   agents/<name>.md               ← agent definition
   agents/<name>/memory.md        ← optional curated project memory
   skills/<name>.md               ← reusable project instructions
-  commands/                      ← custom slash-commands (optional)
   mcps.json                      ← MCP hints without secrets
 ```
 
@@ -83,7 +81,6 @@ Do not store:
 .apc/sessions/
 .apc/conversations/
 .apc/messages/
-.apc/project.db
 .apc/cache/
 .apc/tmp/
 .apc/private/

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/apc/parser.js

@@ -123,7 +123,7 @@ import { fileURLToPath } from "node:url";
 const __parserDir = path.dirname(fileURLToPath(import.meta.url));
 
 export const VAULT_DIR = path.join(os.homedir(), ".apx", "agents");
-export const BUNDLED_VAULT_DIR = path.resolve(__parserDir, "../../assets/agent-vault-defaults");
+export const BUNDLED_VAULT_DIR = path.resolve(__parserDir, "../../../assets/agent-vault-defaults");
 export const VAULT_TOMBSTONE_PATH = path.join(VAULT_DIR, ".removed.json");
 
 function readVaultDirRaw(dir) {

package/src/core/apc/scaffold.js

@@ -16,7 +16,9 @@ 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, "..", "..", "..");
 const BUNDLED_SKILLS_DIR = path.join(PACKAGE_ROOT, "skills");
-const RUNTIME_SKILLS_DIR = path.join(__dirname, "runtime-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";
 

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

@@ -4,7 +4,9 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export const PACKAGE_ROOT = path.resolve(__dirname, "..", "..");
+// __dirname is src/core/apc/ after the Phase 3 move (was src/core/ before).
+// Repo root is three levels up, not two.
+export const PACKAGE_ROOT = path.resolve(__dirname, "..", "..", "..");
 
 export const APC_SKILL_REL = path.join("skills", "apc-context", "SKILL.md");
 export const APC_SKILL_REMOTE =

package/src/core/engines/gemini.js

@@ -51,15 +51,24 @@ function toGeminiContents(messages) {
     if (m.role === "assistant" && Array.isArray(m.tool_calls) && m.tool_calls.length > 0) {
       out.push({
         role: "model",
-        parts: m.tool_calls.map((tc) => ({
-          functionCall: {
-            name: tc.function?.name || tc.name,
-            args:
-              typeof tc.function?.arguments === "string"
-                ? safeParseJson(tc.function.arguments)
-                : tc.function?.arguments || tc.arguments || {},
-          },
-        })),
+        parts: m.tool_calls.map((tc) => {
+          const part = {
+            functionCall: {
+              name: tc.function?.name || tc.name,
+              args:
+                typeof tc.function?.arguments === "string"
+                  ? safeParseJson(tc.function.arguments)
+                  : tc.function?.arguments || tc.arguments || {},
+            },
+          };
+          // Gemini 3.x thinking models require us to echo back the
+          // thoughtSignature that came attached to the original functionCall
+          // part, or the API rejects the next turn with 400. We captured it
+          // in the response parser; replay it verbatim when present.
+          const sig = tc._thoughtSignature || tc.thought_signature;
+          if (sig) part.thoughtSignature = sig;
+          return part;
+        }),
       });
       continue;
     }
@@ -143,14 +152,22 @@ export default {
     for (const p of parts) {
       const fc = p.functionCall || p.function_call;
       if (fc?.name) {
-        toolCalls.push({
+        const tc = {
           id: `gemini_${randomUUID().slice(0, 8)}`,
           type: "function",
           function: {
             name: fc.name,
             arguments: typeof fc.args === "string" ? fc.args : JSON.stringify(fc.args || {}),
           },
-        });
+        };
+        // Thinking models (Gemini 3.x) attach a thoughtSignature to the part
+        // alongside the functionCall. We must replay it on the next request
+        // or the API 400s. Carry it on the tool_call so the next call to
+        // toGeminiContents() can put it back. Underscore prefix marks it as
+        // adapter-private metadata other engines should ignore.
+        const sig = p.thoughtSignature || p.thought_signature;
+        if (sig) tc._thoughtSignature = sig;
+        toolCalls.push(tc);
       }
     }
 

package/src/core/engines/index.js

@@ -52,12 +52,22 @@ export async function callEngine({ modelId, system, messages, config, temperatur
   const { provider, model } = resolveProvider(modelId);
   const adapter = getAdapter(provider);
   const providerCfg = (config && config.engines && config.engines[provider]) || {};
+  // The per-provider `default_max_tokens` set in the web admin (Provider modal
+  // slider) acts as a floor: callers may ask for more, but never less. This
+  // matters for "thinking" models (e.g. Gemini 3.x) whose internal reasoning
+  // tokens count against maxOutputTokens — too low a cap and the visible reply
+  // gets truncated mid-sentence. Fallback chain:
+  //   caller value → provider cfg → 2048 (safe baseline that survives thinking
+  //   models without truncating; non-thinking models just don't fill it).
+  const providerCap = Number(providerCfg.default_max_tokens) || 0;
+  const callerCap = Number(maxTokens) || 0;
+  const effectiveMaxTokens = Math.max(callerCap, providerCap) || 2048;
   return adapter.chat({
     system,
     messages,
     model,
     temperature,
-    maxTokens,
+    maxTokens: effectiveMaxTokens,
     tools,
     toolChoice,
     config: providerCfg,

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/engines.js

@@ -13,6 +13,11 @@ const DEFAULT_BASE = {
   ollama:     "http://localhost:11434",
 };
 
+// Gemini's native models endpoint returns a much richer catalog than the
+// OpenAI-compat shim (which only echoes back a handful). We always query the
+// native URL regardless of the user's configured base_url.
+const GEMINI_NATIVE_BASE = "https://generativelanguage.googleapis.com/v1beta";
+
 // Returns { models } or { error }. Reads the right /models endpoint per engine.
 async function listModels(engine, baseUrl, apiKey) {
   const base = String(baseUrl || DEFAULT_BASE[engine] || "").replace(/\/$/, "");
@@ -37,7 +42,32 @@ async function listModels(engine, baseUrl, apiKey) {
     return { models: data.map((m) => m?.id).filter(Boolean) };
   }
 
-  // openai-compatible family: openai, groq, openrouter, gemini, azure, custom
+  if (engine === "gemini") {
+    if (!apiKey) return { error: "falta api_key" };
+    // Native Gemini API: returns a `models` array with rich metadata, including
+    // `supportedGenerationMethods` so we can drop embeddings/vision-only entries.
+    // Names come back as "models/<id>"; strip the prefix for display.
+    const r = await fetchJsonWithTimeout(
+      `${GEMINI_NATIVE_BASE}/models?key=${encodeURIComponent(apiKey)}&pageSize=200`,
+      { timeoutMs: 5000 },
+    );
+    if (!r.ok) return { error: r.reason || `HTTP ${r.status}` };
+    const data = Array.isArray(r.json?.models) ? r.json.models : [];
+    const models = data
+      .filter((m) => {
+        const methods = m?.supportedGenerationMethods;
+        if (!Array.isArray(methods)) return true;
+        return methods.includes("generateContent");
+      })
+      .map((m) => {
+        const name = typeof m?.name === "string" ? m.name : "";
+        return name.startsWith("models/") ? name.slice("models/".length) : name;
+      })
+      .filter(Boolean);
+    return { models };
+  }
+
+  // openai-compatible family: openai, groq, openrouter, azure, custom
   if (!apiKey) return { error: "falta api_key" };
   if (!base) return { error: "falta base_url" };
   const r = await fetchJsonWithTimeout(`${base}/models`, {

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)