quoxcli 0.0.0-stage → 0.2.0

package/lib/api/endpoints/agent-attach.js

@@ -0,0 +1,126 @@
+/**
+ * 'agent-attach.*' endpoints — QUOXIDENTITY P1 (docs/QUOXIDENTITY_P1_CONTRACT.md,
+ * territory C). Lease lifecycle lives on the auth service (services/auth,
+ * territory A); the attach kit is served by the collector (services/collector,
+ * territory B) and is fetched with the short-TTL attach JWT, not the caller's
+ * normal session token.
+ *
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const agentAttach = {
+  'agent-attach.lease.create': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ agentId }) => `/api/agent-attach/${encodeURIComponent(agentId)}/lease`,
+    tags: ['live-write'],
+  },
+  'agent-attach.lease.heartbeat': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ leaseId }) => `/api/agent-attach/lease/${encodeURIComponent(leaseId)}/heartbeat`,
+    tags: ['live-write'],
+  },
+  'agent-attach.lease.release': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ leaseId }) => `/api/agent-attach/lease/${encodeURIComponent(leaseId)}/release`,
+    tags: ['live-write'],
+  },
+  'agent-attach.status': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ agentId }) => `/api/agent-attach/${encodeURIComponent(agentId)}/status`,
+    tags: ['live-safe'],
+  },
+  // P1 grant model (owner decision: per-agent grant, default owner-only). The
+  // auth routes exist server-side; these fragments + the grant/revoke/list
+  // verbs are what make them reachable. Org owner/admin only.
+  'agent-attach.grants.add': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ agentId }) => `/api/agent-attach/${encodeURIComponent(agentId)}/grants`,
+    tags: ['live-write'],
+  },
+  'agent-attach.grants.remove': {
+    method: 'DELETE',
+    service: 'auth',
+    path: ({ agentId, granteeUserId }) =>
+      `/api/agent-attach/${encodeURIComponent(agentId)}/grants/${encodeURIComponent(granteeUserId)}`,
+    tags: ['live-write'],
+  },
+  'agent-attach.grants.list': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ agentId }) => `/api/agent-attach/${encodeURIComponent(agentId)}/grants`,
+    tags: ['live-safe'],
+  },
+  // QUOXIDENTITY P10: roster-wide (attach-any) grant. Org owner/admin only.
+  'agent-attach.grants.add-all': {
+    method: 'POST',
+    service: 'auth',
+    path: () => `/api/agent-attach/grants/all`,
+    tags: ['live-write'],
+  },
+  'agent-attach.grants.remove-all': {
+    method: 'DELETE',
+    service: 'auth',
+    path: ({ granteeUserId }) => `/api/agent-attach/grants/all/${encodeURIComponent(granteeUserId)}`,
+    tags: ['live-write'],
+  },
+  // Served by the collector, not auth: the kit is fetched with the attach
+  // JWT (Authorization header set explicitly by the caller via noAuth+headers),
+  // never the caller's own session token.
+  'agent-attach.kit': {
+    method: 'GET',
+    service: 'collector',
+    path: () => `/api/v1/agent-attach/kit`,
+    tags: ['live-safe'],
+  },
+  // P2 (docs/QUOXIDENTITY_P2_CONTRACT.md, territory D/E): stores a handoff
+  // note before the CLI releases the lease, so the next session attached to
+  // this agent resumes with continuity. Same gate shape as the kit route:
+  // attach-lease-bearing callers only, authenticated with the attach JWT.
+  'agent-attach.handoff': {
+    method: 'POST',
+    service: 'collector',
+    path: () => `/api/v1/agent-attach/handoff`,
+    tags: ['live-write'],
+  },
+  // P4 (docs/QUOXIDENTITY_P4_CONTRACT.md §5): detach witnessing symmetry.
+  // Witness-only: does NOT release the lease (auth, territory A, owns lease
+  // state). Same gate shape as the kit/handoff routes: attach-lease-bearing
+  // callers only, authenticated with the attach JWT. The CLI posts this
+  // between releasing a checked-out slot and releasing the lease.
+  'agent-attach.detach': {
+    method: 'POST',
+    service: 'collector',
+    path: () => `/api/v1/agent-attach/detach`,
+    tags: ['live-write'],
+  },
+  // P3 (docs/QUOXIDENTITY_P3_CONTRACT.md, territory F/G): binding an agent
+  // identity to a durable slot ADDRESS (dev_slots row). Served by the
+  // collector next to the kit route, same auth gate pattern. PUT/DELETE are
+  // org admin only (binding an address is an admin act); GET is open to any
+  // org member or an attach-token caller. Slot HTTP shapes themselves
+  // (checkout/release/say/etc.) are NOT duplicated here: the CLI reuses
+  // v1.slots.* from ./v1.js for those.
+  'agent-attach.slot-binding.set': {
+    method: 'PUT',
+    service: 'collector',
+    path: ({ agentId }) => `/api/v1/agent-attach/${encodeURIComponent(agentId)}/slot-binding`,
+    tags: ['live-write'],
+  },
+  'agent-attach.slot-binding.delete': {
+    method: 'DELETE',
+    service: 'collector',
+    path: ({ agentId }) => `/api/v1/agent-attach/${encodeURIComponent(agentId)}/slot-binding`,
+    tags: ['live-write'],
+  },
+  'agent-attach.slot-binding.get': {
+    method: 'GET',
+    service: 'collector',
+    path: ({ agentId }) => `/api/v1/agent-attach/${encodeURIComponent(agentId)}/slot-binding`,
+    tags: ['live-safe'],
+  },
+};

package/lib/api/endpoints/agents.js

@@ -0,0 +1,56 @@
+/**
+ * 'agents.*' endpoints — extracted from the former monolithic
+ * cli/lib/api/endpoints.js as part of the per-domain fragment split.
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const agents = {
+  'agents.create': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/agents`,
+    tags: ['live-write'],
+  },
+  'agents.delete': {
+    method: 'DELETE',
+    service: 'auth',
+    path: ({ orgId, agentId }) => `/api/orgs/${orgId}/agents/${agentId}`,
+    tags: ['live-write'],
+  },
+  'agents.get': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId, agentId }) => `/api/orgs/${orgId}/agents/${agentId}`,
+    tags: ['live-safe'],
+  },
+  'agents.list': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/agents`,
+    tags: ['live-safe'],
+  },
+  'agents.tools.create': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId, agentId }) => `/api/orgs/${orgId}/agents/${agentId}/tools`,
+    tags: ['live-write'],
+  },
+  'agents.tools.delete': {
+    method: 'DELETE',
+    service: 'auth',
+    path: ({ orgId, agentId, id }) => `/api/orgs/${orgId}/agents/${agentId}/tools/${id}`,
+    tags: ['live-write'],
+  },
+  'agents.tools.list': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId, agentId }) => `/api/orgs/${orgId}/agents/${agentId}/tools`,
+    tags: ['live-safe'],
+  },
+  'agents.update': {
+    method: 'PATCH',
+    service: 'auth',
+    path: ({ orgId, agentId }) => `/api/orgs/${orgId}/agents/${agentId}`,
+    tags: ['live-write'],
+  },
+};

package/lib/api/endpoints/assistants.js

@@ -0,0 +1,50 @@
+/**
+ * 'assistants.*' endpoints — extracted from the former monolithic
+ * cli/lib/api/endpoints.js as part of the per-domain fragment split.
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const assistants = {
+  'assistants.create': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/assistants`,
+    tags: ['live-write'],
+  },
+  'assistants.delete': {
+    method: 'DELETE',
+    service: 'auth',
+    path: ({ orgId, assistantId }) => `/api/orgs/${orgId}/assistants/${assistantId}`,
+    tags: ['live-write'],
+  },
+  'assistants.deploy': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId, assistantId }) => `/api/orgs/${orgId}/assistants/${assistantId}/deploy`,
+    tags: ['live-write'],
+  },
+  'assistants.fork': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId, assistantId }) => `/api/orgs/${orgId}/assistants/${assistantId}/fork`,
+    tags: ['live-write'],
+  },
+  'assistants.get': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId, assistantId }) => `/api/orgs/${orgId}/assistants/${assistantId}`,
+    tags: ['live-safe'],
+  },
+  'assistants.list': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/assistants`,
+    tags: ['live-safe'],
+  },
+  'assistants.update': {
+    method: 'PATCH',
+    service: 'auth',
+    path: ({ orgId, assistantId }) => `/api/orgs/${orgId}/assistants/${assistantId}`,
+    tags: ['live-write'],
+  },
+};

package/lib/api/endpoints/audit.js

@@ -0,0 +1,14 @@
+/**
+ * 'audit.*' endpoints — extracted from the former monolithic
+ * cli/lib/api/endpoints.js as part of the per-domain fragment split.
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const audit = {
+  'audit.list': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/audit`,
+    tags: ['live-safe'],
+  },
+};

package/lib/api/endpoints/auth.js

@@ -0,0 +1,50 @@
+/**
+ * 'auth.*' endpoints — extracted from the former monolithic
+ * cli/lib/api/endpoints.js as part of the per-domain fragment split.
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const auth = {
+  'auth.me.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/auth/me`,
+    tags: ['live-safe'],
+  },
+  // QuoxSound: the CLI writes the same server-side `soundProfile` preference
+  // the dashboard does (PATCH merges top-level preference namespaces).
+  'auth.me.update': {
+    method: 'PATCH',
+    service: 'auth',
+    path: () => `/api/auth/me`,
+    tags: ['live-write'],
+  },
+  // fleet #390: PATCH /me/password already existed and worked, but nothing
+  // in the CLI exposed it, so rotating your own password meant hand-rolling
+  // a curl with a bearer token.
+  'auth.me.password': {
+    method: 'PATCH',
+    service: 'auth',
+    path: () => `/api/auth/me/password`,
+    tags: ['live-write'],
+  },
+  'auth.signup': {
+    method: 'POST',
+    service: 'auth',
+    path: () => `/api/auth/signup`,
+    tags: ['live-write'],
+  },
+  // QUOXON-C2c: one-time dashboard sign-in link (10 min, single-use, user+org bound).
+  'auth.login-link': {
+    method: 'POST',
+    service: 'auth',
+    path: () => `/api/auth/login-link`,
+    tags: ['live-write'],
+  },
+  'auth.switch-org': {
+    method: 'POST',
+    service: 'auth',
+    path: () => `/api/auth/switch-org`,
+    tags: ['live-write'],
+  },
+};

package/lib/api/endpoints/awareness.js

@@ -0,0 +1,34 @@
+/**
+ * 'awareness.*' endpoints: QuoxAwareness ledger (cross-surface situational awareness).
+ * Collector routes: POST/GET /api/v1/awareness, GET /api/v1/awareness/summary,
+ * DELETE /api/v1/awareness/:key. Org-scoped, requireServiceOrUserAuth.
+ *
+ * See cli/lib/api/endpoints/index.js for the fragment convention.
+ */
+
+export const awareness = {
+  'awareness.post': {
+    method: 'POST',
+    service: 'collector',
+    path: () => `/api/v1/awareness`,
+    tags: ['live-write'],
+  },
+  'awareness.list': {
+    method: 'GET',
+    service: 'collector',
+    path: () => `/api/v1/awareness`,
+    tags: ['live-safe'],
+  },
+  'awareness.summary': {
+    method: 'GET',
+    service: 'collector',
+    path: () => `/api/v1/awareness/summary`,
+    tags: ['live-safe'],
+  },
+  'awareness.remove': {
+    method: 'DELETE',
+    service: 'collector',
+    path: ({ key }) => `/api/v1/awareness/${encodeURIComponent(key)}`,
+    tags: ['live-write'],
+  },
+};

