@aitne/daemon 0.1.7 → 0.1.9

package/dist/services/mcp/session-materializer.d.ts

@@ -44,7 +44,7 @@ export interface MaterializeMcpParams {
     /**
      * Resolved vault context dir (result of `getContextDir(config)`). Used
      * only to decide whether the agent-facing MCP section should mention
-     * `rules/mcp.md`. Optional so tests and internal callers without a
+     * `policies/mcp.md`. Optional so tests and internal callers without a
      * config handle can still materialize; when omitted the reference is
      * silently dropped instead of pointing at a non-existent file.
      */
@@ -84,7 +84,7 @@ export interface RenderMcpSectionOptions {
      */
     autonomous?: boolean;
     /**
-     * Whether `<contextDir>/rules/mcp.md` exists. When false, the agent-facing
+     * Whether `<contextDir>/policies/mcp.md` exists. When false, the agent-facing
      * section no longer tells the model to consult a file that doesn't exist —
      * prevents spurious `curl` hunts in DMs and routines.
      */
@@ -120,4 +120,3 @@ export { scopedEnvVarName };
  * it is tightly coupled to the generator's placeholder format.
  */
 export declare function resolvePlaceholdersDeep<T>(value: T, env: Record<string, string>): T;
-//# sourceMappingURL=session-materializer.d.ts.map

package/dist/services/mcp/session-materializer.js

@@ -21,6 +21,7 @@ const INSTRUCTION_FILES = {
     claude: "CLAUDE.md",
     codex: "AGENTS.md",
     gemini: "GEMINI.md",
+    opencode: "AGENTS.md",
 };
 /**
  * Per-backend MCP config file path, relative to the session workdir. Must
@@ -76,15 +77,18 @@ export async function materializeMcpForSession(params) {
         // the spawn env, resulting in silent auth failures. For Codex stdio,
         // the stale file also contains inlined secret values, so deletion is
         // the defense-in-depth story too.
-        const stalePath = join(params.sessionDir, BACKEND_CONFIG_PATHS[params.backendId]);
-        try {
-            rmSync(stalePath, { force: true });
-        }
-        catch (err) {
-            /* c8 ignore next — `force: true` swallows ENOENT and most other
-               common failure modes; this guards against EACCES on a workdir the
-               daemon owns, which shouldn't happen in practice. */
-            logger.warn({ err, path: stalePath, backendId: params.backendId }, "Failed to remove stale MCP config file");
+        const staleConfigPath = BACKEND_CONFIG_PATHS[params.backendId];
+        if (staleConfigPath) {
+            const stalePath = join(params.sessionDir, staleConfigPath);
+            try {
+                rmSync(stalePath, { force: true });
+            }
+            catch (err) {
+                /* c8 ignore next — `force: true` swallows ENOENT and most other
+                   common failure modes; this guards against EACCES on a workdir the
+                   daemon owns, which shouldn't happen in practice. */
+                logger.warn({ err, path: stalePath, backendId: params.backendId }, "Failed to remove stale MCP config file");
+            }
         }
         return {
             servers: [],
@@ -110,7 +114,7 @@ export async function materializeMcpForSession(params) {
     const absConfigPath = join(params.sessionDir, generated.path);
     writeAtomic(absConfigPath, generated.contents);
     const rulesFileExists = params.contextDir
-        ? existsSync(join(params.contextDir, "rules/mcp.md"))
+        ? existsSync(join(params.contextDir, "policies/mcp.md"))
         : false;
     appendMcpSection(params.sessionDir, params.backendId, forBackend, {
         backendId: params.backendId,
@@ -216,7 +220,7 @@ export function renderMcpSection(servers, options = {}) {
         ? `The following MCP servers are enabled for this session (backend: \`${backendId}\`).`
         : "The following MCP servers are enabled.");
     if (rulesFileExists) {
-        push("Consult `rules/mcp.md` for per-server usage rules.");
+        push("Consult `policies/mcp.md` for per-server usage rules.");
     }
     push("");
     let truncatedServers = 0;
@@ -358,4 +362,3 @@ export function resolvePlaceholdersDeep(value, env) {
     }
     return value;
 }
-//# sourceMappingURL=session-materializer.js.map

package/dist/services/mcp/tool-audit.d.ts

@@ -50,4 +50,3 @@ export declare function listMcpToolCalls(db: Database.Database, serverId: string
  * string), so comparison uses integer arithmetic rather than datetime().
  */
 export declare function pruneOldMcpToolCalls(db: Database.Database, days: number): number;
-//# sourceMappingURL=tool-audit.d.ts.map

package/dist/services/mcp/tool-audit.js

@@ -71,4 +71,3 @@ export function pruneOldMcpToolCalls(db, days) {
         return 0;
     }
 }
-//# sourceMappingURL=tool-audit.js.map

package/dist/services/mcp/types.d.ts

@@ -47,6 +47,7 @@ export declare const McpServerSchema: z.ZodObject<{
     envKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
     headerKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
     backends: z.ZodArray<z.ZodEnum<{
+        opencode: "opencode";
         claude: "claude";
         codex: "codex";
         gemini: "gemini";
@@ -85,4 +86,3 @@ export declare function validateTransportShape(input: Pick<McpServer, "transport
 };
 /** Encrypted blob name convention for a per-server secret value. */
 export declare function mcpSecretBlobName(serverId: string, keyName: string): string;
-//# sourceMappingURL=types.d.ts.map

package/dist/services/mcp/types.js

@@ -91,4 +91,3 @@ export function validateTransportShape(input) {
 export function mcpSecretBlobName(serverId, keyName) {
     return `mcp:${serverId}:${keyName}`;
 }
-//# sourceMappingURL=types.js.map

package/dist/services/notion.d.ts

@@ -99,10 +99,26 @@ export declare class NotionService {
     /**
      * Paginated async iterator for poller use — yields every page
      * edited strictly after `lastEditedTime` across all pages of results.
-     * Walks `has_more` / `next_cursor` until the data source is exhausted.
+     * Walks `has_more` / `next_cursor` until the data source is exhausted
+     * OR `maxPages` is reached, whichever comes first.
+     *
+     * `signal` is checked between page fetches AND wraps each underlying
+     * SDK call via `raceWithAbort` (defensive — `@notionhq/client` v5's
+     * `dataSources.query` signature does not surface a RequestOptions arg,
+     * so we cannot pass the signal natively). A fired signal yields
+     * whatever has accumulated so far and returns; callers (NotionPoller)
+     * keep partial progress via the `last_edited_time` cursor advance, so
+     * the next tick resumes from where this one stopped.
+     *
+     * `maxPages` defaults to {@link NOTION_DEFAULT_MAX_PAGES} so a Notion
+     * data source with millions of edited rows since the seeded cursor
+     * (e.g. cold-cursor on a flip back to direct mode) cannot pin the
+     * poller indefinitely walking the backlog.
      */
     queryUpdatedSince(databaseId: string, lastEditedTime: string, opts?: {
         inTrash?: boolean;
+        maxPages?: number;
+        signal?: AbortSignal;
     }): AsyncIterable<PageObjectResponse>;
     search(params: {
         query?: string;
@@ -131,4 +147,3 @@ export declare class NotionService {
 }
 export declare function simplifyPage(page: PageObjectResponse): SimplifiedPage;
 export declare function flattenProperties(props: PageObjectResponse["properties"]): Record<string, unknown>;
-//# sourceMappingURL=notion.d.ts.map

package/dist/services/notion.js

@@ -1,5 +1,16 @@
 import { createLogger } from "../logging.js";
+import { raceWithAbort as raceNotionWithAbort } from "../core/abort-utils.js";
 const logger = createLogger("notion-service");
+/**
+ * Upper bound on pages walked per `queryUpdatedSince` call. Each page
+ * holds up to 100 rows, so 50 pages ≈ 5000 rows per tick — generous
+ * for a single poll window, finite enough to keep the poller responsive
+ * when the cursor is far behind (cold start, mode flip, long downtime).
+ * When the cap is hit the iterator stops; the caller's cursor advances
+ * to the last yielded `last_edited_time` so the next tick resumes from
+ * the same point.
+ */
+const NOTION_DEFAULT_MAX_PAGES = 50;
 /**
  * Local narrowing predicate so this module has no static value import
  * from `@notionhq/client` — the package is imported dynamically inside
@@ -96,13 +107,31 @@ export class NotionService {
     /**
      * Paginated async iterator for poller use — yields every page
      * edited strictly after `lastEditedTime` across all pages of results.
-     * Walks `has_more` / `next_cursor` until the data source is exhausted.
+     * Walks `has_more` / `next_cursor` until the data source is exhausted
+     * OR `maxPages` is reached, whichever comes first.
+     *
+     * `signal` is checked between page fetches AND wraps each underlying
+     * SDK call via `raceWithAbort` (defensive — `@notionhq/client` v5's
+     * `dataSources.query` signature does not surface a RequestOptions arg,
+     * so we cannot pass the signal natively). A fired signal yields
+     * whatever has accumulated so far and returns; callers (NotionPoller)
+     * keep partial progress via the `last_edited_time` cursor advance, so
+     * the next tick resumes from where this one stopped.
+     *
+     * `maxPages` defaults to {@link NOTION_DEFAULT_MAX_PAGES} so a Notion
+     * data source with millions of edited rows since the seeded cursor
+     * (e.g. cold-cursor on a flip back to direct mode) cannot pin the
+     * poller indefinitely walking the backlog.
      */
     async *queryUpdatedSince(databaseId, lastEditedTime, opts = {}) {
         const client = this.requireClient();
+        const maxPages = opts.maxPages ?? NOTION_DEFAULT_MAX_PAGES;
         let cursor;
+        let pages = 0;
         do {
-            const response = await client.dataSources.query({
+            if (opts.signal?.aborted)
+                return;
+            const queryPromise = client.dataSources.query({
                 data_source_id: databaseId,
                 filter: {
                     timestamp: "last_edited_time",
@@ -113,11 +142,19 @@ export class NotionService {
                 start_cursor: cursor,
                 in_trash: opts.inTrash,
             });
+            const response = opts.signal
+                ? await raceNotionWithAbort(queryPromise, opts.signal)
+                : await queryPromise;
             for (const page of response.results) {
                 if (isFullPage(page))
                     yield page;
             }
             cursor = response.has_more ? (response.next_cursor ?? undefined) : undefined;
+            pages += 1;
+            if (cursor && pages >= maxPages) {
+                logger.warn({ databaseId, pages, maxPages, lastEditedTime }, "queryUpdatedSince hit page cap — remaining pages deferred to next tick");
+                return;
+            }
         } while (cursor);
     }
     // ─────────────────────────────────────────────────────────────
@@ -347,4 +384,3 @@ function buildMarkdownUpdateArgs(pageId, mode) {
             };
     }
 }
-//# sourceMappingURL=notion.js.map

package/dist/services/observations-batch.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Pure batch processor for observation ingestion.
+ *
+ * Shared between two callers that hold the same contract but live behind
+ * different surfaces:
+ *
+ *   - `POST /observations/batch` HTTP route — handles HTTP-envelope concerns
+ *     (content-length cap, JSON parse, status-code shaping) then delegates
+ *     here for the per-item write loop.
+ *   - SDK MCP tool `mcp__aitne-observations__submit_observations` — invoked
+ *     by the Claude pre-pass session directly via the in-process MCP
+ *     transport. No shell parser, no curl envelope.
+ *
+ * The MCP path exists because the Claude Code SDK's bash parser (`Ae6` in
+ * `cli.js`) flags any command containing characters in the Unicode-
+ * whitespace regex (` `, ` `, ` -​`, `
+`, `
+`,
+ * ` `, ` `, `　`, ``) as `too-complex` and falls through
+ * to ask-mode — which under `permissionMode: "dontAsk"` is denied. Mail
+ * subjects/snippets from promotional senders and non-ASCII content
+ * routinely contain these characters, producing deterministic pre-pass
+ * failures (visible as `budget-cap` after retries). The in-process MCP
+ * tool sends observations as structured JSON over the MCP transport,
+ * completely bypassing the shell parser.
+ */
+import type Database from "better-sqlite3";
+import { type IntegrationKey } from "@aitne/shared";
+/** Maximum items per `submit_observations` / `POST /observations/batch` call. */
+export declare const BATCH_MAX_OBSERVATIONS = 200;
+export declare const BATCH_EXPECTED_SHAPE = "{\"observations\": [{\"source\": string, \"ref\": string, \"changeType\"?: \"created\"|\"modified\"|\"deleted\", \"actor\"?: \"agent\"|\"system\", \"payload\"?: unknown}, ...]}";
+export declare const BATCH_EXAMPLE = "{\"observations\":[{\"source\":\"google_calendar:primary\",\"ref\":\"evt-1\",\"payload\":{\"kind\":\"calendar\",\"providerId\":\"primary\",\"raw\":{\"title\":\"\u2026\"}}},{\"source\":\"google_calendar:primary\",\"ref\":\"evt-2\",\"payload\":{\"kind\":\"calendar\",\"providerId\":\"primary\",\"raw\":{\"title\":\"\u2026\"}}}]}";
+export type BatchItemStatus = "created" | "modified" | "duplicate" | "flip_locked" | "validation_error";
+export interface BatchItemResult {
+    index: number;
+    status: BatchItemStatus;
+    /** Echoed for correlation when the agent needs to map a failure back to its input. */
+    source?: string;
+    ref?: string;
+    contentHash?: string;
+    id?: number;
+    error?: string;
+    hint?: string;
+}
+export interface ProcessBatchResult {
+    results: BatchItemResult[];
+    fetched: number;
+    posted: number;
+    duplicates: number;
+    errors: number;
+}
+/**
+ * Map a `source` string to its registered integration key. Matches the exact
+ * key first, then falls back to a colon prefix (e.g. `"gmail:account-1"`)
+ * so per-account / per-database source values still resolve. Returns null
+ * for anything else.
+ */
+export declare function inferIntegrationKeyFromSource(source: string): IntegrationKey | null;
+/**
+ * Normalize pre-pass mail payloads at the ingest chokepoint so the
+ * hourly-check gate can read a canonical shape regardless of mode. See
+ * HOURLY_CHECK_GATE_REDESIGN_PLAN.md for the full rationale; the rules:
+ *   - mail integration source AND `payload.raw.from` is a string → set
+ *     `is_read = 0` and `from_email = <lowercased extracted address>`
+ *     (unless already present, in which case respect the caller).
+ *   - non-mail or non-shape-matching payloads pass through verbatim.
+ */
+export declare function normalizeMailObservationPayload(source: string, payload: unknown): unknown;
+type ValidatedBatchItem = {
+    ok: true;
+    source: string;
+    ref: string;
+    changeType: "created" | "modified" | "deleted";
+    actor: "agent" | "system";
+    payload: unknown;
+} | {
+    ok: false;
+    result: BatchItemResult;
+};
+export declare function validateBatchItem(item: unknown, index: number): ValidatedBatchItem;
+/**
+ * Run the per-item validation + flip-lock check + recordObservation loop
+ * inside one explicit transaction. Returns the per-item result array so
+ * callers can echo it back to the agent for self-correlation.
+ *
+ * Callers are responsible for:
+ *  - bounding the batch size against {@link BATCH_MAX_OBSERVATIONS} (this
+ *    function trusts the input length; the route caps before calling).
+ *  - any wire-format concerns (HTTP body parsing, MCP envelope shaping).
+ *
+ * The loop is single-pass and skip-on-failure: a `validation_error` or
+ * `flip_locked` item does NOT abort the batch — it lands in `results[]`
+ * with the right `status` and `errorCount` is incremented. Same semantics
+ * as the original in-route implementation; preserved so existing tests
+ * that assert mixed-success/error outcomes keep passing.
+ */
+export declare function processObservationsBatch(db: Database.Database, observations: readonly unknown[]): ProcessBatchResult;
+export {};

package/dist/services/observations-batch.js

@@ -0,0 +1,256 @@
+/**
+ * Pure batch processor for observation ingestion.
+ *
+ * Shared between two callers that hold the same contract but live behind
+ * different surfaces:
+ *
+ *   - `POST /observations/batch` HTTP route — handles HTTP-envelope concerns
+ *     (content-length cap, JSON parse, status-code shaping) then delegates
+ *     here for the per-item write loop.
+ *   - SDK MCP tool `mcp__aitne-observations__submit_observations` — invoked
+ *     by the Claude pre-pass session directly via the in-process MCP
+ *     transport. No shell parser, no curl envelope.
+ *
+ * The MCP path exists because the Claude Code SDK's bash parser (`Ae6` in
+ * `cli.js`) flags any command containing characters in the Unicode-
+ * whitespace regex (` `, ` `, ` -​`, `
+`, `
+`,
+ * ` `, ` `, `　`, ``) as `too-complex` and falls through
+ * to ask-mode — which under `permissionMode: "dontAsk"` is denied. Mail
+ * subjects/snippets from promotional senders and non-ASCII content
+ * routinely contain these characters, producing deterministic pre-pass
+ * failures (visible as `budget-cap` after retries). The in-process MCP
+ * tool sends observations as structured JSON over the MCP transport,
+ * completely bypassing the shell parser.
+ */
+import { INTEGRATION_DESCRIPTORS, INTEGRATION_KEYS, isIntegrationKey, } from "@aitne/shared";
+import { readIntegrationFlipLock } from "../core/integration-lifecycle.js";
+import { recordObservation } from "../db/observations.js";
+import { createLogger } from "../logging.js";
+const logger = createLogger("observations-batch");
+/** Maximum items per `submit_observations` / `POST /observations/batch` call. */
+export const BATCH_MAX_OBSERVATIONS = 200;
+export const BATCH_EXPECTED_SHAPE = '{"observations": [{"source": string, "ref": string, "changeType"?: "created"|"modified"|"deleted", "actor"?: "agent"|"system", "payload"?: unknown}, ...]}';
+export const BATCH_EXAMPLE = '{"observations":[{"source":"google_calendar:primary","ref":"evt-1","payload":{"kind":"calendar","providerId":"primary","raw":{"title":"…"}}},{"source":"google_calendar:primary","ref":"evt-2","payload":{"kind":"calendar","providerId":"primary","raw":{"title":"…"}}}]}';
+/**
+ * Map a `source` string to its registered integration key. Matches the exact
+ * key first, then falls back to a colon prefix (e.g. `"gmail:account-1"`)
+ * so per-account / per-database source values still resolve. Returns null
+ * for anything else.
+ */
+export function inferIntegrationKeyFromSource(source) {
+    if (isIntegrationKey(source))
+        return source;
+    for (const key of INTEGRATION_KEYS) {
+        if (source.startsWith(`${key}:`))
+            return key;
+    }
+    return null;
+}
+/** Per-integration source prefixes whose pre-pass payload carries the
+ *  mail shape (`payload.raw.from`, no `is_read`). Drives
+ *  {@link normalizeMailObservationPayload} so the hourly-check gate can
+ *  read a canonical `is_read` + `from_email` shape regardless of mode. */
+const MAIL_OBSERVATION_INTEGRATION_KEYS = new Set(INTEGRATION_KEYS.filter((k) => {
+    const partial = INTEGRATION_DESCRIPTORS[k].prePassPartial;
+    return typeof partial === "string" && partial.startsWith("mail-acquire.");
+}));
+const EMAIL_RE = /<([^<>@\s]+@[^<>@\s]+)>|([^\s<>@]+@[^\s<>@]+)/;
+function extractEmailAddress(raw) {
+    const match = EMAIL_RE.exec(raw);
+    if (!match)
+        return null;
+    return (match[1] ?? match[2] ?? "").trim().toLowerCase() || null;
+}
+/**
+ * Normalize pre-pass mail payloads at the ingest chokepoint so the
+ * hourly-check gate can read a canonical shape regardless of mode. See
+ * HOURLY_CHECK_GATE_REDESIGN_PLAN.md for the full rationale; the rules:
+ *   - mail integration source AND `payload.raw.from` is a string → set
+ *     `is_read = 0` and `from_email = <lowercased extracted address>`
+ *     (unless already present, in which case respect the caller).
+ *   - non-mail or non-shape-matching payloads pass through verbatim.
+ */
+export function normalizeMailObservationPayload(source, payload) {
+    const key = inferIntegrationKeyFromSource(source);
+    if (!key || !MAIL_OBSERVATION_INTEGRATION_KEYS.has(key))
+        return payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return payload;
+    const obj = payload;
+    const raw = obj.raw;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return payload;
+    const fromValue = raw.from;
+    if (typeof fromValue !== "string")
+        return payload;
+    const next = { ...obj };
+    if (!("is_read" in next)) {
+        next.is_read = 0;
+    }
+    if (!("from_email" in next)) {
+        const extracted = extractEmailAddress(fromValue);
+        if (extracted) {
+            next.from_email = extracted;
+        }
+    }
+    return next;
+}
+export function validateBatchItem(item, index) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+        return {
+            ok: false,
+            result: {
+                index,
+                status: "validation_error",
+                error: "item must be a JSON object",
+                hint: BATCH_EXPECTED_SHAPE,
+            },
+        };
+    }
+    const obj = item;
+    if (typeof obj.source !== "string" || obj.source.length === 0) {
+        return {
+            ok: false,
+            result: {
+                index,
+                status: "validation_error",
+                error: "'source' must be a non-empty string",
+                hint: "Use 'gmail:<account>', 'google_calendar:<calendarId>', 'notion:<dbId>', etc.",
+            },
+        };
+    }
+    if (typeof obj.ref !== "string" || obj.ref.length === 0) {
+        return {
+            ok: false,
+            result: {
+                index,
+                status: "validation_error",
+                source: obj.source,
+                error: "'ref' must be a non-empty string",
+                hint: "Stable id within the source — e.g. message id, event id",
+            },
+        };
+    }
+    const changeType = typeof obj.changeType === "string" ? obj.changeType : "created";
+    if (!["created", "modified", "deleted"].includes(changeType)) {
+        return {
+            ok: false,
+            result: {
+                index,
+                status: "validation_error",
+                source: obj.source,
+                ref: obj.ref,
+                error: `'changeType' must be 'created'|'modified'|'deleted' — received '${changeType}'`,
+            },
+        };
+    }
+    const actor = typeof obj.actor === "string" ? obj.actor : "agent";
+    if (!["agent", "system"].includes(actor)) {
+        return {
+            ok: false,
+            result: {
+                index,
+                status: "validation_error",
+                source: obj.source,
+                ref: obj.ref,
+                error: `'actor' must be 'agent' or 'system' — received '${actor}'`,
+            },
+        };
+    }
+    return {
+        ok: true,
+        source: obj.source,
+        ref: obj.ref,
+        changeType: changeType,
+        actor: actor,
+        payload: obj.payload,
+    };
+}
+/**
+ * Run the per-item validation + flip-lock check + recordObservation loop
+ * inside one explicit transaction. Returns the per-item result array so
+ * callers can echo it back to the agent for self-correlation.
+ *
+ * Callers are responsible for:
+ *  - bounding the batch size against {@link BATCH_MAX_OBSERVATIONS} (this
+ *    function trusts the input length; the route caps before calling).
+ *  - any wire-format concerns (HTTP body parsing, MCP envelope shaping).
+ *
+ * The loop is single-pass and skip-on-failure: a `validation_error` or
+ * `flip_locked` item does NOT abort the batch — it lands in `results[]`
+ * with the right `status` and `errorCount` is incremented. Same semantics
+ * as the original in-route implementation; preserved so existing tests
+ * that assert mixed-success/error outcomes keep passing.
+ */
+export function processObservationsBatch(db, observations) {
+    const results = [];
+    let posted = 0;
+    let duplicates = 0;
+    let errorCount = 0;
+    const writeBatch = db.transaction((items) => {
+        for (let i = 0; i < items.length; i++) {
+            const validated = validateBatchItem(items[i], i);
+            if (!validated.ok) {
+                results.push(validated.result);
+                errorCount += 1;
+                continue;
+            }
+            const lockedKey = inferIntegrationKeyFromSource(validated.source);
+            if (lockedKey) {
+                const lock = readIntegrationFlipLock(db, lockedKey);
+                if (lock) {
+                    logger.warn({ source: validated.source, ref: validated.ref, lockedKey, lock }, "Batch observation write rejected — integration flip lock held");
+                    results.push({
+                        index: i,
+                        status: "flip_locked",
+                        source: validated.source,
+                        ref: validated.ref,
+                        error: `Integration '${lockedKey}' flip in progress`,
+                    });
+                    errorCount += 1;
+                    continue;
+                }
+            }
+            const normalizedPayload = normalizeMailObservationPayload(validated.source, validated.payload);
+            const result = recordObservation(db, {
+                source: validated.source,
+                ref: validated.ref,
+                changeType: validated.changeType,
+                actor: validated.actor,
+                payload: normalizedPayload,
+            });
+            if (result.action === "duplicate") {
+                duplicates += 1;
+                results.push({
+                    index: i,
+                    status: "duplicate",
+                    source: validated.source,
+                    ref: validated.ref,
+                    contentHash: result.contentHash,
+                    id: result.id,
+                });
+            }
+            else {
+                posted += 1;
+                results.push({
+                    index: i,
+                    status: result.action,
+                    source: validated.source,
+                    ref: validated.ref,
+                    contentHash: result.contentHash,
+                    id: result.id,
+                });
+            }
+        }
+    });
+    writeBatch(observations);
+    return {
+        results,
+        fetched: observations.length,
+        posted,
+        duplicates,
+        errors: errorCount,
+    };
+}

package/dist/services/obsidian.d.ts

@@ -113,4 +113,3 @@ export declare class ObsidianService {
     /** Parse the CLI search output into structured results */
     private parseSearchResult;
 }
-//# sourceMappingURL=obsidian.d.ts.map

package/dist/services/obsidian.js

@@ -302,4 +302,3 @@ export class ObsidianService {
         return results;
     }
 }
-//# sourceMappingURL=obsidian.js.map

package/dist/services/service-registry.d.ts

@@ -11,7 +11,6 @@ import type { GmailService } from "./gmail.js";
 import type { ObsidianService } from "./obsidian.js";
 import type { NotionService } from "./notion.js";
 import type { GitHubService } from "./github.js";
-import type { GoogleMapsService } from "./google-maps.js";
 import type { MailAccountRegistry } from "./mail/account-registry.js";
 import type { JournalMirrorService } from "./journal/writer.js";
 export interface ServiceRegistry {
@@ -22,10 +21,8 @@ export interface ServiceRegistry {
     obsidian: ObsidianService | null;
     notion: NotionService | null;
     github: GitHubService | null;
-    googleMaps: GoogleMapsService | null;
     journal: JournalMirrorService | null;
     /** Error messages from service initialization attempts */
     errors: Record<string, string>;
 }
 export declare function createServiceRegistry(): ServiceRegistry;
-//# sourceMappingURL=service-registry.d.ts.map

package/dist/services/service-registry.js

@@ -7,9 +7,7 @@ export function createServiceRegistry() {
         obsidian: null,
         notion: null,
         github: null,
-        googleMaps: null,
         journal: null,
         errors: {},
     };
 }
-//# sourceMappingURL=service-registry.js.map

package/dist/services/voice/transcriber-impl.d.ts

@@ -12,4 +12,3 @@ export declare const defaultLoadPipeline: PipelineLoader;
  * carries the samples directly.
  */
 export declare const decodeAudioWithFfmpeg: AudioDecoder;
-//# sourceMappingURL=transcriber-impl.d.ts.map