@agentprojectcontext/apx 1.78.0 → 1.79.0

package/src/interfaces/cli/commands/commitment.js

@@ -0,0 +1,154 @@
+// apx commitment — what you promised, to whom, by when.
+//
+//   apx commitment add "<what>" --to "<person>" [--due 2026-05-30] [--project X]
+//                              [--channel telegram] [--ref <message id>]
+//   apx commitment list        [--all | --project X] [--to X] [--state open|kept|missed|all]
+//                              [--overdue] [--due-before ISO] [--limit N]
+//   apx commitment show <id>   [--project X]
+//   apx commitment kept <id>   [--project X] [--note "..."]
+//   apx commitment missed <id> [--project X] [--note "..."]
+//   apx commitment renegotiate <id> --due <ISO> [--project X] [--note "..."]
+//
+// A task is something to do; a commitment is something you promised a person.
+// Kept separate on purpose — see core/stores/commitments.js.
+import { http } from "../http.js";
+import { resolveProjectId } from "./project.js";
+
+export const COMMITMENT_USAGE = {
+  add:         'apx commitment add "<what>" --to "<person>" [--due ISO] [--project X] [--channel C] [--ref R]',
+  list:        "apx commitment list [--all | --project X] [--to X] [--state open|kept|missed|all] [--overdue] [--due-before ISO] [--limit N]",
+  show:        "apx commitment show <id> [--project X]",
+  kept:        'apx commitment kept <id> [--project X] [--note "..."]',
+  missed:      'apx commitment missed <id> [--project X] [--note "..."]',
+  renegotiate: 'apx commitment renegotiate <id> --due <ISO> [--project X] [--note "..."]',
+};
+
+function fail(sub, msg) {
+  console.error(`apx commitment ${sub}: ${msg}`);
+  console.error(`Usage: ${COMMITMENT_USAGE[sub]}`);
+  process.exit(1);
+}
+
+function shortDate(iso) {
+  if (!iso) return "";
+  return String(iso).replace(/T/, " ").replace(/Z$/, "").slice(0, 16);
+}
+
+/** Is this promise past its date and still open? */
+function isOverdue(c) {
+  return c.state === "open" && c.due && c.due < new Date().toISOString();
+}
+
+function renderTable(rows, { showProject = false } = {}) {
+  if (!rows.length) {
+    console.log("(no commitments)");
+    return;
+  }
+  const idW = Math.max(...rows.map((r) => String(r.id).length), 2);
+  const whoW = Math.min(Math.max(...rows.map((r) => String(r.counterparty || "").length), 3), 20);
+  const projW = showProject
+    ? Math.min(Math.max(...rows.map((r) => String(r.project_name || "").length), 7), 18)
+    : 0;
+
+  for (const c of rows) {
+    const proj = showProject
+      ? String(c.project_name || "").slice(0, projW).padEnd(projW) + "  "
+      : "";
+    // The flag carries the whole point of the type: a broken promise should be
+    // impossible to skim past.
+    const flag =
+      c.state === "kept" ? "✓" :
+      c.state === "missed" ? "✗" :
+      isOverdue(c) ? "!" : " ";
+    const moved = c.renegotiated_count ? ` (moved ×${c.renegotiated_count})` : "";
+    console.log(
+      `${flag} ${String(c.id).padEnd(idW)}  ${proj}` +
+      `${String(c.counterparty || "").slice(0, whoW).padEnd(whoW)}  ` +
+      `${(c.due ? shortDate(c.due).slice(0, 10) : "—").padEnd(10)}  ` +
+      `${String(c.body || "").slice(0, 48)}${moved}`
+    );
+  }
+  const overdue = rows.filter(isOverdue).length;
+  if (overdue) console.log(`\n${overdue} past their date.`);
+}
+
+export async function cmdCommitmentAdd(args) {
+  const body = args?._?.[0];
+  const to = args?.flags?.to;
+  if (!body) fail("add", "what you promised is required");
+  if (!to) fail("add", "--to <person> is required — without a counterparty this is a task");
+
+  const pid = await resolveProjectId(args?.flags?.project);
+  const created = await http.post(`/api/projects/${pid}/commitments`, {
+    counterparty: to,
+    body,
+    due: args?.flags?.due || null,
+    origin_channel: args?.flags?.channel || "cli",
+    origin_message_ref: args?.flags?.ref || null,
+  });
+  console.log(`${created.id}  → ${created.counterparty}${created.due ? ` by ${shortDate(created.due).slice(0, 10)}` : ""}`);
+  console.log(`  ${created.body}`);
+}
+
+export async function cmdCommitmentList(args) {
+  const f = args?.flags || {};
+  const q = new URLSearchParams();
+  if (f.state) q.set("state", f.state);
+  if (f.to) q.set("counterparty", f.to);
+  if (f.overdue) q.set("overdue", "1");
+  if (f["due-before"]) q.set("due_before", f["due-before"]);
+  if (f.limit) q.set("limit", f.limit);
+
+  if (f.all) {
+    const { data } = await http.get(`/api/commitments?${q.toString()}`);
+    renderTable(data || [], { showProject: true });
+    return;
+  }
+  const pid = await resolveProjectId(args?.flags?.project);
+  const { data } = await http.get(`/api/projects/${pid}/commitments?${q.toString()}`);
+  renderTable(data || []);
+}
+
+export async function cmdCommitmentShow(args) {
+  const id = args?._?.[0];
+  if (!id) fail("show", "id required");
+  const pid = await resolveProjectId(args?.flags?.project);
+  const c = await http.get(`/api/projects/${pid}/commitments/${encodeURIComponent(id)}`);
+  console.log(`${c.id}  [${c.state}${isOverdue(c) ? " · OVERDUE" : ""}]`);
+  console.log(`  To:        ${c.counterparty}`);
+  console.log(`  What:      ${c.body}`);
+  console.log(`  Promised:  ${shortDate(c.promised_at)}${c.origin_channel ? ` on ${c.origin_channel}` : ""}`);
+  console.log(`  Due:       ${c.due ? shortDate(c.due) : "(no date)"}`);
+  if (c.note) console.log(`  Note:      ${c.note}`);
+  // The history is the relationship record — print it, it is the reason the
+  // renegotiate event exists at all.
+  for (const h of c.history || []) {
+    console.log(`  Moved:     ${shortDate(h.due)?.slice(0, 10) || "?"} → (on ${shortDate(h.moved_at)})${h.note ? ` — ${h.note}` : ""}`);
+  }
+}
+
+async function close(args, sub) {
+  const id = args?._?.[0];
+  if (!id) fail(sub, "id required");
+  const pid = await resolveProjectId(args?.flags?.project);
+  const c = await http.post(`/api/projects/${pid}/commitments/${encodeURIComponent(id)}/${sub}`, {
+    note: args?.flags?.note || null,
+  });
+  console.log(`${c.id} → ${c.state}`);
+}
+
+export const cmdCommitmentKept = (args) => close(args, "kept");
+export const cmdCommitmentMissed = (args) => close(args, "missed");
+
+export async function cmdCommitmentRenegotiate(args) {
+  const id = args?._?.[0];
+  const due = args?.flags?.due;
+  if (!id) fail("renegotiate", "id required");
+  if (!due) fail("renegotiate", "--due <ISO> is required — a promise with no new date is a promise that vanished");
+  const pid = await resolveProjectId(args?.flags?.project);
+  const c = await http.post(`/api/projects/${pid}/commitments/${encodeURIComponent(id)}/renegotiate`, {
+    due,
+    note: args?.flags?.note || null,
+  });
+  console.log(`${c.id} → new date ${shortDate(c.due).slice(0, 10)} (moved ×${c.renegotiated_count})`);
+}

