@agentprojectcontext/apx 1.80.0 → 1.80.2

package/package.json

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

package/src/core/agent/tools/handlers/remember-routine.js

@@ -0,0 +1,79 @@
+import { appendRoutineMemory } from "#core/stores/routine-memory.js";
+
+/**
+ * A routine writing to its OWN memory.
+ *
+ * WHY THIS TOOL EXISTS. Routine memory is a file, and until now the only way to
+ * write it was `write_file` — which is gated as dangerous, correctly, because it
+ * can write anywhere. In a routine there is nobody to confirm anything, so
+ * `requirePermission` threw "Action requires user confirmation", the model
+ * treated it as a dead end, and the evening anchor ended without sending
+ * anything. The run still reported `ok`, so the only symptom was silence.
+ *
+ * An agent recording what it learned is not a dangerous act. It is the most
+ * ordinary thing it does, and it must not need a human standing by.
+ *
+ * WHY IT IS SAFE UNGATED: there is no path argument. The destination comes from
+ * the running routine's own context (channelMeta.routineId + the project's
+ * storage), so this tool cannot write anywhere else however it is called. That
+ * is the whole difference between this and write_file, and it is the reason the
+ * permission is unnecessary rather than merely inconvenient.
+ */
+export default {
+  name: "remember_routine",
+  schema: {
+    type: "function",
+    function: {
+      name: "remember_routine",
+      description:
+        "Save a durable note to THIS routine's own memory — what you learned about how the " +
+        "owner works, what turned out to be worth mentioning, what turned out to be noise. " +
+        "Only available while a routine is running. Use this instead of write_file: it is the " +
+        "routine's own notebook and needs no permission. For facts about the owner that matter " +
+        "on every channel, use `remember` instead.",
+      parameters: {
+        type: "object",
+        required: ["note"],
+        properties: {
+          note: {
+            type: "string",
+            description: "One line. A judgement that will change what you do next time, not a log of what happened.",
+          },
+        },
+      },
+    },
+  },
+  makeHandler: ({ channel, channelMeta, projects }) => async ({ note } = {}) => {
+    const text = String(note || "").trim();
+    if (!text) return { error: "note required" };
+
+    const routineId = channelMeta?.routineId;
+    const routineName = channelMeta?.routineName || "";
+    if (!routineId) {
+      // Said plainly so the model reaches for `remember` instead of retrying.
+      return {
+        error:
+          "remember_routine only works inside a running routine. " +
+          "Use `remember` for a durable fact about the owner.",
+        channel: channel || null,
+      };
+    }
+
+    // The routine's project storage, never a model-supplied path.
+    const projectPath = channelMeta?.projectPath || "";
+    let storagePath = "";
+    for (const entry of projects?.list?.() || []) {
+      if (projectPath && entry.path !== projectPath) continue;
+      storagePath = projects.get(entry.id)?.storagePath || "";
+      if (storagePath) break;
+    }
+    if (!storagePath) return { error: "could not resolve this routine's storage" };
+
+    try {
+      const r = appendRoutineMemory(storagePath, routineId, text, { routineName });
+      return { saved: true, routine: routineName || routineId, note: text, path: r?.path };
+    } catch (e) {
+      return { error: e.message };
+    }
+  },
+};

package/src/core/agent/tools/names.js

