aimeat 1.33.2 → 1.35.0

package/dist/public/views/secretary/use-specialists.js

@@ -0,0 +1,103 @@
+/**
+ * @file secretary/use-specialists.js
+ * @description Secretary-side specialist management (Phase 3 surface). List the owner's specialists,
+ *   create one from a role template (+ a brain purpose), run its queued tasks now, or remove it. A
+ *   specialist is a stripped-down Secretary (node-run, own brain) that publishes a workflow-compatible
+ *   offer on creation — so creating one here gives the workflow designer a new building block.
+ * @structure useSpecialists({ showToast }) -> { list, form, openForm, closeForm, setField, create, busy, remove, runNow }
+ *   · specialistsCard(p) -> section
+ * @usage const spec = useSpecialists({ showToast }); specialistsCard({ ...spec })
+ * @version-history
+ *   v0.1.0 — 2026-06-28 — Phase 3: specialist create/list/run/delete card driven by /v1/specialists.
+ */
+import { h } from 'preact';
+import htm from 'htm';
+import { useState, useEffect, useCallback } from 'preact/hooks';
+import { apiGet, apiPost, apiDelete } from '/js/api.js';
+import { t } from '/js/i18n.js';
+
+const html = htm.bind(h);
+/** Role templates a specialist can be created from (each selects a scope profile server-side). */
+export const SPECIALIST_ROLES = ['specialist', 'sdr', 'prep', 'finance', 'recruiter'];
+
+export function useSpecialists({ showToast }) {
+  const [list, setList] = useState([]);
+  const [form, setForm] = useState(null);   // null = closed; { name, role, purpose }
+  const [busy, setBusy] = useState(false);
+
+  const load = useCallback(async () => {
+    const r = await apiGet('/v1/specialists').catch(() => null);
+    setList((r && r.data && r.data.specialists) || []);
+  }, []);
+  useEffect(() => { load(); }, [load]);
+  useEffect(() => {
+    const handler = () => load();
+    window.addEventListener('aimeat-live-update', handler);
+    return () => window.removeEventListener('aimeat-live-update', handler);
+  }, [load]);
+
+  const openForm = useCallback(() => setForm({ name: '', role: 'specialist', purpose: '' }), []);
+  const closeForm = useCallback(() => setForm(null), []);
+  const setField = useCallback((k, v) => setForm((f) => (f ? { ...f, [k]: v } : f)), []);
+
+  const create = useCallback(async () => {
+    if (!form || !form.name.trim()) return;
+    setBusy(true);
+    try {
+      const body = { name: form.name.trim(), role: form.role || 'specialist' };
+      if ((form.purpose || '').trim()) body.brain = { purpose: form.purpose.trim() };
+      await apiPost('/v1/specialists', body);
+      showToast(t('secretary.spec.created'));
+      setForm(null);
+      await load();
+    } catch (e) {
+      showToast(`${t('secretary.spec.error')}: ${e.message}`, true);
+    } finally {
+      setBusy(false);
+    }
+  }, [form, load, showToast]);
+
+  const remove = useCallback(async (name) => {
+    await apiDelete(`/v1/specialists/${encodeURIComponent(name)}`).catch(() => {});
+    await load();
+  }, [load]);
+
+  const runNow = useCallback(async (name) => {
+    try {
+      const r = await apiPost(`/v1/specialists/${encodeURIComponent(name)}/run`, {});
+      showToast(t('secretary.spec.ran', { n: (r && r.data && r.data.ran) || 0 }));
+      await load();
+    } catch (e) {
+      showToast(`${t('secretary.spec.error')}: ${e.message}`, true);
+    }
+  }, [load, showToast]);
+
+  return { list, form, openForm, closeForm, setField, create, busy, remove, runNow };
+}
+
+/** Specialists card: list + create-from-role-template + run-now / remove. */
+export function specialistsCard(p) {
+  return html`
+    <section class="sec-card sec-specialists">
+      <div class="sec-card-head">
+        <h2 class="sec-h2">${t('secretary.spec.title')}</h2>
+        <button class="btn-outline btn-sm" onClick=${p.form ? p.closeForm : p.openForm}>${p.form ? t('secretary.spec.cancel') : t('secretary.spec.add')}</button>
+      </div>
+      ${p.list.length === 0 && !p.form ? html`<p class="sec-hint">${t('secretary.spec.empty')}</p>` : null}
+      ${p.list.length ? html`<ul class="sec-goal-list">
+        ${p.list.map((s) => html`<li class="sec-goal-row" key=${s.name}>
+          <div class="sec-goal-main"><span class="sec-goal-title">${s.display_name || s.name}</span> <span class="sec-hint">· ${s.role}</span></div>
+          <button class="sec-linkbtn" onClick=${() => p.runNow(s.name)}>${t('secretary.spec.run')}</button>
+          <button class="sec-linkbtn sec-next-discard" onClick=${() => p.remove(s.name)}>${t('secretary.spec.remove')}</button>
+        </li>`)}
+      </ul>` : null}
+      ${p.form ? html`<div class="sec-form">
+        <input class="sec-input" placeholder=${t('secretary.spec.namePh')} value=${p.form.name} onInput=${(e) => p.setField('name', e.target.value)} />
+        <select class="sec-input" value=${p.form.role} onChange=${(e) => p.setField('role', e.target.value)}>
+          ${SPECIALIST_ROLES.map((r) => html`<option value=${r} selected=${p.form.role === r}>${r}</option>`)}
+        </select>
+        <textarea class="sec-paste" placeholder=${t('secretary.spec.purposePh')} value=${p.form.purpose} onInput=${(e) => p.setField('purpose', e.target.value)}></textarea>
+        <button class="btn-primary btn-sm" disabled=${p.busy || !p.form.name.trim()} onClick=${p.create}>${p.busy ? t('secretary.saving') : t('secretary.spec.create')}</button>
+      </div>` : null}
+    </section>`;
+}

