@agentprojectcontext/apx 1.25.0 → 1.27.1

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

@@ -0,0 +1,86 @@
+// Tiny in-house i18n. No runtime library — keys are dotted paths into
+// `es.ts`. The lookup is dynamic (so loading another locale later is just
+// swapping the dictionary) but the bundle ships only one language at a
+// time. Unknown keys log a warning and return the key itself so missing
+// strings surface visually in dev.
+import { es, type EsStrings } from "./es";
+import { en } from "./en";
+import { STORAGE } from "../constants";
+
+type DeepKeys<T, P extends string = ""> = {
+  [K in keyof T & string]: T[K] extends object
+    ? DeepKeys<T[K], P extends "" ? K : `${P}.${K}`>
+    : P extends "" ? K : `${P}.${K}`;
+}[keyof T & string];
+
+export type TKey = DeepKeys<EsStrings>;
+
+const dictionaries: Record<string, unknown> = { es, en };
+export type Locale = "es" | "en";
+
+function readLocale(): Locale {
+  try {
+    const saved = localStorage.getItem(STORAGE.language);
+    if (saved && saved in dictionaries) return saved as Locale;
+  } catch { /* ignore */ }
+  return "es";
+}
+
+let activeLocale: Locale = readLocale();
+
+export function setLocale(l: Locale) {
+  activeLocale = l;
+  try { localStorage.setItem(STORAGE.language, l); } catch { /* quota */ }
+}
+
+export const LOCALES: { value: Locale; label: string }[] = [
+  { value: "es", label: "Español" },
+  { value: "en", label: "English" },
+];
+
+export function getLocale(): Locale { return activeLocale; }
+
+function lookup(key: string): string | undefined {
+  const dict = dictionaries[activeLocale] as Record<string, unknown>;
+  const parts = key.split(".");
+  let cur: any = dict;
+  for (const p of parts) {
+    if (cur && typeof cur === "object" && p in cur) cur = cur[p];
+    else return undefined;
+  }
+  return typeof cur === "string" ? cur : undefined;
+}
+
+function format(s: string, vars?: Record<string, string | number>): string {
+  if (!vars) return s;
+  return s.replace(/\{(\w+)\}/g, (_m, k) => (k in vars ? String(vars[k]) : `{${k}}`));
+}
+
+// Falls back to es dict when a key is missing in the active locale (safety net).
+function lookupWithFallback(key: string): string | undefined {
+  const found = lookup(key);
+  if (found !== undefined) return found;
+  if (activeLocale !== "es") {
+    const esDict = dictionaries["es"] as Record<string, unknown>;
+    const parts = key.split(".");
+    let cur: unknown = esDict;
+    for (const p of parts) {
+      if (cur && typeof cur === "object" && p in (cur as Record<string, unknown>)) {
+        cur = (cur as Record<string, unknown>)[p];
+      } else return undefined;
+    }
+    return typeof cur === "string" ? cur : undefined;
+  }
+  return undefined;
+}
+
+export function t(key: TKey, vars?: Record<string, string | number>): string {
+  const found = lookupWithFallback(key as string);
+  if (found === undefined) {
+    if ((import.meta as { env?: { DEV?: boolean } }).env?.DEV) {
+      console.warn(`[i18n] missing key: ${key}`);
+    }
+    return key as string;
+  }
+  return format(found, vars);
+}

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

@@ -0,0 +1,30 @@
+import { http } from "../http";
+import type { GlobalConfig, PairedClient, PairInit, PairStatus, SuperAgentConfig } from "../../types/daemon";
+
+export const Admin = {
+  reload:   () => http.post<{ ok: true; super_agent_model: string; fallback_order: string[] }>("/admin/reload"),
+  shutdown: () => http.post<{ ok: true }>("/admin/shutdown"),
+  config:   {
+    get:   () => http.get<{ config: GlobalConfig }>("/admin/config"),
+    patch: (body: { set?: Record<string, unknown>; unset?: string[] }) =>
+      http.patch<{ ok: true; config: GlobalConfig }>("/admin/config", body),
+  },
+  superAgent: () => http.get<SuperAgentConfig>("/admin/super-agent"),
+  logs: (file: "errors" | "apx" = "errors", limit = 200) =>
+    http.get<{ file: string; entries?: Array<Record<string, unknown>>; lines?: string[] }>(
+      `/admin/logs?file=${file}&limit=${limit}`,
+    ),
+};
+
+export const Pair = {
+  list:   () => http.get<{ clients: PairedClient[] }>("/pair/list"),
+  revoke: (id: string) => http.del<void>(`/pair/revoke/${encodeURIComponent(id)}`),
+  // Mint a pairing nonce (localhost-only on the daemon). Used by the web's
+  // "Vincular dispositivo" — same nonce the terminal `apx pair` uses.
+  init:   () => http.post<PairInit>("/pair/init", {}),
+  status: (pid: string) => http.get<PairStatus>(`/pair/status/${encodeURIComponent(pid)}`),
+  // Browser plays the "device" role: confirm a nonce (scanned via QR or pasted)
+  // to mint a per-client token. Unauthenticated by design (nonce-gated).
+  confirm: (body: { pairing_id: string; label?: string; kind?: string }) =>
+    http.post<{ token: string; client_id: string; label: string; kind: string }>("/pair/confirm", body),
+};

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

