@agentprojectcontext/apx 1.6.0 → 1.8.0

package/src/core/apc-context-skill.md

@@ -95,6 +95,9 @@ APX can provide a local daemon, MCP management, Telegram bridge, routines, and r
 across Codex, Claude Code, OpenCode, Aider, or direct LLM engines. Those are APX runtime features,
 not APC portable-core requirements.
 
+The APX super-agent uses `~/.apx/projects/default` for system-level work when no project is named.
+APX routines can run heartbeat, shell, Telegram, project agent, or super-agent tasks on a schedule.
+
 APX runtime state belongs outside the repository:
 
 ```text

package/src/core/apx-skill.md

@@ -5,6 +5,9 @@ The daemon runs on `127.0.0.1:7430` and auto-starts on first `apx` call.
 APX reads APC project context from `.apc/`, but APX runtime state belongs outside the repository
 under `~/.apx/projects/<project-id>/`.
 
+The APX super-agent has an always-available default workspace at `~/.apx/projects/default`.
+When no project is named, system-level work belongs there.
+
 ---
 
 ## Coordinate with other agents
@@ -73,10 +76,37 @@ apx session check                                # exits 1 if session already ac
 
 ```bash
 apx messages tail                               # last 50 messages, all channels
+apx messages chat --channel telegram -n 20      # chat view with user/agent/system type
 apx messages tail --channel runtime             # only agent invocations
 apx messages tail --agent <slug> -n 20
 ```
 
+Message rows expose `type` (`user`, `agent`, `tool`, `system`) and `actor_id`; use `messages chat`
+when you need a readable transcript.
+
+## Super-agent permissions
+
+```bash
+apx permission show
+apx permission set automatico   # total | automatico | permiso
+```
+
+`automatico` runs read/list/safe shell checks directly and asks before destructive shell, MCP,
+runtime, outbound, config, or filesystem mutation actions.
+
+## Routines
+
+```bash
+apx routine list
+apx routine get <name>
+apx routine history <name>
+apx routine add clima --kind super_agent --schedule every:5m \
+  --permission-mode total \
+  --spec '{"prompt":"Check weather and send Telegram update."}'
+```
+
+Routine kinds: `heartbeat`, `exec_agent`, `super_agent`, `telegram`, `shell`.
+
 ## APC_RESULT
 
 Print on the last meaningful line of your output so the invoker captures it:

package/src/core/config.js

@@ -46,6 +46,8 @@ const DEFAULT_CONFIG = {
     name: "apx",
     model: "",                          // e.g. "ollama:llama3.2:3b"
     system: "",                         // optional override; defaults baked into super-agent.js
+    permission_mode: "automatico",       // total | automatico | permiso
+    allowed_tools: [],                   // used by permission_mode="permiso"
   },
   engines: {
     anthropic: { api_key: "" },

package/src/core/mascot.js

@@ -4,9 +4,7 @@
 const R = "\x1b[0m";
 const B = "\x1b[1m";
 const W = "\x1b[97m";       // bright white
-const K = "\x1b[30m";       // black
 const BK = "\x1b[40m";      // bg black
-const BW = "\x1b[47m";      // bg white
 const CY = "\x1b[36m";
 const YE = "\x1b[33m";
 const GR = "\x1b[32m";
@@ -34,10 +32,10 @@ const MOODS = {
   wave: {
     color: CY,
     lines: [
-      `   ${BK}${W}  ▄███████▄  ${R}     👋`,
-      `  ${BK}${W} █ ${R}${B}██${R}${W}   ${B}██${R}${BK}${W} █ ${R}`,
-      `  ${BK}${W} █  ◕   ◕  █ ${R}`,
-      `  ${BK}${W} █   ╰▽╯   █ ${R}`,
+      `   ${BK}${W}  ▄███████▄  ${R}   ${DI}/)${R}`,
+      `  ${BK}${W} █ ${R}${B}██${R}${W}   ${B}██${R}${BK}${W} █ ${R}  ${DI}//${R}`,
+      `  ${BK}${W} █  ◕   ◕  █ ${R} ${DI}//${R}`,
+      `  ${BK}${W} █   ╰▽╯   █ ${R}${DI}/${R}`,
       `   ${BK}${W}  ▀███████▀  ${R}`,
       `   ${DI}   ╱  ╲  ╱  ╲   ${R}`,
     ],
