@agentprojectcontext/apx 1.31.2 → 1.32.2

package/src/host/daemon/plugins/telegram/media.js

@@ -0,0 +1,162 @@
+// Telegram media helpers: send photo/voice/document/audio + download a remote
+// file. Auto-extracted from plugins/telegram/index.js — these used to live
+// inline next to the poll loop and the super-agent dispatch.
+//
+// Each helper takes the bot token and chat id explicitly so they can be used
+// from any code path (tests, other plugins, future agents). Buffer or
+// absolute path input is accepted for media; for URLs the helpers pass them
+// through to Telegram and let the API fetch them.
+import fs from "node:fs";
+import path from "node:path";
+
+export const API_BASE = "https://api.telegram.org";
+
+/**
+ * Send a photo to a Telegram chat.
+ * @param {string} token     Bot token
+ * @param {string|number} chatId  Telegram chat_id
+ * @param {string|Buffer} photo   Absolute file path OR Buffer of image data
+ * @param {object} [opts]
+ * @param {string} [opts.caption]
+ * @param {string} [opts.parse_mode]  "HTML" | "Markdown" | "MarkdownV2"
+ */
+export async function sendPhoto(token, chatId, photo, { caption, parse_mode } = {}) {
+  const url = `${API_BASE}/bot${token}/sendPhoto`;
+  const form = new FormData();
+  form.append("chat_id", String(chatId));
+  if (caption) form.append("caption", caption);
+  if (parse_mode) form.append("parse_mode", parse_mode);
+
+  if (typeof photo === "string" && photo.startsWith("http")) {
+    // Public URL — send as string
+    form.append("photo", photo);
+  } else {
+    // Local file path or Buffer
+    const buf = Buffer.isBuffer(photo) ? photo : fs.readFileSync(photo);
+    const name = typeof photo === "string" ? path.basename(photo) : "photo.jpg";
+    const blob = new Blob([buf], { type: name.endsWith(".png") ? "image/png" : "image/jpeg" });
+    form.append("photo", blob, name);
+  }
+
+  const res = await fetch(url, { method: "POST", body: form });
+  const json = await res.json();
+  if (!json.ok) throw new Error(`sendPhoto failed: ${json.description || res.status}`);
+  return json.result;
+}
+
+/**
+ * Send a voice message (OGG/Opus preferred by Telegram).
+ * @param {string} token
+ * @param {string|number} chatId
+ * @param {string|Buffer} audio  Path or Buffer
+ * @param {object} [opts]
+ * @param {string} [opts.caption]
+ * @param {number} [opts.duration]
+ */
+export async function sendVoice(token, chatId, audio, { caption, duration } = {}) {
+  const url = `${API_BASE}/bot${token}/sendVoice`;
+  const form = new FormData();
+  form.append("chat_id", String(chatId));
+  if (caption) form.append("caption", caption);
+  if (duration) form.append("duration", String(duration));
+
+  const buf = Buffer.isBuffer(audio) ? audio : fs.readFileSync(audio);
+  const name = typeof audio === "string" ? path.basename(audio) : "voice.ogg";
+  const blob = new Blob([buf], { type: "audio/ogg" });
+  form.append("voice", blob, name);
+
+  const res = await fetch(url, { method: "POST", body: form });
+  const json = await res.json();
+  if (!json.ok) throw new Error(`sendVoice failed: ${json.description || res.status}`);
+  return json.result;
+}
+
+/**
+ * Send an audio file (MP3, M4A, etc — shown in Telegram music player).
+ * @param {string} token
+ * @param {string|number} chatId
+ * @param {string|Buffer} audio  Path or Buffer
+ * @param {object} [opts]
+ * @param {string} [opts.caption]
+ * @param {string} [opts.title]
+ * @param {string} [opts.performer]
+ */
+/**
+ * Send any file as a Telegram document (PDF, zip, txt, etc).
+ * @param {string} token
+ * @param {string|number} chatId
+ * @param {string|Buffer} document  Path or Buffer of document data
+ * @param {object} [opts]
+ * @param {string} [opts.caption]
+ * @param {string} [opts.filename] override filename for Buffer input
+ * @param {string} [opts.mime_type]
+ */
+export async function sendDocument(token, chatId, document, { caption, filename, mime_type } = {}) {
+  const url = `${API_BASE}/bot${token}/sendDocument`;
+  const form = new FormData();
+  form.append("chat_id", String(chatId));
+  if (caption) form.append("caption", caption);
+
+  // URL string → let Telegram fetch it
+  if (typeof document === "string" && /^https?:\/\//.test(document)) {
+    form.append("document", document);
+  } else {
+    const buf = Buffer.isBuffer(document) ? document : fs.readFileSync(document);
+    const name =
+      filename ||
+      (typeof document === "string" ? path.basename(document) : "document.bin");
+    const blob = new Blob([buf], { type: mime_type || "application/octet-stream" });
+    form.append("document", blob, name);
+  }
+
+  const res = await fetch(url, { method: "POST", body: form });
+  const json = await res.json();
+  if (!json.ok) throw new Error(`sendDocument failed: ${json.description || res.status}`);
+  return json.result;
+}
+
+export async function sendAudio(token, chatId, audio, { caption, title, performer } = {}) {
+  const url = `${API_BASE}/bot${token}/sendAudio`;
+  const form = new FormData();
+  form.append("chat_id", String(chatId));
+  if (caption) form.append("caption", caption);
+  if (title) form.append("title", title);
+  if (performer) form.append("performer", performer);
+
+  const buf = Buffer.isBuffer(audio) ? audio : fs.readFileSync(audio);
+  const name = typeof audio === "string" ? path.basename(audio) : "audio.mp3";
+  const blob = new Blob([buf], { type: "audio/mpeg" });
+  form.append("audio", blob, name);
+
+  const res = await fetch(url, { method: "POST", body: form });
+  const json = await res.json();
+  if (!json.ok) throw new Error(`sendAudio failed: ${json.description || res.status}`);
+  return json.result;
+}
+
+// Audio transcription is delegated to the central dispatcher
+// (../transcription.js) which handles local (faster-whisper via Python) +
+// OpenAI cloud fallback. See that module for config keys.
+
+/**
+ * Download a file from Telegram servers.
+ * Returns the local file path where it was saved.
+ */
+export async function downloadTelegramFile(token, fileId, destDir) {
+  // Step 1: get file path from Telegram
+  const infoRes = await fetch(`${API_BASE}/bot${token}/getFile?file_id=${fileId}`);
+  const infoJson = await infoRes.json();
+  if (!infoJson.ok) throw new Error(`getFile failed: ${infoJson.description}`);
+  const filePath = infoJson.result.file_path; // e.g. "photos/file_123.jpg"
+  const ext = path.extname(filePath) || ".jpg";
+  const fileName = `tg_${fileId.slice(-8)}_${Date.now()}${ext}`;
+  const localPath = path.join(destDir, fileName);
+
+  // Step 2: download
+  const dlRes = await fetch(`${API_BASE}/file/bot${token}/${filePath}`);
+  if (!dlRes.ok) throw new Error(`download failed: ${dlRes.status}`);
+  const buf = Buffer.from(await dlRes.arrayBuffer());
+  fs.writeFileSync(localPath, buf);
+  return localPath;
+}
+

