@remnic/core 9.69.56 → 9.69.57

package/dist/chunk-QOPB6KE3.js

@@ -0,0 +1,1530 @@
+import {
+  coerceBooleanLike,
+  coerceNumber
+} from "./chunk-PQVCH2AE.js";
+import {
+  isLoopbackHost
+} from "./chunk-C5C7IJ4Q.js";
+import {
+  assertValidTimezone,
+  isValidActivityDate
+} from "./chunk-353C5UNV.js";
+import {
+  extractJsonCandidates
+} from "./chunk-RGMVMVMF.js";
+import {
+  expandTildePath
+} from "./chunk-6KH5NLQS.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/activity/journal-vault-prereq.ts
+var VAULT_JOURNAL_PREREQUISITES = [
+  "vault.enabled",
+  "vault.dailyNotePath",
+  "vault.readback.journalSection"
+];
+function checkVaultJournalPrerequisites(input) {
+  const missing = [];
+  if (input.vaultEnabled !== true) missing.push("vault.enabled");
+  if (typeof input.dailyNotePath !== "string" || input.dailyNotePath.trim().length === 0) {
+    missing.push("vault.dailyNotePath");
+  }
+  if (typeof input.journalSection !== "string" || input.journalSection.trim().length === 0) {
+    missing.push("vault.readback.journalSection");
+  }
+  if (missing.length === 0) return { ok: true };
+  return {
+    ok: false,
+    missing,
+    message: `vault journal read-back prerequisites unmet: ${missing.join(", ")}`
+  };
+}
+
+// src/activity/vault-path.ts
+import path from "path";
+var VAULT_TEMPLATE_TOKENS = [
+  "{yyyy}",
+  "{yy}",
+  "{M}",
+  "{MM}",
+  "{d}",
+  "{dd}",
+  "{ww}",
+  "{MMM}",
+  "{MMMM}",
+  "{ddd}",
+  "{dddd}"
+];
+var TOKEN_LOOKUP = Object.fromEntries(VAULT_TEMPLATE_TOKENS.map((t) => [t, true]));
+var ANY_BRACED_RE = /\{[^{}]*\}/g;
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var WEEKDAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function templateValues(date) {
+  const [yyyy, mm, dd] = date.split("-");
+  const monthIndex = Number(mm) - 1;
+  const weekday = new Date(Date.UTC(Number(yyyy), monthIndex, Number(dd))).getUTCDay();
+  return {
+    "{yyyy}": yyyy,
+    "{yy}": yyyy.slice(2),
+    "{MM}": mm,
+    "{dd}": dd,
+    "{M}": String(Number(mm)),
+    "{d}": String(Number(dd)),
+    "{ww}": isoWeekNumber(date),
+    "{MMM}": MONTH_NAMES[monthIndex].slice(0, 3),
+    "{MMMM}": MONTH_NAMES[monthIndex],
+    "{ddd}": WEEKDAY_NAMES[weekday].slice(0, 3),
+    "{dddd}": WEEKDAY_NAMES[weekday]
+  };
+}
+function expandVaultTemplateTokens(text, date) {
+  if (!isValidActivityDate(date)) {
+    throw new RangeError(`Invalid vault date "${date}"; expected YYYY-MM-DD.`);
+  }
+  if (typeof text !== "string" || text.length === 0) {
+    throw new RangeError("Vault template must be a non-empty string.");
+  }
+  const values = templateValues(date);
+  return text.replace(ANY_BRACED_RE, (token) => {
+    if (TOKEN_LOOKUP[token] === true) return values[token];
+    throw new RangeError(
+      `Unknown vault template token ${token}; valid tokens are ${VAULT_TEMPLATE_TOKENS.join(" ")}.`
+    );
+  });
+}
+function validateVaultNoteTemplate(template) {
+  if (typeof template !== "string" || template.length === 0) {
+    throw new RangeError("Vault note path template must be a non-empty relative path.");
+  }
+  if (path.posix.isAbsolute(template) || path.win32.isAbsolute(template)) {
+    throw new RangeError("Vault note path template must be relative; absolute templates are rejected.");
+  }
+  if (template.split(/[\\/]/).some((segment) => segment === "..")) {
+    throw new RangeError("Vault note path template must not contain `..` segments.");
+  }
+  expandVaultTemplateTokens(template, "2026-01-04");
+}
+function resolveVaultNotePath(template, date, options) {
+  if (!isValidActivityDate(date)) {
+    throw new RangeError(`Invalid vault date "${date}"; expected YYYY-MM-DD.`);
+  }
+  if (options?.timezone !== void 0) {
+    assertValidTimezone(options.timezone);
+  }
+  validateVaultNoteTemplate(template);
+  const expanded = expandVaultTemplateTokens(template, date);
+  if (path.posix.isAbsolute(expanded) || path.win32.isAbsolute(expanded)) {
+    throw new RangeError("Vault note path template must be relative; absolute templates are rejected.");
+  }
+  return expanded;
+}
+function isoWeekNumber(date) {
+  const [year, month, day] = date.split("-").map(Number);
+  const utc = new Date(Date.UTC(year, month - 1, day));
+  const dayNum = utc.getUTCDay() || 7;
+  utc.setUTCDate(utc.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(utc.getUTCFullYear(), 0, 1));
+  const weekNo = Math.ceil(((utc.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return String(weekNo).padStart(2, "0");
+}
+
+// src/activity/vault-publish.ts
+import { createHash, randomBytes } from "crypto";
+import { readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import path2 from "path";
+function applyManagedRegion(fileText, opts) {
+  if (opts.strategy === "heading") return applyHeadingRegion(fileText, opts.name, opts.content);
+  const startMarker = `<!-- remnic:${opts.name}:start -->`;
+  const endMarker = `<!-- remnic:${opts.name}:end -->`;
+  const rows = fileLines(fileText);
+  let startRow;
+  let endRow;
+  for (const row of rows) {
+    if (row.fenced) continue;
+    const trimmed = row.line.trim();
+    if (startRow === void 0) {
+      if (trimmed === startMarker) startRow = row;
+    } else if (endRow === void 0 && trimmed === endMarker) {
+      endRow = row;
+      break;
+    }
+  }
+  if (startRow === void 0 || endRow === void 0) {
+    return { ok: false, reason: "no_marker", text: fileText };
+  }
+  const { body, eol } = ownedBody(fileText, opts.content);
+  return {
+    ok: true,
+    text: `${fileText.slice(0, startRow.start + startRow.line.length)}${eol}${body}${eol}${fileText.slice(endRow.start)}`
+  };
+}
+function applyHeadingRegion(fileText, name, content) {
+  const wanted = name.trim();
+  const rows = fileLines(fileText);
+  const hits = [];
+  for (const row of rows) {
+    if (row.fenced) continue;
+    const heading = parseAtxHeading(row.line);
+    if (heading && heading.text === wanted) {
+      hits.push({ line: row.number, level: heading.level, next: row.next });
+    }
+  }
+  if (hits.length === 0) return { ok: false, reason: "no_heading", text: fileText };
+  if (hits.length > 1) {
+    return { ok: false, reason: "duplicate_heading", lines: hits.map((hit2) => hit2.line), text: fileText };
+  }
+  const hit = hits[0];
+  let sectionEnd = fileText.length;
+  for (const row of rows) {
+    if (row.start < hit.next || row.fenced) continue;
+    const heading = parseAtxHeading(row.line);
+    if (heading && heading.level <= hit.level) {
+      sectionEnd = row.start;
+      break;
+    }
+  }
+  const { body, eol } = ownedBody(fileText, demoteOwnedHeadings(content, hit.level));
+  const prefix = hit.next === fileText.length && !fileText.endsWith("\n") && !fileText.endsWith("\r") ? `${fileText}${eol}` : fileText.slice(0, hit.next);
+  return { ok: true, text: `${prefix}${body}${eol}${fileText.slice(sectionEnd)}` };
+}
+function demoteOwnedHeadings(content, owningLevel) {
+  const rows = fileLines(content);
+  let out = "";
+  let cursor = 0;
+  for (const row of rows) {
+    const heading = row.fenced ? null : parseAtxHeading(row.line);
+    if (heading === null) continue;
+    const level = Math.min(owningLevel + heading.level, 6);
+    const replacement = level > owningLevel ? `${"#".repeat(level)} ${heading.text}` : `**${heading.text}**`;
+    out += content.slice(cursor, row.start) + replacement;
+    cursor = row.start + row.line.length;
+  }
+  return out + content.slice(cursor);
+}
+function ownedBody(fileText, content) {
+  const eol = fileText.includes("\r\n") ? "\r\n" : "\n";
+  let body = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\r\n") body = body.replace(/\n/g, "\r\n");
+  if (body.endsWith(eol)) body = body.slice(0, -eol.length);
+  return { body, eol };
+}
+function fileLines(fileText) {
+  const rows = [];
+  let start = 0;
+  let number = 1;
+  let fence = null;
+  while (start < fileText.length) {
+    let i = start;
+    while (i < fileText.length && fileText[i] !== "\n" && fileText[i] !== "\r") i++;
+    let next = i;
+    if (fileText[i] === "\r" && fileText[i + 1] === "\n") next = i + 2;
+    else if (fileText[i] === "\n" || fileText[i] === "\r") next = i + 1;
+    else next = fileText.length;
+    const line = fileText.slice(start, i);
+    const indentedCode = indentColumn(line) >= 4;
+    const run = indentedCode ? null : fenceRun(line);
+    let fenced;
+    if (fence === null) {
+      if (run !== null && !(run.char === "`" && run.info.includes("`"))) {
+        fence = { char: run.char, len: run.len };
+      }
+      fenced = fence !== null || indentedCode;
+    } else {
+      fenced = true;
+      if (run !== null && run.char === fence.char && run.len >= fence.len && run.info.length === 0) {
+        fence = null;
+      }
+    }
+    rows.push({ line, start, next, number, fenced });
+    number += 1;
+    start = next;
+  }
+  return rows;
+}
+function indentColumn(line) {
+  let col = 0;
+  for (let i = 0; i < line.length; i += 1) {
+    const ch = line[i];
+    if (ch === " ") col += 1;
+    else if (ch === "	") col += 4 - col % 4;
+    else break;
+  }
+  return col;
+}
+function fenceRun(line) {
+  const body = line.trimStart();
+  const char = body[0];
+  if (char !== "`" && char !== "~") return null;
+  let len = 0;
+  while (len < body.length && body[len] === char) len++;
+  if (len < 3) return null;
+  return { char, len, info: body.slice(len).trim() };
+}
+function parseAtxHeading(line) {
+  let at = 0;
+  let indent = 0;
+  while (at < line.length && (line[at] === " " || line[at] === "	")) {
+    indent += line[at] === " " ? 1 : 4 - indent % 4;
+    if (indent >= 4) return null;
+    at += 1;
+  }
+  let level = 0;
+  while (level < 6 && line[at + level] === "#") level++;
+  if (level === 0) return null;
+  const after = line[at + level];
+  if (after !== " " && after !== "	") return null;
+  let start = at + level + 1;
+  let end = line.length;
+  while (start < end && (line[start] === " " || line[start] === "	")) start++;
+  while (end > start && (line[end - 1] === " " || line[end - 1] === "	")) end--;
+  let hashEnd = end;
+  while (hashEnd > start && line[hashEnd - 1] === "#") hashEnd--;
+  if (hashEnd < end && hashEnd > start && (line[hashEnd - 1] === " " || line[end - 1] === "	")) {
+    end = hashEnd;
+    while (end > start && (line[end - 1] === " " || line[end - 1] === "	")) end--;
+  }
+  return { level, text: line.slice(start, end) };
+}
+function headingSurvivesRoundTrip(name) {
+  const parsed = parseAtxHeading(`## ${name}`);
+  return parsed !== null && parsed.text === name;
+}
+function publishVaultRegion(input) {
+  const vault = expandTildePath(input.vaultPath);
+  try {
+    if (!statSync(vault).isDirectory()) return { ok: false, reason: "not_directory" };
+  } catch {
+    return { ok: false, reason: "not_directory" };
+  }
+  if (input.relativeFile.length === 0 || path2.isAbsolute(input.relativeFile)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  const root = path2.resolve(vault);
+  const dest = path2.resolve(root, input.relativeFile);
+  const rel = path2.relative(root, dest);
+  if (rel.length === 0 || rel.startsWith("..") || path2.isAbsolute(rel)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  let existing;
+  try {
+    if (!statSync(dest).isFile()) return { ok: false, reason: "missing_file" };
+    existing = readFileSync(dest, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { ok: false, reason: "missing_file" };
+    throw err;
+  }
+  const applied = applyManagedRegion(existing, {
+    strategy: "markers",
+    name: input.name,
+    content: input.content
+  });
+  if (!applied.ok) return { ok: false, reason: "no_marker" };
+  const prevHash = createHash("sha256").update(existing, "utf8").digest("hex");
+  const nextHash = createHash("sha256").update(applied.text, "utf8").digest("hex");
+  if (prevHash === nextHash) return { ok: true, status: "unchanged" };
+  const tmpPath = path2.join(path2.dirname(dest), `.remnic-vault-${randomBytes(8).toString("hex")}.tmp`);
+  writeFileSync(tmpPath, applied.text);
+  try {
+    renameSync(tmpPath, dest);
+  } catch (renameErr) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw renameErr;
+  }
+  return { ok: true, status: "updated" };
+}
+
+// src/activity/vault-region.ts
+function validateRegionName(name) {
+  if (typeof name !== "string") {
+    return { ok: false, error: "invalid_name" };
+  }
+  if (name.includes("\n") || name.includes("\r") || name.includes("-->") || name.includes(":")) {
+    return { ok: false, error: "invalid_name" };
+  }
+  if (name.trim() !== name || name.trim().length === 0) {
+    return { ok: false, error: "invalid_name" };
+  }
+  return { ok: true, name };
+}
+
+// src/activity/timeline/analysis-failure.ts
+var ANALYSIS_FAILURE_KINDS = [
+  "provider_unavailable",
+  "timeout",
+  "aborted",
+  "rate_limited",
+  "malformed_json",
+  "invalid_schema",
+  "partial_output",
+  "invalid_config"
+];
+var RETRYABLE_BY_KIND = {
+  provider_unavailable: true,
+  timeout: true,
+  rate_limited: true,
+  aborted: false,
+  malformed_json: false,
+  invalid_schema: false,
+  partial_output: false,
+  invalid_config: false
+};
+function isAnalysisFailureKind(value) {
+  return typeof value === "string" && ANALYSIS_FAILURE_KINDS.includes(value);
+}
+function classifyAnalysisFailure(kind) {
+  if (!isAnalysisFailureKind(kind)) {
+    throw new TypeError(
+      `unknown analysis failure kind: ${String(kind)}; allowed kinds: ${ANALYSIS_FAILURE_KINDS.join(", ")}`
+    );
+  }
+  return {
+    kind,
+    retryable: RETRYABLE_BY_KIND[kind],
+    preservesDeterministic: true
+  };
+}
+
+// src/activity/timeline/analysis-provider.ts
+var TimelineAnalysisProviderError = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+  }
+  kind;
+  name = "TimelineAnalysisProviderError";
+};
+var TIMELINE_ANALYSIS_LOCAL_PROVIDER_ID = "local";
+var RATE_LIMIT_MESSAGE = /rate limit|too many requests/i;
+function classifyAnalysisProviderError(error) {
+  if (error instanceof TimelineAnalysisProviderError) return error.kind;
+  if (error instanceof Error) {
+    if (error.name === "AbortError" || "code" in error && error.code === "ABORT_ERR") {
+      return "aborted";
+    }
+    if (error.name === "TimeoutError") return "timeout";
+    const status = "status" in error ? error.status : "statusCode" in error ? error.statusCode : void 0;
+    if (status === 429 || RATE_LIMIT_MESSAGE.test(error.message)) return "rate_limited";
+  }
+  return "provider_unavailable";
+}
+function timelineAnalysisCompleteFromClients(input) {
+  const { localLlm, remoteLlm } = input;
+  return async ({ prompt, provider, model, signal }) => {
+    const messages = [{ role: "user", content: prompt }];
+    if (provider === TIMELINE_ANALYSIS_LOCAL_PROVIDER_ID) {
+      if (!localLlm) {
+        throw new TimelineAnalysisProviderError(
+          "provider_unavailable",
+          "timeline analysis local provider is not configured"
+        );
+      }
+      const failureDiag2 = {};
+      const result2 = await localLlm.chatCompletion(messages, {
+        temperature: 0,
+        maxTokens: 2048,
+        signal,
+        operation: "timeline-analysis",
+        redactProviderErrors: true,
+        model,
+        failureDiag: failureDiag2
+      });
+      if (result2 === null) {
+        throw new TimelineAnalysisProviderError(
+          classifyAnalysisProviderError(failureDiag2.lastError),
+          "timeline analysis local provider returned no completion"
+        );
+      }
+      return result2.content;
+    }
+    if (!remoteLlm) {
+      throw new TimelineAnalysisProviderError(
+        "provider_unavailable",
+        "timeline analysis remote provider is not configured"
+      );
+    }
+    const failureDiag = {};
+    const result = await remoteLlm.chatCompletion(messages, {
+      temperature: 0,
+      maxTokens: 2048,
+      signal,
+      modelChain: { primary: `${provider}/${model}` },
+      includeDefaultModelFallback: false,
+      redactProviderErrors: true,
+      failureDiag
+    });
+    if (result === null) {
+      throw new TimelineAnalysisProviderError(
+        classifyAnalysisProviderError(failureDiag.lastError),
+        `timeline analysis provider "${provider}" is not configured`
+      );
+    }
+    return result.content;
+  };
+}
+
+// src/activity/timeline/categories.ts
+var TIMELINE_RESERVED_UNKNOWN = "system.unknown";
+var TIMELINE_RESERVED_IDLE = "system.idle";
+var TIMELINE_RESERVED_PAUSE = "system.pause";
+var COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
+function isTimelineCategoryId(id) {
+  const parts = id.split(".");
+  if (parts.length === 0) return false;
+  for (const part of parts) {
+    if (part.length === 0) return false;
+    const first = part.charCodeAt(0);
+    if (first < 97 || first > 122) return false;
+    for (let i = 1; i < part.length; i += 1) {
+      const code = part.charCodeAt(i);
+      const ok = code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 45;
+      if (!ok) return false;
+    }
+  }
+  return true;
+}
+var DEFAULT_TIMELINE_CATEGORIES = [
+  { id: "development", name: "Development", color: "#3b82f6", description: "Editors, terminals, IDEs, and code forges.", order: 10 },
+  { id: "communication", name: "Communication", color: "#f59e0b", description: "Mail, chat, and meetings.", order: 20 },
+  { id: "browsing", name: "Browsing", color: "#6366f1", description: "Web browsing without a more specific domain match.", order: 30 },
+  { id: "documents", name: "Documents", color: "#10b981", description: "Writing, notes, and PDFs.", order: 40 },
+  { id: "design", name: "Design & Media", color: "#ec4899", description: "Design, audio, and video tools.", order: 50 },
+  { id: "data", name: "Data & Analysis", color: "#84cc16", description: "Spreadsheets, dashboards, and databases.", order: 60 },
+  { id: "admin", name: "Admin", color: "#64748b", description: "File managers, settings, and system utilities.", order: 70 },
+  { id: "entertainment", name: "Entertainment", color: "#ef4444", description: "Video, music, and games.", order: 80 },
+  { id: TIMELINE_RESERVED_UNKNOWN, name: "Uncategorized", color: "#9ca3af", description: "Activity with no matching classification signal. Kept visible, never silently reassigned.", order: 990, system: true },
+  { id: TIMELINE_RESERVED_IDLE, name: "Idle", color: "#d1d5db", description: "Derived gap between cards where no activity was observed.", order: 991, system: true, idle: true },
+  { id: TIMELINE_RESERVED_PAUSE, name: "Paused", color: "#a78bfa", description: "User-declared pause interval.", order: 992, system: true }
+];
+function validateTimelineCategories(categories) {
+  if (!Array.isArray(categories) || categories.length === 0) {
+    throw new RangeError("timeline categories must be a non-empty array");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const category of categories) {
+    if (typeof category.id !== "string" || !isTimelineCategoryId(category.id)) {
+      throw new RangeError(`timeline category id must be dotted kebab-case: ${String(category.id)}`);
+    }
+    if (seen.has(category.id)) {
+      throw new RangeError(`timeline category id must be unique: ${category.id}`);
+    }
+    seen.add(category.id);
+    if (typeof category.name !== "string" || category.name.length === 0) {
+      throw new RangeError(`timeline category ${category.id}: name must be a non-empty string`);
+    }
+    if (typeof category.color !== "string" || !COLOR_PATTERN.test(category.color)) {
+      throw new RangeError(`timeline category ${category.id}: color must be #RRGGBB`);
+    }
+    if (typeof category.description !== "string" || category.description.length === 0) {
+      throw new RangeError(`timeline category ${category.id}: description must be a non-empty string`);
+    }
+    if (!Number.isInteger(category.order)) {
+      throw new RangeError(`timeline category ${category.id}: order must be an integer`);
+    }
+    const isReserved = category.id === TIMELINE_RESERVED_UNKNOWN || category.id === TIMELINE_RESERVED_IDLE || category.id === TIMELINE_RESERVED_PAUSE;
+    if (isReserved && category.system !== true) {
+      throw new RangeError(`timeline category ${category.id} is reserved and must set system: true`);
+    }
+    if (!isReserved) {
+      if (category.id.startsWith("system.")) {
+        throw new RangeError(`timeline category id namespace "system." is reserved: ${category.id}`);
+      }
+      if (category.system === true || category.idle === true) {
+        throw new RangeError(`timeline category ${category.id}: only reserved categories may set system/idle flags`);
+      }
+    }
+  }
+  const idle = categories.find((category) => category.id === TIMELINE_RESERVED_IDLE);
+  if (idle !== void 0 && idle.idle !== true) {
+    throw new RangeError(`timeline category ${TIMELINE_RESERVED_IDLE} must set idle: true`);
+  }
+  for (const reserved of [TIMELINE_RESERVED_UNKNOWN, TIMELINE_RESERVED_IDLE, TIMELINE_RESERVED_PAUSE]) {
+    if (!categories.some((category) => category.id === reserved)) {
+      throw new RangeError(`timeline categories must include the reserved "${reserved}" category`);
+    }
+  }
+}
+function sortTimelineCategories(categories) {
+  return [...categories].sort((a, b) => a.order - b.order || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+
+// src/activity/timeline/analysis.ts
+var TIMELINE_ANALYSIS_PROMPT_VERSION = 1;
+var TIMELINE_ANALYSIS_BATCH_SIZE = 40;
+var TIMELINE_ANALYSIS_BATCH_OVERLAP = 2;
+var TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS = 15e3;
+var TimelineAnalysisConfigError = class extends Error {
+  name = "TimelineAnalysisConfigError";
+  code = "invalid_config";
+  constructor(message) {
+    super(message);
+  }
+};
+var INSTRUCTIONS = [
+  "Use only supplied evidence.",
+  "Preserve chronology.",
+  "Do not invent people, places, or tasks.",
+  "Avoid productivity or emotional claims.",
+  "Merge adjacent activity only when the evidence justifies it.",
+  'Return strict JSON: {"ops":[...]} with evidenceRange, title, summary, categoryId, confidence, uncertainty.',
+  "Cite evidence ranges for every op. Empty ops is a valid no-op."
+].join(" ");
+function fail(status, cards, provider, model, kind) {
+  log.info(`timeline analysis status=${status} provider=${provider} model=${model} promptVersion=${TIMELINE_ANALYSIS_PROMPT_VERSION}`);
+  return {
+    status,
+    cards,
+    provider,
+    model,
+    promptVersion: TIMELINE_ANALYSIS_PROMPT_VERSION,
+    failure: classifyAnalysisFailure(kind)
+  };
+}
+function requiredToken(value, name) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TimelineAnalysisConfigError(`${name} is required`);
+  }
+  return value.trim();
+}
+function evidenceKeyOf(observation) {
+  const parsed = Date.parse(observation.capturedAtUtc);
+  const instant = Number.isFinite(parsed) ? new Date(parsed).toISOString() : observation.capturedAtUtc;
+  return `${observation.machine}|${instant}|${observation.contentHash}`;
+}
+function sortObservations(observations) {
+  return [...observations].sort((a, b) => {
+    const time = Date.parse(a.capturedAtUtc) - Date.parse(b.capturedAtUtc);
+    if (time !== 0) return time;
+    if (a.contentHash !== b.contentHash) return a.contentHash < b.contentHash ? -1 : 1;
+    return a.id - b.id;
+  });
+}
+function batchObservations(observations) {
+  if (observations.length === 0) return [[]];
+  const size = TIMELINE_ANALYSIS_BATCH_SIZE;
+  const overlap = TIMELINE_ANALYSIS_BATCH_OVERLAP;
+  const step = size - overlap;
+  const batches = [];
+  for (let start = 0; start < observations.length; start += step) {
+    batches.push(observations.slice(start, start + size));
+    if (start + size >= observations.length) break;
+  }
+  return batches;
+}
+function safeObservation(observation) {
+  return {
+    id: observation.id,
+    machine: observation.machine,
+    capturedAtUtc: observation.capturedAtUtc,
+    app: observation.app,
+    windowTitle: observation.windowTitle,
+    ...observation.browserUrl ? { browserUrl: observation.browserUrl } : {},
+    contentHash: observation.contentHash
+  };
+}
+function safeCard(card) {
+  return {
+    id: card.id,
+    kind: card.kind,
+    title: card.title,
+    summary: card.summary,
+    categoryId: card.categoryId,
+    confidence: card.confidence,
+    startUtc: card.startUtc,
+    endUtc: card.endUtc,
+    machine: card.machine,
+    evidenceIds: card.evidenceIds,
+    evidenceRange: card.evidenceRange,
+    ...card.manualEdit ? { manualEdit: card.manualEdit } : {}
+  };
+}
+function buildTimelineAnalysisPrompt(input) {
+  const payload = {
+    date: input.date ?? null,
+    timezone: input.timezone ?? null,
+    categories: input.categories.map((category) => ({ id: category.id, name: category.name })),
+    preferences: input.preferences ?? [],
+    priorEdits: input.priorEdits ?? [],
+    cards: input.cards.map(safeCard),
+    observations: input.observations.map(safeObservation)
+  };
+  return `${INSTRUCTIONS}
+${JSON.stringify(payload)}`;
+}
+async function callComplete(complete, prompt, provider, model, timeoutMs, parent) {
+  const { promise: timeoutPromise, reject } = Promise.withResolvers();
+  const failOnce = (message, name) => {
+    reject(Object.assign(new Error(message), { name }));
+  };
+  const timer = setTimeout(() => failOnce("timeline analysis timed out", "TimeoutError"), timeoutMs);
+  if (parent?.aborted) {
+    clearTimeout(timer);
+    throw Object.assign(new Error("timeline analysis aborted"), { name: "AbortError" });
+  }
+  const onAbort = () => failOnce("timeline analysis aborted", "AbortError");
+  parent?.addEventListener("abort", onAbort, { once: true });
+  const signal = parent ? AbortSignal.any([parent, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
+  try {
+    return await Promise.race([complete({ prompt, provider, model, signal }), timeoutPromise]);
+  } finally {
+    clearTimeout(timer);
+    parent?.removeEventListener("abort", onAbort);
+  }
+}
+function asOp(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  if (!("cardId" in value) || typeof value.cardId !== "string" || value.cardId.length === 0) return null;
+  if (!("evidenceRange" in value)) return null;
+  const range = value.evidenceRange;
+  if (!range || typeof range !== "object" || Array.isArray(range)) return null;
+  if (!("firstKey" in range) || typeof range.firstKey !== "string" || range.firstKey.length === 0) return null;
+  if (!("lastKey" in range) || typeof range.lastKey !== "string" || range.lastKey.length === 0) return null;
+  if ("title" in value && value.title !== void 0 && typeof value.title !== "string") return null;
+  if ("summary" in value && value.summary !== void 0 && typeof value.summary !== "string") return null;
+  if ("categoryId" in value && value.categoryId !== void 0 && typeof value.categoryId !== "string") return null;
+  if ("uncertainty" in value && value.uncertainty !== void 0 && typeof value.uncertainty !== "string") return null;
+  if ("confidence" in value && value.confidence !== void 0 && (typeof value.confidence !== "number" || value.confidence < 0 || value.confidence > 1)) {
+    return null;
+  }
+  return {
+    cardId: value.cardId,
+    title: "title" in value && typeof value.title === "string" ? value.title : void 0,
+    summary: "summary" in value && typeof value.summary === "string" ? value.summary : void 0,
+    categoryId: "categoryId" in value && typeof value.categoryId === "string" ? value.categoryId : void 0,
+    confidence: "confidence" in value && typeof value.confidence === "number" ? value.confidence : void 0,
+    uncertainty: "uncertainty" in value && typeof value.uncertainty === "string" ? value.uncertainty : void 0,
+    evidenceRange: { firstKey: range.firstKey, lastKey: range.lastKey }
+  };
+}
+function parseOps(raw) {
+  if (typeof raw !== "string" || raw.trim().length === 0) return { ok: false, kind: "partial_output" };
+  let sawParsableShape = false;
+  for (const candidate of extractJsonCandidates(raw)) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      if (!("ops" in parsed) || !Array.isArray(parsed.ops)) {
+        sawParsableShape = true;
+        continue;
+      }
+      const out = [];
+      let valid = true;
+      for (const item of parsed.ops) {
+        const op = asOp(item);
+        if (!op) {
+          valid = false;
+          break;
+        }
+        out.push(op);
+      }
+      if (valid) return { ok: true, ops: out };
+      sawParsableShape = true;
+    } catch {
+      continue;
+    }
+  }
+  if (sawParsableShape) return { ok: false, kind: "invalid_schema" };
+  return { ok: false, kind: "malformed_json" };
+}
+function knownEvidenceKeys(cards, observations) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const observation of observations) keys.add(evidenceKeyOf(observation));
+  for (const card of cards) {
+    if (card.evidenceRange) {
+      keys.add(card.evidenceRange.firstKey);
+      keys.add(card.evidenceRange.lastKey);
+    }
+  }
+  return keys;
+}
+function applyOps(cards, ops, categories, evidenceKeys) {
+  if (ops.length === 0) return cards;
+  const byId = new Map(cards.map((card) => [card.id, card]));
+  const allowedCategories = new Set(categories.map((category) => category.id));
+  const next = /* @__PURE__ */ new Map();
+  for (const op of ops) {
+    const card = byId.get(op.cardId);
+    if (!card) return null;
+    if (!evidenceKeys.has(op.evidenceRange.firstKey) || !evidenceKeys.has(op.evidenceRange.lastKey)) return null;
+    if (op.categoryId !== void 0 && !allowedCategories.has(op.categoryId)) return null;
+    if (card.manualEdit) continue;
+    next.set(card.id, {
+      ...card,
+      ...op.title !== void 0 ? { title: op.title } : {},
+      ...op.summary !== void 0 ? { summary: op.summary } : {},
+      ...op.categoryId !== void 0 ? { categoryId: op.categoryId } : {},
+      ...op.confidence !== void 0 ? { confidence: op.confidence } : {}
+    });
+  }
+  if (next.size === 0) return cards;
+  return cards.map((card) => next.get(card.id) ?? card);
+}
+async function analyzeTimelineCards(input) {
+  const cards = input.cards;
+  if (!input.enabled) {
+    return { status: "disabled", cards };
+  }
+  const provider = requiredToken(input.provider, "provider");
+  const model = requiredToken(input.model, "model");
+  const complete = input.complete;
+  if (typeof complete !== "function") {
+    throw new TimelineAnalysisConfigError("complete is required");
+  }
+  const timeoutMs = input.timeoutMs ?? TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS;
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+    throw new TimelineAnalysisConfigError("timeoutMs must be a positive integer");
+  }
+  if (input.cards.length === 0 && input.observations.length === 0) {
+    return {
+      status: "invalid_output",
+      cards,
+      provider,
+      model,
+      promptVersion: TIMELINE_ANALYSIS_PROMPT_VERSION
+    };
+  }
+  const categories = input.categories ?? DEFAULT_TIMELINE_CATEGORIES;
+  const ordered = sortObservations(input.observations);
+  const batches = batchObservations(ordered);
+  const merged = /* @__PURE__ */ new Map();
+  try {
+    for (const batch of batches) {
+      const prompt = buildTimelineAnalysisPrompt({
+        date: input.date,
+        timezone: input.timezone,
+        cards: input.cards,
+        observations: batch,
+        categories,
+        preferences: input.preferences,
+        priorEdits: input.priorEdits
+      });
+      const raw = await callComplete(complete, prompt, provider, model, timeoutMs, input.signal);
+      const parsed = parseOps(raw);
+      if (!parsed.ok) return fail("invalid_output", cards, provider, model, parsed.kind);
+      for (const op of parsed.ops) merged.set(op.cardId, op);
+    }
+  } catch (error) {
+    return fail("provider_failed", cards, provider, model, classifyAnalysisProviderError(error));
+  }
+  const applied = applyOps(cards, [...merged.values()], categories, knownEvidenceKeys(cards, ordered));
+  if (!applied) return fail("invalid_output", cards, provider, model, "invalid_schema");
+  log.info(`timeline analysis status=ok provider=${provider} model=${model} promptVersion=${TIMELINE_ANALYSIS_PROMPT_VERSION}`);
+  return {
+    status: "ok",
+    cards: applied,
+    provider,
+    model,
+    promptVersion: TIMELINE_ANALYSIS_PROMPT_VERSION
+  };
+}
+
+// src/activity/timeline/analysis-metadata.ts
+var ANALYSIS_METADATA_MAX_FIELD_LENGTH = 120;
+var isAnalysisIdentifier = (value) => IDENTIFIER.test(value);
+var IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:\-\/]*$/;
+var FIELD_PATTERNS = {
+  provider: IDENTIFIER,
+  model: IDENTIFIER,
+  promptVersion: IDENTIFIER
+};
+function validateMetadataField(field, value) {
+  if (typeof value !== "string") {
+    throw new RangeError(
+      `analysis run metadata ${field} must be a string; received ${typeof value}`
+    );
+  }
+  if (value.length === 0) {
+    throw new RangeError(`analysis run metadata ${field} must not be empty`);
+  }
+  if (value.length > ANALYSIS_METADATA_MAX_FIELD_LENGTH) {
+    throw new RangeError(
+      `analysis run metadata ${field} is too long (max ${ANALYSIS_METADATA_MAX_FIELD_LENGTH} characters)`
+    );
+  }
+  if (/[\n\r\u2028\u2029]/.test(value)) {
+    throw new RangeError(`analysis run metadata ${field} must not contain a line break`);
+  }
+  const pattern = FIELD_PATTERNS[field];
+  if (pattern === void 0) {
+    throw new RangeError(`analysis run metadata has no pattern for field ${field}`);
+  }
+  if (!pattern.test(value)) {
+    throw new RangeError(
+      `analysis run metadata ${field} must be an identifier (letters, digits, and ._:-/ only)`
+    );
+  }
+  return value;
+}
+function buildAnalysisRunMetadata(input) {
+  const provider = validateMetadataField("provider", input.provider);
+  const model = validateMetadataField("model", input.model);
+  const promptVersion = validateMetadataField("promptVersion", input.promptVersion);
+  const observationCount = input.observationCount;
+  if (typeof observationCount !== "number" || !Number.isInteger(observationCount) || observationCount < 0) {
+    throw new RangeError(
+      `analysis run metadata observationCount must be a non-negative integer; received ${typeof observationCount}`
+    );
+  }
+  return { provider, model, promptVersion, observationCount };
+}
+
+// src/activity/config.ts
+import path3 from "path";
+
+// src/activity/journal-heading.ts
+function normalizeJournalHeading(value) {
+  const heading = value.trim();
+  if (heading.length === 0) return { ok: false, error: "empty_heading" };
+  if (heading.includes("\n") || heading.includes("\r")) {
+    return { ok: false, error: "invalid_heading" };
+  }
+  return { ok: true, heading };
+}
+function applyLegacyJournalHeading(input) {
+  if (input.heading === void 0) {
+    return { journalSection: input.journalSection, usedLegacyHeading: false, ignoredLegacyHeading: false };
+  }
+  if (typeof input.heading !== "string") {
+    throw new TypeError("activity.timeline.journal.heading must be a string");
+  }
+  const normalized = normalizeJournalHeading(input.heading);
+  if (!normalized.ok) {
+    throw new RangeError(
+      normalized.error === "empty_heading" ? "activity.timeline.journal.heading must be a non-empty string" : "activity.timeline.journal.heading must not contain a newline"
+    );
+  }
+  if (input.journalSection.trim().length > 0) {
+    return {
+      journalSection: input.journalSection,
+      usedLegacyHeading: false,
+      ignoredLegacyHeading: true
+    };
+  }
+  return {
+    journalSection: normalized.heading,
+    usedLegacyHeading: true,
+    ignoredLegacyHeading: false
+  };
+}
+
+// src/activity/journal-source.ts
+var JOURNAL_SOURCES = ["memoryDir", "vault"];
+function resolveJournalSource(input) {
+  if (input.source === "file") {
+    return { ok: true, mode: "memoryDir", deprecatedAlias: "file" };
+  }
+  if (JOURNAL_SOURCES.includes(input.source)) {
+    return { ok: true, mode: input.source };
+  }
+  return { ok: false, error: "unknown_source" };
+}
+
+// src/activity/config.ts
+var EXTRACTION_MODES = ["off", "smart"];
+var IMPORTANCE_LEVELS = ["critical", "high", "normal", "low", "trivial"];
+function defaultActivityConfig() {
+  return {
+    enabled: false,
+    timezone: "UTC",
+    syncDays: 1,
+    autoSyncIntervalMinutes: 15,
+    sources: [],
+    extractionMode: "off",
+    sourceTrust: 0.6,
+    autoApproveTrust: 0.8,
+    reviewTrust: 0.5,
+    minConfidence: 0.7,
+    minImportance: "normal",
+    maxMemoriesPerDay: 0,
+    timeline: {
+      enabled: false,
+      analysis: parseTimelineAnalysisConfig(void 0),
+      journal: { enabled: false, source: "memoryDir", extractionMode: "off" },
+      qa: { enabled: false, maxRangeDays: 31 },
+      vault: parseTimelineVaultConfig(void 0)
+    }
+  };
+}
+function asRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${name} must be an object`);
+  }
+  return value;
+}
+function optionalString(value, name) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length === 0) throw new TypeError(`${name} must be a non-empty string`);
+  return value;
+}
+function parseUnitInterval(value, key, fallback) {
+  if (value === void 0) return fallback;
+  const parsed = coerceNumber(value);
+  if (parsed === void 0 || !Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+    throw new RangeError(`activity.${key} must be a number in [0, 1]`);
+  }
+  return parsed;
+}
+function validateActivityBaseUrl(baseUrl) {
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    throw new RangeError(`activity source baseUrl must be a valid URL: ${baseUrl}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new RangeError("activity source baseUrl must use HTTP or HTTPS");
+  }
+  if (!isLoopbackHost(parsed.hostname)) {
+    throw new RangeError(`activity source baseUrl must target a loopback host (got ${parsed.hostname})`);
+  }
+  return parsed;
+}
+function parseSource(value) {
+  const raw = asRecord(value, "activity source");
+  const machineLabel = optionalString(raw.machineLabel, "activity source machineLabel");
+  const baseUrl = optionalString(raw.baseUrl, "activity source baseUrl");
+  if (machineLabel === void 0 || baseUrl === void 0) {
+    throw new TypeError("activity source requires machineLabel and baseUrl");
+  }
+  if (machineLabel.trim().length === 0) {
+    throw new RangeError("activity source machineLabel must not be blank");
+  }
+  validateActivityBaseUrl(baseUrl);
+  const token = optionalString(raw.token, "activity source token");
+  return { machineLabel, baseUrl, ...token === void 0 ? {} : { token } };
+}
+function parseActivityConfig(raw) {
+  const defaults = defaultActivityConfig();
+  if (raw === void 0 || raw === null) {
+    return { ...defaults };
+  }
+  const config = asRecord(raw, "activity");
+  const enabledValue = coerceBooleanLike(config.enabled, "activity.enabled");
+  if (config.enabled !== void 0 && enabledValue === void 0) {
+    throw new TypeError("activity.enabled must be a boolean");
+  }
+  const timezone = optionalString(config.timezone, "activity.timezone") ?? "UTC";
+  assertValidTimezone(timezone);
+  const syncDaysValue = coerceNumber(config.syncDays, "activity.syncDays");
+  if (config.syncDays !== void 0 && syncDaysValue === void 0) {
+    throw new TypeError("activity.syncDays must be a finite number");
+  }
+  const syncDays = syncDaysValue ?? 1;
+  if (!Number.isInteger(syncDays) || syncDays < 1 || syncDays > 90) {
+    throw new RangeError("activity.syncDays must be an integer from 1 to 90");
+  }
+  const intervalValue = coerceNumber(config.autoSyncIntervalMinutes, "activity.autoSyncIntervalMinutes");
+  if (config.autoSyncIntervalMinutes !== void 0 && intervalValue === void 0) {
+    throw new TypeError("activity.autoSyncIntervalMinutes must be a finite number");
+  }
+  const autoSyncIntervalMinutes = intervalValue ?? 15;
+  if (!Number.isInteger(autoSyncIntervalMinutes) || autoSyncIntervalMinutes < 1 || autoSyncIntervalMinutes > 1440) {
+    throw new RangeError("activity.autoSyncIntervalMinutes must be an integer from 1 to 1440");
+  }
+  if (config.sources !== void 0 && !Array.isArray(config.sources)) {
+    throw new TypeError("activity.sources must be an array");
+  }
+  const sources = (config.sources ?? []).map(parseSource);
+  const labels = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    if (labels.has(source.machineLabel)) {
+      throw new RangeError(`activity source machineLabel must be unique: ${source.machineLabel}`);
+    }
+    labels.add(source.machineLabel);
+  }
+  const enabled = enabledValue ?? false;
+  if (enabled && sources.length === 0) throw new RangeError("activity.enabled requires at least one source");
+  const extractionMode = config.extractionMode === void 0 ? defaults.extractionMode : config.extractionMode;
+  if (typeof extractionMode !== "string" || !EXTRACTION_MODES.includes(extractionMode)) {
+    throw new RangeError(`activity.extractionMode must be one of: ${EXTRACTION_MODES.join(", ")}`);
+  }
+  const minImportance = config.minImportance === void 0 ? defaults.minImportance : config.minImportance;
+  if (typeof minImportance !== "string" || !IMPORTANCE_LEVELS.includes(minImportance)) {
+    throw new RangeError(`activity.minImportance must be one of: ${IMPORTANCE_LEVELS.join(", ")}`);
+  }
+  const rawMaxMemoriesPerDay = config.maxMemoriesPerDay === void 0 ? defaults.maxMemoriesPerDay : config.maxMemoriesPerDay;
+  const maxMemoriesPerDay = coerceNumber(rawMaxMemoriesPerDay);
+  if (maxMemoriesPerDay === void 0 || !Number.isInteger(maxMemoriesPerDay) || maxMemoriesPerDay < 0) {
+    throw new RangeError("activity.maxMemoriesPerDay must be a non-negative integer");
+  }
+  const autoApproveTrust = parseUnitInterval(config.autoApproveTrust, "autoApproveTrust", defaults.autoApproveTrust);
+  const reviewTrust = parseUnitInterval(config.reviewTrust, "reviewTrust", defaults.reviewTrust);
+  if (reviewTrust >= autoApproveTrust) {
+    throw new RangeError(
+      `activity.reviewTrust (${reviewTrust}) must be below autoApproveTrust (${autoApproveTrust})`
+    );
+  }
+  return {
+    enabled,
+    timezone,
+    syncDays,
+    autoSyncIntervalMinutes,
+    sources,
+    extractionMode,
+    sourceTrust: parseUnitInterval(config.sourceTrust, "sourceTrust", defaults.sourceTrust),
+    autoApproveTrust,
+    reviewTrust,
+    minConfidence: parseUnitInterval(config.minConfidence, "minConfidence", defaults.minConfidence),
+    minImportance,
+    maxMemoriesPerDay,
+    timeline: parseTimelineConfig(config.timeline)
+  };
+}
+function parseTimelineConfig(raw) {
+  if (raw === void 0) {
+    return {
+      enabled: false,
+      analysis: parseTimelineAnalysisConfig(void 0),
+      journal: { enabled: false, source: "memoryDir", extractionMode: "off" },
+      qa: parseTimelineQaConfig(void 0),
+      vault: parseTimelineVaultConfig(void 0)
+    };
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError("activity.timeline must be an object");
+  }
+  const timeline = raw;
+  const enabledValue = coerceBooleanLike(timeline.enabled, "activity.timeline.enabled");
+  if (timeline.enabled !== void 0 && enabledValue === void 0) {
+    throw new TypeError("activity.timeline.enabled must be a boolean");
+  }
+  const journal = parseTimelineJournalConfig(timeline.journal);
+  let vault = parseTimelineVaultConfig(timeline.vault);
+  const journalRaw = timeline.journal;
+  const headingRaw = typeof journalRaw === "object" && journalRaw !== null && !Array.isArray(journalRaw) ? journalRaw.heading : void 0;
+  if (headingRaw !== void 0) {
+    const aliased = applyLegacyJournalHeading({
+      journalSection: vault.readback.journalSection,
+      heading: headingRaw
+    });
+    process.emitWarning(
+      aliased.ignoredLegacyHeading ? "activity.timeline.journal.heading is deprecated and ignored because activity.timeline.vault.readback.journalSection is set; use vault.readback.journalSection." : "activity.timeline.journal.heading is deprecated; use activity.timeline.vault.readback.journalSection.",
+      { type: "DeprecationWarning", code: "REMNIC_DEP_JOURNAL_HEADING" }
+    );
+    if (aliased.usedLegacyHeading) {
+      vault = { ...vault, readback: { ...vault.readback, journalSection: aliased.journalSection } };
+    }
+  }
+  if (journal.source === "vault") {
+    const prereq = checkVaultJournalPrerequisites({
+      vaultEnabled: vault.enabled,
+      dailyNotePath: vault.dailyNotePath,
+      journalSection: vault.readback.journalSection
+    });
+    if (!prereq.ok) {
+      throw new RangeError(
+        `activity.timeline.journal.source "vault" requires ${prereq.message}`
+      );
+    }
+  }
+  return {
+    enabled: enabledValue ?? false,
+    analysis: parseTimelineAnalysisConfig(timeline.analysis),
+    journal,
+    qa: parseTimelineQaConfig(timeline.qa),
+    vault
+  };
+}
+function parseTimelineAnalysisConfig(raw) {
+  if (raw === void 0) return { enabled: false };
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError("activity.timeline.analysis must be an object");
+  }
+  const analysis = raw;
+  const enabled = requireBool(analysis.enabled, "activity.timeline.analysis.enabled", false);
+  const provider = optionalNonEmptyString(analysis.provider, "activity.timeline.analysis.provider")?.trim();
+  const model = optionalNonEmptyString(analysis.model, "activity.timeline.analysis.model")?.trim();
+  for (const [key, value] of [
+    ["provider", provider],
+    ["model", model]
+  ]) {
+    if (value === void 0) continue;
+    if (key === "provider" && value.includes("/")) {
+      throw new RangeError(
+        "activity.timeline.analysis.provider must be a single provider segment (no '/')"
+      );
+    }
+    if (!isAnalysisIdentifier(value)) {
+      throw new RangeError(
+        `activity.timeline.analysis.${key} must be an identifier (letters, digits, and ._:-/ only)`
+      );
+    }
+    if (value.length > ANALYSIS_METADATA_MAX_FIELD_LENGTH) {
+      throw new RangeError(
+        `activity.timeline.analysis.${key} must be at most ${ANALYSIS_METADATA_MAX_FIELD_LENGTH} characters`
+      );
+    }
+  }
+  if (enabled && (provider === void 0 || model === void 0)) {
+    throw new RangeError(
+      "activity.timeline.analysis.provider and model are required when analysis is enabled"
+    );
+  }
+  const timeoutMsValue = coerceNumber(analysis.timeoutMs, "activity.timeline.analysis.timeoutMs");
+  if (analysis.timeoutMs !== void 0 && timeoutMsValue === void 0) {
+    throw new TypeError("activity.timeline.analysis.timeoutMs must be a finite number");
+  }
+  const timeoutMs = timeoutMsValue ?? TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS;
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 1e3 || timeoutMs > 12e4) {
+    throw new RangeError("activity.timeline.analysis.timeoutMs must be an integer from 1000 to 120000");
+  }
+  if (analysis.preferences !== void 0) {
+    if (!Array.isArray(analysis.preferences)) {
+      throw new TypeError("activity.timeline.analysis.preferences must be an array of strings");
+    }
+    if (analysis.preferences.length > 16) {
+      throw new RangeError("activity.timeline.analysis.preferences supports at most 16 entries");
+    }
+    for (const entry of analysis.preferences) {
+      if (typeof entry !== "string" || entry.trim().length === 0) {
+        throw new TypeError("activity.timeline.analysis.preferences entries must be non-empty strings");
+      }
+      if (entry.length > 200) {
+        throw new RangeError("activity.timeline.analysis.preferences entries must be at most 200 characters");
+      }
+    }
+  }
+  const preferences = analysis.preferences;
+  return {
+    enabled,
+    ...provider === void 0 ? {} : { provider },
+    ...model === void 0 ? {} : { model },
+    ...analysis.timeoutMs !== void 0 || timeoutMsValue !== void 0 ? { timeoutMs } : {},
+    ...preferences === void 0 ? {} : { preferences }
+  };
+}
+function parseTimelineVaultConfig(raw) {
+  if (raw === void 0) return defaultVaultConfig();
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError("activity.timeline.vault must be an object");
+  }
+  const vault = raw;
+  const enabled = requireBool(vault.enabled, "activity.timeline.vault.enabled", false);
+  const createMissingNotes = requireBool(vault.createMissingNotes, "activity.timeline.vault.createMissingNotes", false);
+  const autoPublish = requireBool(vault.autoPublish, "activity.timeline.vault.autoPublish", true);
+  const vaultPath = optionalNonEmptyString(vault.vaultPath, "activity.timeline.vault.vaultPath") ?? "";
+  const dailyNotePath = optionalNonEmptyString(vault.dailyNotePath, "activity.timeline.vault.dailyNotePath") ?? "{yyyy}-{MM}-{dd}.md";
+  const weeklyNotePath = optionalNonEmptyString(vault.weeklyNotePath, "activity.timeline.vault.weeklyNotePath") ?? "";
+  const noteTemplate = optionalNonEmptyString(vault.noteTemplate, "activity.timeline.vault.noteTemplate") ?? "";
+  const insertUnderHeading = optionalNonEmptyString(vault.insertUnderHeading, "activity.timeline.vault.insertUnderHeading") ?? "";
+  if (insertUnderHeading.length > 0) {
+    const heading = normalizeJournalHeading(insertUnderHeading);
+    if (!heading.ok || heading.heading !== insertUnderHeading) {
+      throw new RangeError(
+        "activity.timeline.vault.insertUnderHeading must be a non-empty trimmed single-line heading"
+      );
+    }
+    if (!headingSurvivesRoundTrip(insertUnderHeading)) {
+      throw new RangeError(
+        "activity.timeline.vault.insertUnderHeading must survive a heading render-and-parse round trip"
+      );
+    }
+  }
+  if (typeof vault.sectionStrategy !== "undefined" && typeof vault.sectionStrategy !== "string") {
+    throw new TypeError("activity.timeline.vault.sectionStrategy must be a string");
+  }
+  const sectionStrategy = vault.sectionStrategy ?? "markers";
+  if (sectionStrategy !== "markers" && sectionStrategy !== "heading") {
+    throw new RangeError('activity.timeline.vault.sectionStrategy must be one of "markers", "heading"');
+  }
+  const tildeRooted = vaultPath === "~" || vaultPath.startsWith("~/") || vaultPath.startsWith("~\\");
+  if (enabled && (vaultPath.trim().length === 0 || !tildeRooted && !path3.isAbsolute(vaultPath))) {
+    throw new RangeError(
+      `activity.timeline.vault.vaultPath must be an absolute or \`~\`-rooted path when activity.timeline.vault.enabled is true; a relative path resolves against the process working directory (got ${JSON.stringify(vaultPath)})`
+    );
+  }
+  try {
+    validateVaultNoteTemplate(dailyNotePath);
+  } catch (err) {
+    throw new RangeError(`activity.timeline.vault.dailyNotePath: ${err.message}`);
+  }
+  if (weeklyNotePath.length > 0) {
+    try {
+      validateVaultNoteTemplate(weeklyNotePath);
+    } catch (err) {
+      throw new RangeError(`activity.timeline.vault.weeklyNotePath: ${err.message}`);
+    }
+  }
+  if (createMissingNotes) {
+    if (noteTemplate.length === 0) {
+      throw new RangeError(
+        "activity.timeline.vault.noteTemplate must name a vault-relative template file when activity.timeline.vault.createMissingNotes is true"
+      );
+    }
+    try {
+      validateVaultNoteTemplate(noteTemplate);
+    } catch (err) {
+      throw new RangeError(`activity.timeline.vault.noteTemplate: ${err.message}`);
+    }
+  }
+  const publish = parseVaultPublishBlock(vault.publish, weeklyNotePath);
+  if (sectionStrategy === "heading") {
+    for (const kind of ["timeline", "standup", "weekly", "locations"]) {
+      if (!headingSurvivesRoundTrip(publish[kind].section)) {
+        throw new RangeError(
+          `activity.timeline.vault.publish.${kind}.section must survive a heading render-and-parse round trip`
+        );
+      }
+    }
+  }
+  const wikilinksRaw = vault.wikilinks;
+  const wikilinks = wikilinksRaw === void 0 ? { places: false, placesFolder: "Places" } : parseVaultWikilinks(wikilinksRaw);
+  const propertiesRaw = vault.properties;
+  const properties = propertiesRaw === void 0 ? { mode: "off", prefix: "remnic_" } : parseVaultProperties(propertiesRaw);
+  const readbackRaw = vault.readback;
+  if (readbackRaw !== void 0 && (typeof readbackRaw !== "object" || readbackRaw === null || Array.isArray(readbackRaw))) {
+    throw new TypeError("activity.timeline.vault.readback must be an object");
+  }
+  const readbackJournalSection = optionalNonEmptyString(
+    readbackRaw?.journalSection,
+    "activity.timeline.vault.readback.journalSection"
+  );
+  if (readbackJournalSection !== void 0 && readbackJournalSection.length > 0) {
+    const heading = normalizeJournalHeading(readbackJournalSection);
+    if (!heading.ok || heading.heading !== readbackJournalSection) {
+      throw new RangeError(
+        "activity.timeline.vault.readback.journalSection must be a non-empty trimmed single-line heading"
+      );
+    }
+  }
+  const readback = {
+    journalSection: readbackJournalSection ?? ""
+  };
+  return {
+    enabled,
+    vaultPath,
+    dailyNotePath,
+    weeklyNotePath,
+    createMissingNotes,
+    noteTemplate,
+    sectionStrategy,
+    publish,
+    insertUnderHeading,
+    readback,
+    wikilinks,
+    properties,
+    autoPublish
+  };
+}
+function defaultVaultConfig() {
+  return {
+    enabled: false,
+    vaultPath: "",
+    dailyNotePath: "{yyyy}-{MM}-{dd}.md",
+    weeklyNotePath: "",
+    createMissingNotes: false,
+    noteTemplate: "",
+    sectionStrategy: "markers",
+    publish: {
+      timeline: { enabled: true, target: "daily", section: "Timeline" },
+      standup: { enabled: false, target: "daily", section: "Standup" },
+      weekly: { enabled: false, target: "weekly", section: "Weekly Review" },
+      locations: { enabled: false, target: "daily", section: "Locations" }
+    },
+    insertUnderHeading: "",
+    wikilinks: { places: false, placesFolder: "Places" },
+    properties: { mode: "off", prefix: "remnic_" },
+    autoPublish: true,
+    readback: { journalSection: "" }
+  };
+}
+function requireBool(value, key, fallback) {
+  const coerced = coerceBooleanLike(value, key);
+  if (value === void 0) return fallback;
+  if (coerced === void 0) {
+    throw new TypeError(`${key} must be a boolean`);
+  }
+  return coerced;
+}
+function optionalNonEmptyString(value, key) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new TypeError(`${key} must be a string`);
+  }
+  return value;
+}
+function parseVaultPublishBlock(raw, weeklyNotePath) {
+  const defaults = defaultVaultConfig().publish;
+  if (raw === void 0) return defaults;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError("activity.timeline.vault.publish must be an object");
+  }
+  const block = raw;
+  const publish = {
+    timeline: parseVaultTarget(block.timeline, "timeline", defaults.timeline, weeklyNotePath),
+    standup: parseVaultTarget(block.standup, "standup", defaults.standup, weeklyNotePath),
+    weekly: parseVaultTarget(block.weekly, "weekly", defaults.weekly, weeklyNotePath),
+    locations: parseVaultTarget(block.locations, "locations", defaults.locations, weeklyNotePath)
+  };
+  for (const targetFile of ["daily", "weekly"]) {
+    const sections = ["timeline", "standup", "weekly", "locations"].filter((kind) => publish[kind].target === targetFile && publish[kind].enabled).map((kind) => publish[kind].section);
+    const duplicates = sections.filter((section, index) => sections.indexOf(section) !== index);
+    if (duplicates.length > 0) {
+      throw new RangeError(
+        `activity.timeline.vault.publish section names must be unique per target file; duplicate ${targetFile} section(s): ${[...new Set(duplicates)].join(", ")}`
+      );
+    }
+  }
+  return publish;
+}
+function parseVaultTarget(raw, kind, fallback, weeklyNotePath) {
+  if (raw === void 0) return fallback;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError(`activity.timeline.vault.publish.${kind} must be an object`);
+  }
+  const entry = raw;
+  const enabled = requireBool(entry.enabled, `activity.timeline.vault.publish.${kind}.enabled`, fallback.enabled);
+  const target = entry.target === void 0 ? fallback.target : entry.target;
+  if (target !== "daily" && target !== "weekly") {
+    throw new RangeError(`activity.timeline.vault.publish.${kind}.target must be one of "daily", "weekly"`);
+  }
+  const section = entry.section === void 0 ? fallback.section : entry.section;
+  if (typeof section !== "string" || section.trim().length === 0 || section !== section.trim()) {
+    throw new RangeError(`activity.timeline.vault.publish.${kind}.section must be a non-empty trimmed string`);
+  }
+  if (!validateRegionName(section).ok) {
+    throw new RangeError(
+      `activity.timeline.vault.publish.${kind}.section must not contain a line break or "-->"`
+    );
+  }
+  if (enabled && target === "weekly" && weeklyNotePath.length === 0) {
+    throw new RangeError(
+      `activity.timeline.vault.publish.${kind}.target is "weekly" but activity.timeline.vault.weeklyNotePath is empty; configure weeklyNotePath first`
+    );
+  }
+  return { enabled, target, section };
+}
+function parseVaultWikilinks(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError("activity.timeline.vault.wikilinks must be an object");
+  }
+  const block = raw;
+  const places = requireBool(block.places, "activity.timeline.vault.wikilinks.places", false);
+  const placesFolder = optionalNonEmptyString(block.placesFolder, "activity.timeline.vault.wikilinks.placesFolder") ?? "Places";
+  return { places, placesFolder };
+}
+function parseVaultProperties(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError("activity.timeline.vault.properties must be an object");
+  }
+  const block = raw;
+  const mode = block.mode === void 0 ? "off" : block.mode;
+  if (mode !== "off" && mode !== "frontmatter" && mode !== "dataview-inline") {
+    throw new RangeError(
+      'activity.timeline.vault.properties.mode must be one of "off", "frontmatter", "dataview-inline"'
+    );
+  }
+  const prefix = optionalNonEmptyString(block.prefix, "activity.timeline.vault.properties.prefix") ?? "remnic_";
+  if (prefix.trim().length === 0 || prefix !== prefix.trim()) {
+    throw new RangeError("activity.timeline.vault.properties.prefix must be non-empty and trimmed");
+  }
+  return { mode, prefix };
+}
+function parseTimelineJournalConfig(raw) {
+  if (raw === void 0) return { enabled: false, source: "memoryDir", extractionMode: "off" };
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError("activity.timeline.journal must be an object");
+  }
+  const journal = raw;
+  const enabledValue = coerceBooleanLike(journal.enabled, "activity.timeline.journal.enabled");
+  if (journal.enabled !== void 0 && enabledValue === void 0) {
+    throw new TypeError("activity.timeline.journal.enabled must be a boolean");
+  }
+  const source = journal.source === void 0 ? "memoryDir" : typeof journal.source === "string" ? journal.source : "";
+  const resolved = resolveJournalSource({ source });
+  if (!resolved.ok) {
+    throw new RangeError('activity.timeline.journal.source must be one of "memoryDir", "vault"');
+  }
+  if (resolved.deprecatedAlias === "file") {
+    process.emitWarning(
+      'activity.timeline.journal.source "file" is deprecated; use "memoryDir".',
+      { type: "DeprecationWarning", code: "REMNIC_DEP_JOURNAL_SOURCE_FILE" }
+    );
+  }
+  const extractionMode = journal.extractionMode === void 0 ? "off" : journal.extractionMode;
+  if (extractionMode !== "off" && extractionMode !== "review") {
+    throw new RangeError('activity.timeline.journal.extractionMode must be one of "off", "review"');
+  }
+  return { enabled: enabledValue ?? false, source: resolved.mode, extractionMode };
+}
+function parseTimelineQaConfig(raw) {
+  if (raw === void 0) return { enabled: false, maxRangeDays: 31 };
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError("activity.timeline.qa must be an object");
+  }
+  const qa = raw;
+  const enabledValue = coerceBooleanLike(qa.enabled, "activity.timeline.qa.enabled");
+  if (qa.enabled !== void 0 && enabledValue === void 0) {
+    throw new TypeError("activity.timeline.qa.enabled must be a boolean");
+  }
+  const maxRangeDaysValue = coerceNumber(qa.maxRangeDays, "activity.timeline.qa.maxRangeDays");
+  if (qa.maxRangeDays !== void 0 && maxRangeDaysValue === void 0) {
+    throw new TypeError("activity.timeline.qa.maxRangeDays must be an integer from 1 to 366");
+  }
+  const maxRangeDays = maxRangeDaysValue ?? 31;
+  if (!Number.isInteger(maxRangeDays) || maxRangeDays < 1 || maxRangeDays > 366) {
+    throw new RangeError("activity.timeline.qa.maxRangeDays must be an integer from 1 to 366");
+  }
+  return { enabled: enabledValue ?? false, maxRangeDays };
+}
+
+export {
+  VAULT_JOURNAL_PREREQUISITES,
+  checkVaultJournalPrerequisites,
+  resolveJournalSource,
+  VAULT_TEMPLATE_TOKENS,
+  expandVaultTemplateTokens,
+  validateVaultNoteTemplate,
+  resolveVaultNotePath,
+  applyManagedRegion,
+  fileLines,
+  parseAtxHeading,
+  headingSurvivesRoundTrip,
+  publishVaultRegion,
+  validateRegionName,
+  ANALYSIS_FAILURE_KINDS,
+  isAnalysisFailureKind,
+  classifyAnalysisFailure,
+  TimelineAnalysisProviderError,
+  TIMELINE_ANALYSIS_LOCAL_PROVIDER_ID,
+  classifyAnalysisProviderError,
+  timelineAnalysisCompleteFromClients,
+  TIMELINE_RESERVED_UNKNOWN,
+  TIMELINE_RESERVED_IDLE,
+  TIMELINE_RESERVED_PAUSE,
+  DEFAULT_TIMELINE_CATEGORIES,
+  validateTimelineCategories,
+  sortTimelineCategories,
+  TIMELINE_ANALYSIS_PROMPT_VERSION,
+  TIMELINE_ANALYSIS_BATCH_SIZE,
+  TIMELINE_ANALYSIS_BATCH_OVERLAP,
+  TIMELINE_ANALYSIS_DEFAULT_TIMEOUT_MS,
+  TimelineAnalysisConfigError,
+  buildTimelineAnalysisPrompt,
+  analyzeTimelineCards,
+  ANALYSIS_METADATA_MAX_FIELD_LENGTH,
+  isAnalysisIdentifier,
+  buildAnalysisRunMetadata,
+  defaultActivityConfig,
+  validateActivityBaseUrl,
+  parseActivityConfig,
+  parseTimelineVaultConfig
+};
+//# sourceMappingURL=chunk-QOPB6KE3.js.map