@murphai/murph 0.2.11 → 0.2.13

package/node_modules/@murphai/assistant-engine/dist/assistant/cron.js

@@ -3,7 +3,7 @@ import { loadVault, upsertAutomation } from '@murphai/core';
 import { listAutomations as listCanonicalAutomations, showAutomation as showCanonicalAutomation, } from '@murphai/query';
 import { assistantCronJobSchema, assistantCronRunRecordSchema, assistantCronScheduleSchema, assistantCronTargetSchema, } from '@murphai/operator-config/assistant-cli-contracts';
 import { loadRuntimeModule } from '@murphai/vault-usecases/runtime';
-import { renderAutoLoggedFoodMealNote } from '@murphai/vault-usecases/records';
+import { buildDailyFoodCronJobId, buildDailyFoodCronJobName, buildDailyFoodCronPrompt, buildDailyFoodSchedule, renderAutoLoggedFoodMealNote, } from '@murphai/vault-usecases/records';
 import { loadImporterRuntime } from '@murphai/vault-usecases/runtime';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
 import { withAssistantCronWriteLock } from "./cron/locking.js";
@@ -11,7 +11,7 @@ import { buildAssistantCronSchedule, computeAssistantCronNextRunAt, } from "./cr
 import { getAssistantCronPresetDefinition, listAssistantCronPresets as listBuiltinAssistantCronPresets, renderAssistantCronPreset, } from "./cron/presets.js";
 import { appendAssistantCronRun, assertAssistantCronJobNameIsAvailable, buildAssistantCronTarget, createAssistantCronJobId, createAssistantCronRunId, ensureAssistantCronState, isAssistantCronJobDue, normalizeRequiredAssistantCronText, readAssistantCronRuns, readAssistantCronStore, resolveAssistantCronJobFromStore, resolveAssistantCronJobIndex, resolveAssistantCronRunLookupId, sortAssistantCronJobs, writeAssistantCronStore, } from "./cron/store.js";
 import { buildAssistantCronNotificationDedupeToken } from "./cron/notification-delivery.js";
-import { createAssistantCronAutomationRuntimeRecord, findAssistantCronAutomationRuntimeRecord, readAssistantCronAutomationRuntimeStore, removeAssistantCronAutomationRuntimeRecord, upsertAssistantCronAutomationRuntimeRecord, writeAssistantCronAutomationRuntimeStore, } from "./cron/runtime-state.js";
+import { createAssistantCronCanonicalRuntimeRecord, findAssistantCronCanonicalRuntimeRecord, readAssistantCronCanonicalRuntimeStore, removeAssistantCronCanonicalRuntimeRecord, upsertAssistantCronCanonicalRuntimeRecord, writeAssistantCronCanonicalRuntimeStore, } from "./cron/runtime-state.js";
 import { sendAssistantNotificationLocal } from "../assistant-service.js";
 import { getAssistantChannelAdapter } from "./channel-adapters.js";
 import { resolveAssistantBindingDelivery } from "./bindings.js";
@@ -63,11 +63,12 @@ export async function addAssistantCronJob(input) {
     const name = normalizeRequiredAssistantCronText(resolvedInput.name, 'name');
     const prompt = normalizeRequiredAssistantCronText(resolvedInput.prompt, 'prompt');
     const enabled = resolvedInput.enabled ?? true;
-    const schedule = await resolveAssistantCronScheduleForVault(input.vault, resolvedInput.schedule);
+    const resolvedSchedule = await resolveAssistantCronScheduleForVault(input.vault, resolvedInput.schedule);
+    const schedule = assistantCronScheduleSchema.parse(resolvedInput.schedule);
     const keepAfterRun = schedule.kind === 'at'
         ? resolvedInput.keepAfterRun ?? false
         : true;
-    const nextRunAt = computeAssistantCronNextRunAt(schedule, now);
+    const nextRunAt = computeAssistantCronNextRunAt(resolvedSchedule, now);
     if (enabled && nextRunAt === null) {
         throw new VaultCliError('ASSISTANT_CRON_INVALID_SCHEDULE', 'The assistant cron schedule does not produce a future run time.');
     }
@@ -91,18 +92,19 @@ export async function addAssistantCronJob(input) {
                 route: buildCanonicalAutomationRoute(target),
                 instructions: prompt,
             }));
-            const runtimeStore = await readAssistantCronAutomationRuntimeStore(paths);
-            const runtimeState = createAssistantCronAutomationRuntimeRecord({
-                automationId: created.record.automationId,
-                nextRunAt,
+            const runtimeStore = await readAssistantCronCanonicalRuntimeStore(paths);
+            const timeZone = await resolveAssistantCronDefaultTimeZone(input.vault);
+            const source = requireCanonicalAssistantCronRecord(created.record, timeZone);
+            const runtimeState = createAssistantCronCanonicalRuntimeRecord({
+                jobId: source.automationId,
                 now: now.toISOString(),
                 sessionId: target.sessionId,
                 alias: target.alias,
             });
-            upsertAssistantCronAutomationRuntimeRecord(runtimeStore, runtimeState);
-            await writeAssistantCronAutomationRuntimeStore(paths, runtimeStore);
+            upsertAssistantCronCanonicalRuntimeRecord(runtimeStore, runtimeState);
+            await writeAssistantCronCanonicalRuntimeStore(paths, runtimeStore);
             return projectCanonicalAssistantCronJob({
-                automation: requireCanonicalAssistantCronRecord(created.record),
+                source,
                 runtimeState,
             });
         });