@@ -0,0 +1,46 @@
+import { http } from "../http";
+import type { AgentDetail, AgentEntry } from "../../types/daemon";
+
+export const Agents = {
+  list:   (pid: string) => http.get<AgentEntry[]>(`/projects/${pid}/agents`),
+  get:    (pid: string, slug: string) => http.get<AgentDetail>(`/projects/${pid}/agents/${slug}`),
+  create: (pid: string, body: Partial<AgentEntry> & { slug: string }) =>
+    http.post<AgentEntry>(`/projects/${pid}/agents`, body),
+  update: (pid: string, slug: string, body: Partial<AgentEntry> & { system?: string }) =>
+    http.patch<AgentEntry>(`/projects/${pid}/agents/${encodeURIComponent(slug)}`, body),
+  remove: (pid: string, slug: string) =>
+    http.del<{ ok: boolean }>(`/projects/${pid}/agents/${encodeURIComponent(slug)}`),
+  chat: (pid: string, slug: string, body: { prompt: string; conversation_id?: string }) =>
+    http.post<{ conversation_id: string; text: string; usage?: unknown; engine: string }>(
+      `/projects/${pid}/agents/${encodeURIComponent(slug)}/chat`,
+      body,
+    ),
+  memory: {
+    get: (pid: string, slug: string) =>
+      http.get<{ body: string }>(`/projects/${pid}/agents/${slug}/memory`),
+    put: (pid: string, slug: string, body: string) =>
+      http.put<{ ok: boolean; bytes: number }>(`/projects/${pid}/agents/${slug}/memory`, { body }),
+  },
+  // Vault = global agent templates. Two-layer: bundled defaults shipped with
+  // APX + user overrides/new ones in ~/.apx/agents. The API merges both and
+  // exposes a `source` per entry: "bundled" | "user" | "user-override".
+  // Tombstones (deleted bundled defaults) are hidden unless includeRemoved=true.
+  vault: (opts?: { includeRemoved?: boolean }) =>
+    http.get<(AgentEntry & { source?: "bundled" | "user" | "user-override" })[]>(
+      opts?.includeRemoved ? "/agents/vault?include_removed=1" : "/agents/vault",
+    ),
+  vaultCreate: (slug: string, fields: Record<string, unknown> = {}, body = "") =>
+    http.post<AgentEntry>("/agents/vault", { slug, fields, body }),
+  vaultPatch: (slug: string, patch: { fields?: Record<string, unknown>; body?: string }) =>
+    http.patch<AgentEntry>(`/agents/vault/${encodeURIComponent(slug)}`, patch),
+  vaultRemove: (slug: string) =>
+    http.del<{ ok: boolean; removed: "user" | "tomb" | "user+tomb" }>(
+      `/agents/vault/${encodeURIComponent(slug)}`,
+    ),
+  vaultRestore: (slug: string) =>
+    http.post<{ ok: boolean; agent: AgentEntry | null }>(
+      `/agents/vault/${encodeURIComponent(slug)}/restore`,
+    ),
+  import: (pid: string, slug: string) =>
+    http.post<AgentEntry>(`/projects/${pid}/agents/import`, { slug }),
+};

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