@@ -42,6 +42,7 @@ export const TOOLS = Object.freeze({
   LIST_TASKS:          "list_tasks",
   CREATE_TASK:         "create_task",
   RECORD_COMMITMENT:   "record_commitment",
+  REMEMBER_ROUTINE:    "remember_routine",
   LIST_COMMITMENTS:    "list_commitments",
 
   // Interaction
@@ -139,6 +140,7 @@ export const NATIVE_TOOL_NAMES = new Set([
   TOOLS.CREATE_TASK,
   TOOLS.RECORD_COMMITMENT,
   TOOLS.LIST_COMMITMENTS,
+  TOOLS.REMEMBER_ROUTINE,
   TOOLS.ASK_QUESTIONS,
   TOOLS.SEARCH_SESSIONS,
   TOOLS.TRANSCRIBE_AUDIO,
@@ -228,6 +230,7 @@ export const SIDE_EFFECT_TOOLS = new Set([
   TOOLS.SEND_TELEGRAM,
   TOOLS.CREATE_TASK,
   TOOLS.RECORD_COMMITMENT,
+  TOOLS.REMEMBER_ROUTINE,
   TOOLS.WRITE_FILE,
   TOOLS.EDIT_FILE,
   TOOLS.RUN_SHELL,

package/src/core/agent/tools/registry.js

@@ -30,6 +30,7 @@ import askQuestions from "./handlers/ask-questions.js";
 import createTask from "./handlers/create-task.js";
 import recordCommitment from "./handlers/record-commitment.js";
 import listCommitments from "./handlers/list-commitments.js";
+import rememberRoutine from "./handlers/remember-routine.js";
 import listTasks from "./handlers/list-tasks.js";
 import discoverTools from "./handlers/discover-tools.js";
 import gitStatus from "./handlers/git-status.js";
@@ -85,6 +86,7 @@ const NATIVE_TOOLS = [
   listTasks,
   recordCommitment,
   listCommitments,
+  rememberRoutine,
   discoverTools,
   gitStatus,
   gitDiff,
@@ -143,6 +145,10 @@ export const BASE_TOOL_NAMES = new Set([
   TOOLS.READ_AGENT_MEMORY,
   TOOLS.READ_SELF_MEMORY,
   TOOLS.REMEMBER,
+  // NOT here: remember_routine. It only works inside a routine, and the routine
+  // channel is in FULL_CHANNELS — it already receives the whole registry. Adding
+  // it to the base set would spend tokens on every Telegram and desktop turn for
+  // a tool that returns an error on those channels.
   TOOLS.SET_IDENTITY,
   // Sessions + messages (self-recall + channel history).
   TOOLS.SEARCH_SESSIONS,

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

@@ -5,7 +5,7 @@
   "permission_mode": "permiso",
   "enabled_by_default": true,
   "spec": {
-    "prompt": "Close the day. Review what moved today, what is still stuck, and what carries over to tomorrow, across every registered project. Call list_tasks and list_commitments ONCE each, with no project argument — both search every project in a single call. Do not loop over projects. If a commitment came due today, ask whether it was kept — do not mark it yourself.\n\nSend ONE short message covering those, keeping promises to people separate from ordinary tasks. Note anything that has gone quiet longer than the staleness threshold. If the day was quiet, say that plainly in a line or two.\n\nThen record in your routine memory anything durable you learned about how this person works.\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": "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.",
     "anchor": true
   },
   "allowed_tools": [

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

@@ -5,7 +5,7 @@
   "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. Call list_tasks and list_commitments ONCE each, with no project argument — both search every project in a single call. Do not loop over projects. 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\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.",
     "anchor": true
   },
   "allowed_tools": [

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

@@ -5,7 +5,7 @@
   "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."
+    "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."
   },
   "allowed_tools": [
     "send_telegram"

package/src/core/routines/runner.js

@@ -145,6 +145,12 @@ async function handleSuperAgent(ctx, routine, extraChannelMeta = {}) {
     suppressTools: suppressTools.length > 0 ? suppressTools : null,
   });
 
+  // A tool that needed a human in a run with no human is a DEAD END, not a
+  // hiccup: nobody is ever going to confirm it. Reporting the run as "ok"
+  // meant the only symptom was silence — the evening anchor produced nothing
+  // and it took twenty-one shell commands to work out why. Name it.
+  const blocked = blockedForPermission(result.trace);
+
   project.logMessage({
     channel: CHANNELS.ROUTINE,
     direction: "out",
@@ -161,9 +167,37 @@ async function handleSuperAgent(ctx, routine, extraChannelMeta = {}) {
       usage: result.usage,
     },
   });
+  if (blocked.length) {
+    return {
+      status: "error",
+      error:
+        `blocked waiting for a confirmation nobody can give: ${blocked.join(", ")}. ` +
+        `A scheduled run has no one to approve a dangerous tool — either allow it on ` +
+        `this routine (allowed_tools) or use a tool that does not need approval.`,
+      blocked_tools: blocked,
+      reply: result.text,
+      trace: result.trace,
+    };
+  }
   return { status: "ok", reply: result.text, trace: result.trace };
 }
 
+/**
+ * Tools whose result was "Action requires user confirmation" — the message
+ * createPermissionGuard throws when there is no confirmation channel wired
+ * (tools/helpers.js). Distinct from a tool that merely failed.
+ */
+export function blockedForPermission(trace) {
+  const names = new Set();
+  for (const item of Array.isArray(trace) ? trace : []) {
+    const err = item?.result?.error;
+    if (typeof err === "string" && /requires user confirmation/i.test(err)) {
+      names.add(item.tool || "unknown");
+    }
+  }
+  return [...names];
+}
+
 async function handleTelegram(ctx, routine) {
   const { plugins } = ctx;
   const tg = plugins?.get("telegram");