@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/core/profiles/bundled/secretary/config.schema.es.json

@@ -0,0 +1,68 @@
+{
+  "properties": {
+    "day_open_schedule": {
+      "title": "Abre el día (cron)",
+      "description": "Cuándo corre el anclaje de la mañana. Cron de cinco campos, en la hora local de la máquina."
+    },
+    "day_close_schedule": {
+      "title": "Cierra el día (cron)",
+      "description": "Cuándo corre el anclaje de la tarde."
+    },
+    "nudge_budget_per_day": {
+      "title": "Mensajes no pedidos por día",
+      "description": "El tope fuera de los anclajes. Menos suele ser mejor. Declarar esto activa el presupuesto de interrupciones."
+    },
+    "quiet_hours": {
+      "title": "Horas de silencio",
+      "description": "Sin mensajes no pedidos en esta ventana. Las respuestas nunca se retienen."
+    },
+    "nudge_project_cooldown_minutes": {
+      "title": "Espacio mínimo por proyecto (minutos)",
+      "description": "Tres ideas sueltas sobre el mismo proyecto en una hora es una interrupción de más."
+    },
+    "nudge_kind_cooldown_minutes": {
+      "title": "Espacio mínimo por tipo (minutos)",
+      "description": "Evita que una condición que se repite llene el presupuesto del día ella sola."
+    },
+    "watch_schedule": {
+      "title": "Corre el watch (cron)",
+      "description": "Cada cuánto barre cosas que valga la pena notar entre los anclajes. Barato: si no hay nada que reportar, nunca despierta al modelo."
+    },
+    "calendar_command": {
+      "title": "Comando de calendario (opcional)",
+      "description": "Comando de shell que imprime la agenda de hoy. Su salida llega al anclaje de la mañana ya buscada, así que leerla no cuesta ni una llamada a herramienta ni un permiso. Vacío significa sin calendario, y el anclaje simplemente no dice nada de eso. Ejemplo: apx mcp run calendar list_events '{\"timeMin\":\"today\"}'"
+    },
+    "stale_project_days": {
+      "title": "Un proyecto queda inactivo tras (días)",
+      "description": "Días sin actividad registrada de tarea o compromiso antes de que valga mencionarlo."
+    },
+    "blocked_task_hours": {
+      "title": "Una tarea bloqueada queda trabada tras (horas)",
+      "description": "Bloqueada esta mañana es un estado de trabajo normal, no un problema."
+    },
+    "commitment_lead_hours": {
+      "title": "Avisar de una promesa con esta anticipación (horas)",
+      "description": "Cuánto antes de su fecha levantar un compromiso, mientras todavía hay tiempo de cumplirlo."
+    },
+    "primary_channel": {
+      "title": "Canal principal",
+      "description": "A dónde van los mensajes no pedidos por defecto."
+    },
+    "routine_delivery": {
+      "type": "string",
+      "enum": [
+        "telegram",
+        "web",
+        "telegram,web",
+        "none"
+      ],
+      "default": "telegram",
+      "title": "Dónde se entregan los anclajes",
+      "description": "Los mensajes de apertura y cierre los entrega el runtime a este canal, así llegan aunque el modelo se olvide de mandarlos. Con 'none' quedan solo en el registro."
+    },
+    "formality": {
+      "title": "Trato",
+      "description": "Solo tiene efecto en idiomas que lo distinguen (tú / vos / usted)."
+    }
+  }
+}

package/src/core/profiles/bundled/secretary/config.schema.json

@@ -43,6 +43,12 @@
       "title": "Watch runs (cron)",
       "description": "How often to sweep for things worth noticing between the anchors. Cheap: with nothing to report it never wakes the model."
     },
+    "calendar_command": {
+      "type": "string",
+      "default": "",
+      "title": "Calendar command (optional)",
+      "description": "Shell command that prints today's agenda. Its output reaches the morning anchor already fetched, so reading it costs no tool call and no permission. Blank means no calendar, and the anchor simply says nothing about one. Example: apx mcp run calendar list_events '{\"timeMin\":\"today\"}'"
+    },
     "stale_project_days": {
       "type": "integer",
       "default": 7,
@@ -63,14 +69,36 @@
     },
     "primary_channel": {
       "type": "string",
-      "enum": ["telegram", "desktop", "cli", "web"],
+      "enum": [
+        "telegram",
+        "desktop",
+        "cli",
+        "web"
+      ],
       "default": "telegram",
       "title": "Primary channel",
       "description": "Where unrequested messages go by default."
     },