@@ -0,0 +1,122 @@
+import { http, streamNdjson } from "../http";
+import type { ChatStreamEvent, ChatUsage } from "../../types/daemon";
+
+// Code module client — the web surface for OpenCode-style coding sessions.
+//
+// Backed by the daemon's project-scoped code-session API (see
+// src/host/daemon/api/code.js). Sessions are persistent and server-side
+// stateful: the turn handler rebuilds history from the stored transcript, so
+// the client never sends `previousMessages`. Each session runs the super-agent
+// on the `code` channel with a plan/build mode and an optional model override.
+
+export type CodeMode = "build" | "plan";
+
+/** Rich part shape — mirrors hooks/useChat.ts ChatPart (text | tool). */
+export type CodeTextPart = { kind: "text"; text: string };
+export type CodeToolPart = {
+  kind: "tool";
+  id: string;
+  tool: string;
+  args?: Record<string, unknown>;
+  result?: unknown;
+  status: "running" | "done" | "error" | "deduped";
+};
+export type CodePart = CodeTextPart | CodeToolPart;
+
+export interface CodeTurn {
+  role: "user" | "assistant";
+  parts: CodePart[];
+  ts: string;
+  model?: string;
+  mode?: CodeMode;
+  usage?: ChatUsage;
+  notes?: string[];
+}
+
+/** Session list row (no messages). */
+export interface CodeSessionRow {
+  id: string;
+  title: string;
+  mode: CodeMode;
+  model: string | null;
+  createdAt: string;
+  updatedAt: string;
+  messageCount: number;
+  hasGit: boolean;
+}
+
+/** Full session with transcript. */
+export interface CodeSession {
+  id: string;
+  projectId: string | null;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  model: string | null;
+  mode: CodeMode;
+  git: { baselineCommit: string | null; baselineTree: string } | null;
+  messages: CodeTurn[];
+}
+
+/** A single changed file in the session's diff vs its baseline. */
+export interface CodeFileChange {
+  path: string;
+  status: "added" | "modified" | "deleted";
+  additions: number | null;
+  deletions: number | null;
+  patch: string;
+}
+
+export interface CodeChanges {
+  git: boolean;
+  files: CodeFileChange[];
+}
+
+export type CodeStreamEvent = ChatStreamEvent & {
+  name?: string;
+  tool?: string;
+};
+
+const base = (pid: string | number) => `/projects/${pid}/code/sessions`;
+
+export const Code = {
+  sessions: {
+    list: (pid: string | number) =>
+      http.get<{ sessions: CodeSessionRow[] }>(base(pid)).then((r) => r.sessions),
+
+    get: (pid: string | number, sid: string) =>
+      http.get<CodeSession>(`${base(pid)}/${sid}`),
+
+    create: (
+      pid: string | number,
+      body: { title?: string; model?: string | null; mode?: CodeMode } = {},
+    ) => http.post<CodeSession>(base(pid), body),
+
+    update: (
+      pid: string | number,
+      sid: string,
+      patch: { title?: string; model?: string | null; mode?: CodeMode },
+    ) => http.patch<CodeSession>(`${base(pid)}/${sid}`, patch),
+
+    remove: (pid: string | number, sid: string) =>
+      http.del<{ ok: boolean }>(`${base(pid)}/${sid}`),
+  },
+
+  changes: (pid: string | number, sid: string) =>
+    http.get<CodeChanges>(`${base(pid)}/${sid}/changes`),
+
+  /** Stream a coding turn into a session. History is server-side. */
+  stream: (
+    pid: string | number,
+    sid: string,
+    body: { prompt: string },
+    onEvent: (ev: CodeStreamEvent) => void,
+    signal?: AbortSignal,
+  ) =>
+    streamNdjson<CodeStreamEvent>(
+      `${base(pid)}/${sid}/chat/stream`,
+      body,
+      onEvent,
+      signal,
+    ),
+};

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

@@ -0,0 +1,16 @@
+import { http } from "../http";
+import type { ConversationDetail, ConversationListEntry } from "../../types/daemon";
+
+export const Conversations = {
+  list: (pid: string, slug: string) =>
+    http.get<ConversationListEntry[]>(`/projects/${pid}/agents/${slug}/conversations`),
+  get:  (pid: string, slug: string, id: string) =>
+    http.get<ConversationDetail>(`/projects/${pid}/agents/${slug}/conversations/${id}`),
+  compact: (pid: string, slug: string, id?: string) =>
+    http.post<{ ok?: boolean }>(
+      id
+        ? `/projects/${pid}/agents/${slug}/conversations/${id}/compact`
+        : `/projects/${pid}/agents/${slug}/compact`,
+      {}
+    ),
+};

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