@@ -163,19 +165,22 @@ async function resolveAssistantCronTargetDefaults(input) {
     };
 }
 async function listCanonicalAssistantCronRecords(vault, status = ['active', 'paused']) {
-    const records = await listCanonicalAutomations(vault, {
-        status: [...status],
-    });
-    return records.flatMap((record) => {
-        const normalized = normalizeCanonicalAssistantCronRecord(record);
-        return normalized ? [normalized] : [];
-    });
-}
-async function findCanonicalAssistantCronRecord(vault, lookup) {
-    const record = await showCanonicalAutomation(vault, lookup);
-    return record ? normalizeCanonicalAssistantCronRecord(record) : null;
+    const timeZone = await resolveAssistantCronDefaultTimeZone(vault);
+    const [automationRecords, foodRecords] = await Promise.all([
+        listCanonicalAutomations(vault, {
+            status: [...status],
+        }),
+        listCanonicalFoodAutoLogRecords(vault, timeZone),
+    ]);
+    return [
+        ...automationRecords.flatMap((record) => {
+            const normalized = normalizeCanonicalAssistantCronRecord(record, timeZone);
+            return normalized ? [normalized] : [];
+        }),
+        ...(status.includes('active') ? foodRecords : []),
+    ];
 }
-function normalizeCanonicalAssistantCronRecord(record) {
+function normalizeCanonicalAssistantCronRecord(record, timeZone) {
     if (record.status !== 'active' && record.status !== 'paused') {
         return null;
     }
@@ -183,67 +188,190 @@ function normalizeCanonicalAssistantCronRecord(record) {
     if (typeof instructions !== 'string') {
         throw new VaultCliError('ASSISTANT_CRON_INVALID_AUTOMATION', `Canonical automation "${record.automationId}" is missing scheduled instructions.`);
     }
-    const { prompt: _prompt, ...rest } = record;
     return {
-        ...rest,
+        kind: 'automation',
+        automationId: record.automationId,
+        continuityPolicy: record.continuityPolicy,
+        createdAt: record.createdAt,
         instructions,
+        route: record.route,
+        schedule: normalizeAssistantCronPublicSchedule(record.schedule),
+        slug: record.slug,
         status: record.status,
+        summary: record.summary,
+        tags: [...record.tags],
+        timeZone: record.schedule.kind === 'cron' || record.schedule.kind === 'dailyLocal'
+            ? timeZone
+            : null,
+        title: record.title,
+        updatedAt: record.updatedAt,
     };
 }
-function requireCanonicalAssistantCronRecord(record) {
-    const normalized = normalizeCanonicalAssistantCronRecord(record);
+function requireCanonicalAssistantCronRecord(record, timeZone) {
+    const normalized = normalizeCanonicalAssistantCronRecord(record, timeZone);
     if (!normalized) {
         throw new VaultCliError('ASSISTANT_CRON_INVALID_AUTOMATION', `Canonical automation "${record.automationId}" is not active or paused.`);
     }
     return normalized;
 }
-function createInitialCanonicalAutomationRuntimeState(automation) {
-    const createdAt = automation.createdAt;
-    return createAssistantCronAutomationRuntimeRecord({
-        automationId: automation.automationId,
-        nextRunAt: automation.status === 'active'
-            ? computeAssistantCronNextRunAt(toAssistantCronSchedule(automation.schedule), new Date(createdAt))
-            : null,
-        now: createdAt,
+async function listCanonicalFoodAutoLogRecords(vault, timeZone) {
+    const core = await loadFoodAutoLogCoreRuntime();
+    if (typeof core.listFoods !== 'function') {
+        return [];
+    }
+    const foods = await core.listFoods(vault);
+    return foods.flatMap((food) => {
+        const localTime = normalizeNullableString(food.autoLogDaily?.time);
+        const slug = normalizeNullableString(food.slug);
+        if (!localTime || !slug) {
+            return [];
+        }
+        return [{
+                kind: 'foodAutoLog',
+                foodId: food.foodId,
+                jobId: buildDailyFoodCronJobId(food.foodId),
+                schedule: buildDailyFoodSchedule(localTime),
+                slug,
+                timeZone,
+                title: food.title,
+            }];
     });
 }
-function resolveCanonicalAutomationRuntimeState(automation, store) {
-    return (findAssistantCronAutomationRuntimeRecord(store, automation.automationId) ??
-        createInitialCanonicalAutomationRuntimeState(automation));
+function resolveCanonicalAssistantCronJobLookupKeys(record) {
+    if (record.kind === 'automation') {
+        return [record.automationId, record.slug, record.title];
+    }
+    return [record.jobId, buildDailyFoodCronJobName(record.slug)];
+}
+function findCanonicalAssistantCronRecordInList(records, lookup) {
+    const normalizedLookup = normalizeRequiredAssistantCronText(lookup, 'job');
+    const foldedLookup = normalizedLookup.toLocaleLowerCase();
+    return (records.find((record) => resolveCanonicalAssistantCronJobLookupKeys(record).some((candidate) => typeof candidate === 'string' &&
+        candidate.toLocaleLowerCase() === foldedLookup)) ?? null);
+}
+function createInitialCanonicalRuntimeState(source, now) {
+    return createAssistantCronCanonicalRuntimeRecord({
+        jobId: resolveCanonicalAssistantCronJobId(source),
+        now,
+    });
+}
+function resolveCanonicalRuntimeState(source, store, legacyLocalJob) {
+    return (findAssistantCronCanonicalRuntimeRecord(store, resolveCanonicalAssistantCronJobId(source)) ??
+        migrateLegacyLocalFoodRuntimeState(source, legacyLocalJob) ??
+        createInitialCanonicalRuntimeState(source, new Date().toISOString()));
 }
 function projectCanonicalAssistantCronJob(input) {
-    const continuitySessionId = input.automation.continuityPolicy === 'preserve'
+    const continuitySessionId = input.source.kind === 'automation' &&
+        input.source.continuityPolicy === 'preserve'
         ? input.runtimeState.sessionId
         : null;
-    const continuityAlias = input.automation.continuityPolicy === 'preserve'
+    const continuityAlias = input.source.kind === 'automation' &&
+        input.source.continuityPolicy === 'preserve'
         ? input.runtimeState.alias
         : null;
+    const targetRoute = input.source.kind === 'automation'
+        ? input.source.route
+        : {
+            channel: null,
+            deliveryTarget: null,
+            identityId: null,
+            participantId: null,
+            sourceThreadId: null,
+        };
     const target = assistantCronTargetSchema.parse({
         sessionId: continuitySessionId,
         alias: continuityAlias,
-        channel: input.automation.route.channel,
-        identityId: input.automation.route.identityId,
-        participantId: input.automation.route.participantId,
-        sourceThreadId: input.automation.route.sourceThreadId,
-        deliveryTarget: input.automation.route.deliveryTarget,
+        channel: targetRoute.channel,
+        identityId: targetRoute.identityId,
+        participantId: targetRoute.participantId,
+        sourceThreadId: targetRoute.sourceThreadId,
+        deliveryTarget: targetRoute.deliveryTarget,
+    });
+    const projectedState = projectCanonicalAssistantCronJobState({
+        source: input.source,
+        runtimeState: input.runtimeState,
     });
     return assistantCronJobSchema.parse({
         schema: ASSISTANT_CRON_JOB_SCHEMA,
-        jobId: input.automation.automationId,
-        name: input.automation.title,
-        enabled: input.automation.status === 'active',
-        keepAfterRun: input.automation.schedule.kind !== 'at',
-        prompt: input.automation.instructions,
-        schedule: toAssistantCronSchedule(input.automation.schedule),
+        jobId: resolveCanonicalAssistantCronJobId(input.source),
+        name: input.source.kind === 'automation'
+            ? input.source.title
+            : buildDailyFoodCronJobName(input.source.slug),
+        enabled: isCanonicalAssistantCronSourceEnabled(input.source),
+        keepAfterRun: input.source.schedule.kind !== 'at',
+        prompt: input.source.kind === 'automation'
+            ? input.source.instructions
+            : buildDailyFoodCronPrompt(input.source.title),
+        schedule: input.source.schedule,
         target,
-        createdAt: input.automation.createdAt,
-        updatedAt: input.automation.updatedAt,
+        foodAutoLog: input.source.kind === 'foodAutoLog'
+            ? {
+                foodId: input.source.foodId,
+            }
+            : undefined,
+        createdAt: input.source.kind === 'automation'
+            ? input.source.createdAt
+            : input.runtimeState.createdAt,
+        updatedAt: input.source.kind === 'automation'
+            ? input.source.updatedAt
+            : input.runtimeState.updatedAt,
+        state: projectedState,
+    });
+}
+function projectCanonicalAssistantCronJobState(input) {
+    const nextRunAt = resolveCanonicalAssistantCronNextRunAt({
+        source: input.source,
         state: input.runtimeState.state,
     });
+    return {
+        nextRunAt,
+        lastRunAt: input.runtimeState.state.lastRunAt,
+        lastSucceededAt: input.runtimeState.state.lastSucceededAt,
+        lastFailedAt: input.runtimeState.state.lastFailedAt,
+        consecutiveFailures: input.runtimeState.state.consecutiveFailures,
+        lastError: input.runtimeState.state.lastError,
+        runningAt: input.runtimeState.state.runningAt,
+        runningPid: input.runtimeState.state.runningPid,
+    };
+}
+function resolveCanonicalAssistantCronJobId(source) {
+    return source.kind === 'automation' ? source.automationId : source.jobId;
+}
+function isCanonicalAssistantCronSourceEnabled(source) {
+    return source.kind === 'automation' ? source.status === 'active' : true;
 }
-function toAssistantCronSchedule(schedule) {
+function normalizeAssistantCronPublicSchedule(schedule) {
+    if (schedule.kind === 'cron') {
+        return assistantCronScheduleSchema.parse({
+            kind: 'cron',
+            expression: schedule.expression,
+        });
+    }
+    if (schedule.kind === 'dailyLocal') {
+        return assistantCronScheduleSchema.parse({
+            kind: 'dailyLocal',
+            localTime: schedule.localTime,
+        });
+    }
     return assistantCronScheduleSchema.parse(schedule);
 }
+function resolveAssistantCronResolvedSchedule(input) {
+    if (input.schedule.kind === 'cron') {
+        return {
+            kind: 'cron',
+            expression: input.schedule.expression,
+            timeZone: input.timeZone ?? 'UTC',
+        };
+    }
+    if (input.schedule.kind === 'dailyLocal') {
+        return {
+            kind: 'dailyLocal',
+            localTime: input.schedule.localTime,
+            timeZone: input.timeZone ?? 'UTC',
+        };
+    }
+    return input.schedule;
+}
 function buildCanonicalAutomationRoute(target) {
     return {
         channel: target.channel ?? '',
@@ -270,50 +398,80 @@ function buildCanonicalAutomationUpsertInput(input) {
 }
 async function projectResolvedAssistantCronJob(vault, lookup) {
     const paths = resolveAssistantStatePaths(vault);
-    const localStore = await readAssistantCronStore(paths);
-    const localJob = tryResolveLocalAssistantCronJob(localStore, lookup);
+    const [localStore, canonicalRecords, runtimeStore] = await Promise.all([
+        readAssistantCronStore(paths),
+        listCanonicalAssistantCronRecords(vault),
+        readAssistantCronCanonicalRuntimeStore(paths),
+    ]);
+    const canonicalFoodIds = buildCanonicalFoodIdSet(canonicalRecords);
+    const visibleLocalStore = buildVisibleLocalAssistantCronStore(localStore, canonicalFoodIds);
+    const localJob = tryResolveLocalAssistantCronJob(visibleLocalStore, lookup);
     if (localJob) {
         return {
             kind: 'local',
             job: localJob,
         };
     }
-    const automation = await findCanonicalAssistantCronRecord(vault, lookup);
-    if (!automation) {
+    const source = findCanonicalAssistantCronRecordInList(canonicalRecords, lookup);
+    if (!source) {
         throw new VaultCliError('ASSISTANT_CRON_JOB_NOT_FOUND', `Assistant cron job "${normalizeRequiredAssistantCronText(lookup, 'job')}" was not found.`);
     }
-    const runtimeStore = await readAssistantCronAutomationRuntimeStore(paths);
-    const runtimeState = resolveCanonicalAutomationRuntimeState(automation, runtimeStore);
+    const legacyFoodJob = source.kind === 'foodAutoLog'
+        ? tryResolveLocalAssistantCronFoodJobByFoodId(localStore, source.foodId)
+        : null;
+    const runtimeState = resolveCanonicalRuntimeState(source, runtimeStore, legacyFoodJob);
     return {
-        kind: 'automation',
-        automation,
+        kind: 'canonical',
+        source,
         runtimeState,
         job: projectCanonicalAssistantCronJob({
-            automation,
+            source,
             runtimeState,
         }),
     };
 }
-function tryResolveLocalAssistantCronJob(store, lookup) {
+function tryResolveLocalAssistantCronJob(store, lookup, options = {}) {
     try {
-        return resolveAssistantCronJobFromStore(store, lookup);
+        const resolved = resolveAssistantCronJobFromStore(store, lookup);
+        if (options.allowFoodAutoLog === false && resolved.foodAutoLog) {
+            return null;
+        }
+        return resolved;
     }
     catch {
         return null;
     }
 }
+function tryResolveLocalAssistantCronFoodJobByFoodId(store, foodId) {
+    return store.jobs.find((job) => job.foodAutoLog?.foodId === foodId) ?? null;
+}
+function buildCanonicalFoodIdSet(records) {
+    return new Set(records.flatMap((record) => record.kind === 'foodAutoLog' ? [record.foodId] : []));
+}
+function buildVisibleLocalAssistantCronStore(store, canonicalFoodIds) {
+    if (canonicalFoodIds.size === 0) {
+        return store;
+    }
+    return {
+        ...store,
+        jobs: store.jobs.filter((job) => !job.foodAutoLog || !canonicalFoodIds.has(job.foodAutoLog.foodId)),
+    };
+}
 export async function listAssistantCronJobs(vault) {
     const paths = resolveAssistantStatePaths(vault);
     const [localStore, canonicalRecords, runtimeStore] = await Promise.all([
         readAssistantCronStore(paths),
         listCanonicalAssistantCronRecords(vault),
-        readAssistantCronAutomationRuntimeStore(paths),
+        readAssistantCronCanonicalRuntimeStore(paths),
     ]);
+    const canonicalFoodIds = buildCanonicalFoodIdSet(canonicalRecords);
     return sortAssistantCronJobs([
-        ...localStore.jobs,
-        ...canonicalRecords.map((automation) => projectCanonicalAssistantCronJob({
-            automation,
-            runtimeState: resolveCanonicalAutomationRuntimeState(automation, runtimeStore),
+        ...buildVisibleLocalAssistantCronStore(localStore, canonicalFoodIds).jobs,
+        ...canonicalRecords.map((source) => projectCanonicalAssistantCronJob({
+            source,
+            runtimeState: resolveCanonicalRuntimeState(source, runtimeStore, source.kind === 'foodAutoLog'
+                ? tryResolveLocalAssistantCronFoodJobByFoodId(localStore, source.foodId)
+                : null),
         })),
     ]);
 }
@@ -329,30 +487,44 @@ export async function removeAssistantCronJob(vault, job) {
     await ensureAssistantCronState(paths);
     return withAssistantCronWriteLock(paths, async () => {
         const store = await readAssistantCronStore(paths);
-        const localJob = tryResolveLocalAssistantCronJob(store, job);
+        const canonicalRecords = await listCanonicalAssistantCronRecords(vault);
+        const canonicalFoodIds = buildCanonicalFoodIdSet(canonicalRecords);
+        const visibleLocalStore = buildVisibleLocalAssistantCronStore(store, canonicalFoodIds);
+        const localJob = tryResolveLocalAssistantCronJob(visibleLocalStore, job);
         if (localJob) {
-            const index = resolveAssistantCronJobIndex(store, job);
+            const index = store.jobs.findIndex((entry) => entry.jobId === localJob.jobId);
             const [removed] = store.jobs.splice(index, 1);
             await writeAssistantCronStore(paths, store);
             return removed;
         }
         const resolved = await projectResolvedAssistantCronJob(vault, job);
-        if (resolved.kind !== 'automation') {
+        if (resolved.kind !== 'canonical') {
             return resolved.job;
         }
-        await upsertAutomation(buildCanonicalAutomationUpsertInput({
-            vault,
-            automationId: resolved.automation.automationId,
-            automation: resolved.automation,
-            title: resolved.automation.title,
-            status: 'archived',
-            schedule: toAssistantCronSchedule(resolved.automation.schedule),
-            route: resolved.automation.route,
-            instructions: resolved.automation.instructions,
-        }));
-        const runtimeStore = await readAssistantCronAutomationRuntimeStore(paths);
-        if (removeAssistantCronAutomationRuntimeRecord(runtimeStore, resolved.automation.automationId)) {
-            await writeAssistantCronAutomationRuntimeStore(paths, runtimeStore);
+        if (resolved.source.kind === 'automation') {
+            await upsertAutomation(buildCanonicalAutomationUpsertInput({
+                vault,
+                automationId: resolved.source.automationId,
+                automation: resolved.source,
+                title: resolved.source.title,
+                status: 'archived',
+                schedule: resolved.source.schedule,
+                route: resolved.source.route,
+                instructions: resolved.source.instructions,
+            }));
+        }
+        else {
+            const foodId = resolved.source.foodId;
+            await clearCanonicalFoodAutoLogSchedule(vault, foodId);
+            const nextLocalJobs = store.jobs.filter((entry) => entry.foodAutoLog?.foodId !== foodId);
+            if (nextLocalJobs.length !== store.jobs.length) {
+                store.jobs = nextLocalJobs;
+                await writeAssistantCronStore(paths, store);
+            }
+        }
+        const runtimeStore = await readAssistantCronCanonicalRuntimeStore(paths);
+        if (removeAssistantCronCanonicalRuntimeRecord(runtimeStore, resolveCanonicalAssistantCronJobId(resolved.source))) {
+            await writeAssistantCronCanonicalRuntimeStore(paths, runtimeStore);
         }
         return resolved.job;
     });
@@ -387,39 +559,47 @@ export async function setAssistantCronJobEnabled(vault, job, enabled) {
             return updated;
         }
         const resolved = await projectResolvedAssistantCronJob(vault, job);
-        if (resolved.kind !== 'automation') {
+        if (resolved.kind !== 'canonical') {
             return resolved.job;
         }
+        if (resolved.source.kind === 'foodAutoLog') {
+            throw new VaultCliError('ASSISTANT_CRON_INVALID_STATE', `Recurring food auto-log job "${resolved.job.name}" is controlled by the canonical food record, not assistant cron enable/disable.`);
+        }
         const now = new Date();
         const nextRunAt = enabled
-            ? resolveAssistantCronReenabledNextRunAt(resolved.job, now)
-            : resolved.runtimeState.state.nextRunAt;
+            ? computeAssistantCronNextRunAt(resolveAssistantCronResolvedSchedule({
+                schedule: resolved.source.schedule,
+                timeZone: resolved.source.timeZone,
+            }), now)
+            : null;
         if (enabled && nextRunAt === null) {
             throw new VaultCliError('ASSISTANT_CRON_INVALID_STATE', `Assistant cron job "${resolved.job.name}" no longer has a future scheduled run. Run it manually or recreate it with a new schedule.`);
         }
         const updatedAutomation = await upsertAutomation(buildCanonicalAutomationUpsertInput({
             vault,
-            automationId: resolved.automation.automationId,
-            automation: resolved.automation,
-            title: resolved.automation.title,
+            automationId: resolved.source.automationId,
+            automation: resolved.source,
+            title: resolved.source.title,
             status: enabled ? 'active' : 'paused',
-            schedule: toAssistantCronSchedule(resolved.automation.schedule),
-            route: resolved.automation.route,
-            instructions: resolved.automation.instructions,
+            schedule: resolved.source.schedule,
+            route: resolved.source.route,
+            instructions: resolved.source.instructions,
         }));
-        const runtimeStore = await readAssistantCronAutomationRuntimeStore(paths);
+        const runtimeStore = await readAssistantCronCanonicalRuntimeStore(paths);
         const updatedRuntimeState = {
             ...resolved.runtimeState,
             updatedAt: now.toISOString(),
             state: {
                 ...resolved.runtimeState.state,
-                nextRunAt,
+                activatedAt: enabled ? now.toISOString() : resolved.runtimeState.state.activatedAt,
+                pendingOccurrenceAt: null,
+                retryAfterAt: null,
             },
         };
-        upsertAssistantCronAutomationRuntimeRecord(runtimeStore, updatedRuntimeState);
-        await writeAssistantCronAutomationRuntimeStore(paths, runtimeStore);
+        upsertAssistantCronCanonicalRuntimeRecord(runtimeStore, updatedRuntimeState);
+        await writeAssistantCronCanonicalRuntimeStore(paths, runtimeStore);
         return projectCanonicalAssistantCronJob({
-            automation: requireCanonicalAssistantCronRecord(updatedAutomation.record),
+            source: requireCanonicalAssistantCronRecord(updatedAutomation.record, await resolveAssistantCronDefaultTimeZone(vault)),
             runtimeState: updatedRuntimeState,
         });
     });
@@ -488,7 +668,7 @@ export async function setAssistantCronJobTarget(input) {
             };
         }
         const resolved = await projectResolvedAssistantCronJob(resolvedInput.vault, resolvedInput.job);
-        if (resolved.kind !== 'automation') {
+        if (resolved.kind !== 'canonical') {
             return {
                 job: resolved.job,
                 beforeTarget: buildAssistantCronTargetSnapshot(resolved.job),
@@ -498,6 +678,9 @@ export async function setAssistantCronJobTarget(input) {
                 dryRun: Boolean(resolvedInput.dryRun),
             };
         }
+        if (resolved.source.kind === 'foodAutoLog') {
+            throw new VaultCliError('ASSISTANT_CRON_DELIVERY_REQUIRED', `Recurring food auto-log job "${resolved.job.name}" does not support assistant delivery targeting.`);
+        }
         if (resolved.runtimeState.state.runningAt !== null) {
             throw new VaultCliError('ASSISTANT_CRON_JOB_RUNNING', `Assistant cron job "${resolved.job.name}" is already running.`);
         }
@@ -536,25 +719,25 @@ export async function setAssistantCronJobTarget(input) {
         const now = (resolvedInput.now ?? new Date()).toISOString();
         const updatedAutomation = await upsertAutomation(buildCanonicalAutomationUpsertInput({
             vault: resolvedInput.vault,
-            automationId: resolved.automation.automationId,
-            automation: resolved.automation,
-            title: resolved.automation.title,
-            status: resolved.automation.status,
-            schedule: toAssistantCronSchedule(resolved.automation.schedule),
+            automationId: resolved.source.automationId,
+            automation: resolved.source,
+            title: resolved.source.title,
+            status: resolved.source.status,
+            schedule: resolved.source.schedule,
             route: buildCanonicalAutomationRoute(afterTarget.target),
-            instructions: resolved.automation.instructions,
+            instructions: resolved.source.instructions,
         }));
-        const runtimeStore = await readAssistantCronAutomationRuntimeStore(paths);
+        const runtimeStore = await readAssistantCronCanonicalRuntimeStore(paths);
         const updatedRuntimeState = {
             ...resolved.runtimeState,
             alias: afterTarget.target.alias,
             sessionId: afterTarget.target.sessionId,
             updatedAt: now,
         };
-        upsertAssistantCronAutomationRuntimeRecord(runtimeStore, updatedRuntimeState);
-        await writeAssistantCronAutomationRuntimeStore(paths, runtimeStore);
+        upsertAssistantCronCanonicalRuntimeRecord(runtimeStore, updatedRuntimeState);
+        await writeAssistantCronCanonicalRuntimeStore(paths, runtimeStore);
         const updatedJob = projectCanonicalAssistantCronJob({
-            automation: requireCanonicalAssistantCronRecord(updatedAutomation.record),
+            source: requireCanonicalAssistantCronRecord(updatedAutomation.record, await resolveAssistantCronDefaultTimeZone(resolvedInput.vault)),
             runtimeState: updatedRuntimeState,
         });
         return {
@@ -638,29 +821,34 @@ export async function runAssistantCronJobNow(input) {
             };
         }
         const resolved = await projectResolvedAssistantCronJob(input.vault, input.job);
-        if (resolved.kind !== 'automation') {
+        if (resolved.kind !== 'canonical') {
             return resolved;
         }
         if (resolved.runtimeState.state.runningAt !== null) {
             throw new VaultCliError('ASSISTANT_CRON_JOB_RUNNING', `Assistant cron job "${resolved.job.name}" is already running.`);
         }
-        const runtimeStore = await readAssistantCronAutomationRuntimeStore(paths);
+        const runtimeStore = await readAssistantCronCanonicalRuntimeStore(paths);
+        const now = new Date().toISOString();
+        const occurrenceAt = resolveCanonicalAssistantCronOccurrenceAt(resolved.source, resolved.runtimeState) ??
+            now;
         const updatedRuntimeState = {
             ...resolved.runtimeState,
-            updatedAt: new Date().toISOString(),
+            updatedAt: now,
             state: {
                 ...resolved.runtimeState.state,
-                runningAt: new Date().toISOString(),
+                pendingOccurrenceAt: occurrenceAt,
+                retryAfterAt: null,
+                runningAt: now,
                 runningPid: process.pid,
             },
         };
-        upsertAssistantCronAutomationRuntimeRecord(runtimeStore, updatedRuntimeState);
-        await writeAssistantCronAutomationRuntimeStore(paths, runtimeStore);
+        upsertAssistantCronCanonicalRuntimeRecord(runtimeStore, updatedRuntimeState);
+        await writeAssistantCronCanonicalRuntimeStore(paths, runtimeStore);
         return {
             ...resolved,
             runtimeState: updatedRuntimeState,
             job: projectCanonicalAssistantCronJob({
-                automation: resolved.automation,
+                source: resolved.source,
                 runtimeState: updatedRuntimeState,
             }),
         };
@@ -755,22 +943,26 @@ async function claimNextDueAssistantCronJob(paths, vault) {
         const [store, canonicalRecords, runtimeStore] = await Promise.all([
             readAssistantCronStore(paths),
             listCanonicalAssistantCronRecords(vault, ['active']),
-            readAssistantCronAutomationRuntimeStore(paths),
+            readAssistantCronCanonicalRuntimeStore(paths),
         ]);
         const now = new Date().toISOString();
-        const canonicalEntries = canonicalRecords.map((automation) => {
-            const runtimeState = resolveCanonicalAutomationRuntimeState(automation, runtimeStore);
+        const canonicalFoodIds = buildCanonicalFoodIdSet(canonicalRecords);
+        const visibleLocalStore = buildVisibleLocalAssistantCronStore(store, canonicalFoodIds);
+        const canonicalEntries = canonicalRecords.map((source) => {
+            const runtimeState = resolveCanonicalRuntimeState(source, runtimeStore, source.kind === 'foodAutoLog'
+                ? tryResolveLocalAssistantCronFoodJobByFoodId(store, source.foodId)
+                : null);
             return {
-                automation,
+                source,
                 runtimeState,
                 job: projectCanonicalAssistantCronJob({
-                    automation,
+                    source,
                     runtimeState,
                 }),
             };
         });
         const candidate = sortAssistantCronJobs([
-            ...store.jobs,
+            ...visibleLocalStore.jobs,
             ...canonicalEntries.map((entry) => entry.job),
         ]).find((job) => isAssistantCronJobDue(job, now));
         if (!candidate) {
@@ -794,24 +986,27 @@ async function claimNextDueAssistantCronJob(paths, vault) {
                 job: claimed,
             };
         }
-        const canonicalEntry = canonicalEntries.find((entry) => entry.automation.automationId === candidate.jobId);
+        const canonicalEntry = canonicalEntries.find((entry) => resolveCanonicalAssistantCronJobId(entry.source) === candidate.jobId);
+        const occurrenceAt = resolveCanonicalAssistantCronOccurrenceAt(canonicalEntry.source, canonicalEntry.runtimeState) ?? candidate.state.nextRunAt ?? now;
         const updatedRuntimeState = {
             ...canonicalEntry.runtimeState,
             updatedAt: now,
             state: {
                 ...canonicalEntry.runtimeState.state,
+                pendingOccurrenceAt: occurrenceAt,
+                retryAfterAt: null,
                 runningAt: now,
                 runningPid: process.pid,
             },
         };
-        upsertAssistantCronAutomationRuntimeRecord(runtimeStore, updatedRuntimeState);
-        await writeAssistantCronAutomationRuntimeStore(paths, runtimeStore);
+        upsertAssistantCronCanonicalRuntimeRecord(runtimeStore, updatedRuntimeState);
+        await writeAssistantCronCanonicalRuntimeStore(paths, runtimeStore);
         return {
-            kind: 'automation',
-            automation: canonicalEntry.automation,
+            kind: 'canonical',
+            source: canonicalEntry.source,
             runtimeState: updatedRuntimeState,
             job: projectCanonicalAssistantCronJob({
-                automation: canonicalEntry.automation,
+                source: canonicalEntry.source,
                 runtimeState: updatedRuntimeState,
             }),
         };
@@ -918,57 +1113,65 @@ async function executeClaimedAssistantCronJob(input) {
                 removedAfterRun,
             };
         }
-        const runtimeStore = await readAssistantCronAutomationRuntimeStore(input.paths);
-        const currentRuntimeState = findAssistantCronAutomationRuntimeRecord(runtimeStore, input.job.automation.automationId) ?? input.job.runtimeState;
-        const currentJob = projectCanonicalAssistantCronJob({
-            automation: input.job.automation,
-            runtimeState: currentRuntimeState,
-        });
-        const finalizedJob = finalizeAssistantCronJobAfterRun({
-            job: currentJob,
+        const runtimeStore = await readAssistantCronCanonicalRuntimeStore(input.paths);
+        const currentRuntimeState = findAssistantCronCanonicalRuntimeRecord(runtimeStore, resolveCanonicalAssistantCronJobId(input.job.source)) ?? input.job.runtimeState;
+        const updatedRuntimeState = finalizeCanonicalAssistantCronRuntimeAfterRun({
             finishedAt,
-            responseSessionId: input.job.automation.continuityPolicy === 'preserve' ? sessionId : null,
             run: {
                 ...run,
                 status,
             },
+            runtimeState: currentRuntimeState,
+            responseSessionId: input.job.source.kind === 'automation' &&
+                input.job.source.continuityPolicy === 'preserve'
+                ? sessionId
+                : null,
+            source: input.job.source,
         });
-        const updatedRuntimeState = {
+        const persistedRuntimeState = {
             ...currentRuntimeState,
-            alias: input.job.automation.continuityPolicy === 'preserve'
-                ? finalizedJob.target.alias
+            alias: input.job.source.kind === 'automation' &&
+                input.job.source.continuityPolicy === 'preserve'
+                ? updatedRuntimeState.alias
                 : null,
-            sessionId: input.job.automation.continuityPolicy === 'preserve'
-                ? finalizedJob.target.sessionId
+            sessionId: input.job.source.kind === 'automation' &&
+                input.job.source.continuityPolicy === 'preserve'
+                ? updatedRuntimeState.sessionId
                 : null,
             updatedAt: finishedAt,
-            state: finalizedJob.state,
+            state: updatedRuntimeState.state,
         };
+        const finalizedJob = projectCanonicalAssistantCronJob({
+            source: input.job.source,
+            runtimeState: persistedRuntimeState,
+        });
         let removedAfterRun = false;
         if (shouldRemoveAssistantCronJobAfterRun(finalizedJob, run)) {
-            await upsertAutomation(buildCanonicalAutomationUpsertInput({
-                vault: input.vault,
-                automationId: input.job.automation.automationId,
-                automation: input.job.automation,
-                title: input.job.automation.title,
-                status: 'archived',
-                schedule: toAssistantCronSchedule(input.job.automation.schedule),
-                route: input.job.automation.route,
-                instructions: input.job.automation.instructions,
-            }));
-            removeAssistantCronAutomationRuntimeRecord(runtimeStore, input.job.automation.automationId);
+            if (input.job.source.kind === 'automation') {
+                await upsertAutomation(buildCanonicalAutomationUpsertInput({
+                    vault: input.vault,
+                    automationId: input.job.source.automationId,
+                    automation: input.job.source,
+                    title: input.job.source.title,
+                    status: 'archived',
+                    schedule: input.job.source.schedule,
+                    route: input.job.source.route,
+                    instructions: input.job.source.instructions,
+                }));
+            }
+            removeAssistantCronCanonicalRuntimeRecord(runtimeStore, resolveCanonicalAssistantCronJobId(input.job.source));
             removedAfterRun = true;
         }
         else {
-            upsertAssistantCronAutomationRuntimeRecord(runtimeStore, updatedRuntimeState);
+            upsertAssistantCronCanonicalRuntimeRecord(runtimeStore, persistedRuntimeState);
         }
-        await writeAssistantCronAutomationRuntimeStore(input.paths, runtimeStore);
+        await writeAssistantCronCanonicalRuntimeStore(input.paths, runtimeStore);
         return {
             job: removedAfterRun
                 ? finalizedJob
                 : projectCanonicalAssistantCronJob({
-                    automation: input.job.automation,
-                    runtimeState: updatedRuntimeState,
+                    source: input.job.source,
+                    runtimeState: persistedRuntimeState,
                 }),
             removedAfterRun,
         };
@@ -1063,14 +1266,125 @@ function resolveAssistantCronFailureBackoffMs(failureCount) {
     }
     return 60 * 60_000;
 }
+function resolveCanonicalAssistantCronOccurrenceAt(source, runtimeState) {
+    if (!isCanonicalAssistantCronSourceEnabled(source)) {
+        return null;
+    }
+    if (runtimeState.state.pendingOccurrenceAt) {
+        return runtimeState.state.pendingOccurrenceAt;
+    }
+    if (source.schedule.kind === 'at') {
+        return source.schedule.at;
+    }
+    const anchorAt = runtimeState.state.lastSucceededAt ?? runtimeState.state.activatedAt;
+    if (!anchorAt) {
+        return null;
+    }
+    return computeAssistantCronNextRunAt(resolveAssistantCronResolvedSchedule({
+        schedule: source.schedule,
+        timeZone: source.kind === 'automation' ? source.timeZone : source.timeZone,
+    }), new Date(anchorAt));
+}
+function resolveCanonicalAssistantCronNextRunAt(input) {
+    if (!isCanonicalAssistantCronSourceEnabled(input.source)) {
+        return null;
+    }
+    if (input.state.pendingOccurrenceAt) {
+        return input.state.retryAfterAt ?? input.state.pendingOccurrenceAt;
+    }
+    if (input.source.schedule.kind === 'at') {
+        return input.source.schedule.at;
+    }
+    const anchorAt = input.state.lastSucceededAt ?? input.state.activatedAt;
+    if (!anchorAt) {
+        return null;
+    }
+    return computeAssistantCronNextRunAt(resolveAssistantCronResolvedSchedule({
+        schedule: input.source.schedule,
+        timeZone: input.source.kind === 'automation'
+            ? input.source.timeZone
+            : input.source.timeZone,
+    }), new Date(anchorAt));
+}
+function finalizeCanonicalAssistantCronRuntimeAfterRun(input) {
+    const runningClearedState = {
+        ...input.runtimeState.state,
+        runningAt: null,
+        runningPid: null,
+        lastRunAt: input.finishedAt,
+    };
+    if (input.run.status === 'succeeded') {
+        return {
+            ...input.runtimeState,
+            sessionId: input.responseSessionId ?? input.runtimeState.sessionId,
+            updatedAt: input.finishedAt,
+            state: {
+                ...runningClearedState,
+                pendingOccurrenceAt: null,
+                retryAfterAt: null,
+                lastSucceededAt: input.finishedAt,
+                lastError: null,
+                consecutiveFailures: 0,
+            },
+        };
+    }
+    const failureCount = input.runtimeState.state.consecutiveFailures + 1;
+    const retryAfterAt = isCanonicalAssistantCronSourceEnabled(input.source)
+        ? new Date(Date.parse(input.finishedAt) + resolveAssistantCronFailureBackoffMs(failureCount)).toISOString()
+        : null;
+    return {
+        ...input.runtimeState,
+        updatedAt: input.finishedAt,
+        state: {
+            ...runningClearedState,
+            pendingOccurrenceAt: input.runtimeState.state.pendingOccurrenceAt ??
+                resolveCanonicalAssistantCronOccurrenceAt(input.source, input.runtimeState),
+            retryAfterAt,
+            lastFailedAt: input.finishedAt,
+            lastError: input.run.error,
+            consecutiveFailures: failureCount,
+        },
+    };
+}
+function migrateLegacyLocalFoodRuntimeState(source, legacyLocalJob) {
+    if (source.kind !== 'foodAutoLog' || !legacyLocalJob) {
+        return null;
+    }
+    return {
+        schema: 'murph.assistant-canonical-cron-runtime-state.v2',
+        jobId: source.jobId,
+        alias: null,
+        sessionId: null,
+        createdAt: legacyLocalJob.createdAt,
+        updatedAt: legacyLocalJob.updatedAt,
+        state: {
+            activatedAt: legacyLocalJob.createdAt,
+            pendingOccurrenceAt: legacyLocalJob.state.runningAt !== null ||
+                legacyLocalJob.state.consecutiveFailures > 0
+                ? legacyLocalJob.state.nextRunAt
+                : null,
+            retryAfterAt: legacyLocalJob.state.consecutiveFailures > 0
+                ? legacyLocalJob.state.nextRunAt
+                : null,
+            lastRunAt: legacyLocalJob.state.lastRunAt,
+            lastSucceededAt: legacyLocalJob.state.lastSucceededAt,
+            lastFailedAt: legacyLocalJob.state.lastFailedAt,
+            consecutiveFailures: legacyLocalJob.state.consecutiveFailures,
+            lastError: legacyLocalJob.state.lastError,
+            runningAt: legacyLocalJob.state.runningAt,
+            runningPid: legacyLocalJob.state.runningPid,
+        },
+    };
+}
 async function resolveAssistantCronScheduleForVault(vault, schedule) {
-    if (schedule.kind !== 'cron' || schedule.timeZone) {
-        return assistantCronScheduleSchema.parse(schedule);
+    const publicSchedule = assistantCronScheduleSchema.parse(schedule);
+    if (publicSchedule.kind === 'cron' || publicSchedule.kind === 'dailyLocal') {
+        return resolveAssistantCronResolvedSchedule({
+            schedule: publicSchedule,
+            timeZone: await resolveAssistantCronDefaultTimeZone(vault),
+        });
     }
-    return assistantCronScheduleSchema.parse({
-        ...schedule,
-        timeZone: await resolveAssistantCronDefaultTimeZone(vault),
-    });
+    return publicSchedule;
 }
 async function resolveAssistantCronDefaultTimeZone(vault) {
     try {
@@ -1083,6 +1397,36 @@ async function resolveAssistantCronDefaultTimeZone(vault) {
         return resolveSystemTimeZone();
     }
 }
+async function loadFoodAutoLogCoreRuntime() {
+    return loadRuntimeModule('@murphai/core');
+}
+async function clearCanonicalFoodAutoLogSchedule(vault, foodId) {
+    const core = await loadFoodAutoLogCoreRuntime();
+    const existing = await core.readFood({
+        vaultRoot: vault,
+        foodId,
+    });
+    await core.upsertFood({
+        vaultRoot: vault,
+        foodId: existing.foodId,
+        slug: existing.slug,
+        title: existing.title,
+        status: existing.status,
+        summary: existing.summary,
+        kind: existing.kind,
+        brand: existing.brand,
+        vendor: existing.vendor,
+        location: existing.location,
+        serving: existing.serving,
+        nutrition: existing.nutrition,
+        aliases: existing.aliases,
+        ingredients: existing.ingredients,
+        tags: existing.tags,
+        note: existing.note,
+        attachedProtocolIds: existing.attachedProtocolIds,
+        autoLogDaily: null,
+    });
+}
 function assistantCronJobHasStableSessionLocator(job) {
     return Boolean(job.target.sessionId ||
         job.target.alias ||