@gotcos/glasses-server 6.44.7 → 6.44.10

package/CHANGELOG.md

@@ -1,3 +1,56 @@
+## 6.44.10
+
+Ingest progress for COS Control.
+
+- `GET /api/context/graph/ingest/progress` (the bridge's `graph-ingest-progress`,
+  read-only): where the current or last Control-started run stands. The run's
+  total, how many are indexed and failed, the document in flight with its
+  estimated calls, the last eight outcomes with their seconds, the budget line,
+  the queue's pending count, and the log's last lines. A run started somewhere
+  else (a Claude session) holds the lock but writes no log here, so it reports
+  as `external` with the counts only. COS Control 0.5.195's Sync card polls it
+  every five seconds while the ingest lock is held.
+
+## 6.44.9
+
+Knowledge from zero: the setup path behind COS Control's Knowledge tab.
+
+- `GET /api/context/graph/setup` is the readiness checklist (`graph-setup-status`):
+  the LightRAG SDK, the model backend, the embedding key, the owner Mac, the
+  source folders, the queue and graph counts, today's budget, the scheduled
+  agent, and up to three sample documents ready to index.
+- `POST /api/context/graph/setup/sources` `{ action, path }` adds, removes,
+  enables or disables a source folder (`graph-setup-sources`); the list comes
+  back. `POST /api/context/graph/setup/owner` makes this Mac the ingestion
+  owner (`graph-setup-owner`).
+- `POST /api/context/graph/setup/sample` (202) queues up to three documents
+  from the enabled sources through the indexer's own dedup and starts one
+  bounded run (`graph-ingest-sample`); the reply names what was queued, what
+  was skipped and why, and the run's pid or the reason nothing started.
+- `POST /api/context/graph/ask` `{ q }` asks the graph one question
+  (`graph-ask`, hybrid mode, 150 s bound) and returns the answer with its
+  elapsed time. `POST /api/context/graph/setup/schedule` `{ enabled, interval_s }`
+  installs or removes the `com.cos.lightrag-ingest` agent on the owner Mac
+  (`graph-schedule`), logging under ~/Library/Logs/COS.
+- A replica answers 409 `not_owner` on every write; a bad field is a 400
+  before the bridge is called. Each person's graph, queue, owner file and
+  sources stay on their own Mac by construction.
+
+## 6.44.8
+
+One more learning write: start indexing the queue.
+
+- `POST /api/context/graph/ingest` with `{ "limit": 1..50 }` (default 10) asks
+  the bridge's `graph-ingest-start` to run one bounded, detached
+  `lightrag_indexer.py --process-queue --limit N` on the ingestion owner and
+  answers 202 at once with `{ started, pid, limit, pending, lock }`. Nothing
+  started is still a 202 with the reason as a flag: `already_running` (the
+  ingest lock is held by a Claude session, a scheduled run or a backup),
+  `nothing_pending`, or `budget_exhausted` with `{ used, cap }`. A replica
+  answers 409 `not_owner` with the owner host. The child stops on its own: the
+  limit, the daily call cap inside the indexer, and the lock it holds for the
+  run. COS Control 0.5.192's Sync card uses it for Index now.
+
 ## 6.44.7
 
 One learning write: a review decision.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.44.7",
+  "version": "6.44.10",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {

package/server/lib/cos-context-browser.ts

@@ -803,6 +803,158 @@ export function normalizeIndexBuildKickoff(value: unknown): { started: boolean;
   }
 }
 
