@murphai/murph 0.1.1

package/dist/commands/assistant.js

@@ -0,0 +1,1663 @@
+import { Cli, z } from 'incur';
+import { assistantApprovalPolicyValues, assistantAskResultSchema, assistantChatProviderValues, assistantChatResultSchema, assistantCronAddResultSchema, assistantCronListResultSchema, assistantCronPresetInstallResultSchema, assistantCronPresetListResultSchema, assistantCronPresetShowResultSchema, assistantCronRemoveResultSchema, assistantCronRunResultSchema, assistantCronRunsResultSchema, assistantCronShowResultSchema, assistantCronStatusResultSchema, assistantCronTargetSetResultSchema, assistantCronTargetShowResultSchema, assistantDeliverResultSchema, assistantDoctorResultSchema, assistantMemoryGetResultSchema, assistantMemoryQueryScopeValues, assistantMemorySearchResultSchema, assistantMemoryVisibleSectionValues, assistantRunResultSchema, assistantStateDeleteResultSchema, assistantStateListResultSchema, assistantStatePatchResultSchema, assistantStatePutResultSchema, assistantStateShowResultSchema, assistantSelfDeliveryTargetClearResultSchema, assistantSelfDeliveryTargetListResultSchema, assistantSelfDeliveryTargetSetResultSchema, assistantSelfDeliveryTargetShowResultSchema, assistantSandboxValues, assistantSessionListResultSchema, assistantSessionShowResultSchema, assistantStopResultSchema, assistantStatusResultSchema, } from '@murphai/assistant-core/assistant-cli-contracts';
+import { deliverAssistantMessage } from '@murphai/assistant-core/outbound-channel';
+import { addAssistantCronJob, buildAssistantCronSchedule, getAssistantCronPreset, getAssistantCronJob, getAssistantCronJobTarget, getAssistantCronStatus, getAssistantStateDocument, installAssistantCronPreset, listAssistantCronPresets, listAssistantCronJobs, listAssistantCronRuns, listAssistantStateDocuments, deleteAssistantStateDocument, patchAssistantStateDocument, putAssistantStateDocument, removeAssistantCronJob, runAssistantAutomation, runAssistantChat, runAssistantCronJobNow, sendAssistantMessage, setAssistantCronJobTarget, setAssistantCronJobEnabled, stopAssistantAutomation, } from '../assistant-runtime.js';
+import { runAssistantDoctor } from '../assistant/doctor.js';
+import { getAssistantStatus } from '../assistant/status.js';
+import { redactAssistantSessionForDisplay, redactAssistantSessionsForDisplay, } from '@murphai/assistant-core/assistant-runtime';
+import { assertAssistantMemoryTurnContextVault, getAssistantMemory, redactAssistantMemoryRecord, redactAssistantMemorySearchHit, resolveAssistantMemoryStoragePaths, resolveAssistantMemoryTurnContext, searchAssistantMemory, } from '@murphai/assistant-core/assistant-runtime';
+import { redactAssistantDisplayPath, getAssistantSession, listAssistantSessions, redactAssistantStateDocumentListEntry, redactAssistantStateDocumentSnapshot, resolveAssistantStatePaths, } from '@murphai/assistant-core/assistant-state';
+import { emptyArgsSchema, parseHeadersJsonOption, requestIdFromOptions, withBaseOptions, } from '@murphai/assistant-core/command-helpers';
+import { inputFileOptionSchema, loadJsonInputObject, } from '@murphai/assistant-core/json-input';
+import { normalizeRepeatableFlagOption } from '@murphai/assistant-core/option-utils';
+import { applyAssistantSelfDeliveryTargetDefaults, clearAssistantSelfDeliveryTargets, listAssistantSelfDeliveryTargets, resolveAssistantSelfDeliveryTarget, resolveOperatorConfigPath, saveAssistantSelfDeliveryTarget, } from '@murphai/assistant-core/operator-config';
+import { formatAssistantRunEventForTerminal, formatForegroundLogLine, formatInboxRunEventForTerminal, resolveForegroundTerminalLogOptions, } from '../run-terminal-logging.js';
+import { VaultCliError } from '@murphai/assistant-core/vault-cli-errors';
+import { requestIdSchema } from '@murphai/assistant-core/vault-cli-contracts';
+const assistantSessionOptionFields = {
+    session: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Existing Murph assistant session id to resume.'),
+    alias: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional stable alias used to map an external conversation onto one assistant session.'),
+    channel: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional channel label such as imessage, telegram, linq, or email.'),
+    identity: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional local assistant identity id for multi-user routing.'),
+    participant: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional remote actor id for multi-user routing and direct-conversation binding.'),
+    sourceThread: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional upstream thread id from the source channel. Thread ids anchor stored conversation bindings when present.'),
+};
+const assistantProviderOptionFields = {
+    provider: z
+        .enum(assistantChatProviderValues)
+        .optional()
+        .describe('Chat provider adapter for the local assistant surface. The runtime is provider-backed even when only one adapter is installed.'),
+    codexCommand: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional Codex CLI executable path. Defaults to `codex`.'),
+    model: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional provider model override for local chat turns.'),
+    baseUrl: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional OpenAI-compatible base URL for local assistant chat, such as http://127.0.0.1:11434/v1 for Ollama.'),
+    apiKeyEnv: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional environment variable name that stores the OpenAI-compatible API key for local assistant chat.'),
+    providerName: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional stable provider label for OpenAI-compatible local assistant chat sessions.'),
+    headersJson: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional JSON object of extra HTTP headers for OpenAI-compatible local assistant chat sessions.'),
+    sandbox: z
+        .enum(assistantSandboxValues)
+        .optional()
+        .describe('Codex sandbox mode for local assistant chat. Codex runs as a privileged local adapter by default, so leaving this unset keeps its normal unsandboxed behavior.'),
+    approvalPolicy: z
+        .enum(assistantApprovalPolicyValues)
+        .optional()
+        .describe('Codex approval policy for local assistant chat. Defaults to never for the privileged local Codex adapter.'),
+    profile: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional Codex config profile name.'),
+    oss: z
+        .boolean()
+        .optional()
+        .describe('Use Codex OSS mode, which expects a local Ollama-backed open-source provider.'),
+};
+const assistantDeliveryOptionFields = {
+    deliverResponse: z
+        .boolean()
+        .optional()
+        .describe('After generating a response, deliver it over the mapped outbound channel session when available.'),
+    deliveryTarget: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional one-send outbound target override. For iMessage this can be a phone number, email handle, or chat id; for Telegram it can be a chat id or <chatId>:topic:<messageThreadId>; for Linq it can be a chat id; for email it can be a recipient address while thread-bound sessions reply in place.'),
+};
+const assistantCronDeliveryOptionFields = {
+    deliveryTarget: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional explicit outbound destination for each cron run. For iMessage this can be a phone number, email handle, or chat id; for Telegram it can be a chat id or <chatId>:topic:<messageThreadId>; for Linq it can be a chat id; for email it can be a recipient address while thread-bound cron jobs reply in place.'),
+};
+const assistantCronTargetSourceOptionFields = {
+    copyFrom: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Copy the current delivery target from another assistant cron job instead of providing route flags directly.'),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe('Validate and preview the target change without writing scheduler state.'),
+    resetContinuity: z
+        .boolean()
+        .optional()
+        .describe('Clear the saved sessionId and alias while retargeting so the next run starts fresh instead of rebinding the existing assistant session.'),
+    toSelf: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Use the saved self-delivery target for one channel, such as email or telegram.'),
+};
+const assistantCronStateOptionFields = {
+    state: z
+        .boolean()
+        .optional()
+        .describe('Bind this cron job to a default assistant state document under assistant-state/state/cron/<jobId>.json. Use this only when the cron needs run-to-run scratch state such as cooldowns, dedupe, unresolved follow-ups, or delivery policy.'),
+    stateDoc: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional explicit assistant state document id to bind to this cron job, such as cron/weekly-health-snapshot. Prefer this only when the cron needs stable cross-run scratch state or must share one state doc across related jobs.'),
+};
+const assistantSelfDeliveryTargetOptionFields = {
+    identity: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional local assistant identity id to reuse for this saved channel target.'),
+    participant: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional remote actor id to reuse for this saved channel target.'),
+    sourceThread: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional upstream thread id to reuse for this saved channel target.'),
+    deliveryTarget: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional explicit outbound destination to save for this channel target, such as a phone number, Telegram chat id, or email address.'),
+};
+function parseAssistantCronPresetVariables(value) {
+    const entries = normalizeRepeatableFlagOption(value, 'var') ?? [];
+    const variables = {};
+    for (const entry of entries) {
+        const separatorIndex = entry.indexOf('=');
+        if (separatorIndex <= 0 || separatorIndex === entry.length - 1) {
+            throw new VaultCliError('invalid_option', 'Preset variables must use key=value form. Repeat --var for multiple values.');
+        }
+        const key = entry.slice(0, separatorIndex).trim();
+        const variableValue = entry.slice(separatorIndex + 1).trim();
+        if (key.length === 0 || variableValue.length === 0) {
+            throw new VaultCliError('invalid_option', 'Preset variables must use key=value form with non-empty keys and values.');
+        }
+        if (Object.hasOwn(variables, key)) {
+            throw new VaultCliError('invalid_option', `Preset variable "${key}" was provided more than once. Repeat --var only for different keys.`);
+        }
+        variables[key] = variableValue;
+    }
+    return variables;
+}
+function assertAssistantSelfDeliveryTargetInput(input) {
+    if (!input.deliveryTarget && !input.participant && !input.sourceThread) {
+        throw new VaultCliError('invalid_option', 'Saved self delivery targets require at least --participant, --sourceThread, or --deliveryTarget.');
+    }
+    if (input.channel === 'email' && !input.identity) {
+        throw new VaultCliError('invalid_option', 'Saved email self delivery targets require --identity with the configured AgentMail inbox id.');
+    }
+}
+const assistantChatArgsSchema = z.object({
+    prompt: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional first prompt to send before the chat loop starts.'),
+});
+const assistantChatOptionsSchema = withBaseOptions({
+    ...assistantSessionOptionFields,
+    ...assistantProviderOptionFields,
+});
+function createAssistantStatusCommandDefinition(input) {
+    return {
+        args: emptyArgsSchema,
+        description: input?.description ??
+            'Show a compact assistant-state snapshot including recent turn receipts and the outbound outbox backlog.',
+        hint: input?.hint ??
+            'Use this when the assistant feels stuck, duplicated a send, or you want the latest receipt timeline without opening files under assistant-state/.',
+        options: withBaseOptions({
+            session: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('Optional assistant session id to scope the recent turn receipts.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(50)
+                .default(5)
+                .describe('Maximum number of recent sessions, turns, and pending outbox intents to return.'),
+        }),
+        output: assistantStatusResultSchema,
+        async run(context) {
+            return getAssistantStatus({
+                vault: context.options.vault,
+                sessionId: context.options.session,
+                limit: context.options.limit,
+            });
+        },
+    };
+}
+function createAssistantDoctorCommandDefinition(input) {
+    return {
+        args: emptyArgsSchema,
+        description: input?.description ??
+            'Run lightweight assistant-state diagnostics for session files, receipts, transcripts, automation state, and the outbound outbox.',
+        hint: input?.hint ??
+            'Use --repair to migrate legacy inline secret headers into private sidecars and to tighten assistant-state permissions in place.',
+        options: withBaseOptions({
+            repair: z
+                .boolean()
+                .default(false)
+                .describe('Repair assistant-state secrecy issues in place by moving legacy inline secret headers into private sidecars and fixing private file permissions.'),
+        }),
+        output: assistantDoctorResultSchema,
+        async run(context) {
+            return runAssistantDoctor(context.options.vault, {
+                repair: context.options.repair,
+            });
+        },
+    };
+}
+function createAssistantStopCommandDefinition(input) {
+    return {
+        args: emptyArgsSchema,
+        description: input?.description ??
+            'Stop the assistant automation loop for this vault and clear stale run-lock state when the recorded process is already gone.',
+        hint: input?.hint ??
+            'Use this to recover from a stuck `assistant run` / `murph run`. Murph sends SIGTERM first, waits briefly, and only force-kills the recorded PID if it refuses to exit.',
+        options: withBaseOptions(),
+        output: assistantStopResultSchema,
+        async run(context) {
+            return stopAssistantAutomation({
+                vault: context.options.vault,
+            });
+        },
+    };
+}
+function buildAssistantVaultResultPath(vault) {
+    return {
+        vault: redactAssistantDisplayPath(vault),
+    };
+}
+function buildAssistantStateRootResultPaths(vault, stateRoot) {
+    return {
+        ...buildAssistantVaultResultPath(vault),
+        stateRoot: redactAssistantDisplayPath(stateRoot),
+    };
+}
+function buildAssistantStateResultPaths(vault) {
+    const statePaths = resolveAssistantStatePaths(vault);
+    return buildAssistantStateRootResultPaths(vault, statePaths.assistantStateRoot);
+}
+function buildAssistantStateDocumentResultPaths(vault) {
+    const statePaths = resolveAssistantStatePaths(vault);
+    return {
+        ...buildAssistantStateRootResultPaths(vault, statePaths.assistantStateRoot),
+        documentsRoot: redactAssistantDisplayPath(statePaths.stateDirectory),
+    };
+}
+function buildAssistantMemoryResultPaths(vault) {
+    const statePaths = resolveAssistantMemoryStoragePaths(vault);
+    return buildAssistantStateRootResultPaths(vault, statePaths.assistantStateRoot);
+}
+function buildAssistantCronResultPaths(vault) {
+    const statePaths = resolveAssistantStatePaths(vault);
+    return {
+        ...buildAssistantStateRootResultPaths(vault, statePaths.assistantStateRoot),
+        jobsPath: redactAssistantDisplayPath(statePaths.cronJobsPath),
+        runsRoot: redactAssistantDisplayPath(statePaths.cronRunsDirectory),
+    };
+}
+function buildAssistantOperatorConfigResult() {
+    return {
+        configPath: redactAssistantDisplayPath(resolveOperatorConfigPath()),
+    };
+}
+function assistantConversationOptionsFromCli(options) {
+    return {
+        sessionId: options.session,
+        alias: options.alias,
+        channel: options.channel,
+        identityId: options.identity,
+        participantId: options.participant,
+        sourceThreadId: options.sourceThread,
+    };
+}
+function assistantProviderOverridesFromCli(options) {
+    const headers = parseHeadersJsonOption(options.headersJson);
+    return {
+        provider: options.provider,
+        codexCommand: options.codexCommand,
+        model: options.model,
+        baseUrl: options.baseUrl,
+        apiKeyEnv: options.apiKeyEnv,
+        providerName: options.providerName,
+        sandbox: options.sandbox,
+        approvalPolicy: options.approvalPolicy,
+        profile: options.profile,
+        oss: options.oss,
+        ...(headers ? { headers } : {}),
+    };
+}
+function assistantDeliveryOverridesFromCli(options) {
+    return {
+        deliverResponse: options.deliverResponse,
+        deliveryTarget: options.deliveryTarget,
+    };
+}
+async function resolveAssistantDeliveryRouteFromCli(input) {
+    return applyAssistantSelfDeliveryTargetDefaults({
+        channel: input.channel,
+        identityId: input.identity,
+        participantId: input.participant,
+        sourceThreadId: input.sourceThread,
+        deliveryTarget: input.deliveryTarget,
+    }, {
+        allowSingleSavedTargetFallback: input.allowSingleSavedTargetFallback,
+    });
+}
+function assistantCronStateOptionsFromCli(options) {
+    return {
+        bindState: options.state,
+        stateDocId: options.stateDoc,
+    };
+}
+async function resolveAssistantCronTargetFromCli(input) {
+    const hasExplicitRoute = Boolean(input.channel) ||
+        Boolean(input.identity) ||
+        Boolean(input.participant) ||
+        Boolean(input.sourceThread) ||
+        Boolean(input.deliveryTarget);
+    const selectedSources = [
+        input.toSelf ? 'to-self' : null,
+        input.copyFrom ? 'copy-from' : null,
+        hasExplicitRoute ? 'explicit-route' : null,
+    ].filter((value) => value !== null);
+    if (selectedSources.length !== 1) {
+        throw new VaultCliError('invalid_option', 'Provide exactly one cron target source: --toSelf <channel>, --copyFrom <job>, or an explicit route via --channel/--identity/--participant/--sourceThread/--deliveryTarget.');
+    }
+    if (input.toSelf) {
+        const savedTarget = await resolveAssistantSelfDeliveryTarget(input.toSelf);
+        if (!savedTarget) {
+            throw new VaultCliError('ASSISTANT_SELF_TARGET_NOT_FOUND', `No saved self-delivery target exists for channel "${input.toSelf}". Save one first with \`assistant self-target set ${input.toSelf} ...\`.`);
+        }
+        return {
+            channel: savedTarget.channel,
+            identityId: savedTarget.identityId ?? undefined,
+            participantId: savedTarget.participantId ?? undefined,
+            sourceThreadId: savedTarget.sourceThreadId ?? undefined,
+            deliveryTarget: savedTarget.deliveryTarget ?? undefined,
+        };
+    }
+    if (input.copyFrom) {
+        const sourceJobTarget = await getAssistantCronJobTarget(input.vault, input.copyFrom);
+        return {
+            channel: sourceJobTarget.target.channel ?? undefined,
+            identityId: sourceJobTarget.target.identityId ?? undefined,
+            participantId: sourceJobTarget.target.participantId ?? undefined,
+            sourceThreadId: sourceJobTarget.target.sourceThreadId ?? undefined,
+            deliveryTarget: sourceJobTarget.target.deliveryTarget ?? undefined,
+        };
+    }
+    const resolvedRoute = await resolveAssistantDeliveryRouteFromCli({
+        allowSingleSavedTargetFallback: false,
+        channel: input.channel,
+        identity: input.identity,
+        participant: input.participant,
+        sourceThread: input.sourceThread,
+        deliveryTarget: input.deliveryTarget,
+    });
+    return {
+        channel: resolvedRoute.channel ?? undefined,
+        identityId: resolvedRoute.identityId ?? undefined,
+        participantId: resolvedRoute.participantId ?? undefined,
+        sourceThreadId: resolvedRoute.sourceThreadId ?? undefined,
+        deliveryTarget: resolvedRoute.deliveryTarget ?? undefined,
+    };
+}
+async function runAssistantChatCommand(context) {
+    const result = await runAssistantChat({
+        vault: context.options.vault,
+        includeFirstTurnCheckIn: true,
+        initialPrompt: context.args.prompt,
+        ...assistantConversationOptionsFromCli(context.options),
+        ...assistantProviderOverridesFromCli(context.options),
+    });
+    if (!context.agent && !context.formatExplicit) {
+        process.stderr.write(`Resume chat by typing: ${formatAssistantChatResumeCommand(result.session.sessionId)}\n`);
+    }
+    return result;
+}
+function formatAssistantChatResumeCommand(sessionId) {
+    return `murph chat --session "${sessionId}"`;
+}
+function createAssistantChatCommandDefinition(input) {
+    return {
+        args: assistantChatArgsSchema,
+        description: input?.description ??
+            'Open an Ink terminal chat UI backed by the chosen provider while Murph stores session metadata plus a local transcript outside the canonical vault.',
+        hint: input?.hint ??
+            'Type /exit to close the chat loop or /session to print the current Murph session id.',
+        options: assistantChatOptionsSchema,
+        output: assistantChatResultSchema,
+        outputPolicy: 'agent-only',
+        run: runAssistantChatCommand,
+    };
+}
+const assistantRunOptionsSchema = withBaseOptions({
+    model: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional model id for canonical inbox triage routing, such as gpt-oss:20b or an AI Gateway model string. Omit it when you only want channel auto-reply.'),
+    baseUrl: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional OpenAI-compatible base URL for the inbox routing model.'),
+    apiKey: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional explicit API key for the OpenAI-compatible routing endpoint.'),
+    apiKeyEnv: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional environment variable name that stores the routing API key.'),
+    providerName: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional stable provider label for the routing endpoint.'),
+    headersJson: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional JSON object of extra HTTP headers for the routing endpoint.'),
+    scanIntervalMs: z
+        .number()
+        .int()
+        .positive()
+        .max(60000)
+        .default(5000)
+        .describe('Polling interval between inbox scans when running continuously.'),
+    maxPerScan: z
+        .number()
+        .int()
+        .positive()
+        .max(200)
+        .default(50)
+        .describe('Maximum inbox captures to inspect during each assistant scan.'),
+    allowSelfAuthored: z
+        .boolean()
+        .optional()
+        .describe('Allow self-authored captures to trigger channel auto-reply. Useful for texting your own Mac, but only safe when you dedicate a self-chat thread to Murph.'),
+    sessionRolloverHours: z
+        .number()
+        .int()
+        .positive()
+        .max(24 * 30)
+        .optional()
+        .describe('Optional maximum age for a reused assistant session in hours before Murph starts a new one for the same channel thread.'),
+    once: z
+        .boolean()
+        .optional()
+        .describe('Run one assistant scan and then exit.'),
+    skipDaemon: z
+        .boolean()
+        .optional()
+        .describe('Do not start the inbox foreground daemon; only run the assistant scan loop.'),
+});
+function createAssistantRunCommandDefinition(inboxServices, vaultServices, input) {
+    return {
+        args: emptyArgsSchema,
+        description: input?.description ??
+            'Start the local assistant automation loop that watches the inbox runtime, runs due assistant cron jobs, auto-replies over configured channels such as iMessage or Telegram, and optionally applies model-routed canonical promotions.',
+        hint: input?.hint ??
+            'Use --baseUrl with a local OpenAI-compatible model endpoint such as Ollama when you also want canonical inbox triage. Channel auto-reply can run without a routing model, and assistant cron schedules fire while this loop is active.',
+        examples: [
+            {
+                options: {
+                    vault: './vault',
+                    model: 'gpt-oss:20b',
+                    baseUrl: 'http://127.0.0.1:11434/v1',
+                },
+                description: 'Run the always-on inbox assistant against a local Ollama model.',
+            },
+            {
+                options: {
+                    vault: './vault',
+                    model: 'gpt-oss:20b',
+                    baseUrl: 'http://127.0.0.1:11434/v1',
+                    once: true,
+                    skipDaemon: true,
+                },
+                description: 'Run a single inbox scan without starting the foreground daemon.',
+            },
+            {
+                options: {
+                    vault: './vault',
+                    allowSelfAuthored: true,
+                    sessionRolloverHours: 48,
+                },
+                description: 'Run dedicated iMessage self-chat mode with two-day session rollover.',
+            },
+        ],
+        options: assistantRunOptionsSchema,
+        output: assistantRunResultSchema,
+        async run(context) {
+            const terminalLogOptions = resolveForegroundTerminalLogOptions(process.env);
+            return runAssistantAutomation({
+                inboxServices,
+                vaultServices,
+                vault: context.options.vault,
+                requestId: requestIdFromOptions(context.options),
+                modelSpec: context.options.model
+                    ? {
+                        model: context.options.model,
+                        baseUrl: context.options.baseUrl,
+                        apiKey: context.options.apiKey,
+                        apiKeyEnv: context.options.apiKeyEnv,
+                        providerName: context.options.providerName,
+                        headers: parseHeadersJsonOption(context.options.headersJson),
+                    }
+                    : undefined,
+                scanIntervalMs: context.options.scanIntervalMs,
+                maxPerScan: context.options.maxPerScan,
+                allowSelfAuthored: context.options.allowSelfAuthored,
+                sessionMaxAgeMs: typeof context.options.sessionRolloverHours === 'number'
+                    ? context.options.sessionRolloverHours * 60 * 60 * 1000
+                    : null,
+                once: context.options.once,
+                startDaemon: context.options.skipDaemon ? false : true,
+                onEvent(event) {
+                    const message = formatAssistantRunEventForTerminal(event, terminalLogOptions);
+                    if (message) {
+                        console.error(formatForegroundLogLine('assistant', message));
+                    }
+                },
+                onInboxEvent(event) {
+                    const message = formatInboxRunEventForTerminal(event, terminalLogOptions);
+                    if (message) {
+                        console.error(formatForegroundLogLine('assistant', message));
+                    }
+                },
+            });
+        },
+    };
+}
+export function registerAssistantCommands(cli, inboxServices, vaultServices) {
+    const assistant = Cli.create('assistant', {
+        description: 'Murph-native assistant runtime with provider-backed local chat sessions, Ink terminal chat, outbound delivery, and auto-routing inbox automation.',
+    });
+    const registerConversationCommands = () => {
+        assistant.command('ask', {
+            args: z.object({
+                prompt: z.string().min(1).describe('Prompt to send to the local assistant session.'),
+            }),
+            description: 'Send one message through the local provider-backed assistant and persist session metadata plus a local transcript outside the canonical vault.',
+            hint: 'Murph persists a local transcript plus per-session metadata under assistant-state/, and still reuses provider-side history when available. Use --deliverResponse to send the assistant reply back out over a mapped channel such as iMessage, Telegram, or email.',
+            examples: [
+                {
+                    args: {
+                        prompt: 'Summarize the latest documents in this vault.',
+                    },
+                    options: {
+                        vault: './vault',
+                    },
+                    description: 'Start a new local assistant session rooted at the vault directory.',
+                },
+                {
+                    args: {
+                        prompt: 'Send a quick check-in about lunch.',
+                    },
+                    options: {
+                        vault: './vault',
+                        channel: 'imessage',
+                        participant: '+15551234567',
+                        deliverResponse: true,
+                    },
+                    description: 'Generate a reply locally and deliver it over iMessage.',
+                },
+                {
+                    args: {
+                        prompt: 'Reply that I can review the latest labs tonight.',
+                    },
+                    options: {
+                        vault: './vault',
+                        channel: 'telegram',
+                        participant: '123456789',
+                        sourceThread: '123456789',
+                        deliverResponse: true,
+                    },
+                    description: 'Generate a reply locally and deliver it back into a Telegram bot chat.',
+                },
+                {
+                    args: {
+                        prompt: "Send today's summary by email.",
+                    },
+                    options: {
+                        vault: './vault',
+                        channel: 'email',
+                        identity: 'inbox_123',
+                        participant: 'you@example.com',
+                        deliverResponse: true,
+                    },
+                    description: 'Generate a reply locally and deliver it over AgentMail email.',
+                },
+            ],
+            options: withBaseOptions({
+                ...assistantSessionOptionFields,
+                ...assistantProviderOptionFields,
+                ...assistantDeliveryOptionFields,
+            }),
+            output: assistantAskResultSchema,
+            async run(context) {
+                const deliveryOverrides = assistantDeliveryOverridesFromCli(context.options);
+                const savedRoute = deliveryOverrides.deliverResponse && !context.options.session
+                    ? await resolveAssistantDeliveryRouteFromCli({
+                        allowSingleSavedTargetFallback: true,
+                        channel: context.options.channel,
+                        identity: context.options.identity,
+                        participant: context.options.participant,
+                        sourceThread: context.options.sourceThread,
+                        deliveryTarget: deliveryOverrides.deliveryTarget,
+                    })
+                    : null;
+                return sendAssistantMessage({
+                    vault: context.options.vault,
+                    prompt: context.args.prompt,
+                    ...assistantConversationOptionsFromCli({
+                        ...context.options,
+                        channel: savedRoute?.channel ?? context.options.channel,
+                        identity: savedRoute?.identityId ?? context.options.identity,
+                        participant: savedRoute?.participantId ?? context.options.participant,
+                        sourceThread: savedRoute?.sourceThreadId ?? context.options.sourceThread,
+                    }),
+                    ...assistantProviderOverridesFromCli(context.options),
+                    ...deliveryOverrides,
+                    deliveryTarget: savedRoute?.deliveryTarget ?? deliveryOverrides.deliveryTarget,
+                });
+            },
+        });
+        assistant.command('chat', createAssistantChatCommandDefinition());
+        assistant.command('deliver', {
+            args: z.object({
+                message: z
+                    .string()
+                    .min(1)
+                    .describe('Outbound message body to deliver over the mapped assistant channel.'),
+            }),
+            description: 'Deliver one outbound assistant message without invoking the chat provider. iMessage, Telegram, Linq, and email all use the same stored assistant channel binding surface.',
+            hint: 'Use --deliveryTarget to override the stored delivery target for one send only. For iMessage that target can be a phone number, email handle, or chat id; for Telegram it can be a chat id or <chatId>:topic:<messageThreadId>; for Linq it can be a chat id; for email it can be a recipient address while thread-bound sessions reply in place.',
+            examples: [
+                {
+                    args: {
+                        message: 'Here is your nutrition recap for lunch.',
+                    },
+                    options: {
+                        vault: './vault',
+                        channel: 'imessage',
+                        participant: '+15551234567',
+                    },
+                    description: 'Send a direct iMessage to one participant.',
+                },
+                {
+                    args: {
+                        message: 'I saw the message and queued your follow-up.',
+                    },
+                    options: {
+                        vault: './vault',
+                        channel: 'linq',
+                        sourceThread: 'chat_123',
+                        deliveryTarget: 'chat_123',
+                    },
+                    description: 'Send a Linq reply back into the same direct chat.',
+                },
+                {
+                    args: {
+                        message: 'I imported that lab report and queued the parser.',
+                    },
+                    options: {
+                        vault: './vault',
+                        channel: 'telegram',
+                        sourceThread: '-1001234567890:topic:42',
+                        deliveryTarget: '-1001234567890:topic:42',
+                    },
+                    description: 'Send a Telegram reply into a specific chat topic.',
+                },
+                {
+                    args: {
+                        message: 'Your weekly summary is ready.',
+                    },
+                    options: {
+                        vault: './vault',
+                        channel: 'email',
+                        identity: 'inbox_123',
+                        deliveryTarget: 'you@example.com',
+                    },
+                    description: 'Send a one-off outbound summary email through an AgentMail inbox.',
+                },
+                {
+                    args: {
+                        message: 'I imported that lab report and queued the parser.',
+                    },
+                    options: {
+                        vault: './vault',
+                        session: 'asst_123',
+                        deliveryTarget: 'chat45e2b868',
+                    },
+                    description: 'Reuse an existing session and override the outbound target for one message.',
+                },
+            ],
+            options: withBaseOptions({
+                ...assistantSessionOptionFields,
+                deliveryTarget: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional one-send outbound target override. For iMessage this can be a phone number, email handle, or chat id; for Telegram it can be a chat id or <chatId>:topic:<messageThreadId>; for Linq it can be a chat id; for email it can be a recipient address while thread-bound sessions reply in place.'),
+            }),
+            output: assistantDeliverResultSchema,
+            async run(context) {
+                const deliveryOverrides = assistantDeliveryOverridesFromCli(context.options);
+                const savedRoute = context.options.session
+                    ? null
+                    : await resolveAssistantDeliveryRouteFromCli({
+                        allowSingleSavedTargetFallback: true,
+                        channel: context.options.channel,
+                        identity: context.options.identity,
+                        participant: context.options.participant,
+                        sourceThread: context.options.sourceThread,
+                        deliveryTarget: deliveryOverrides.deliveryTarget,
+                    });
+                return deliverAssistantMessage({
+                    vault: context.options.vault,
+                    message: context.args.message,
+                    ...assistantConversationOptionsFromCli({
+                        ...context.options,
+                        channel: savedRoute?.channel ?? context.options.channel,
+                        identity: savedRoute?.identityId ?? context.options.identity,
+                        participant: savedRoute?.participantId ?? context.options.participant,
+                        sourceThread: savedRoute?.sourceThreadId ?? context.options.sourceThread,
+                    }),
+                    target: savedRoute?.deliveryTarget ?? deliveryOverrides.deliveryTarget,
+                });
+            },
+        });
+        assistant.command('run', createAssistantRunCommandDefinition(inboxServices, vaultServices));
+    };
+    const registerStateCommands = () => {
+        const state = Cli.create('state', {
+            description: 'Inspect and update small non-canonical assistant state documents stored outside the vault under assistant-state/state.',
+        });
+        state.command('list', {
+            args: emptyArgsSchema,
+            description: 'List assistant state documents, optionally filtered by a prefix namespace.',
+            hint: 'Use prefixes such as `cron` or `cron/<jobId>` to narrow the scratchpad documents that belong to one workflow.',
+            options: withBaseOptions({
+                prefix: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional slash-delimited document prefix such as cron or cron/job_123.'),
+            }),
+            output: assistantStateListResultSchema,
+            async run(context) {
+                const documents = await listAssistantStateDocuments({
+                    vault: context.options.vault,
+                    prefix: context.options.prefix,
+                });
+                return {
+                    ...buildAssistantStateDocumentResultPaths(context.options.vault),
+                    prefix: context.options.prefix ?? null,
+                    documents: documents.map(redactAssistantStateDocumentListEntry),
+                };
+            },
+        });
+        state.command('show', {
+            args: z.object({
+                doc: z.string().min(1).describe('Assistant state document id such as cron/job_123.'),
+            }),
+            description: 'Show one assistant state document by id.',
+            options: withBaseOptions(),
+            output: assistantStateShowResultSchema,
+            async run(context) {
+                const document = await getAssistantStateDocument({
+                    vault: context.options.vault,
+                    docId: context.args.doc,
+                });
+                return {
+                    ...buildAssistantStateDocumentResultPaths(context.options.vault),
+                    document: redactAssistantStateDocumentSnapshot(document),
+                };
+            },
+        });
+        state.command('put', {
+            args: z.object({
+                doc: z.string().min(1).describe('Assistant state document id such as cron/job_123.'),
+            }),
+            description: 'Replace one assistant state document with a JSON object payload.',
+            hint: 'Use this for full replacement. For incremental updates that preserve existing keys, use `assistant state patch`.',
+            options: withBaseOptions({
+                input: inputFileOptionSchema.describe('JSON object payload in @file.json form or - for stdin.'),
+            }),
+            output: assistantStatePutResultSchema,
+            async run(context) {
+                const value = await loadJsonInputObject(context.options.input, 'assistant state document');
+                const document = await putAssistantStateDocument({
+                    vault: context.options.vault,
+                    docId: context.args.doc,
+                    value,
+                });
+                return {
+                    ...buildAssistantStateDocumentResultPaths(context.options.vault),
+                    document: redactAssistantStateDocumentSnapshot(document),
+                };
+            },
+        });
+        state.command('patch', {
+            args: z.object({
+                doc: z.string().min(1).describe('Assistant state document id such as cron/job_123.'),
+            }),
+            description: 'Merge-patch one assistant state document with a JSON object payload.',
+            hint: 'This uses JSON Merge Patch semantics: object keys merge recursively, `null` deletes a key, and arrays replace the previous value.',
+            options: withBaseOptions({
+                input: inputFileOptionSchema.describe('JSON object merge-patch payload in @file.json form or - for stdin.'),
+            }),
+            output: assistantStatePatchResultSchema,
+            async run(context) {
+                const patch = await loadJsonInputObject(context.options.input, 'assistant state patch');
+                const document = await patchAssistantStateDocument({
+                    vault: context.options.vault,
+                    docId: context.args.doc,
+                    patch,
+                });
+                return {
+                    ...buildAssistantStateDocumentResultPaths(context.options.vault),
+                    document: redactAssistantStateDocumentSnapshot(document),
+                };
+            },
+        });
+        state.command('delete', {
+            args: z.object({
+                doc: z.string().min(1).describe('Assistant state document id such as cron/job_123.'),
+            }),
+            description: 'Delete one assistant state document by id.',
+            options: withBaseOptions(),
+            output: assistantStateDeleteResultSchema,
+            async run(context) {
+                const result = await deleteAssistantStateDocument({
+                    vault: context.options.vault,
+                    docId: context.args.doc,
+                });
+                return {
+                    ...buildAssistantStateDocumentResultPaths(context.options.vault),
+                    docId: result.docId,
+                    documentPath: redactAssistantDisplayPath(result.documentPath),
+                    existed: result.existed,
+                };
+            },
+        });
+        assistant.command(state);
+    };
+    const registerMemoryCommands = () => {
+        const memory = Cli.create('memory', {
+            description: 'Inspect non-canonical assistant memory stored as Markdown outside the vault under assistant-state/.',
+        });
+        memory.command('search', {
+            args: emptyArgsSchema,
+            description: 'Search assistant memory across durable long-term notes and short-lived daily notes.',
+            hint: 'Use --scope long-term for durable identity/preferences/instructions and --scope daily for recent project context.',
+            examples: [
+                {
+                    options: {
+                        vault: './vault',
+                        scope: 'long-term',
+                        text: 'concise answers',
+                    },
+                    description: 'Search durable assistant response preferences.',
+                },
+                {
+                    options: {
+                        vault: './vault',
+                        scope: 'daily',
+                        limit: 5,
+                    },
+                    description: 'List the latest recent-context notes.',
+                },
+            ],
+            options: withBaseOptions({
+                text: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional lexical query for assistant memory search.'),
+                scope: z
+                    .enum(assistantMemoryQueryScopeValues)
+                    .default('all')
+                    .describe('Choose long-term memory, daily notes, or both.'),
+                section: z
+                    .enum(assistantMemoryVisibleSectionValues)
+                    .optional()
+                    .describe('Optional section filter such as Identity or Notes.'),
+                limit: z
+                    .number()
+                    .int()
+                    .positive()
+                    .max(25)
+                    .default(8)
+                    .describe('Maximum number of assistant memory hits to return.'),
+            }),
+            output: assistantMemorySearchResultSchema,
+            async run(context) {
+                const turnContext = resolveAssistantMemoryTurnContext();
+                if (turnContext) {
+                    assertAssistantMemoryTurnContextVault(turnContext, context.options.vault);
+                }
+                const result = await searchAssistantMemory({
+                    vault: context.options.vault,
+                    text: context.options.text,
+                    scope: context.options.scope,
+                    section: context.options.section,
+                    limit: context.options.limit,
+                    includeSensitiveHealthContext: turnContext?.allowSensitiveHealthContext ?? true,
+                });
+                return {
+                    ...buildAssistantMemoryResultPaths(context.options.vault),
+                    query: result.query,
+                    scope: result.scope,
+                    section: result.section,
+                    results: result.results.map(redactAssistantMemorySearchHit),
+                };
+            },
+        });
+        memory.command('get', {
+            args: z.object({
+                memoryId: z.string().min(1).describe('Assistant memory id returned by search.'),
+            }),
+            description: 'Fetch one assistant memory record by id.',
+            options: withBaseOptions(),
+            output: assistantMemoryGetResultSchema,
+            async run(context) {
+                const turnContext = resolveAssistantMemoryTurnContext();
+                if (turnContext) {
+                    assertAssistantMemoryTurnContextVault(turnContext, context.options.vault);
+                }
+                const memoryRecord = await getAssistantMemory({
+                    vault: context.options.vault,
+                    id: context.args.memoryId,
+                    includeSensitiveHealthContext: turnContext?.allowSensitiveHealthContext ?? true,
+                });
+                return {
+                    ...buildAssistantMemoryResultPaths(context.options.vault),
+                    memory: redactAssistantMemoryRecord(memoryRecord),
+                };
+            },
+        });
+        assistant.command(memory);
+    };
+    const registerSelfTargetCommands = () => {
+        const selfTarget = Cli.create('self-target', {
+            description: 'Manage local saved self-delivery targets for outbound assistant actions without storing them in the canonical vault.',
+        });
+        selfTarget.command('list', {
+            args: emptyArgsSchema,
+            description: 'List saved self-delivery targets from local operator config.',
+            options: z.object({
+                requestId: requestIdSchema,
+            }),
+            output: assistantSelfDeliveryTargetListResultSchema,
+            async run() {
+                return {
+                    ...buildAssistantOperatorConfigResult(),
+                    targets: await listAssistantSelfDeliveryTargets(),
+                };
+            },
+        });
+        selfTarget.command('show', {
+            args: z.object({
+                channel: z.string().min(1).describe('Saved outbound channel to inspect.'),
+            }),
+            description: 'Show one saved self-delivery target for a specific outbound channel.',
+            options: z.object({
+                requestId: requestIdSchema,
+            }),
+            output: assistantSelfDeliveryTargetShowResultSchema,
+            async run(context) {
+                const targets = await listAssistantSelfDeliveryTargets();
+                return {
+                    ...buildAssistantOperatorConfigResult(),
+                    target: targets.find((target) => target.channel === context.args.channel.trim().toLowerCase()) ??
+                        null,
+                };
+            },
+        });
+        selfTarget.command('set', {
+            args: z.object({
+                channel: z
+                    .string()
+                    .min(1)
+                    .describe('Outbound channel to save, such as telegram, imessage, linq, or email.'),
+            }),
+            description: 'Save or replace the local default outbound target for one channel.',
+            hint: 'Use this after the user gives you a phone number, Telegram chat, or email target so later actions can reuse it without asking again.',
+            options: z.object({
+                requestId: requestIdSchema,
+                ...assistantSelfDeliveryTargetOptionFields,
+            }),
+            output: assistantSelfDeliveryTargetSetResultSchema,
+            async run(context) {
+                const channel = context.args.channel.trim().toLowerCase();
+                assertAssistantSelfDeliveryTargetInput({
+                    channel,
+                    identity: context.options.identity,
+                    participant: context.options.participant,
+                    sourceThread: context.options.sourceThread,
+                    deliveryTarget: context.options.deliveryTarget,
+                });
+                const target = await saveAssistantSelfDeliveryTarget({
+                    channel,
+                    identityId: context.options.identity ?? null,
+                    participantId: context.options.participant ?? null,
+                    sourceThreadId: context.options.sourceThread ?? null,
+                    deliveryTarget: context.options.deliveryTarget ?? null,
+                });
+                return {
+                    ...buildAssistantOperatorConfigResult(),
+                    target,
+                };
+            },
+        });
+        selfTarget.command('clear', {
+            args: z.object({
+                channel: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional saved outbound channel to clear. Omit to clear all saved self-targets.'),
+            }),
+            description: 'Clear one saved self-delivery target or remove all of them.',
+            options: z.object({
+                requestId: requestIdSchema,
+            }),
+            output: assistantSelfDeliveryTargetClearResultSchema,
+            async run(context) {
+                return {
+                    ...buildAssistantOperatorConfigResult(),
+                    clearedChannels: await clearAssistantSelfDeliveryTargets(context.args.channel),
+                };
+            },
+        });
+        assistant.command(selfTarget);
+    };
+    const registerCronCommands = () => {
+        const cron = Cli.create('cron', {
+            description: 'Manage scheduled assistant prompts stored outside the canonical vault under assistant-state/cron.',
+        });
+        const preset = Cli.create('preset', {
+            description: 'Browse and materialize built-in assistant cron templates without editing scheduler state files directly.',
+        });
+        preset.command('list', {
+            args: emptyArgsSchema,
+            description: 'List the built-in assistant cron presets that can be installed later.',
+            hint: 'Presets are templates, not active jobs. Use `assistant cron preset install` to turn one into a real cron job.',
+            options: withBaseOptions(),
+            output: assistantCronPresetListResultSchema,
+            async run(context) {
+                return {
+                    ...buildAssistantVaultResultPath(context.options.vault),
+                    presets: listAssistantCronPresets(),
+                };
+            },
+        });
+        preset.command('show', {
+            args: z.object({
+                preset: z.string().min(1).describe('Assistant cron preset id to inspect.'),
+            }),
+            description: 'Show one built-in assistant cron preset, including its prompt template.',
+            options: withBaseOptions(),
+            output: assistantCronPresetShowResultSchema,
+            async run(context) {
+                const presetDefinition = getAssistantCronPreset(context.args.preset);
+                return {
+                    ...buildAssistantVaultResultPath(context.options.vault),
+                    preset: {
+                        id: presetDefinition.id,
+                        category: presetDefinition.category,
+                        title: presetDefinition.title,
+                        description: presetDefinition.description,
+                        suggestedName: presetDefinition.suggestedName,
+                        suggestedSchedule: presetDefinition.suggestedSchedule,
+                        suggestedScheduleLabel: presetDefinition.suggestedScheduleLabel,
+                        variables: presetDefinition.variables,
+                    },
+                    promptTemplate: presetDefinition.promptTemplate,
+                };
+            },
+        });
+        preset.command('install', {
+            args: z.object({
+                preset: z.string().min(1).describe('Assistant cron preset id to install.'),
+            }),
+            description: 'Create one assistant cron job from a built-in preset template.',
+            hint: 'Repeat --var key=value to fill preset slots. If you omit --at, --every, and --cron, Murph uses the preset’s suggested schedule. Cron jobs require an explicit outbound channel route and always deliver their response. Add --state only when the job needs run-to-run scratch state such as cooldowns, dedupe, unresolved follow-ups, or delivery policy; leave it off for stateless digest/report jobs.',
+            examples: [
+                {
+                    args: {
+                        preset: 'condition-research-roundup',
+                    },
+                    options: {
+                        vault: './vault',
+                        name: 'cholesterol-research-roundup',
+                        var: ['condition_or_goal=lowering cholesterol'],
+                    },
+                    description: 'Install the condition research preset with a cholesterol-focused variable override.',
+                },
+                {
+                    args: {
+                        preset: 'environment-health-watch',
+                    },
+                    options: {
+                        vault: './vault',
+                        var: ['location_context=Brisbane, Queensland, Australia'],
+                        channel: 'telegram',
+                        participant: '123456789',
+                        sourceThread: '123456789',
+                    },
+                    description: 'Install the environment-health preset and deliver the weekly report back into a Telegram chat.',
+                },
+            ],
+            options: withBaseOptions({
+                name: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional cron job name override. Defaults to the preset’s suggested name.'),
+                var: z
+                    .array(z.string().min(1))
+                    .optional()
+                    .describe('Optional preset variable assignment in key=value form. Repeat --var for multiple values.'),
+                instructions: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional extra instructions appended to the preset prompt before the job is created.'),
+                at: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional one-shot ISO 8601 timestamp with an explicit offset.'),
+                every: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional recurring interval such as 30m, 2h, or 1d.'),
+                cron: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Optional five-field cron expression override.'),
+                disabled: z
+                    .boolean()
+                    .optional()
+                    .describe('Create the preset-backed cron job in a disabled state without scheduling it yet.'),
+                ...assistantSessionOptionFields,
+                ...assistantCronDeliveryOptionFields,
+                ...assistantCronStateOptionFields,
+            }),
+            output: assistantCronPresetInstallResultSchema,
+            async run(context) {
+                const schedule = context.options.at || context.options.every || context.options.cron
+                    ? buildAssistantCronSchedule({
+                        at: context.options.at,
+                        every: context.options.every,
+                        cron: context.options.cron,
+                    })
+                    : undefined;
+                const savedRoute = await resolveAssistantDeliveryRouteFromCli({
+                    allowSingleSavedTargetFallback: true,
+                    channel: context.options.channel,
+                    identity: context.options.identity,
+                    participant: context.options.participant,
+                    sourceThread: context.options.sourceThread,
+                    deliveryTarget: context.options.deliveryTarget,
+                });
+                const result = await installAssistantCronPreset({
+                    vault: context.options.vault,
+                    presetId: context.args.preset,
+                    name: context.options.name,
+                    variables: parseAssistantCronPresetVariables(context.options.var),
+                    additionalInstructions: context.options.instructions,
+                    schedule,
+                    enabled: context.options.disabled ? false : true,
+                    ...assistantCronStateOptionsFromCli(context.options),
+                    ...assistantConversationOptionsFromCli({
+                        ...context.options,
+                        channel: savedRoute.channel ?? context.options.channel,
+                        identity: savedRoute.identityId ?? context.options.identity,
+                        participant: savedRoute.participantId ?? context.options.participant,
+                        sourceThread: savedRoute.sourceThreadId ?? context.options.sourceThread,
+                    }),
+                    deliveryTarget: savedRoute.deliveryTarget ?? context.options.deliveryTarget,
+                });
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    preset: result.preset,
+                    job: result.job,
+                    resolvedPrompt: result.resolvedPrompt,
+                    resolvedVariables: result.resolvedVariables,
+                };
+            },
+        });
+        cron.command(preset);
+        cron.command('status', {
+            args: emptyArgsSchema,
+            description: 'Show scheduler counts and the next upcoming assistant cron run.',
+            hint: 'Assistant cron jobs execute while `assistant run` is active for the vault.',
+            options: withBaseOptions(),
+            output: assistantCronStatusResultSchema,
+            async run(context) {
+                const status = await getAssistantCronStatus(context.options.vault);
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    ...status,
+                };
+            },
+        });
+        cron.command('list', {
+            args: emptyArgsSchema,
+            description: 'List assistant cron jobs for one vault.',
+            options: withBaseOptions(),
+            output: assistantCronListResultSchema,
+            async run(context) {
+                const jobs = await listAssistantCronJobs(context.options.vault);
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    jobs,
+                };
+            },
+        });
+        cron.command('show', {
+            args: z.object({
+                job: z.string().min(1).describe('Assistant cron job id or name to inspect.'),
+            }),
+            description: 'Show one assistant cron job record.',
+            options: withBaseOptions(),
+            output: assistantCronShowResultSchema,
+            async run(context) {
+                const job = await getAssistantCronJob(context.options.vault, context.args.job);
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    job,
+                };
+            },
+        });
+        const target = Cli.create('target', {
+            description: 'Inspect or replace the outbound delivery target for an existing assistant cron job.',
+        });
+        target.command('show', {
+            args: z.object({
+                job: z.string().min(1).describe('Assistant cron job id or name to inspect.'),
+            }),
+            description: 'Show the current outbound delivery target for one assistant cron job.',
+            hint: 'Use this before retargeting a cron job so you can see the current channel, explicit destination, and inferred binding delivery.',
+            options: withBaseOptions(),
+            output: assistantCronTargetShowResultSchema,
+            async run(context) {
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    cronTarget: await getAssistantCronJobTarget(context.options.vault, context.args.job),
+                };
+            },
+        });
+        target.command('set', {
+            args: z.object({
+                job: z.string().min(1).describe('Assistant cron job id or name to retarget.'),
+            }),
+            description: 'Replace the outbound delivery target for one assistant cron job in place.',
+            hint: 'Provide exactly one target source: `--toSelf <channel>`, `--copyFrom <job>`, or an explicit route via `--channel` plus the usual delivery flags. When the audience changes, Murph clears stored cron session continuity so the next run does not reuse the old routed conversation.',
+            examples: [
+                {
+                    args: {
+                        job: 'weekly-health-snapshot',
+                    },
+                    options: {
+                        vault: './vault',
+                        toSelf: 'email',
+                    },
+                    description: 'Retarget an existing cron job to the saved email self-target.',
+                },
+                {
+                    args: {
+                        job: 'condition-research-roundup',
+                    },
+                    options: {
+                        vault: './vault',
+                        copyFrom: 'weekly-health-snapshot',
+                    },
+                    description: 'Copy the current delivery target from another cron job.',
+                },
+            ],
+            options: withBaseOptions({
+                ...assistantCronTargetSourceOptionFields,
+                ...assistantCronDeliveryOptionFields,
+                channel: assistantSessionOptionFields.channel,
+                identity: assistantSessionOptionFields.identity,
+                participant: assistantSessionOptionFields.participant,
+                sourceThread: assistantSessionOptionFields.sourceThread,
+            }),
+            output: assistantCronTargetSetResultSchema,
+            async run(context) {
+                const resolvedTarget = await resolveAssistantCronTargetFromCli({
+                    vault: context.options.vault,
+                    channel: context.options.channel,
+                    copyFrom: context.options.copyFrom,
+                    deliveryTarget: context.options.deliveryTarget,
+                    identity: context.options.identity,
+                    participant: context.options.participant,
+                    sourceThread: context.options.sourceThread,
+                    toSelf: context.options.toSelf,
+                });
+                const result = await setAssistantCronJobTarget({
+                    vault: context.options.vault,
+                    job: context.args.job,
+                    dryRun: context.options.dryRun,
+                    resetContinuity: context.options.resetContinuity,
+                    ...resolvedTarget,
+                });
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    job: result.job,
+                    beforeTarget: result.beforeTarget,
+                    afterTarget: result.afterTarget,
+                    changed: result.changed,
+                    continuityReset: result.continuityReset,
+                    dryRun: result.dryRun,
+                };
+            },
+        });
+        cron.command(target);
+        cron.command('add', {
+            args: z.object({
+                prompt: z.string().min(1).describe('Prompt to send when the assistant cron job fires.'),
+            }),
+            description: 'Create one assistant cron job backed by the local assistant runtime.',
+            hint: 'Provide exactly one of --at, --every, or --cron. One-shot jobs are deleted after they succeed unless you pass --keepAfterRun. Cron jobs require an explicit outbound channel route and always deliver their response. Add --state or --stateDoc only when the job needs run-to-run scratch state such as cooldowns, dedupe, unresolved follow-ups, or delivery policy; leave it off for stateless jobs that can recompute everything each run.',
+            examples: [
+                {
+                    args: {
+                        prompt: 'Check whether I have been sitting too long and remind me to stretch.',
+                    },
+                    options: {
+                        vault: './vault',
+                        name: 'stretch-reminder',
+                        every: '2h',
+                    },
+                    description: 'Create a recurring interval job.',
+                },
+                {
+                    args: {
+                        prompt: 'Remind me to review my lab results after dinner.',
+                    },
+                    options: {
+                        vault: './vault',
+                        name: 'lab-review-tonight',
+                        at: '2026-03-22T18:30:00+10:00',
+                    },
+                    description: 'Create a one-shot reminder at a specific timestamp.',
+                },
+                {
+                    args: {
+                        prompt: 'Every weekday morning, ask me for a quick symptom check-in.',
+                    },
+                    options: {
+                        vault: './vault',
+                        name: 'weekday-symptom-check',
+                        cron: '0 8 * * 1-5',
+                        channel: 'telegram',
+                        participant: '-1001234567890',
+                    },
+                    description: 'Create a cron expression job that also delivers the reply back out.',
+                },
+            ],
+            options: withBaseOptions({
+                name: z
+                    .string()
+                    .min(1)
+                    .describe('Unique assistant cron job name.'),
+                at: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('One-shot ISO 8601 timestamp with an explicit offset.'),
+                every: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Recurring interval such as 30m, 2h, or 1d.'),
+                cron: z
+                    .string()
+                    .min(1)
+                    .optional()
+                    .describe('Five-field cron expression: minute hour day-of-month month day-of-week.'),
+                keepAfterRun: z
+                    .boolean()
+                    .optional()
+                    .describe('Keep a completed one-shot job in the scheduler instead of deleting it.'),
+                disabled: z
+                    .boolean()
+                    .optional()
+                    .describe('Create the job in a disabled state without scheduling it yet.'),
+                ...assistantSessionOptionFields,
+                ...assistantCronDeliveryOptionFields,
+                ...assistantCronStateOptionFields,
+            }),
+            output: assistantCronAddResultSchema,
+            async run(context) {
+                const savedRoute = await resolveAssistantDeliveryRouteFromCli({
+                    allowSingleSavedTargetFallback: true,
+                    channel: context.options.channel,
+                    identity: context.options.identity,
+                    participant: context.options.participant,
+                    sourceThread: context.options.sourceThread,
+                    deliveryTarget: context.options.deliveryTarget,
+                });
+                const job = await addAssistantCronJob({
+                    vault: context.options.vault,
+                    name: context.options.name,
+                    prompt: context.args.prompt,
+                    schedule: buildAssistantCronSchedule({
+                        at: context.options.at,
+                        every: context.options.every,
+                        cron: context.options.cron,
+                    }),
+                    enabled: context.options.disabled ? false : true,
+                    keepAfterRun: context.options.keepAfterRun,
+                    ...assistantCronStateOptionsFromCli(context.options),
+                    ...assistantConversationOptionsFromCli({
+                        ...context.options,
+                        channel: savedRoute.channel ?? context.options.channel,
+                        identity: savedRoute.identityId ?? context.options.identity,
+                        participant: savedRoute.participantId ?? context.options.participant,
+                        sourceThread: savedRoute.sourceThreadId ?? context.options.sourceThread,
+                    }),
+                    deliveryTarget: savedRoute.deliveryTarget ?? context.options.deliveryTarget,
+                });
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    job,
+                };
+            },
+        });
+        cron.command('remove', {
+            args: z.object({
+                job: z.string().min(1).describe('Assistant cron job id or name to remove.'),
+            }),
+            description: 'Remove one assistant cron job from the scheduler.',
+            options: withBaseOptions(),
+            output: assistantCronRemoveResultSchema,
+            async run(context) {
+                const removed = await removeAssistantCronJob(context.options.vault, context.args.job);
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    removed,
+                };
+            },
+        });
+        cron.command('enable', {
+            args: z.object({
+                job: z.string().min(1).describe('Assistant cron job id or name to enable.'),
+            }),
+            description: 'Enable one assistant cron job.',
+            options: withBaseOptions(),
+            output: assistantCronShowResultSchema,
+            async run(context) {
+                const job = await setAssistantCronJobEnabled(context.options.vault, context.args.job, true);
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    job,
+                };
+            },
+        });
+        cron.command('disable', {
+            args: z.object({
+                job: z.string().min(1).describe('Assistant cron job id or name to disable.'),
+            }),
+            description: 'Disable one assistant cron job without deleting it.',
+            options: withBaseOptions(),
+            output: assistantCronShowResultSchema,
+            async run(context) {
+                const job = await setAssistantCronJobEnabled(context.options.vault, context.args.job, false);
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    job,
+                };
+            },
+        });
+        cron.command('run', {
+            args: z.object({
+                job: z.string().min(1).describe('Assistant cron job id or name to run immediately.'),
+            }),
+            description: 'Run one assistant cron job immediately, regardless of its next scheduled time.',
+            options: withBaseOptions(),
+            output: assistantCronRunResultSchema,
+            async run(context) {
+                const result = await runAssistantCronJobNow({
+                    vault: context.options.vault,
+                    job: context.args.job,
+                });
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    job: result.job,
+                    removedAfterRun: result.removedAfterRun,
+                    run: result.run,
+                };
+            },
+        });
+        cron.command('runs', {
+            args: z.object({
+                job: z.string().min(1).describe('Assistant cron job id or name to inspect run history for.'),
+            }),
+            description: 'List recent run history for one assistant cron job.',
+            options: withBaseOptions({
+                limit: z
+                    .number()
+                    .int()
+                    .positive()
+                    .max(100)
+                    .default(20)
+                    .describe('Maximum number of recent runs to return.'),
+            }),
+            output: assistantCronRunsResultSchema,
+            async run(context) {
+                const result = await listAssistantCronRuns({
+                    vault: context.options.vault,
+                    job: context.args.job,
+                    limit: context.options.limit,
+                });
+                return {
+                    ...buildAssistantCronResultPaths(context.options.vault),
+                    jobId: result.jobId,
+                    runs: result.runs,
+                };
+            },
+        });
+        assistant.command(cron);
+    };
+    const registerObservabilityCommands = () => {
+        assistant.command('status', createAssistantStatusCommandDefinition());
+        assistant.command('doctor', createAssistantDoctorCommandDefinition());
+        assistant.command('stop', createAssistantStopCommandDefinition());
+    };
+    const registerSessionCommands = () => {
+        const session = Cli.create('session', {
+            description: 'Inspect Murph assistant session metadata stored outside the canonical vault.',
+        });
+        session.command('list', {
+            args: emptyArgsSchema,
+            description: 'List known assistant sessions for one vault.',
+            options: withBaseOptions(),
+            output: assistantSessionListResultSchema,
+            async run(context) {
+                const sessions = await listAssistantSessions(context.options.vault);
+                return assistantSessionListResultSchema.parse({
+                    ...buildAssistantStateResultPaths(context.options.vault),
+                    sessions: redactAssistantSessionsForDisplay(sessions),
+                });
+            },
+        });
+        session.command('show', {
+            args: z.object({
+                sessionId: z.string().min(1).describe('Murph assistant session id to inspect.'),
+            }),
+            description: 'Show one assistant session metadata record.',
+            options: withBaseOptions(),
+            output: assistantSessionShowResultSchema,
+            async run(context) {
+                const session = await getAssistantSession(context.options.vault, context.args.sessionId);
+                return assistantSessionShowResultSchema.parse({
+                    ...buildAssistantStateResultPaths(context.options.vault),
+                    session: redactAssistantSessionForDisplay(session),
+                });
+            },
+        });
+        assistant.command(session);
+    };
+    const registerRootAliases = () => {
+        cli.command('chat', createAssistantChatCommandDefinition({
+            description: 'Open the same assistant chat UI as `assistant chat` directly from the CLI root.',
+            hint: 'Shorthand for `assistant chat`. Type /exit to close the chat loop or /session to print the current Murph session id.',
+        }));
+        cli.command('run', createAssistantRunCommandDefinition(inboxServices, vaultServices, {
+            description: 'Start the same assistant automation loop as `assistant run` directly from the CLI root.',
+            hint: 'Shorthand for `assistant run`. This starts the always-on automation loop, so it may watch inbox state, auto-reply over configured channels, and keep the terminal attached until you stop it.',
+        }));
+        cli.command('status', createAssistantStatusCommandDefinition({
+            description: 'Show the same assistant-state snapshot as `assistant status` directly from the CLI root.',
+            hint: 'Shorthand for `assistant status`. Use this to inspect recent turn receipts, session freshness, and pending outbox work.',
+        }));
+        cli.command('doctor', createAssistantDoctorCommandDefinition({
+            description: 'Run the same assistant-state diagnostics as `assistant doctor` directly from the CLI root.',
+            hint: 'Shorthand for `assistant doctor`. Use this when debugging transcript corruption, missing receipts, or stale outbox intents.',
+        }));
+        cli.command('stop', createAssistantStopCommandDefinition({
+            description: 'Stop the same assistant automation loop as `assistant stop` directly from the CLI root.',
+            hint: 'Shorthand for `assistant stop`. Use this when `murph run` is already active for the same vault and you need a recovery command instead of manual lock cleanup.',
+        }));
+    };
+    registerConversationCommands();
+    registerStateCommands();
+    registerMemoryCommands();
+    registerSelfTargetCommands();
+    registerCronCommands();
+    registerObservabilityCommands();
+    registerSessionCommands();
+    cli.command(assistant);
+    registerRootAliases();
+}
+//# sourceMappingURL=assistant.js.map