+    "routine_delivery": {
+      "type": "string",
+      "enum": [
+        "telegram",
+        "web",
+        "telegram,web",
+        "none"
+      ],
+      "default": "telegram",
+      "title": "Where the anchors are delivered",
+      "description": "The morning and evening messages are handed to this channel by the runtime, so they arrive whether or not the model remembers to send them. 'none' keeps them in the log only."
+    },
     "formality": {
       "type": "string",
-      "enum": ["tu", "vos", "usted", "neutral"],
+      "enum": [
+        "tu",
+        "vos",
+        "usted",
+        "neutral"
+      ],
       "default": "neutral",
       "title": "Form of address",
       "description": "Only meaningful in languages that distinguish it."

package/src/core/profiles/bundled/secretary/profile.json

@@ -11,7 +11,9 @@
   "provides": {
     "routines": [
       "day-open",
-      "day-close"
+      "day-close",
+      "watch",
+      "a2a-sweep"
     ],
     "channels": [
       "routine"

package/src/core/profiles/bundled/secretary/routines/a2a-sweep.json

@@ -0,0 +1,20 @@
+{
+  "name": "a2a-sweep",
+  "kind": "watch",
+  "schedule": "*/20 * * * *",
+  "permission_mode": "permiso",
+  "enabled_by_default": true,
+  "spec": {
+    "prompt": "You are sweeping the agent-to-agent (a2a) inbox for {{owner_name}}. The signals below are messages other agents sent for them since the last sweep — facts, already gathered.\n\nDecide which, if any, are worth {{owner_name}} hearing RIGHT NOW versus folding into the next day-open/day-close brief. A `blocker` is urgent and crosses even quiet-hours; a `status` or `fyi` almost always waits for the brief. Most sweeps should stay quiet. A promise inside a message is already tracked as a commitment — do not repeat it here.\n\nIf you decide to speak, your reply IS the message: ONE line, second person, ready to read. This routine delivers what you write to {{owner_name}}'s channel — there is no send tool to call, and the interruption budget still applies (a blocker or a message they solicited crosses it; ordinary status/fyi is held when the budget says so). If you decide to stay quiet, do NOT write that decision as a message. Reply with `NO_MESSAGE` as the very first line and put your reasoning on the lines after it. The marker is what keeps it off {{owner_name}}'s phone and off their interruption budget; what you write after it is filed as a note they can go and read, not a message they receive.\n\nNote what you learned with remember_routine, especially when you stayed quiet.",
+    "types": [
+      "a2a_message"
+    ]
+  },
+  "deliver_to": [
+    "profile"
+  ],
+  "allowed_tools": [
+    "send_telegram",
+    "remember_routine"
+  ]
+}

package/src/core/profiles/bundled/secretary/routines/day-close.json

@@ -5,9 +5,12 @@
   "permission_mode": "permiso",
   "enabled_by_default": true,
   "spec": {
-    "prompt": "Close the day, across every registered project.\n\nHOW TO SPEND YOUR STEPS. You get a small, fixed number of tool calls, and the LAST one is taken away from you to write your closing prose — so a turn spent exploring ends with nothing delivered. Gather with list_tasks and list_commitments (once each, no project argument) and NOTHING ELSE. Do not search sessions, do not read files, do not run shell commands: none of that is what {{owner_name}} asked for. Then send, immediately. Report what you actually have; an honest short message beats a complete one that never arrives.\n\nSend ONE short message with three things: what moved today, what is still stuck, and what carries over. Keep promises to people separate from ordinary tasks — if a commitment came due today, ask whether it was kept rather than marking it yourself. Note anything that has gone quiet longer than the staleness threshold. If the day was quiet, say that plainly in a line.\n\nDELIVERY: send_telegram. A routine's own output is only written to the log — if you do not call the tool, {{owner_name}} receives nothing at all. One message, then stop.\n\nAfter sending, record with remember_routine anything durable you learned about how this person works — one line. Never write_file for this: a scheduled run has nobody to approve it and the whole turn dies there.",
+    "prompt": "Close the day, across every registered project.\n\nHOW TO SPEND YOUR STEPS. You get a small, fixed number of tool calls, and the LAST one is taken away from you to write your closing prose — so a turn spent exploring ends with nothing delivered. Gather with list_tasks and list_commitments (once each, no project argument) and NOTHING ELSE. Do not search sessions, do not read files, do not run shell commands: none of that is what {{owner_name}} asked for. Then send, immediately. Report what you actually have; an honest short message beats a complete one that never arrives.\n\nSend ONE short message with three things: what moved today, what is still stuck, and what carries over. Keep promises to people separate from ordinary tasks — if a commitment came due today, ask whether it was kept rather than marking it yourself. Note anything that has gone quiet longer than the staleness threshold. If the day was quiet, say that plainly in a line.\n\nDELIVERY: your closing message IS the message. This routine delivers what you write to the channel itself, so there is no send tool to call — write the last thing you say AS the message, in the second person, ready to read. One message, then stop.\n\nAfter sending, record with remember_routine anything durable you learned about how this person works — one line. Never write_file for this: a scheduled run has nobody to approve it and the whole turn dies there.",
     "anchor": true
   },
+  "deliver_to": [
+    "profile"
+  ],
   "allowed_tools": [
     "send_telegram"
   ]

package/src/core/profiles/bundled/secretary/routines/day-open.json

@@ -5,10 +5,16 @@
   "permission_mode": "permiso",
   "enabled_by_default": true,
   "spec": {
-    "prompt": "Open the day. Look at what is due today, what is overdue, what is blocked, and what is promised, across every registered project. HOW TO SPEND YOUR STEPS. You get a small, fixed number of tool calls, and the LAST one is taken away from you to write your closing prose — so a turn spent exploring ends with nothing delivered. Gather with list_tasks and list_commitments (once each, no project argument) and NOTHING ELSE. Do not search sessions, do not read files, do not run shell commands: none of that is what {{owner_name}} asked for. Then send, immediately. Report what you actually have; an honest short message beats a complete one that never arrives. Lead with promises: a broken promise costs more than a late task, so it goes first and is named as a promise to a person, never folded into the task list.\n\nThen send ONE short message: promises coming due or already past, what is due today, anything on the calendar, and the single thing that most deserves attention. Not an inventory.\n\nIf there is genuinely nothing pressing, say so in one line — and then do the thing a chief of staff does with an empty morning: ask what should go on today's list, or name the one stale project worth picking up. An empty day is a prompt, not a silence.\n\nDELIVERY: send it with send_telegram. A routine's own output is only written to the log — if you do not call the tool, {{owner_name}} receives nothing at all. Send exactly one message, then stop; do not end the turn by asking whether to keep looking.",
+    "prompt": "Open the day. Look at what is due today, what is overdue, what is blocked, and what is promised, across every registered project. HOW TO SPEND YOUR STEPS. You get a small, fixed number of tool calls, and the LAST one is taken away from you to write your closing prose — so a turn spent exploring ends with nothing delivered. Gather with list_tasks and list_commitments (once each, no project argument) and NOTHING ELSE. Do not search sessions, do not read files, do not run shell commands: none of that is what {{owner_name}} asked for. Then send, immediately. Report what you actually have; an honest short message beats a complete one that never arrives. Lead with promises: a broken promise costs more than a late task, so it goes first and is named as a promise to a person, never folded into the task list.\n\nTODAY'S AGENDA — already fetched for you, below, at the cost of zero steps:\n<calendar>\n{{pre_output}}\n</calendar>\nIf that block is empty, no calendar is connected: say nothing about the calendar at all, and do not apologise for not having one. If it carries an error rather than an agenda, treat it the same way. Never name a meeting that is not written there.\n\nThen send ONE short message: promises coming due or already past, what is due today, anything on the calendar, and the single thing that most deserves attention. Not an inventory.\n\nIf there is genuinely nothing pressing, say so in one line — and then do the thing a chief of staff does with an empty morning: ask what should go on today's list, or name the one stale project worth picking up. An empty day is a prompt, not a silence.\n\nDELIVERY: your closing message IS the message. This routine delivers what you write to the channel itself, so there is no send tool to call and nothing is lost if you forget one — write the last thing you say AS the message, in the second person, ready to read. Then stop; do not end the turn by asking whether to keep looking.",
     "anchor": true
   },
+  "deliver_to": [
+    "profile"
+  ],
   "allowed_tools": [
     "send_telegram"
+  ],
+  "pre_commands": [
+    "{{calendar_command}}"
   ]
 }

package/src/core/profiles/bundled/secretary/routines/watch.json

@@ -5,9 +5,20 @@
   "permission_mode": "permiso",
   "enabled_by_default": true,
   "spec": {
-    "prompt": "You are watching {{owner_name}}'s projects between the anchors. The signals below were detected deterministically — they are facts, already gathered; you do not need to look them up again.\n\nDecide whether any of it is worth interrupting for RIGHT NOW rather than waiting for the next anchor. Staying quiet is the normal outcome and costs you nothing. A message that could have waited until tomorrow morning costs you the next one, because that is the one they will not open.\n\nIf you do speak: send ONE line naming the single most important thing and what you suggest doing about it, with send_telegram. DELIVERY: send it with send_telegram. A routine's own output is only written to the log — if you do not call the tool, {{owner_name}} receives nothing at all. If you decide to stay quiet, just say so in your reply and call nothing.\n\nWhichever you choose, note what you learned with remember_routine — especially when you stayed quiet, because next time you need to know this kind of signal was not worth it."
+    "prompt": "You are watching {{owner_name}}'s projects between the anchors. The signals below were detected deterministically — they are facts, already gathered; you do not need to look them up again.\n\nDecide whether any of it is worth interrupting for RIGHT NOW rather than waiting for the next anchor. Staying quiet is the normal outcome and costs you nothing. A message that could have waited until tomorrow morning costs you the next one, because that is the one they will not open.\n\nIf you decide to speak, your reply IS the message: write ONE line naming the single most important thing and what you suggest doing about it, in the second person, ready to read. This routine delivers what you write to {{owner_name}}'s channel itself — there is no send tool to call and nothing is lost if you forget one. If you decide to stay quiet, do NOT write that decision as a message. Reply with `NO_MESSAGE` as the very first line and put your reasoning on the lines after it. The marker is what keeps it off {{owner_name}}'s phone and off their interruption budget; what you write after it is filed as a note they can go and read, not a message they receive.\n\nWhichever you choose, note what you learned with remember_routine — especially when you stayed quiet, because next time you need to know this kind of signal was not worth it.",
+    "types": [
+      "overdue_task",
+      "blocked_task",
+      "stale_project",
+      "commitment_due",
+      "overdue_commitment"
+    ]
   },
+  "deliver_to": [
+    "profile"
+  ],
   "allowed_tools": [
-    "send_telegram"
+    "send_telegram",
+    "remember_routine"
   ]
 }

package/src/core/profiles/lifecycle.js

@@ -15,6 +15,8 @@ import { readConfig, writeConfig } from "../config/index.js";
 import { projectStorageRoot, DEFAULT_PROJECT_ID } from "../config/paths.js";
 import { readIdentity } from "../identity/index.js";
 import { renderPromptTemplate } from "../agent/render-template.js";
+import { getPluginService } from "../integrations/catalog.js";
+import { resolveIntegration } from "../integrations/store.js";
 import {
   listRoutines,
   upsertRoutine,
@@ -45,6 +47,7 @@ import {
 } from "./store.js";
 import {
   renderProfilePrompt,
+  profileTemplateVars,
   clearProfileBlockCache,
   validateTemplateVars,
   profileChannelFile,
@@ -74,6 +77,12 @@ function routineFingerprint(r) {
     pre_commands: r?.pre_commands || [],
     post_commands: r?.post_commands || [],
     skip_prompt_on: r?.skip_prompt_on || "signal",
+    // Added LAST and only when set, so the digest of every routine installed
+    // before delivery existed is byte-identical to the one stored beside it.
+    // Folding an always-present `deliver_to: null` into the canonical object
+    // would change every stored hash at once, and every package routine would
+    // read as "the user edited this" and never be updated again.
+    ...(r?.deliver_to?.length ? { deliver_to: r.deliver_to } : {}),
   };
   return crypto.createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
 }
@@ -353,27 +362,84 @@ export function installProfile(source, { force = false } = {}) {
 
 // --------------------- routines ---------------------------------------------
 
+/**
+ * Placeholders that belong to the routine RUNTIME, not to this renderer.
+ * `{{pre_output}}` is filled by core/routines/runner.js with the stdout of
+ * pre_commands, moments before the handler runs. Rendering happens at install
+ * time, long before that, and an unknown variable renders as "" — so without
+ * this identity mapping a profile could never hand its pre_commands output to
+ * its own prompt.
+ */
+const RUNTIME_PLACEHOLDERS = Object.freeze({ pre_output: "{{pre_output}}" });
+
+/**
+ * A rendered shell command that came out empty is a setting the user left
+ * blank, not a command to run. Keeping it would hand runner.js a `""` to
+ * execute and, worse, make `hasPreCmds` true — which changes how the routine
+ * behaves (skip_prompt_on, {{pre_output}}) for a step that does nothing.
+ */
+function dropBlankCommands(spec) {
+  const out = { ...spec };
+  for (const key of ["pre_commands", "post_commands"]) {
+    if (!Array.isArray(out[key])) continue;
+    const kept = out[key].filter((c) => typeof c === "string" && c.trim() !== "");
+    if (kept.length) out[key] = kept;
+    else delete out[key];
+  }
+  return out;
+}
+
+/** Render every string leaf of a parsed value, leaving keys and non-strings alone. */
+function renderDeep(value, settings) {
+  if (typeof value === "string") return renderPromptTemplate(value, settings);
+  if (Array.isArray(value)) return value.map((v) => renderDeep(v, settings));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, renderDeep(v, settings)]));
+  }
+  return value;
+}
+
 /** The profile's routine specs, rendered against its effective settings. */
 export function renderProfileRoutines(profile, globalConfig) {
   const dir = path.join(profile.dir, "routines");
   if (!fs.existsSync(dir)) return [];
 
-  const settings = effectiveProfileConfig(profile, globalConfig);
+  // The SAME variables PROFILE.md gets — settings plus the read-only facts from
+  // identity.json. Rendering routines with settings alone left `{{owner_name}}`
+  // empty in every routine that used it, which is how the Secretary's anchor
+  // came to tell the model "none of that is what  asked for".
+  const identity = (() => { try { return readIdentity(); } catch { return null; } })();
+  const settings = {
+    ...profileTemplateVars(profile, identity, globalConfig),
+    ...RUNTIME_PLACEHOLDERS,
+  };
   const out = [];
 
   for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".json")).sort()) {
+    const text = fs.readFileSync(path.join(dir, file), "utf8");
     let raw;
     try {
-      raw = JSON.parse(renderPromptTemplate(fs.readFileSync(path.join(dir, file), "utf8"), settings));
-    } catch (e) {
-      throw new Error(`profile "${profile.id}": routines/${file} is not valid JSON after rendering — ${e.message}`);
+      // Parse FIRST, then render the string leaves. Rendering the file text
+      // instead lets a setting decide where the document ends: one double quote
+      // in a value — `apx mcp run cal list '{"day":"today"}'` is the realistic
+      // one — and the routine stops being JSON.
+      raw = renderDeep(JSON.parse(text), settings);
+    } catch {
+      // Unless the file is not JSON until it IS rendered, which is what a
+      // placeholder in an unquoted position (`"timeout": {{secs}}`) means. That
+      // shape predates the safe path, so it keeps working the old way.
+      try {
+        raw = JSON.parse(renderPromptTemplate(text, settings));
+      } catch (e) {
+        throw new Error(`profile "${profile.id}": routines/${file} is not valid JSON after rendering — ${e.message}`);
+      }
     }
     if (!raw?.name || !raw?.kind || !raw?.schedule) {
       throw new Error(`profile "${profile.id}": routines/${file} needs name, kind and schedule`);
     }
     // Namespaced, because `name` is the real primary key of the routines store
     // and a profile must never collide with a routine the user wrote.
-    out.push({ ...raw, name: `${profile.id}-${raw.name}` });
+    out.push({ ...dropBlankCommands(raw), name: `${profile.id}-${raw.name}` });
   }
   return out;
 }
