clementine-agent 1.18.103 → 1.18.105

package/dist/agent/draft-store.d.ts

@@ -0,0 +1,57 @@
+/**
+ * PRD §11 Phase 5b / 1.18.105 — Draft store for cron tasks.
+ *
+ * Drafts live alongside CRON.md (the published source of truth) but in a
+ * separate per-task JSON sidecar at ~/.clementine/cron-drafts/<safe>.json.
+ * Schedule firing always reads CRON.md, so a draft never accidentally
+ * goes live until the user clicks Publish.
+ *
+ * Why a sidecar instead of editing CRON.md and gating with frontmatter:
+ * - One CRON.md edit = many tasks affected. Drafts are per-task by design.
+ * - Sidecars survive even if CRON.md gets rewritten (e.g. by an agent).
+ * - The published-vs-draft diff is a clean two-document compare.
+ *
+ * Tradeoff: a draft can become "orphaned" if its base task gets renamed.
+ * We detect this via basedOnName and surface a banner in the editor when
+ * we can't find the published peer. Manual cleanup via DELETE /api/cron/
+ * :name/draft.
+ */
+import type { CronJobDefinition } from '../types.js';
+/** Stable hash of a job def — used to detect drift between when the draft
+ *  was created and the current published version. If the published task
+ *  changed under the draft (someone else edited it), we surface a warning
+ *  and ask the user if they want to rebase. */
+export declare function hashJobDef(def: CronJobDefinition): string;
+export interface DraftRecord {
+    /** Task name this draft belongs to. Matches the published task's name
+     *  (renames detach the draft — the user must republish to a new name). */
+    name: string;
+    /** Full job def the user is staging. Same shape as CronJobDefinition. */
+    draft: CronJobDefinition;
+    /** ISO timestamp of last save. */
+    savedAt: string;
+    /** Author marker. 'dashboard' for UI saves; future channels may add their
+     *  own values. */
+    changedBy: string;
+    /** Hash of the published def at the time the draft was first created.
+     *  If the live published def hashes to something different now, the
+     *  draft is "rebased" — the editor surfaces a banner. */
+    basedOnPublishedHash: string | null;
+}
+export declare function getDraft(name: string): DraftRecord | null;
+export declare function saveDraft(record: DraftRecord): void;
+export declare function deleteDraft(name: string): boolean;
+export declare function listDraftNames(): string[];
+/** Compute draft state vs current published def. The badge in the editor
+ *  reads this directly — four states matching the n8n flow:
+ *    none           = no draft sidecar, task is on its published version
+ *    draft          = draft exists, no published peer (new task being created)
+ *    ready          = draft + published peer; draft != published
+ *    up_to_date     = draft + published peer; draft hashes match published
+ *    rebase_needed  = draft + published peer; published has drifted since draft was created
+ */
+export type DraftBadgeState = 'none' | 'draft' | 'ready' | 'up_to_date' | 'rebase_needed';
+export declare function computeBadgeState(name: string, publishedDef: CronJobDefinition | null): DraftBadgeState;
+/** Test-only: where we read/write drafts. Tests use a clean tmpdir. */
+export declare function _draftDirForTests(): string;
+//# sourceMappingURL=draft-store.d.ts.map

package/dist/agent/draft-store.js

