@murphai/murph 0.1.15 → 0.1.17

package/node_modules/@murphai/operator-config/dist/assistant-cli-contracts.js

@@ -0,0 +1,998 @@
+import { z } from 'zod';
+import { isoTimestampSchema, pathSchema, timeZoneSchema, } from './vault-cli-contracts.js';
+import { isValidAssistantOpaqueId } from './assistant/state-ids.js';
+export const assistantSandboxValues = [
+    'read-only',
+    'workspace-write',
+    'danger-full-access',
+];
+export const assistantApprovalPolicyValues = [
+    'untrusted',
+    'on-request',
+    'never',
+];
+export const assistantReasoningEffortValues = [
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+];
+export const assistantChatProviderValues = ['codex-cli', 'openai-compatible'];
+export const assistantChannelDeliveryTargetKindValues = [
+    'explicit',
+    'participant',
+    'thread',
+];
+export const assistantBindingDeliveryKindValues = [
+    'participant',
+    'thread',
+];
+export const assistantTranscriptEntryKindValues = [
+    'user',
+    'assistant',
+    'error',
+];
+export const assistantTurnTriggerValues = [
+    'manual-ask',
+    'manual-deliver',
+    'automation-auto-reply',
+    'automation-cron',
+];
+export const assistantTurnActionClassValues = ['analysis', 'outbound'];
+export const assistantTurnStateValues = [
+    'running',
+    'awaiting-delivery',
+    'deferred',
+    'delivery-failed',
+    'failed',
+    'completed',
+];
+export const assistantTurnEventKindValues = [
+    'accepted',
+    'context-ready',
+    'provider-started',
+    'provider-completed',
+    'delivery-prepared',
+    'delivery-sent',
+    'delivery-deduplicated',
+    'deferred',
+    'failed',
+    'completed',
+];
+export const assistantCronScheduleKindValues = [
+    'at',
+    'every',
+    'cron',
+    'dailyLocal',
+];
+export const assistantCronTriggerValues = ['manual', 'scheduled'];
+export const assistantCronRunStatusValues = [
+    'succeeded',
+    'failed',
+    'skipped',
+];
+export const assistantTurnReceiptStatusValues = [
+    'running',
+    'completed',
+    'deferred',
+    'blocked',
+    'failed',
+];
+export const assistantTurnTimelineEventKindValues = [
+    'turn.started',
+    'user.persisted',
+    'provider.attempt.started',
+    'provider.attempt.succeeded',
+    'provider.attempt.failed',
+    'provider.failover.applied',
+    'provider.cooldown.started',
+    'delivery.queued',
+    'delivery.attempt.started',
+    'delivery.sent',
+    'delivery.retry-scheduled',
+    'delivery.failed',
+    'turn.blocked',
+    'turn.completed',
+    'turn.deferred',
+];
+export const assistantAskResultStatusValues = ['completed'];
+export const assistantOutboxStatusValues = [
+    'pending',
+    'sending',
+    'retryable',
+    'sent',
+    'failed',
+    'abandoned',
+];
+export const assistantDiagnosticLevelValues = [
+    'info',
+    'warn',
+    'error',
+];
+export const assistantDiagnosticComponentValues = [
+    'assistant',
+    'provider',
+    'delivery',
+    'outbox',
+    'automation',
+    'status',
+];
+export const assistantStatusRunLockStateValues = [
+    'unlocked',
+    'active',
+    'stale',
+];
+export const assistantQuarantineArtifactKindValues = [
+    'session',
+    'indexes',
+    'automation',
+    'status',
+    'diagnostics-snapshot',
+    'failover',
+    'turn-receipt',
+    'outbox-intent',
+    'runtime-budget',
+    'cron-store',
+    'cron-run',
+];
+export const assistantRuntimeEventKindValues = [
+    'session.upserted',
+    'session.quarantined',
+    'indexes.rebuilt',
+    'indexes.quarantined',
+    'automation.recovered',
+    'automation.quarantined',
+    'outbox.intent.upserted',
+    'outbox.intent.quarantined',
+    'turn.receipt.upserted',
+    'turn.receipt.quarantined',
+    'diagnostics.event.recorded',
+    'diagnostics.snapshot.recovered',
+    'diagnostics.snapshot.quarantined',
+    'failover.state.upserted',
+    'failover.state.quarantined',
+    'status.snapshot.refreshed',
+    'status.snapshot.quarantined',
+    'runtime-budget.recovered',
+    'runtime-budget.quarantined',
+    'cron.store.quarantined',
+    'cron.run.quarantined',
+    'runtime.maintenance',
+];
+export const assistantHeadersSchema = z.record(z.string().min(1), z.string());
+export const assistantCodexModelTargetSchema = z
+    .object({
+    adapter: z.literal('codex-cli'),
+    approvalPolicy: z.enum(assistantApprovalPolicyValues).nullable().default(null),
+    codexCommand: z.string().min(1).nullable().default(null),
+    codexHome: z.string().min(1).nullable().optional(),
+    model: z.string().min(1).nullable().default(null),
+    oss: z.boolean().default(false),
+    profile: z.string().min(1).nullable().default(null),
+    reasoningEffort: z.enum(assistantReasoningEffortValues).nullable().default(null),
+    sandbox: z.enum(assistantSandboxValues).nullable().default(null),
+})
+    .strict();
+export const assistantOpenAiCompatibleModelTargetSchema = z
+    .object({
+    adapter: z.literal('openai-compatible'),
+    apiKeyEnv: z.string().min(1).nullable().default(null),
+    endpoint: z.string().min(1).nullable().default(null),
+    headers: assistantHeadersSchema.nullable().default(null),
+    model: z.string().min(1).nullable().default(null),
+    providerName: z.string().min(1).nullable().default(null),
+    reasoningEffort: z.enum(assistantReasoningEffortValues).nullable().default(null),
+})
+    .strict();
+export const assistantModelTargetSchema = z.discriminatedUnion('adapter', [
+    assistantCodexModelTargetSchema,
+    assistantOpenAiCompatibleModelTargetSchema,
+]);
+export const assistantSessionProviderStateSchema = z
+    .object({
+    resumeRouteId: z.string().min(1).nullable().default(null),
+})
+    .strict();
+export const assistantSessionResumeStateSchema = z
+    .object({
+    providerSessionId: z.string().min(1).nullable().default(null),
+    resumeRouteId: z.string().min(1).nullable().default(null),
+})
+    .strict();
+export const assistantSessionIdSchema = z.string().refine((value) => isValidAssistantOpaqueId(value), 'Assistant session ids must be opaque runtime ids without path separators or traversal segments.');
+export const assistantProviderSessionOptionsSchema = z.object({
+    model: z.string().min(1).nullable(),
+    reasoningEffort: z.string().min(1).nullable().default(null),
+    sandbox: z.enum(assistantSandboxValues).nullable(),
+    approvalPolicy: z.enum(assistantApprovalPolicyValues).nullable(),
+    profile: z.string().min(1).nullable(),
+    oss: z.boolean(),
+    codexHome: z.string().min(1).nullable().optional(),
+    baseUrl: z.string().min(1).nullable().optional(),
+    apiKeyEnv: z.string().min(1).nullable().optional(),
+    providerName: z.string().min(1).nullable().optional(),
+    headers: assistantHeadersSchema.nullable().optional(),
+});
+export const assistantSessionSecretsSchema = z
+    .object({
+    schema: z.literal('murph.assistant-session-secrets.v1'),
+    sessionId: z.string().min(1),
+    updatedAt: isoTimestampSchema,
+    providerHeaders: assistantHeadersSchema.nullable().default(null),
+    providerBindingHeaders: assistantHeadersSchema.nullable().default(null),
+})
+    .strict();
+export const assistantProviderFailoverRouteSchema = z
+    .object({
+    name: z.string().min(1).nullable().default(null),
+    provider: z.enum(assistantChatProviderValues),
+    codexCommand: z.string().min(1).nullable().default(null),
+    codexHome: z.string().min(1).nullable().optional(),
+    model: z.string().min(1).nullable().default(null),
+    reasoningEffort: z.string().min(1).nullable().default(null),
+    sandbox: z.enum(assistantSandboxValues).nullable().default(null),
+    approvalPolicy: z.enum(assistantApprovalPolicyValues).nullable().default(null),
+    profile: z.string().min(1).nullable().default(null),
+    oss: z.boolean().default(false),
+    baseUrl: z.string().min(1).nullable().optional(),
+    apiKeyEnv: z.string().min(1).nullable().optional(),
+    providerName: z.string().min(1).nullable().optional(),
+    headers: assistantHeadersSchema.nullable().optional(),
+    cooldownMs: z.number().int().positive().nullable().default(null),
+})
+    .strict();
+export const assistantAliasStoreSchema = z
+    .object({
+    version: z.literal(2),
+    aliases: z.record(z.string(), assistantSessionIdSchema),
+    conversationKeys: z.record(z.string(), assistantSessionIdSchema),
+})
+    .strict();
+export const assistantBindingDeliverySchema = z.object({
+    kind: z.enum(assistantBindingDeliveryKindValues),
+    target: z.string().min(1),
+});
+export const assistantSessionBindingSchema = z.object({
+    conversationKey: z.string().min(1).nullable(),
+    channel: z.string().min(1).nullable(),
+    identityId: z.string().min(1).nullable(),
+    actorId: z.string().min(1).nullable(),
+    threadId: z.string().min(1).nullable(),
+    threadIsDirect: z.boolean().nullable(),
+    delivery: assistantBindingDeliverySchema.nullable(),
+});
+export const assistantProviderBindingSchema = z
+    .object({
+    provider: z.enum(assistantChatProviderValues),
+    providerSessionId: z.string().min(1).nullable(),
+    providerState: assistantSessionProviderStateSchema.nullable().optional(),
+    providerOptions: assistantProviderSessionOptionsSchema,
+})
+    .strict();
+export const assistantPersistedSessionSchema = z
+    .object({
+    schema: z.literal('murph.assistant-session.v4'),
+    sessionId: assistantSessionIdSchema,
+    target: assistantModelTargetSchema,
+    resumeState: assistantSessionResumeStateSchema.nullable().default(null),
+    alias: z.string().min(1).nullable(),
+    binding: assistantSessionBindingSchema,
+    createdAt: isoTimestampSchema,
+    updatedAt: isoTimestampSchema,
+    lastTurnAt: isoTimestampSchema.nullable(),
+    turnCount: z.number().int().nonnegative(),
+})
+    .strict();
+export const assistantSessionSchema = assistantPersistedSessionSchema.transform((value) => normalizeAssistantSessionRecord(value));
+export function parseAssistantSessionRecord(value) {
+    return assistantSessionSchema.parse(value);
+}
+const assistantSessionOutputSchema = assistantPersistedSessionSchema
+    .extend({
+    provider: z.enum(assistantChatProviderValues),
+    providerOptions: assistantProviderSessionOptionsSchema,
+    providerBinding: assistantProviderBindingSchema.nullable().default(null),
+})
+    .strict();
+function normalizeAssistantSessionRecord(value) {
+    return buildAssistantRuntimeSession({
+        ...value,
+        resumeState: normalizeAssistantSessionResumeState(value.resumeState),
+    });
+}
+function buildAssistantRuntimeSession(value) {
+    const provider = value.target.adapter;
+    const providerOptions = value.target.adapter === 'openai-compatible'
+        ? assistantProviderSessionOptionsSchema.parse({
+            model: value.target.model,
+            reasoningEffort: value.target.reasoningEffort,
+            sandbox: null,
+            approvalPolicy: null,
+            profile: null,
+            oss: false,
+            ...(value.target.endpoint ? { baseUrl: value.target.endpoint } : {}),
+            ...(value.target.apiKeyEnv ? { apiKeyEnv: value.target.apiKeyEnv } : {}),
+            ...(value.target.providerName
+                ? { providerName: value.target.providerName }
+                : {}),
+            ...(value.target.headers ? { headers: value.target.headers } : {}),
+        })
+        : assistantProviderSessionOptionsSchema.parse({
+            model: value.target.model,
+            reasoningEffort: value.target.reasoningEffort,
+            sandbox: value.target.sandbox,
+            approvalPolicy: value.target.approvalPolicy,
+            profile: value.target.profile,
+            oss: value.target.oss,
+            ...(value.target.codexHome ? { codexHome: value.target.codexHome } : {}),
+        });
+    const providerBinding = value.resumeState &&
+        (value.resumeState.providerSessionId !== null ||
+            value.resumeState.resumeRouteId !== null)
+        ? assistantProviderBindingSchema.parse({
+            provider,
+            providerOptions,
+            providerSessionId: value.resumeState.providerSessionId,
+            providerState: value.resumeState.resumeRouteId !== null
+                ? {
+                    resumeRouteId: value.resumeState.resumeRouteId,
+                }
+                : null,
+        })
+        : null;
+    return {
+        ...value,
+        provider,
+        providerBinding,
+        providerOptions,
+    };
+}
+function normalizeAssistantSessionResumeState(value) {
+    if (!value) {
+        return null;
+    }
+    const providerSessionId = typeof value.providerSessionId === 'string' && value.providerSessionId.trim().length > 0
+        ? value.providerSessionId.trim()
+        : null;
+    const resumeRouteId = typeof value.resumeRouteId === 'string' && value.resumeRouteId.trim().length > 0
+        ? value.resumeRouteId.trim()
+        : null;
+    return providerSessionId || resumeRouteId
+        ? assistantSessionResumeStateSchema.parse({
+            providerSessionId,
+            resumeRouteId,
+        })
+        : null;
+}
+export const assistantTranscriptEntrySchema = z.object({
+    schema: z.literal('murph.assistant-transcript-entry.v1'),
+    kind: z.enum(assistantTranscriptEntryKindValues),
+    text: z.string(),
+    createdAt: isoTimestampSchema,
+});
+export const assistantChannelDeliverySchema = z.object({
+    channel: z.string().min(1),
+    idempotencyKey: z.string().min(1).nullable().default(null),
+    target: z.string().min(1),
+    targetKind: z.enum(assistantChannelDeliveryTargetKindValues),
+    sentAt: isoTimestampSchema,
+    messageLength: z.number().int().nonnegative(),
+    providerMessageId: z.string().min(1).nullable().default(null),
+    providerThreadId: z.string().min(1).nullable().default(null),
+});
+export const assistantDeliveryErrorSchema = z.object({
+    code: z.string().min(1).nullable(),
+    message: z.string().min(1),
+});
+export const assistantTurnReceiptContextSchema = z
+    .object({
+    deliveryRequested: z.boolean(),
+    usedConversationTranscript: z.boolean(),
+    usedMemoryPrompt: z.boolean(),
+    usedSensitiveHealthContext: z.boolean(),
+})
+    .strict();
+export const assistantTurnReceiptEventSchema = z
+    .object({
+    at: isoTimestampSchema,
+    kind: z.enum(assistantTurnEventKindValues),
+    message: z.string().min(1),
+    state: z.enum(assistantTurnStateValues).nullable(),
+})
+    .strict();
+export const assistantTurnTimelineEventSchema = z
+    .object({
+    at: isoTimestampSchema,
+    kind: z.enum(assistantTurnTimelineEventKindValues),
+    detail: z.string().nullable().default(null),
+    metadata: z.record(z.string(), z.string()).default({}),
+})
+    .strict();
+export const assistantTurnReceiptSchema = z
+    .object({
+    schema: z.literal('murph.assistant-turn-receipt.v1'),
+    turnId: z.string().min(1),
+    sessionId: assistantSessionIdSchema,
+    provider: z.enum(assistantChatProviderValues),
+    providerModel: z.string().min(1).nullable(),
+    promptPreview: z.string().nullable(),
+    responsePreview: z.string().nullable(),
+    status: z.enum(assistantTurnReceiptStatusValues),
+    deliveryRequested: z.boolean(),
+    deliveryDisposition: z.enum([
+        'not-requested',
+        'queued',
+        'sent',
+        'retryable',
+        'blocked',
+        'failed',
+    ]),
+    deliveryIntentId: z.string().min(1).nullable(),
+    startedAt: isoTimestampSchema,
+    updatedAt: isoTimestampSchema,
+    completedAt: isoTimestampSchema.nullable(),
+    lastError: assistantDeliveryErrorSchema.nullable(),
+    timeline: z.array(assistantTurnTimelineEventSchema),
+})
+    .strict();
+export const assistantOutboxIntentStatusValues = assistantOutboxStatusValues;
+export const assistantOutboxIntentSchema = z
+    .object({
+    schema: z.literal('murph.assistant-outbox-intent.v1'),
+    intentId: z.string().min(1),
+    sessionId: assistantSessionIdSchema,
+    turnId: z.string().min(1),
+    createdAt: isoTimestampSchema,
+    updatedAt: isoTimestampSchema,
+    lastAttemptAt: isoTimestampSchema.nullable(),
+    nextAttemptAt: isoTimestampSchema.nullable(),
+    sentAt: isoTimestampSchema.nullable(),
+    attemptCount: z.number().int().nonnegative(),
+    status: z.enum(assistantOutboxIntentStatusValues),
+    message: z.string().min(1),
+    dedupeKey: z.string().min(1),
+    targetFingerprint: z.string().min(1),
+    channel: z.string().min(1).nullable(),
+    identityId: z.string().min(1).nullable(),
+    actorId: z.string().min(1).nullable(),
+    threadId: z.string().min(1).nullable(),
+    threadIsDirect: z.boolean().nullable(),
+    replyToMessageId: z.string().min(1).nullable().default(null),
+    bindingDelivery: assistantBindingDeliverySchema.nullable(),
+    explicitTarget: z.string().min(1).nullable(),
+    delivery: assistantChannelDeliverySchema.nullable(),
+    deliveryConfirmationPending: z.boolean().default(false),
+    deliveryIdempotencyKey: z.string().min(1).nullable().default(null),
+    deliveryTransportIdempotent: z.boolean().default(false),
+    lastError: assistantDeliveryErrorSchema.nullable(),
+})
+    .strict();
+export const assistantDiagnosticEventSchema = z
+    .object({
+    schema: z.literal('murph.assistant-diagnostic-event.v1'),
+    at: isoTimestampSchema,
+    level: z.enum(assistantDiagnosticLevelValues),
+    component: z.enum(assistantDiagnosticComponentValues),
+    kind: z.string().min(1),
+    message: z.string().min(1),
+    code: z.string().min(1).nullable(),
+    sessionId: z.string().min(1).nullable(),
+    turnId: z.string().min(1).nullable(),
+    intentId: z.string().min(1).nullable(),
+    dataJson: z.string().nullable(),
+})
+    .strict();
+export const assistantDiagnosticsCountersSchema = z
+    .object({
+    turnsStarted: z.number().int().nonnegative(),
+    turnsCompleted: z.number().int().nonnegative(),
+    turnsDeferred: z.number().int().nonnegative(),
+    turnsFailed: z.number().int().nonnegative(),
+    providerAttempts: z.number().int().nonnegative(),
+    providerFailures: z.number().int().nonnegative(),
+    providerFailovers: z.number().int().nonnegative(),
+    deliveriesQueued: z.number().int().nonnegative(),
+    deliveriesSent: z.number().int().nonnegative(),
+    deliveriesFailed: z.number().int().nonnegative(),
+    deliveriesRetryable: z.number().int().nonnegative(),
+    outboxDrains: z.number().int().nonnegative(),
+    outboxRetries: z.number().int().nonnegative(),
+    automationScans: z.number().int().nonnegative(),
+})
+    .strict();
+export const assistantDiagnosticsSnapshotSchema = z
+    .object({
+    schema: z.literal('murph.assistant-diagnostics.v1'),
+    updatedAt: isoTimestampSchema,
+    lastEventAt: isoTimestampSchema.nullable(),
+    lastErrorAt: isoTimestampSchema.nullable(),
+    counters: assistantDiagnosticsCountersSchema,
+    recentWarnings: z.array(z.string()),
+})
+    .strict();
+export const assistantQuarantineEntrySchema = z
+    .object({
+    schema: z.literal('murph.assistant-quarantine-entry.v1'),
+    quarantineId: z.string().min(1),
+    artifactKind: z.enum(assistantQuarantineArtifactKindValues),
+    originalPath: pathSchema,
+    quarantinedPath: pathSchema,
+    metadataPath: pathSchema,
+    quarantinedAt: isoTimestampSchema,
+    errorCode: z.string().min(1).nullable(),
+    message: z.string().min(1),
+})
+    .strict();
+export const assistantQuarantineSummarySchema = z
+    .object({
+    total: z.number().int().nonnegative(),
+    byKind: z.record(z.string(), z.number().int().nonnegative()),
+    recent: z.array(assistantQuarantineEntrySchema),
+})
+    .strict();
+export const assistantRuntimeCacheBudgetSchema = z
+    .object({
+    name: z.string().min(1),
+    limit: z.number().int().positive(),
+    size: z.number().int().nonnegative(),
+    hits: z.number().int().nonnegative(),
+    misses: z.number().int().nonnegative(),
+    evictions: z.number().int().nonnegative(),
+    expired: z.number().int().nonnegative(),
+    ttlMs: z.number().int().positive(),
+})
+    .strict();
+export const assistantRuntimeMaintenanceSnapshotSchema = z
+    .object({
+    lastRunAt: isoTimestampSchema.nullable(),
+    staleQuarantinePruned: z.number().int().nonnegative(),
+    staleLocksCleared: z.number().int().nonnegative(),
+    notes: z.array(z.string()),
+})
+    .strict();
+export const assistantRuntimeBudgetSnapshotSchema = z
+    .object({
+    schema: z.literal('murph.assistant-runtime-budget.v1'),
+    updatedAt: isoTimestampSchema,
+    caches: z.array(assistantRuntimeCacheBudgetSchema),
+    maintenance: assistantRuntimeMaintenanceSnapshotSchema,
+})
+    .strict();
+export const assistantRuntimeEventSchema = z
+    .object({
+    schema: z.literal('murph.assistant-runtime-event.v1'),
+    at: isoTimestampSchema,
+    level: z.enum(assistantDiagnosticLevelValues),
+    kind: z.enum(assistantRuntimeEventKindValues),
+    component: z.string().min(1),
+    entityId: z.string().min(1).nullable(),
+    entityType: z.string().min(1).nullable(),
+    message: z.string().min(1),
+    dataJson: z.string().nullable(),
+})
+    .strict();
+export const assistantProviderRouteStateSchema = z
+    .object({
+    routeId: z.string().min(1),
+    label: z.string().min(1),
+    provider: z.enum(assistantChatProviderValues),
+    model: z.string().min(1).nullable(),
+    failureCount: z.number().int().nonnegative(),
+    successCount: z.number().int().nonnegative(),
+    consecutiveFailures: z.number().int().nonnegative(),
+    lastFailureAt: isoTimestampSchema.nullable(),
+    lastErrorCode: z.string().min(1).nullable(),
+    lastErrorMessage: z.string().min(1).nullable(),
+    cooldownUntil: isoTimestampSchema.nullable(),
+})
+    .strict();
+export const assistantFailoverStateSchema = z
+    .object({
+    schema: z.literal('murph.assistant-failover-state.v1'),
+    updatedAt: isoTimestampSchema,
+    routes: z.array(assistantProviderRouteStateSchema),
+})
+    .strict();
+export const assistantStatusRunLockSchema = z
+    .object({
+    state: z.enum(assistantStatusRunLockStateValues),
+    pid: z.number().int().positive().nullable(),
+    startedAt: isoTimestampSchema.nullable(),
+    mode: z.enum(['continuous', 'once']).nullable(),
+    command: z.string().min(1).nullable(),
+    reason: z.string().nullable(),
+})
+    .strict();
+export const assistantStatusAutomationSchema = z
+    .object({
+    inboxScanCursor: z.lazy(() => assistantAutomationCursorSchema).nullable(),
+    autoReplyScanCursor: z.lazy(() => assistantAutomationCursorSchema).nullable(),
+    autoReplyChannels: z.array(z.string().min(1)),
+    autoReplyBacklogChannels: z.array(z.string().min(1)),
+    autoReplyPrimed: z.boolean(),
+    updatedAt: isoTimestampSchema.nullable(),
+})
+    .strict();
+export const assistantStatusOutboxSummarySchema = z
+    .object({
+    total: z.number().int().nonnegative(),
+    pending: z.number().int().nonnegative(),
+    sending: z.number().int().nonnegative(),
+    retryable: z.number().int().nonnegative(),
+    sent: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    abandoned: z.number().int().nonnegative(),
+    oldestPendingAt: isoTimestampSchema.nullable(),
+    nextAttemptAt: isoTimestampSchema.nullable(),
+})
+    .strict();
+export const assistantStatusResultSchema = z
+    .object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    statusPath: pathSchema,
+    outboxRoot: pathSchema,
+    diagnosticsPath: pathSchema,
+    failoverStatePath: pathSchema,
+    turnsRoot: pathSchema,
+    generatedAt: isoTimestampSchema,
+    runLock: assistantStatusRunLockSchema,
+    automation: assistantStatusAutomationSchema,
+    outbox: assistantStatusOutboxSummarySchema,
+    diagnostics: assistantDiagnosticsSnapshotSchema,
+    failover: assistantFailoverStateSchema,
+    quarantine: assistantQuarantineSummarySchema,
+    runtimeBudget: assistantRuntimeBudgetSnapshotSchema,
+    recentTurns: z.array(assistantTurnReceiptSchema),
+    warnings: z.array(z.string()),
+})
+    .strict();
+export const assistantDoctorCheckStatusValues = ['pass', 'warn', 'fail'];
+export const assistantDoctorCheckSchema = z
+    .object({
+    name: z.string().min(1),
+    status: z.enum(assistantDoctorCheckStatusValues),
+    message: z.string().min(1),
+    details: z.record(z.string(), z.unknown()).optional(),
+})
+    .strict();
+export const assistantDoctorResultSchema = z
+    .object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    ok: z.boolean(),
+    sessionCount: z.number().int().nonnegative(),
+    transcriptFileCount: z.number().int().nonnegative(),
+    receiptCount: z.number().int().nonnegative(),
+    outboxIntentCount: z.number().int().nonnegative(),
+    quarantineCount: z.number().int().nonnegative(),
+    checks: z.array(assistantDoctorCheckSchema),
+})
+    .strict();
+export const assistantCronAtScheduleSchema = z
+    .object({
+    kind: z.literal('at'),
+    at: isoTimestampSchema,
+})
+    .strict();
+export const assistantCronEveryScheduleSchema = z
+    .object({
+    kind: z.literal('every'),
+    everyMs: z.number().int().positive(),
+})
+    .strict();
+export const assistantCronExpressionScheduleSchema = z
+    .object({
+    kind: z.literal('cron'),
+    expression: z.string().min(1),
+    timeZone: timeZoneSchema,
+})
+    .strict();
+export const assistantCronExpressionScheduleInputSchema = z
+    .object({
+    kind: z.literal('cron'),
+    expression: z.string().min(1),
+    timeZone: timeZoneSchema.optional(),
+})
+    .strict();
+export const assistantCronDailyLocalScheduleSchema = z
+    .object({
+    kind: z.literal('dailyLocal'),
+    localTime: z
+        .string()
+        .regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/u, 'Expected a 24-hour HH:MM time.'),
+    timeZone: timeZoneSchema,
+})
+    .strict();
+export const assistantCronScheduleSchema = z.discriminatedUnion('kind', [
+    assistantCronAtScheduleSchema,
+    assistantCronEveryScheduleSchema,
+    assistantCronExpressionScheduleSchema,
+    assistantCronDailyLocalScheduleSchema,
+]);
+export const assistantCronScheduleInputSchema = z.discriminatedUnion('kind', [
+    assistantCronAtScheduleSchema,
+    assistantCronEveryScheduleSchema,
+    assistantCronExpressionScheduleInputSchema,
+    assistantCronDailyLocalScheduleSchema,
+]);
+export const assistantCronTargetSchema = z
+    .object({
+    sessionId: z.string().min(1).nullable(),
+    alias: z.string().min(1).nullable(),
+    channel: z.string().min(1).nullable(),
+    identityId: z.string().min(1).nullable(),
+    participantId: z.string().min(1).nullable(),
+    sourceThreadId: z.string().min(1).nullable(),
+    deliveryTarget: z.string().min(1).nullable(),
+    deliverResponse: z.boolean(),
+})
+    .strict();
+export const assistantSelfDeliveryTargetSchema = z
+    .object({
+    channel: z.string().min(1),
+    identityId: z.string().min(1).nullable(),
+    participantId: z.string().min(1).nullable(),
+    sourceThreadId: z.string().min(1).nullable(),
+    deliveryTarget: z.string().min(1).nullable(),
+})
+    .strict();
+export const assistantCronJobStateSchema = z
+    .object({
+    nextRunAt: isoTimestampSchema.nullable(),
+    lastRunAt: isoTimestampSchema.nullable(),
+    lastSucceededAt: isoTimestampSchema.nullable(),
+    lastFailedAt: isoTimestampSchema.nullable(),
+    consecutiveFailures: z.number().int().nonnegative(),
+    lastError: z.string().nullable(),
+    runningAt: isoTimestampSchema.nullable(),
+    runningPid: z.number().int().positive().nullable(),
+})
+    .strict();
+export const assistantCronFoodAutoLogSchema = z
+    .object({
+    foodId: z.string().min(1),
+})
+    .strict();
+export const assistantCronJobSchema = z
+    .object({
+    schema: z.literal('murph.assistant-cron-job.v1'),
+    jobId: z.string().min(1),
+    name: z.string().min(1),
+    enabled: z.boolean(),
+    keepAfterRun: z.boolean(),
+    prompt: z.string().min(1),
+    schedule: assistantCronScheduleSchema,
+    target: assistantCronTargetSchema,
+    foodAutoLog: assistantCronFoodAutoLogSchema.optional(),
+    createdAt: isoTimestampSchema,
+    updatedAt: isoTimestampSchema,
+    state: assistantCronJobStateSchema,
+})
+    .strict();
+export const assistantCronRunRecordSchema = z
+    .object({
+    schema: z.literal('murph.assistant-cron-run.v1'),
+    runId: z.string().min(1),
+    jobId: z.string().min(1),
+    trigger: z.enum(assistantCronTriggerValues),
+    status: z.enum(assistantCronRunStatusValues),
+    startedAt: isoTimestampSchema,
+    finishedAt: isoTimestampSchema,
+    sessionId: z.string().min(1).nullable(),
+    response: z.string().nullable(),
+    responseLength: z.number().int().nonnegative(),
+    error: z.string().nullable(),
+})
+    .strict();
+export const assistantCronPresetVariableSchema = z
+    .object({
+    key: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string().min(1),
+    required: z.boolean(),
+    defaultValue: z.string().min(1).nullable(),
+    example: z.string().min(1).nullable(),
+})
+    .strict();
+export const assistantCronPresetSchema = z
+    .object({
+    id: z.string().min(1),
+    category: z.string().min(1),
+    title: z.string().min(1),
+    description: z.string().min(1),
+    suggestedName: z.string().min(1),
+    suggestedSchedule: assistantCronScheduleInputSchema,
+    suggestedScheduleLabel: z.string().min(1),
+    variables: z.array(assistantCronPresetVariableSchema),
+})
+    .strict();
+export const assistantAskResultSchema = z.object({
+    vault: pathSchema,
+    status: z.enum(assistantAskResultStatusValues).default('completed'),
+    prompt: z.string().min(1),
+    response: z.string(),
+    session: assistantSessionOutputSchema,
+    delivery: assistantChannelDeliverySchema.nullable(),
+    deliveryDeferred: z.boolean().default(false),
+    deliveryIntentId: z.string().min(1).nullable().default(null),
+    deliveryError: assistantDeliveryErrorSchema.nullable(),
+});
+export const assistantChatResultSchema = z.object({
+    vault: pathSchema,
+    startedAt: isoTimestampSchema,
+    stoppedAt: isoTimestampSchema,
+    turns: z.number().int().nonnegative(),
+    session: assistantSessionOutputSchema,
+});
+export const assistantDeliverResultSchema = z.object({
+    vault: pathSchema,
+    message: z.string().min(1),
+    session: assistantSessionOutputSchema,
+    delivery: assistantChannelDeliverySchema,
+});
+export const assistantSessionListResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    sessions: z.array(assistantSessionOutputSchema),
+});
+export const assistantSessionShowResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    session: assistantSessionOutputSchema,
+});
+export const assistantCronStatusResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    totalJobs: z.number().int().nonnegative(),
+    enabledJobs: z.number().int().nonnegative(),
+    dueJobs: z.number().int().nonnegative(),
+    runningJobs: z.number().int().nonnegative(),
+    nextRunAt: isoTimestampSchema.nullable(),
+});
+export const assistantCronListResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    jobs: z.array(assistantCronJobSchema),
+});
+export const assistantCronShowResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    job: assistantCronJobSchema,
+});
+export const assistantCronAddResultSchema = assistantCronShowResultSchema;
+export const assistantCronRemoveResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    removed: assistantCronJobSchema,
+});
+export const assistantCronRunResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    job: assistantCronJobSchema,
+    removedAfterRun: z.boolean(),
+    run: assistantCronRunRecordSchema,
+});
+export const assistantCronRunsResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    jobId: z.string().min(1),
+    runs: z.array(assistantCronRunRecordSchema),
+});
+export const assistantCronTargetSnapshotSchema = z.object({
+    jobId: z.string().min(1),
+    jobName: z.string().min(1),
+    target: assistantCronTargetSchema,
+    bindingDelivery: assistantBindingDeliverySchema.nullable(),
+});
+export const assistantCronTargetShowResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    cronTarget: assistantCronTargetSnapshotSchema,
+});
+export const assistantCronTargetSetResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    job: assistantCronJobSchema,
+    beforeTarget: assistantCronTargetSnapshotSchema,
+    afterTarget: assistantCronTargetSnapshotSchema,
+    changed: z.boolean(),
+    continuityReset: z.boolean(),
+    dryRun: z.boolean(),
+});
+export const assistantCronPresetListResultSchema = z.object({
+    vault: pathSchema,
+    presets: z.array(assistantCronPresetSchema),
+});
+export const assistantCronPresetShowResultSchema = z.object({
+    vault: pathSchema,
+    preset: assistantCronPresetSchema,
+    promptTemplate: z.string().min(1),
+});
+export const assistantCronPresetInstallResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    jobsPath: pathSchema,
+    runsRoot: pathSchema,
+    preset: assistantCronPresetSchema,
+    job: assistantCronJobSchema,
+    resolvedPrompt: z.string().min(1),
+    resolvedVariables: z.record(z.string(), z.string()),
+});
+export const assistantSelfDeliveryTargetListResultSchema = z.object({
+    configPath: pathSchema,
+    targets: z.array(assistantSelfDeliveryTargetSchema),
+});
+export const assistantSelfDeliveryTargetShowResultSchema = z.object({
+    configPath: pathSchema,
+    target: assistantSelfDeliveryTargetSchema.nullable(),
+});
+export const assistantSelfDeliveryTargetSetResultSchema = z.object({
+    configPath: pathSchema,
+    target: assistantSelfDeliveryTargetSchema,
+});
+export const assistantSelfDeliveryTargetClearResultSchema = z.object({
+    configPath: pathSchema,
+    clearedChannels: z.array(z.string().min(1)),
+});
+export const assistantRunResultSchema = z.object({
+    vault: pathSchema,
+    startedAt: isoTimestampSchema,
+    stoppedAt: isoTimestampSchema,
+    reason: z.enum(['completed', 'signal', 'error']),
+    daemonStarted: z.boolean(),
+    scans: z.number().int().nonnegative(),
+    considered: z.number().int().nonnegative(),
+    routed: z.number().int().nonnegative(),
+    noAction: z.number().int().nonnegative(),
+    skipped: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    replyConsidered: z.number().int().nonnegative(),
+    replied: z.number().int().nonnegative(),
+    replySkipped: z.number().int().nonnegative(),
+    replyFailed: z.number().int().nonnegative(),
+    lastError: z.string().nullable(),
+});
+export const assistantStopResultSchema = z.object({
+    vault: pathSchema,
+    stateRoot: pathSchema,
+    stopped: z.boolean(),
+    stopMethod: z.enum(['signal', 'force-kill', 'stale-lock-cleanup']),
+    pid: z.number().int().positive().nullable(),
+    startedAt: isoTimestampSchema.nullable(),
+    stoppedAt: isoTimestampSchema,
+    command: z.string().min(1).nullable(),
+    message: z.string().min(1),
+});
+export const assistantAutomationCursorSchema = z.object({
+    occurredAt: isoTimestampSchema,
+    captureId: z.string().min(1),
+});
+export const assistantAutomationStateSchema = z
+    .object({
+    version: z.literal(2),
+    inboxScanCursor: assistantAutomationCursorSchema.nullable(),
+    autoReplyScanCursor: assistantAutomationCursorSchema.nullable(),
+    autoReplyChannels: z.array(z.string().min(1)),
+    autoReplyBacklogChannels: z.array(z.string().min(1)).default([]),
+    autoReplyPrimed: z.boolean(),
+    updatedAt: isoTimestampSchema,
+})
+    .strict();
+//# sourceMappingURL=assistant-cli-contracts.js.map