recallnest 2.2.1 → 2.3.0

package/src/conversation-importer.ts

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import type { PersistMemoryDeps } from "./capture-engine.js";
 import { persistMemory } from "./capture-engine.js";
 import type { StoredMemoryRecord } from "./memory-schema.js";
+import { isConnectorOutputV1, type ConnectorOutputV1 } from "./connector-types.js";
 
 export interface NormalizedMessage {
   role: "user" | "assistant" | "system";
@@ -14,7 +15,8 @@ export type ConversationFormat =
   | "claude-ai"
   | "chatgpt"
   | "slack"
-  | "plaintext";
+  | "plaintext"
+  | "connector-v1";
 
 // ---------------------------------------------------------------------------
 // Format detection
@@ -40,6 +42,10 @@ export function detectFormat(content: string): ConversationFormat {
       }
 
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        // connector-v1: highest priority — explicit version tag
+        if (isConnectorOutputV1(parsed)) {
+          return "connector-v1";
+        }
         if (parsed.chat_conversations !== undefined) {
           return "claude-ai";
         }
@@ -366,6 +372,22 @@ export function normalizePlaintext(content: string): NormalizedMessage[] {
   return messages;
 }
 
+// ---------------------------------------------------------------------------
+// Connector-v1 normalizer
+// ---------------------------------------------------------------------------
+
+export function normalizeConnectorV1(content: string): NormalizedMessage[] {
+  const parsed: ConnectorOutputV1 = JSON.parse(content);
+  if (!isConnectorOutputV1(parsed)) {
+    throw new Error("Invalid connector-v1 format: missing version/source/scope/records");
+  }
+  return parsed.records.map((r) => ({
+    role: "user" as const,
+    content: r.title ? `[${r.title}] ${r.text}` : r.text,
+    ...(r.timestamp ? { timestamp: r.timestamp } : {}),
+  }));
+}
+
 // ---------------------------------------------------------------------------
 // Unified normalize dispatcher
 // ---------------------------------------------------------------------------
@@ -382,6 +404,8 @@ export function normalizeConversation(content: string, format: ConversationForma
       return normalizeSlack(content);
     case "plaintext":
       return normalizePlaintext(content);
+    case "connector-v1":
+      return normalizeConnectorV1(content);
   }
 }
 

package/src/data-checkup.ts

@@ -15,6 +15,7 @@
 import type { MemoryEntry, MemoryStore } from "./store.js";
 import { resolveTier, type MemoryTier } from "./decay-engine.js";
 import { measureInterferenceDensity } from "./interference-detector.js";
+import { readHeartbeats, checkSourceStaleness, formatAge } from "./source-heartbeat.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -151,7 +152,33 @@ function checkVersionGroups(entries: MemoryEntry[]): CheckResult {
   };
 }
 
