@murphai/murph 0.2.12 → 1.0.0

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

@@ -1,17 +1,17 @@
-import { resolveSystemTimeZone, } from '@murphai/contracts';
-import { loadVault, upsertAutomation } from '@murphai/core';
-import { listAutomations as listCanonicalAutomations, showAutomation as showCanonicalAutomation, } from '@murphai/query';
+import { resolveSystemTimeZone } from '@murphai/contracts';
+import { loadVault, setScheduledLogStatus, upsertAutomation } from '@murphai/core';
+import { listAutomations as listCanonicalAutomations, listScheduledLogs as listCanonicalScheduledLogs, 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 { loadImporterRuntime } from '@murphai/vault-usecases/runtime';
+import { buildDailyFoodCronJobName, buildDailyFoodCronPrompt, } from '@murphai/vault-usecases/records';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
 import { withAssistantCronWriteLock } from "./cron/locking.js";
 import { buildAssistantCronSchedule, computeAssistantCronNextRunAt, } from "./cron/schedule.js";
 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 { clearCanonicalFoodAutoLogSchedule, listCanonicalFoodAutoLogRecords, runFoodAutoLogCronJob, } from "./cron/food-auto-log.js";
+import { normalizeCanonicalScheduledLogCronRecord, runScheduledLogCronJob, } from "./cron/scheduled-log.js";
 import { sendAssistantNotificationLocal } from "../assistant-service.js";
 import { getAssistantChannelAdapter } from "./channel-adapters.js";
 import { resolveAssistantBindingDelivery } from "./bindings.js";
@@ -46,7 +46,7 @@ export async function installAssistantCronPreset(input) {
         channel: input.channel,
         identityId: input.identityId,
         participantId: input.participantId,
-        sourceThreadId: input.sourceThreadId,
+        threadId: input.threadId,
         deliveryTarget: input.deliveryTarget,
     });
     return {
@@ -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,
             });
         });