package/lib/api/endpoints/backup-schedules.js

@@ -0,0 +1,20 @@
+/**
+ * 'backup-schedules.*' endpoints — extracted from the former monolithic
+ * cli/lib/api/endpoints.js as part of the per-domain fragment split.
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const backupSchedules = {
+  'backup-schedules.create': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/backup-schedules`,
+    tags: ['live-write'],
+  },
+  'backup-schedules.list': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/backup-schedules`,
+    tags: ['live-safe'],
+  },
+};

package/lib/api/endpoints/backups.js

@@ -0,0 +1,86 @@
+/**
+ * 'backups.*' endpoints — extracted from the former monolithic
+ * cli/lib/api/endpoints.js as part of the per-domain fragment split.
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const backups = {
+  'backups.create': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/backups`,
+    tags: ['live-write'],
+  },
+  'backups.delete': {
+    method: 'DELETE',
+    service: 'auth',
+    path: ({ orgId, backupId }) => `/api/orgs/${orgId}/backups/${backupId}`,
+    tags: ['live-write'],
+  },
+  'backups.get': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId, backupId }) => `/api/orgs/${orgId}/backups/${backupId}`,
+    tags: ['live-safe'],
+  },
+  'backups.list': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ orgId }) => `/api/orgs/${orgId}/backups`,
+    tags: ['live-safe'],
+  },
+  'backups.restore': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId, backupId }) => `/api/orgs/${orgId}/backups/${backupId}/restore`,
+    tags: ['live-write'],
+  },
+  'backups.verify': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ orgId, backupId }) => `/api/orgs/${orgId}/backups/${backupId}/verify`,
+    tags: ['live-write'],
+  },
+
+  // ── G2d slice 3: the INSTANCE-ADMIN, SERVER-WIDE lane ───────────────────
+  // Everything above is the per-ORG tenant lane (:orgId scoped). These are
+  // the whole-box lane behind services/auth/routes/admin-backups.js: no org
+  // in the path, instance-admin only, and the work runs on the governed
+  // host-side runner. Driven by `quox backup server …`.
+  'backups.server.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => '/api/admin/backups',
+    tags: ['live-safe'],
+  },
+  'backups.server.status': {
+    method: 'GET',
+    service: 'auth',
+    path: () => '/api/admin/backups/status',
+    tags: ['live-safe'],
+  },
+  'backups.server.create': {
+    method: 'POST',
+    service: 'auth',
+    path: () => '/api/admin/backups',
+    tags: ['live-write'],
+  },
+  'backups.server.download': {
+    method: 'GET',
+    service: 'auth',
+    path: ({ archiveId }) => `/api/admin/backups/${encodeURIComponent(archiveId)}/download`,
+    tags: ['live-safe'],
+  },
+  'backups.server.restore': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ archiveId }) => `/api/admin/backups/${encodeURIComponent(archiveId)}/restore`,
+    tags: ['live-write'],
+  },
+  'backups.server.restoreStatus': {
+    method: 'GET',
+    service: 'auth',
+    path: () => '/api/admin/backups/restore-status',
+    tags: ['live-safe'],
+  },
+};

package/lib/api/endpoints/brain.js

@@ -0,0 +1,140 @@
+/**
+ * 'brain.*' endpoints — Quox Qortex (services/quoxbrain, port 3106).
+ * Mirrors the 'memory.*' fragment (./memory.js) convention. See
+ * cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ *
+ * Route confirmation (services/quoxbrain/server.js): brain.search.list is a
+ * POST (not GET) — the route takes { query, limit, offset, ... } in the
+ * request body, not a query string. Response shape: { results, tookMs }.
+ */
+
+export const brain = {
+  'brain.note.get': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: ({ id }) => `/notes/${id}`,
+    tags: ['live-safe'],
+  },
+  'brain.search.list': {
+    method: 'POST',
+    service: 'quoxbrain',
+    path: () => `/brain/search`,
+    tags: ['live-safe'],
+  },
+  // ONE-BRAIN CX2: token-budgeted context pack. Body { query, tokenBudget? };
+  // shape { passages, tokensUsed, insufficient, relevance, retrieval }.
+  'brain.context.pack': {
+    method: 'POST',
+    service: 'quoxbrain',
+    path: () => `/brain/context`,
+    tags: ['live-safe'],
+  },
+  // BRAIN2-V3 A2: capture a note into the caller's NotesQ vault
+  // (services/quoxbrain/lib/capture.js). Body { text?, title?, url?, tags? };
+  // shape { noteId, status: created|updated|unchanged, title }.
+  'brain.capture.create': {
+    method: 'POST',
+    service: 'quoxbrain',
+    path: () => `/brain/capture`,
+    tags: ['write'],
+  },
+  'brain.status.list': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/brain/status`,
+    tags: ['live-safe'],
+  },
+  // BRAIN2-AUDIT: the usage ledger (services/quoxbrain/server.js
+  // GET /brain/usage, org-scoped by the authenticate middleware) — "is it
+  // used?" as a visible number. Shape: { week, total, lastAgentQueryAt,
+  // lastSearchAt }, each period carrying per-surface counts plus a
+  // byExternalSource breakdown.
+  'brain.usage.list': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/brain/usage`,
+    tags: ['live-safe'],
+  },
+  // BRAIN2-W13 A 118: durable per-turn citation records (GET /brain/citations?session=&limit=).
+  'brain.citations.list': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/brain/citations`,
+    tags: ['live-safe'],
+  },
+  // ONE-BRAIN CX5: relevance judgements (the labelled eval set).
+  'brain.judgements.create': {
+    method: 'POST',
+    service: 'quoxbrain',
+    path: () => `/brain/judgements`,
+    tags: ['write'],
+  },
+  'brain.judgements.list': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/brain/judgements`,
+    tags: ['live-safe'],
+  },
+  // ONE-BRAIN CX6: topic subscriptions ("tell my slot when new notes about X land").
+  'brain.subscriptions.create': {
+    method: 'POST',
+    service: 'quoxbrain',
+    path: () => `/brain/subscriptions`,
+    tags: ['write'],
+  },
+  // ONE-BRAIN CX6: the Feed's source registry (collector feedApiHandlers.js).
+  'brain.sources.list': {
+    method: 'GET',
+    service: 'collector',
+    path: () => `/api/feed/sources`,
+    tags: ['live-safe'],
+  },
+  'brain.sources.update': {
+    method: 'PUT',
+    service: 'collector',
+    path: ({ type }) => `/api/feed/sources/${encodeURIComponent(type)}`,
+    tags: ['write'],
+  },
+  'brain.subscriptions.list': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/brain/subscriptions`,
+    tags: ['live-safe'],
+  },
+  'brain.subscriptions.delete': {
+    method: 'DELETE',
+    service: 'quoxbrain',
+    path: ({ id }) => `/brain/subscriptions/${encodeURIComponent(id)}`,
+    tags: ['write'],
+  },
+  // BRAIN2-AUDIT: "Ask Qortex" starter questions generated from the caller's
+  // own corpus (services/quoxbrain/lib/suggestions.js, GET /brain/suggestions).
+  // Shape: { suggestions:[{question,reason,source,noteId}], message?, generatedAt }.
+  'brain.suggestions.list': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/brain/suggestions`,
+    tags: ['live-safe'],
+  },
+  // BRAIN2-V3 B3: daily brief (services/quoxbrain/lib/brief.js, GET /brain/brief?since=24h).
+  'brain.brief.get': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/brain/brief`,
+    tags: ['live-safe'],
+  },
+  // BRAIN2-W8: portable export of the caller's visible notes (services/quoxbrain
+  // GET /export). ?format=jsonl (default, application/x-ndjson) | markdown (tar).
+  'brain.export.get': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/export`,
+    tags: ['live-safe'],
+  },
+  'brain.vaults.list': {
+    method: 'GET',
+    service: 'quoxbrain',
+    path: () => `/vaults`,
+    tags: ['live-safe'],
+  },
+};