-/** Check 6 (F2): Interference density — detect semantic clustering pressure. */
+/** Check 6 (GB-3): Source health — detect stale connector data sources. */
+function checkSourceHealth(heartbeatPath?: string): CheckResult {
+  const heartbeats = readHeartbeats(heartbeatPath);
+  const sources = Object.values(heartbeats);
+  if (sources.length === 0) {
+    return { name: "source_health", status: "ok", detail: "No connector sources tracked yet" };
+  }
+
+  const stale30 = checkSourceStaleness(30, heartbeatPath);
+  const stale7 = checkSourceStaleness(7, heartbeatPath);
+
+  const summary = sources
+    .map((s) => `${s.source}: ${formatAge(s.lastIngest)}`)
+    .join(", ");
+
+  if (stale30.length > 0) {
+    const names = stale30.map((s) => `${s.source} (${s.daysSince}d)`).join(", ");
+    return { name: "source_health", status: "error", detail: `${summary} — critically stale: ${names}` };
+  }
+  if (stale7.length > 0) {
+    const names = stale7.map((s) => `${s.source} (${s.daysSince}d)`).join(", ");
+    return { name: "source_health", status: "warning", detail: `${summary} — stale: ${names}` };
+  }
+  return { name: "source_health", status: "ok", detail: `All sources fresh: ${summary}` };
+}
+
+/** Check 7 (F2): Interference density — detect semantic clustering pressure. */
 function checkInterferenceDensity(entries: MemoryEntry[]): CheckResult {
   // Only check entries with vectors (skip schema/empty entries)
   const withVectors = entries.filter(e => e.vector && e.vector.length > 0);
@@ -192,6 +219,8 @@ function checkInterferenceDensity(entries: MemoryEntry[]): CheckResult {
 export interface CheckupDeps {
   store: Pick<MemoryStore, "list" | "stats">;
   openConflictCount: number;
+  /** Optional override path for source-heartbeat.json (used in tests). */
+  heartbeatPath?: string;
 }
 
 export async function runDataCheckup(deps: CheckupDeps): Promise<CheckupReport> {
@@ -204,6 +233,7 @@ export async function runDataCheckup(deps: CheckupDeps): Promise<CheckupReport>
       checkTierDistribution(entries),
       checkConflictBacklog(deps.openConflictCount),
       checkVersionGroups(entries),
+      checkSourceHealth(deps.heartbeatPath),
       checkInterferenceDensity(entries),
     ],
     totalEntries: entries.length,

package/src/doctor.ts

@@ -27,6 +27,7 @@ import {
 } from "./memory-schema.js";
 import { collectScopeInventory, type ScopeInventoryReport } from "./scope-inventory.js";
 import { MemoryStore, type MemoryEntry, validateStoragePath } from "./store.js";
+import { readHeartbeats, formatAge } from "./source-heartbeat.js";
 
 interface CheckResult {
   name: string;
@@ -508,6 +509,34 @@ export async function runDoctor(options: { ci?: boolean } = {}): Promise<CheckRe
     ));
   }
 
+  // GB-3: Source heartbeat summary
+  try {
+    const heartbeats = readHeartbeats();
+    const sources = Object.values(heartbeats);
+    if (sources.length === 0) {
+      results.push(pass("Source heartbeats", "no connector sources tracked yet"));
+    } else {
+      const summary = sources
+        .map((s) => `${s.source}: ${formatAge(s.lastIngest)}`)
+        .join(", ");
+      const staleCount = sources.filter((s) => {
+        const daysSince = (Date.now() - Date.parse(s.lastIngest)) / 86_400_000;
+        return daysSince > 7;
+      }).length;
+      if (staleCount > 0) {
+        results.push(warn(
+          "Source heartbeats",
+          `${summary} (${staleCount} stale >7d)`,
+          "lm ingest --connector <file>",
+        ));
+      } else {
+        results.push(pass("Source heartbeats", summary));
+      }
+    }
+  } catch {
+    results.push(warn("Source heartbeats", "unable to read heartbeat file"));
+  }
+
   return results;
 }
 

package/src/ingest.ts

@@ -15,6 +15,9 @@ import { detectLang, tokenizeFts } from "./language-hook.js";
 import type { MemoryStore, MemoryEntry } from "./store.js";
 import type { Embedder } from "./embedder.js";
 import { chunkDocument, type ChunkerConfig } from "./chunker.js";
+import type { ConnectorOutputV1, ConnectorRecord } from "./connector-types.js";
+import { isConnectorOutputV1 } from "./connector-types.js";
+import { isObsidianVault, scanVault } from "./obsidian-connector.js";
 import { segmentEvents, type EventSegmenterConfig, DEFAULT_EVENT_SEGMENTER_CONFIG } from "./event-segmenter.js";
 import { isProcessed, markProcessed } from "./tracker.js";
 import type { LLMClient, SmartExtraction } from "./llm-client.js";
@@ -1850,3 +1853,203 @@ export async function ingestGenericText(
 
   return result;
 }