+export const INGEST_LIMIT_DEFAULT = 10
+export const INGEST_LIMIT_MAX = 50
+
+export interface IngestKickoff {
+  started: boolean
+  already_running: boolean
+  nothing_pending: boolean
+  budget_exhausted: boolean
+  pid: number | null
+  limit: number | null
+  pending: number | null
+  lock: { state: string; owner_pid: number | null } | null
+  budget: { used: number; cap: number } | null
+}
+
+/** The bridge's `graph-ingest-start` answer, every flag a real boolean. */
+export function normalizeIngestKickoff(value: unknown): IngestKickoff {
+  const source = asRecord(value) ?? {}
+  const lock = asRecord(source.lock)
+  const budget = asRecord(source.budget)
+  return {
+    started: source.started === true,
+    already_running: source.already_running === true,
+    nothing_pending: source.nothing_pending === true,
+    budget_exhausted: source.budget_exhausted === true,
+    pid: integerOrAbsent(source.pid) ?? null,
+    limit: integerOrAbsent(source.limit) ?? null,
+    pending: integerOrAbsent(source.pending) ?? null,
+    lock: lock ? { state: stringOrAbsent(lock.state, 16) ?? 'unknown', owner_pid: integerOrAbsent(lock.owner_pid) ?? null } : null,
+    budget: budget && integerOrAbsent(budget.used) !== undefined && integerOrAbsent(budget.cap) !== undefined
+      ? { used: integerOrAbsent(budget.used)!, cap: integerOrAbsent(budget.cap)! } : null,
+  }
+}
+
+export const KNOWLEDGE_SETUP_SAMPLE_MAX = 3
+
+/**
+ * A folder or file path the user chose for the setup path. Unlike
+ * `stringOrAbsent`, which hides local paths from surfaces that must not leak
+ * them, this keeps the path: COS Control shows it back to the person who
+ * picked it, on the Mac it lives on.
+ */
+function chosenPathOrAbsent(value: unknown, max = 1000): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed.slice(0, max) : undefined
+}
+export const KNOWLEDGE_ASK_MAX_CHARS = 400
+
+export interface KnowledgeSetupCheck { id: string; ok: boolean; detail: string }
+export interface KnowledgeSetupSource { path: string; enabled: boolean; exists: boolean; files: number | null; added_at: string | null }
+
+/** `graph-setup-status`: the checklist behind the Knowledge setup path. */
+export function normalizeKnowledgeSetup(value: unknown): Record<string, unknown> {
+  const s = asRecord(value) ?? {}
+  const owner = asRecord(s.owner) ?? {}
+  const queue = asRecord(s.queue) ?? {}
+  const graph = asRecord(s.graph) ?? {}
+  const budget = asRecord(s.budget) ?? {}
+  const schedule = asRecord(s.schedule) ?? {}
+  const sample = asRecord(s.sample) ?? {}
+  const checks: KnowledgeSetupCheck[] = (Array.isArray(s.checks) ? s.checks : []).flatMap((row) => {
+    const r = asRecord(row); if (!r) return []
+    const id = stringOrAbsent(r.id, 40); if (!id) return []
+    return [{ id, ok: r.ok === true, detail: stringOrAbsent(r.detail, 400) ?? '' }]
+  })
+  return {
+    ready: checks.length > 0 && checks.every(c => c.ok),
+    checks,
+    owner: {
+      owner_host: stringOrAbsent(owner.owner_host, 120) ?? null,
+      this_host: stringOrAbsent(owner.this_host, 120) ?? null,
+      is_owner: owner.is_owner === true,
+      source: stringOrAbsent(owner.source, 16) ?? 'none',
+    },
+    sources: normalizeKnowledgeSources(s.sources),
+    queue: { pending: integerOrAbsent(queue.pending) ?? null, indexed: integerOrAbsent(queue.indexed) ?? null },
+    graph: { entities: integerOrAbsent(graph.entities) ?? null, relationships: integerOrAbsent(graph.relationships) ?? null },
+    budget: { used: integerOrAbsent(budget.used) ?? null, cap: integerOrAbsent(budget.cap) ?? null },
+    schedule: { installed: schedule.installed === true, interval_s: integerOrAbsent(schedule.interval_s) ?? null, plist: chosenPathOrAbsent(schedule.plist, 400) ?? null },
+    sample: {
+      candidates: (Array.isArray(sample.candidates) ? sample.candidates : []).flatMap((row) => {
+        const r = asRecord(row); const path = r ? chosenPathOrAbsent(r.path) : undefined
+        return path ? [{ path, bytes: integerOrAbsent(r!.bytes) ?? null }] : []
+      }).slice(0, KNOWLEDGE_SETUP_SAMPLE_MAX),
+      queued: integerOrAbsent(sample.queued) ?? 0,
+      indexed: integerOrAbsent(sample.indexed) ?? 0,
+    },
+    lock: normalizeIngestKickoff({ lock: s.lock }).lock,
+    ask_ready: s.ask_ready === true,
+    protocol: integerOrAbsent(s.protocol) ?? null,
+  }
+}
+
+export function normalizeKnowledgeSources(value: unknown): KnowledgeSetupSource[] {
+  return (Array.isArray(value) ? value : []).flatMap((row) => {
+    const r = asRecord(row); if (!r) return []
+    const path = chosenPathOrAbsent(r.path); if (!path) return []
+    return [{ path, enabled: r.enabled !== false, exists: r.exists !== false, files: integerOrAbsent(r.files) ?? null, added_at: isoOrAbsent(r.added_at) ?? null }]
+  })
+}
+
+/** `graph-ingest-sample`: what was queued, what was not, and whether a run started. */
+export function normalizeSampleKickoff(value: unknown): Record<string, unknown> {
+  const s = asRecord(value) ?? {}
+  const rows = (key: string, extra: string) => (Array.isArray(s[key]) ? (s[key] as unknown[]) : []).flatMap((row) => {
+    const r = asRecord(row); const path = r ? chosenPathOrAbsent(r.path) : undefined
+    return path ? [{ path, [extra]: stringOrAbsent(r![extra], 200) ?? null }] : []
+  })
+  return { ...normalizeIngestKickoff(s), queued: rows('queued', 'id'), skipped: rows('skipped', 'reason') }
+}
+
+/** `graph-ask`: one answer from the graph, bounded. */
+export function normalizeGraphAnswer(value: unknown): { question: string; mode: string; answer: string; elapsed_s: number | null } | null {
+  const s = asRecord(value) ?? {}
+  const answer = typeof s.answer === 'string' ? s.answer.slice(0, 20_000) : null
+  if (answer === null) return null
+  return { question: stringOrAbsent(s.question, KNOWLEDGE_ASK_MAX_CHARS) ?? '', mode: stringOrAbsent(s.mode, 16) ?? 'hybrid', answer, elapsed_s: typeof s.elapsed_s === 'number' && Number.isFinite(s.elapsed_s) ? s.elapsed_s : null }
+}
+
+export interface IngestProgressItem { id: string; outcome: 'indexed' | 'failed' | 'unknown'; seconds: number | null; reason: string | null }
+
+/** `graph-ingest-progress`: where the current or last Control-started run stands. */
+export function normalizeIngestProgress(value: unknown): Record<string, unknown> {
+  const s = asRecord(value) ?? {}
+  const current = asRecord(s.current)
+  const budget = asRecord(s.budget)
+  const items: IngestProgressItem[] = (Array.isArray(s.items) ? s.items : []).flatMap((row) => {
+    const r = asRecord(row); const id = r ? stringOrAbsent(r.id, 200) : undefined
+    if (!id) return []
+    const outcome: IngestProgressItem['outcome'] = r!.outcome === 'indexed' ? 'indexed' : r!.outcome === 'failed' ? 'failed' : 'unknown'
+    return [{ id, outcome, seconds: typeof r!.seconds === 'number' && Number.isFinite(r!.seconds) ? r!.seconds : null, reason: stringOrAbsent(r!.reason, 200) ?? null }]
+  }).slice(-8)
+  return {
+    running: s.running === true,
+    pid: integerOrAbsent(s.pid) ?? null,
+    external: s.external === true,
+    pending: integerOrAbsent(s.pending) ?? null,
+    total: integerOrAbsent(s.total) ?? null,
+    done: integerOrAbsent(s.done) ?? 0,
+    failed: integerOrAbsent(s.failed) ?? 0,
+    current: current && stringOrAbsent(current.id, 200) ? { id: stringOrAbsent(current.id, 200)!, est_calls: integerOrAbsent(current.est_calls) ?? null } : null,
+    items,
+    remaining_calls: integerOrAbsent(s.remaining_calls) ?? null,
+    budget: budget && integerOrAbsent(budget.used) !== undefined && integerOrAbsent(budget.cap) !== undefined ? { used: integerOrAbsent(budget.used)!, cap: integerOrAbsent(budget.cap)! } : null,
+    ended: s.ended === true,
+    log_tail: (Array.isArray(s.log_tail) ? s.log_tail : []).filter((l): l is string => typeof l === 'string').map(l => l.slice(0, 300)).slice(-24),
+    log_age_s: typeof s.log_age_s === 'number' && Number.isFinite(s.log_age_s) ? s.log_age_s : null,
+    lock: normalizeIngestKickoff({ lock: s.lock }).lock,
+  }
+}
+
 export function normalizeContextBrowserStatus(value: unknown): ContextBrowserStatus {
   const source = value && typeof value === 'object' && !Array.isArray(value)
     ? value as Record<string, unknown> : {}

package/server/lib/python-bridge.ts

@@ -57,6 +57,14 @@ export const LEARNING_COMMANDS = [
   'graph-index-build',
   'learning-to-review',
   'learning-decide',
+  'graph-ingest-start',
+  'graph-setup-status',
+  'graph-setup-sources',
+  'graph-setup-owner',
+  'graph-ingest-sample',
+  'graph-ask',
+  'graph-schedule',
+  'graph-ingest-progress',
 ] as const
 
 // The optional Python bridge is available only when the user points us at a real
@@ -230,6 +238,14 @@ function standaloneNoop(args: string[]): unknown {
     case 'graph-index-build':
     case 'learning-to-review':
     case 'learning-decide':
+    case 'graph-ingest-start':
+    case 'graph-setup-status':
+    case 'graph-setup-sources':
+    case 'graph-setup-owner':
+    case 'graph-ingest-sample':
+    case 'graph-ask':
+    case 'graph-schedule':
+    case 'graph-ingest-progress':
       return { error: 'cos_pipeline_not_configured' }
     case 'task-rows':
     case 'task-capture':

package/server/routes/memory.ts

@@ -22,6 +22,16 @@ import { normalizeReviewDecision, LEARNING_REVIEW_LIMIT,
   normalizeGraphSearch,
   normalizeGraphStatus,
   normalizeIndexBuildKickoff,
+  normalizeIngestKickoff,
+  INGEST_LIMIT_DEFAULT,
+  INGEST_LIMIT_MAX,
+  normalizeKnowledgeSetup,
+  normalizeKnowledgeSources,
+  normalizeSampleKickoff,
+  normalizeGraphAnswer,
+  normalizeIngestProgress,
+  KNOWLEDGE_SETUP_SAMPLE_MAX,
+  KNOWLEDGE_ASK_MAX_CHARS,
   normalizeLearningEventDetail,
   normalizeLearningEvents,
   normalizeLearningStatus,
@@ -303,6 +313,180 @@ memoryRouter.post('/context/graph/index', async (_req, res) => {
   }
 })
 
+/**
+ * 202 Accepted: start ONE bounded, detached queue ingest on the ingestion
+ * owner (`lightrag_indexer.py --process-queue --limit N`). The bridge command
+ * only spawns and answers, so this never holds the ingest lock or waits on a
+ * model call. A replica answers 409 `not_owner`; a held lock, an empty queue
+ * or a spent daily budget come back as a 202 whose flags say why nothing
+ * started. Poll GET /context/graph/status for `lock.state` and `queue.pending`.
+ */
+memoryRouter.post('/context/graph/ingest', async (req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  const raw = (req.body as { limit?: unknown } | undefined)?.limit
+  const limit = raw === undefined || raw === null ? INGEST_LIMIT_DEFAULT : Number(raw)
+  if (!Number.isInteger(limit) || limit < 1 || limit > INGEST_LIMIT_MAX) {
+    res.status(400).json({ error: 'invalid_limit', message: `limit must be an integer from 1 to ${INGEST_LIMIT_MAX}` })
+    return
+  }
+  try {
+    const data = await callPython(['graph-ingest-start', `--limit=${limit}`, '--reason=control'], 5_000)
+    const code = bridgeErrorCode(data)
+    if (code === 'not_owner') {
+      const detail = data as { message?: unknown; owner_host?: unknown }
+      res.status(409).json({ error: code, message: typeof detail.message === 'string' ? detail.message : undefined, owner_host: typeof detail.owner_host === 'string' ? detail.owner_host : null })
+      return
+    }
+    if (code) { res.status(code.startsWith('invalid_') ? 400 : 503).json({ error: code }); return }
+    res.status(202).json(normalizeIngestKickoff(data))
+  } catch (error) {
+    console.warn('[context] ingest bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+/** Where the current or last Control-started ingest stands (6.44.10). Read-only. */
+memoryRouter.get('/context/graph/ingest/progress', async (_req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  try {
+    const data = await callPython(['graph-ingest-progress'], 10_000)
+    const code = bridgeErrorCode(data)
+    if (code) { res.status(503).json({ error: code }); return }
+    res.json(normalizeIngestProgress(data))
+  } catch (error) {
+    console.warn('[context] progress bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+// ── Knowledge setup (6.44.9): from zero to a first index, in COS Control ──
+//
+// Six bridge commands behind one guided path: the readiness checklist, the
+// source folders, the owner Mac, three sample documents, one question, and
+// the scheduled batches. Every write is bounded and owner-only; a replica
+// answers 409 not_owner. Paths and questions ride as single argv tokens.
+
+/** Map a bridge error to the status the setup routes share. */
+function sendSetupError(res: import('express').Response, code: string, data: unknown): void {
+  const detail = asDetail(data)
+  if (code === 'not_owner') { res.status(409).json({ error: code, message: detail.message, owner_host: detail.owner_host ?? null }); return }
+  if (code.endsWith('_not_found')) { res.status(404).json({ error: code, message: detail.message }); return }
+  if (code.startsWith('invalid_')) { res.status(400).json({ error: code, message: detail.message }); return }
+  res.status(503).json({ error: code })
+}
+
+function asDetail(data: unknown): { message?: string; owner_host?: string } {
+  const d = (typeof data === 'object' && data !== null ? data : {}) as { message?: unknown; owner_host?: unknown }
+  return { message: typeof d.message === 'string' ? d.message : undefined, owner_host: typeof d.owner_host === 'string' ? d.owner_host : undefined }
+}
+
+memoryRouter.get('/context/graph/setup', async (_req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  try {
+    const data = await callPython(['graph-setup-status'], 20_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    res.json(normalizeKnowledgeSetup(data))
+  } catch (error) {
+    console.warn('[context] setup bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+/** `{ action: add | remove | enable | disable, path }` → the source list after the change. */
+memoryRouter.post('/context/graph/setup/sources', async (req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  const body = (req.body ?? {}) as { action?: unknown; path?: unknown }
+  const action = typeof body.action === 'string' ? body.action : ''
+  const path = typeof body.path === 'string' ? body.path.trim() : ''
+  if (!['add', 'remove', 'enable', 'disable'].includes(action)) { res.status(400).json({ error: 'invalid_action', message: 'action must be add, remove, enable or disable' }); return }
+  if (!path || path.length > 1000 || path.includes('\0')) { res.status(400).json({ error: 'invalid_path', message: 'path must be 1 to 1000 characters' }); return }
+  try {
+    const data = await callPython(['graph-setup-sources', `--action=${action}`, `--path=${path}`], 15_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    const source = data as { sources?: unknown }
+    res.json({ sources: normalizeKnowledgeSources(source.sources) })
+  } catch (error) {
+    console.warn('[context] setup bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+memoryRouter.post('/context/graph/setup/owner', async (_req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  try {
+    const data = await callPython(['graph-setup-owner', '--this-mac'], 10_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    res.json(normalizeKnowledgeSetup({ owner: (data as { owner?: unknown }).owner }).owner === undefined ? {} : { owner: normalizeKnowledgeSetup(data).owner })
+  } catch (error) {
+    console.warn('[context] setup bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+/** 202: queue up to three sample documents from the enabled sources and start one bounded run. */
+memoryRouter.post('/context/graph/setup/sample', async (req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  const raw = (req.body as { limit?: unknown } | undefined)?.limit
+  const limit = raw === undefined || raw === null ? KNOWLEDGE_SETUP_SAMPLE_MAX : Number(raw)
+  if (!Number.isInteger(limit) || limit < 1 || limit > KNOWLEDGE_SETUP_SAMPLE_MAX) { res.status(400).json({ error: 'invalid_limit', message: `limit must be an integer from 1 to ${KNOWLEDGE_SETUP_SAMPLE_MAX}` }); return }
+  try {
+    const data = await callPython(['graph-ingest-sample', `--limit=${limit}`, '--reason=control'], 90_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    res.status(202).json(normalizeSampleKickoff(data))
+  } catch (error) {
+    console.warn('[context] sample bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+/** One question to the graph. Two model calls under the query budget; bounded to 150 s. */
+memoryRouter.post('/context/graph/ask', async (req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  const q = typeof (req.body as { q?: unknown } | undefined)?.q === 'string' ? ((req.body as { q: string }).q).trim() : ''
+  if (q.length < 3 || q.length > KNOWLEDGE_ASK_MAX_CHARS) { res.status(400).json({ error: 'invalid_query', message: `q must be 3 to ${KNOWLEDGE_ASK_MAX_CHARS} characters` }); return }
+  try {
+    const data = await callPython(['graph-ask', `--q=${q}`], 150_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    const answer = normalizeGraphAnswer(data)
+    if (!answer) { res.status(503).json({ error: 'graph_no_answer' }); return }
+    res.json(answer)
+  } catch (error) {
+    console.warn('[context] ask bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+/** `{ enabled, interval_s? }` → install or remove the scheduled batch agent on the owner Mac. */
+memoryRouter.post('/context/graph/setup/schedule', async (req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  const body = (req.body ?? {}) as { enabled?: unknown; interval_s?: unknown }
+  if (typeof body.enabled !== 'boolean') { res.status(400).json({ error: 'invalid_enabled', message: 'enabled must be true or false' }); return }
+  const interval = body.interval_s === undefined || body.interval_s === null ? 3600 : Number(body.interval_s)
+  if (!Number.isInteger(interval) || interval < 900 || interval > 86_400) { res.status(400).json({ error: 'invalid_interval', message: 'interval_s must be an integer from 900 to 86400' }); return }
+  try {
+    const data = await callPython(['graph-schedule', `--enabled=${body.enabled}`, `--interval-s=${interval}`], 20_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    res.json(normalizeKnowledgeSetup({ schedule: (data as { schedule?: unknown }).schedule ?? data }).schedule)
+  } catch (error) {
+    console.warn('[context] schedule bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
 function boundedInteger(value: unknown, fallback: number, min: number, max: number): number {
   const parsed = Number(value)
   if (!Number.isFinite(parsed)) return fallback