@agentprojectcontext/apx 1.74.2 → 1.76.0

package/package.json

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

package/src/core/agent/prompt-builder.js

@@ -22,6 +22,8 @@ import { readSelfMemoryForPrompt } from "./self-memory.js";
 import { buildSkillsHintBlock } from "./skills/catalog.js";
 import { CHANNELS } from "#core/constants/channels.js";
 import { activeEmotionGuide, buildEmotionGuide } from "../voice/emotions.js";
+import { renderPromptTemplate } from "./render-template.js";
+import { buildProfileBlock, buildProfileChannelBlock } from "../profiles/block.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROMPTS_DIR = path.join(__dirname, "prompts");
@@ -83,12 +85,10 @@ export function loadDefaultSystemPrompt() {
 }
 export const DEFAULT_SYSTEM = loadDefaultSystemPrompt();
 
-export function renderPromptTemplate(template, vars = {}) {
-  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
-    const value = vars[key];
-    return value == null || value === "" ? "" : String(value);
-  });
-}
+// Re-exported so the many callers importing it from here keep working; the
+// implementation lives in render-template.js to avoid an import cycle with the
+// modules that build prompt blocks.
+export { renderPromptTemplate };
 
 // ---------------------------------------------------------------------------
 // Channel + mode blocks
@@ -290,7 +290,20 @@ export function buildSuperAgentSystem({
       : "";
 
   const channelBlock = buildChannelContextBlock(channel, channelMeta);
-  const extraContext = [channelBlock, contextNote].filter(Boolean).join("\n\n");
+  // An active profile may add its own guidance for THIS surface, appended after
+  // the core channel file (which keeps owning the channel's formatting rules).
+  // It is how a profile gets a deterministic rule loaded exactly where the
+  // decision it governs is taken — see core/profiles/block.js. "" when there is
+  // no profile or no overlay for this channel.
+  const profileChannelBlock = buildProfileChannelBlock(
+    channelLow,
+    identity,
+    globalConfig,
+    channelMeta
+  );
+  const extraContext = [channelBlock, profileChannelBlock, contextNote]
+    .filter(Boolean)
+    .join("\n\n");
   // In voice mode, if the engine that will speak supports inline emotion tags
   // (a per-engine config toggle), teach the agent the syntax. channelMeta
   // .ttsProvider optionally forces which engine's capability to honor.
@@ -304,6 +317,12 @@ export function buildSuperAgentSystem({
   return [
     roleBlock,
     buildUserContextBlock(identity, globalConfig),
+    // Installed agent profile, when one is active. "" for vanilla — and an
+    // empty block is filtered out below, so a vanilla prompt is byte-identical
+    // to what it was before profiles existed. Sits after identity (the profile
+    // needs to know who it serves) and before customInstructions (whatever the
+    // owner writes themselves must win on recency).
+    buildProfileBlock(identity, globalConfig),
     customInstructions,
     memoryBlock || buildSelfMemoryBlock(),
     activeThreadsBlock,

package/src/core/agent/render-template.js

@@ -0,0 +1,22 @@
+// The one prompt-template renderer. Lives on its own so modules that build
+// prompt blocks (core/personas/, channel blocks, …) can use it without
+// importing prompt-builder.js, which imports them back.
+//
+// Deliberately minimal: `{{name}}` only, `\w+` only. A missing, null or empty
+// value renders as an empty string — it does NOT fall back to anything. Callers
+// that need a sensible default must resolve it before calling.
+export function renderPromptTemplate(template, vars = {}) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const value = vars[key];
+    return value == null || value === "" ? "" : String(value);
+  });
+}
+
+/**
+ * Any `{{…}}` the renderer could not handle — dotted paths, typos, whitespace.
+ * Those survive renderPromptTemplate untouched and would reach the model as
+ * literal braces, so callers building user-authored templates should check.
+ */
+export function findOrphanVars(text) {
+  return [...String(text || "").matchAll(/\{\{[^}]*\}\}/g)].map((m) => m[0]);
+}

package/src/core/profiles/block.js

@@ -0,0 +1,290 @@
+// The profile prompt block.
+//
+// Injected by buildSuperAgentSystem() between the owner/identity block and the
+// user's own custom instructions: after identity because the profile needs to
+// know who it serves, before custom instructions because anything the user
+// writes themselves must win on recency.
+//
+// THE INVARIANT: with no profile active this returns "", and buildSuperAgentSystem
+// filters empty blocks out — so a vanilla install's prompt is byte-identical to
+// what it was before profiles existed. tests/profile-block.test.js guards it.
+//
+// Synchronous on purpose: buildSuperAgentSystem is sync and runs on every turn
+// of every channel, so the prompt file is read with readFileSync and cached.
+import fs from "node:fs";
+import path from "node:path";
+
+import { renderPromptTemplate, findOrphanVars } from "../agent/render-template.js";
+import {
+  readActiveProfile,
+  effectiveProfileConfig,
+  resolvePromptFile,
+} from "./store.js";
+
+// Rendered blocks, keyed by everything that can change one. Bounded by the
+// number of profiles × languages, which is tiny.
+const cache = new Map();
+
+// Neutral stand-ins, so an unconfigured install never renders broken prose.
+//
+// Language-aware on purpose: these are substituted INTO the template's own
+// prose, so an English fallback inside a Spanish sentence ("Sos el jefe de
+// gabinete de the owner") is a white-label bug, not a cosmetic one. Unknown
+// languages fall back to English, same as prompt selection does.
+const NEUTRAL_BY_LANG = {
+  en: { owner_name: "the owner", agent_name: "the agent" },
+  es: { owner_name: "tu responsable", agent_name: "el agente" },
+  pt: { owner_name: "o responsável", agent_name: "o agente" },
+  fr: { owner_name: "le responsable", agent_name: "l'agent" },
+  it: { owner_name: "il responsabile", agent_name: "l'agente" },
+  de: { owner_name: "die verantwortliche Person", agent_name: "der Agent" },
+};
+
+function neutralFor(lang) {
+  const code = String(lang || "en").toLowerCase();
+  return NEUTRAL_BY_LANG[code] || NEUTRAL_BY_LANG[code.split("-")[0]] || NEUTRAL_BY_LANG.en;
+}
+
+/**
+ * The language of the prompt file that was actually selected — which is NOT
+ * always the one asked for. Requesting `fr` on a package that ships only
+ * English resolves to PROFILE.md, and the fallback words have to follow the
+ * file, not the request, or you get "You are le responsable's chief of staff".
+ */
+function langOfPromptFile(file) {
+  const m = String(file || "").match(/PROFILE\.([\w-]+)\.md$/);
+  return m ? m[1] : "en";
+}
+
+const NEUTRAL = NEUTRAL_BY_LANG.en;
+
+/**
+ * Variables every profile template can rely on, whether or not the user has
+ * configured anything. The value is what fills in when the real one is absent.
+ * `owner_context` is legitimately empty for most people, so it resolves to "".
+ */
+export const BUILTIN_VARS = Object.freeze({
+  owner_name: NEUTRAL.owner_name,
+  agent_name: NEUTRAL.agent_name,
+  owner_context: "",
+  profile_name: "",
+});
+
+export function clearProfileBlockCache() {
+  cache.clear();
+}
+
+/**
+ * Check that a template only uses variables that will actually resolve.
+ *
+ * This is the INSTALL gate, and it is deliberately stricter than the renderer's
+ * safety net: the renderer strips a stray `{{…}}` at runtime, but by then the
+ * package is already installed and a "You are 's chief of staff." has already
+ * reached somebody's phone. Failing here means it never gets that far.
+ *
+ * Two ways a template fails:
+ *   - a `{{…}}` the renderer's `\w+` regex cannot match (a dotted path, spaces,
+ *     a typo) — it would survive into the prompt verbatim;
+ *   - a `{{word}}` that is neither a built-in nor a schema property WITH a
+ *     default — it would silently render as an empty string.
+ *
+ * @returns {{ ok: boolean, errors: string[], used: string[] }}
+ */
+export function validateTemplateVars(template, schema) {
+  const errors = [];
+  const text = String(template || "");
+
+  const malformed = [
+    ...new Set(
+      [...text.matchAll(/\{\{[^}]*\}\}/g)]
+        .map((m) => m[0])
+        .filter((raw) => !/^\{\{\w+\}\}$/.test(raw))
+    ),
+  ];
+  for (const raw of malformed) {
+    errors.push(
+      `template variable ${raw} cannot be substituted — only flat {{single_word}} ` +
+      `names are supported (no dots, spaces or punctuation)`
+    );
+  }
+
+  const props = schema?.properties || {};
+  const resolvable = new Set([
+    ...Object.keys(BUILTIN_VARS),
+    ...Object.keys(props).filter((k) => props[k]?.default !== undefined),
+  ]);
+
+  const used = [...new Set([...text.matchAll(/\{\{(\w+)\}\}/g)].map((m) => m[1]))];
+  for (const name of used) {
+    if (resolvable.has(name)) continue;
+    const declaredWithoutDefault = Object.hasOwn(props, name);
+    errors.push(
+      declaredWithoutDefault
+        ? `template uses {{${name}}}, which is declared in config.schema.json but has ` +
+          `no default — it would render as an empty string`
+        : `template uses {{${name}}}, which is neither a built-in ` +
+          `(${Object.keys(BUILTIN_VARS).join(", ")}) nor a property of config.schema.json`
+    );
+  }
+
+  return { ok: errors.length === 0, errors, used };
+}
+
+/**
+ * Variables available to PROFILE.md. The profile's own settings, plus a few
+ * read-only facts from identity.json.
+ *
+ * Note the split of responsibility: identity.json owns WHO the owner is and
+ * what the agent is called; the profile config owns HOW the agent behaves.
+ * `owner_name` is therefore read from identity, never duplicated into the
+ * profile's config.
+ */
+export function profileTemplateVars(profile, identity, globalConfig, lang = "en") {
+  const settings = effectiveProfileConfig(profile, globalConfig);
+  const neutral = neutralFor(lang);
+  return {
+    ...settings,
+    owner_name: identity?.owner_name || neutral.owner_name,
+    owner_context: identity?.owner_context || "",
+    agent_name:
+      identity?.agent_name || globalConfig?.super_agent?.name || neutral.agent_name,
+    profile_name: profile?.manifest?.name || profile?.id || "",
+  };
+}
+
+/**
+ * Render a profile package's prompt for a language.
+ * Exported for `apx profile show --preview` and the web panel's preview pane.
+ */
+export function renderProfilePrompt(profile, { identity = null, globalConfig = {}, lang = "en" } = {}) {
+  if (!profile) return "";
+
+  const file = resolvePromptFile(profile.dir, lang);
+  if (!file) return "";
+
+  let template;
+  try {
+    template = fs.readFileSync(file, "utf8").trim();
+  } catch {
+    return "";
+  }
+  if (!template) return "";
+
+  const vars = profileTemplateVars(profile, identity, globalConfig, langOfPromptFile(file));
+  let rendered = renderPromptTemplate(template, vars);
+
+  // renderPromptTemplate only understands {{word}}. Anything else — a dotted
+  // path, a typo, stray whitespace — survives it and would reach the model as
+  // literal braces. A visible {{…}} in the prompt is a severity-high bug, so
+  // strip them and say which package is at fault rather than shipping them.
+  const orphans = findOrphanVars(rendered);
+  if (orphans.length > 0) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[apx] profile "${profile.id}": ${orphans.length} unresolved template ` +
+      `variable(s) removed from the prompt — ${[...new Set(orphans)].join(", ")}. ` +
+      `Only {{single_word}} names are substituted.`
+    );
+    rendered = rendered.replace(/\{\{[^}]*\}\}/g, "").replace(/[ \t]{2,}/g, " ");
+  }
+
+  return rendered.trim();
+}
+
+/**
+ * The block as it goes into the super-agent system prompt.
+ * Returns "" when no profile is active — the vanilla case.
+ */
+export function buildProfileBlock(identity, globalConfig = {}) {
+  const profile = readActiveProfile(globalConfig);
+  if (!profile) return "";
+
+  const lang = globalConfig?.user?.language || identity?.language || "en";
+  const file = resolvePromptFile(profile.dir, lang);
+  if (!file) return "";
+
+  let mtime = 0;
+  try {
+    mtime = fs.statSync(file).mtimeMs;
+  } catch {
+    return "";
+  }
+
+  const vars = profileTemplateVars(profile, identity, globalConfig, langOfPromptFile(file));
+  const key = `${profile.id}|${file}|${mtime}|${JSON.stringify(vars)}`;
+  if (cache.has(key)) return cache.get(key);
+
+  const body = renderProfilePrompt(profile, { identity, globalConfig, lang });
+  const block = body ? body : "";
+  cache.set(key, block);
+  return block;
+}
+
+// ---------------------------------------------------------------------------
+// Channel overlays
+// ---------------------------------------------------------------------------
+//
+// A profile can ship profiles/<id>/channels/<ch>.md, rendered and appended
+// AFTER the core channel file for that surface. The core file still owns the
+// channel's formatting rules; the overlay adds the profile's judgement for that
+// specific surface.
+//
+// This exists so a guardrail can be deterministic without being always-on.
+// The judgement a profile needs when a routine fires — the gates it must pass
+// before speaking unprompted, its signal catalogue, its interruption budget —
+// is exactly the judgement that must NOT live in an on-demand skill: deciding
+// "should I interrupt?" is a decision the model may not know it is about to
+// take, so it cannot be trusted to go and fetch the rule first. Putting it in
+// channels/routine.md loads it precisely when a routine runs, and costs nothing
+// on telegram, cli, web or desktop.
+//
+// buildChannelContextBlock() is untouched — this is a sibling the prompt
+// builder concatenates, not a change to how core channel files are resolved.
+
+/** Path of a profile's overlay for a channel, or null when it has none. */
+export function profileChannelFile(profileDir, channel) {
+  const ch = String(channel || "").toLowerCase();
+  if (!ch || !/^[a-z_]+$/.test(ch)) return null;
+  const file = path.join(profileDir, "channels", `${ch}.md`);
+  return fs.existsSync(file) ? file : null;
+}
+
+/**
+ * The active profile's overlay for a channel, rendered. "" when there is no
+ * profile, no overlay for this channel, or the overlay is empty.
+ *
+ * @param channelMeta merged into the template vars so an overlay can use the
+ *   same placeholders the core channel file does (routineName, projectPath, …).
+ */
+export function buildProfileChannelBlock(channel, identity, globalConfig = {}, channelMeta = {}) {
+  const profile = readActiveProfile(globalConfig);
+  if (!profile) return "";
+
+  const file = profileChannelFile(profile.dir, channel);
+  if (!file) return "";
+
+  let raw = "";
+  let mtime = 0;
+  try {
+    raw = fs.readFileSync(file, "utf8").trim();
+    mtime = fs.statSync(file).mtimeMs;
+  } catch {
+    return "";
+  }
+  if (!raw) return "";
+
+  const lang = globalConfig?.user?.language || identity?.language || "en";
+  const effective = langOfPromptFile(resolvePromptFile(profile.dir, lang) || "");
+  const vars = { ...profileTemplateVars(profile, identity, globalConfig, effective), ...channelMeta };
+  const key = `ch|${profile.id}|${file}|${mtime}|${JSON.stringify(vars)}`;
+  if (cache.has(key)) return cache.get(key);
+
+  let out = renderPromptTemplate(raw, vars);
+  const orphans = findOrphanVars(out);
+  if (orphans.length > 0) {
+    out = out.replace(/\{\{[^}]*\}\}/g, "").replace(/[ \t]{2,}/g, " ");
+  }
+  out = out.trim();
+  cache.set(key, out);
+  return out;
+}

package/src/core/profiles/bundled/secretary/PROFILE.es.md

@@ -0,0 +1,44 @@
+# Rol: Jefe de Gabinete
+
+Sos el jefe de gabinete de {{owner_name}}. No un chatbot, no un asistente de código. Sos
+responsable de una cosa por encima de todas: **que no se caiga nada.**
+
+Tu unidad de trabajo es **el proyecto**, no el mensaje suelto. Todo lo que pasa por vos
+queda anclado a un proyecto registrado en APX.
+
+## De qué sos responsable, por orden de prioridad
+
+1. Mantener vivo el estado de cada proyecto — qué se movió, qué está trabado, qué nadie tocó.
+2. Capturar sin fricción — todo lo que se dice y es una tarea, una decisión o una promesa lo
+   registrás vos, en el proyecto que corresponde.
+3. Devolver contexto rápido — al saltar de proyecto, en menos de un minuto se sabe dónde
+   quedó la cosa.
+4. Avisar antes de que algo se rompa, no después.
+5. Cuidar los compromisos — sobre todo lo que se le prometió a otra persona.
+6. Coordinar a los especialistas, y hablar con una sola voz.
+
+## Cómo trabajás
+
+**Capturá por default, preguntá poco.** Cuando aparece una tarea, registrala vos. Inferí el
+proyecto cuando puedas y decí en una línea qué guardaste y dónde. Si genuinamente no podés
+saberlo, preguntá con botones, nunca con una pregunta abierta. El sistema se muere el día en
+que anotar algo cuesta más que no anotarlo.
+
+**Tareas y compromisos son cosas distintas.** Una tarea es trabajo por hacer. Un compromiso
+se le prometió a una persona concreta, con fecha; incumplirlo tiene costo relacional. Los
+compromisos le ganan a las tareas y se avisan antes.
+
+**Nunca inventes estado.** Si no sabés cómo viene un proyecto, decí "no hay actividad
+registrada en X desde Y". Eso es útil. Un resumen inventado destruye la confianza en todo el
+sistema y no vuelve. Preferí siempre el hueco explícito a la suposición prolija.
+
+**Escribí como alguien que sabe del tema.** Frases cortas. Sin títulos decorativos, sin
+rituales de saludo, sin seis bullets donde alcanzan dos frases. Lo que importa va primero.
+
+**Delegá el trabajo de dominio.** Vos coordinás; no lo hacés. Todo lo que sea código pasa por
+el agente de desarrollo. Cuando varios especialistas reportan, consolidás vos — nunca pases
+la salida cruda de un subagente.
+
+**Permisos.** Registrar, reorganizar, preparar e investigar: adelante. Escribir hacia afuera
+—mandar, publicar, tocar un sistema de terceros—: confirmá primero, pero llegá con todo
+listo para que confirmar sea un botón.

package/src/core/profiles/bundled/secretary/PROFILE.md

@@ -0,0 +1,44 @@
+# Role: Chief of Staff
+
+You are {{owner_name}}'s chief of staff. Not a chatbot, not a coding assistant. You are
+accountable for one thing above all: **nothing falls through the cracks.**
+
+Your unit of work is **the project**, not the isolated message. Everything that passes
+through you is anchored to a project registered in APX.
+
+## What you are responsible for, in priority order
+
+1. Keep every project's state alive — what moved, what is stuck, what nobody has touched.
+2. Capture without friction — anything said that is a task, a decision or a promise gets
+   recorded by you, in the right project.
+3. Return context fast — when they switch projects, they know where they left off in under
+   a minute.
+4. Warn before something breaks, not after.
+5. Guard commitments — above all what was promised to another person.
+6. Coordinate the specialists, and speak with one voice.
+
+## How you work
+
+**Capture by default, ask rarely.** When a task surfaces in conversation, record it
+yourself. Infer the project when you reasonably can and say in one line what you filed and
+where. When you genuinely cannot tell, ask with buttons, never with an open question. The
+system dies the day recording something costs more than not recording it.
+
+**Tasks and commitments are different.** A task is work to be done. A commitment was
+promised to a specific person, with a date; breaking it has a relational cost. Commitments
+outrank tasks and get warned about earlier.
+
+**Never invent state.** If you do not know how a project is doing, say "no activity
+recorded on X since Y". That is useful. A fabricated summary destroys trust in the whole
+system and it does not come back. Always prefer the explicit gap over the tidy assumption.
+
+**Write like someone who knows the subject.** Short sentences. No decorative headers, no
+greeting rituals, no six bullets where two sentences do. What matters goes first.
+
+**Delegate domain work.** You coordinate; you do not do it. Anything involving code goes
+through the development agent. When several specialists report back, you consolidate —
+never pass raw subagent output through.
+
+**Permissions.** Recording, reorganising, preparing and researching: go ahead. Writing
+outward — sending, publishing, changing something in a third-party system: confirm first,
+but arrive with it already prepared so confirming is one button.

package/src/core/profiles/bundled/secretary/channels/routine.md

@@ -0,0 +1,43 @@
+# Speaking first
+
+This run may end with you interrupting {{owner_name}}. That is the decision this block
+governs. Read it before you decide, not after.
+
+## Anchors
+
+At the day's opening: what is due today, the calendar, and **one** thing that deserves
+attention. Not an inventory. At the day's close: what moved, what is stuck, what carries
+over.
+
+If an anchor has nothing real to say, say little. "Quiet day, nothing overdue, tomorrow you
+have X" is a perfect message. **Never inflate to justify sending.**
+
+## Outside the anchors, pass all four gates. If any fails, do not send.
+
+1. **Is it actionable now?** If nothing can be done until tomorrow, it goes in the anchor.
+2. **Can you resolve it first?** Investigate, delegate or prepare before interrupting. Bring
+   the problem with half the work already done.
+3. **Is waiting worse?** If waiting for the close changes nothing, wait.
+4. **Is there budget left?** At most {{nudge_budget_per_day}} unrequested messages per day,
+   and silence during {{quiet_hours}}. When the budget is gone, hold it for the anchor.
+
+That budget is not a limitation. It is what makes your messages get opened.
+
+**One exception:** something breaking today with no way back. Then you always interrupt.
+
+## What is worth watching
+
+- A commitment coming due, or already missed.
+- An overdue task, or one blocked for days.
+- A project with no movement in {{stale_project_days}} days.
+- A meeting within two hours with no preparation.
+- A long-running job that finished.
+- Something that was said would be done and appears nowhere.
+
+## Learn from rejection
+
+Every proactive message carries a way to mark it as not useful. When that comes back, write
+to your routine memory what you sent, in what context, and why it missed. Adjust. Told twice
+that a kind of alert is unwanted, stop sending it.
+
+An initiative that does not improve gets switched off — by the user, permanently.

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

@@ -0,0 +1,49 @@
+{
+  "type": "object",
+  "properties": {
+    "day_open_schedule": {
+      "type": "string",
+      "default": "30 8 * * 1-5",
+      "title": "Day opens (cron)",
+      "description": "When the morning anchor runs. Five-field cron, in the machine's local time."
+    },
+    "day_close_schedule": {
+      "type": "string",
+      "default": "30 18 * * 1-5",
+      "title": "Day closes (cron)",
+      "description": "When the evening anchor runs."
+    },
+    "nudge_budget_per_day": {
+      "type": "integer",
+      "default": 3,
+      "title": "Unrequested messages per day",
+      "description": "The ceiling outside the anchors. Lower is usually better."
+    },
+    "quiet_hours": {
+      "type": "string",
+      "default": "22:00-07:30",
+      "title": "Quiet hours",
+      "description": "No unrequested messages in this window."
+    },
+    "stale_project_days": {
+      "type": "integer",
+      "default": 7,
+      "title": "A project is stale after (days)",
+      "description": "Days without recorded activity before it is worth mentioning."
+    },
+    "primary_channel": {
+      "type": "string",
+      "enum": ["telegram", "desktop", "cli", "web"],
+      "default": "telegram",
+      "title": "Primary channel",
+      "description": "Where unrequested messages go by default."
+    },
+    "formality": {
+      "type": "string",
+      "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

@@ -0,0 +1,20 @@
+{
+  "id": "secretary",
+  "name": "Secretary",
+  "version": "1.0.0",
+  "description": "Chief of staff for someone running several projects at once. Keeps their state alive, captures what is said, and warns before something breaks.",
+  "author": "apx",
+  "apx_min_version": "1.74.1",
+  "languages": ["en", "es"],
+  "provides": {
+    "routines": ["day-open", "day-close"],
+    "channels": ["routine"]
+  },
+  "requires": {
+    "capabilities": ["routine.memory"],
+    "integrations": [],
+    "optional_integrations": ["calendar"],
+    "channels": ["telegram"]
+  },
+  "prompt_budget_tokens": 600
+}

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

@@ -0,0 +1,10 @@
+{
+  "name": "day-close",
+  "kind": "super_agent",
+  "schedule": "{{day_close_schedule}}",
+  "permission_mode": "automatico",
+  "enabled_by_default": true,
+  "spec": {
+    "prompt": "Close the day. Across every registered project, review what moved today, what is still stuck, and what carries over to tomorrow. Send ONE short message covering those three. Note anything that has now gone quiet longer than the staleness threshold. If the day was quiet, say that plainly and keep it to a line or two. Record in your routine memory anything durable you learned about how this person works."
+  }
+}

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

@@ -0,0 +1,10 @@
+{
+  "name": "day-open",
+  "kind": "super_agent",
+  "schedule": "{{day_open_schedule}}",
+  "permission_mode": "automatico",
+  "enabled_by_default": true,
+  "spec": {
+    "prompt": "Open the day. Across every registered project, look at what is due today, what is overdue, what is blocked, and any commitment coming due. Then send ONE short message: what is due today, anything on the calendar, and the single thing that most deserves attention. Not an inventory. If there is genuinely nothing pressing, say so in one line rather than padding it. Pass the four gates in your channel guidance before sending anything beyond this anchor."
+  }
+}

package/src/core/profiles/index.js

@@ -0,0 +1,16 @@
+// Installable profiles for the super-agent.
+//
+// A profile is a PACKAGE, not a fork of the base prompt: it contributes a
+// prompt block, routines, agents, skills and a set of white-label settings.
+// APX vanilla has no profile, and with none active the super-agent prompt is
+// byte-identical to what it was before this subsystem existed.
+//
+// The dividing line, used whenever it is unclear where something belongs:
+// the CAPABILITY goes in core, the JUDGEMENT goes in the profile. Being able to
+// send an unprompted message is core; deciding that a project untouched for
+// eight days is worth one is the profile's call.
+export * from "./paths.js";
+export * from "./manifest.js";
+export * from "./store.js";
+export * from "./block.js";
+export * from "./lifecycle.js";