@@ -76,7 +74,7 @@ const MOODS = {
   excited: {
     color: BL,
     lines: [
-      `   ${BK}${W}  ▄███████▄  ${R}  ${BL}⬆${R}`,
+      `   ${BK}${W}  ▄███████▄  ${R}  ${BL}↑${R}`,
       `  ${BK}${W} █ ${R}${B}██${R}${W}   ${B}██${R}${BK}${W} █ ${R}`,
       `  ${BK}${W} █  ★   ★  █ ${R}`,
       `  ${BK}${W} █   ╰◡╯   █ ${R}`,

package/src/core/messages-store.js

@@ -7,7 +7,7 @@
 //   ~/.apx/messages/<channel>/YYYY-MM-DD.jsonl
 //
 // Each line:
-//   {"ts":"...","channel":"...","direction":"in|out","author":"...","body":"...","meta":{...}}
+//   {"ts":"...","channel":"...","direction":"in|out","type":"user|agent|tool|system","author":"...","actor_id":"...","body":"...","meta":{...}}
 //
 // Why JSONL: same shape as Claude Code's ~/.claude/projects/<id>.jsonl.
 // Streamable, structured, no markdown parsing fragility.
@@ -32,24 +32,61 @@ function dayPathMd(projectRoot, ts) {
   return path.join(projectRoot, "messages", `${day}.md`);
 }
 
-export function appendMessageToFs({ projectRoot, channel, direction, author, body, meta = {}, ts, agent_slug, session_id, external_id }) {
-  ts = ts || nowIso();
-  const file = dayPathJsonl(projectRoot, ts);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
+const VALID_MESSAGE_TYPES = new Set(["user", "agent", "tool", "system"]);
+
+function normalizeMessageType(type) {
+  return typeof type === "string" && VALID_MESSAGE_TYPES.has(type) ? type : null;
+}
+
+export function inferMessageType({ type, channel, direction, author, agent_slug, meta = {} } = {}) {
+  const explicit = normalizeMessageType(type) || normalizeMessageType(meta.type) || normalizeMessageType(meta.actor_type);
+  if (explicit) return explicit;
+  if (channel === "a2a") return "agent";
+  if (meta.tool || meta.tool_name) return "tool";
+  if (author === "system") return "system";
+  if (agent_slug && author && author !== "user" && !String(author).startsWith("@")) return "agent";
+  if (direction === "in" && (author === "user" || String(author || "").startsWith("@"))) return "user";
+  if (direction === "out") return "agent";
+  return direction === "in" ? "user" : "agent";
+}
 
-  // Compose meta from explicit fields plus the bag
-  const fullMeta = {
+function inferActorId({ type, actor_id, author, agent_slug, meta = {} } = {}) {
+  if (actor_id) return actor_id;
+  if (meta.actor_id) return meta.actor_id;
+  if (type === "user") return meta.user_id ? String(meta.user_id) : (author || "user");
+  if (type === "agent") return agent_slug || author || "agent";
+  if (type === "tool") return meta.tool || meta.tool_name || author || "tool";
+  if (type === "system") return author || "system";
+  return author || null;
+}
+
+function messageMeta({ type, actor_id, agent_slug, session_id, external_id, meta = {} }) {
+  return {
+    ...meta,
+    type,
+    ...(actor_id ? { actor_id } : {}),
     ...(agent_slug ? { agent: agent_slug } : {}),
     ...(session_id ? { session_id } : {}),
     ...(external_id ? { external_id } : {}),
-    ...meta,
   };
+}
+
+export function appendMessageToFs({ projectRoot, channel, direction, type, actor_id, author, body, meta = {}, ts, agent_slug, session_id, external_id }) {
+  ts = ts || nowIso();
+  const file = dayPathJsonl(projectRoot, ts);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+
+  const msgType = inferMessageType({ type, channel, direction, author, agent_slug, meta });
+  const msgActorId = inferActorId({ type: msgType, actor_id, author, agent_slug, meta });
+  const fullMeta = messageMeta({ type: msgType, actor_id: msgActorId, agent_slug, session_id, external_id, meta });
 
   const record = {
     ts,
     channel,
     direction,
+    type: msgType,
     author: author || null,
+    ...(msgActorId ? { actor_id: msgActorId } : {}),
     body: body || "",
     ...(Object.keys(fullMeta).length ? { meta: fullMeta } : {}),
   };
@@ -65,6 +102,16 @@ export function insertMessageRow(db, m) {
     const a = db.prepare("SELECT id FROM agents WHERE slug = ?").get(m.agent_slug);
     if (a) agent_id = a.id;
   }
+  const type = inferMessageType(m);
+  const actor_id = inferActorId({ ...m, type });
+  const meta = messageMeta({
+    type,
+    actor_id,
+    agent_slug: m.agent_slug,
+    session_id: m.session_id,
+    external_id: m.external_id,
+    meta: m.meta || {},
+  });
   return db
     .prepare(
       `INSERT INTO messages (agent_id, session_id, channel, direction, external_id, author, body, meta_json, ts)
@@ -78,17 +125,19 @@ export function insertMessageRow(db, m) {
       m.external_id || null,
       m.author || null,
       m.body || "",
-      JSON.stringify(m.meta || {}),
+      JSON.stringify(meta),
       m.ts
     );
 }
 
 // Single entry point used by everywhere the daemon writes a message.
-export function appendMessage({ projectRoot, db, channel, direction, author, body, meta = {}, ts, agent_slug, session_id, external_id }) {
+export function appendMessage({ projectRoot, db, channel, direction, type, actor_id, author, body, meta = {}, ts, agent_slug, session_id, external_id }) {
   const written = appendMessageToFs({
     projectRoot,
     channel,
     direction,
+    type,
+    actor_id,
     author,
     body,
     meta,
@@ -100,6 +149,8 @@ export function appendMessage({ projectRoot, db, channel, direction, author, bod
   insertMessageRow(db, {
     channel,
     direction,
+    type,
+    actor_id,
     author,
     body,
     meta,
@@ -121,15 +172,33 @@ export function parseDayJsonl(text) {
     try { obj = JSON.parse(trimmed); } catch { continue; }
     if (!obj || typeof obj !== "object") continue;
     const meta = obj.meta || {};
+    const agent_slug = obj.agent_slug || meta.agent;
+    const type = inferMessageType({
+      type: obj.type,
+      channel: obj.channel,
+      direction: obj.direction,
+      author: obj.author,
+      agent_slug,
+      meta,
+    });
+    const actor_id = inferActorId({
+      type,
+      actor_id: obj.actor_id,
+      author: obj.author,
+      agent_slug,
+      meta,
+    });
     out.push({
       ts: obj.ts,
       channel: obj.channel,
       direction: obj.direction,
+      type,
       author: obj.author,
+      actor_id,
       body: obj.body || "",
       meta,
-      agent_slug: meta.agent,
-      session_id: typeof meta.apc_session_id === "number" ? meta.apc_session_id : null,
+      agent_slug,
+      session_id: meta.session_id ?? (typeof meta.apc_session_id === "number" ? meta.apc_session_id : null),
       external_id: meta.external_id,
     });
   }
@@ -156,10 +225,15 @@ export function parseDayFile(text) {
       body = body.replace(metaMatch[0], "");
     }
     body = body.trim();
+    const agent_slug = meta.agent;
+    const type = inferMessageType({ channel, direction, author, agent_slug, meta });
+    const actor_id = inferActorId({ type, author, agent_slug, meta });
     out.push({
       ts, channel, direction, author, body, meta,
-      agent_slug: meta.agent,
-      session_id: typeof meta.apc_session_id === "number" ? meta.apc_session_id : null,
+      type,
+      actor_id,
+      agent_slug,
+      session_id: meta.session_id ?? (typeof meta.apc_session_id === "number" ? meta.apc_session_id : null),
       external_id: meta.external_id,
     });
   }
@@ -343,21 +417,21 @@ export function getRecentTelegramTurnsFromFs({
 // ---------------------------------------------------------------------------
 
 // Write a message to the global channel store.  No SQL cache — JSONL only.
-export function appendGlobalMessage({ channel, direction, author, body, meta = {}, ts, agent_slug, external_id }) {
+export function appendGlobalMessage({ channel, direction, type, actor_id, author, body, meta = {}, ts, agent_slug, external_id }) {
   ts = ts || nowIso();
   const dir = path.join(GLOBAL_MESSAGES_DIR, channel);
   fs.mkdirSync(dir, { recursive: true });
   const file = path.join(dir, `${ts.slice(0, 10)}.jsonl`);
-  const fullMeta = {
-    ...(agent_slug ? { agent: agent_slug } : {}),
-    ...(external_id ? { external_id } : {}),
-    ...meta,
-  };
+  const msgType = inferMessageType({ type, channel, direction, author, agent_slug, meta });
+  const msgActorId = inferActorId({ type: msgType, actor_id, author, agent_slug, meta });
+  const fullMeta = messageMeta({ type: msgType, actor_id: msgActorId, agent_slug, external_id, meta });
   const record = {
     ts,
     channel,
     direction,
+    type: msgType,
     author: author || null,
+    ...(msgActorId ? { actor_id: msgActorId } : {}),
     body: body || "",
     ...(Object.keys(fullMeta).length ? { meta: fullMeta } : {}),
   };

package/src/core/routines-store.js

@@ -75,7 +75,7 @@ export function getRoutine(projectPath, name) {
   return readFile(projectPath).find((r) => r.name === name) || null;
 }
 
-export function upsertRoutine(projectPath, { name, kind, schedule, spec, enabled = true }) {
+export function upsertRoutine(projectPath, { name, kind, schedule, spec, enabled = true, permission_mode, allowed_tools }) {
   if (!name || !kind || !schedule) throw new Error("routine requires name, kind, schedule");
   const now = nowIso();
   const routines = readFile(projectPath);
@@ -87,6 +87,8 @@ export function upsertRoutine(projectPath, { name, kind, schedule, spec, enabled
     kind,
     schedule,
     spec: spec || {},
+    permission_mode: permission_mode || prev?.permission_mode || null,
+    allowed_tools: Array.isArray(allowed_tools) ? allowed_tools : (prev?.allowed_tools || []),
     enabled: enabled !== false,
     last_run_at: prev?.last_run_at ?? null,
     last_status: prev?.last_status ?? null,

package/src/daemon/api.js

@@ -348,13 +348,13 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
   app.post("/projects/:pid/messages", (req, res) => {
     const p = project(req, res);
     if (!p) return;
-    const { channel, direction, agent_slug, body, meta = {}, author = null } =
+    const { channel, direction, type, actor_id, agent_slug, body, meta = {}, author = null } =
       req.body || {};
     if (!channel || !direction || !body)
       return res.status(400).json({ error: "channel, direction, body required" });
     if (!["in", "out"].includes(direction))
       return res.status(400).json({ error: "direction must be in|out" });
-    const r = p.logMessage({ agent_slug: agent_slug || null, channel, direction, author, body, meta });
+    const r = p.logMessage({ agent_slug: agent_slug || null, channel, direction, type, actor_id, author, body, meta });
     res.status(201).json({ ok: true, ts: r.ts });
   });
 
@@ -843,7 +843,7 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
     const r = getRoutine(p.path, req.params.name);
     if (!r) return res.status(404).json({ error: "routine not found" });
     try {
-      const result = await runRoutineNow({ project: p, plugins, globalConfig: config }, r);
+      const result = await runRoutineNow({ project: p, projects, plugins, registries, globalConfig: config }, r);
       res.json(result);
     } catch (e) {
       res.status(500).json({ error: e.message });

package/src/daemon/index.js

@@ -44,6 +44,32 @@ function writePid() {
   } catch {}
 }
 
+function pidIsAlive(pid) {
+  if (!pid || pid === process.pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function claimSingleton() {
+  try {
+    if (fs.existsSync(PID_PATH)) {
+      const pid = parseInt(fs.readFileSync(PID_PATH, "utf8"), 10);
+      if (pidIsAlive(pid)) {
+        log(`fatal: apx-daemon already running with pid ${pid}`);
+        process.exit(1);
+      }
+      fs.unlinkSync(PID_PATH);
+    }
+  } catch (e) {
+    log(`fatal: cannot claim daemon pid file: ${e.message}`);
+    process.exit(1);
+  }
+}
+
 function clearPid() {
   try {
     if (fs.existsSync(PID_PATH)) fs.unlinkSync(PID_PATH);
@@ -71,6 +97,7 @@ class RegistryCache {
 
 async function main() {
   ensureHome();
+  claimSingleton();
 
   const cfg = readConfig();
   const host = effectiveHost(cfg);
@@ -95,15 +122,14 @@ async function main() {
 
   const plugins = new PluginManager({ projects, config: cfg, log, registries });
   plugins.initAll();
-  plugins.startAll();
 
   const scheduler = new RoutineScheduler({
     projects,
     plugins,
+    registries,
     globalConfig: cfg,
     log,
   });
-  scheduler.start();
 
   const startedAt = Date.now();
   const app = buildApi({
@@ -130,10 +156,20 @@ async function main() {
     writePid();
     log(`apx-daemon ${PKG.version} listening on http://${host}:${port}`);
     log(`projects: ${projects.list().length} | plugins: ${Object.keys(plugins.status()).join(", ") || "(none)"}`);
+    plugins.startAll();
+    scheduler.start();
     // Fire wake-up message after a short delay so plugins (Telegram) are ready
     setTimeout(() => triggerWakeup(cfg, log), 3000);
   });
 
+  server.on("error", (e) => {
+    log(`fatal: listen ${host}:${port} failed: ${e.message}`);
+    plugins.stopAll();
+    registries.shutdown();
+    clearPid();
+    process.exit(1);
+  });
+
   function shutdown(signal) {
     log(`received ${signal}, shutting down...`);
     scheduler.stop();

package/src/daemon/plugins/telegram.js

@@ -252,7 +252,7 @@ class ChannelPoller {
     if (chat_id && !isReset) {
       previousMessages = getRecentTelegramTurnsFromFs({
         chat_id,
-        limit: 12,
+        limit: 20,
         max_age_hours: 24,
       });
       // Honour a /reset marker: drop everything up to and including it.
@@ -276,11 +276,14 @@ class ChannelPoller {
     appendGlobalMessage({
       channel: "telegram",
       direction: "in",
+      type: "user",
+      actor_id: msg.from?.id ? String(msg.from.id) : author,
       external_id: String(u.update_id),
       author,
       body: text,
       meta: {
         chat_id,
+        user_id: msg.from?.id || null,
         message_id: msg.message_id,
         tg_channel: this.channel.name,
       },
@@ -299,6 +302,8 @@ class ChannelPoller {
         appendGlobalMessage({
           channel: "telegram",
           direction: "out",
+          type: "agent",
+          actor_id: "apx",
           author: "apx",
           body: ack,
           meta: { chat_id, tg_channel: this.channel.name, in_reply_to: u.update_id, reset: true },
@@ -355,7 +360,7 @@ class ChannelPoller {
           registries: this.registries,
           prompt: text,
           previousMessages,
-          contextNote: `Inbound came on Telegram channel "${this.channel.name}" from ${author}. Previous turns of this chat are included for context.`,
+          contextNote: `You are replying inside Telegram right now. Telegram channel="${this.channel.name}", author=${author}, chat_id=${chat_id}. Keep the reply plain-text and concise. Previous turns of this chat are included only for local conversational context; re-call tools for facts.`,
         });
         replyText = sa.text;
         replyAuthor = sa.name;
@@ -401,12 +406,34 @@ class ChannelPoller {
       appendGlobalMessage({
         channel: "telegram",
         direction: "out",
+        type: "agent",
+        actor_id: replyAuthor || "apx",
+        agent_slug: replyAuthor || "apx",
         author: replyAuthor || "apx",
         body: clean || replyText,
         meta,
       });
     } catch (e) {
       this.log(`telegram[${this.channel.name}] send-back error: ${e.message}`);
+      appendGlobalMessage({
+        channel: "telegram",
+        direction: "out",
+        type: "agent",
+        actor_id: replyAuthor || "apx",
+        agent_slug: replyAuthor || "apx",
+        author: replyAuthor || "apx",
+        body: `[send_failed] ${clean || replyText}`,
+        meta: {
+          chat_id,
+          tg_channel: this.channel.name,
+          in_reply_to: u.update_id,
+          send_error: e.message,
+          ...(saTrace && saTrace.length > 0
+            ? { tools_called: saTrace.map((t) => ({ tool: t.tool, args: t.args })) }
+            : {}),
+          ...(saUsage ? { usage: saUsage } : {}),
+        },
+      });
     }
   }
 
@@ -533,6 +560,9 @@ export default {
         appendGlobalMessage({
           channel: "telegram",
           direction: "out",
+          type: "agent",
+          actor_id: author,
+          agent_slug: author,
           author,
           body: text,
           meta: {

package/src/daemon/routines.js

@@ -6,6 +6,7 @@
 // Kinds:
 //   heartbeat   — log a heartbeat message.   spec: { channel?, message? }
 //   exec_agent  — call an agent engine.       spec: { agent: slug, prompt }
+//   super_agent — call the APX super-agent.   spec: { prompt }
 //   telegram    — send a Telegram message.    spec: { channel?, chat_id?, text }
 //   shell       — run a shell command.        spec: { command, timeout_ms? }
 
@@ -13,6 +14,7 @@ import { spawn } from "node:child_process";
 import path from "node:path";
 import fs from "node:fs";
 import { callEngine } from "./engines/index.js";
+import { runSuperAgent } from "./super-agent.js";
 import { readAgents } from "../core/parser.js";
 import {
   listRoutines,
@@ -48,6 +50,8 @@ async function handleHeartbeat(ctx, routine) {
   project.logMessage({
     channel,
     direction: "out",
+    type: "system",
+    actor_id: "apx:routine",
     author: "apx",
     body: message,
     meta: { routine: routine.name },
@@ -85,6 +89,8 @@ async function handleExecAgent(ctx, routine) {
     agent_slug: slug,
     channel: "routine",
     direction: "out",
+    type: "agent",
+    actor_id: slug,
     author: slug,
     body: result.text,
     meta: { routine: routine.name, usage: result.usage },
@@ -92,6 +98,39 @@ async function handleExecAgent(ctx, routine) {
   return { status: "ok", reply: result.text };
 }
 
+async function handleSuperAgent(ctx, routine) {
+  const { project, globalConfig, projects, plugins, registries } = ctx;
+  const { prompt } = routine.spec;
+  if (!prompt) throw new Error("super_agent: spec needs { prompt }");
+
+  const cfg = structuredClone(globalConfig || {});
+  cfg.super_agent = {
+    ...(globalConfig?.super_agent || {}),
+    ...(routine.permission_mode ? { permission_mode: routine.permission_mode } : {}),
+    ...(Array.isArray(routine.allowed_tools) ? { allowed_tools: routine.allowed_tools } : {}),
+  };
+
+  const result = await runSuperAgent({
+    globalConfig: cfg,
+    projects,
+    plugins,
+    registries,
+    prompt,
+    contextNote: `You were invoked by APX routine "${routine.name}" in project ${project.path}. This is an autonomous scheduled run, not an interactive Telegram reply.`,
+  });
+
+  project.logMessage({
+    channel: "routine",
+    direction: "out",
+    type: "agent",
+    actor_id: result.name || "super_agent",
+    author: result.name || "super_agent",
+    body: result.text || "",
+    meta: { routine: routine.name, tool_trace: result.trace, usage: result.usage },
+  });
+  return { status: "ok", reply: result.text, trace: result.trace };
+}
+
 async function handleTelegram(ctx, routine) {
   const { plugins } = ctx;
   const tg = plugins?.get("telegram");
@@ -130,6 +169,7 @@ function handleShell(ctx, routine) {
 const HANDLERS = {
   heartbeat: handleHeartbeat,
   exec_agent: handleExecAgent,
+  super_agent: handleSuperAgent,
   telegram: handleTelegram,
   shell: handleShell,
 };
@@ -144,6 +184,10 @@ export async function runRoutineNow(ctx, routine) {
   let errMsg = null;
   try {
     result = await handler(ctx, routine);
+    if (result?.status === "error") {
+      status = "error";
+      errMsg = result.error || result.stderr || `routine ${routine.name} returned error status`;
+    }
   } catch (e) {
     status = "error";
     errMsg = e.message;
@@ -159,13 +203,25 @@ export async function runRoutineNow(ctx, routine) {
     next_run_at: next,
     disable: isOnce,
   });
+  ctx.project.logMessage?.({
+    channel: "routine",
+    direction: "out",
+    type: "system",
+    actor_id: "apx:routine",
+    author: "apx",
+    body: status === "ok"
+      ? `routine ${routine.name} ok`
+      : `routine ${routine.name} error: ${errMsg}`,
+    meta: { routine: routine.name, status, result },
+  });
   return { ...result, last_run_at: lastRun, next_run_at: next };
 }
 
 export class RoutineScheduler {
-  constructor({ projects, plugins, globalConfig, log }) {
+  constructor({ projects, plugins, registries, globalConfig, log }) {
     this.projects = projects;
     this.plugins = plugins;
+    this.registries = registries;
     this.globalConfig = globalConfig;
     this.log = log || (() => {});
     this._timer = null;
@@ -199,7 +255,13 @@ export class RoutineScheduler {
         for (const r of due) {
           this.log(`routine ${r.name} (${r.kind}) firing in project #${proj.id}`);
           await runRoutineNow(
-            { project: proj, plugins: this.plugins, globalConfig: this.globalConfig },
+            {
+              project: proj,
+              projects: this.projects,
+              plugins: this.plugins,
+              registries: this.registries,
+              globalConfig: this.globalConfig,
+            },
             r
           );
         }