package/dist/public/views/secretary/use-triggers.js

@@ -0,0 +1,159 @@
+/**
+ * @file secretary/use-triggers.js
+ * @description Triggers (Slice 3) — proactive follow-ups the Secretary binds to what it tracks. CRUD over
+ *   `secretary.trigger.{id}` records (kind: time | recurring | completion | condition). The autonomous
+ *   tick is the engine that evaluates + fires them (services/scheduler.ts + the pure helpers in
+ *   services/secretary-tick.ts); this hook only manages the records the owner creates/pauses/deletes.
+ * @structure useTriggers({ active, showToast }) -> { triggers, armed, form, openForm, createTrigger, togglePause, removeTrigger, ... }
+ * @usage const trig = useTriggers({ active, showToast }); triggersCard({ ...trig, goals, routines })
+ * @version-history
+ *   v0.2.0 — 2026-06-28 — Bound actions: a trigger can BIND a workflow or a specialist to its fire
+ *     (action.{kind,workflowId|specialistName,prompt}); loads /v1/workflows + buildAction() composes it.
+ *   v0.1.0 — 2026-06-28 — Slice 3: trigger CRUD hook (create all 4 kinds, pause/resume, delete).
+ */
+import { useState, useEffect, useCallback, useMemo } from 'preact/hooks';
+import { api, apiGet, apiPost, apiDelete } from '/js/api.js';
+import { t } from '/js/i18n.js';
+import { extractJson } from '/js/services/secretary-helpers.js';
+
+const PREFIX = 'secretary.trigger.';
+const CADENCE_MS = { daily: 86400000, weekly: 604800000, monthly: 2592000000 };
+function genId() { return 'tr-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 5); }
+
+/** Cheap gate (Slice 4): only bother the model when text smells recurring or deadline-y (FI + EN). */
+const TRIG_HINTS = /(joka\s+(päivä|viikko|kuukausi|aamu|ilta|maanantai|tiistai|keskiviikko|torstai|perjantai)|viikoittain|päivittäin|kuukausittain|säännöllisesti|muistuta|deadline|määräaika|mennessä|ennen\s+\d|weekly|daily|monthly|every\s+(day|week|month|morning|monday|tuesday|wednesday|thursday|friday)|remind|by\s+\w+day|each\s+(day|week|month))/i;
+
+const EMPTY_FORM = { kind: 'recurring', label: '', cadence: 'weekly', when: '', targetId: '', condType: 'memory_count', condPrefix: '', condValue: 5, condDays: 7, actionKind: 'remind', actionWorkflowId: '', actionSpecialistName: '', actionPrompt: '' };
+
+/** Build the trigger's bound `action` from the form. 'remind' (default) → feed + action-item; 'workflow'
+ *  → start the chosen workflow; 'specialist' → queue + run a task (the prompt) for the chosen specialist. */
+function buildAction(form) {
+  const summary = form.label.trim();
+  if (form.actionKind === 'workflow' && form.actionWorkflowId) return { kind: 'workflow', summary, workflowId: form.actionWorkflowId };
+  if (form.actionKind === 'specialist' && form.actionSpecialistName) return { kind: 'specialist', summary, specialistName: form.actionSpecialistName, prompt: (form.actionPrompt || '').trim() || summary };
+  return { kind: 'remind', summary };
+}
+
+export function useTriggers({ active, showToast }) {
+  const [triggers, setTriggers] = useState([]);
+  const [workflows, setWorkflows] = useState([]); // saved workflows a trigger can bind to (run-on-fire)
+  const [form, setForm] = useState(null); // null = closed
+  const [adding, setAdding] = useState(false);
+
+  const load = useCallback(async () => {
+    // Cache-bust: the tick fires/settles triggers server-side, so always read fresh.
+    const r = await apiGet(`/v1/memory?prefix=${encodeURIComponent(PREFIX)}&_=${Date.now()}`).catch(() => null);
+    const items = (r && r.data && r.data.items) || [];
+    setTriggers(items.map((it) => it.value).filter((v) => v && v.id).sort((a, b) => String(b.createdAt || '').localeCompare(String(a.createdAt || ''))));
+  }, []);
+  useEffect(() => { load(); }, [load]);
+  useEffect(() => {
+    apiGet('/v1/workflows').then((r) => setWorkflows((r && r.data && r.data.workflows) || [])).catch(() => {});
+  }, []);
+  useEffect(() => {
+    const h = () => load();
+    window.addEventListener('aimeat-live-update', h);
+    return () => window.removeEventListener('aimeat-live-update', h);
+  }, [load]);
+
+  const writeTrigger = useCallback(async (tr) => {
+    await apiPost('/v1/memory', { key: PREFIX + tr.id, value: tr, visibility: 'private', tags: ['secretary', 'trigger', tr.status || ''] });
+  }, []);
+
+  const openForm = useCallback(() => setForm({ ...EMPTY_FORM }), []);
+  const closeForm = useCallback(() => setForm(null), []);
+  const setField = useCallback((k, v) => setForm((f) => (f ? { ...f, [k]: v } : f)), []);
+
+  const createTrigger = useCallback(async () => {
+    if (!form || !form.label.trim()) return;
+    const now = Date.now();
+    const tr = {
+      id: genId(), kind: form.kind, label: form.label.trim().slice(0, 200),
+      contextId: (active && active.id) || '', status: 'armed', createdBy: 'owner',
+      createdAt: new Date().toISOString(), action: buildAction(form),
+    };
+    if (form.kind === 'time') {
+      if (!form.when) { showToast(t('secretary.trig.needWhen'), true); return; }
+      tr.when = new Date(form.when).toISOString(); tr.nextFireAt = tr.when;
+    } else if (form.kind === 'recurring') {
+      tr.cadence = form.cadence; tr.nextFireAt = new Date(now + (CADENCE_MS[form.cadence] || CADENCE_MS.weekly)).toISOString();
+    } else if (form.kind === 'completion') {
+      if (!form.targetId) { showToast(t('secretary.trig.needTarget'), true); return; }
+      tr.target = { type: 'item', id: form.targetId };
+    } else if (form.kind === 'condition') {
+      if (!form.condPrefix.trim()) { showToast(t('secretary.trig.needPrefix'), true); return; }
+      tr.condition = { type: form.condType, prefix: form.condPrefix.trim(), op: '>=', value: Number(form.condValue) || 0, days: Number(form.condDays) || 7 };
+    }
+    setAdding(true);
+    try {
+      await writeTrigger(tr);
+      showToast(t('secretary.trig.created'));
+      setForm(null);
+      await load();
+    } catch (e) {
+      showToast(`${t('secretary.trig.error')}: ${e.message}`, true);
+    } finally {
+      setAdding(false);
+    }
+  }, [form, active, writeTrigger, load, showToast]);
+
+  const togglePause = useCallback(async (tr) => {
+    await writeTrigger({ ...tr, status: tr.status === 'paused' ? 'armed' : 'paused' }).catch(() => {});
+    await load();
+  }, [writeTrigger, load]);
+
+  /** Edit a trigger in place (label/cadence) — writes the memory record. Recomputes nextFireAt when a
+   *  recurring trigger's cadence changes. Used by the calendar's inline editor + the triggers card. */
+  const updateTrigger = useCallback(async (id, patch) => {
+    const cur = triggers.find((x) => x.id === id);
+    if (!cur) return;
+    const next = { ...cur, ...patch };
+    if (patch.label) { next.label = String(patch.label).slice(0, 200); next.action = { ...(next.action || {}), summary: next.label }; }
+    if (patch.cadence && next.kind === 'recurring' && patch.cadence !== cur.cadence) {
+      next.cadence = patch.cadence;
+      next.nextFireAt = new Date(Date.now() + (CADENCE_MS[patch.cadence] || CADENCE_MS.weekly)).toISOString();
+    }
+    await writeTrigger(next).catch(() => {});
+    await load();
+  }, [triggers, writeTrigger, load]);
+
+  const removeTrigger = useCallback(async (tr) => {
+    await apiDelete(`/v1/memory/${encodeURIComponent(PREFIX + tr.id)}`).catch(() => {});
+    await load();
+  }, [load]);
+
+  /** Arm a proposed trigger (Slice 4): status → armed, computing nextFireAt for recurring if unset. */
+  const armTrigger = useCallback(async (tr) => {
+    const now = Date.now();
+    const armedTr = { ...tr, status: 'armed' };
+    if (tr.kind === 'recurring' && !tr.nextFireAt) armedTr.nextFireAt = new Date(now + (CADENCE_MS[tr.cadence] || CADENCE_MS.weekly)).toISOString();
+    await writeTrigger(armedTr).catch(() => {});
+    await load();
+  }, [writeTrigger, load]);
+
+  /** Slice 4 auto-detect: if `text` clearly implies a recurring follow-up or a deadline, create a
+   *  PROPOSED trigger the owner can Arm or Dismiss. Cheap keyword gate first, then one AI call. No-op
+   *  when nothing clearly recurring/deadline is present, so it never nags. */
+  const proposeTriggerFromText = useCallback(async (text) => {
+    const s = String(text || '').trim();
+    if (!s || !TRIG_HINTS.test(s)) return;
+    if (triggers.some((tr) => tr.status === 'proposed' && tr.fromText === s)) return; // no duplicate proposal
+    try {
+      const sys = `You decide whether a note implies a recurring follow-up or a one-off deadline the Secretary should track. Return ONLY JSON: {"trigger": false} OR {"trigger": true, "kind": "recurring", "label": "short label", "cadence": "daily"|"weekly"|"monthly"} OR {"trigger": true, "kind": "time", "label": "short label", "when": "ISO datetime"}. Say true ONLY if there is a CLEAR recurrence or deadline. Write the label in the user's language.`;
+      const r = await api('/v1/ai/complete', { method: 'POST', body: JSON.stringify({ prompt: s, systemPrompt: sys, app_id: 'secretary-trigger-detect' }), timeoutMs: 1_800_000, retries: 0 });
+      let j = null;
+      try { j = extractJson((r && r.data && r.data.content) || ''); } catch { /* ignore */ }
+      if (!j || !j.trigger || !j.label) return;
+      const tr = { id: genId(), kind: j.kind === 'time' ? 'time' : 'recurring', label: String(j.label).slice(0, 200), contextId: (active && active.id) || '', status: 'proposed', createdBy: 'secretary', fromText: s, createdAt: new Date().toISOString(), action: { kind: 'remind', summary: String(j.label).slice(0, 200) } };
+      if (tr.kind === 'time' && j.when) { tr.when = new Date(j.when).toISOString(); tr.nextFireAt = tr.when; }
+      else { tr.cadence = ['daily', 'weekly', 'monthly'].includes(j.cadence) ? j.cadence : 'weekly'; }
+      await writeTrigger(tr);
+      showToast(t('secretary.trig.proposed'));
+      await load();
+    } catch { /* best-effort — detection never blocks the user */ }
+  }, [triggers, active, writeTrigger, load, showToast]);
+
+  const armed = useMemo(() => triggers.filter((tr) => tr.status === 'armed'), [triggers]);
+  const proposed = useMemo(() => triggers.filter((tr) => tr.status === 'proposed'), [triggers]);
+  return { triggers, workflows, armed, proposed, form, openForm, closeForm, setField, createTrigger, adding, togglePause, updateTrigger, removeTrigger, armTrigger, proposeTriggerFromText };
+}

package/dist/public/views/secretary/use-whats-next.js

@@ -0,0 +1,340 @@
+/**
+ * @file secretary/use-whats-next.js
+ * @description B2 — Routines + "What's next". Generalises the Phase-3c guided plan into the Secretary's
+ *   forward-driver: it either PROPOSES a new Routine (a named, recurring, multi-step workflow it tracks)
+ *   from a goal via the owner's OpenRouter key, or ADVANCES an active one — approving each step
+ *   band-gated (act → run · draft|ask → approve first + log a decision contract · off → skip), executing
+ *   the automatable part (discover = scout, file/briefing/reminders = file a note into the self-organism),
+ *   recording the result, and persisting the routine under `secretary.config.contexts[i].routines[]`.
+ *   Delegation/create steps are proposed + band-gated but their execution is DEFERRED to B4 (marked
+ *   deferred, never fake-acted). Band routing is the pure `routeRoutineStep` helper (services/secretary-tick),
+ *   shared with the autonomous tick + asserted in e2e-secretary. Redesign: docs/internal/2026-06-25-secretary-view-redesign.md (B2).
+ * @structure ROUTINE_CAPABILITIES · buildRoutinePrompt · useWhatsNext({ active, config, persistConfig, policy, wsList, suggestedWsId, showToast })
+ * @usage const next = useWhatsNext({...}); whatsNextCard(next) / routinesCard(next)
+ * @version-history
+ *   v0.6.0 — 2026-06-28 — G7: a delegate step can run an Agent Workflow (chaining specialists) instead of a
+ *     single agent task — loads the owner's workflows, POST /v1/workflows/:id/run, tracks the runId; checkDelegateResult polls it.
+ *   v0.5.0 — 2026-06-28 — G4: split FILE_CAPS into NOTE_CAPS (file a note) + FEED_CAPS (briefing/reminders
+ *     surface in the Home feed), mirroring actionKind() — consistent with the tick + legacy action-loop.
+ *   v0.4.0 — 2026-06-28 — G2: recurring routines — setRoutineCadence (none/daily/weekly); the tick
+ *     re-arms a completed routine once its cadence elapses (services/secretary-tick.ts).
+ *   v0.3.0 — 2026-06-28 — B5: action-items — handle (advance routine / check delegate) + dismiss the
+ *     follow-ups the tick derived (active context's actionItems[]); delegated steps stay active until done.
+ *   v0.2.0 — 2026-06-28 — B4: a delegate step creates an agent task for an owner-picked target agent
+ *     (POST /v1/agents/:name/tasks, queued, parent_task_id = routine id); checkDelegateResult pulls the
+ *     task status back into the routine. delegate removed from the deferred set.
+ *   v0.1.0 — 2026-06-27 — B2: Routine entity + "What's next" propose/advance with band-gated, persisted steps.
+ */
+import { useState, useCallback, useMemo, useEffect } from 'preact/hooks';
+import { api, apiGet, apiPost } from '/js/api.js';
+import { t } from '/js/i18n.js';
+import { extractJson, buildDecisionRecord } from '/js/services/secretary-helpers.js';
+import { routeRoutineStep } from '/js/services/secretary-rules.js';
+import { SPECIALIST_CONTRACT } from '/views/secretary/quality.js';
+
+/** Capabilities a routine step may use (subset of the policy taxonomy the Secretary can plan with). */
+export const ROUTINE_CAPABILITIES = ['discover', 'file_intake', 'briefing', 'reminders', 'curate_knowledge', 'create_resource', 'delegate'];
+// G4: the capability→kind split MIRRORS actionKind() in services/secretary-tick.ts — keep in sync.
+// NOTE caps file a note into the self-organism; FEED caps (briefing/reminders are nudges, not documents)
+// surface in the Home feed — exactly how the tick + the legacy action-loop treat them.
+const NOTE_CAPS = new Set(['file_intake', 'curate_knowledge']);
+const FEED_CAPS = new Set(['briefing', 'reminders']);
+/** Steps proposed + band-gated but whose execution is still deferred (create lands later; spend/messaging are Enterprise). */
+const DEFERRED_CAPS = new Set(['create_resource', 'resource_invoke', 'third_party_message', 'spend']);
+
+function genId(p) { return p + Date.now().toString(36) + Math.random().toString(36).slice(2, 6); }
+
+export function buildRoutinePrompt(goal, contextName) {
+  return `In the "${contextName || 'personal'}" context, the user's goal is:
+"""
+${goal}
+"""
+Design a short, repeatable ROUTINE (a named, multi-step workflow the Secretary can run and track) that makes progress on this goal. Output ONLY a JSON object inside a single code block, EXACTLY this shape:
+
+\`\`\`json
+{ "title": "short routine name", "purpose": "one line — what this routine achieves", "steps": [ { "capability": "discover", "summary": "what this step does, one sentence" } ] }
+\`\`\`
+
+Rules:
+- 3–6 steps, ordered, concrete and specific to the goal.
+- Each step's "capability" MUST be one of: ${ROUTINE_CAPABILITIES.join(', ')}.
+- Prefer starting with "discover" (scout what already exists) before any "create_resource"/"delegate".
+- Output ONLY the JSON code block — no commentary.`;
+}
+
+export function useWhatsNext({ active, config, persistConfig, policy, wsList, suggestedWsId, showToast }) {
+  const [goal, setGoal] = useState('');
+  const [proposing, setProposing] = useState(false);
+  const [selectedId, setSelectedId] = useState(null); // routine being walked in the card
+  const [busyStepId, setBusyStepId] = useState(null);
+  const [delegateAgent, setDelegateAgent] = useState(''); // owner's chosen agent target for the next delegate step
+  const [delegateWorkflow, setDelegateWorkflow] = useState(''); // G7: owner's chosen workflow to run for a delegate step
+  const [checkingStepId, setCheckingStepId] = useState(null);
+  const [workflows, setWorkflows] = useState([]); // G7: the owner's Agent Workflows (delegate can run one)
+
+  // G7: load the owner's workflows so a delegate step can run one (chaining specialists) instead of a single agent task.
+  useEffect(() => {
+    let cancelled = false;
+    apiGet('/v1/workflows').then((r) => { if (!cancelled) setWorkflows((r && r.data && r.data.workflows) || []); }).catch(() => {});
+    return () => { cancelled = true; };
+  }, []);
+
+  const routines = useMemo(() => (active && Array.isArray(active.routines)) ? active.routines : [], [active]);
+  const activeRoutines = useMemo(() => routines.filter((r) => r.status === 'active'), [routines]);
+  const selected = useMemo(() => routines.find((r) => r.id === selectedId) || null, [routines, selectedId]);
+  const bands = useMemo(() => (policy && policy.bands) || {}, [policy]);
+
+  /** Read-modify-write the active context's routines list into a fresh config and persist. */
+  const writeRoutines = useCallback(async (nextRoutines) => {
+    if (!active) return;
+    const next = { ...config, contexts: (config.contexts || []).map((c) => (c.id === active.id ? { ...c, routines: nextRoutines } : c)) };
+    await persistConfig(next);
+  }, [active, config, persistConfig]);
+
+  const patchRoutine = useCallback(async (routineId, updater) => {
+    const nextRoutines = routines.map((r) => (r.id === routineId ? updater(r) : r));
+    await writeRoutines(nextRoutines);
+  }, [routines, writeRoutines]);
+
+  /** Propose (and save) a NEW routine from the goal — the "What's next: something new" path. */
+  const proposeRoutine = useCallback(async () => {
+    const g = goal.trim();
+    if (!g || !active) return;
+    setProposing(true);
+    try {
+      const r = await api('/v1/ai/complete', { method: 'POST', body: JSON.stringify({ prompt: buildRoutinePrompt(g, active.name), app_id: 'secretary-routine' }), timeoutMs: 1_800_000, retries: 0 });
+      const json = extractJson((r && r.data && r.data.content) || '');
+      if (!json || !Array.isArray(json.steps) || json.steps.length === 0) throw new Error(t('secretary.next.bad'));
+      const steps = json.steps.slice(0, 8).map((s) => {
+        const capability = ROUTINE_CAPABILITIES.includes(s.capability) ? s.capability : 'file_intake';
+        return { id: genId('s'), capability, summary: String(s.summary || '').slice(0, 200), band: (typeof bands[capability] === 'string' ? bands[capability] : 'ask'), status: 'pending', result: null };
+      });
+      const routine = {
+        id: genId('r'), title: String(json.title || g).slice(0, 80), purpose: String(json.purpose || '').slice(0, 200),
+        steps, cadence: null, status: 'active', lastRunAt: null, nextRunAt: null,
+        results: [], createdBy: 'owner', createdAt: new Date().toISOString(),
+      };
+      await writeRoutines([routine, ...routines]);
+      setSelectedId(routine.id);
+      setGoal('');
+      showToast(t('secretary.next.proposed'));
+    } catch (e) {
+      showToast(`${t('secretary.next.error')}: ${e.message}`, true);
+    } finally {
+      setProposing(false);
+    }
+  }, [goal, active, bands, routines, writeRoutines, showToast]);
+
+  /** Carry out one step's capability (B2: discover scouts, file caps file a note; B4: delegate creates an agent task). */
+  const performStep = useCallback(async (step, opts = {}) => {
+    if (step.capability === 'delegate' && opts.workflowId) {
+      // G7: run an Agent Workflow (chaining specialists) instead of a single agent task. The run executes
+      // server-side over the workflow's steps; the routine tracks its runId (checkDelegateResult polls it).
+      const resp = await apiPost(`/v1/workflows/${encodeURIComponent(opts.workflowId)}/run`, { mode: 'full' });
+      const runId = resp && resp.data && resp.data.runId;
+      return { status: 'delegated', summary: t('secretary.next.resultWorkflow', { wf: opts.workflowName || opts.workflowId }), workflowId: opts.workflowId, runId: runId || null };
+    }
+    if (step.capability === 'delegate') {
+      // B4: hand the step off to one of the owner's other agents as an agent task (queued so it's runnable;
+      // parent_task_id links it back to this routine). The owner picked the target when approving.
+      const agentName = String(opts.agentName || '').trim();
+      if (!agentName) throw new Error(t('secretary.next.delegateNoAgent'));
+      const ctxLine = opts.routinePurpose ? `${opts.routinePurpose}\n\n` : '';
+      // Specialist parity: every delegated task carries the same quality contract the Secretary works to
+      // (grounded, no fabrication, ask via aimeat_dm_ask) + a pointer to where the facts live.
+      const grounding = active.organismId
+        ? `\n\nFacts live in organism ${active.organismId}${wsList.length ? `, workspaces: ${wsList.map((w) => w.name).slice(0, 6).join(', ')}` : ''} — read them with your memory/workspace tools; do not guess.`
+        : '';
+      const description = `${SPECIALIST_CONTRACT}\n\nTASK: ${ctxLine}${step.summary}${grounding}`.slice(0, 8000);
+      const resp = await apiPost(`/v1/agents/${encodeURIComponent(agentName)}/tasks`, {
+        title: step.summary.slice(0, 200),
+        description,
+        status: 'queued',
+        parent_task_id: opts.routineId || undefined,
+      });
+      const taskId = resp && resp.data && resp.data.task && resp.data.task.id;
+      return { status: 'delegated', summary: t('secretary.next.resultDelegated', { agent: agentName }), taskId: taskId || null, agentName };
+    }
+    if (step.capability === 'discover') {
+      const params = new URLSearchParams({ scope: 'public', per_page: '10' });
+      if (step.summary) params.set('q', step.summary);
+      let found = 0;
+      try {
+        const d = await apiGet('/v1/discover?' + params.toString());
+        found = (d && d.data && Array.isArray(d.data.entries)) ? d.data.entries.length : 0;
+      } catch { /* discovery is best-effort */ }
+      return { status: 'done', summary: t('secretary.next.resultFound', { n: found }) || `Found ${found}` };
+    }
+    if (NOTE_CAPS.has(step.capability)) {
+      const wsId = suggestedWsId || (wsList[0] && wsList[0].id);
+      if (active.organismId && wsId) {
+        const id = genId('n');
+        await apiPost('/v1/memory', {
+          key: `organism.${active.organismId}.w.${wsId}.notes.${id}`,
+          value: { id, title: step.summary.slice(0, 80), body: step.summary, createdAt: new Date().toISOString(), via: 'secretary-routine' },
+          visibility: 'private',
+        });
+        const w = wsList.find((x) => x.id === wsId);
+        return { status: 'done', summary: t('secretary.next.resultFiled', { ws: (w && w.name) || '' }) || `Filed into ${(w && w.name) || ''}` };
+      }
+      return { status: 'done', summary: t('secretary.next.resultNoted') || 'Noted' };
+    }
+    if (FEED_CAPS.has(step.capability)) {
+      // G4: briefing/reminders surface in the Home feed (newest first, cap 50) — same shape as the tick's appendFeed.
+      const r = await apiGet('/v1/memory/secretary.feed').catch(() => null);
+      const existing = (r && r.data && r.data.value && Array.isArray(r.data.value.items)) ? r.data.value.items : [];
+      const entry = { id: genId('f'), ts: new Date().toISOString(), kind: 'act', contextId: active.id, contextName: active.name || '', text: step.summary };
+      await apiPost('/v1/memory', { key: 'secretary.feed', value: { items: [entry, ...existing].slice(0, 50) }, visibility: 'private' });
+      return { status: 'done', summary: t('secretary.next.resultSurfaced') || 'Surfaced in the feed' };
+    }
+    if (DEFERRED_CAPS.has(step.capability)) {
+      return { status: 'deferred', summary: t('secretary.next.resultDeferred') || 'Deferred' };
+    }
+    // Unknown capability → safest is to note it rather than fake-act.
+    return { status: 'done', summary: t('secretary.next.resultNoted') || 'Noted' };
+  }, [active, wsList, suggestedWsId]);
+
+  /**
+   * Approve + run a step, band-gated. Skip (off) marks it skipped without acting; confirm (draft|ask)
+   * also logs a decision contract so the learning loop later scores how the routine turned out.
+   */
+  const approveStep = useCallback(async (routine, step, opts = {}) => {
+    if (!active || busyStepId) return;
+    // Band routing via the shared rules module (proven equal to the server's secretary-tick.ts by the G6
+    // parity test) — recomputed from the live policy so a band change applies before approval.
+    const { disposition } = routeRoutineStep(step, bands);
+    setBusyStepId(step.id);
+    try {
+      let outcome;
+      if (disposition === 'skip') {
+        outcome = { status: 'skipped', summary: t('secretary.next.resultSkipped') || 'Skipped (off)' };
+      } else {
+        outcome = await performStep(step, { ...opts, routineId: routine.id, routinePurpose: routine.purpose });
+        if (disposition === 'confirm') {
+          // The approval is a real choice — log a decision contract (reuses the Phase-5 learning loop).
+          try {
+            const rec = buildDecisionRecord({
+              decision: `${routine.title}: ${step.summary}`.slice(0, 200), options: [],
+              chosen: t('secretary.next.decisionChosen') || 'Approved this routine step',
+              rationale: routine.purpose || '', expectedOutcome: step.summary, revisitDays: 7, active,
+            });
+            await apiPost('/v1/memory', { key: `secretary.decision.${rec.id}`, value: rec, visibility: 'private', tags: ['secretary', 'decision', 'open', active.id || ''] });
+          } catch { /* decision logging is best-effort */ }
+        }
+      }
+      const ts = new Date().toISOString();
+      // Delegated steps carry the agent-task ref (taskId + agent) OR the workflow run ref (G7) for later checking.
+      const resultObj = { summary: outcome.summary, ts,
+        ...(outcome.taskId ? { taskId: outcome.taskId, agentName: outcome.agentName } : {}),
+        ...(outcome.workflowId ? { workflowId: outcome.workflowId, runId: outcome.runId } : {}) };
+      const nextSteps = routine.steps.map((s) => (s.id === step.id ? { ...s, status: outcome.status, result: resultObj } : s));
+      // B4/B5 fix: a 'delegated' step is NOT settled (its task is still out) — keep the routine active
+      // (on the dashboard) until checkDelegateResult marks it done once the delegated task completes.
+      const allSettled = nextSteps.every((s) => s.status !== 'pending' && s.status !== 'running' && s.status !== 'delegated');
+      const updater = (r) => ({
+        ...r, steps: nextSteps, lastRunAt: ts,
+        results: outcome.status === 'skipped' ? r.results : [{ ts, summary: outcome.summary }, ...(r.results || [])].slice(0, 20),
+        status: allSettled ? 'done' : r.status,
+      });
+      await patchRoutine(routine.id, updater);
+      window.dispatchEvent(new CustomEvent('aimeat-live-update'));
+    } catch (e) {
+      showToast(`${t('secretary.next.error')}: ${e.message}`, true);
+    } finally {
+      setBusyStepId(null);
+    }
+  }, [active, bands, busyStepId, performStep, patchRoutine, showToast]);
+
+  const setRoutineStatus = useCallback((routine, status) => patchRoutine(routine.id, (r) => ({ ...r, status })), [patchRoutine]);
+  const deleteRoutine = useCallback((routine) => writeRoutines(routines.filter((r) => r.id !== routine.id)), [routines, writeRoutines]);
+  // G2: set a routine's cadence (recurrence). The tick re-arms a completed routine once its cadence
+  // elapses (services/secretary-tick.ts routineDueForRearm); '' clears it back to run-once.
+  const setRoutineCadence = useCallback((routine, cadence) => patchRoutine(routine.id, (r) => ({ ...r, cadence: cadence || null })), [patchRoutine]);
+
+  /** "Advance" from the dashboard: select the routine + scroll the working card into view. */
+  const advance = useCallback((routine) => {
+    setSelectedId(routine.id);
+    const el = document.querySelector('.sec-next');
+    if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+  }, []);
+
+  const nextPendingStep = useCallback((routine) => (routine.steps || []).find((s) => s.status === 'pending') || null, []);
+
+  /**
+   * B4: pull a delegated step's agent-task status back into the routine (the result flowing home).
+   * `closeItemId` (B5) optionally marks an action-item done in the SAME config write — one persist, so a
+   * handled "check result" action-item can't clobber the routine update with a stale second write.
+   */
+  const checkDelegateResult = useCallback(async (routine, step, closeItemId = null) => {
+    const ref = step.result || {};
+    const isWorkflow = !!(ref.workflowId && ref.runId);
+    if ((!isWorkflow && (!ref.taskId || !ref.agentName)) || checkingStepId) return;
+    setCheckingStepId(step.id);
+    try {
+      let status; let summary;
+      if (isWorkflow) {
+        // G7: poll the workflow run's outcome.
+        const r = await apiGet(`/v1/workflows/${encodeURIComponent(ref.workflowId)}/runs/${encodeURIComponent(ref.runId)}`);
+        const run = (r && r.data) || {};
+        status = run.status || run.outcome || 'unknown';
+        summary = t('secretary.next.resultWorkflowStatus', { wf: ref.workflowId, status });
+      } else {
+        const r = await apiGet(`/v1/agents/${encodeURIComponent(ref.agentName)}/tasks/${encodeURIComponent(ref.taskId)}`);
+        const task = r && r.data && r.data.task;
+        status = (task && task.status) || 'unknown';
+        summary = t('secretary.next.resultDelegateStatus', { agent: ref.agentName, status });
+      }
+      const ts = new Date().toISOString();
+      // B4/B5/G7: once the delegated task / workflow run reaches a terminal state, settle the step.
+      const done = ['completed', 'done', 'closed', 'failed', 'cancelled', 'partial', 'error'].includes(String(status).toLowerCase());
+      const next = { ...config, contexts: (config.contexts || []).map((c) => {
+        if (!active || c.id !== active.id) return c;
+        const nextRoutines = (c.routines || []).map((rt) => {
+          if (rt.id !== routine.id) return rt;
+          const steps = (rt.steps || []).map((s) => (s.id === step.id ? { ...s, status: done ? 'done' : s.status, result: { ...s.result, summary, checkedAt: ts } } : s));
+          const allSettled = steps.every((s) => s.status !== 'pending' && s.status !== 'running' && s.status !== 'delegated');
+          return { ...rt, steps, results: [{ ts, summary }, ...(rt.results || [])].slice(0, 20), status: allSettled ? 'done' : rt.status };
+        });
+        const nextItems = closeItemId ? (c.actionItems || []).map((a) => (a.id === closeItemId ? { ...a, status: 'done' } : a)) : c.actionItems;
+        return { ...c, routines: nextRoutines, actionItems: nextItems };
+      }) };
+      await persistConfig(next);
+      window.dispatchEvent(new CustomEvent('aimeat-live-update'));
+    } catch (e) {
+      showToast(`${t('secretary.next.error')}: ${e.message}`, true);
+    } finally {
+      setCheckingStepId(null);
+    }
+  }, [active, config, persistConfig, checkingStepId, showToast]);
+
+  // ── B5: action-items (the tick-derived follow-ups) live on the active context; handle/dismiss them ──
+  const allActionItems = useMemo(() => (active && Array.isArray(active.actionItems)) ? active.actionItems : [], [active]);
+  const actionItems = useMemo(() => allActionItems.filter((a) => a.status === 'open'), [allActionItems]);
+  const writeActionItems = useCallback(async (nextItems) => {
+    if (!active) return;
+    const next = { ...config, contexts: (config.contexts || []).map((c) => (c.id === active.id ? { ...c, actionItems: nextItems } : c)) };
+    await persistConfig(next);
+  }, [active, config, persistConfig]);
+  const dismissActionItem = useCallback((item) => writeActionItems(allActionItems.map((a) => (a.id === item.id ? { ...a, status: 'done' } : a))), [allActionItems, writeActionItems]);
+  /** One-click handle: 'advance' opens the routine here (local state) then dismisses the item; 'check-delegate'
+   *  pulls the task result home AND closes the item in one config write (no stale-config clobber). */
+  const handleActionItem = useCallback(async (item) => {
+    const sa = item.suggestedAction || {};
+    const routine = routines.find((r) => r.id === sa.routineId);
+    if (sa.kind === 'check-delegate' && routine) {
+      const step = (routine.steps || []).find((s) => s.id === sa.stepId);
+      if (step && step.result && step.result.taskId) { await checkDelegateResult(routine, step, item.id); return; }
+    }
+    if (sa.kind === 'advance' && routine) advance(routine); // local state only — no persist before the dismiss
+    await dismissActionItem(item);
+  }, [routines, advance, checkDelegateResult, dismissActionItem]);
+
+  return {
+    goal, setGoal, proposing, proposeRoutine,
+    routines, activeRoutines, selected, selectedId, setSelectedId,
+    busyStepId, approveStep, setRoutineStatus, deleteRoutine, setRoutineCadence, advance, nextPendingStep,
+    delegateAgent, setDelegateAgent, checkingStepId, checkDelegateResult,
+    workflows, delegateWorkflow, setDelegateWorkflow,
+    actionItems, handleActionItem, dismissActionItem,
+  };
+}