package/lib/api/endpoints/budgets.js

@@ -0,0 +1,62 @@
+/**
+ * 'budgets.*' endpoints — WP3.2 (docs/STREAM_CLI_PARITY_PLAN.md §2.3 #7).
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ *
+ * Backend: quoxflow (NOT the auth service, NOT proxied by collector) —
+ * quoxflow/src/api/routes/budgets.ts, mounted at `/api/budgets` (see
+ * quoxflow/src/api/app.ts). `service: 'quoxflow'` resolves via the
+ * SERVICE_PORTS.quoxflow=3200 entry (see cli/lib/api/endpoints/triggers.js
+ * header for the full access-path decision this fragment reuses).
+ *
+ * Org scoping is via `?org_id=` QUERY PARAM on GET (list/get/usage), NOT a
+ * path segment — unlike triggers.ts, this route IS org-checked server-side:
+ *   - list requires `org_id` (400 org_id_required if missing) and filters
+ *     `budgetStore.listBudgets({ org_id })` — no cross-tenant leak.
+ *   - get/usage: `org_id` is optional on the query, but if present is
+ *     checked against the budget's own `org_id` (403 forbidden on mismatch).
+ *     Omitting it entirely returns the budget regardless of owner org — the
+ *     CLI always sends org_id here to stay on the safe/scoped path.
+ *   - create: `org_id` required in the POST body.
+ *   - update (PATCH): `org_id` required in the body, checked against the
+ *     existing budget's org_id (403 on mismatch) before applying the patch.
+ *   - delete: `org_id` required in the body, checked the same way.
+ */
+
+export const budgets = {
+  'budgets.list': {
+    method: 'GET',
+    service: 'quoxflow',
+    path: () => `/api/budgets`,
+    tags: ['live-safe'],
+  },
+  'budgets.get': {
+    method: 'GET',
+    service: 'quoxflow',
+    path: ({ id }) => `/api/budgets/${id}`,
+    tags: ['live-safe'],
+  },
+  'budgets.create': {
+    method: 'POST',
+    service: 'quoxflow',
+    path: () => `/api/budgets`,
+    tags: ['live-write'],
+  },
+  'budgets.update': {
+    method: 'PATCH',
+    service: 'quoxflow',
+    path: ({ id }) => `/api/budgets/${id}`,
+    tags: ['live-write'],
+  },
+  'budgets.delete': {
+    method: 'DELETE',
+    service: 'quoxflow',
+    path: ({ id }) => `/api/budgets/${id}`,
+    tags: ['live-write'],
+  },
+  'budgets.usage': {
+    method: 'GET',
+    service: 'quoxflow',
+    path: ({ id }) => `/api/budgets/${id}/usage`,
+    tags: ['live-safe'],
+  },
+};