package/src/host/daemon/projects-helpers.js

@@ -0,0 +1,54 @@
+// Helpers that need the running daemon's projects registry to do their work
+// (projectMeta + resolveProject). Pure / config-only helpers live in
+// core/agent/tools/helpers.js.
+import path from "node:path";
+
+export function projectMeta(projects, entry) {
+  const meta = projects.list().find((p) => p.id === entry.id);
+  return {
+    id: entry.id,
+    name: meta?.name || path.basename(entry.path),
+    path: entry.path,
+  };
+}
+
+export function resolveProject(projects, target, { allowMulti = false } = {}) {
+  if (target === undefined || target === null || target === "") {
+    if (allowMulti) return null;
+    const defaultProject = projects.get(0);
+    if (defaultProject) return defaultProject;
+    const all = projects.list();
+    if (all.length === 1) return projects.get(all[0].id);
+    throw new Error(`multiple projects registered (${all.length}); specify project=<id|name|path>`);
+  }
+
+  const tgt = String(target);
+  if (tgt.toLowerCase() === "default") {
+    const defaultProject = projects.get(0);
+    if (!defaultProject) throw new Error("default project not available");
+    return defaultProject;
+  }
+
+  if (typeof target === "number" || /^\d+$/.test(tgt)) {
+    const entry = projects.get(parseInt(tgt, 10));
+    if (!entry) throw new Error(`project id ${target} not found`);
+    return entry;
+  }
+
+  const all = projects.list();
+  const byPath = all.find((p) => p.path === path.resolve(tgt));
+  if (byPath) return projects.get(byPath.id);
+
+  const byName = all.find((p) => p.name === tgt);
+  if (byName) return projects.get(byName.id);
+
+  const tgtLow = tgt.toLowerCase();
+  const fuzzy = all.filter(
+    (p) => p.name.toLowerCase().includes(tgtLow) || p.path.toLowerCase().includes(tgtLow)
+  );
+  if (fuzzy.length === 1) return projects.get(fuzzy[0].id);
+  if (fuzzy.length > 1) {
+    throw new Error(`project "${tgt}" is ambiguous; matches: ${fuzzy.map((p) => p.name).join(", ")}`);
+  }
+  throw new Error(`project "${tgt}" not found`);
+}