@@ -148,7 +150,7 @@ async function resolveAssistantCronTargetDefaults(input) {
         channel: input.channel,
         identityId: input.identityId,
         participantId: input.participantId,
-        sourceThreadId: input.sourceThreadId,
+        threadId: input.threadId,
         deliveryTarget: input.deliveryTarget,
     }, {
         allowSingleSavedTargetFallback: true,
@@ -158,24 +160,34 @@ async function resolveAssistantCronTargetDefaults(input) {
         channel: resolvedTarget.channel ?? undefined,
         identityId: resolvedTarget.identityId ?? undefined,
         participantId: resolvedTarget.participantId ?? undefined,
-        sourceThreadId: resolvedTarget.sourceThreadId ?? undefined,
+        threadId: resolvedTarget.threadId ?? undefined,
         deliveryTarget: resolvedTarget.deliveryTarget ?? undefined,
     };
 }
 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, scheduledLogRecords, foodRecords] = await Promise.all([
+        listCanonicalAutomations(vault, {
+            status: [...status],
+        }),
+        listCanonicalScheduledLogs(vault, {
+            status: [...status],
+        }),
+        listCanonicalFoodAutoLogRecords(vault, timeZone),
+    ]);
+    return [
+        ...automationRecords.flatMap((record) => {
+            const normalized = normalizeCanonicalAssistantCronRecord(record, timeZone);
+            return normalized ? [normalized] : [];
+        }),
+        ...scheduledLogRecords.flatMap((record) => {
+            const normalized = normalizeCanonicalScheduledLogCronRecord(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,74 +195,217 @@ 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,
+function resolveCanonicalAssistantCronJobLookupKeys(record) {
+    switch (record.kind) {
+        case 'automation':
+            return [record.automationId, record.slug, record.title];
+        case 'scheduledLog':
+            return [record.scheduledLogId, record.slug, record.title];
+        case 'foodAutoLog':
+            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 resolveCanonicalAutomationRuntimeState(automation, store) {
-    return (findAssistantCronAutomationRuntimeRecord(store, automation.automationId) ??
-        createInitialCanonicalAutomationRuntimeState(automation));
+function resolveCanonicalRuntimeState(source, store) {
+    return (findAssistantCronCanonicalRuntimeRecord(store, resolveCanonicalAssistantCronJobId(source)) ??
+        createInitialCanonicalRuntimeState(source, new Date().toISOString()));
+}
+function buildCanonicalAssistantCronJobName(source) {
+    switch (source.kind) {
+        case 'automation':
+        case 'scheduledLog':
+            return source.title;
+        case 'foodAutoLog':
+            return buildDailyFoodCronJobName(source.slug);
+    }
+}
+function buildCanonicalAssistantCronJobPrompt(source) {
+    switch (source.kind) {
+        case 'automation':
+            return source.instructions;
+        case 'scheduledLog':
+            return `Auto-log scheduled log "${source.title}" as ${source.actionKind}.`;
+        case 'foodAutoLog':
+            return buildDailyFoodCronPrompt(source.title);
+    }
+}
+function resolveCanonicalAssistantCronCreatedAt(input) {
+    return input.source.kind === 'foodAutoLog'
+        ? input.runtimeState.createdAt
+        : input.source.createdAt;
+}
+function resolveCanonicalAssistantCronUpdatedAt(input) {
+    return input.source.kind === 'foodAutoLog'
+        ? input.runtimeState.updatedAt
+        : input.source.updatedAt;
 }
 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,
+            threadId: 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,
+        threadId: targetRoute.threadId,
+        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: buildCanonicalAssistantCronJobName(input.source),
+        enabled: isCanonicalAssistantCronSourceEnabled(input.source),
+        keepAfterRun: input.source.schedule.kind !== 'at',
+        prompt: buildCanonicalAssistantCronJobPrompt(input.source),
+        schedule: input.source.schedule,
         target,
-        createdAt: input.automation.createdAt,
-        updatedAt: input.automation.updatedAt,
+        foodAutoLog: input.source.kind === 'foodAutoLog'
+            ? {
+                foodId: input.source.foodId,
+            }
+            : undefined,
+        scheduledLog: input.source.kind === 'scheduledLog'
+            ? {
+                scheduledLogId: input.source.scheduledLogId,
+                actionKind: input.source.actionKind,
+            }
+            : undefined,
+        createdAt: resolveCanonicalAssistantCronCreatedAt(input),
+        updatedAt: resolveCanonicalAssistantCronUpdatedAt(input),
+        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 toAssistantCronSchedule(schedule) {
+function resolveCanonicalAssistantCronJobId(source) {
+    switch (source.kind) {
+        case 'automation':
+            return source.automationId;
+        case 'scheduledLog':
+            return source.scheduledLogId;
+        case 'foodAutoLog':
+            return source.jobId;
+    }
+}
+function isCanonicalAssistantCronSourceEnabled(source) {
+    switch (source.kind) {
+        case 'automation':
+        case 'scheduledLog':
+            return source.status === 'active';
+        case 'foodAutoLog':
+            return true;
+    }
+}
+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 ?? '',
         deliveryTarget: target.deliveryTarget,
         identityId: target.identityId,
         participantId: target.participantId,
-        sourceThreadId: target.sourceThreadId,
+        threadId: target.threadId,
     };
 }
 function buildCanonicalAutomationUpsertInput(input) {
@@ -270,50 +425,72 @@ 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 runtimeState = resolveCanonicalRuntimeState(source, runtimeStore);
     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 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),
         })),
     ]);
 }
@@ -329,30 +506,51 @@ 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 if (resolved.source.kind === 'scheduledLog') {
+            await setScheduledLogStatus({
+                vaultRoot: vault,
+                scheduledLogId: resolved.source.scheduledLogId,
+                status: 'archived',
+            });
+        }
+        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 +585,63 @@ 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,
-            status: enabled ? 'active' : 'paused',
-            schedule: toAssistantCronSchedule(resolved.automation.schedule),
-            route: resolved.automation.route,
-            instructions: resolved.automation.instructions,
-        }));
-        const runtimeStore = await readAssistantCronAutomationRuntimeStore(paths);
+        let updatedSource = resolved.source;
+        if (resolved.source.kind === 'automation') {
+            const updatedAutomation = await upsertAutomation(buildCanonicalAutomationUpsertInput({
+                vault,
+                automationId: resolved.source.automationId,
+                automation: resolved.source,
+                title: resolved.source.title,
+                status: enabled ? 'active' : 'paused',
+                schedule: resolved.source.schedule,
+                route: resolved.source.route,
+                instructions: resolved.source.instructions,
+            }));
+            updatedSource = requireCanonicalAssistantCronRecord(updatedAutomation.record, await resolveAssistantCronDefaultTimeZone(vault));
+        }
+        else if (resolved.source.kind === 'scheduledLog') {
+            await setScheduledLogStatus({
+                vaultRoot: vault,
+                scheduledLogId: resolved.source.scheduledLogId,
+                status: enabled ? 'active' : 'paused',
+            });
+            updatedSource = {
+                ...resolved.source,
+                status: enabled ? 'active' : 'paused',
+                updatedAt: now.toISOString(),
+            };
+        }
+        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: updatedSource,
             runtimeState: updatedRuntimeState,
         });
     });
