@goodandready/dsh-cron 0.2.5 → 0.2.7

package/lib/client.js

@@ -36,6 +36,7 @@ window.__ModuleLoader__.load({
     const ICON_EDIT = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"></path></svg>';
     const ICON_SEND = '<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><line x1="22" y1="2" x2="11" y2="13"></line><polygon points="22 2 15 22 11 13 2 9 22 2"></polygon></svg>';
     const ICON_COPY = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>';
+    const ICON_TUNE = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><line x1="4" y1="21" x2="4" y2="14"></line><line x1="4" y1="10" x2="4" y2="3"></line><line x1="12" y1="21" x2="12" y2="12"></line><line x1="12" y1="8" x2="12" y2="3"></line><line x1="20" y1="21" x2="20" y2="16"></line><line x1="20" y1="12" x2="20" y2="3"></line><line x1="1" y1="14" x2="7" y2="14"></line><line x1="9" y1="8" x2="15" y2="8"></line><line x1="17" y1="16" x2="23" y2="16"></line></svg>';
     const ICON_DOWNLOAD = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="7 10 12 15 17 10"></polyline><line x1="12" y1="15" x2="12" y2="3"></line></svg>';
     const ICON_UPLOAD = '<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path><polyline points="17 8 12 3 7 8"></polyline><line x1="12" y1="3" x2="12" y2="15"></line></svg>';
     const ICON_TELEGRAM = '<svg viewBox="0 0 24 24" width="16" height="16" fill="currentColor" aria-hidden="true"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm4.64 6.8-1.7 8.01c-.13.58-.47.72-.95.45l-2.6-1.92-1.25 1.21c-.14.14-.26.26-.53.26l.19-2.64 4.81-4.35c.21-.19-.05-.29-.32-.11L8.34 13.5 5.78 12.7c-.56-.17-.57-.56.12-.83l10-3.86c.46-.17.87.11.74.79z"/></svg>';
@@ -60,6 +61,8 @@ window.__ModuleLoader__.load({
         'actions.runNowShort': 'Run',
         'actions.edit': 'Edit / Details',
         'actions.duplicate': 'Duplicate task',
+        'actions.tuneWithDsh': 'Tune with DSH',
+        'tune.startFailed': 'Could not start the tuning dialogue: {error}',
         'actions.delete': 'Delete task',
         'duplicate.done': 'Copy created and paused: review its schedule before resuming it.',
         'duplicate.oneShotHint': 'The copy is one-shot and paused — its original time has likely passed, so set a new time before resuming.',
@@ -105,8 +108,11 @@ window.__ModuleLoader__.load({
         'list.typeShell': 'Shell',
         'list.typeLlm': 'LLM',
         'list.oneShot': 'One-shot',
+        'list.configManaged': 'Config',
+        'list.configManagedHint': 'Declared in config.jobs in the profile config file; edit the file to change or remove it',
         'list.next': ' · next: {time}',
         'recs.title': 'Recommended tasks',
+        'recs.hint': 'Ready-to-use recipes. Clicking one opens the form with its fields filled in — nothing is created until you save.',
         'modal.editTitle': 'Edit task',
         'modal.newTitle': 'New scheduled task',
         'modal.statusActive': '● Active',
@@ -170,6 +176,18 @@ window.__ModuleLoader__.load({
         'form.providerDefault': 'Default (DSH)',
         'form.modelLabel': 'LLM model',
         'form.modelDefault': 'Default',
+        'form.silentRuleLabel': 'Silent rule (optional)',
+        'form.silentRulePlaceholder': 'Stay silent when no filesystem is above 80%',
+        'form.silentRuleHint': 'For tasks with output: a cheap model judges the run against this rule and the report is skipped when it says to stay silent. If the model is unavailable or unsure, the report is delivered.',
+        'history.silentSkip': 'stayed silent:',
+        'history.diagnosis': 'Diagnosis',
+        'history.applySuggestion': 'Open the edit form with this suggestion',
+        'form.inspectOnFailureLabel': 'Diagnose failures with a model',
+        'form.inspectOnFailureHint': 'After a failed run a model reads the prompt, the error and the output, and the diagnosis with a proposed prompt change is stored with the run. Nothing is applied automatically.',
+        'settings.inspectorModelLabel': 'Model for failure diagnosis',
+        'form.fallbackModelLabel': 'Fallback model (optional)',
+        'form.fallbackModelPlaceholder': 'e.g. deepseek-reasoner',
+        'form.fallbackModelHint': 'If the run fails on the model above, it is retried once on this model. Both attempts are counted in the cost.',
         'form.promptLabelScript': 'Shell command or script',
         'form.promptLabelLlm': 'Instruction / Prompt for the agent',
         'form.promptPlaceholderScript': 'curl -fsSL https://... || exit 1',
@@ -195,7 +213,7 @@ window.__ModuleLoader__.load({
         'form.channelsHint': 'Pick the channels for this task. An explicit selection overrides the Telegram switch above; leave everything unchecked to fall back to it.',
         'form.templateLabel': 'Message template (optional)',
         'form.templatePlaceholder': '⏰ {title} — {status} in {duration}',
-        'form.templateHint': 'Variables: {title} {id} {status} {output} {error} {duration} {schedule} {time} {tokens} {cost}. Empty = built-in text.',
+        'form.templateHint': 'Variables: {title} {id} {status} {output} {error} {duration} {schedule} {time} {tokens} {cost} {model}. Empty = built-in text.',
         'form.channelTelegram': 'Telegram',
         'form.channelKanban': 'dsh-kanban card',
         'form.channelDiscord': 'Discord',
@@ -213,6 +231,8 @@ window.__ModuleLoader__.load({
         'settings.channelTemplateLabel': 'Template for {channel}',
         'settings.botTokenRefLabel': 'Bot token credential name',
         'settings.botTokenRefPlaceholder': 'e.g. TELEGRAM_BOT_TOKEN',
+        'settings.apiTokenLabel': 'External API token',
+        'settings.apiTokenPlaceholder': 'Bearer token for /dsh-cron/api/* (empty = disabled)',
         'settings.discordLabel': 'Discord webhook URL',
         'settings.slackLabel': 'Slack webhook URL',
         'settings.ntfyUrlLabel': 'ntfy server URL',
@@ -229,6 +249,9 @@ window.__ModuleLoader__.load({
         'settings.templateLabel': 'Default message template',
         'settings.templateHint': 'Applies to every channel without its own template. Empty = built-in text.',
         'settings.deliveryTimeoutMsLabel': 'Delivery timeout per channel (ms)',
+        'settings.automationSection': 'Automation models',
+        'settings.automationHint': 'Models used for the small helper calls (rule evaluation, failure analysis). Leave empty to use the task model.',
+        'settings.silentRuleModelLabel': 'Model for silent rules',
         'settings.secretsOnCard': 'Credentials referenced from the settings panel are shown masked and stored by name.',
         'form.nextRunLabel': 'Next run: ',
         'form.notScheduled': 'not scheduled',
@@ -354,6 +377,9 @@ window.__ModuleLoader__.load({
       { key: 'ntfyTokenRef', labelKey: 'settings.ntfyTokenRefLabel', group: 'secrets' },
       { key: 'pushplusTokenRef', labelKey: 'settings.pushplusTokenRefLabel', group: 'secrets' },
       { key: 'giteaTokenRef', labelKey: 'settings.giteaTokenRefLabel', group: 'secrets' },
+      // The external API is the one surface where a typed secret is the point:
+      // a CI job cannot present a credential reference (#54).
+      { key: 'apiToken', labelKey: 'settings.apiTokenLabel', placeholderKey: 'settings.apiTokenPlaceholder', group: 'secrets' },
       { key: 'discordWebhookUrl', labelKey: 'settings.discordLabel', group: 'channels' },
       { key: 'slackWebhookUrl', labelKey: 'settings.slackLabel', group: 'channels' },
       { key: 'ntfyUrl', labelKey: 'settings.ntfyUrlLabel', group: 'channels' },
@@ -365,6 +391,8 @@ window.__ModuleLoader__.load({
       { key: 'giteaBaseUrl', labelKey: 'settings.giteaBaseUrlLabel', group: 'channels' },
       { key: 'giteaRepo', labelKey: 'settings.giteaRepoLabel', group: 'channels' },
       { key: 'deliveryTimeoutMs', labelKey: 'settings.deliveryTimeoutMsLabel', group: 'channels', numeric: true, defaultValue: 15000, min: 1000 },
+      { key: 'silentRuleModel', labelKey: 'settings.silentRuleModelLabel', group: 'automation' },
+      { key: 'inspectorModel', labelKey: 'settings.inspectorModelLabel', group: 'automation' },
     ];
     const DELIVERY_SETTING_KEYS = DELIVERY_SETTING_FIELDS.map((f) => f.key);
     // The global template plus the per-channel override map (server model).
@@ -436,6 +464,12 @@ window.__ModuleLoader__.load({
             ...DELIVERY_SETTING_FIELDS.filter((f) => f.group === 'channels').map(field)
           ),
         ]),
+        section('automation', 'settings.automationSection', [
+          React.createElement('div', { className: 'dsh-cron-hint', key: 'hint', style: { marginBottom: '10px' } }, T('settings.automationHint')),
+          React.createElement('div', { className: 'dsh-cron-form-row', key: 'row' },
+            ...DELIVERY_SETTING_FIELDS.filter((f) => f.group === 'automation').map(field)
+          ),
+        ]),
         section('templates', 'settings.templatesSection', [
           React.createElement('div', { className: 'dsh-cron-form-group', key: 'global', style: { marginBottom: '10px' } },
             React.createElement('label', null, T('settings.templateLabel')),
@@ -629,6 +663,7 @@ window.__ModuleLoader__.load({
       .dsh-cron-stat-val { font-size: 18px; font-weight: 700; color: var(--dsw-alias-label-primary, #fff); }
       .dsh-cron-stat-lbl { font-size: 12px; color: var(--dsw-alias-label-secondary, #777); margin-top: 0; }
       .dsh-cron-oneshot-tag { display: inline-flex; align-items: center; font-size: 11px; padding: 2px 8px; border-radius: 999px; border: 1px solid var(--dsh-cron-accent); background: var(--dsh-cron-accent-bg); color: var(--dsh-cron-accent); font-weight: 500; }
+      .dsh-cron-config-tag { display: inline-flex; align-items: center; font-size: 11px; padding: 2px 8px; border-radius: 999px; border: 1px solid var(--dsw-alias-border-l2, #444); color: var(--dsw-alias-label-secondary, #ccc); font-weight: 500; }
       .dsh-cron-cost-tag { display: inline-flex; align-items: center; font-size: 11px; padding: 2px 8px; border-radius: 999px; border: 1px solid var(--dsh-cron-success); background: var(--dsh-cron-success-bg); color: var(--dsh-cron-success); font-weight: 500; }
       .dsh-cron-tokens-tag { display: inline-flex; align-items: center; font-size: 11px; padding: 2px 8px; border-radius: 999px; border: 1px solid var(--dsh-cron-info); background: var(--dsh-cron-info-bg); color: var(--dsh-cron-info); }
       .dsh-cron-checkbox-row { display: flex; align-items: center; gap: 8px; font-size: 13px; color: var(--dsw-alias-label-secondary, #ccc); cursor: pointer; user-select: none; }
@@ -778,6 +813,16 @@ window.__ModuleLoader__.load({
       if (status === 'timeout') return T_KEY(t, 'history.statusTimeout');
       return T_KEY(t, 'history.statusFailed');
     }
+
+    /**
+     * A config-declared task is owned by the profile config file (#50): the
+     * panel shows it, but editing, pausing or deleting it here would be undone
+     * at the next start, so the row keeps the source label instead of the
+     * actions that cannot stick.
+     */
+    function isConfigManaged(task) {
+      return Boolean(task) && task.managedBy === 'config';
+    }
     function T_KEY(t, key, vars) {
       return (typeof t === 'function' ? t : translate)(key, vars);
     }
@@ -815,6 +860,9 @@ window.__ModuleLoader__.load({
       const [formPrompt, setFormPrompt] = React.useState('');
       const [formProvider, setFormProvider] = React.useState('');
       const [formModel, setFormModel] = React.useState('');
+      const [formFallbackModel, setFormFallbackModel] = React.useState('');
+      const [formSilentRule, setFormSilentRule] = React.useState('');
+      const [formInspectOnFailure, setFormInspectOnFailure] = React.useState(false);
       const [formDelivery, setFormDelivery] = React.useState('isolated');
       const [selectedTaskMeta, setSelectedTaskMeta] = React.useState(null);
       const [modalTab, setModalTab] = React.useState('params');
@@ -1138,6 +1186,40 @@ window.__ModuleLoader__.load({
         }
       };
 
+      /** #49: tune an existing task in a dialogue instead of editing fields. */
+      const handleTuneWithDsh = async (task) => {
+        const lines = [
+          `Tune the existing scheduled task "${task.title}" (id: ${task.id}).`,
+          'Its current configuration is:',
+          `- type: ${task.type || 'llm'}`,
+          `- schedule: ${task.scheduleText || task.schedule} (${task.schedule})`,
+          `- status: ${task.status}`,
+          task.model ? `- model: ${task.model}${task.fallbackModel ? `, fallback: ${task.fallbackModel}` : ''}` : null,
+          Array.isArray(task.channels) && task.channels.length ? `- channels: ${task.channels.join(', ')}` : null,
+          `- prompt: ${String(task.prompt || '').slice(0, 400)}`,
+          '',
+          'Ask what should change, then apply it with the cron_update_task tool (read the current state again with cron_get_task if you need the full configuration).',
+          'If the change makes the task execute code (script/node/python/ssh/docker), confirm it with me explicitly before applying it.',
+        ].filter(Boolean);
+        try {
+          const res = await fetch('/dsh-cron/chat/start', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ prompt: lines.join(String.fromCharCode(10)) })
+          });
+          const data = await res.json();
+          if (!data.ok || !data.sessionId) {
+            alert(T_KEY(t, 'tune.startFailed', { error: (data && data.error) || '' }));
+            return;
+          }
+          if (onClose) onClose();
+          else toggle.set(false);
+          await openSession(ctx, data.sessionId);
+        } catch (err) {
+          alert(T_KEY(t, 'tune.startFailed', { error: err.message }));
+        }
+      };
+
       const handleDelete = async (id) => {
         if (!confirm(T_KEY(t, 'confirm.delete'))) return;
         try {
@@ -1272,10 +1354,21 @@ window.__ModuleLoader__.load({
         setFormPythonPath('');
         setFormSkillName('');
         setFormWorkflowName('');
+        // Reset before the preset branch, so a recipe keeps what it sets.
+        setFormFallbackModel('');
+        setFormSilentRule('');
+        setFormInspectOnFailure(false);
         if (preset) {
           setFormTitle(preset.title || '');
           setFormSchedule(preset.schedule || '');
           setFormPrompt(preset.prompt || '');
+          // #48: a recipe preset also carries its runtime and delivery shape.
+          if (preset.type) setFormType(preset.type);
+          if (Array.isArray(preset.channels) && preset.channels.length) setFormChannels(preset.channels.filter((c) => DELIVERY_CHANNELS.includes(c)));
+          if (preset.silentRule !== undefined) setFormSilentRule(preset.silentRule || '');
+          if (preset.fallbackModel !== undefined) setFormFallbackModel(preset.fallbackModel || '');
+          if (preset.inspectOnFailure !== undefined) setFormInspectOnFailure(Boolean(preset.inspectOnFailure));
+          setFormOnlyOnFailure(Boolean(preset.onlyOnFailure));
           setFormProvider(defaultModelInfo?.provider || '');
           setFormModel(defaultModelInfo?.model || '');
           if (defaultModelInfo?.provider) loadModels(defaultModelInfo.provider);
@@ -1305,7 +1398,7 @@ window.__ModuleLoader__.load({
         }
       };
 
-      const openEditModal = (task) => {
+      const openEditModal = (task, overrides = {}) => {
         setDropdownOpen(false);
         setFormId(task.id);
         setSelectedTaskMeta(task);
@@ -1313,9 +1406,12 @@ window.__ModuleLoader__.load({
         setFormTitle(task.title || '');
         setFormSchedule(task.schedule || '');
         setFormType(task.type || 'llm');
-        setFormPrompt(task.prompt || '');
+        setFormPrompt(overrides.prompt !== undefined ? overrides.prompt : (task.prompt || ''));
         setFormProvider(task.provider || '');
         setFormModel(task.model || '');
+        setFormFallbackModel(task.fallbackModel || '');
+        setFormSilentRule(task.silentRule || '');
+        setFormInspectOnFailure(Boolean(task.inspectOnFailure));
         setFormDelivery(task.delivery || 'isolated');
         setFormNotifyTelegram(Boolean(task.notifyTelegram));
         setFormChannels(Array.isArray(task.channels) ? task.channels.filter((c) => DELIVERY_CHANNELS.includes(c)) : []);
@@ -1372,6 +1468,9 @@ window.__ModuleLoader__.load({
             delivery: formDelivery || 'isolated',
             provider: isAgentType ? (formProvider || undefined) : undefined,
             model: isAgentType ? (formModel || undefined) : undefined,
+            fallbackModel: isAgentType ? (formFallbackModel.trim() || undefined) : undefined,
+            silentRule: isAgentType ? undefined : formSilentRule.trim(),
+            inspectOnFailure: isAgentType ? Boolean(formInspectOnFailure) : false,
             notifyTelegram: formNotifyTelegram,
             channels: formChannels,
             template: formTemplate.trim(),
@@ -1653,18 +1752,19 @@ window.__ModuleLoader__.load({
                     key: task.id,
                     className: 'dsh-cron-task-item',
                     'data-task-id': task.id,
-                    role: 'button',
-                    tabIndex: 0,
+                    role: isConfigManaged(task) ? undefined : 'button',
+                    tabIndex: isConfigManaged(task) ? undefined : 0,
                     'aria-label': task.title,
-                    onClick: () => openEditModal(task),
-                    onKeyDown: (e) => {
+                    style: isConfigManaged(task) ? { cursor: 'default' } : undefined,
+                    onClick: isConfigManaged(task) ? undefined : () => openEditModal(task),
+                    onKeyDown: isConfigManaged(task) ? undefined : (e) => {
                       if (e.key === 'Enter' || e.key === ' ') {
                         e.preventDefault();
                         openEditModal(task);
                       }
                     }
                   },
-                    React.createElement('button', {
+                    isConfigManaged(task) ? null : React.createElement('button', {
                       type: 'button',
                       className: 'dsh-cron-task-status-btn' + (task.running ? ' dsh-cron-pulse' : ''),
                       'data-active': task.status === 'active' ? 'true' : undefined,
@@ -1683,6 +1783,10 @@ window.__ModuleLoader__.load({
                         }, task.type === 'script' ? T_KEY(t, 'list.typeShell') : T_KEY(t, 'list.typeLlm')),
                         task.model ? React.createElement('span', { className: 'dsh-cron-task-model-tag' }, task.model.split('/').pop()) : null,
                         task.oneShot ? React.createElement('span', { className: 'dsh-cron-oneshot-tag' }, T_KEY(t, 'list.oneShot')) : null,
+                        isConfigManaged(task) ? React.createElement('span', {
+                          className: 'dsh-cron-config-tag',
+                          title: T_KEY(t, 'list.configManagedHint')
+                        }, T_KEY(t, 'list.configManaged')) : null,
                         task.totalCostUsd > 0 ? React.createElement('span', { className: 'dsh-cron-cost-tag' }, '$' + task.totalCostUsd.toFixed(4)) : null,
                         task.totalTokens > 0 ? React.createElement('span', { className: 'dsh-cron-tokens-tag' }, (task.totalTokens > 1000 ? Math.round(task.totalTokens / 1000) + 'k' : task.totalTokens) + ' tok') : null
                       ),
@@ -1708,21 +1812,28 @@ window.__ModuleLoader__.load({
                         title: T_KEY(t, 'actions.runNow'),
                         onClick: () => handleRunNow(task.id)
                       }, T_KEY(t, 'actions.runNowShort')),
-                      React.createElement('button', {
+                      isConfigManaged(task) ? null : React.createElement('button', {
                         type: 'button',
                         className: 'dsh-cron-icon-btn',
                         title: T_KEY(t, 'actions.edit'),
                         'aria-label': T_KEY(t, 'actions.edit'),
                         onClick: () => openEditModal(task)
                       }, React.createElement('span', svgProps(ICON_EDIT))),
-                      React.createElement('button', {
+                      isConfigManaged(task) ? null : React.createElement('button', {
+                        type: 'button',
+                        className: 'dsh-cron-icon-btn',
+                        title: T_KEY(t, 'actions.tuneWithDsh'),
+                        'aria-label': T_KEY(t, 'actions.tuneWithDsh'),
+                        onClick: () => handleTuneWithDsh(task)
+                      }, React.createElement('span', svgProps(ICON_TUNE))),
+                      isConfigManaged(task) ? null : React.createElement('button', {
                         type: 'button',
                         className: 'dsh-cron-icon-btn',
                         title: T_KEY(t, 'actions.duplicate'),
                         'aria-label': T_KEY(t, 'actions.duplicate'),
                         onClick: () => handleDuplicate(task)
                       }, React.createElement('span', svgProps(ICON_COPY))),
-                      React.createElement('button', {
+                      isConfigManaged(task) ? null : React.createElement('button', {
                         type: 'button',
                         className: 'dsh-cron-icon-btn dsh-cron-danger',
                         title: T_KEY(t, 'actions.delete'),
@@ -1734,6 +1845,7 @@ window.__ModuleLoader__.load({
                 )
           ),
           React.createElement('div', { className: 'dsh-cron-recs-title' }, T_KEY(t, 'recs.title')),
+          React.createElement('div', { className: 'dsh-cron-hint', style: { marginBottom: '8px' } }, T_KEY(t, 'recs.hint')),
           React.createElement('div', { className: 'dsh-cron-recs-list' },
             recs.map((rec) =>
               React.createElement('div', {
@@ -1820,6 +1932,35 @@ window.__ModuleLoader__.load({
                           React.createElement('span', { style: { color: 'var(--dsw-alias-label-tertiary, #888)', fontSize: '11.5px' } }, (run.durationMs || 0) + ' ms')
                         )
                       ),
+                      // #43: a diagnosed failure shows what went wrong and
+                      // offers to prefill the prompt with the suggestion.
+                      run.diagnosis && React.createElement('div', {
+                        className: 'dsh-cron-status-banner',
+                        'data-type': 'info',
+                        style: { marginTop: '8px', display: 'flex', flexDirection: 'column', gap: '6px' }
+                      },
+                        React.createElement('div', null,
+                          React.createElement('strong', null, T_KEY(t, 'history.diagnosis')),
+                          run.confidence ? ` (${run.confidence})` : ''
+                        ),
+                        React.createElement('div', null, run.diagnosis),
+                        run.suggestion && React.createElement('div', null,
+                          React.createElement('button', {
+                            type: 'button',
+                            className: 'dsh-cron-btn-secondary',
+                            style: { padding: '2px 8px', fontSize: '12px' },
+                            onClick: () => openEditModal(selectedTaskMeta, { prompt: run.suggestion })
+                          }, T_KEY(t, 'history.applySuggestion'))
+                        )
+                      ),
+                      // #44: a run suppressed by its silent rule says why.
+                      run.silentSkip && React.createElement('div', {
+                        className: 'dsh-cron-hint',
+                        style: { display: 'flex', gap: '6px', alignItems: 'center' }
+                      },
+                        React.createElement('span', { className: 'dsh-cron-badge-ref' }, T_KEY(t, 'history.silentSkip')),
+                        React.createElement('span', null, run.silentReason || '')
+                      ),
                       run.output && React.createElement('div', { className: 'dsh-cron-history-output' }, run.output),
                       run.error && React.createElement('div', { className: 'dsh-cron-history-output', style: { color: 'var(--dsh-cron-danger)', borderColor: 'var(--dsh-cron-danger-bg)' } }, run.error),
                       run.sessionId && React.createElement('button', {
@@ -1982,7 +2123,28 @@ window.__ModuleLoader__.load({
                       React.createElement('option', { value: '' }, T_KEY(t, 'form.modelDefault')),
                       models.map((m) => React.createElement('option', { key: m.id, value: m.id }, m.name || m.id))
                     )
-                  )
+                  ),
+                  // #45: one retry on a stronger model when the cheap one fails.
+                  React.createElement('div', { className: 'dsh-cron-form-group' },
+                    React.createElement('label', null, T_KEY(t, 'form.fallbackModelLabel')),
+                    React.createElement('input', {
+                      type: 'text',
+                      value: formFallbackModel,
+                      placeholder: T_KEY(t, 'form.fallbackModelPlaceholder'),
+                      onChange: (e) => setFormFallbackModel(e.target.value)
+                    }),
+                    React.createElement('div', { className: 'dsh-cron-hint' }, T_KEY(t, 'form.fallbackModelHint'))
+                  ),
+                  // #43: diagnose failures with a model.
+                  React.createElement('label', { className: 'dsh-cron-checkbox-row', style: { marginTop: '4px' } },
+                    React.createElement('input', {
+                      type: 'checkbox',
+                      checked: formInspectOnFailure,
+                      onChange: (e) => setFormInspectOnFailure(e.target.checked)
+                    }),
+                    React.createElement('span', null, T_KEY(t, 'form.inspectOnFailureLabel'))
+                  ),
+                  formInspectOnFailure && React.createElement('div', { className: 'dsh-cron-hint' }, T_KEY(t, 'form.inspectOnFailureHint'))
                 ),
                 formType === 'http' && React.createElement('div', { className: 'dsh-cron-form-row' },
                   React.createElement('div', { className: 'dsh-cron-form-group' },
@@ -2204,6 +2366,17 @@ window.__ModuleLoader__.load({
                       onChange: (e) => setFormTemplate(e.target.value)
                     }),
                     React.createElement('div', { className: 'dsh-cron-hint' }, T_KEY(t, 'form.templateHint'))
+                  ),
+                  // #44: output-producing runtimes may stay silent by rule.
+                  !AGENT_FORM_TYPES.includes(formType) && React.createElement('div', { className: 'dsh-cron-form-group', style: { marginTop: '12px', marginBottom: 0 } },
+                    React.createElement('label', null, T_KEY(t, 'form.silentRuleLabel')),
+                    React.createElement('input', {
+                      type: 'text',
+                      value: formSilentRule,
+                      placeholder: T_KEY(t, 'form.silentRulePlaceholder'),
+                      onChange: (e) => setFormSilentRule(e.target.value)
+                    }),
+                    React.createElement('div', { className: 'dsh-cron-hint' }, T_KEY(t, 'form.silentRuleHint'))
                   )
                 ),
                 selectedTaskMeta && React.createElement('div', {

package/lib/config-jobs.js

@@ -0,0 +1,206 @@
+/**
+ * Jobs declared in the profile config (#50, ADR-0001).
+ *
+ * The config file owns the jobs it declares: at startup every declared job is
+ * created or updated, and a job that disappears from the config is removed.
+ * Tasks created by a user through the UI, the REST API or an agent tool are
+ * never touched — when a declared id collides with one of them the entry is
+ * skipped and reported, because silently overwriting a user's task is worse
+ * than a visible conflict.
+ *
+ * Entries are validated one by one with a precise message, so one broken job
+ * cannot take the plugin down or stop the remaining jobs from syncing.
+ */
+
+import { normalizeTaskType, CODE_EXECUTING_TYPES } from './runtimes.js';
+import { parseScheduleExpression } from './scheduler.js';
+import { unknownChannelIds } from './channels.js';
+import { PATCHABLE_TASK_FIELDS, validateTaskType } from './task-transfer.js';
+import { pickPatchableFields } from './http-utils.js';
+
+/** Marker that makes a task owned by the config (#50). */
+export const MANAGED_BY_CONFIG = 'config';
+
+/**
+ * One message for every surface that refuses to change a config-owned task, so
+ * the panel, the REST routes, the tools and the external API all say the same
+ * thing about where the task really lives.
+ */
+export function configOwnedMessage(id) {
+  return 'Task "' + id + '" is declared in the profile config (config.jobs); change the config file instead';
+}
+
+/** True when a stored task is owned by the config file. */
+export function isConfigOwned(task) {
+  return Boolean(task) && task.managedBy === MANAGED_BY_CONFIG;
+}
+
+/**
+ * Fields an entry may pass through, minus the ones the sync handles itself:
+ * identity, the parsed schedule and the derived one-shot flag.
+ */
+const PASSTHROUGH_FIELDS = PATCHABLE_TASK_FIELDS.filter(
+  (key) => !['title', 'schedule', 'prompt', 'type', 'status', 'oneShot'].includes(key)
+);
+
+/**
+ * Task types whose payload is the prompt itself (see validateTaskType).
+ * ssh and docker are included because their dedicated fields only describe how
+ * to connect or which image to use — without a prompt the runner executes
+ * `true`, which reports success while doing nothing. http is excluded on
+ * purpose: it accepts the target in httpUrl.
+ */
+const PROMPT_TYPES = ['script', 'node', 'python', 'ssh', 'docker', 'llm', 'skill', 'workflow'];
+
+function reject(index, message) {
+  return { ok: false, error: 'config.jobs[' + index + ']: ' + message };
+}
+
+/**
+ * Validate one declared job and turn it into a task record. Returns
+ * `{ ok: false, error }` with the entry index so the operator can find it.
+ */
+export function buildConfigJob(entry, index = 0) {
+  if (!entry || typeof entry !== 'object') return reject(index, 'entry must be an object');
+
+  const id = String(entry.id || '').trim();
+  if (!id) return reject(index, 'id is required');
+  if (!String(entry.title || '').trim()) return reject(index, 'title is required');
+  if (!String(entry.schedule || '').trim()) return reject(index, 'schedule is required');
+
+  const unknown = unknownChannelIds(entry.channels);
+  if (unknown.length) return reject(index, 'unknown channel ids: ' + unknown.join(', '));
+
+  const type = normalizeTaskType(entry.type || 'llm');
+  // These types carry their payload in the prompt: a job declared without one
+  // would be created, armed and report success while doing nothing.
+  if (PROMPT_TYPES.includes(type) && !String(entry.prompt || '').trim()) {
+    return reject(index, type + ' jobs require a non-empty prompt (the command or instruction to run)');
+  }
+  let parsed;
+  try {
+    parsed = parseScheduleExpression(entry.schedule);
+  } catch (err) {
+    return reject(index, 'invalid schedule: ' + err.message);
+  }
+
+  const job = {
+    ...pickPatchableFields(entry, PASSTHROUGH_FIELDS),
+    id,
+    title: String(entry.title),
+    type,
+    status: entry.status === 'paused' ? 'paused' : 'active',
+    schedule: parsed.cronPattern || String(entry.schedule).trim(),
+    scheduleText: parsed.humanText,
+    oneShot: Boolean(parsed.isOneShot),
+    managedBy: MANAGED_BY_CONFIG,
+  };
+  if (entry.prompt !== undefined) job.prompt = String(entry.prompt);
+
+  const typeError = validateTaskType(type, job);
+  if (typeError) return reject(index, typeError);
+  return { ok: true, job };
+}
+
+/**
+ * Names of the config-owned fields in which the stored task differs from the
+ * declared job. An empty list means the stored task is already in sync.
+ */
+export function diffConfigJob(stored, declared) {
+  const changed = [];
+  for (const key of Object.keys(declared)) {
+    if (key === 'id' || key === 'managedBy') continue;
+    const next = declared[key];
+    const prev = stored ? stored[key] : undefined;
+    const same = Array.isArray(next)
+      ? Array.isArray(prev) && next.length === prev.length && next.every((value, i) => value === prev[i])
+      : next === prev;
+    if (!same) changed.push(key);
+  }
+  return changed;
+}
+
+/** Decide what the sync would create, update and remove. Pure, for tests. */
+export function planConfigSync(entries, existingTasks) {
+  const list = Array.isArray(entries) ? entries : [];
+  const existing = new Map((Array.isArray(existingTasks) ? existingTasks : []).map((task) => [task.id, task]));
+  const plan = { create: [], update: [], remove: [], skipped: [], warnings: [] };
+  const declaredIds = new Set();
+
+  list.forEach((entry, index) => {
+    // An entry keeps its id "declared" even when the rest of it is invalid:
+    // otherwise one typo in a schedule would look like "the job was removed
+    // from the config" and the sync would delete the working task.
+    const rawId = entry && typeof entry === 'object' && entry.id !== undefined ? String(entry.id).trim() : '';
+    if (rawId) declaredIds.add(rawId);
+
+    const built = buildConfigJob(entry, index);
+    if (!built.ok) {
+      plan.skipped.push({ index, error: built.error });
+      return;
+    }
+    const job = built.job;
+    declaredIds.add(job.id);
+
+    const stored = existing.get(job.id);
+    if (!stored) {
+      plan.create.push(job);
+    } else if (stored.managedBy !== MANAGED_BY_CONFIG) {
+      plan.skipped.push({
+        index,
+        id: job.id,
+        error: 'config.jobs[' + index + ']: a task with id "' + job.id + '" exists but is not managed by the config; it was left untouched',
+      });
+    } else {
+      const changed = diffConfigJob(stored, job);
+      if (changed.length) plan.update.push({ job, changed });
+    }
+
+    if (CODE_EXECUTING_TYPES.includes(job.type)) {
+      plan.warnings.push('job "' + job.id + '" executes code (' + job.type + '); the config file is its only source');
+    }
+  });
+
+  for (const task of existing.values()) {
+    if (task.managedBy === MANAGED_BY_CONFIG && !declaredIds.has(task.id)) plan.remove.push(task.id);
+  }
+  return plan;
+}
+
+/**
+ * Apply the plan: create, update and remove tasks, then arm or pause them.
+ * Never throws for a single bad entry — that entry is reported and skipped.
+ */
+export function applyConfigSync({ store, scheduler, entries, log = console }) {
+  const plan = planConfigSync(entries, store.list({ status: 'all' }));
+  for (const warning of plan.warnings) log.warn('[dsh-cron] config jobs: ' + warning);
+  for (const entry of plan.skipped) log.error('[dsh-cron] config jobs: skipped: ' + entry.error);
+
+  let created = 0;
+  let updated = 0;
+  let removed = 0;
+
+  for (const job of plan.create) {
+    const task = store.set({ ...job });
+    if (task.status === 'active') scheduler.scheduleTask(task);
+    created += 1;
+  }
+
+  for (const item of plan.update) {
+    const current = store.get(item.job.id);
+    const task = store.set({ ...current, ...item.job, id: item.job.id });
+    if (task.status === 'active') scheduler.scheduleTask(task);
+    else scheduler.pauseTask(task.id);
+    updated += 1;
+    log.log('[dsh-cron] config job "' + task.id + '" updated: ' + item.changed.join(', '));
+  }
+
+  for (const id of plan.remove) {
+    scheduler.pauseTask(id);
+    store.delete(id);
+    removed += 1;
+    log.log('[dsh-cron] config job "' + id + '" removed: it is no longer declared');
+  }
+
+  return { created, updated, removed, skipped: plan.skipped.length };
+}