@@ -0,0 +1,113 @@
+/**
+ * PRD §11 Phase 5b / 1.18.105 — Draft store for cron tasks.
+ *
+ * Drafts live alongside CRON.md (the published source of truth) but in a
+ * separate per-task JSON sidecar at ~/.clementine/cron-drafts/<safe>.json.
+ * Schedule firing always reads CRON.md, so a draft never accidentally
+ * goes live until the user clicks Publish.
+ *
+ * Why a sidecar instead of editing CRON.md and gating with frontmatter:
+ * - One CRON.md edit = many tasks affected. Drafts are per-task by design.
+ * - Sidecars survive even if CRON.md gets rewritten (e.g. by an agent).
+ * - The published-vs-draft diff is a clean two-document compare.
+ *
+ * Tradeoff: a draft can become "orphaned" if its base task gets renamed.
+ * We detect this via basedOnName and surface a banner in the editor when
+ * we can't find the published peer. Manual cleanup via DELETE /api/cron/
+ * :name/draft.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+/** Read BASE_DIR fresh on every call so tests can swap CLEMENTINE_HOME
+ *  per-test without the module cache sticking the value at import time. */
+function draftDir() {
+    const base = process.env.CLEMENTINE_HOME || path.join(os.homedir(), '.clementine');
+    return path.join(base, 'cron-drafts');
+}
+function safeName(name) {
+    // Mirror the convention used by CronRunLog.runs/<safe>.jsonl so users
+    // can grep for related files easily.
+    return String(name).replace(/[^a-zA-Z0-9_:-]/g, '_').slice(0, 128);
+}
+function draftPath(name) {
+    return path.join(draftDir(), safeName(name) + '.json');
+}
+/** Stable hash of a job def — used to detect drift between when the draft
+ *  was created and the current published version. If the published task
+ *  changed under the draft (someone else edited it), we surface a warning
+ *  and ask the user if they want to rebase. */
+export function hashJobDef(def) {
+    const canonical = JSON.stringify(def, Object.keys(def).sort());
+    return createHash('sha256').update(canonical).digest('hex').slice(0, 16);
+}
+export function getDraft(name) {
+    const file = draftPath(name);
+    if (!existsSync(file))
+        return null;
+    try {
+        const raw = readFileSync(file, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveDraft(record) {
+    if (!record.name)
+        throw new Error('draft.name is required');
+    if (!record.draft || typeof record.draft !== 'object')
+        throw new Error('draft.draft (job def) is required');
+    mkdirSync(draftDir(), { recursive: true });
+    const file = draftPath(record.name);
+    writeFileSync(file, JSON.stringify(record, null, 2) + '\n');
+}
+export function deleteDraft(name) {
+    const file = draftPath(name);
+    if (!existsSync(file))
+        return false;
+    try {
+        unlinkSync(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function listDraftNames() {
+    const dir = draftDir();
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => f.replace(/\.json$/, ''));
+    }
+    catch {
+        return [];
+    }
+}
+export function computeBadgeState(name, publishedDef) {
+    const d = getDraft(name);
+    if (!d)
+        return 'none';
+    if (!publishedDef)
+        return 'draft';
+    const publishedHash = hashJobDef(publishedDef);
+    const draftHash = hashJobDef(d.draft);
+    if (publishedHash === draftHash)
+        return 'up_to_date';
+    // Drift detection: if the draft was based on a published version we no
+    // longer recognise, surface "rebase needed". This covers two scenarios:
+    // (a) someone else edited the published def, (b) the user published
+    // through a different surface and forgot to discard the draft.
+    if (d.basedOnPublishedHash && d.basedOnPublishedHash !== publishedHash)
+        return 'rebase_needed';
+    return 'ready';
+}
+/** Test-only: where we read/write drafts. Tests use a clean tmpdir. */
+export function _draftDirForTests() {
+    return draftDir();
+}
+//# sourceMappingURL=draft-store.js.map

package/dist/cli/dashboard.js

@@ -4600,6 +4600,156 @@ export async function cmdDashboard(opts) {
     // tasks should pay the small per-tool overhead of curl-on-every-event)
     // and the installer refuses to overwrite a settings.local.json that
     // wasn't created by us.
+    // ── PRD §11 Phase 5b / 1.18.105: Draft / Publish endpoints ────────
+    // Tasks support per-task draft sidecars at ~/.clementine/cron-drafts/.
+    // The schedule fires off CRON.md only — drafts never go live until
+    // POST /publish promotes them. Five endpoints cover the n8n-style flow:
+    //   GET /api/cron/:job/draft       — current draft + badge state
+    //   POST /api/cron/:job/draft      — save/replace the draft
+    //   POST /api/cron/:job/publish    — promote draft to CRON.md
+    //   DELETE /api/cron/:job/draft    — discard the draft
+    //   GET /api/cron/drafts           — list all drafted task names
+    app.get('/api/cron/drafts', async (_req, res) => {
+        try {
+            const { listDraftNames } = await import('../agent/draft-store.js');
+            res.json({ ok: true, names: listDraftNames() });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    app.get('/api/cron/:job/draft', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const { parseCronJobs } = await import('../gateway/cron-scheduler.js');
+            const { getDraft, computeBadgeState } = await import('../agent/draft-store.js');
+            const draft = getDraft(jobName);
+            const published = parseCronJobs().find((j) => String(j.name).toLowerCase() === jobName.toLowerCase()) ?? null;
+            const badge = computeBadgeState(jobName, published);
+            res.json({ ok: true, draft, published, badge });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    app.post('/api/cron/:job/draft', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const body = (req.body ?? {});
+            const draftDef = body.draft;
+            if (!draftDef || typeof draftDef !== 'object') {
+                res.status(400).json({ ok: false, error: 'draft (job def) required in body' });
+                return;
+            }
+            // Force the draft's name to match the URL param so a stale UI can't
+            // retarget. Mostly defensive — the editor wouldn't call here with a
+            // mismatched name, but be paranoid.
+            draftDef.name = jobName;
+            const { parseCronJobs } = await import('../gateway/cron-scheduler.js');
+            const { saveDraft, hashJobDef } = await import('../agent/draft-store.js');
+            const published = parseCronJobs().find((j) => String(j.name).toLowerCase() === jobName.toLowerCase()) ?? null;
+            saveDraft({
+                name: jobName,
+                draft: draftDef,
+                savedAt: new Date().toISOString(),
+                changedBy: typeof body.changedBy === 'string' ? body.changedBy : 'dashboard',
+                basedOnPublishedHash: published ? hashJobDef(published) : null,
+            });
+            res.json({ ok: true, message: published ? 'Draft saved.' : 'Draft saved (no published version yet — Publish to make it live).' });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    app.delete('/api/cron/:job/draft', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const { deleteDraft } = await import('../agent/draft-store.js');
+            const removed = deleteDraft(jobName);
+            res.json({ ok: true, removed, message: removed ? 'Draft discarded.' : 'No draft to discard.' });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    app.post('/api/cron/:job/publish', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const { getDraft, deleteDraft } = await import('../agent/draft-store.js');
+            const record = getDraft(jobName);
+            if (!record) {
+                res.status(404).json({ ok: false, error: `No draft for "${jobName}". Save changes as a draft first.` });
+                return;
+            }
+            // Promote: write the draft def into CRON.md by re-using the
+            // dashboard's existing readCronFileAt / writeCronFileAt helpers
+            // (defined alongside POST /api/cron). Find the matching job entry
+            // and overwrite in place; if no match, append.
+            try {
+                // Agent-scoped tasks ("<agent>:<jobname>") live in their own
+                // agents/<agent>/CRON.md. Detect via the slug prefix to pick the
+                // right file.
+                const draftDef = record.draft;
+                let targetFile = CRON_FILE;
+                const slugMatch = jobName.match(/^([a-z0-9_-]+):(.+)$/i);
+                if (draftDef.agent || slugMatch) {
+                    const slug = String(draftDef.agent ?? slugMatch?.[1] ?? '');
+                    if (slug && slug !== 'clementine') {
+                        targetFile = path.join(VAULT_DIR, '00-System', 'agents', slug, 'CRON.md');
+                    }
+                }
+                const { parsed, jobs } = readCronFileAt(targetFile);
+                const idx = jobs.findIndex((j) => String(j.name ?? '').toLowerCase() === jobName.toLowerCase());
+                // Strip our internal-only fields before writing CRON.md so we
+                // don't pollute the canonical file with hash sidecars etc.
+                const cleanDraft = { ...record.draft };
+                if (idx >= 0)
+                    jobs[idx] = cleanDraft;
+                else
+                    jobs.push(cleanDraft);
+                writeCronFileAt(targetFile, parsed, jobs);
+            }
+            catch (writeErr) {
+                res.status(500).json({ ok: false, error: 'failed to write CRON.md: ' + String(writeErr) });
+                return;
+            }
+            deleteDraft(jobName);
+            // Hot-reload the scheduler so the new published def takes effect on
+            // the next tick instead of waiting for the next file scan.
+            try {
+                const gw = await getGateway();
+                const sched = gw.cronScheduler;
+                if (sched && typeof sched.reloadJobs === 'function')
+                    sched.reloadJobs();
+            }
+            catch { /* non-fatal */ }
+            // Broadcast so other tabs refresh task cards immediately.
+            try {
+                broadcastEvent({ type: 'cron_published', data: { job: jobName } });
+            }
+            catch { /* non-fatal */ }
+            res.json({ ok: true, message: `Published "${jobName}". Schedule fires from this version starting now.` });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
     app.get('/api/cron/:job/hooks-status', async (req, res) => {
         try {
             const jobName = req.params.job;
@@ -5916,6 +6066,90 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             res.status(500).json({ ok: false, error: String(err) });
         }
     });
+    // ── PRD §12 Phase 6.3 / 1.18.104: real latency split ─────────────
+    // Aggregates per-run tool durations from the event store so the
+    // Latency mini-card can show real numbers (model API time / tool
+    // execution time / framework overhead) instead of the heuristic
+    // placeholder. Only runs with path B hook events contribute to the
+    // tool-time numerator; the dashboard falls back to the heuristic
+    // when coverage is too low.
+    //
+    // Implementation note: walking N event-log files is O(events) but
+    // the data is tiny (hundreds of KB per run, mostly text). For 7d of
+    // runs this is well under 100ms even with hundreds of runs. If it
+    // gets slow we'll add an in-memory cache keyed on the file mtime.
+    app.get('/api/runs/latency-summary', async (req, res) => {
+        try {
+            const windowHours = Math.max(1, Math.min(168, parseInt(String(req.query.windowHours ?? '168'), 10) || 168));
+            const cutoffMs = Date.now() - windowHours * 60 * 60 * 1000;
+            const log = new CronRunLog();
+            const runs = log.readAllRecent(500, 30);
+            const inWindow = runs.filter((r) => {
+                const t = r.startedAt ? new Date(r.startedAt).getTime() : 0;
+                return t >= cutoffMs && r.status === 'ok' && typeof r.durationMs === 'number';
+            });
+            const { EventLog } = await import('../gateway/event-log.js');
+            const eventLog = new EventLog();
+            const summaries = [];
+            let withHooks = 0;
+            let totalDurationMs = 0;
+            let totalToolMs = 0;
+            for (const r of inWindow) {
+                const runId = r.id;
+                if (!runId)
+                    continue;
+                const events = eventLog.readByRun(runId);
+                let toolMs = 0;
+                let calls = 0;
+                let hasHook = false;
+                for (const ev of events) {
+                    // Path B PostToolUse fires after every tool with duration_ms set
+                    // (see hook-event ingest endpoint in 1.18.101). The kind='hook'
+                    // + hookEventName='PostToolUse' combo is what we sum.
+                    const e = ev;
+                    if (e.kind === 'hook' && e.hookEventName === 'PostToolUse' && typeof e.durationMs === 'number') {
+                        toolMs += e.durationMs;
+                        calls += 1;
+                        hasHook = true;
+                    }
+                }
+                const durationMs = r.durationMs ?? 0;
+                summaries.push({ runId, durationMs, toolDurationMs: toolMs, toolCalls: calls, hasHookData: hasHook });
+                if (hasHook) {
+                    withHooks += 1;
+                    totalDurationMs += durationMs;
+                    totalToolMs += toolMs;
+                }
+            }
+            // Coverage percentage: how many runs in the window contributed real data.
+            const coverage = inWindow.length > 0 ? withHooks / inWindow.length : 0;
+            // Average splits across runs that DID have hook data. The model
+            // segment is what's left after tools + a small framework overhead
+            // (we use 5% as a conservative estimate for SDK plumbing time —
+            // real measurement of this needs a tighter timing pass that we'll
+            // add when path B's SessionStart/Stop events get duration_ms too).
+            const avgDurationMs = withHooks > 0 ? totalDurationMs / withHooks : 0;
+            const avgToolMs = withHooks > 0 ? totalToolMs / withHooks : 0;
+            const overheadFraction = 0.05;
+            const overheadMs = avgDurationMs * overheadFraction;
+            const modelMs = Math.max(0, avgDurationMs - avgToolMs - overheadMs);
+            res.json({
+                ok: true,
+                windowHours,
+                runsTotal: inWindow.length,
+                runsWithHooks: withHooks,
+                coverage,
+                avgDurationMs,
+                avgToolMs,
+                avgModelMs: modelMs,
+                avgOverheadMs: overheadMs,
+                summaries,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
     // ── Recent runs across ALL cron jobs ───────────────────────────
     // Powers the "Recent History" zone on the Tasks page. Returns the most
     // recent N CronRunEntry rows merged from every per-job .jsonl, sorted
@@ -21095,8 +21329,18 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
              when editing a saved task (set by openEditCronModal). Disabled
              during an in-flight run. -->
         <button class="btn btn-sm btn-success" id="cron-run-once-btn" onclick="runCronOnceFromModal()" style="display:none;font-size:12px;padding:6px 14px">▶ Run task once</button>
+        <!-- PRD §11 Phase 5b / 1.18.105: draft state badge. Updates via
+             refreshCronDraftBadge(jobName) after every save / load /
+             publish / discard. -->
+        <span id="cron-draft-badge" style="display:none;font-size:11px;padding:3px 8px;border-radius:999px;font-weight:500"></span>
       </div>
       <button onclick="closeCronModal()">Cancel</button>
+      <!-- PRD §11 Phase 5b / 1.18.105: Save as draft / Publish split for
+           saved tasks. Visible only when editing an already-published
+           task (cron-modal-save is hidden for those). -->
+      <button class="btn btn-sm" id="cron-discard-draft-btn" onclick="discardCronDraft()" style="display:none;font-size:12px;padding:6px 12px">Discard draft</button>
+      <button class="btn btn-sm" id="cron-save-draft-btn" onclick="saveCronAsDraft()" style="display:none;font-size:12px;padding:6px 14px">Save as draft</button>
+      <button class="btn-primary" id="cron-publish-btn" onclick="publishCronDraft()" style="display:none">Publish</button>
       <button class="btn-primary" id="cron-modal-save" onclick="saveCronJob()">Create Task</button>
     </div>
   </div>
@@ -24615,20 +24859,38 @@ async function refreshMiniDashboards() {
   var costFigure = totalCost7 < 0.01 ? '$' + totalCost7.toFixed(4) : '$' + totalCost7.toFixed(2);
 
   // ── Latency split card ─────────────────────────────────────────────
-  // Sum durationMs across last7 OK runs only — we don't yet have a clean
-  // signal for tool time per run. Until path B hooks land we approximate:
-  //   tool ~ 35%, model ~ 55%, overhead ~ 10% — these are placeholders
-  //   that get replaced with real values once PostToolUse durations are
-  //   summed from event logs (Phase 4d).
+  // PRD §12 Phase 6.3 / 1.18.104: real latency split when path B hooks
+  // are providing PostToolUse duration_ms data. Falls back to the
+  // heuristic placeholder when coverage is too low.
   var okRuns = last7.filter(function(rn) { return rn.status === 'ok' && typeof rn.durationMs === 'number'; });
   var avgDur = okRuns.length > 0
     ? Math.round(okRuns.reduce(function(a, b) { return a + b.durationMs; }, 0) / okRuns.length)
     : 0;
+  // Default to heuristic split.
   var latToolPct = 35, latModelPct = 55, latOverPct = 10;
+  var latencyMode = 'heuristic'; // becomes 'real' if coverage >= 50%
+  var coverageLabel = '';
+  try {
+    var lr = await apiFetch('/api/runs/latency-summary?windowHours=168');
+    var ld = await lr.json();
+    if (ld && ld.ok && ld.coverage >= 0.5 && ld.avgDurationMs > 0) {
+      var totalMs = ld.avgDurationMs;
+      latToolPct = Math.round((ld.avgToolMs / totalMs) * 100);
+      latModelPct = Math.round((ld.avgModelMs / totalMs) * 100);
+      latOverPct = Math.max(0, 100 - latToolPct - latModelPct);
+      avgDur = Math.round(ld.avgDurationMs);
+      latencyMode = 'real';
+      coverageLabel = ld.runsWithHooks + '/' + ld.runsTotal + ' runs · path B';
+    } else if (ld && ld.ok) {
+      coverageLabel = ld.coverage > 0
+        ? Math.round(ld.coverage * 100) + '% coverage — need 50%+ for real split'
+        : 'no path B data yet';
+    }
+  } catch (e) { /* fall through to heuristic */ }
   var splitHtml = '<div class="mini-split">'
-    + '<div class="mini-split-seg" style="background:#3b82f6;width:' + latModelPct + '%" title="Model API time (~' + latModelPct + '%)">' + (latModelPct >= 12 ? 'model' : '') + '</div>'
-    + '<div class="mini-split-seg" style="background:#8b5cf6;width:' + latToolPct + '%" title="Tool execution time (~' + latToolPct + '%)">' + (latToolPct >= 12 ? 'tools' : '') + '</div>'
-    + '<div class="mini-split-seg" style="background:#6b7280;width:' + latOverPct + '%" title="Framework overhead (~' + latOverPct + '%)">' + (latOverPct >= 12 ? 'overhead' : '') + '</div>'
+    + '<div class="mini-split-seg" style="background:#3b82f6;width:' + latModelPct + '%" title="Model API time">' + (latModelPct >= 12 ? 'model ' + latModelPct + '%' : '') + '</div>'
+    + '<div class="mini-split-seg" style="background:#8b5cf6;width:' + latToolPct + '%" title="Tool execution time">' + (latToolPct >= 12 ? 'tools ' + latToolPct + '%' : '') + '</div>'
+    + '<div class="mini-split-seg" style="background:#6b7280;width:' + latOverPct + '%" title="Framework overhead">' + (latOverPct >= 12 ? 'overhead ' + latOverPct + '%' : '') + '</div>'
     + '</div>'
     + '<div class="mini-split-legend">'
     +   '<span><span class="mini-split-legend-dot" style="background:#3b82f6"></span>model</span>'
@@ -24636,7 +24898,14 @@ async function refreshMiniDashboards() {
     +   '<span><span class="mini-split-legend-dot" style="background:#6b7280"></span>overhead</span>'
     + '</div>';
   var latFigure = avgDur > 0 ? formatDurationMs(avgDur) : '—';
-  var latSub = okRuns.length > 0 ? 'avg of ' + okRuns.length + ' successful runs · 7d' : 'no successful runs in 7d';
+  var latSub;
+  if (okRuns.length === 0) {
+    latSub = 'no successful runs in 7d';
+  } else if (latencyMode === 'real') {
+    latSub = 'avg of ' + okRuns.length + ' successful runs · ' + coverageLabel;
+  } else {
+    latSub = 'avg of ' + okRuns.length + ' successful runs · split is heuristic (' + (coverageLabel || 'install hooks per task to see real numbers') + ')';
+  }
 
   // ── Reliability card ───────────────────────────────────────────────
   // Per-day failure column, stacked by category. Categories use the same
@@ -24750,7 +25019,7 @@ async function refreshMiniDashboards() {
     + '<div class="mini-card">'
     +   '<div class="mini-card-head"><span class="mini-card-title">Latency · avg</span><span class="mini-card-figure">' + esc(latFigure) + '</span></div>'
     +   splitHtml
-    +   '<div class="mini-card-sub">' + esc(latSub) + ' · split is heuristic until path B hooks land per-task (enable in cron editor → Last run)</div>'
+    +   '<div class="mini-card-sub">' + esc(latSub) + '</div>'
     + '</div>'
     + '<div class="mini-card">'
     +   '<div class="mini-card-head"><span class="mini-card-title">Reliability · 7d</span><span class="mini-card-figure">' + totalFails7 + ' fail' + (totalFails7 === 1 ? '' : 's') + '</span></div>'
@@ -27732,6 +28001,8 @@ function openEditCronModal(jobName) {
   _cronPreviewLoadedFor = null;
   document.getElementById('cron-modal-title').textContent = 'Edit: ' + jobName;
   document.getElementById('cron-modal-save').textContent = 'Save Changes';
+  // PRD §11 Phase 5b / 1.18.105: load draft state for footer badge + buttons.
+  if (typeof refreshCronDraftBadge === 'function') refreshCronDraftBadge(jobName);
   document.getElementById('cron-name').value = job.name;
   document.getElementById('cron-name').disabled = true;
   setScheduleFromCron(job.schedule || '0 9 * * *');
@@ -28278,6 +28549,168 @@ async function saveCronJob() {
   }
 }
 
+// ── PRD §11 Phase 5b / 1.18.105: Draft / Publish handlers ───────────
+// Build the same body saveCronJob builds, but POST it as a draft sidecar
+// instead of overwriting CRON.md. The schedule keeps firing the published
+// version until the user clicks Publish.
+function _buildCronJobBodyForDraft() {
+  // Reuse the same field collection logic saveCronJob uses, minus the
+  // PUT/POST round-trip. Returns null when validation fails so the caller
+  // can bail without further work.
+  var name = document.getElementById('cron-name').value.trim();
+  var schedule = document.getElementById('cron-schedule').value.trim();
+  var prompt = document.getElementById('cron-prompt').value.trim();
+  if (!name) { toast('Task name is required', 'error'); return null; }
+  if (!schedule) { toast('Schedule is required', 'error'); return null; }
+  if (!prompt) { toast('Prompt is required', 'error'); return null; }
+  var tier = parseInt(document.getElementById('cron-tier').value);
+  var work_dir = document.getElementById('cron-workdir').value;
+  var mode = document.getElementById('cron-mode').value;
+  var max_hours = mode === 'unleashed' ? parseInt(document.getElementById('cron-maxhours').value) : undefined;
+  var max_retries_val = document.getElementById('cron-max-retries').value;
+  var max_retries = max_retries_val !== '' ? parseInt(max_retries_val) : undefined;
+  var after = document.getElementById('cron-after').value || undefined;
+  var context = document.getElementById('cron-context').value.trim() || undefined;
+  var category = (document.getElementById('cron-category')?.value || '').trim() || undefined;
+  var allowedTools = parseAllowedToolsRaw();
+  var successCriteriaText = (document.getElementById('cron-success-criteria-text')?.value || '').trim();
+  var successSchemaRaw = (document.getElementById('cron-success-schema')?.value || '').trim();
+  var successSchema;
+  if (successSchemaRaw) {
+    try { successSchema = JSON.parse(successSchemaRaw); }
+    catch (e) { toast('Success schema is not valid JSON', 'error'); return null; }
+  }
+  var addDirs = (document.getElementById('cron-add-dirs')?.value || '')
+    .split(/\\r?\\n/).map(function(s){return s.trim();}).filter(Boolean);
+  return {
+    name: name, schedule: schedule, prompt: prompt, tier: tier,
+    enabled: true,
+    work_dir: work_dir || undefined,
+    mode: mode,
+    max_hours: max_hours,
+    max_retries: max_retries,
+    after: after,
+    context: context,
+    category: category,
+    skills: _cronSelectedSkills,
+    allowedTools: allowedTools,
+    allowedMcpServers: _cronSelectedMcp,
+    tags: _cronTags,
+    predictable: typeof _cronPredictable === 'boolean' ? _cronPredictable : true,
+    successCriteriaText: successCriteriaText || undefined,
+    successSchema: successSchema || undefined,
+    addDirs: addDirs.length ? addDirs : undefined,
+  };
+}
+
+async function saveCronAsDraft() {
+  if (!editingCronJob) {
+    toast('Save the task first; drafts apply to existing tasks.', 'info');
+    return;
+  }
+  var body = _buildCronJobBodyForDraft();
+  if (!body) return;
+  try {
+    var r = await apiFetch('/api/cron/' + encodeURIComponent(editingCronJob) + '/draft', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ draft: body, changedBy: 'dashboard' }),
+    });
+    var d = await r.json().catch(function() { return {}; });
+    if (!r.ok || d.ok === false) {
+      toast(d.error || ('Save draft failed (HTTP ' + r.status + ')'), 'error');
+      return;
+    }
+    toast(d.message || 'Draft saved.', 'success');
+    captureCronModalSnapshot();
+    refreshCronDraftBadge(editingCronJob);
+  } catch (err) { toast('Save draft failed: ' + err, 'error'); }
+}
+
+async function publishCronDraft() {
+  if (!editingCronJob) return;
+  if (!confirm('Publish the draft to live? The schedule will start firing the new version on the next tick.')) return;
+  try {
+    var r = await apiFetch('/api/cron/' + encodeURIComponent(editingCronJob) + '/publish', { method: 'POST' });
+    var d = await r.json().catch(function() { return {}; });
+    if (!r.ok || d.ok === false) {
+      toast(d.error || ('Publish failed (HTTP ' + r.status + ')'), 'error');
+      return;
+    }
+    toast(d.message || 'Published.', 'success');
+    refreshCron();
+    refreshCronDraftBadge(editingCronJob);
+  } catch (err) { toast('Publish failed: ' + err, 'error'); }
+}
+
+async function discardCronDraft() {
+  if (!editingCronJob) return;
+  if (!confirm('Discard the unpublished draft? This restores the editor to the published version.')) return;
+  try {
+    var r = await apiFetch('/api/cron/' + encodeURIComponent(editingCronJob) + '/draft', { method: 'DELETE' });
+    var d = await r.json().catch(function() { return {}; });
+    if (!r.ok || d.ok === false) {
+      toast(d.error || ('Discard failed (HTTP ' + r.status + ')'), 'error');
+      return;
+    }
+    toast(d.message || 'Draft discarded.', 'success');
+    refreshCronDraftBadge(editingCronJob);
+    // Reload the modal contents from the published version so the editor
+    // matches what the schedule will fire.
+    if (editingCronJob && typeof openEditCronModal === 'function') {
+      var name = editingCronJob;
+      // openEditCronModal re-fetches and re-populates fields.
+      openEditCronModal(name);
+    }
+  } catch (err) { toast('Discard failed: ' + err, 'error'); }
+}
+
+// Update the draft badge + footer button visibility based on the
+// computed badge state. Called from openEditCronModal after load and
+// after every draft action.
+async function refreshCronDraftBadge(jobName) {
+  var badge = document.getElementById('cron-draft-badge');
+  var saveDraftBtn = document.getElementById('cron-save-draft-btn');
+  var publishBtn = document.getElementById('cron-publish-btn');
+  var discardBtn = document.getElementById('cron-discard-draft-btn');
+  if (!badge || !jobName) return;
+  try {
+    var r = await apiFetch('/api/cron/' + encodeURIComponent(jobName) + '/draft');
+    var d = await r.json();
+    if (!r.ok || !d.ok) {
+      badge.style.display = 'none';
+      if (saveDraftBtn) saveDraftBtn.style.display = '';
+      if (publishBtn) publishBtn.style.display = 'none';
+      if (discardBtn) discardBtn.style.display = 'none';
+      return;
+    }
+    var state = d.badge || 'none';
+    var label, color;
+    if (state === 'up_to_date') { label = '✓ Published, no draft changes'; color = 'var(--green)'; }
+    else if (state === 'ready') { label = '● Ready to publish'; color = 'var(--accent)'; }
+    else if (state === 'rebase_needed') { label = '⚠ Published drifted — review draft'; color = 'var(--yellow)'; }
+    else if (state === 'draft') { label = '✎ Draft (not yet published)'; color = 'var(--accent)'; }
+    else { label = ''; color = ''; }
+    if (label) {
+      badge.style.display = '';
+      badge.textContent = label;
+      badge.style.background = color + '20';
+      badge.style.color = color;
+    } else {
+      badge.style.display = 'none';
+    }
+    // Footer button visibility depends on whether we have a saved task
+    // (editingCronJob) AND whether a draft already exists. Save-as-draft
+    // is always visible when editing; Publish/Discard only when a draft
+    // exists.
+    if (saveDraftBtn) saveDraftBtn.style.display = '';
+    if (publishBtn) publishBtn.style.display = (state === 'ready' || state === 'rebase_needed' || state === 'draft') ? '' : 'none';
+    if (discardBtn) discardBtn.style.display = (state === 'ready' || state === 'rebase_needed' || state === 'draft' || state === 'up_to_date') ? '' : 'none';
+  } catch (err) {
+    if (badge) badge.style.display = 'none';
+  }
+}
+
 // ── Cron Training Chat ───────────────────
 function showCronTraining() {
   document.getElementById('cron-training-section').style.display = '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.103",
+  "version": "1.18.105",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",