@@ -0,0 +1,106 @@
+import { http } from "../http";
+
+// Deck (companion app) client. Talks to the daemon's /deck surface.
+// Shapes match src/host/daemon/api/deck.js exactly.
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type WidgetSource = "apx" | "external";
+
+export type WidgetStatus =
+  | "available"
+  | "not_configured"
+  | "configured"
+  | "disabled";
+
+export interface DeckWidget {
+  id: string;
+  title: string;
+  source: WidgetSource;
+  /** desktop id this widget belongs to */
+  desktop: string;
+  kind: string;
+  status: WidgetStatus;
+  /** Only present on external widgets. null = no user override yet. */
+  user_enabled: boolean | null;
+  /** Optional live plugin status from daemon (external widgets only). */
+  daemon_status?: { enabled?: boolean; [k: string]: unknown };
+}
+
+export interface DeckDesktop {
+  id: string;
+  title: string;
+}
+
+export interface DeckSuggestedAction {
+  id: string;
+  title: string;
+  risk: "safe" | "confirm";
+  endpoint: string;
+}
+
+export interface DeckSection {
+  name: string;
+  desktops: DeckDesktop[];
+  widgets: DeckWidget[];
+  suggested_actions: DeckSuggestedAction[];
+}
+
+export interface DeckDaemonInfo {
+  name: string;
+  version: string;
+  host: string;
+  port: number;
+  uptime_s: number;
+  started_at: string;
+}
+
+export interface DeckManifest {
+  status: string;
+  daemon: DeckDaemonInfo;
+  deck: DeckSection;
+  apx: {
+    active_project: { id: number; path: string; name: string } | null;
+    projects: Array<{ id: number; path: string; name: string; kind: string; agents: number }>;
+    plugins: Record<string, unknown>;
+    endpoints: Record<string, string>;
+  };
+  safety: {
+    direct_shell: boolean;
+    arbitrary_commands: boolean;
+    dangerous_actions_require_confirmation: boolean;
+    allowed_actions_only: boolean;
+  };
+}
+
+export interface WidgetPatchResult {
+  id: string;
+  enabled: boolean;
+  override: { enabled: boolean };
+}
+
+// ── API Client ───────────────────────────────────────────────────────────────
+
+export const Deck = {
+  /** GET /deck/manifest — full companion manifest. */
+  manifest: () => http.get<DeckManifest>("/deck/manifest"),
+
+  /**
+   * PATCH /deck/widgets/:id  { enabled: boolean }
+   * Only "external" source widgets are toggleable.
+   * Core (source="apx") widgets return 404.
+   */
+  setWidget: (id: string, body: { enabled: boolean }) =>
+    http.patch<WidgetPatchResult>(`/deck/widgets/${encodeURIComponent(id)}`, body),
+
+  /**
+   * POST /deck/exec
+   * Whitelisted intent-based action runner for the Deck companion.
+   */
+  exec: (body: {
+    kind: "open_app" | "open_path" | "open_path_in" | "open_url" | "copy_clipboard";
+    target?: string;
+    app?: string;
+    text?: string;
+  }) => http.post<{ ok: boolean; kind: string; [k: string]: unknown }>("/deck/exec", body),
+};

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

@@ -0,0 +1,54 @@
+import { http } from "../http";
+
+// Desktop (floating voice window) client. Talks to the daemon's /desktop
+// surface (see src/host/daemon/api/desktop.js + plugins/desktop.js).
+//
+// The desktop window is an Electron app spawned by the CLI (`apx desktop start`),
+// NOT by the daemon — so the daemon can only report how many windows are
+// currently connected over the /desktop/ws WebSocket. The web admin shows that
+// status, edits persisted config (desktop.shortcut, desktop.enabled,
+// desktop.theme, desktop.position), and toggles login-item autostart via the
+// shared autostart helpers (core/desktop/autostart.js).
+
+export interface DesktopStatus {
+  ok: boolean;
+  connected_clients: number;
+  running: boolean;
+}
+
+export interface AutostartStatus {
+  ok: boolean;
+  enabled: boolean;
+  platform: NodeJS.Platform | string;
+}
+
+export const Desktop = {
+  /** GET /desktop/status — connected window count + running flag (live probe). */
+  status: () => http.get<DesktopStatus>("/desktop/status"),
+
+  /** GET /desktop/autostart — current login-item state for this platform. */
+  autostartGet: () => http.get<AutostartStatus>("/desktop/autostart"),
+
+  /** POST /desktop/autostart {enable} — toggle the login-item on or off. */
+  autostartSet: (enable: boolean) =>
+    http.post<AutostartStatus>("/desktop/autostart", { enable }),
+};
+
+// Last-N messages for the "desktop" global channel (preview the latest
+// conversation in the web admin). Uses the unified messages-global endpoint.
+
+export interface GlobalMessage {
+  channel: string;
+  direction: "in" | "out";
+  type: string;
+  actor_id?: string | null;
+  agent_slug?: string | null;
+  body: string;
+  meta?: Record<string, unknown>;
+  author?: string | null;
+  ts: string;
+}
+
+export function fetchDesktopMessages(limit = 30) {
+  return http.get<GlobalMessage[]>(`/messages/global?channel=desktop&limit=${limit}`);
+}

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