+
+// ============================================================================
+// Connector-v1 Ingest (GB-2)
+// ============================================================================
+
+/**
+ * Ingest a connector-v1 formatted JSON payload.
+ *
+ * External connectors (Obsidian, Email, RSS, etc.) produce a standard
+ * ConnectorOutputV1 JSON → this function consumes it through the existing
+ * dedup / smartExtract / buildIngestedEntry pipeline.
+ *
+ * contentHash on each record enables incremental sync: if a record with the
+ * same hash is already in the store, it is skipped without embedding.
+ */
+export async function ingestConnectorFile(
+  store: MemoryStore,
+  embedder: Embedder,
+  content: string,
+  options: { verbose?: boolean; noDedup?: boolean; llm?: LLMClient | null } = {},
+): Promise<IngestResult> {
+  const parsed = JSON.parse(content);
+  if (!isConnectorOutputV1(parsed)) {
+    return {
+      source: "connector",
+      filesProcessed: 0,
+      chunksIngested: 0,
+      chunksSkipped: 0,
+      chunksDeduped: 0,
+      dedupReasonCounts: createDedupReasonCounts(),
+      errors: ["Invalid connector-v1 format: missing version/source/scope/records"],
+    };
+  }
+
+  const connectorData = parsed as ConnectorOutputV1;
+  const { source, scope, records } = connectorData;
+
+  const result: IngestResult = {
+    source: `connector:${source}`,
+    filesProcessed: 1,
+    chunksIngested: 0,
+    chunksSkipped: 0,
+    chunksDeduped: 0,
+    dedupReasonCounts: createDedupReasonCounts(),
+    errors: [],
+  };
+
+  if (records.length === 0) return result;
+
+  const batchSize = 32;
+
+  for (let i = 0; i < records.length; i += batchSize) {
+    const batch = records.slice(i, i + batchSize);
+    const texts = batch.map((r: ConnectorRecord) =>
+      r.title ? `[${r.title}] ${r.text}` : r.text,
+    );
+
+    try {
+      const vectors = await embedder.embedBatchPassage(texts);
+
+      // --- dedup pass ---
+      const dedupedTexts: string[] = [];
+      const dedupedVectors: number[][] = [];
+      const dedupedRecords: ConnectorRecord[] = [];
+
+      for (let j = 0; j < batch.length; j++) {
+        const vector = vectors[j];
+        if (!vector || vector.length === 0) {
+          result.chunksSkipped++;
+          continue;
+        }
+        if (!options.noDedup) {
+          const decision = await dedupCheck(store, vector, texts[j], options.llm);
+          recordDedupDecision(result, decision);
+          if (decision.secondaryDeletes?.length) {
+            await executeSecondaryDeletes(store, decision.secondaryDeletes);
+          }
+          if (decision.action === "skip") continue;
+        }
+        dedupedTexts.push(texts[j]);
+        dedupedVectors.push(vector);
+        dedupedRecords.push(batch[j]);
+      }
+
+      if (dedupedTexts.length === 0) continue;
+
+      // --- extract + build entries ---
+      const extractions = await smartExtractBatch(dedupedTexts, options.llm);
+      const coreSummaries = await generateCoreSummaries(dedupedTexts, options.llm);
+      const toStore: Array<{
+        text: string;
+        vector: number[];
+        category: string;
+        scope: string;
+        importance: number;
+        metadata: string;
+      }> = [];
+
+      for (let j = 0; j < dedupedTexts.length; j++) {
+        const record = dedupedRecords[j];
+        const entry = buildIngestedEntry({
+          source: `connector:${source}`,
+          scope,
+          text: dedupedTexts[j],
+          vector: dedupedVectors[j],
+          extraction: extractions[j],
+          file: record.id,
+          heading: record.title,
+          coreSummary: coreSummaries[j],
+        });
+
+        // Merge connector-specific metadata
+        const meta = JSON.parse(entry.metadata);
+        if (record.tags?.length) meta.connectorTags = record.tags;
+        if (record.contentHash) meta.contentHash = record.contentHash;
+        if (record.sourceMetadata) meta.sourceMetadata = record.sourceMetadata;
+        entry.metadata = JSON.stringify(meta);
+
+        // Respect categoryHint / importanceHint from connector
+        if (record.categoryHint) {
+          entry.category = record.categoryHint;
+        }
+        if (record.importanceHint !== undefined) {
+          entry.importance = record.importanceHint;
+        }
+
+        toStore.push(entry);
+      }
+
+      if (toStore.length > 0) {
+        await store.storeBatch(toStore);
+        result.chunksIngested += toStore.length;
+      }
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      result.errors.push(`Connector batch error: ${msg}`);
+    }
+  }
+
+  if (options.verbose) {
+    console.log(`  connector:${source}: ${records.length} records → ${result.chunksIngested} stored`);
+  }
+
+  // GB-3: Write source heartbeat after connector ingest
+  try {
+    const { writeHeartbeat } = await import("./source-heartbeat.js");
+    writeHeartbeat(source, result.chunksIngested, result.errors);
+  } catch {
+    // Heartbeat write is best-effort — don't break ingest on failure
+  }
+
+  return result;
+}
+
+// ============================================================================
+// Obsidian Vault Ingest (GB-1)
+// ============================================================================
+
+/**
+ * Scan an Obsidian vault and ingest its markdown files through the connector-v1 pipeline.
+ *
+ * Wrapper that:
+ * 1. Validates the path is an Obsidian vault (.obsidian/ exists)
+ * 2. Calls scanVault() to produce a ConnectorOutputV1 payload
+ * 3. Feeds the payload to ingestConnectorFile()
+ */
+export async function ingestObsidianVault(
+  store: MemoryStore,
+  embedder: Embedder,
+  vaultPath: string,
+  options: {
+    verbose?: boolean;
+    noDedup?: boolean;
+    llm?: LLMClient | null;
+    scopePrefix?: string;
+  } = {},
+): Promise<IngestResult> {
+  const resolved = expandHome(vaultPath);
+
+  if (!isObsidianVault(resolved)) {
+    return {
+      source: "obsidian",
+      filesProcessed: 0,
+      chunksIngested: 0,
+      chunksSkipped: 0,
+      chunksDeduped: 0,
+      dedupReasonCounts: createDedupReasonCounts(),
+      errors: [`Not an Obsidian vault (missing .obsidian/ directory): ${resolved}`],
+    };
+  }
+
+  const output = scanVault(resolved, { scopePrefix: options.scopePrefix });
+  const content = JSON.stringify(output);
+
+  if (options.verbose) {
+    console.log(`  obsidian: scanned ${output.records.length} notes from ${resolved}`);
+  }
+
+  return ingestConnectorFile(store, embedder, content, options);
+}

