@agentprojectcontext/apx 1.78.0 → 1.80.0

package/src/interfaces/web/src/i18n/es.ts

@@ -3,6 +3,32 @@
 // will TypeScript-error on unknown keys.
 
 export const es = {
+    cron: {
+      daily:            "todos los días a las {at}",
+      weekdays:         "de lunes a viernes a las {at}",
+      weekends:         "fines de semana a las {at}",
+      on_days:          "{days} a las {at}",
+      monthly:          "el día {day} de cada mes a las {at}",
+      every_hour:       "cada hora, al minuto {minute}",
+      every_n_hours:    "cada {n} horas, al minuto {minute}",
+      every_n_minutes:  "cada {n} minutos",
+      every_minute:     "cada minuto",
+      every_label:      "cada N horas en vez de una hora fija",
+      use_cron:         "editar como cron",
+      use_picker:       "usar el selector",
+      preset_every_day: "todos los días",
+      preset_weekdays:  "días de semana",
+      preset_weekends:  "fin de semana",
+      day_short: { sun: "Dom", mon: "Lun", tue: "Mar", wed: "Mié", thu: "Jue", fri: "Vie", sat: "Sáb" },
+    },
+    when: {
+      now:     "ahora",
+      in:      "en {amount}",
+      ago:     "hace {amount}",
+      minutes: "{n} min",
+      hours:   "{n} h",
+      days:    "{n} d",
+    },
   common: {
     loading:      "Cargando…",
     saving:       "Guardando…",
@@ -144,6 +170,11 @@ export const es = {
     no_folders:  "Sin carpetas.",
   },
   inbox: {
+    search: "Buscar",
+    no_match: "No coincide nada",
+    hide_quiet: "Ocultar agentes callados",
+    open_in_project: "Abrir en el proyecto",
+    super_agent_scope: "Todos los proyectos",
     title: "Bandeja de agentes",
     subtitle:
       "Cada agente como una conversación, lo más reciente primero.",
@@ -196,6 +227,8 @@ export const es = {
     devices_revoke:      "Revocar",
     account_section:     "Cuenta",
     agents_section:      "Agentes & modelos",
+    super_agent_section: "Super-agente",
+    knowledge_section:   "Modelos y conocimiento",
     channels_section:    "Canales & dispositivos",
     modules_section:     "Módulos",
     advanced_section:    "Avanzado",
@@ -207,6 +240,7 @@ export const es = {
       engines: "Engines & modelos",
       telegram: "Telegram",
       devices: "Dispositivos",
+      nudge: "Interrupciones",
       advanced: "Avanzado",
     },
 
@@ -223,6 +257,9 @@ export const es = {
       activate: "Activar",
       replace_active: "Reemplazar el activo",
       deactivate: "Desactivar",
+      on: "Activo",
+      off: "Inactivo",
+      replaces_active: "Activarlo reemplaza al perfil activo",
       deactivate_title: "¿Desactivar el perfil?",
       deactivate_confirm:
         "APX vuelve a vanilla. Las rutinas del perfil se deshabilitan pero no se borran, y tu configuración, tareas y memoria quedan intactas: volver a activarlo restaura todo.",
@@ -246,6 +283,34 @@ export const es = {
       doctor_vanilla: "Sin perfil activo. APX se comporta como siempre.",
     },
 
+    nudge: {
+      title: "Presupuesto de interrupciones",
+      subtitle:
+        "Cada cuánto puede escribirte APX sin que se lo pidas. Las respuestas a tus propios mensajes nunca se retienen.",
+      off_hint:
+        "El presupuesto está apagado: sale todo mensaje no solicitado. Igual queda registrado acá abajo.",
+      on_hint: "{{sent}} enviados hoy, quedan {{left}}.",
+      source: "Definido por",
+      enabled: "Aplicar el presupuesto",
+      daily_max: "Mensajes por día",
+      daily_max_hint: "0 significa sin techo.",
+      quiet_hours: "Horas de silencio",
+      quiet_hours_hint: "HH:MM-HH:MM. Cruza la medianoche sin problema. Vacío = ninguna.",
+      cooldown: "Espacio mínimo (minutos)",
+      project_cooldown: "Espacio mínimo por proyecto (minutos)",
+      kind_cooldown: "Espacio mínimo por tipo (minutos)",
+      critical_bypass: "Lo crítico puede saltarse el presupuesto",
+      critical_bypass_hint: "Los saltos quedan siempre registrados y marcados.",
+      log_title: "Lo que mandó",
+      log_subtitle: "Sólo mensajes no solicitados, del más nuevo al más viejo. Lo que marques alimenta lo que manda después.",
+      log_empty: "Todavía no mandó nada sin que se lo pidieras.",
+      useful: "Me sirvió",
+      noise: "No me servía",
+      bypass: "se salteó el presupuesto",
+      saved: "Presupuesto actualizado",
+      unrated: "sin calificar",
+    },
+
     identity: {
       title: "Identidad",
       subtitle: "Datos del usuario. Configuración del agente va en Super-agente.",
@@ -339,6 +404,7 @@ export const es = {
       agents:   "Agents",
       routines: "Rutinas",
       tasks:    "Tasks",
+      commitments: "Compromisos",
       mcps:     "MCPs",
       artifacts: "Artifacts",
       vars:     "Variables",
@@ -443,6 +509,16 @@ export const es = {
     },
 
     global_tasks: {
+
+      add: "Agregar",
+
+      add_title: "Nueva tarea",
+
+      field_title: "Tarea",
+
+      field_project: "Proyecto",
+
+      field_due: "Vence",
       any_status: "cualquier estado",
       title:       "Tasks (todos los proyectos)",
       subtitle:    "Tareas agregadas de todos los proyectos registrados.",
@@ -451,6 +527,44 @@ export const es = {
       go_project:  "Ir al proyecto",
     },
 
+    commitments: {
+
+      add: "Agregar",
+
+      add_title: "Registrar una promesa",
+
+      add_hint: "Algo que le dijiste a una persona concreta que ibas a hacer. Las tareas están al lado.",
+
+      field_who: "Quién está esperando",
+
+      field_who_hint: "El nombre como lo dirías vos — texto libre, no un contacto.",
+
+      field_what: "Qué prometiste",
+
+      field_what_ph: "mandar el presupuesto corregido",
+
+      field_due: "Para cuándo",
+
+      field_due_hint: "Opcional, pero es la parte que lo hace útil.",
+
+      field_project: "Proyecto",
+      title:    "Compromisos",
+      subtitle: "Qué prometiste, a quién y para cuándo. Aparte de las tareas: acá hay alguien esperando.",
+      empty:    "Nada prometido.",
+      overdue:  "vencía",
+      overdue_only: "Pasados de fecha",
+      no_date:  "sin fecha acordada",
+      moved:    "movido",
+      mark_kept:   "Cumplido",
+      mark_missed: "Incumplido",
+      state: {
+        open:   "abiertos",
+        kept:   "cumplidos",
+        missed: "incumplidos",
+        all:    "todos",
+      },
+    },
+
     routines: {
       title:       "Heartbeats / Routines",
       subtitle:    "Cron, every:Nm, once:ISO. Cada rutina dispara un agente o un shell.",
@@ -782,6 +896,12 @@ export const es = {
     },
 
     memories: {
+
+      super_agent_group: "Super-agente",
+
+      notebook_item: "Libreta de {persona}",
+
+      tokens: "~{n} tok",
       sidebar_title:   "Memorias",
       general_group:   "General",
       general_item:    "Memoria del proyecto",
@@ -873,6 +993,8 @@ export const es = {
     no_activity_ch: "Sin actividad en el canal \"{ch}\".",
     error:        "No pude leer los mensajes: {msg}",
     show_more:    "ver más",
+    event_routine_created: "rutina creada",
+    event_routine_updated: "rutina actualizada",
     show_less:    "ver menos",
     daemon_errors: "Errores del daemon (~/.apx/logs/errors.jsonl)",
     no_errors:    "Sin errores registrados. 🎉",
@@ -1564,6 +1686,9 @@ export const es = {
     kind_routine:            "rutina",
     kind_hierarchy:          "jerarquía",
     nodes_drag_hint:         "{n} nodos · arrastrá para reordenar",
+    kind_watch:              "Vigía",
+    kind_watch_desc:         "Barre buscando cosas que valga la pena notar — vencidos, promesas por caer, proyectos en silencio. No cuesta nada cuando no hay nada que reportar.",
+    action_watch:            "Vigila señales, y sólo juzga cuando encuentra alguna",
     kind_exec_agent:         "Agente del proyecto",
     kind_exec_agent_desc:    "Corre un agente del proyecto con un prompt. Vos elegís cuál.",
     kind_super_agent:        "Super-agente",
@@ -1583,6 +1708,7 @@ export const es = {
     preset_every_10m:        "cada 10 min",
     preset_hourly:           "cada hora",
     preset_daily_9am:        "diario 9am",
+    sched_manual:            "solo cuando lo corrés vos",
     preset_weekdays_9am:     "días hábiles 9am",
     preset_manual:           "Manual",
     var_pre_output_prompt:   "Salida de texto de los pre-commands. Se reemplaza dentro del prompt/texto antes de enviarlo. Útil para inyectar datos frescos (clima, una API) en la instrucción.",
@@ -1873,6 +1999,7 @@ export const es = {
   shared_ui: {
     skill_inspector_title: "Skill Inspector ({embedder}) eligió estas skills para este turno",
     tools_count:           "{n} tools",
+    tools_failed:          "{n} fallaron",
     tool_read_file:        "Leer archivo",
     tool_write_file:       "Escribir archivo",
     tool_edit_file:        "Editar archivo",

package/src/interfaces/web/src/lib/api/commitments.ts

@@ -0,0 +1,57 @@
+import { http, unwrapPage } from "../http";
+
+export type CommitmentState = "open" | "kept" | "missed";
+
+export type CommitmentEntry = {
+  id: string;
+  created_at: string;
+  updated_at: string;
+  state: CommitmentState;
+  counterparty: string;
+  body: string;
+  promised_at: string;
+  due: string | null;
+  origin_channel: string | null;
+  origin_message_ref: string | null;
+  note?: string | null;
+  renegotiated_count?: number;
+  history: { due: string | null; moved_at: string; note: string | null }[];
+};
+
+export type GlobalCommitmentEntry = CommitmentEntry & {
+  project_id: string | number;
+  project_name: string;
+};
+
+type ListOpts = {
+  state?: CommitmentState | "all";
+  counterparty?: string;
+  overdue?: boolean;
+  limit: number;
+  offset: number;
+};
+
+function qs(o: ListOpts): string {
+  const p = new URLSearchParams();
+  if (o.state) p.set("state", o.state);
+  if (o.counterparty) p.set("counterparty", o.counterparty);
+  if (o.overdue) p.set("overdue", "1");
+  p.set("limit", String(o.limit));
+  p.set("offset", String(o.offset));
+  return p.toString();
+}
+
+export const Commitments = {
+  globalPage: (o: ListOpts) =>
+    http.get<unknown>(`/api/commitments?${qs(o)}`).then((b) => unwrapPage<GlobalCommitmentEntry>(b)),
+  listPage: (pid: string, o: ListOpts) =>
+    http.get<unknown>(`/api/projects/${pid}/commitments?${qs(o)}`).then((b) => unwrapPage<CommitmentEntry>(b)),
+  add: (pid: string, body: { counterparty: string; body: string; due?: string | null }) =>
+    http.post<CommitmentEntry>(`/api/projects/${pid}/commitments`, body),
+  kept: (pid: string, id: string, note?: string) =>
+    http.post<CommitmentEntry>(`/api/projects/${pid}/commitments/${id}/kept`, { note }),
+  missed: (pid: string, id: string, note?: string) =>
+    http.post<CommitmentEntry>(`/api/projects/${pid}/commitments/${id}/missed`, { note }),
+  renegotiate: (pid: string, id: string, due: string, note?: string) =>
+    http.post<CommitmentEntry>(`/api/projects/${pid}/commitments/${id}/renegotiate`, { due, note }),
+};

package/src/interfaces/web/src/lib/api/notebook.ts

@@ -0,0 +1,23 @@
+import { http } from "../http";
+
+/**
+ * The super-agent's own notebook (~/.apx/memory.md).
+ *
+ * Distinct from project memory (.apc/memory.md) and from each agent's memory.
+ * This is the one that ships in EVERY prompt on every channel, which is why it
+ * reports its own token cost.
+ */
+export interface NotebookInfo {
+  body: string;
+  path: string;
+  chars: number;
+  approx_tokens: number;
+  entries: number;
+  /** How many entries were written by memory consolidation rather than by hand. */
+  consolidated: number;
+}
+
+export const Notebook = {
+  get: () => http.get<NotebookInfo>("/api/notebook"),
+  put: (body: string) => http.put<{ ok: true } & Omit<NotebookInfo, "body">>("/api/notebook", { body }),
+};

package/src/interfaces/web/src/lib/api/nudges.ts

@@ -0,0 +1,53 @@
+import { http } from "../http";
+
+export type NudgePolicy = {
+  enabled: boolean;
+  daily_max: number;
+  quiet_hours: string;
+  cooldown_minutes: number;
+  project_cooldown_minutes: number;
+  kind_cooldown_minutes: number;
+  critical_bypasses_budget: boolean;
+};
+
+export type NudgeEntry = {
+  id: string;
+  at: string;
+  kind: string;
+  project_id: string | null;
+  severity: string;
+  channel: string;
+  chat_id: string | null;
+  preview: string;
+  bypassed_budget: boolean;
+  feedback: { useful: boolean; note: string; at: string } | null;
+};
+
+export type NudgeStats = {
+  total: number;
+  today: number;
+  rated: number;
+  by_kind: { kind: string; sent: number; useful: number; noise: number }[];
+};
+
+export const NudgesApi = {
+  list: (limit = 50) =>
+    http.get<{ data: NudgeEntry[]; meta: { total: number; stats: NudgeStats } }>(
+      `/api/nudges?limit=${limit}`,
+    ),
+  policy: () =>
+    http.get<{
+      policy: NudgePolicy;
+      /** Which layers contributed: defaults → profile → user. */
+      source: string[];
+      defaults: NudgePolicy;
+      user_overrides: Partial<NudgePolicy>;
+    }>("/api/nudges/policy"),
+  setPolicy: (values: Partial<NudgePolicy>) =>
+    http.put<{ ok: true; policy: NudgePolicy; source: string[] }>("/api/nudges/policy", values),
+  feedback: (id: string, useful: boolean, note = "") =>
+    http.post<{ ok: true; entry: NudgeEntry }>(
+      `/api/nudges/${encodeURIComponent(id)}/feedback`,
+      { useful, note },
+    ),
+};

package/src/interfaces/web/src/lib/cron.ts

@@ -0,0 +1,196 @@
+/**
+ * Five-field cron ⇄ human, both directions.
+ *
+ * `30 8 * * 1-5` is not a thing anyone should have to read to answer "when
+ * does my morning message arrive". Two pure functions, one file, so the
+ * summary shown in a status line and the picker used in a form can never
+ * disagree about what an expression means.
+ *
+ * Deliberately NOT a general cron library. It covers what APX writes and what
+ * the picker produces — fixed time, day-of-week sets, day-of-month, and
+ * step values — and says plainly when it does not understand something rather
+ * than guessing. `describeCron` returning null is the signal for a surface to
+ * fall back to showing the raw expression.
+ */
+
+export interface CronParts {
+  minute: string;
+  hour: string;
+  dom: string;
+  month: string;
+  dow: string;
+}
+
+/** What a picker edits. */
+export interface CronSelection {
+  /** "HH:MM" in the machine's local time. */
+  time: string;
+  /** 0=Sunday … 6=Saturday. Empty = every day. */
+  days: number[];
+  /** Run every N hours instead of at a fixed time. 0 = off. */
+  everyHours: number;
+}
+
+export const DAY_KEYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"] as const;
+
+export function parseCron(expr: string): CronParts | null {
+  const f = String(expr || "").trim().split(/\s+/);
+  if (f.length !== 5) return null;
+  return { minute: f[0], hour: f[1], dom: f[2], month: f[3], dow: f[4] };
+}
+
+// Expand `1-5`, `1,3,5`, `*` and step values like `*/2` into concrete numbers.
+// (Kept as a line comment: a `*/` inside a block comment closes it.)
+function expand(field: string, min: number, max: number): number[] | null {
+  const out = new Set<number>();
+  for (const part of String(field).split(",")) {
+    const step = part.match(/^(.+)\/(\d+)$/);
+    const body = step ? step[1] : part;
+    const by = step ? Number(step[2]) : 1;
+    if (!Number.isFinite(by) || by < 1) return null;
+
+    let lo: number;
+    let hi: number;
+    if (body === "*") { lo = min; hi = max; }
+    else {
+      const range = body.match(/^(\d+)-(\d+)$/);
+      if (range) { lo = Number(range[1]); hi = Number(range[2]); }
+      else if (/^\d+$/.test(body)) { lo = Number(body); hi = lo; }
+      else return null;
+    }
+    if (lo < min || hi > max || lo > hi) return null;
+    for (let v = lo; v <= hi; v += by) out.add(v);
+  }
+  return [...out].sort((a, b) => a - b);
+}
+
+/** Day numbers a cron dow field selects. Cron accepts 7 for Sunday. */
+export function cronDays(dow: string): number[] | null {
+  if (dow === "*" || dow === "?") return [];
+  const nums = expand(dow.replace(/\b7\b/g, "0"), 0, 6);
+  return nums && nums.length ? nums : null;
+}
+
+/**
+ * A sentence. Returns null when the expression is beyond what this understands
+ * — the caller shows the raw cron rather than a confident wrong reading.
+ */
+export function describeCron(
+  expr: string,
+  t: (key: string, vars?: Record<string, string | number>) => string,
+): string | null {
+  const p = parseCron(expr);
+  if (!p) return null;
+  if (p.month !== "*") return null;      // "in March" is not a case APX writes
+  if (p.dom !== "*" && p.dow !== "*") return null; // both set is ambiguous in cron itself
+
+  // Every N hours: `0 */2 * * *`.
+  const stepHour = p.hour.match(/^\*\/(\d+)$/);
+  if (stepHour && /^\d+$/.test(p.minute)) {
+    const n = Number(stepHour[1]);
+    return n === 1
+      ? t("cron.every_hour", { minute: pad(Number(p.minute)) })
+      : t("cron.every_n_hours", { n, minute: pad(Number(p.minute)) });
+  }
+  // Every N minutes: `*/15 * * * *`.
+  const stepMin = p.minute.match(/^\*\/(\d+)$/);
+  if (stepMin && p.hour === "*") return t("cron.every_n_minutes", { n: Number(stepMin[1]) });
+  if (p.minute === "*" && p.hour === "*") return t("cron.every_minute");
+
+  const hours = expand(p.hour, 0, 23);
+  const minutes = expand(p.minute, 0, 59);
+  if (!hours || !minutes || minutes.length !== 1) return null;
+
+  const at = hours.length === 1
+    ? `${pad(hours[0])}:${pad(minutes[0])}`
+    : hours.map((h) => `${pad(h)}:${pad(minutes[0])}`).join(", ");
+
+  if (p.dom !== "*") {
+    const doms = expand(p.dom, 1, 31);
+    if (!doms || doms.length !== 1) return null;
+    return t("cron.monthly", { day: doms[0], at });
+  }
+
+  const days = cronDays(p.dow);
+  if (days === null) return null;
+  if (!days.length) return t("cron.daily", { at });
+
+  const weekdays = [1, 2, 3, 4, 5];
+  const isWeekdays = days.length === 5 && weekdays.every((d) => days.includes(d));
+  if (isWeekdays) return t("cron.weekdays", { at });
+  if (days.length === 2 && days.includes(0) && days.includes(6)) return t("cron.weekends", { at });
+
+  const names = days.map((d) => t(`cron.day_short.${DAY_KEYS[d]}`)).join(", ");
+  return t("cron.on_days", { days: names, at });
+}
+
+/** Cron → what a picker should show. */
+export function cronToSelection(expr: string): CronSelection {
+  const p = parseCron(expr);
+  const fallback: CronSelection = { time: "08:00", days: [], everyHours: 0 };
+  if (!p) return fallback;
+
+  const stepHour = p.hour.match(/^\*\/(\d+)$/);
+  if (stepHour) {
+    return {
+      time: `00:${pad(Number(/^\d+$/.test(p.minute) ? p.minute : 0))}`,
+      days: [],
+      everyHours: Number(stepHour[1]),
+    };
+  }
+  const hours = expand(p.hour, 0, 23);
+  const minutes = expand(p.minute, 0, 59);
+  const days = cronDays(p.dow);
+  return {
+    time: hours?.length && minutes?.length ? `${pad(hours[0])}:${pad(minutes[0])}` : fallback.time,
+    days: days ?? [],
+    everyHours: 0,
+  };
+}
+
+/** What a picker produces. Always a valid five-field expression. */
+export function selectionToCron(sel: CronSelection): string {
+  if (sel.everyHours > 0) {
+    const [, mm] = splitTime(sel.time);
+    return `${mm} */${clamp(sel.everyHours, 1, 23)} * * *`;
+  }
+  const [hh, mm] = splitTime(sel.time);
+  // Sorted, and 0 kept as 0 — cron accepts both 0 and 7 for Sunday, and
+  // writing one form consistently keeps round-tripping stable.
+  const dow = sel.days.length && sel.days.length < 7
+    ? [...sel.days].sort((a, b) => a - b).join(",")
+    : "*";
+  return `${mm} ${hh} * * ${dow}`;
+}
+
+/** Is this something the pickers can represent without losing information? */
+export function isPickerFriendly(expr: string): boolean {
+  const p = parseCron(expr);
+  if (!p) return false;
+  if (p.month !== "*" || p.dom !== "*") return false;
+  return selectionToCron(cronToSelection(expr)) === normalizeCron(expr);
+}
+
+/** `30 08 * * 1-5` → `30 8 * * 1,2,3,4,5`, so comparisons are meaningful. */
+export function normalizeCron(expr: string): string {
+  const p = parseCron(expr);
+  if (!p) return String(expr || "").trim();
+  const days = cronDays(p.dow);
+  const dow = days && days.length && days.length < 7 ? days.join(",") : "*";
+  const one = (f: string) => (/^\d+$/.test(f) ? String(Number(f)) : f);
+  return `${one(p.minute)} ${one(p.hour)} ${p.dom} ${p.month} ${dow}`;
+}
+
+function splitTime(time: string): [string, string] {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(String(time || "").trim());
+  if (!m) return ["8", "0"];
+  return [String(clamp(Number(m[1]), 0, 23)), String(clamp(Number(m[2]), 0, 59))];
+}
+
+function pad(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+function clamp(n: number, lo: number, hi: number): number {
+  return Math.min(hi, Math.max(lo, Number.isFinite(n) ? n : lo));
+}

package/src/interfaces/web/src/lib/when.ts

@@ -0,0 +1,32 @@
+/**
+ * "in 8 hours" / "2 minutes ago".
+ *
+ * A status row showing two absolute timestamps makes the reader do the
+ * arithmetic that the row exists to save them. The absolute value stays
+ * available as a tooltip for when the exact minute is what matters.
+ */
+type T = (key: string, vars?: Record<string, string | number>) => string;
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+
+export function relativeWhen(iso: string, t: T, now: number = Date.now()): string {
+  const ms = Date.parse(iso);
+  if (!Number.isFinite(ms)) return "—";
+  const diff = ms - now;
+  const ahead = diff >= 0;
+  const abs = Math.abs(diff);
+
+  // Under a minute reads as "now" in both directions: "in 34 seconds" is
+  // precision nobody acts on.
+  if (abs < MINUTE) return t("when.now");
+
+  const [n, unit] =
+    abs < HOUR ? [Math.round(abs / MINUTE), "minutes"] :
+    abs < DAY ? [Math.round(abs / HOUR), "hours"] :
+    [Math.round(abs / DAY), "days"];
+
+  const amount = t(`when.${unit}`, { n });
+  return ahead ? t("when.in", { amount }) : t("when.ago", { amount });
+}