@@ -0,0 +1,44 @@
+import { http } from "../http";
+
+// RAG embeddings client. Talks to the daemon's /embeddings surface
+// (src/host/daemon/api/embeddings.js + the engine registry at
+// src/core/memory/embed-engines/index.js). Mirrors the TTS/STT pattern: pick a
+// provider + model per section, config persists under config.memory.embeddings.
+
+export type EmbedProviderId = "ollama" | "openai" | "gemini" | "tf";
+export type EmbedMode = "chain" | "single";
+
+export interface EmbedEngineInfo {
+  id: string;
+  available: boolean;   // probe says it can embed right now
+  configured: boolean;  // has a non-empty memory.embeddings.<id> config block
+  enabled: boolean;     // included in the fallback chain
+}
+
+export interface EmbedProvidersResponse {
+  configured_provider: string; // "auto" | <engine id>
+  mode: EmbedMode;
+  order: string[];
+  engines: EmbedEngineInfo[];
+}
+
+export interface EmbedTestResult {
+  ok: boolean;
+  provider: string;
+  embedder: string;  // e.g. "ollama:nomic-embed-text" | "openai:text-embedding-3-small" | "tf"
+  dim: number;
+  ms: number;
+}
+
+export interface EmbedReindexResult {
+  ok: boolean;
+  cleared: number;
+  indexed: number;
+}
+
+export const Embeddings = {
+  providers: () => http.get<EmbedProvidersResponse>("/embeddings/providers"),
+  test: (body: { text?: string; provider?: string } = {}) =>
+    http.post<EmbedTestResult>("/embeddings/test", body),
+  reindex: () => http.post<EmbedReindexResult>("/embeddings/reindex", {}),
+};

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

@@ -0,0 +1,17 @@
+import { http } from "../http";
+import type { EngineSummary } from "../../types/daemon";
+
+export interface EngineModels {
+  engine: string;
+  base_url?: string;
+  models: string[];
+  error?: string;
+}
+
+export const Engines = {
+  list: () => http.get<EngineSummary>("/engines"),
+  // Live model catalog. api_key optional: falls back to the stored secret for
+  // the provider slug (so editing an existing provider works without retyping).
+  models: (body: { engine: string; slug?: string; base_url?: string; api_key?: string }) =>
+    http.post<EngineModels>("/engines/models", body),
+};

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

@@ -0,0 +1,12 @@
+import { http } from "../http";
+
+export interface DirectoryList {
+  path: string;
+  parent: string | null;
+  entries: string[];
+}
+
+export const Filesystem = {
+  dirs: (path: string) =>
+    http.get<DirectoryList>(`/admin/fs/dirs?path=${encodeURIComponent(path)}`),
+};

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

@@ -0,0 +1,6 @@
+import { http } from "../http";
+import type { HealthSummary } from "../../types/daemon";
+
+export const Health = {
+  get: () => http.get<HealthSummary>("/health"),
+};

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

@@ -0,0 +1,7 @@
+import { http } from "../http";
+import type { Identity } from "../../types/daemon";
+
+export const IdentityApi = {
+  get:   () => http.get<Identity>("/identity"),
+  patch: (body: Partial<Identity>) => http.patch<Identity>("/identity", body),
+};

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

@@ -0,0 +1,29 @@
+import { http } from "../http";
+import type { McpEntry } from "../../types/daemon";
+
+export type McpScope = "shared" | "runtime" | "global";
+
+export interface McpCheck {
+  sources: Array<{ name: string; path: string }>;
+  entries: McpEntry[];
+  conflicts: Array<{ name: string; sources: string[] }>;
+}
+
+export interface McpAddBody {
+  name: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string;
+  headers?: Record<string, string>;
+  enabled?: boolean;
+}
+
+export const Mcps = {
+  list:   (pid: string) => http.get<McpEntry[]>(`/projects/${pid}/mcps`),
+  check:  (pid: string) => http.get<McpCheck>(`/projects/${pid}/mcps/check`),
+  add:    (pid: string, scope: McpScope, body: McpAddBody) =>
+    http.post<{ ok: true; name: string }>(`/projects/${pid}/mcps?scope=${scope}`, body),
+  remove: (pid: string, name: string, scope: McpScope = "shared") =>
+    http.del<void>(`/projects/${pid}/mcps/${encodeURIComponent(name)}?scope=${scope}`),
+};

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