package/src/interfaces/cli/commands/daemon.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import { PID_PATH, LOG_PATH } from "#core/config/paths.js";
 import { ensureDaemon, http } from "../http.js";
+import { installService, uninstallService, serviceStatus } from "#core/daemon/service.js";
 
 // Wait until nothing answers on the daemon port (old process fully exited and
 // released it), so a fresh start can bind it. Resolves true when down.
@@ -244,3 +245,59 @@ export async function cmdDaemonLogs(args) {
     return new Promise(() => {});
   }
 }
+
+// ── Service (opt-in supervision) ─────────────────────────────────────────────
+
+export async function cmdDaemonInstallService() {
+  const before = serviceStatus();
+  if (!before.supervised && before.platform !== "win32") {
+    console.error(`apx daemon install-service: ${before.note || "not supported here"}`);
+    process.exit(1);
+  }
+
+  const r = installService();
+  if (!r.ok) {
+    console.error(`apx daemon install-service: ${r.error}`);
+    process.exit(1);
+  }
+
+  console.log(`\n  ${fmt.green("●")} ${fmt.bold("apx daemon")} is now a service`);
+  console.log(`  ${fmt.gray("·")}  ${fmt.cyan("unit")}  ${r.path}`);
+  if (r.log) console.log(`  ${fmt.gray("·")}  ${fmt.cyan("log")}   ${r.log}`);
+  console.log("");
+  if (r.supervised) {
+    console.log("  If it dies, it comes back. It survives a reboot.");
+  } else {
+    // Never let the headline promise more than the platform delivers.
+    console.log(`  ${fmt.yellow("Note")}: ${r.note}`);
+  }
+  if (r.note && r.supervised) console.log(`  ${fmt.yellow("Note")}: ${r.note}`);
+  console.log(`\n  Undo any time: ${fmt.cyan("apx daemon uninstall-service")}\n`);
+}
+
+export async function cmdDaemonUninstallService() {
+  const r = uninstallService();
+  if (!r.ok) {
+    console.error(`apx daemon uninstall-service: ${r.error}`);
+    process.exit(1);
+  }
+  console.log(r.removed
+    ? `\n  service removed — ${r.path}\n  The daemon keeps working; it just is not supervised any more.\n`
+    : "\n  no service was installed — nothing to remove\n");
+}
+
+export async function cmdDaemonServiceStatus() {
+  const s = serviceStatus();
+  if (!s.installed) {
+    console.log(`\n  daemon service: ${fmt.dim("not installed")}`);
+    console.log("  The daemon starts when a command needs it, and nothing restarts it if it dies.");
+    console.log(`  Install: ${fmt.cyan("apx daemon install-service")}\n`);
+    if (s.note) console.log(`  ${fmt.yellow("Note")}: ${s.note}\n`);
+    return;
+  }
+  console.log(`\n  daemon service: ${fmt.green("installed")}  ${fmt.gray("·")}  ${s.path}`);
+  console.log(s.supervised
+    ? "  Supervised: it restarts on its own and survives a reboot."
+    : `  ${fmt.yellow("Not supervised")}: ${s.note}`);
+  console.log("");
+}