package/src/mcp-server.ts

@@ -1819,11 +1819,11 @@ registerTool(
 
 registerTool(
   "import_conversations",
-  "Import a conversation file (Claude Code JSONL, Claude.ai JSON, ChatGPT JSON, Slack JSON, or plaintext) into memory. Auto-detects format or use explicit format parameter. Messages are normalized and stored via the standard persistMemory pipeline.",
+  "Import a conversation file (Claude Code JSONL, Claude.ai JSON, ChatGPT JSON, Slack JSON, plaintext, or connector-v1 JSON) into memory. Auto-detects format or use explicit format parameter. Messages are normalized and stored via the standard persistMemory pipeline. For connector-v1 format, use the standard ConnectorOutputV1 schema (see docs/connector-spec.md).",
   {
     content: z.string().min(1).max(500_000).describe("Raw file content to import"),
     scope: z.string().min(1).max(160).describe("Target scope for imported memories, e.g. 'project:myapp'"),
-    format: z.enum(["auto", "claude-code", "claude-ai", "chatgpt", "slack", "plaintext"]).default("auto").describe("Conversation format. Use 'auto' to detect automatically."),
+    format: z.enum(["auto", "claude-code", "claude-ai", "chatgpt", "slack", "plaintext", "connector-v1"]).default("auto").describe("Conversation format. Use 'auto' to detect automatically. 'connector-v1' for standard connector output."),
   },
   async ({ content, scope, format }) => {
     const { detectFormat, normalizeConversation, ingestNormalizedMessages } = await import("./conversation-importer.js");

package/src/obsidian-connector.ts

@@ -0,0 +1,282 @@
+/**
+ * Obsidian Vault Connector (GB-1)
+ *
+ * Scans an Obsidian vault directory and produces a ConnectorOutputV1 payload.
+ * Recognizes:
+ * - .obsidian/ directory (vault detection)
+ * - YAML frontmatter (tags, aliases, arbitrary metadata)
+ * - [[wikilinks]] (extracted as entity associations via link: tags)
+ * - Directory structure (folder: tags for scope/topic mapping)
+ * - Content hash (SHA-256 prefix) for incremental sync
+ */
+
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { join, relative, basename, dirname } from "node:path";
+import type { ConnectorOutputV1, ConnectorRecord } from "./connector-types.js";
+
+// ============================================================================
+// Vault Detection
+// ============================================================================
+
+/** Check if a directory is an Obsidian vault (contains .obsidian/ folder) */
+export function isObsidianVault(dirPath: string): boolean {
+  try {
+    return existsSync(join(dirPath, ".obsidian"));
+  } catch {
+    return false;
+  }
+}
+
+// ============================================================================
+// YAML Frontmatter Parser
+// ============================================================================
+
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)(?:\r?\n)?---/;
+
+export interface ObsidianFrontmatter {
+  tags?: string[];
+  aliases?: string[];
+  [key: string]: unknown;
+}
+
+/**
+ * Parse YAML frontmatter from markdown content.
+ * Lightweight parser — handles:
+ * - key: value (strings)
+ * - key: [inline, list]
+ * - key:\n  - list\n  - items
+ * Does NOT handle nested objects, multi-line strings, or anchors.
+ * Returns null frontmatter on parse failure (never throws).
+ */
+export function parseFrontmatter(content: string): {
+  frontmatter: ObsidianFrontmatter | null;
+  body: string;
+} {
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) return { frontmatter: null, body: content };
+
+  const yamlBlock = match[1];
+  const body = content.slice(match[0].length).trimStart();
+
+  try {
+    const fm: ObsidianFrontmatter = {};
+    let currentKey: string | null = null;
+    let listAccum: string[] = [];
+
+    function flushList(): void {
+      if (currentKey && listAccum.length > 0) {
+        fm[currentKey] = listAccum;
+        listAccum = [];
+      }
+      currentKey = null;
+    }
+
+    for (const line of yamlBlock.split("\n")) {
+      // List item: "  - value"
+      const listItem = line.match(/^\s+-\s+(.+)/);
+      if (listItem && currentKey) {
+        listAccum.push(listItem[1].trim().replace(/^['"]|['"]$/g, ""));
+        continue;
+      }
+
+      // Key-value: "key: value"
+      const kv = line.match(/^([\w][\w-]*):\s*(.*)/);
+      if (kv) {
+        flushList();
+        const [, key, rawVal] = kv;
+        const val = rawVal.trim();
+
+        if (val === "" || val === "[]") {
+          // Empty value or empty inline list — start list accumulator
+          currentKey = key;
+          listAccum = [];
+        } else if (val.startsWith("[") && val.endsWith("]")) {
+          // Inline list: [a, b, c]
+          fm[key] = val
+            .slice(1, -1)
+            .split(",")
+            .map((s) => s.trim().replace(/^['"]|['"]$/g, ""))
+            .filter(Boolean);
+        } else {
+          // Simple string value
+          fm[key] = val.replace(/^['"]|['"]$/g, "");
+        }
+      }
+    }
+    flushList();
+
+    return {
+      frontmatter: Object.keys(fm).length > 0 ? fm : null,
+      body,
+    };
+  } catch {
+    // Parse failure — return body without frontmatter
+    return { frontmatter: null, body };
+  }
+}
+
+// ============================================================================
+// Wikilink Extraction
+// ============================================================================
+
+const WIKILINK_PATTERN = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+
+export interface WikiLink {
+  /** Link target (file name without extension) */
+  target: string;
+  /** Optional display text (after |) */
+  displayText?: string;
+}
+
+/**
+ * Extract [[wikilinks]] from markdown text.
+ * Handles [[target]] and [[target|display text]].
+ * Does NOT handle embed syntax ![[embed]] (those are skipped).
+ */
+export function extractWikiLinks(text: string): WikiLink[] {
+  const links: WikiLink[] = [];
+  // Create a fresh regex to avoid stale lastIndex
+  const re = new RegExp(WIKILINK_PATTERN.source, WIKILINK_PATTERN.flags);
+  let match: RegExpExecArray | null;
+
+  while ((match = re.exec(text)) !== null) {
+    // Skip embed syntax: character before [[ is !
+    if (match.index > 0 && text[match.index - 1] === "!") continue;
+
+    links.push({
+      target: match[1].trim(),
+      ...(match[2] ? { displayText: match[2].trim() } : {}),
+    });
+  }
+
+  return links;
+}
+
+// ============================================================================
+// Content Hash
+// ============================================================================
+
+/** SHA-256 first 16 hex chars — compact but collision-safe for incremental sync */
+export function contentHash(text: string): string {
+  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+
+// ============================================================================
+// Vault Scanner
+// ============================================================================
+
+export interface ScanVaultOptions {
+  /** Scope prefix, defaults to "vault:<vault-folder-name>" */
+  scopePrefix?: string;
+  /** Directories to exclude (defaults: .obsidian, .trash, .git, node_modules) */
+  excludeDirs?: string[];
+  /** Minimum file content length to include (default: 30 chars) */
+  minContentLength?: number;
+}
+
+/**
+ * Scan an Obsidian vault and produce a ConnectorOutputV1 payload.
+ *
+ * - Recursively walks .md files (skipping excluded directories)
+ * - Parses YAML frontmatter -> tags
+ * - Extracts [[wikilinks]] -> link:<target> tags
+ * - Maps folder structure -> folder:<path> tags
+ * - Computes SHA-256 content hash for incremental sync
+ */
+export function scanVault(
+  vaultPath: string,
+  options?: ScanVaultOptions,
+): ConnectorOutputV1 {
+  const vaultName = basename(vaultPath);
+  const scopePrefix = options?.scopePrefix ?? `vault:${vaultName}`;
+  const defaultExclude = [".obsidian", ".trash", ".git", "node_modules"];
+  const excludeDirs = new Set(options?.excludeDirs ?? defaultExclude);
+  const minLen = options?.minContentLength ?? 30;
+
+  const records: ConnectorRecord[] = [];
+
+  function walk(dir: string): void {
+    let entries: ReturnType<typeof readdirSync>;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return; // Permission denied or broken symlink — skip
+    }
+
+    for (const entry of entries) {
+      if (excludeDirs.has(entry.name)) continue;
+
+      const full = join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+
+      if (!entry.name.endsWith(".md")) continue;
+
+      let raw: string;
+      try {
+        raw = readFileSync(full, "utf-8");
+      } catch {
+        continue; // Unreadable file — skip
+      }
+
+      if (raw.trim().length < minLen) continue;
+
+      const { frontmatter, body } = parseFrontmatter(raw);
+      const wikiLinks = extractWikiLinks(body);
+      const relPath = relative(vaultPath, full);
+      const folder = dirname(relPath);
+
+      // --- Build tags ---
+      const tags: string[] = [];
+
+      // Frontmatter tags
+      if (frontmatter?.tags) {
+        const fmTags = Array.isArray(frontmatter.tags)
+          ? frontmatter.tags
+          : [String(frontmatter.tags)];
+        for (const t of fmTags) {
+          tags.push(String(t));
+        }
+      }
+
+      // Wikilink entity associations
+      for (const link of wikiLinks) {
+        tags.push(`link:${link.target}`);
+      }
+
+      // Folder path
+      if (folder !== ".") {
+        tags.push(`folder:${folder}`);
+      }
+
+      records.push({
+        id: `obsidian:${relPath}`,
+        text: body,
+        title: basename(entry.name, ".md"),
+        tags,
+        contentHash: contentHash(raw),
+        timestamp: new Date(statSync(full).mtimeMs).toISOString(),
+        sourceMetadata: {
+          vaultPath,
+          relativePath: relPath,
+          ...(frontmatter ? { frontmatter } : {}),
+          ...(wikiLinks.length > 0 ? { wikiLinks } : {}),
+        },
+      });
+    }
+  }
+
+  walk(vaultPath);
+
+  return {
+    version: "connector-v1",
+    source: "obsidian",
+    scope: scopePrefix,
+    producedAt: new Date().toISOString(),
+    records,
+  };
+}

package/src/session-schema.ts

@@ -66,9 +66,9 @@ export const ResumeContextResponseSchema = z.object({
   essentialContext: EssentialContextSchema.optional(),
   latestCheckpoint: ResumeCheckpointSummarySchema.optional(),
   /** CC-1: Hint for where to inject recalled context in the prompt. */
-  injectionHint: z.enum(["system_prompt", "user_attachment"]).default("user_attachment").optional(),
+  injectionHint: z.enum(["system_prompt", "user_attachment"]).optional().default("user_attachment"),
   /** Upstream #345: Mark recalled context as ephemeral — host should discard on compaction, not persist to transcript. */
-  ephemeral: z.boolean().default(true).optional(),
+  ephemeral: z.boolean().optional().default(true),
   responseMode: ResumeResponseModeSchema.default("default"),
   responseGuidance: optionalBoundedStringSchema(400),
   /** Constructive retrieval: LLM-synthesized reconstruction of context. */