agent-remnote 0.4.1 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # agent-remnote
 
+## 0.4.2
+
+### Patch Changes
+
+- 1dfc8f0: Fix Host API write flows so requests using the default `ensureDaemon=true` path no longer fail from missing daemon runtime services.
+
+  Enable `rem outline` and `daily rem-id` over Host API, and make `apiBaseUrl` behave as a strict remote mode so local-only commands fail fast instead of silently reading local DB state.
+
 ## 0.4.1
 
 ### Patch Changes

package/dist/main.js

@@ -89911,35 +89911,97 @@ var QueueLive = succeed10(Queue, {
   })
 });
 
+// src/commands/_remoteMode.ts
+function normalizeHints(hints) {
+  if (!Array.isArray(hints))
+    return;
+  const out = hints.map((item) => String(item).trim()).filter(Boolean);
+  return out.length > 0 ? out : undefined;
+}
+function remoteModeUnsupportedError(params3) {
+  return new CliError({
+    code: "INVALID_ARGS",
+    message: `${params3.command} is unavailable when apiBaseUrl is configured: ${params3.reason}`,
+    exitCode: 2,
+    details: {
+      command: params3.command,
+      api_base_url: params3.apiBaseUrl,
+      reason: params3.reason
+    },
+    hint: normalizeHints([
+      "Run this command on the host if you need direct local DB access.",
+      ...params3.hints ?? []
+    ])
+  });
+}
+function failInRemoteMode(params3) {
+  return gen2(function* () {
+    const cfg = yield* AppConfig;
+    if (!cfg.apiBaseUrl)
+      return;
+    return yield* fail8(remoteModeUnsupportedError({
+      command: params3.command,
+      reason: params3.reason,
+      hints: params3.hints,
+      apiBaseUrl: cfg.apiBaseUrl
+    }));
+  });
+}
+
 // src/services/RemDb.ts
 class RemDb extends Tag2("RemDb")() {
 }
 var RemDbLive = succeed10(RemDb, {
-  withDb: (dbPath, fn) => tryPromise2({
-    try: async () => await withResolvedDatabase(dbPath, fn),
-    catch: (error4) => {
-      if (isCliError(error4))
-        return error4;
-      return new CliError({
-        code: "DB_UNAVAILABLE",
-        message: String(error4?.message || error4 || "RemNote DB is unavailable"),
-        exitCode: 1,
-        details: { db_path: dbPath }
-      });
+  withDb: (dbPath, fn) => gen2(function* () {
+    const cfg = yield* AppConfig;
+    if (cfg.apiBaseUrl) {
+      return yield* fail8(remoteModeUnsupportedError({
+        command: "local RemNote DB access",
+        reason: "this path still reads the local RemNote database directly",
+        hints: [
+          "Use a Host API backed read command instead.",
+          "If no remote endpoint exists yet, run the command on the host."
+        ],
+        apiBaseUrl: cfg.apiBaseUrl
+      }));
     }
+    return yield* tryPromise2({
+      try: async () => await withResolvedDatabase(dbPath, fn),
+      catch: (error4) => {
+        if (isCliError(error4))
+          return error4;
+        return new CliError({
+          code: "DB_UNAVAILABLE",
+          message: String(error4?.message || error4 || "RemNote DB is unavailable"),
+          exitCode: 1,
+          details: { db_path: dbPath }
+        });
+      }
+    });
   }),
-  backups: (basePath) => tryPromise2({
-    try: async () => await discoverBackups(basePath),
-    catch: (error4) => {
-      if (isCliError(error4))
-        return error4;
-      return new CliError({
-        code: "DB_UNAVAILABLE",
-        message: String(error4?.message || error4 || "Failed to read RemNote backup directory"),
-        exitCode: 1,
-        details: { base_path: basePath }
-      });
+  backups: (basePath) => gen2(function* () {
+    const cfg = yield* AppConfig;
+    if (cfg.apiBaseUrl) {
+      return yield* fail8(remoteModeUnsupportedError({
+        command: "db backups",
+        reason: "listing backup files requires direct local filesystem access",
+        hints: ["Run this command on the host."],
+        apiBaseUrl: cfg.apiBaseUrl
+      }));
     }
+    return yield* tryPromise2({
+      try: async () => await discoverBackups(basePath),
+      catch: (error4) => {
+        if (isCliError(error4))
+          return error4;
+        return new CliError({
+          code: "DB_UNAVAILABLE",
+          message: String(error4?.message || error4 || "Failed to read RemNote backup directory"),
+          exitCode: 1,
+          details: { base_path: basePath }
+        });
+      }
+    });
   })
 });
 
@@ -92678,6 +92740,10 @@ var days2 = integer7("days").pipe(optional5, map34(optionToUndefined9));
 var maxLines = integer7("max-lines").pipe(optional5, map34(optionToUndefined9));
 var dailySummaryCommand = exports_Command.make("summary", { days: days2, maxLines }, ({ days: days3, maxLines: maxLines2 }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "daily summary",
+    reason: "this command still summarizes Daily Notes from the local RemNote database"
+  });
   const result = yield* tryPromise2({
     try: async () => await executeSummarizeDailyNotes({
       dbPath: cfg.remnoteDb,
@@ -92689,6 +92755,180 @@ var dailySummaryCommand = exports_Command.make("summary", { days: days2, maxLine
   yield* writeSuccess({ data: result, md: result.markdown ?? "" });
 }).pipe(catchAll2(writeFailure)));
 
+// src/services/HostApiClient.ts
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.trim().replace(/\/+$/, "");
+}
+function apiTimeoutError(params3) {
+  return new CliError({
+    code: "API_TIMEOUT",
+    message: `API timeout after ${params3.timeoutMs}ms`,
+    exitCode: 1,
+    details: { base_url: params3.baseUrl, path: params3.path, timeout_ms: params3.timeoutMs }
+  });
+}
+function apiUnavailableError(params3) {
+  return new CliError({
+    code: "API_UNAVAILABLE",
+    message: String(params3.error?.message || params3.error || "API request failed"),
+    exitCode: 1,
+    details: { base_url: params3.baseUrl, path: params3.path }
+  });
+}
+function exitCodeFromRemoteCode(code2) {
+  return code2 === "INVALID_ARGS" ? 2 : 1;
+}
+function parseEnvelope(raw4) {
+  if (!raw4 || typeof raw4 !== "object") {
+    return { ok: false, error: { code: "INTERNAL", message: "Invalid API response envelope" } };
+  }
+  return raw4;
+}
+function buildQuery(params3) {
+  const sp = new URLSearchParams;
+  for (const [key, value8] of Object.entries(params3)) {
+    if (value8 === undefined || value8 === null)
+      continue;
+    if (typeof value8 === "string") {
+      if (!value8.trim())
+        continue;
+      sp.set(key, value8);
+      continue;
+    }
+    if (typeof value8 === "number" || typeof value8 === "boolean") {
+      sp.set(key, String(value8));
+    }
+  }
+  const query = sp.toString();
+  return query ? `?${query}` : "";
+}
+function requestJson(params3) {
+  const timeoutMs = Math.max(1, params3.timeoutMs ?? 15000);
+  const baseUrl = normalizeBaseUrl(params3.baseUrl);
+  const url2 = `${baseUrl}${params3.path}`;
+  return async((resume2) => {
+    const controller = new AbortController;
+    const timer2 = setTimeout(() => controller.abort(), timeoutMs);
+    fetch(url2, {
+      method: params3.method,
+      headers: params3.method === "POST" ? { "content-type": "application/json" } : undefined,
+      body: params3.body === undefined ? undefined : JSON.stringify(params3.body),
+      signal: controller.signal
+    }).then(async (response) => {
+      clearTimeout(timer2);
+      let parsed;
+      try {
+        parsed = parseEnvelope(await response.json());
+      } catch (error4) {
+        resume2(fail8(new CliError({
+          code: "API_UNAVAILABLE",
+          message: "API returned a non-JSON response",
+          exitCode: 1,
+          details: { url: url2, status: response.status, error: String(error4?.message || error4) }
+        })));
+        return;
+      }
+      if (parsed.ok === true) {
+        resume2(succeed8(parsed.data));
+        return;
+      }
+      const code2 = typeof parsed.error?.code === "string" ? parsed.error.code : "INTERNAL";
+      const message2 = typeof parsed.error?.message === "string" ? parsed.error.message : "API request failed";
+      const hint = Array.isArray(parsed.hint) ? parsed.hint.map(String) : undefined;
+      resume2(fail8(new CliError({
+        code: code2,
+        message: message2,
+        exitCode: exitCodeFromRemoteCode(code2),
+        details: parsed.error?.details,
+        hint
+      })));
+    }).catch((error4) => {
+      clearTimeout(timer2);
+      if (error4?.name === "AbortError") {
+        resume2(fail8(apiTimeoutError({ baseUrl, path: params3.path, timeoutMs })));
+        return;
+      }
+      resume2(fail8(apiUnavailableError({ baseUrl, path: params3.path, error: error4 })));
+    });
+    return sync3(() => {
+      clearTimeout(timer2);
+      controller.abort();
+    });
+  });
+}
+
+class HostApiClient extends Tag2("HostApiClient")() {
+}
+var HostApiClientLive = succeed10(HostApiClient, {
+  health: ({ baseUrl, timeoutMs }) => requestJson({ baseUrl, path: "/v1/health", method: "GET", timeoutMs }),
+  status: ({ baseUrl, timeoutMs }) => requestJson({ baseUrl, path: "/v1/status", method: "GET", timeoutMs }),
+  uiContextSnapshot: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/plugin/ui-context/snapshot${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  uiContextPage: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/plugin/ui-context/page${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  uiContextFocusedRem: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/plugin/ui-context/focused-rem${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  uiContextDescribe: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, selectionLimit, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/plugin/ui-context/describe${buildQuery({ stateFile: stateFile3, staleMs: staleMs2, selectionLimit })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  selectionSnapshot: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/plugin/selection/snapshot${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  selectionRoots: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/plugin/selection/roots${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  selectionCurrent: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/plugin/selection/current${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  pluginCurrent: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, selectionLimit, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/plugin/current${buildQuery({ stateFile: stateFile3, staleMs: staleMs2, selectionLimit })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  selectionOutline: ({ baseUrl, body, timeoutMs }) => requestJson({ baseUrl, path: "/v1/plugin/selection/outline", method: "POST", body, timeoutMs }),
+  uiContext: ({ baseUrl, timeoutMs }) => requestJson({ baseUrl, path: "/v1/ui-context", method: "GET", timeoutMs }),
+  selection: ({ baseUrl, timeoutMs }) => requestJson({ baseUrl, path: "/v1/selection", method: "GET", timeoutMs }),
+  searchDb: ({ baseUrl, ...body }) => requestJson({ baseUrl, path: "/v1/search/db", method: "POST", body }),
+  searchPlugin: ({ baseUrl, ...body }) => requestJson({ baseUrl, path: "/v1/search/plugin", method: "POST", body }),
+  writeOps: ({ baseUrl, body, timeoutMs }) => requestJson({ baseUrl, path: "/v1/write/ops", method: "POST", body, timeoutMs }),
+  writeMarkdown: ({ baseUrl, body, timeoutMs }) => requestJson({ baseUrl, path: "/v1/write/markdown", method: "POST", body, timeoutMs }),
+  readOutline: ({ baseUrl, body, timeoutMs }) => requestJson({ baseUrl, path: "/v1/read/outline", method: "POST", body, timeoutMs }),
+  dailyRemId: ({ baseUrl, date: date6, offsetDays, timeoutMs }) => requestJson({
+    baseUrl,
+    path: `/v1/daily/rem-id${buildQuery({ date: date6, offsetDays })}`,
+    method: "GET",
+    timeoutMs
+  }),
+  queueWait: ({ baseUrl, txnId, timeoutMs, pollMs }) => requestJson({ baseUrl, path: "/v1/queue/wait", method: "POST", body: { txnId, timeoutMs, pollMs } }),
+  queueTxn: ({ baseUrl, txnId, timeoutMs }) => requestJson({ baseUrl, path: `/v1/queue/txns/${encodeURIComponent(txnId)}`, method: "GET", timeoutMs }),
+  triggerSync: ({ baseUrl, timeoutMs }) => requestJson({ baseUrl, path: "/v1/actions/trigger-sync", method: "POST", timeoutMs })
+});
+
 // src/services/RefResolver.ts
 class RefResolver extends Tag2("RefResolver")() {
 }
@@ -92772,6 +93012,17 @@ var RefResolverLive = succeed10(RefResolver, {
       try: () => parseRef(ref),
       catch: (e) => e && typeof e === "object" && e._tag === "CliError" ? e : new CliError({ code: "INVALID_ARGS", message: `Invalid ref: ${ref}`, exitCode: 2 })
     });
+    if (cfg.apiBaseUrl && parsed.kind !== "id") {
+      return yield* fail8(remoteModeUnsupportedError({
+        command: `ref resolution (${ref})`,
+        reason: "this path still resolves refs by reading the local RemNote database",
+        hints: [
+          "Use a remote-capable command that accepts --ref and forwards it to the host API.",
+          "If no remote endpoint exists yet, run the command on the host."
+        ],
+        apiBaseUrl: cfg.apiBaseUrl
+      }));
+    }
     if (parsed.kind === "id")
       return parsed.value;
     const dailyOffset = parsed.kind === "daily" ? yield* try_3({
@@ -92816,10 +93067,15 @@ function optionToUndefined10(opt) {
   return isSome2(opt) ? opt.value : undefined;
 }
 function parseDateInput(raw4) {
-  const value8 = new Date(raw4);
+  const trimmed2 = raw4.trim();
+  const match24 = /^(\d{4})-(\d{2})-(\d{2})$/.exec(trimmed2);
+  const value8 = match24 ? new Date(Number(match24[1]), Number(match24[2]) - 1, Number(match24[3])) : new Date(trimmed2);
   if (Number.isNaN(value8.getTime())) {
     throw new CliError({ code: "INVALID_ARGS", message: `Invalid date: ${raw4}`, exitCode: 2 });
   }
+  if (match24 && (value8.getFullYear() !== Number(match24[1]) || value8.getMonth() !== Number(match24[2]) - 1 || value8.getDate() !== Number(match24[3]))) {
+    throw new CliError({ code: "INVALID_ARGS", message: `Invalid date: ${raw4}`, exitCode: 2 });
+  }
   return value8;
 }
 var date6 = text9("date").pipe(optional5, map34(optionToUndefined10));
@@ -92829,8 +93085,25 @@ var dailyRemIdCommand = exports_Command.make("rem-id", { date: date6, offsetDays
     return yield* fail8(new CliError({ code: "INVALID_ARGS", message: "Choose only one of --date or --offset-days", exitCode: 2 }));
   }
   const cfg = yield* AppConfig;
+  const hostApi = yield* HostApiClient;
   const refs = yield* RefResolver;
   const remDb = yield* RemDb;
+  if (cfg.apiBaseUrl) {
+    const data = yield* hostApi.dailyRemId({
+      baseUrl: cfg.apiBaseUrl,
+      date: date7,
+      offsetDays: offsetDays2
+    });
+    yield* writeSuccess({
+      data,
+      ids: [data.remId],
+      md: `- ref: ${data.ref}
+- rem_id: ${data.remId}${data.dateString ? `
+- date_string: ${data.dateString}` : ""}
+`
+    });
+    return;
+  }
   let ref = `daily:${offsetDays2 ?? 0}`;
   let remId = "";
   let dateString;
@@ -93466,10 +93739,15 @@ var bundleTitle = readOptionalText("bundle-title");
 var BULK_THRESHOLD_LINES = 80;
 var BULK_THRESHOLD_CHARS = 5000;
 function parseDateInput2(raw4) {
-  const d = new Date(raw4);
+  const trimmed2 = raw4.trim();
+  const match24 = /^(\d{4})-(\d{2})-(\d{2})$/.exec(trimmed2);
+  const d = match24 ? new Date(Number(match24[1]), Number(match24[2]) - 1, Number(match24[3])) : new Date(trimmed2);
   if (isNaN(d.getTime())) {
     throw new CliError({ code: "INVALID_ARGS", message: `Invalid date: ${raw4}`, exitCode: 2 });
   }
+  if (match24 && (d.getFullYear() !== Number(match24[1]) || d.getMonth() !== Number(match24[2]) - 1 || d.getDate() !== Number(match24[3]))) {
+    throw new CliError({ code: "INVALID_ARGS", message: `Invalid date: ${raw4}`, exitCode: 2 });
+  }
   return d;
 }
 function todayAtMidnight() {
@@ -93563,6 +93841,11 @@ var dailyWriteCommand = exports_Command.make("write", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "daily write",
+    reason: "this command still needs local Daily Note metadata before enqueueing writes",
+    hints: ["Use `import markdown --ref daily:today ...` in remote mode."]
+  });
   const fileInput = yield* FileInput;
   const payloadSvc = yield* Payload;
   const remDb = yield* RemDb;
@@ -93589,7 +93872,11 @@ var dailyWriteCommand = exports_Command.make("write", {
   const target2 = date8 ? yield* try_3({
     try: () => parseDateInput2(date8),
     catch: (e) => isCliError(e) ? e : new CliError({ code: "INVALID_ARGS", message: "Invalid date", exitCode: 2 })
-  }) : new Date(todayAtMidnight().getTime() + (offsetDays3 ?? 0) * 24 * 3600 * 1000);
+  }) : (() => {
+    const target3 = todayAtMidnight();
+    target3.setDate(target3.getDate() + (offsetDays3 ?? 0));
+    return target3;
+  })();
   const dateString = yield* remDb.withDb(cfg.remnoteDb, async (db) => {
     const fmt = await getDateFormatting(db) ?? "yyyy/MM/dd";
     return formatDateWithPattern(target2, fmt);
@@ -93668,21 +93955,27 @@ function optionToUndefined12(opt) {
 }
 var basePath = text9("base-path").pipe(optional5, map34(optionToUndefined12));
 var limit = integer7("limit").pipe(withDefault5(50));
-var dbBackupsCommand = exports_Command.make("backups", { basePath, limit }, ({ basePath: basePath2, limit: limit2 }) => tryPromise2({
-  try: async () => await executeListRemBackups({
-    basePath: basePath2 ? resolveUserFilePath(basePath2) : undefined,
-    limit: limit2
-  }),
-  catch: (e) => cliErrorFromUnknown(e, { code: "DB_UNAVAILABLE" })
-}).pipe(flatMap9((result) => {
+var dbBackupsCommand = exports_Command.make("backups", { basePath, limit }, ({ basePath: basePath2, limit: limit2 }) => gen2(function* () {
+  yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "db backups",
+    reason: "this command still lists local RemNote backup files from the filesystem"
+  });
+  const result = yield* tryPromise2({
+    try: async () => await executeListRemBackups({
+      basePath: basePath2 ? resolveUserFilePath(basePath2) : undefined,
+      limit: limit2
+    }),
+    catch: (e) => cliErrorFromUnknown(e, { code: "DB_UNAVAILABLE" })
+  });
   const md = [
     `- base_path: ${result.basePath}`,
     `- total: ${result.total}`,
     ...Array.isArray(result.items) ? result.items.map((it) => `- ${it.path}`) : []
   ].join(`
 `);
-  return writeSuccess({ data: result, md });
-}), catchAll2(writeFailure)));
+  yield* writeSuccess({ data: result, md });
+}).pipe(catchAll2(writeFailure)));
 
 // src/commands/read/db/recent.ts
 function optionToUndefined13(opt) {
@@ -94256,173 +94549,6 @@ var wechatOutlineCommand = exports_Command.make("outline", {
 // src/commands/write/wechat/index.ts
 var writeWechatCommand = exports_Command.make("wechat", {}).pipe(exports_Command.withSubcommands([wechatOutlineCommand]));
 
-// src/services/HostApiClient.ts
-function normalizeBaseUrl(baseUrl) {
-  return baseUrl.trim().replace(/\/+$/, "");
-}
-function apiTimeoutError(params3) {
-  return new CliError({
-    code: "API_TIMEOUT",
-    message: `API timeout after ${params3.timeoutMs}ms`,
-    exitCode: 1,
-    details: { base_url: params3.baseUrl, path: params3.path, timeout_ms: params3.timeoutMs }
-  });
-}
-function apiUnavailableError(params3) {
-  return new CliError({
-    code: "API_UNAVAILABLE",
-    message: String(params3.error?.message || params3.error || "API request failed"),
-    exitCode: 1,
-    details: { base_url: params3.baseUrl, path: params3.path }
-  });
-}
-function exitCodeFromRemoteCode(code2) {
-  return code2 === "INVALID_ARGS" ? 2 : 1;
-}
-function parseEnvelope(raw4) {
-  if (!raw4 || typeof raw4 !== "object") {
-    return { ok: false, error: { code: "INTERNAL", message: "Invalid API response envelope" } };
-  }
-  return raw4;
-}
-function buildQuery(params3) {
-  const sp = new URLSearchParams;
-  for (const [key, value8] of Object.entries(params3)) {
-    if (value8 === undefined || value8 === null)
-      continue;
-    if (typeof value8 === "string") {
-      if (!value8.trim())
-        continue;
-      sp.set(key, value8);
-      continue;
-    }
-    if (typeof value8 === "number" || typeof value8 === "boolean") {
-      sp.set(key, String(value8));
-    }
-  }
-  const query = sp.toString();
-  return query ? `?${query}` : "";
-}
-function requestJson(params3) {
-  const timeoutMs2 = Math.max(1, params3.timeoutMs ?? 15000);
-  const baseUrl = normalizeBaseUrl(params3.baseUrl);
-  const url2 = `${baseUrl}${params3.path}`;
-  return async((resume2) => {
-    const controller = new AbortController;
-    const timer2 = setTimeout(() => controller.abort(), timeoutMs2);
-    fetch(url2, {
-      method: params3.method,
-      headers: params3.method === "POST" ? { "content-type": "application/json" } : undefined,
-      body: params3.body === undefined ? undefined : JSON.stringify(params3.body),
-      signal: controller.signal
-    }).then(async (response) => {
-      clearTimeout(timer2);
-      let parsed;
-      try {
-        parsed = parseEnvelope(await response.json());
-      } catch (error4) {
-        resume2(fail8(new CliError({
-          code: "API_UNAVAILABLE",
-          message: "API returned a non-JSON response",
-          exitCode: 1,
-          details: { url: url2, status: response.status, error: String(error4?.message || error4) }
-        })));
-        return;
-      }
-      if (parsed.ok === true) {
-        resume2(succeed8(parsed.data));
-        return;
-      }
-      const code2 = typeof parsed.error?.code === "string" ? parsed.error.code : "INTERNAL";
-      const message2 = typeof parsed.error?.message === "string" ? parsed.error.message : "API request failed";
-      const hint = Array.isArray(parsed.hint) ? parsed.hint.map(String) : undefined;
-      resume2(fail8(new CliError({
-        code: code2,
-        message: message2,
-        exitCode: exitCodeFromRemoteCode(code2),
-        details: parsed.error?.details,
-        hint
-      })));
-    }).catch((error4) => {
-      clearTimeout(timer2);
-      if (error4?.name === "AbortError") {
-        resume2(fail8(apiTimeoutError({ baseUrl, path: params3.path, timeoutMs: timeoutMs2 })));
-        return;
-      }
-      resume2(fail8(apiUnavailableError({ baseUrl, path: params3.path, error: error4 })));
-    });
-    return sync3(() => {
-      clearTimeout(timer2);
-      controller.abort();
-    });
-  });
-}
-
-class HostApiClient extends Tag2("HostApiClient")() {
-}
-var HostApiClientLive = succeed10(HostApiClient, {
-  health: ({ baseUrl, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: "/v1/health", method: "GET", timeoutMs: timeoutMs2 }),
-  status: ({ baseUrl, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: "/v1/status", method: "GET", timeoutMs: timeoutMs2 }),
-  uiContextSnapshot: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs: timeoutMs2 }) => requestJson({
-    baseUrl,
-    path: `/v1/plugin/ui-context/snapshot${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-    method: "GET",
-    timeoutMs: timeoutMs2
-  }),
-  uiContextPage: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs: timeoutMs2 }) => requestJson({
-    baseUrl,
-    path: `/v1/plugin/ui-context/page${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-    method: "GET",
-    timeoutMs: timeoutMs2
-  }),
-  uiContextFocusedRem: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs: timeoutMs2 }) => requestJson({
-    baseUrl,
-    path: `/v1/plugin/ui-context/focused-rem${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-    method: "GET",
-    timeoutMs: timeoutMs2
-  }),
-  uiContextDescribe: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, selectionLimit, timeoutMs: timeoutMs2 }) => requestJson({
-    baseUrl,
-    path: `/v1/plugin/ui-context/describe${buildQuery({ stateFile: stateFile3, staleMs: staleMs2, selectionLimit })}`,
-    method: "GET",
-    timeoutMs: timeoutMs2
-  }),
-  selectionSnapshot: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs: timeoutMs2 }) => requestJson({
-    baseUrl,
-    path: `/v1/plugin/selection/snapshot${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-    method: "GET",
-    timeoutMs: timeoutMs2
-  }),
-  selectionRoots: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs: timeoutMs2 }) => requestJson({
-    baseUrl,
-    path: `/v1/plugin/selection/roots${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-    method: "GET",
-    timeoutMs: timeoutMs2
-  }),
-  selectionCurrent: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs: timeoutMs2 }) => requestJson({
-    baseUrl,
-    path: `/v1/plugin/selection/current${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-    method: "GET",
-    timeoutMs: timeoutMs2
-  }),
-  pluginCurrent: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, selectionLimit, timeoutMs: timeoutMs2 }) => requestJson({
-    baseUrl,
-    path: `/v1/plugin/current${buildQuery({ stateFile: stateFile3, staleMs: staleMs2, selectionLimit })}`,
-    method: "GET",
-    timeoutMs: timeoutMs2
-  }),
-  selectionOutline: ({ baseUrl, body, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: "/v1/plugin/selection/outline", method: "POST", body, timeoutMs: timeoutMs2 }),
-  uiContext: ({ baseUrl, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: "/v1/ui-context", method: "GET", timeoutMs: timeoutMs2 }),
-  selection: ({ baseUrl, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: "/v1/selection", method: "GET", timeoutMs: timeoutMs2 }),
-  searchDb: ({ baseUrl, ...body }) => requestJson({ baseUrl, path: "/v1/search/db", method: "POST", body }),
-  searchPlugin: ({ baseUrl, ...body }) => requestJson({ baseUrl, path: "/v1/search/plugin", method: "POST", body }),
-  writeOps: ({ baseUrl, body, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: "/v1/write/ops", method: "POST", body, timeoutMs: timeoutMs2 }),
-  writeMarkdown: ({ baseUrl, body, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: "/v1/write/markdown", method: "POST", body, timeoutMs: timeoutMs2 }),
-  queueWait: ({ baseUrl, txnId, timeoutMs: timeoutMs2, pollMs: pollMs2 }) => requestJson({ baseUrl, path: "/v1/queue/wait", method: "POST", body: { txnId, timeoutMs: timeoutMs2, pollMs: pollMs2 } }),
-  queueTxn: ({ baseUrl, txnId, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: `/v1/queue/txns/${encodeURIComponent(txnId)}`, method: "GET", timeoutMs: timeoutMs2 }),
-  triggerSync: ({ baseUrl, timeoutMs: timeoutMs2 }) => requestJson({ baseUrl, path: "/v1/actions/trigger-sync", method: "POST", timeoutMs: timeoutMs2 })
-});
-
 // src/commands/import/markdown.ts
 function optionToUndefined15(opt) {
   return isSome2(opt) ? opt.value : undefined;
@@ -95574,6 +95700,22 @@ function clampInt5(value8, min5, max7) {
     return min5;
   return Math.max(min5, Math.min(max7, Math.floor(value8)));
 }
+function parseDateInput3(raw4) {
+  const trimmed2 = raw4.trim();
+  const match24 = /^(\d{4})-(\d{2})-(\d{2})$/.exec(trimmed2);
+  const value8 = match24 ? new Date(Number(match24[1]), Number(match24[2]) - 1, Number(match24[3])) : new Date(trimmed2);
+  if (Number.isNaN(value8.getTime())) {
+    throw new CliError({ code: "INVALID_ARGS", message: `Invalid date: ${raw4}`, exitCode: 2 });
+  }
+  if (match24 && (value8.getFullYear() !== Number(match24[1]) || value8.getMonth() !== Number(match24[2]) - 1 || value8.getDate() !== Number(match24[3]))) {
+    throw new CliError({ code: "INVALID_ARGS", message: `Invalid date: ${raw4}`, exitCode: 2 });
+  }
+  return value8;
+}
+function todayAtMidnight2() {
+  const now2 = new Date;
+  return new Date(now2.getFullYear(), now2.getMonth(), now2.getDate());
+}
 function executeDbSearchUseCase(params3) {
   return gen2(function* () {
     const cfg = yield* AppConfig;
@@ -95629,6 +95771,87 @@ function executePluginSearchUseCase(params3) {
     });
   });
 }
+function executeReadOutlineUseCase(params3) {
+  return gen2(function* () {
+    const cfg = yield* AppConfig;
+    const refs = yield* RefResolver;
+    if (params3.id && params3.ref) {
+      return yield* fail8(new CliError({ code: "INVALID_ARGS", message: "Choose only one of --id or --ref", exitCode: 2 }));
+    }
+    const resolvedId = params3.ref ? yield* refs.resolve(params3.ref) : params3.id;
+    if (!resolvedId) {
+      return yield* fail8(new CliError({ code: "INVALID_ARGS", message: "You must provide --id or --ref", exitCode: 2 }));
+    }
+    return yield* tryPromise2({
+      try: async () => await executeOutlineRemSubtree({
+        id: resolvedId,
+        dbPath: cfg.remnoteDb,
+        maxDepth: params3.depth,
+        startOffset: params3.offset,
+        maxNodes: params3.nodes,
+        format: params3.format === "json" ? "json" : "markdown",
+        excludeProperties: params3.excludeProperties === true,
+        includeEmpty: params3.includeEmpty === true,
+        expandReferences: params3.expandReferences === false ? false : undefined,
+        maxReferenceDepth: params3.maxReferenceDepth,
+        detail: params3.detail === true
+      }),
+      catch: (error4) => cliErrorFromUnknown(error4, { code: "DB_UNAVAILABLE" })
+    });
+  });
+}
+function executeDailyRemIdUseCase(params3) {
+  return gen2(function* () {
+    if (params3.date && params3.offsetDays !== undefined) {
+      return yield* fail8(new CliError({ code: "INVALID_ARGS", message: "Choose only one of --date or --offset-days", exitCode: 2 }));
+    }
+    const cfg = yield* AppConfig;
+    const refs = yield* RefResolver;
+    const remDb = yield* RemDb;
+    let ref3 = `daily:${params3.offsetDays ?? 0}`;
+    let remId = "";
+    let dateString;
+    if (params3.date) {
+      const target2 = parseDateInput3(params3.date);
+      dateString = yield* remDb.withDb(cfg.remnoteDb, async (db) => {
+        const format9 = await getDateFormatting(db) ?? "yyyy/MM/dd";
+        return formatDateWithPattern(target2, format9);
+      }).pipe(map17((result2) => result2.result), catchAll2(() => succeed8(formatDateWithPattern(target2, "yyyy/MM/dd"))));
+      const result = yield* tryPromise2({
+        try: async () => await executeSearchRemOverview({
+          query: dateString,
+          dbPath: cfg.remnoteDb,
+          limit: 1,
+          preferExact: true,
+          exactFirstSingle: true,
+          excludePages: true
+        }),
+        catch: (error4) => cliErrorFromUnknown(error4, { code: "DB_UNAVAILABLE" })
+      });
+      const first3 = Array.isArray(result.matches) ? result.matches[0] : undefined;
+      remId = first3?.id ? String(first3.id) : "";
+      ref3 = `daily:${params3.date}`;
+      if (!remId) {
+        return yield* fail8(new CliError({
+          code: "INVALID_ARGS",
+          message: `No Daily Rem found for date: ${params3.date}`,
+          exitCode: 2
+        }));
+      }
+    } else {
+      const offset = params3.offsetDays ?? 0;
+      ref3 = `daily:${offset}`;
+      remId = yield* refs.resolve(ref3);
+      const target2 = todayAtMidnight2();
+      target2.setDate(target2.getDate() + offset);
+      dateString = yield* remDb.withDb(cfg.remnoteDb, async (db) => {
+        const format9 = await getDateFormatting(db) ?? "yyyy/MM/dd";
+        return formatDateWithPattern(target2, format9);
+      }).pipe(map17((result) => result.result), catchAll2(() => succeed8(undefined)));
+    }
+    return { ref: ref3, remId, dateString };
+  });
+}
 function executeWriteOpsUseCase(params3) {
   return gen2(function* () {
     const parsed = yield* try_3({
@@ -96189,19 +96412,23 @@ function readJsonBody(req) {
 function runHttpApiRuntime(params3) {
   return gen2(function* () {
     const cfg = yield* AppConfig;
+    const runtimeCfg = { ...cfg, apiBaseUrl: undefined };
     const apiFiles = yield* ApiDaemonFiles;
+    const daemonFiles = yield* DaemonFiles;
     const ws = yield* WsClient;
     const queue = yield* Queue;
     const payload = yield* Payload;
     const refs = yield* RefResolver;
     const hostApi = yield* HostApiClient;
     const remDb = yield* RemDb;
+    const processSvc = yield* Process;
+    const supervisorState = yield* SupervisorState;
     const statusLine = yield* StatusLineController;
     const host3 = params3?.host ?? cfg.apiHost ?? "0.0.0.0";
     const configuredPort = params3?.port ?? cfg.apiPort ?? 3000;
     const stateFilePath = params3?.stateFile ?? cfg.apiStateFile ?? apiFiles.defaultStateFile();
     const startedAt = Date.now();
-    const provide6 = (effect4) => effect4.pipe(provideService2(AppConfig, cfg), provideService2(ApiDaemonFiles, apiFiles), provideService2(WsClient, ws), provideService2(Queue, queue), provideService2(Payload, payload), provideService2(RefResolver, refs), provideService2(HostApiClient, hostApi), provideService2(RemDb, remDb), provideService2(StatusLineController, statusLine));
+    const provide6 = (effect4) => effect4.pipe(provideService2(AppConfig, runtimeCfg), provideService2(ApiDaemonFiles, apiFiles), provideService2(DaemonFiles, daemonFiles), provideService2(WsClient, ws), provideService2(Queue, queue), provideService2(Payload, payload), provideService2(RefResolver, refs), provideService2(HostApiClient, hostApi), provideService2(RemDb, remDb), provideService2(Process, processSvc), provideService2(SupervisorState, supervisorState), provideService2(StatusLineController, statusLine));
     const server = createServer((req, res) => {
       const url2 = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
       const method = req.method || "GET";
@@ -96309,6 +96536,13 @@ function runHttpApiRuntime(params3) {
         }));
         return;
       }
+      if (method === "GET" && url2.pathname === "/v1/daily/rem-id") {
+        run12(executeDailyRemIdUseCase({
+          date: url2.searchParams.get("date") ?? undefined,
+          offsetDays: url2.searchParams.get("offsetDays") ? Number(url2.searchParams.get("offsetDays")) : undefined
+        }));
+        return;
+      }
       if (method === "POST" && url2.pathname === "/v1/plugin/selection/outline") {
         (async () => {
           try {
@@ -96362,6 +96596,35 @@ function runHttpApiRuntime(params3) {
         })();
         return;
       }
+      if (method === "POST" && url2.pathname === "/v1/read/outline") {
+        (async () => {
+          try {
+            const body = await runPromise(readJsonBody(req));
+            await run12(executeReadOutlineUseCase({
+              id: typeof body?.id === "string" ? body.id : undefined,
+              ref: typeof body?.ref === "string" ? body.ref : undefined,
+              depth: typeof body?.depth === "number" ? body.depth : undefined,
+              offset: typeof body?.offset === "number" ? body.offset : undefined,
+              nodes: typeof body?.nodes === "number" ? body.nodes : undefined,
+              format: body?.format === "json" ? "json" : body?.format === "md" ? "md" : undefined,
+              excludeProperties: body?.excludeProperties === true,
+              includeEmpty: body?.includeEmpty === true,
+              expandReferences: body?.expandReferences === true ? true : body?.expandReferences === false ? false : undefined,
+              maxReferenceDepth: typeof body?.maxReferenceDepth === "number" ? body.maxReferenceDepth : undefined,
+              detail: body?.detail === true
+            }));
+          } catch (error4) {
+            const cliError = isCliError(error4) ? error4 : new CliError({
+              code: "INVALID_PAYLOAD",
+              message: "Invalid JSON body",
+              exitCode: 2,
+              details: { error: String(error4?.message || error4) }
+            });
+            sendJson2(res, statusCodeFromCliError(cliError), fail21(toJsonError(cliError), cliError.hint));
+          }
+        })();
+        return;
+      }
       if (method === "POST" && url2.pathname === "/v1/search/plugin") {
         (async () => {
           try {
@@ -98390,6 +98653,10 @@ var readPowerupSchemaCommand = exports_Command.make("schema", { powerup, id: id2
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "powerup schema",
+    reason: "this command still reads local powerup/table metadata from the RemNote database"
+  });
   const resolved = powerup2 ? yield* resolvePowerup(powerup2) : null;
   const tagId = resolved ? resolved.id : normalizeRemIdInput(id3);
   const payload2 = yield* tryPromise2({
@@ -98743,6 +99010,10 @@ var writePowerupApplyCommand = exports_Command.make("apply", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "powerup apply",
+    reason: "this command still reads local powerup metadata before enqueueing writes"
+  });
   const payloadSvc = yield* Payload;
   const remId = normalizeRemIdInput(rem);
   const resolved = powerup2 ? yield* resolvePowerup(powerup2) : null;
@@ -99344,6 +99615,10 @@ var writePowerupRecordAddCommand = exports_Command.make("add", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "powerup record add",
+    reason: "this command still reads local table metadata before enqueueing writes"
+  });
   const refs = yield* RefResolver;
   const payloadSvc = yield* Payload;
   const resolved = powerup2 ? yield* resolvePowerup(powerup2) : null;
@@ -99548,6 +99823,10 @@ var writePowerupRecordDeleteCommand = exports_Command.make("delete", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "powerup record delete",
+    reason: "this command still validates local table membership before enqueueing writes"
+  });
   const payloadSvc = yield* Payload;
   const resolved = powerup2 ? yield* resolvePowerup(powerup2) : null;
   const tableTagId = resolved ? resolved.id : normalizeRemIdInput(tagId);
@@ -99715,6 +99994,10 @@ var writePowerupRecordUpdateCommand = exports_Command.make("update", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "powerup record update",
+    reason: "this command still reads local table membership and schema metadata before enqueueing writes"
+  });
   const payloadSvc = yield* Payload;
   const resolved = powerup2 ? yield* resolvePowerup(powerup2) : null;
   const tableTagId = resolved ? resolved.id : normalizeRemIdInput(tagId);
@@ -100026,6 +100309,10 @@ var sort2 = choice5("sort", ["rank", "updatedAt", "createdAt"]).pipe(optional5,
 var sortDirection = choice5("sort-direction", ["asc", "desc"]).pipe(optional5, map34(optionToUndefined38));
 var readQueryCommand = exports_Command.make("query", { payload: payload2, text: text15, tag: tag7, limit: limit5, offset: offset3, snippetLength, sort: sort2, sortDirection }, ({ payload: payload3, text: text16, tag: tag8, limit: limit6, offset: offset4, snippetLength: snippetLength2, sort: sort3, sortDirection: sortDirection2 }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "query",
+    reason: "this command still executes structured queries against the local RemNote database"
+  });
   const payloadSvc = yield* Payload;
   const queryObj = {};
   if (payload3) {
@@ -100324,6 +100611,10 @@ var readByReferenceCommand = exports_Command.make("by-reference", { reference, t
     return yield* fail8(new CliError({ code: "INVALID_ARGS", message: "Provide at least one Rem ID via --reference", exitCode: 2 }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "rem by-reference",
+    reason: "this command still walks the local RemNote database to expand references"
+  });
   const result = yield* tryPromise2({
     try: async () => await executeFindRemsByReference({
       targetIds: reference2,
@@ -100341,6 +100632,10 @@ var readByReferenceCommand = exports_Command.make("by-reference", { reference, t
 // src/commands/read/connections.ts
 var readConnectionsCommand = exports_Command.make("connections", { id: text9("id") }, ({ id: id3 }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "rem connections",
+    reason: "this command still reads local graph connections from the RemNote database"
+  });
   const payload3 = yield* tryPromise2({
     try: async () => await executeGetRemConnections({ id: id3, dbPath: cfg.remnoteDb }),
     catch: (e) => cliErrorFromUnknown(e, { code: "DB_UNAVAILABLE" })
@@ -100359,6 +100654,10 @@ var readInspectCommand = exports_Command.make("inspect", {
   maxReferenceDepth
 }, ({ id: id3, expandReferences, maxReferenceDepth: maxReferenceDepth2 }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "rem inspect",
+    reason: "this command still inspects the local RemNote database directly"
+  });
   const result = yield* tryPromise2({
     try: async () => await executeInspectRemDoc({
       id: id3,
@@ -100415,10 +100714,34 @@ var readOutlineCommand = exports_Command.make("outline", {
   detail
 }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  const hostApi = yield* HostApiClient;
   const refs = yield* RefResolver;
   if (id4 && ref4) {
     return yield* fail8(new CliError({ code: "INVALID_ARGS", message: "Choose only one of --id or --ref", exitCode: 2 }));
   }
+  if (!id4 && !ref4) {
+    return yield* fail8(new CliError({ code: "INVALID_ARGS", message: "You must provide --id or --ref", exitCode: 2 }));
+  }
+  if (cfg.apiBaseUrl) {
+    const data = yield* hostApi.readOutline({
+      baseUrl: cfg.apiBaseUrl,
+      body: {
+        id: id4,
+        ref: ref4,
+        depth: depth2,
+        offset: offset6,
+        nodes: nodes2,
+        format: format10 === "json" ? "json" : format10 === "md" ? "md" : undefined,
+        excludeProperties,
+        includeEmpty,
+        expandReferences,
+        maxReferenceDepth: maxReferenceDepth2,
+        detail
+      }
+    });
+    yield* writeSuccess({ data, md: data.markdown ?? "" });
+    return;
+  }
   const link3 = ref4 ? tryParseRemnoteLinkFromRef(ref4) : undefined;
   const resolvedId = ref4 ? link3?.remId ?? (yield* refs.resolve(ref4)) : id4;
   if (!resolvedId) {
@@ -100454,6 +100777,10 @@ var id4 = text9("id").pipe(repeated5);
 var maxHops = integer7("max-hops").pipe(optional5, map34(optionToUndefined44));
 var readPageIdCommand = exports_Command.make("page-id", { ref: ref4, id: id4, maxHops, detail: boolean8("detail") }, ({ ref: ref5, id: id5, maxHops: maxHops2, detail }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "rem page-id",
+    reason: "this command still resolves page ancestry from the local RemNote database"
+  });
   const refs = yield* RefResolver;
   const hasRef = typeof ref5 === "string" && ref5.trim().length > 0;
   const hasIds = Array.isArray(id5) && id5.length > 0;
@@ -100516,6 +100843,10 @@ var readReferencesCommand = exports_Command.make("references", {
   inboundMaxDepth
 }, ({ id: id5, includeDescendants, maxDepth: maxDepth5, includeOccurrences, resolveText, includeInbound, inboundMaxDepth: inboundMaxDepth2 }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "rem references",
+    reason: "this command still reads local reference graphs from the RemNote database"
+  });
   const payload3 = yield* tryPromise2({
     try: async () => {
       const { payload: payload4 } = await executeListRemReferences({
@@ -100548,6 +100879,10 @@ var readResolveRefCommand = exports_Command.make("resolve-ref", {
   detail: boolean8("detail")
 }, ({ ids: ids4, expandReferences, maxReferenceDepth: maxReferenceDepth3, detail }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "rem resolve-ref",
+    reason: "this command still resolves references from the local RemNote database"
+  });
   const result = yield* tryPromise2({
     try: async () => await executeResolveRemReference({
       ids: ids4,
@@ -101224,6 +101559,10 @@ var remCommand = exports_Command.make("rem", {}).pipe(exports_Command.withSubcom
 function resolveReplaceTarget(params3) {
   return gen2(function* () {
     const _cfg = yield* AppConfig;
+    yield* failInRemoteMode({
+      command: "replace target resolution",
+      reason: "replace commands still depend on local selection/ref resolution semantics"
+    });
     const refs = yield* RefResolver;
     const hasSelection = params3.selection === true;
     const hasRef = typeof params3.ref === "string" && params3.ref.trim().length > 0;
@@ -101268,6 +101607,10 @@ function resolveReplaceTarget(params3) {
 function expandTargetIds(params3) {
   return gen2(function* () {
     const cfg = yield* AppConfig;
+    yield* failInRemoteMode({
+      command: "replace subtree expansion",
+      reason: "replace commands still expand target subtrees from the local RemNote database"
+    });
     if (params3.scope === "roots") {
       const unique2 = Array.from(new Set(params3.rootIds));
       return {
@@ -102456,6 +102799,10 @@ var writeTableRecordAddCommand = exports_Command.make("add", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "table record add",
+    reason: "this command still reads local table metadata before enqueueing writes"
+  });
   const refs = yield* RefResolver;
   const payloadSvc = yield* Payload;
   const resolvedRef = ref7 ?? "daily:today";
@@ -102634,6 +102981,10 @@ var writeTableRecordDeleteCommand = exports_Command.make("delete", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "table record delete",
+    reason: "this command still validates local row membership before enqueueing writes"
+  });
   const payloadSvc = yield* Payload;
   if (!dryRun) {
     const inspected = yield* tryPromise2({
@@ -102763,6 +103114,10 @@ var writeTableRecordUpdateCommand = exports_Command.make("update", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "table record update",
+    reason: "this command still reads local row membership and schema metadata before enqueueing writes"
+  });
   const payloadSvc = yield* Payload;
   if (!dryRun) {
     const inspected = yield* tryPromise2({
@@ -102901,6 +103256,10 @@ var tableShowCommand = exports_Command.make("show", {
   offset: offset7
 }, ({ id: id5, includeOptions, limit: limit9, offset: offset8 }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "table show",
+    reason: "this command still reads local table metadata from the RemNote database"
+  });
   const payload3 = yield* tryPromise2({
     try: async () => await executeReadRemTable({
       tagId: id5,
@@ -102999,6 +103358,10 @@ function makeTodosListCommand() {
     offset: offset9
   }) => gen2(function* () {
     const cfg = yield* AppConfig;
+    yield* failInRemoteMode({
+      command: "todos list",
+      reason: "this command still derives todo state from the local RemNote database"
+    });
     const payload3 = yield* tryPromise2({
       try: async () => await executeListTodos({
         dbPath: cfg.remnoteDb,
@@ -103135,6 +103498,10 @@ function todoWriteEffect(params3) {
       }));
     }
     const cfg = yield* AppConfig;
+    yield* failInRemoteMode({
+      command: "todo add",
+      reason: "this command still reads local todo schema metadata before enqueueing writes"
+    });
     const payloadSvc = yield* Payload;
     const remId = normalizeRemIdInput(rem);
     const normalizedTagId = tagId2 ? normalizeRemIdInput(tagId2) : undefined;
@@ -103411,6 +103778,10 @@ var writePowerupTodoRemoveCommand = exports_Command.make("remove", {
     }));
   }
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "todo remove",
+    reason: "this command still reads local todo schema metadata before enqueueing writes"
+  });
   const payloadSvc = yield* Payload;
   const remId = normalizeRemIdInput(rem);
   const normalizedTagId = tagId2 ? normalizeRemIdInput(tagId2) : undefined;
@@ -103566,6 +103937,10 @@ var maxNodesPerResult = integer7("max-nodes").pipe(optional5, map34(optionToUnde
 var groupBy2 = choice5("group-by", ["none", "parent", "date"]).pipe(optional5, map34(optionToUndefined51));
 var topicSummaryCommand = exports_Command.make("summary", { keywords, query: query2, timeRange: timeRange3, maxResults, maxNodesPerResult, groupBy: groupBy2 }, ({ keywords: keywords2, query: query3, timeRange: timeRange4, maxResults: maxResults2, maxNodesPerResult: maxNodesPerResult2, groupBy: groupBy3 }) => gen2(function* () {
   const cfg = yield* AppConfig;
+  yield* failInRemoteMode({
+    command: "topic summary",
+    reason: "this command still summarizes topics from the local RemNote database"
+  });
   const keywordList = keywords2 ? keywords2.split(",").map((s) => s.trim()).filter(Boolean) : undefined;
   const queryText = query3?.trim() || undefined;
   if ((!keywordList || keywordList.length === 0) && !queryText) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-remnote",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "license": "MIT",
   "bin": {
     "agent-remnote": "./cli.js"