@@ -0,0 +1,24 @@
+import { http } from "../http";
+import type { MessageEntry } from "../../types/daemon";
+
+const qs = (params: Record<string, string | number | undefined>) => {
+  const s = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== undefined && v !== "") s.set(k, String(v));
+  }
+  const str = s.toString();
+  return str ? `?${str}` : "";
+};
+
+export const Messages = {
+  // Cross-project channels (telegram, direct, …) — ~/.apx/messages/<channel>/*.jsonl
+  global: (opts: { channel?: string; limit?: number; since?: string } = {}) =>
+    http.get<MessageEntry[]>(`/messages/global${qs(opts)}`),
+
+  // Per-project activity — ~/.apx/projects/<id>/messages/*.jsonl
+  project: (pid: string, opts: { channel?: string; agent?: string; limit?: number; since?: string } = {}) =>
+    http.get<MessageEntry[]>(`/projects/${pid}/messages${qs(opts)}`),
+
+  search: (pid: string, q: string, limit = 50) =>
+    http.get<MessageEntry[]>(`/projects/${pid}/messages/search${qs({ q, limit })}`),
+};

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

@@ -0,0 +1,29 @@
+import { http } from "../http";
+import type { ProjectConfig, ProjectEntry } from "../../types/daemon";
+
+export const Projects = {
+  list:    () => http.get<ProjectEntry[]>("/projects"),
+  register:(path: string) => http.post<{ id: number; path: string }>("/projects", { path }),
+  remove:  (id: string)   => http.del<void>(`/projects/${encodeURIComponent(id)}`),
+  rebuild: (id: string)   => http.post<{ ok: true }>(`/projects/${encodeURIComponent(id)}/rebuild`),
+  config:  {
+    show:  (id: string)              => http.get<ProjectConfig>(`/projects/${id}/config`),
+    set:   (id: string, set: Record<string, unknown>) =>
+      http.patch<{ ok: true }>(`/projects/${id}/config`, { set }),
+    unset: (id: string, keys: string[]) =>
+      http.patch<{ ok: true }>(`/projects/${id}/config`, { unset: keys }),
+    put:   (id: string, full: Record<string, unknown>) =>
+      http.put<{ ok: true }>(`/projects/${id}/config`, full),
+  },
+  apcProject: {
+    set: (id: string, set: Record<string, unknown>, unset?: string[]) =>
+      http.patch<{ ok: true; apc_project: Record<string, unknown> }>(`/projects/${id}/apc-project`, { set, unset }),
+    put: (id: string, full: Record<string, unknown>) =>
+      http.put<{ ok: true; apc_project: Record<string, unknown> }>(`/projects/${id}/apc-project`, full),
+  },
+  // Project-level memory (.apc/memory.md). Per-agent memory lives in Agents.memory.
+  memory: {
+    get: (id: string) => http.get<{ body: string; path: string }>(`/projects/${id}/memory`),
+    put: (id: string, body: string) => http.put<{ ok: boolean; bytes: number }>(`/projects/${id}/memory`, { body }),
+  },
+};

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

@@ -0,0 +1,14 @@
+import { http } from "../http";
+import type { RoutineEntry } from "../../types/daemon";
+
+export const Routines = {
+  list:    (pid: string) => http.get<RoutineEntry[]>(`/projects/${pid}/routines`),
+  get:     (pid: string, name: string) => http.get<RoutineEntry>(`/projects/${pid}/routines/${name}`),
+  run:     (pid: string, name: string) => http.post<unknown>(`/projects/${pid}/routines/${name}/run`),
+  enable:  (pid: string, name: string) => http.post<unknown>(`/projects/${pid}/routines/${name}/enable`),
+  disable: (pid: string, name: string) => http.post<unknown>(`/projects/${pid}/routines/${name}/disable`),
+  upsert:  (pid: string, body: Partial<RoutineEntry>) =>
+    http.post<RoutineEntry>(`/projects/${pid}/routines`, body),
+  remove:  (pid: string, name: string) =>
+    http.del<void>(`/projects/${pid}/routines/${encodeURIComponent(name)}`),
+};