@@ -488,7 +710,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 +720,9 @@ export async function setAssistantCronJobTarget(input) {
                 dryRun: Boolean(resolvedInput.dryRun),
             };
         }
+        if (resolved.source.kind !== 'automation') {
+            throw new VaultCliError('ASSISTANT_CRON_DELIVERY_REQUIRED', `Canonical 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 +761,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 +863,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,
             }),
         };
@@ -721,7 +951,7 @@ function buildValidatedAssistantCronTarget(input) {
 function validateAssistantCronDeliveryTarget(input) {
     const channel = normalizeNullableString(input.channel);
     if (!channel) {
-        throw new VaultCliError('ASSISTANT_CRON_DELIVERY_REQUIRED', 'Assistant cron jobs must declare an outbound channel and delivery route. Pass --channel plus --sourceThread, --participant, or --deliveryTarget. Cron jobs send a single notification message to the bound route.');
+        throw new VaultCliError('ASSISTANT_CRON_DELIVERY_REQUIRED', 'Assistant cron jobs must declare an outbound channel and delivery route. Pass --channel plus --thread, --participant, or --deliveryTarget. Cron jobs send a single notification message to the bound route.');
     }
     if (!getAssistantChannelAdapter(channel)) {
         throw new VaultCliError('ASSISTANT_CHANNEL_UNSUPPORTED', `Outbound delivery for channel "${channel}" is not supported in this build.`);
@@ -731,22 +961,22 @@ function validateAssistantCronDeliveryTarget(input) {
         throw new VaultCliError('ASSISTANT_EMAIL_IDENTITY_REQUIRED', 'Email cron jobs require a configured email sender identity. Pass --identity with the email address or provider identity you want to send from.');
     }
     const participantId = normalizeNullableString(input.participantId);
-    const sourceThreadId = normalizeNullableString(input.sourceThreadId);
+    const threadId = normalizeNullableString(input.threadId);
     const deliveryTarget = normalizeNullableString(input.deliveryTarget);
     const bindingDelivery = resolveAssistantBindingDelivery({
         channel,
         actorId: participantId,
-        threadId: sourceThreadId,
+        threadId,
     });
     if (!deliveryTarget && !bindingDelivery) {
-        throw new VaultCliError('ASSISTANT_CRON_DELIVERY_REQUIRED', 'Assistant cron jobs must bind an explicit outbound route. Pass --sourceThread, --participant, or --deliveryTarget for the selected channel.');
+        throw new VaultCliError('ASSISTANT_CRON_DELIVERY_REQUIRED', 'Assistant cron jobs must bind an explicit outbound route. Pass --thread, --participant, or --deliveryTarget for the selected channel.');
     }
     return buildAssistantCronTarget({
         ...input,
         channel,
         identityId,
         participantId,
-        sourceThreadId,
+        threadId,
         deliveryTarget,
     });
 }
@@ -755,22 +985,24 @@ 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);
             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 +1026,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,
             }),
         };
@@ -825,14 +1060,27 @@ async function executeClaimedAssistantCronJob(input) {
     let response = null;
     let errorText = null;
     let status = 'failed';
+    const occurrenceAt = input.job.kind === 'canonical'
+        ? input.job.runtimeState.state.pendingOccurrenceAt ??
+            resolveCanonicalAssistantCronOccurrenceAt(input.job.source, input.job.runtimeState) ??
+            startedAt
+        : startedAt;
     try {
         if (input.signal?.aborted) {
             throw new VaultCliError('ASSISTANT_CRON_ABORTED', `Assistant cron job "${claimedJob.name}" was aborted before it started.`);
         }
-        if (claimedJob.foodAutoLog) {
+        if (input.job.kind === 'canonical' && input.job.source.kind === 'scheduledLog') {
+            response = await runScheduledLogCronJob({
+                vault: input.vault,
+                scheduledLogId: input.job.source.scheduledLogId,
+                occurrenceAt,
+            });
+        }
+        else if (claimedJob.foodAutoLog) {
             response = await runFoodAutoLogCronJob({
                 vault: input.vault,
                 foodId: claimedJob.foodAutoLog.foodId,
+                occurrenceAt,
             });
         }
         else {
@@ -850,7 +1098,7 @@ async function executeClaimedAssistantCronJob(input) {
                 channel: claimedJob.target.channel,
                 identityId: claimedJob.target.identityId,
                 participantId: claimedJob.target.participantId,
-                sourceThreadId: claimedJob.target.sourceThreadId,
+                threadId: claimedJob.target.threadId,
                 deliveryDispatchMode: input.deliveryDispatchMode,
                 deliveryTarget: claimedJob.target.deliveryTarget,
                 turnTrigger: 'automation-cron',
@@ -859,9 +1107,7 @@ async function executeClaimedAssistantCronJob(input) {
             sessionId = result.session.sessionId;
             response = result.response ?? result.decision.privateSummary;
         }
-        if (status === 'failed') {
-            status = 'succeeded';
-        }
+        status = 'succeeded';
     }
     catch (error) {
         errorText = errorMessage(error);
@@ -918,57 +1164,72 @@ 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,
+                }));
+            }
+            else if (input.job.source.kind === 'scheduledLog') {
+                await setScheduledLogStatus({
+                    vaultRoot: input.vault,
+                    scheduledLogId: input.job.source.scheduledLogId,
+                    status: 'archived',
+                });
+            }
+            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 +1324,93 @@ 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.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.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,
+        },
+    };
+}
 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 {
@@ -1087,7 +1427,7 @@ function assistantCronJobHasStableSessionLocator(job) {
     return Boolean(job.target.sessionId ||
         job.target.alias ||
         (job.target.channel &&
-            (job.target.participantId || job.target.sourceThreadId)));
+            (job.target.participantId || job.target.threadId)));
 }
 function buildAssistantCronTargetSnapshot(job) {
     return {
@@ -1097,7 +1437,7 @@ function buildAssistantCronTargetSnapshot(job) {
         bindingDelivery: resolveAssistantBindingDelivery({
             channel: job.target.channel,
             actorId: job.target.participantId,
-            threadId: job.target.sourceThreadId,
+            threadId: job.target.threadId,
             deliveryTarget: job.target.deliveryTarget,
         }),
     };
@@ -1106,7 +1446,7 @@ function assistantCronTargetAudienceEquals(left, right) {
     return (left.channel === right.channel &&
         left.identityId === right.identityId &&
         left.participantId === right.participantId &&
-        left.sourceThreadId === right.sourceThreadId &&
+        left.threadId === right.threadId &&
         left.deliveryTarget === right.deliveryTarget);
 }
 function truncateAssistantCronResponse(response) {
@@ -1115,43 +1455,4 @@ function truncateAssistantCronResponse(response) {
     }
     return response.slice(0, ASSISTANT_CRON_MAX_RESPONSE_LENGTH);
 }
-async function runFoodAutoLogCronJob(input) {
-    const [core, importers] = await Promise.all([
-        loadRuntimeModule('@murphai/core'),
-        loadImporterRuntime(),
-    ]);
-    const food = await core.readFood({
-        vaultRoot: input.vault,
-        foodId: input.foodId,
-    });
-    const note = renderAutoLoggedFoodMealNote(food);
-    const mealInput = {
-        vaultRoot: input.vault,
-        occurredAt: new Date().toISOString(),
-        note,
-        source: 'derived',
-    };
-    const inheritedNutrition = buildInheritedMealNutrition(food.nutrition, food.title);
-    if (inheritedNutrition != null) {
-        mealInput.nutrition = inheritedNutrition;
-    }
-    const result = await importers.addMeal(mealInput);
-    return `Auto-logged recurring food "${food.title}" as meal ${result.mealId}.`;
-}
-function buildInheritedMealNutrition(foodNutrition, title) {
-    const totals = foodNutrition?.perServing;
-    if (!totals) {
-        return undefined;
-    }
-    return {
-        totals,
-        provenance: {
-            source: 'inherited',
-            ...(foodNutrition.provenance?.confidence
-                ? { confidence: foodNutrition.provenance.confidence }
-                : {}),
-            sourceDetail: `Copied from saved food "${title}".`,
-        },
-    };
-}
 //# sourceMappingURL=cron.js.map