package/src/interfaces/cli/commands/memory.js

@@ -2,6 +2,10 @@ import fs from "node:fs";
 import { findApfRoot } from "#core/apc/parser.js";
 import { agentMemoryPath, readAgentMemory, writeAgentMemory, ensureAgentRuntimeDir } from "#core/agent/memory.js";
 import { http } from "../http.js";
+import {
+  proposeConsolidation, applyConsolidation, revertConsolidation, notebookSize,
+} from "#core/memory/consolidate.js";
+import { readSelfMemory } from "#core/agent/self-memory.js";
 
 function requireRoot() {
   const root = findApfRoot();
@@ -66,3 +70,72 @@ function readStdinSync() {
   } catch {}
   return chunks.join("");
 }
+
+
+// ── The super-agent's own notebook (~/.apx/memory.md) ────────────────────────
+//
+// Distinct from `apx memory <agent-slug>` above, which is a PROJECT agent's
+// memory. This one ships in every super-agent prompt on every channel, which
+// is why its size is worth showing and its growth worth controlling.
+
+export async function cmdMemoryNotebook() {
+  const s = notebookSize();
+  console.log(`\nnotebook: ${s.entries} entries · ${s.chars} chars · ~${s.approx_tokens} tokens`);
+  // The number that matters: this is paid on every turn, of every channel.
+  console.log(`  ${s.consolidated} of them written by consolidation.`);
+  console.log("  This file is injected into every super-agent prompt.\n");
+  const body = readSelfMemory();
+  if (body.trim()) process.stdout.write(body.endsWith("\n") ? body : body + "\n");
+}
+
+/**
+ * apx memory consolidate [--apply] [--limit N]
+ *
+ * Candidates arrive on STDIN, one per line. The DISTILLING is the caller's job
+ * — a routine with a model behind it, or a person — and the JUDGEMENT about
+ * what survives lives in core, so the same rules apply whoever proposes.
+ *
+ * Proposes by default. Writing needs --apply, because a background job that
+ * silently edits the file the agent believes about itself is not something to
+ * switch on quietly.
+ */
+export async function cmdMemoryConsolidate(args) {
+  const raw = readStdinSync();
+  const candidates = raw.split("\n").map((l) => l.replace(/^[-*]\s*/, "").trim()).filter(Boolean);
+  if (!candidates.length) {
+    console.error("apx memory consolidate: no candidates on stdin (one fact per line)");
+    process.exit(1);
+  }
+
+  const limits = args?.flags?.limit ? { max_candidates: Number(args.flags.limit) } : undefined;
+  const { kept, rejected } = proposeConsolidation(candidates, limits ? { limits } : {});
+
+  if (!kept.length) {
+    console.log("nothing worth saving.");
+    for (const r of rejected) console.log(`  skipped: ${r.reason} — ${r.text.slice(0, 60)}`);
+    return;
+  }
+
+  if (!args?.flags?.apply) {
+    console.log(`would save ${kept.length}:`);
+    for (const k of kept) console.log(`  + ${k}`);
+    if (rejected.length) {
+      console.log(`\nskipped ${rejected.length}:`);
+      for (const r of rejected) console.log(`  - ${r.reason} — ${r.text.slice(0, 60)}`);
+    }
+    console.log("\nNothing was written. Add --apply to save.");
+    return;
+  }
+
+  const { written } = applyConsolidation(kept);
+  console.log(`saved ${written.length} to the notebook:`);
+  for (const w of written) console.log(`  + ${w}`);
+  console.log("\nUndo: apx memory revert");
+}
+
+export async function cmdMemoryRevert(args) {
+  const { removed } = revertConsolidation(args?.flags?.since ? { since: String(args.flags.since) } : {});
+  console.log(removed
+    ? `removed ${removed} consolidated ${removed === 1 ? "entry" : "entries"} — hand-written notes untouched`
+    : "nothing to revert (no consolidated entries)");
+}