@@ -433,6 +499,44 @@ export function syncProfileRoutines(profile, globalConfig, { enable = true } = {
   return { installed, skipped };
 }
 
+/**
+ * Force the profile's routines back to the package version, discarding local
+ * edits and repairing provenance. This is what sync CANNOT do: sync deliberately
+ * skips a routine the user edited (`user_modified`) or one whose profile origin
+ * was lost (`user_owned`), so a routine that drifted — a hand-patched schedule,
+ * or an `origin` gone null after an old migration — never picks up a new package
+ * field like `deliver_to`. Re-adopt overwrites by NAME: the package spec wins,
+ * `origin`/`origin_hash` are rewritten so it reads as "exactly as installed"
+ * again, and the run history (`last_run_at`) is preserved by upsertRoutine.
+ *
+ * @param {{ only?: string|null }} opts  one routine name, or null for all.
+ * @returns {{ readopted: string[] }}
+ */
+export function readoptProfileRoutines(profile, globalConfig, { only = null } = {}) {
+  const storage = superAgentStorage();
+  const specs = renderProfileRoutines(profile, globalConfig);
+  const existing = listRoutines(storage);
+  const origin = profileOrigin(profile.id);
+
+  const readopted = [];
+  for (const spec of specs) {
+    const { name, enabled_by_default, ...rest } = spec;
+    if (only && name !== only) continue;
+    const prev = existing.find((r) => r.name === name);
+    upsertRoutine(storage, {
+      ...rest,
+      name,
+      // Keep whether the user had it switched off — re-adopt is about behaviour
+      // and provenance, not about turning a routine back on behind their back.
+      enabled: prev ? prev.enabled !== false : enabled_by_default !== false,
+      origin,
+      origin_hash: routineFingerprint(rest),
+    });
+    readopted.push(name);
+  }
+  return { readopted };
+}
+
 /** Disable — never delete — the routines a profile installed. */
 export function disableProfileRoutines(profileId) {
   const storage = superAgentStorage();
@@ -554,6 +658,59 @@ export function setProfileConfig(values, { id = null } = {}) {
   return { config: settings, changed: Object.keys(value), routines };
 }
 
+/**
+ * Re-install the active profile's routines from the package as it is on disk
+ * TODAY, without touching settings or activation.
+ *
+ * A bundled package improves with every APX update, but the routines it
+ * installs are records in the super-agent's store, frozen at install time. So
+ * an owner who installed the Secretary in June kept June's anchors for good —
+ * the improved prompt shipped, and nothing carried it across. The only paths
+ * that re-rendered were `use` and changing a setting, neither of which is a
+ * thing you would think to run after a `git pull`.
+ *
+ * Routines the owner edited are still skipped: their fingerprint no longer
+ * matches the one taken at install, and that is the whole point of the check.
+ */
+export function syncProfile(id = null) {
+  const cfg = readConfig();
+  const state = readProfileState(cfg);
+  const targetId = id || state.active;
+  if (!targetId) throw new Error("no profile is active — run: apx profile use <id>");
+
+  const profile = readProfile(targetId);
+  if (!profile) throw new Error(`profile "${targetId}" is not installed`);
+  if (state.active !== targetId) {
+    throw new Error(`profile "${targetId}" is not active — its routines are not installed`);
+  }
+
+  clearProfileBlockCache();
+  return { id: targetId, version: profile.manifest?.version || null, routines: syncProfileRoutines(profile, cfg) };
+}
+
+/**
+ * Re-adopt the active profile's routines from the package, forcing past the
+ * user_modified/user_owned skips that sync respects. `only` targets one routine
+ * (the per-warning "re-adopt this one" button); omit it to re-adopt all. This is
+ * the recovery path a non-CLI user needs when their installed routines drifted —
+ * see readoptProfileRoutines.
+ */
+export function readoptProfile(id = null, { only = null } = {}) {
+  const cfg = readConfig();
+  const state = readProfileState(cfg);
+  const targetId = id || state.active;
+  if (!targetId) throw new Error("no profile is active — run: apx profile use <id>");
+
+  const profile = readProfile(targetId);
+  if (!profile) throw new Error(`profile "${targetId}" is not installed`);
+  if (state.active !== targetId) {
+    throw new Error(`profile "${targetId}" is not active — its routines are not installed`);
+  }
+
+  clearProfileBlockCache();
+  return { id: targetId, version: profile.manifest?.version || null, ...readoptProfileRoutines(profile, cfg, { only }) };
+}
+
 // --------------------- doctor -----------------------------------------------
 
 /**
@@ -562,11 +719,17 @@ export function setProfileConfig(values, { id = null } = {}) {
  */
 export function profileDoctor(id = null) {
   const cfg = readConfig();
+  // The doctor is owner-facing UI, so its prose follows the owner's language —
+  // unlike the prompt block, which is instructions to the model and stays
+  // English. `fix` values are literal CLI commands and are NOT translated; only
+  // the human sentences around them are.
+  const es = /^es(-|$)/.test(String(cfg.user?.language || "en").toLowerCase());
+  const L = (esStr, enStr) => (es ? esStr : enStr);
   const state = readProfileState(cfg);
   const targetId = id || state.active;
 
   if (!targetId) {
-    return { id: null, active: false, ok: true, checks: [], summary: "No profile active (vanilla)." };
+    return { id: null, active: false, ok: true, checks: [], summary: L("No hay perfil activo (vanilla).", "No profile active (vanilla).") };
   }
 
   const profile = readProfile(targetId);
@@ -575,8 +738,8 @@ export function profileDoctor(id = null) {
       id: targetId,
       active: false,
       ok: false,
-      checks: [{ level: "error", label: "package", detail: `not installed`, fix: `apx profile install ${targetId}` }],
-      summary: `profile "${targetId}" is not installed`,
+      checks: [{ level: "error", label: "package", detail: L("no está instalado", "not installed"), fix: `apx profile install ${targetId}` }],
+      summary: L(`el perfil "${targetId}" no está instalado`, `profile "${targetId}" is not installed`),
     };
   }
 
@@ -595,7 +758,7 @@ export function profileDoctor(id = null) {
         checks.push({
           level: "warn",
           label: "channel",
-          detail: `Telegram is not configured — the profile cannot reach you there`,
+          detail: L("Telegram no está configurado — el perfil no puede alcanzarte ahí", "Telegram is not configured — the profile cannot reach you there"),
           fix: "apx telegram setup",
         });
       }
@@ -603,14 +766,36 @@ export function profileDoctor(id = null) {
   }
 
   // Integrations. Required ones block; optional ones degrade.
+  //
+  // A profile may name an integration APX has no plugin for — `calendar` is the
+  // live case. `apx integration connect calendar` cannot work and never will
+  // until a plugin exists, so pointing at it is worse than saying nothing:
+  // the reader spends their time on a command that returns "unknown plugin".
+  // Those slugs get the path that does exist, which is MCP.
+  const integrationFix = (slug) =>
+    getPluginService(slug)
+      ? `apx integration connect ${slug}`
+      : `apx mcp add ${slug} --scope global --command <cmd> -- <args>`;
+  const integrationDetail = (slug, suffix) =>
+    getPluginService(slug)
+      ? L(`${slug} no está conectado — ${suffix}`, `${slug} is not connected — ${suffix}`)
+      : L(`${slug} no tiene plugin nativo — alcanzalo con un servidor MCP; ${suffix}`, `${slug} has no built-in plugin — reach it through an MCP server; ${suffix}`);
+
+  // Integrations live in per-project stores (~/.apx/projects/<id>/integrations.json),
+  // with project→default precedence — NOT in a global `config.integrations`, which
+  // is null on a normal install. Checking the config object reported "calendar is
+  // not connected" while a connected Google Calendar sat in the default project.
+  // resolveIntegration() looks where they actually are, so a calendar connected at
+  // the (default) project level counts as connected for the super-agent.
+  const integrationConnected = (slug) => !!resolveIntegration({ slug });
   for (const slug of requires.integrations || []) {
-    if (!cfg.integrations?.[slug]) {
-      checks.push({ level: "error", label: "integration", detail: `${slug} is required and not connected`, fix: `apx integration connect ${slug}` });
+    if (!integrationConnected(slug)) {
+      checks.push({ level: "error", label: "integration", detail: integrationDetail(slug, L("el perfil lo requiere", "the profile requires it")), fix: integrationFix(slug) });
     }
   }
   for (const slug of requires.optional_integrations || []) {
-    if (!cfg.integrations?.[slug]) {
-      checks.push({ level: "warn", label: "integration", detail: `${slug} is not connected — the profile degrades without it`, fix: `apx integration connect ${slug}` });
+    if (!integrationConnected(slug)) {
+      checks.push({ level: "warn", label: "integration", detail: integrationDetail(slug, L("el perfil se degrada sin esto", "the profile degrades without it")), fix: integrationFix(slug) });
     }
   }
 
@@ -621,7 +806,7 @@ export function profileDoctor(id = null) {
       checks.push({
         level: "warn",
         label: "capability",
-        detail: `"${cap}" is not provided by this APX version — the profile degrades`,
+        detail: L(`"${cap}" no la provee esta versión de APX — el perfil se degrada`, `"${cap}" is not provided by this APX version — the profile degrades`),
         fix: null,
       });
     }
@@ -630,9 +815,48 @@ export function profileDoctor(id = null) {
   // Routines it installed that are currently off.
   if (state.active === targetId) {
     const origin = profileOrigin(targetId);
-    const off = listRoutines(superAgentStorage()).filter((r) => r.origin === origin && !r.enabled);
-    for (const r of off) {
-      checks.push({ level: "warn", label: "routine", detail: `"${r.name}" is disabled`, fix: `apx routine enable ${r.name}` });
+    const installed = listRoutines(superAgentStorage()).filter((r) => r.origin === origin);
+    for (const r of installed.filter((r) => !r.enabled)) {
+      checks.push({ level: "warn", label: "routine", detail: L(`"${r.name}" está deshabilitada`, `"${r.name}" is disabled`), fix: `apx routine enable ${r.name}` });
+    }
+
+    // Routines that no longer match the package they came from. Worth saying
+    // out loud because nothing announces it: the package improves with every
+    // APX update while the installed record stays exactly as it was, and a
+    // profile setting that lands in a routine (the Secretary's
+    // `calendar_command`) silently does nothing until one of them moves.
+    try {
+      const rendered = renderProfileRoutines(profile, cfg);
+      for (const spec of rendered) {
+        const prev = installed.find((r) => r.name === spec.name);
+        if (!prev) continue;
+        const { name, enabled_by_default, ...rest } = spec;
+        if (routineFingerprint(rest) === routineFingerprint(prev)) continue;
+
+        const edited = prev.origin_hash && routineFingerprint(prev) !== prev.origin_hash;
+        checks.push(edited
+          ? {
+            level: "warn",
+            label: "routine",
+            // `routine` names the record so a UI can offer a targeted re-adopt
+            // (POST /profiles/readopt {routine}) next to this exact warning.
+            routine: name,
+            // Their edits win — that is the contract. But a routine that sync
+            // will always skip is one they now maintain themselves, and they
+            // should hear that while they can still decide otherwise.
+            detail: L(`"${name}" ahora es tuya (la editaste) y el paquete avanzó — sync la va a seguir salteando`, `"${name}" is yours now (you edited it) and the package has moved on — sync will keep skipping it`),
+            fix: L(`apx routine show ${name}  # editala, o borrala y corré: apx profile sync`, `apx routine show ${name}  # then edit it, or delete it and run: apx profile sync`),
+          }
+          : {
+            level: "warn",
+            label: "routine",
+            routine: name,
+            detail: L(`"${name}" es más vieja que el paquete que la instaló`, `"${name}" is older than the package that installed it`),
+            fix: "apx profile sync",
+          });
+      }
+    } catch {
+      /* a package that no longer renders is already reported by validate */
     }
   }
 
@@ -645,8 +869,8 @@ export function profileDoctor(id = null) {
     budget: profile.manifest?.prompt_budget_tokens || null,
     checks,
     summary: errors === 0
-      ? `profile "${targetId}" is healthy${checks.length ? ` (${checks.length} warning(s))` : ""}`
-      : `profile "${targetId}" has ${errors} blocking problem(s)`,
+      ? L(`el perfil "${targetId}" está sano${checks.length ? ` (${checks.length} advertencia(s))` : ""}`, `profile "${targetId}" is healthy${checks.length ? ` (${checks.length} warning(s))` : ""}`)
+      : L(`el perfil "${targetId}" tiene ${errors} problema(s) que bloquean`, `profile "${targetId}" has ${errors} blocking problem(s)`),
   };
 }
 

package/src/core/profiles/paths.js

@@ -49,3 +49,15 @@ export function promptFileFor(lang) {
   if (!code || code.toLowerCase() === "en") return PROMPT_FILE;
   return `PROFILE.${code}.md`;
 }
+
+/**
+ * Language-specific settings-schema filename: config.schema.es.json, …
+ * Mirrors promptFileFor. The localized file carries only display strings
+ * (title/description); types, defaults and enums stay in the base schema, which
+ * is the single source of truth for validation.
+ */
+export function schemaFileFor(lang) {
+  const code = String(lang || "").trim();
+  if (!code || code.toLowerCase() === "en") return CONFIG_SCHEMA_FILE;
+  return `config.schema.${code}.json`;
+}