package/src/host/daemon/routines.js

@@ -15,13 +15,15 @@ import { execFile } from "node:child_process";
 import os from "node:os";
 import fs from "node:fs";
 import path from "node:path";
-import { callEngine } from "../../core/engines/index.js";
-import { runSuperAgent } from "./super-agent.js";
-import { computeSuppressedTools } from "../../core/agent/index.js";
-import { readAgents } from "../../core/parser.js";
-import { buildAgentSystem } from "../../core/agent-system.js";
-import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "../../core/identity.js";
-import { resolveArtifactRef, ARTIFACTS_SKIP_SIGNAL } from "../../core/artifacts-store.js";
+import { callEngine } from "#core/engines/index.js";
+import { runSuperAgent } from "#core/agent/super-agent.js";
+import { computeSuppressedTools } from "#core/agent/index.js";
+import { readAgents } from "#core/apc/parser.js";
+import { buildAgentSystem } from "#core/agent/build-agent-system.js";
+import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
+import { resolveArtifactRef, ARTIFACTS_SKIP_SIGNAL } from "#core/stores/artifacts.js";
+import { ensureRoutineMemory, readRoutineMemoryForPrompt, routineMemoryPath } from "#core/stores/routine-memory.js";
+import { CHANNELS } from "#core/constants/channels.js";
 import {
   listRoutines,
   getRoutine,
@@ -32,7 +34,7 @@ import {
   getDueRoutines,
   parseSchedule,
   computeNextRun,
-} from "../../core/routines-store.js";
+} from "#core/stores/routines.js";
 
 export {
   listRoutines,
@@ -89,7 +91,7 @@ async function handleExecAgent(ctx, routine) {
 
   project.logMessage({
     agent_slug: slug,
-    channel: "routine",
+    channel: CHANNELS.ROUTINE,
     direction: "out",
     type: "agent",
     actor_id: slug,
@@ -129,16 +131,30 @@ async function handleSuperAgent(ctx, routine) {
     plugins,
     registries,
     prompt,
-    channel: "routine",
+    channel: CHANNELS.ROUTINE,
     channelMeta: {
       routineName: routine.name,
+      routineId: routine.id || "",
+      routineSchedule: routine.schedule || "",
+      routineLastRun: routine.last_run || "",
+      routineMemoryPath: (() => {
+        try {
+          ensureRoutineMemory(project.storagePath || project.path, routine.id, routine.name);
+          return routineMemoryPath(project.storagePath || project.path, routine.id);
+        } catch { return ""; }
+      })(),
+      routineMemory: (() => {
+        try {
+          return readRoutineMemoryForPrompt(project.storagePath || project.path, routine.id);
+        } catch { return ""; }
+      })(),
       projectPath: project.path,
     },
     suppressTools: suppressTools.length > 0 ? suppressTools : null,
   });
 
   project.logMessage({
-    channel: "routine",
+    channel: CHANNELS.ROUTINE,
     direction: "out",
     type: "agent",
     actor_id: SUPERAGENT_ACTOR_ID,
@@ -346,7 +362,7 @@ export async function runRoutineNow(ctx, routine) {
     disable: isOnce,
   });
   ctx.project.logMessage?.({
-    channel: "routine",
+    channel: CHANNELS.ROUTINE,
     direction: "out",
     type: "system",
     actor_id: "apx:routine",

package/src/host/daemon/smoke.js

@@ -8,8 +8,8 @@ import path from "node:path";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { ProjectManager } from "./db.js";
-import { McpRegistry } from "../../core/mcp/runner.js";
-import { readAgents } from "../../core/parser.js";
+import { McpRegistry } from "#core/mcp/runner.js";
+import { readAgents } from "#core/apc/parser.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);

package/src/host/daemon/token-store.js

@@ -23,7 +23,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { randomBytes, randomUUID, createHash } from "node:crypto";
-import { APX_HOME } from "../../core/config.js";
+import { APX_HOME } from "#core/config/index.js";
 
 export const CLIENTS_PATH = path.join(APX_HOME, "clients.json");
 

package/src/host/daemon/transcription.js

@@ -30,7 +30,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { spawn, exec } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { logInfo, logWarn, logError } from "../../core/logging.js";
+import { logInfo, logWarn, logError } from "#core/logging.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -76,7 +76,7 @@ export function resolveTranscriptionLanguage(localCfg, userLang) {
 
 async function getConfig() {
   try {
-    const { readConfig } = await import("../core/config.js");
+    const { readConfig } = await import("#core/config/index.js");
     const cfg = readConfig() || {};
     const t = cfg.transcription || {};
     const openaiKey = cfg.engines?.openai?.api_key || process.env.OPENAI_API_KEY || "";

package/src/host/daemon/wakeup.js

@@ -1,7 +1,7 @@
 // Wake-up message — sent via Telegram once per daemon restart (with cooldown).
 import fetch from "node-fetch";
-import { readIdentity, writeIdentity } from "../../core/identity.js";
-import { resolveProvider, getAdapter } from "../../core/engines/index.js";
+import { readIdentity, writeIdentity } from "#core/identity/index.js";
+import { resolveProvider, getAdapter } from "#core/engines/index.js";
 
 const WAKEUP_COOLDOWN_MS = 30 * 60 * 1000; // 30 min
 

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

@@ -1,8 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { findApfRoot, readAgents, readVaultAgents, readVaultAgent, VAULT_DIR, SLUG_RE } from "../../../core/parser.js";
-import { writeAgentFile, writeVaultAgentFile, removeVaultAgent, restoreVaultAgent, addImportedAgent, ensureAgentDir } from "../../../core/scaffold.js";
-import { ensureAgentRuntimeDir, agentMemoryPath } from "../../../core/agent-memory.js";
+import { findApfRoot, readAgents, readVaultAgents, readVaultAgent, VAULT_DIR, SLUG_RE } from "#core/apc/parser.js";
+import { writeAgentFile, writeVaultAgentFile, removeVaultAgent, restoreVaultAgent, addImportedAgent, ensureAgentDir } from "#core/apc/scaffold.js";
+import { ensureAgentRuntimeDir, agentMemoryPath } from "#core/agent/memory.js";
 import { http } from "../http.js";
 
 // ── ANSI ──────────────────────────────────────────────────────────────────────

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

@@ -1,6 +1,40 @@
+import fs from "node:fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
 import { http } from "../http.js";
 import { resolveProjectId } from "./project.js";
 
+// First two bytes of an executable script. Used as a hint when the file
+// doesn't have the exec bit but clearly intends to run (shebang line).
+const SHEBANG = "#!";
+
+// Decide if an artifact is "runnable": exec bit on the file, OR the file
+// starts with a shebang. If shebang-but-not-exec, we set the bit before
+// spawning so `./script` works without the user having to chmod +x.
+function detectRunnable(absPath) {
+  let stat;
+  try {
+    stat = fs.statSync(absPath);
+  } catch {
+    return { runnable: false, reason: "not_found" };
+  }
+  if (!stat.isFile()) return { runnable: false, reason: "not_a_file" };
+  const execBit = (stat.mode & 0o111) !== 0;
+  let hasShebang = false;
+  try {
+    const fd = fs.openSync(absPath, "r");
+    const buf = Buffer.alloc(2);
+    fs.readSync(fd, buf, 0, 2, 0);
+    fs.closeSync(fd);
+    hasShebang = buf.toString("utf8") === SHEBANG;
+  } catch {
+    // ignore: hasShebang stays false
+  }
+  if (execBit) return { runnable: true, reason: "exec_bit", autoChmod: false };
+  if (hasShebang) return { runnable: true, reason: "shebang", autoChmod: true };
+  return { runnable: false, reason: "no_exec_no_shebang" };
+}
+
 export async function cmdArtifactCreate(args) {
   const name = args._[0];
   if (!name) throw new Error("apx artifact create: missing <name>");
@@ -43,3 +77,68 @@ export async function cmdArtifactRemove(args) {
   await http.delete(`/projects/${pid}/artifacts/${encodeURIComponent(name)}`);
   console.log(`removed artifact "${name}"`);
 }
+
+// `apx artifact run <name> [-- args...]`
+//
+// Resolves the artifact's absolute path via the daemon (single source of
+// truth for project storage), then spawns the file LOCALLY with stdio
+// inherited so the caller sees output as if they typed `./artifact <args>`.
+// Detection is lenient: exec bit OR shebang → runnable; shebang-only files
+// get a one-shot chmod +x so the user doesn't have to do it themselves.
+//
+// The remaining argv after `run <name>` is passed straight to the script,
+// so `apx artifact run hello.sh -- hola mundo` becomes `./hello.sh hola mundo`.
+export async function cmdArtifactRun(args) {
+  const name = args._[0];
+  if (!name) throw new Error("apx artifact run: missing <name>");
+  const pid = await resolveProjectId(args?.flags?.project);
+  // Pull the artifact record from the daemon for the absolute path.
+  let entry;
+  try {
+    entry = await http.get(`/projects/${pid}/artifacts/${encodeURIComponent(name)}`);
+  } catch (e) {
+    throw new Error(`artifact "${name}" not found in project #${pid}: ${e.message}`);
+  }
+  const absPath = entry.path;
+  if (!absPath || !fs.existsSync(absPath)) {
+    throw new Error(`artifact "${name}" path missing on disk: ${absPath}`);
+  }
+
+  const detection = detectRunnable(absPath);
+  if (!detection.runnable) {
+    const hint = detection.reason === "no_exec_no_shebang"
+      ? "no es ejecutable (sin shebang ni bit +x). Probá `apx artifact show` para ver el contenido."
+      : `no se puede ejecutar (${detection.reason}).`;
+    throw new Error(`artifact "${name}" ${hint}`);
+  }
+  if (detection.autoChmod) {
+    try {
+      const st = fs.statSync(absPath);
+      fs.chmodSync(absPath, st.mode | 0o111);
+    } catch (e) {
+      throw new Error(`could not chmod +x ${absPath}: ${e.message}`);
+    }
+  }
+
+  // Everything after the artifact name is forwarded to the script. The CLI's
+  // argv parser already strips top-level flags; what's left in `_` is name
+  // + script args.
+  const scriptArgs = (args._ || []).slice(1);
+  const cwd = path.dirname(absPath);
+  const child = spawn(absPath, scriptArgs, { stdio: "inherit", cwd });
+
+  await new Promise((resolve) => {
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        // Killed by signal — surface a non-zero exit for shell pipelines.
+        process.exit(128 + (signal === "SIGINT" ? 2 : 15));
+      }
+      process.exit(code ?? 0);
+    });
+    child.on("error", (err) => {
+      console.error(`apx artifact run: spawn failed — ${err.message}`);
+      resolve();
+      process.exit(1);
+    });
+  });
+}

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

@@ -1,7 +1,7 @@
 // apx command — list and show workflow commands from .apc/commands/
 import fs from "node:fs";
 import path from "node:path";
-import { findApfRoot } from "../../../core/parser.js";
+import { findApfRoot } from "#core/apc/parser.js";
 import { http } from "../http.js";
 import { resolveProjectId } from "./project.js";
 

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

@@ -1,6 +1,7 @@
 import { http } from "../http.js";
 import { resolveProjectId } from "./project.js";
-import { readConfig, writeConfig } from "../../../core/config.js";
+import { readConfig, writeConfig } from "#core/config/index.js";
+import { PERMISSION_MODES, DEFAULT_PERMISSION_MODE } from "#core/constants/permissions.js";
 
 function parseValue(raw) {
   // best-effort: try JSON first (covers numbers, bools, objects, arrays, null,
@@ -61,7 +62,7 @@ export function cmdPermission(args = {}) {
   const cfg = readConfig();
   cfg.super_agent = cfg.super_agent || {};
   if (sub === "show" || sub === "get" || sub === "ls") {
-    console.log(`permission_mode=${cfg.super_agent.permission_mode || "automatico"}`);
+    console.log(`permission_mode=${cfg.super_agent.permission_mode || DEFAULT_PERMISSION_MODE}`);
     console.log(`allowed_tools=${(cfg.super_agent.allowed_tools || []).join(",") || "(none)"}`);
     return;
   }

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

@@ -15,7 +15,7 @@ import {
   LINUX_DESKTOP_PATH,
   WIN_RUN_KEY,
   WIN_RUN_NAME,
-} from "../../../core/desktop/autostart.js";
+} from "#core/desktop/autostart.js";
 
 // Re-exports — kept so existing tests (tests/desktop-autostart.test.js)
 // can still import these directly from the CLI module.

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

@@ -1,5 +1,6 @@
 import { http } from "../http.js";
 import { resolveProjectId } from "./project.js";
+import { CHANNELS } from "#core/constants/channels.js";
 
 /**
  * Resolve exec target from CLI args.
@@ -63,7 +64,7 @@ export async function cmdExec(args) {
   const pid = await resolveProjectId(args?.flags?.project);
   const body = {
     prompt,
-    channel: "cli",
+    channel: CHANNELS.CLI,
     channelMeta: { cwd: process.cwd() },
   };
   if (args.flags.model && args.flags.model !== true) body.model = args.flags.model;

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

@@ -1,5 +1,5 @@
 import readline from "node:readline";
-import { readIdentity, writeIdentity } from "../../../core/identity.js";
+import { readIdentity, writeIdentity } from "#core/identity/index.js";
 
 function ask(rl, question, defaultVal) {
   return new Promise((resolve) => {
@@ -22,7 +22,7 @@ export async function cmdIdentity(args) {
       console.log("No identity configured. Run: apx identity wizard");
       return;
     }
-    const { readConfig } = await import("../../../core/config.js");
+    const { readConfig } = await import("#core/config/index.js");
     const cfg = readConfig();
     console.log("");
     console.log(`  Agent name  : ${id.agent_name}`);

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

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { initApf } from "../../../core/scaffold.js";
+import { initApf } from "#core/apc/scaffold.js";
 
 export function cmdInit(args) {
   const dir = args._[0] || ".";

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

@@ -1,6 +1,6 @@
 import { http } from "../http.js";
 import { resolveProjectId } from "./project.js";
-import { findApfRoot } from "../../../core/parser.js";
+import { findApfRoot } from "#core/apc/parser.js";
 
 const VALID_SCOPES = new Set(["shared", "runtime", "global", "all"]);
 

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

@@ -1,6 +1,6 @@
 import fs from "node:fs";
-import { findApfRoot } from "../../../core/parser.js";
-import { agentMemoryPath, readAgentMemory, writeAgentMemory, ensureAgentRuntimeDir } from "../../../core/agent-memory.js";
+import { findApfRoot } from "#core/apc/parser.js";
+import { agentMemoryPath, readAgentMemory, writeAgentMemory, ensureAgentRuntimeDir } from "#core/agent/memory.js";
 import { http } from "../http.js";
 
 function requireRoot() {

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

@@ -1,11 +1,22 @@
-import { readConfig, writeConfig } from "../../../core/config.js";
+import { readConfig, writeConfig } from "#core/config/index.js";
 import {
   probeAllProviders,
   resolveActiveModel,
-  fallbackOrder,
-  modelForProvider,
+  fallbackModels,
+  parseModelId,
   DEFAULT_FALLBACK_ORDER,
-} from "../../../core/agent/model-router.js";
+} from "#core/agent/model-router.js";
+
+function providersFromFallback(cfg) {
+  const seen = [];
+  for (const m of fallbackModels(cfg)) {
+    try {
+      const p = parseModelId(m).provider;
+      if (!seen.includes(p)) seen.push(p);
+    } catch { /* skip malformed */ }
+  }
+  return seen.length ? seen : [...DEFAULT_FALLBACK_ORDER];
+}
 
 function parseValue(raw) {
   try {
@@ -56,7 +67,7 @@ export async function cmdModel(args = {}) {
     console.log("Model router");
     console.log(`  primary:   ${cfg.super_agent.model || "(not set)"}`);
     console.log(`  fallback:  ${cfg.super_agent.model_fallback.enabled !== false ? "on" : "off"}`);
-    console.log(`  order:     ${fallbackOrder(cfg).join(" → ")}`);
+    console.log(`  order:     ${providersFromFallback(cfg).join(" → ")}`);
     if (active) {
       console.log(`  active:    ${active.modelId}${active.fromFallback ? " (fallback)" : ""}`);
     }
@@ -133,4 +144,3 @@ export async function cmdModel(args = {}) {
   throw new Error(`unknown model subcommand: ${sub}. Try: status | order | key | set | test | enable | disable`);
 }
 
-export { modelForProvider, fallbackOrder };

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

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { findApfRoot } from "../../../core/parser.js";
+import { findApfRoot } from "#core/apc/parser.js";
 import { http } from "../http.js";
 
 function requireRoot() {