package/src/interfaces/cli/commands/nudge.js

@@ -0,0 +1,130 @@
+// apx nudge — the interruption budget: what APX said without being asked,
+// what you thought of it, and how much room is left.
+//
+//   apx nudge status
+//   apx nudge list    [--limit N] [--kind K] [--project P] [--rated | --unrated]
+//   apx nudge set     [--enabled true|false] [--daily-max N] [--quiet 22:00-07:30]
+//                     [--cooldown N] [--project-cooldown N] [--kind-cooldown N]
+//   apx nudge check   --kind K [--severity critical]
+//   apx nudge feedback <id> --useful | --noise [--note "..."]
+import { http } from "../http.js";
+
+export const NUDGE_USAGE = {
+  status:   "apx nudge status",
+  list:     "apx nudge list [--limit N] [--kind K] [--project P] [--rated|--unrated]",
+  set:      "apx nudge set [--enabled true|false] [--daily-max N] [--quiet HH:MM-HH:MM] [--cooldown N] [--project-cooldown N] [--kind-cooldown N]",
+  check:    "apx nudge check --kind K [--severity low|normal|high|critical]",
+  feedback: 'apx nudge feedback <id> --useful|--noise [--note "..."]',
+};
+
+function fail(sub, msg) {
+  console.error(`apx nudge ${sub}: ${msg}`);
+  console.error(`Usage: ${NUDGE_USAGE[sub]}`);
+  process.exit(1);
+}
+
+function shortTs(iso) {
+  if (!iso) return "";
+  return String(iso).replace(/T/, " ").replace(/Z$/, "").slice(0, 16);
+}
+
+export async function cmdNudgeStatus() {
+  const { policy, source, user_overrides } = await http.get("/api/nudges/policy");
+  const { meta } = await http.get("/api/nudges?limit=1");
+  const stats = meta?.stats || { total: 0, today: 0, rated: 0, by_kind: [] };
+
+  if (!policy.enabled) {
+    console.log("interruption budget: OFF — every unrequested message goes out.");
+    console.log("  Nothing is blocked, but everything is still recorded below.");
+    console.log("  Turn it on: apx nudge set --enabled true --daily-max 3");
+  } else {
+    const left = policy.daily_max > 0 ? Math.max(0, policy.daily_max - stats.today) : "∞";
+    console.log(`interruption budget: ON — ${stats.today} sent today, ${left} left`);
+    if (policy.daily_max > 0) console.log(`  Daily max:      ${policy.daily_max}`);
+    if (policy.quiet_hours)   console.log(`  Quiet hours:    ${policy.quiet_hours}`);
+    if (policy.cooldown_minutes) console.log(`  Cooldown:       ${policy.cooldown_minutes}m between any two`);
+    if (policy.project_cooldown_minutes) console.log(`  Per project:    ${policy.project_cooldown_minutes}m`);
+    if (policy.kind_cooldown_minutes)    console.log(`  Per kind:       ${policy.kind_cooldown_minutes}m`);
+    console.log(`  Critical:       ${policy.critical_bypasses_budget ? "may bypass (logged)" : "no bypass"}`);
+  }
+  // Provenance matters: a number the user did not choose should say who did.
+  console.log(`  Set by:         ${source.join(" → ")}`);
+  if (Object.keys(user_overrides || {}).length) {
+    console.log(`  Your overrides: ${Object.entries(user_overrides).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+  }
+
+  console.log("");
+  console.log(`recorded: ${stats.total} total, ${stats.rated} rated`);
+  for (const k of stats.by_kind.slice(0, 8)) {
+    const verdict = k.useful || k.noise ? `  (👍 ${k.useful} / 👎 ${k.noise})` : "";
+    console.log(`  ${k.kind.padEnd(18)} ${String(k.sent).padStart(4)}${verdict}`);
+  }
+}
+
+export async function cmdNudgeList(args) {
+  const q = new URLSearchParams();
+  if (args?.flags?.limit) q.set("limit", args.flags.limit);
+  if (args?.flags?.kind) q.set("kind", args.flags.kind);
+  if (args?.flags?.project) q.set("project_id", args.flags.project);
+  if (args?.flags?.rated) q.set("with_feedback", "1");
+  if (args?.flags?.unrated) q.set("with_feedback", "0");
+
+  const { data } = await http.get(`/api/nudges?${q.toString()}`);
+  if (!data?.length) {
+    console.log("(nothing sent unprompted yet)");
+    return;
+  }
+  const idW = Math.max(...data.map((r) => r.id.length), 2);
+  const kindW = Math.max(...data.map((r) => String(r.kind).length), 4);
+  for (const row of data) {
+    const rating = row.feedback ? (row.feedback.useful ? "👍" : "👎") : "  ";
+    const flag = row.bypassed_budget ? " ⚠︎bypass" : "";
+    console.log(
+      `${row.id.padEnd(idW)}  ${shortTs(row.at)}  ${rating}  ` +
+      `${String(row.kind).padEnd(kindW)}  ${String(row.preview || "").slice(0, 60)}${flag}`
+    );
+  }
+}
+
+export async function cmdNudgeSet(args) {
+  const f = args?.flags || {};
+  const body = {};
+  if (f.enabled !== undefined) body.enabled = String(f.enabled) !== "false";
+  if (f["daily-max"] !== undefined) body.daily_max = Number(f["daily-max"]);
+  if (f.quiet !== undefined) body.quiet_hours = String(f.quiet);
+  if (f.cooldown !== undefined) body.cooldown_minutes = Number(f.cooldown);
+  if (f["project-cooldown"] !== undefined) body.project_cooldown_minutes = Number(f["project-cooldown"]);
+  if (f["kind-cooldown"] !== undefined) body.kind_cooldown_minutes = Number(f["kind-cooldown"]);
+  if (!Object.keys(body).length) fail("set", "nothing to set");
+
+  const { policy, source } = await http.put("/api/nudges/policy", body);
+  console.log(`budget updated (${source.join(" → ")})`);
+  console.log(`  enabled: ${policy.enabled} · daily max: ${policy.daily_max || "∞"} · quiet: ${policy.quiet_hours || "none"}`);
+  console.log("  Applies to the next unrequested message; nothing to restart.");
+}
+
+export async function cmdNudgeCheck(args) {
+  const kind = args?.flags?.kind;
+  if (!kind) fail("check", "--kind required");
+  const r = await http.post("/api/nudges/check", {
+    kind,
+    severity: args?.flags?.severity || "normal",
+    project_id: args?.flags?.project || null,
+  });
+  console.log(r.allowed ? `would send — ${r.reason}` : `would be held — ${r.reason}`);
+  if (!r.allowed && r.retry_after_ms) {
+    console.log(`  Retry in ~${Math.ceil(r.retry_after_ms / 60000)} min.`);
+  }
+}
+
+export async function cmdNudgeFeedback(args) {
+  const id = args?._?.[0];
+  if (!id) fail("feedback", "nudge id required");
+  const f = args?.flags || {};
+  if (!f.useful && !f.noise) fail("feedback", "--useful or --noise required");
+  await http.post(`/api/nudges/${encodeURIComponent(id)}/feedback`, {
+    useful: !!f.useful,
+    note: f.note || "",
+  });
+  console.log(f.useful ? "noted: useful" : "noted: not useful");
+}

package/src/interfaces/cli/help/index.js

@@ -1138,7 +1138,7 @@ export const HELP_TOPICS = new Map(Object.entries({
     summary: "Create a scheduled routine.",
     usage: ["apx routine add <name> --kind <kind> --schedule <schedule> [--spec '<json>'] [--pre-commands 'cmd1,cmd2'] [--post-commands 'cmd'] [--skip-prompt-on signal|pre_failure|pre_success|always|never] [--project <name|id|path>]"],
     options: [
-      ["--kind <kind>", "heartbeat, exec_agent, super_agent, telegram, or shell."],
+      ["--kind <kind>", "heartbeat, exec_agent, super_agent, telegram, shell, or watch."],
       ["--schedule <schedule>", "every:60s, every:5m, every:1h, or once:<iso>."],
       ["--spec '<json>'", "Routine-specific JSON config."],
       ["--pre-commands 'cmd'", "Comma-separated shell commands to run BEFORE the LLM. Use 'artifact:<name>' shorthand."],
@@ -2108,7 +2108,7 @@ export function buildHelp(version) {
     hSec("Routines & Pipeline"),
     hCmd("apx routine list",           36, "list routines + next/last run"),
     hCmd("apx routine add <name>",     36, "--kind K  --schedule S  [--spec '{...}']"),
-    `    ${H.DI}kinds: heartbeat | exec_agent | super_agent | telegram | shell${H.R}`,
+    `    ${H.DI}kinds: heartbeat | exec_agent | super_agent | telegram | shell | watch${H.R}`,
     `    ${H.DI}flags: --permission-mode total|automatico|permiso  --allowed-tools a,b${H.R}`,
     `    ${H.DI}pipeline: --pre-commands 'cmd1,cmd2'  --post-commands 'cmd'${H.R}`,
     `    ${H.DI}         --skip-prompt-on signal|pre_failure|pre_success|always|never${H.R}`,

package/src/interfaces/cli/routes/commitment.js

@@ -0,0 +1,19 @@
+// apx commitment — argument routing.
+import {
+  cmdCommitmentAdd, cmdCommitmentList, cmdCommitmentShow,
+  cmdCommitmentKept, cmdCommitmentMissed, cmdCommitmentRenegotiate,
+} from "../commands/commitment.js";
+
+export const aliases = ["commitments"];
+
+export default async function route(rest, { parseArgs, die }) {
+  const sub = rest[0];
+  const a = parseArgs(rest.slice(1));
+  if (!sub || sub === "list" || sub === "ls") await cmdCommitmentList(a);
+  else if (sub === "add" || sub === "new") await cmdCommitmentAdd(a);
+  else if (sub === "show" || sub === "get") await cmdCommitmentShow(a);
+  else if (sub === "kept" || sub === "done") await cmdCommitmentKept(a);
+  else if (sub === "missed") await cmdCommitmentMissed(a);
+  else if (sub === "renegotiate" || sub === "move") await cmdCommitmentRenegotiate(a);
+  else die(`unknown commitment subcommand: ${sub}\nUsage: apx commitment <list|add|show|kept|missed|renegotiate>`);
+}

package/src/interfaces/cli/routes/daemon.js

@@ -4,7 +4,10 @@
 // owns its own routing and imports only the command functions it calls, so the
 // CLI no longer loads all 38 command modules to run one of them.
 
-import { cmdDaemonLogs, cmdDaemonReload, cmdDaemonRestart, cmdDaemonStart, cmdDaemonStatus, cmdDaemonStop } from "../commands/daemon.js";
+import {
+  cmdDaemonLogs, cmdDaemonReload, cmdDaemonRestart, cmdDaemonStart, cmdDaemonStatus, cmdDaemonStop,
+  cmdDaemonInstallService, cmdDaemonUninstallService, cmdDaemonServiceStatus,
+} from "../commands/daemon.js";
 
 export default async function route(rest, { parseArgs, die }) {
   const sub = rest[0];
@@ -15,5 +18,8 @@ export default async function route(rest, { parseArgs, die }) {
   else if (sub === "reload") await cmdDaemonReload(a);
   else if (sub === "status") await cmdDaemonStatus(a);
   else if (sub === "logs") cmdDaemonLogs(a);
+  else if (sub === "install-service") await cmdDaemonInstallService(a);
+  else if (sub === "uninstall-service") await cmdDaemonUninstallService(a);
+  else if (sub === "service-status") await cmdDaemonServiceStatus(a);
   else die(`unknown daemon subcommand: ${sub || "(none)"}`);
 }

package/src/interfaces/cli/routes/index.js

@@ -44,9 +44,13 @@ export const ROUTES = Object.freeze({
   "artifacts": () => import("./artifact.js"),
   "task": () => import("./task.js"),
   "tasks": () => import("./task.js"),
+  "commitment": () => import("./commitment.js"),
+  "commitments": () => import("./commitment.js"),
   "panel": () => import("./panel.js"),
   "profile": () => import("./profile.js"),
   "profiles": () => import("./profile.js"),
+  "nudge": () => import("./nudge.js"),
+  "nudges": () => import("./nudge.js"),
   "command": () => import("./command.js"),
   "commands": () => import("./command.js"),
   "org": () => import("./org.js"),

package/src/interfaces/cli/routes/memory.js

@@ -4,8 +4,16 @@
 // owns its own routing and imports only the command functions it calls, so the
 // CLI no longer loads all 38 command modules to run one of them.
 
-import { cmdMemory } from "../commands/memory.js";
+import { cmdMemory, cmdMemoryNotebook, cmdMemoryConsolidate, cmdMemoryRevert } from "../commands/memory.js";
 
 export default async function route(rest, { parseArgs }) {
-  cmdMemory(parseArgs(rest));
+  // `apx memory <agent-slug>` is the original form and stays the default, so
+  // these three names are reserved. An agent literally called "notebook" would
+  // be shadowed; that is a trade worth making for a readable command.
+  const sub = rest[0];
+  const a = parseArgs(rest.slice(1));
+  if (sub === "notebook") return cmdMemoryNotebook(a);
+  if (sub === "consolidate") return cmdMemoryConsolidate(a);
+  if (sub === "revert") return cmdMemoryRevert(a);
+  return cmdMemory(parseArgs(rest));
 }

package/src/interfaces/cli/routes/nudge.js

@@ -0,0 +1,17 @@
+// apx nudge — argument routing for the interruption budget.
+import {
+  cmdNudgeStatus, cmdNudgeList, cmdNudgeSet, cmdNudgeCheck, cmdNudgeFeedback,
+} from "../commands/nudge.js";
+
+export const aliases = ["nudges"];
+
+export default async function route(rest, { parseArgs, die }) {
+  const sub = rest[0];
+  const a = parseArgs(rest.slice(1));
+  if (!sub || sub === "status") await cmdNudgeStatus(a);
+  else if (sub === "list" || sub === "ls") await cmdNudgeList(a);
+  else if (sub === "set" || sub === "config") await cmdNudgeSet(a);
+  else if (sub === "check") await cmdNudgeCheck(a);
+  else if (sub === "feedback") await cmdNudgeFeedback(a);
+  else die(`unknown nudge subcommand: ${sub}\nUsage: apx nudge <status|list|set|check|feedback>`);
+}