aimeat 1.33.2 → 1.35.0

package/dist/public/views/secretary.js

@@ -8,9 +8,71 @@
  *   Presentational cards live in ./secretary/cards.js; pure helpers in /js/services/secretary-helpers.js.
  *   Pure frontend orchestration over generic endpoints (directives + organisms + memory + ai/complete +
  *   agent-messages + discover). Full design: docs/plans/2026-06-23-secretary-feature.md.
- * @structure SECRETARY_ICON · SecretaryView (default) — state, effects, handlers, layout (cards in ./secretary/cards.js + ./secretary/cards-reach.js)
+ * @structure SECRETARY_ICON · SecretaryView (default) — state, effects, handlers, layout (cards in ./secretary/cards.js + ./secretary/cards-reach.js + dashboard chrome in ./secretary/dashboard.js)
  * @usage routed at /v1/secretary by spa.html (+ portal.ts spaRoutes).
  * @version-history
+ *   v0.25.0 — 2026-07-01 — Light-vs-heavy seam: setup no longer cheap-authors content (that hallucinated).
+ *     applyResult now CREATES the workspace structure and then proposes grounded Work Briefs (POST
+ *     /v1/secretary/brief) the user hands to a Builder (a connected big AI via the appdev MCP tools). Drops
+ *     the per-workspace author-now fill loop + the author_content band. The dashboard brief tray (cards)
+ *     renders the briefs with "Open in Claude Desktop" / "Send to a connected Builder".
+ *   v0.24.0 — 2026-06-30 — Never-empty + honest fill result. normalizeInlineManifest now GUARANTEES every
+ *     workspace has a document space (appends a "Muistiinpanot" doc space when the design gave only records
+ *     spaces) so the setup fill always has a thinking-home, and is genuinely document-first for unspecified
+ *     spaces. The per-workspace fill loop counts a workspace as filled ONLY on a real 🖊️ authored line (not
+ *     a ⚠️ summary), retries the HTTP call once (flaky owl-alpha), and the toast names workspaces it
+ *     couldn't fill instead of a bare count.
+ *   v0.23.0 — 2026-06-30 — Autonomy chosen up front: "Set up my Secretary" first asks HOW autonomous it
+ *     should be (Prepare/Draft · Run/Act · Only-when-I-ask/Off), each explained in plain words incl. the
+ *     AI-credit cost, BEFORE anything runs — so nobody stumbles into Act bands later. The choice sets the
+ *     new context's author_content band and, for Draft/Act, turns the daily check-in on. Browser-verified.
+ *   v0.22.0 — 2026-06-30 — Live setup progress: the fill runs ONE workspace at a time (author-now?ws=)
+ *     and a top-level overlay (survives the hire→dashboard switch) shows "Filling workspace N/total ·
+ *     <name>" + a progress bar through the whole slow fill, instead of a couple of fleeting toasts.
+ *     Browser-verified: overlay cycled 1/2 → 2/2 with the bar advancing.
+ *   v0.21.0 — 2026-06-30 — Deterministic workspace structure (NO AI): genAndApplyManifest normalizes any
+ *     design-provided inline manifest into a valid one (fixes namespace form + backfills schemaRef/backing/
+ *     writeRole/mode, rekeys schemas, derives a records schema when missing) and falls back to a plain
+ *     document space — instead of a flaky per-workspace AI generator call that left some workspaces as
+ *     "set up when opened". Every workspace now gets its structure reliably, every time. Verified on the
+ *     dev server: a 6-workspace design (with non-conforming komento.* namespaces) all came out structured.
+ *   v0.20.0 — 2026-06-30 — Content at handshake: a fresh hire now fills its workspaces with REAL content
+ *     immediately (POST /v1/secretary/author-now, long timeout) and drops any left empty; the workspace
+ *     generator runs with skipExamples so no fake "example-N" placeholder records are written.
+ *   v0.19.0 — 2026-06-30 — Strategy: setup now auto-links milestones to goals. seedGoals returns the
+ *     assigned goal ids in order; applyResult seeds goals before building the strategy and resolves each
+ *     milestone's index-based goalRefs to real ids (linkMilestoneGoals); reshape strips dangling index
+ *     refs; AI re-plan passes existing goals and validates returned id refs (keepKnownGoalRefs). Removes
+ *     the manual "tick the linked goals" step after setup.
+ *   v0.18.0 — 2026-06-28 — Strategy: optional per-context steering frame (vision/mission/principles/risks
+ *     + current → target + ordered milestone gates). strategyCard slot + handlers (edit fields, milestone
+ *     CRUD/reorder/status, link goals, AI re-plan), enable from Manage & setup, carried in applyResult.
+ *   v0.17.0 — 2026-06-28 — "Reset Secretary": guarded full-wipe card in Manage & setup (doReset →
+ *     POST /v1/secretary/reset → reload to the clean setup screen).
+ *   v0.16.0 — 2026-06-28 — Bound triggers: pass specialists + workflows into triggersCard and the
+ *     calendar event dialog so a trigger's fire can be bound to a workflow/specialist run.
+ *   v0.15.0 — 2026-06-28 — B5 (secretary-view-redesign): action-items. The autonomous tick now advances
+ *     active routines band-driven (act-band file steps auto-run; draft/ask/delegate → action-items) and
+ *     writes contexts[i].actionItems[]; the dashboard renders them (actionItemsCard) with a one-click
+ *     handle (open the routine / check a delegated result) or dismiss. Handlers in useWhatsNext.
+ *   v0.14.0 — 2026-06-27 — B3 (secretary-view-redesign): dynamic quick actions. useQuickActions manages
+ *     per-context quickActions[] — 2–3 brain-seeded shortcuts (active on hire) + secretary-PROPOSED ones
+ *     the owner pins. Active dynamic actions render in the quick row (prompt → canned chat message, compose
+ *     → focus an input); a ✎ panel (quickActionsManager) pins/dismisses proposals + renames/reorders/removes.
+ *     Security: the Secretary may seed/propose only prompt|compose, never a run verb (sanitizeQuickActions).
+ *   v0.13.0 — 2026-06-27 — B2 (secretary-view-redesign): Routines + "What's next". The guided plan is
+ *     generalised into useWhatsNext — propose a new Routine from a goal OR advance an active one, approve
+ *     each step band-gated (act → run · draft|ask → approve + log a decision · off → skip), execute the
+ *     automatable part (discover/file; delegation deferred to B4), and persist under
+ *     contexts[i].routines[]. Active routines render on the dashboard (routinesCard).
+ *   v0.12.0 — 2026-06-27 — B1 (secretary-view-redesign): dashboard-first IA. A core quick-action row
+ *     ("Where do things stand?" read-only orientation · Plan/Find/Note focus · Review decisions when
+ *     due), a "Today" status strip (reliability · budget · next run · last-scan + stale + refresh) above
+ *     the feed/decision-log, chat below, and the set-up-once config cards (brain/operating/crew/knowledge/
+ *     access/history/permissions) moved into a collapsed "Manage & setup" disclosure. Chrome in dashboard.js.
+ *   v0.11.0 — 2026-06-25 — load() reads OpenRouter settings first (which backfills the Secretary agent
+ *     when a key exists) and tracks hasOpenRouterKey, so a pre-configured owner is provisioned on view
+ *     load and the "not set up" message correctly distinguishes "no key" from "provisioning".
  *   v0.10.0 — 2026-06-24 — P3: doc/image intake into the chat (chatCard 📎 → intake.handleAttach:
  *     upload → vision summary → file into the active context's self-organism) and auto-logged decision
  *     contracts from answered Ask cards + approved guided plans (learning loop now sees real choices).
@@ -32,18 +94,27 @@ import { h } from 'preact';
 import htm from 'htm';
 const html = htm.bind(h);
 import { useState, useEffect, useCallback, useMemo } from 'preact/hooks';
-import { t } from '/js/i18n.js';
-import { api, apiGet, apiPost, apiPut } from '/js/api.js';
+import { t, getLocale } from '/js/i18n.js';
+import { api, apiGet, apiPost, apiPut, apiDelete } from '/js/api.js';
 import { useViewCSS } from '/components/useViewCSS.js';
 import { useToast } from '/components/Toast.js';
-import { createOrganism, createWorkspace } from '/js/services/organisms.js';
-import { defaultPolicy, mergePolicy } from '/js/services/secretary-policy.js';
-import { buildDesignPrompt, extractJson, snapshotOf, genCtxId, migrateConfig, suggestContextId, computeBudgetInfo, computeReliability, SECRETARY_AIMEAT_PRIMER } from '/js/services/secretary-helpers.js';
-import { contextSwitcher, hirePanel, chatCard, findCard, noteCard, decisionsCard, brainCard, operatingCard, historyCard, metaCard, guidedPlanCard, feedCard, automationCard, goalsCard, decisionLogCard } from '/views/secretary/cards.js';
+import { createOrganism, createWorkspace, validateGenerated, applyGeneratedWorkspace } from '/js/services/organisms.js';
+import { defaultPolicy, mergePolicy, autonomyPreset } from '/js/services/secretary-policy.js';
+import { buildDesignPrompt, extractJson, snapshotOf, genCtxId, migrateConfig, suggestContextId, computeBudgetInfo, computeReliability, sanitizeQuickActions, normalizeStrategy, MILESTONE_STATUSES, buildStrategyReplanPrompt, linkMilestoneGoals, keepKnownGoalRefs, SECRETARY_AIMEAT_PRIMER } from '/js/services/secretary-helpers.js';
+import { contextSwitcher, hirePanel, chatCard, findCard, noteCard, decisionsCard, brainCard, operatingCard, historyCard, metaCard, whatsNextCard, feedCard, automationCard, goalsCard, decisionLogCard } from '/views/secretary/cards.js';
 import { createResourceCard, knowledgeCard, accessCard, crewCard } from '/views/secretary/cards-reach.js';
+import { quickActionRow, dashStatus, standPanel, briefTrayCard, whatsNextPanel, actionItemsCard, routinesCard, triggersCard, quickActionsManager, manageHeader, workflowDesignPanel, secretaryDangerCard, strategyCard } from '/views/secretary/dashboard.js';
+import { fetchWorkflowOffers, designWorkflow, saveDesignedWorkflow, slugifyWorkflowId } from '/views/secretary/workflow-design.js';
+import { useSpecialists, specialistsCard } from '/views/secretary/use-specialists.js';
 import { useIntake } from '/views/secretary/use-intake.js';
-import { useGuidedPlan } from '/views/secretary/use-guided-plan.js';
+import { useWhatsNext } from '/views/secretary/use-whats-next.js';
+import { useQuickActions } from '/views/secretary/use-quick-actions.js';
+import { useFreshness } from '/views/secretary/use-freshness.js';
 import { useAutonomy } from '/views/secretary/use-autonomy.js';
+import { useCalendar, calendarCard, CalendarEventDialog } from '/views/secretary/calendar.js';
+import { useTriggers } from '/views/secretary/use-triggers.js';
+import { useLayout, LayoutCard } from '/views/secretary/use-layout.js';
+import { produceDeliverable, getAiCapability, reasonJson } from '/views/secretary/quality.js';
 import { useLearning } from '/views/secretary/use-learning.js';
 import { useCreateResource } from '/views/secretary/use-create-resource.js';
 import { useKnowledge } from '/views/secretary/use-knowledge.js';
@@ -62,10 +133,17 @@ export default function SecretaryView() {
   useViewCSS('/css/views/secretary.css');
   const { showToast, ToastContainer } = useToast();
   const [secretary, setSecretary] = useState(undefined); // undefined=loading, null=not provisioned
+  const [hasOpenRouterKey, setHasOpenRouterKey] = useState(false); // owner has an OpenRouter key configured
   const [config, setConfig] = useState(null);            // { contexts:[...], activeContextId }
+  const [briefs, setBriefs] = useState([]);              // open Work Briefs (heavy work to hand a Builder)
+  const [builders, setBuilders] = useState([]);          // connected big-AI agents (not Secretary / specialists)
+  const [dispatching, setDispatching] = useState('');    // briefId currently being dispatched
   const [result, setResult] = useState('');
   const [needs, setNeeds] = useState('');
   const [applying, setApplying] = useState(false);
+  const [setupStep, setSetupStep] = useState(null);      // live setup progress: { phase, done, total, name }
+  const [chooseMode, setChooseMode] = useState(false);   // showing the "how should it work?" autonomy step
+  const [setupMode, setSetupMode] = useState('draft');   // chosen autonomy: 'off' | 'draft' | 'act'
   const [generating, setGenerating] = useState(false);
   const [showHire, setShowHire] = useState(false);
   const [hireMode, setHireMode] = useState('new');       // 'new' (add context) | 'edit' (re-run active)
@@ -76,6 +154,18 @@ export default function SecretaryView() {
   const [findScope, setFindScope] = useState('public');
   const [findResults, setFindResults] = useState(null);  // null=not searched, []=none, [...]
   const [finding, setFinding] = useState(false);
+  const [manageOpen, setManageOpen] = useState(false);   // B1: collapsed "Manage & setup" disclosure
+  const [stand, setStand] = useState(null);              // B1: read-only "where things stand" summary { loading } | { text }
+  const [nextAns, setNextAns] = useState(null);          // "What's next?" — the Secretary's forward answer { loading } | { text }
+  const [pasteDrafts, setPasteDrafts] = useState({});    // prompt-driven path: pasted-back result text, keyed by action id
+  const [wfDesign, setWfDesign] = useState(null);        // "Design a workflow" flow: null | { outcome, designing, draft, trigger, error, saving, saved, errors }
+  const [calEvent, setCalEvent] = useState(null);        // clicked calendar entry → inline type-specific editor dialog
+  const [resetState, setResetState] = useState({ show: false, text: '', busy: false }); // "Reset Secretary" guard
+  const [stratEdit, setStratEdit] = useState(null);      // Strategy text/list edit draft | null
+  const [msInput, setMsInput] = useState('');            // Strategy "add milestone" input
+  const [replan, setReplan] = useState(null);            // Strategy re-plan flow: { note } | { busy } | { draft } | null
+  const [brainDraft, setBrainDraft] = useState(null);    // C2: direct brain editor draft { purpose, rules[] } | null
+  const [savingBrain, setSavingBrain] = useState(false);
 
   const owner = (secretary && secretary.owner)
     || (window.AIMEAT && window.AIMEAT.auth && window.AIMEAT.auth.getSession && window.AIMEAT.auth.getSession()?.owner)
@@ -92,22 +182,52 @@ export default function SecretaryView() {
   }, []);
 
   const load = useCallback(async () => {
+    // Read OpenRouter settings FIRST: this GET also provisions the Secretary agent when a key exists
+    // (backfill for owners who configured OpenRouter before the feature shipped), so by the time we
+    // list agents below the agent is present. Also tells us whether to show "configure OpenRouter".
+    const settingsResp = await apiGet('/v1/openrouter/settings').catch(() => null);
+    setHasOpenRouterKey(!!(settingsResp && settingsResp.data && settingsResp.data.hasApiKey));
     const agentsResp = await apiGet('/v1/agents').catch(() => null);
     const agents = (agentsResp && agentsResp.data && agentsResp.data.agents) || [];
     const sec = agents.find((a) => (a.tags || []).includes('system:secretary'))
       || agents.find((a) => a.name === 'secretary') || null;
     setSecretary(sec);
+    // Builders = connected big-AI agents the heavy work is dispatched to — anything that is NOT the
+    // Secretary (the watcher) and NOT a node-local specialist. These are visually distinct in the brief tray.
+    setBuilders(agents.filter((a) => a && a.name !== 'secretary'
+      && !(a.tags || []).includes('system:secretary') && !(a.tags || []).includes('system:specialist')));
     if (!sec) return;
-    const [dir, cfg] = await Promise.all([
+    const [dir, cfg, briefResp] = await Promise.all([
       apiGet('/v1/agents/secretary/directives').catch(() => null),
       apiGet('/v1/memory/secretary.config').catch(() => null),
+      apiGet('/v1/secretary/briefs').catch(() => null),
     ]);
+    setBriefs((briefResp && briefResp.data && briefResp.data.briefs) || []);
     const rawCfg = (cfg && cfg.data && cfg.data.value) || null;
     const { config: normalized, changed } = migrateConfig(rawCfg, dir && dir.data);
     if (changed) await apiPost('/v1/memory', { key: 'secretary.config', value: normalized, visibility: 'private' }).catch(() => {});
     setConfig(normalized);
   }, []);
 
+  // Dispatch a Work Brief to a connected Builder (lane b): queues a task the Builder picks up + runs via
+  // the appdev MCP tools. Marks the brief 'dispatched' so the tray reflects "waiting on the Builder".
+  const dispatchBrief = useCallback(async (briefId, agentGaii) => {
+    if (!briefId || !agentGaii) return;
+    setDispatching(briefId);
+    try {
+      const r = await apiPost(`/v1/secretary/brief/${encodeURIComponent(briefId)}/dispatch`, { targetAgent: agentGaii }).catch(() => null);
+      if (r && r.data) { showToast(t('secretary.brief.dispatched')); load(); }
+      else showToast(t('secretary.brief.dispatchFailed'), true);
+    } finally { setDispatching(''); }
+  }, [load, showToast]);
+
+  // Resolve a Work Brief (the owner handled it themselves, or it's no longer relevant). Marks it 'done'.
+  const resolveBrief = useCallback(async (briefId) => {
+    if (!briefId) return;
+    await apiPost(`/v1/secretary/brief/${encodeURIComponent(briefId)}/done`, {}).catch(() => null);
+    load();
+  }, [load]);
+
   useEffect(() => { load(); }, [load]);
 
   // Re-fetch config on server-reported changes: the autonomous tick writes pending decisions + the
@@ -127,11 +247,36 @@ export default function SecretaryView() {
   // Cheap, AI-free routing suggestion: does what you're typing belong to another context? (§22)
   const routeSuggestion = useMemo(() => suggestContextId(chatInput, contexts, activeId), [chatInput, contexts, activeId]);
 
+  // "Reset Secretary" — full wipe (brain + all secretary.* + self-organisms/workspaces + specialists +
+  // tick schedule), keeping the OpenRouter key. Guarded by a typed RESET confirm; reloads to the clean
+  // setup screen afterward (state across many hooks is fully torn down server-side).
+  const doReset = useCallback(async () => {
+    setResetState((s) => ({ ...s, busy: true }));
+    try {
+      await apiPost('/v1/secretary/reset', {});
+      showToast(t('secretary.reset.done'));
+      setTimeout(() => window.location.reload(), 700);
+    } catch (e) {
+      showToast(`${t('secretary.reset.error')}: ${e.message}`, true);
+      setResetState((s) => ({ ...s, busy: false }));
+    }
+  }, [showToast]);
+
   // Load the active context's conversation (chat is per-context).
   useEffect(() => {
+    setStand(null);
+    setNextAns(null);
     if (!activeId) { setChat([]); return; }
     let cancelled = false;
     setChat([]);
+    // Restore the last "where things stand" so it persists across reloads (with its timestamp).
+    apiGet(`/v1/memory/${encodeURIComponent('secretary.stand.' + activeId)}`)
+      .then((r) => { const v = r && r.data && r.data.value; if (!cancelled && v && v.text) setStand({ text: v.text, generatedAt: v.generatedAt }); })
+      .catch(() => {});
+    // Restore the last "What's next" list (with its do/skip state) so leaving and coming back keeps it.
+    apiGet(`/v1/memory/${encodeURIComponent('secretary.next.' + activeId)}`)
+      .then((r) => { const v = r && r.data && r.data.value; if (!cancelled && v && Array.isArray(v.actions) && v.actions.length) setNextAns(v); })
+      .catch(() => {});
     apiGet(`/v1/memory/${encodeURIComponent('secretary.chat.' + activeId)}`)
       .then((r) => {
         if (cancelled) return;
@@ -142,14 +287,29 @@ export default function SecretaryView() {
     return () => { cancelled = true; };
   }, [activeId]);
 
+  // Persist the "What's next" list (and its do/skip state) so navigating away and back keeps it.
+  // Stamped with ctxId so a context switch never writes the old list under the new context's key.
+  useEffect(() => {
+    if (!activeId || !nextAns || !Array.isArray(nextAns.actions) || nextAns.ctxId !== activeId) return;
+    apiPost('/v1/memory', { key: `secretary.next.${activeId}`, value: nextAns, visibility: 'private' }).catch(() => {});
+  }, [nextAns, activeId]);
+
   // Intake (note composer + Ask cards + P2-E cross-context auto-routing) lives in its own hook.
-  const intake = useIntake({ active, contexts, config, persistConfig, owner, showToast });
+  // Triggers (Slice 3/4) — declared before intake so a filed note can ask the Secretary to auto-propose a trigger.
+  const trig = useTriggers({ active, showToast });
+  const intake = useIntake({ active, contexts, config, persistConfig, owner, showToast, onNoteFiled: trig.proposeTriggerFromText });
   const { wsList, suggestedWsId } = intake;
 
-  // Phase 3c — guided playbook (propose steps → approve → execute). Logic lives in its own hook.
-  const plan = useGuidedPlan({ active, suggestedWsId, wsList, showToast });
+  // B2 — Routines + "What's next" (generalises the guided plan): propose/advance band-gated routines.
+  const next = useWhatsNext({ active, config, persistConfig, policy, wsList, suggestedWsId, showToast });
+  // B3 — dynamic quick actions (brain-seeded + secretary-proposed, owner-pinned).
+  const qa = useQuickActions({ active, config, persistConfig, owner, showToast });
   // Phase 4 — autonomous tick + Home feed + calendar (own hook).
   const auto = useAutonomy({ showToast });
+  // Decision B — real calendar (month/week/day) of feed (past) + tick & routine cadence (future).
+  const cal = useCalendar();
+  const lay = useLayout();   // customizable dashboard layout (pin to column / reorder / hide; persisted)
+  const spec = useSpecialists({ showToast });   // create/list/run the owner's specialists (Phase 3 building blocks)
   // Phase 5 — learning loop: goals + decision-log contracts + review trigger (own hook).
   const learn = useLearning({ active, auto, showToast });
   // P2 reach: create-don't-just-find (A), knowledge custodian (B), access gatekeeper (C), crew setup (D).
@@ -162,7 +322,108 @@ export default function SecretaryView() {
   const budgetInfo = useMemo(() => computeBudgetInfo(policy.dailyMorselBudget, config, activeId), [policy.dailyMorselBudget, config, activeId]);
   const reliability = useMemo(() => computeReliability(learn.decisions), [learn.decisions]);
 
-  const applyResult = useCallback(async () => {
+  /** C3: seed the hire-proposed goals as standalone goal records (so the learning loop isn't empty). */
+  // Seed the proposed goals and RETURN their assigned ids in input order (null for a skipped/failed one),
+  // so milestone goalRefs (the AI links them by 1-based goal index) can be resolved to real goal ids.
+  const seedGoals = useCallback(async (goals, contextId, contextName) => {
+    const arr = Array.isArray(goals) ? goals.slice(0, 4) : [];
+    const ids = [];
+    for (const g of arr) {
+      const title = String((g && g.title) || '').trim();
+      if (!title) { ids.push(null); continue; }
+      const gid = 'g' + Date.now().toString(36) + Math.random().toString(36).slice(2, 5);
+      const ok = await apiPost('/v1/memory', { key: `secretary.goal.${gid}`, value: { id: gid, title: title.slice(0, 200), why: String((g && g.why) || '').trim().slice(0, 300), status: 'open', contextId, contextName, createdAt: new Date().toISOString() }, visibility: 'private', tags: ['secretary', 'goal', 'open', contextId] }).then(() => true).catch(() => false);
+      ids.push(ok ? gid : null);
+    }
+    return ids;
+  }, []);
+
+  // ── Deterministic workspace structure (NO AI) ──
+  // The design JSON's inline manifests routinely fail the workspace validator (wrong namespace form, or
+  // missing schemaRef/backing/writeRole), which used to push EACH workspace into a flaky per-workspace AI
+  // generator call — owl-alpha failing some of those left workspaces as "set up when opened". Instead we
+  // NORMALIZE any inline manifest into a valid one ourselves, and fall back to a plain document space.
+  // Zero AI calls → every workspace gets its structure reliably, every time.
+  const WS_TYPE_MAP = { text: 'string', number: 'number', date: 'string', select: 'string', boolean: 'boolean', reference: 'string' };
+  const wsSlug = (s) => String(s || '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'tila';
+  const backfillEnvelope = (mf, wsId, name) => {
+    if (!mf) return;
+    mf.manifestVersion = mf.manifestVersion || '1.0';
+    mf.id = mf.id || wsId;
+    mf.name = mf.name || name;
+    mf.kind = mf.kind || 'project';
+    mf.status = ['active', 'paused', 'done', 'archived'].includes(mf.status) ? mf.status : 'active';
+  };
+  // Make ANY inline manifest valid: backfill the envelope + each objectType's required fields, normalize
+  // the namespace to the required shared.* form (rekeying its schema), and derive a schema for a records
+  // type that lacks one. Mutates `manifest`; may add keys to `schemas`.
+  const normalizeInlineManifest = (manifest, schemas, wsId, name) => {
+    backfillEnvelope(manifest, wsId, name);
+    const ots = Array.isArray(manifest.objectTypes) ? manifest.objectTypes : [];
+    manifest.objectTypes = ots.filter(Boolean).map((ot, i) => {
+      const o = { ...ot };
+      o.name = String(o.name || ('tila' + (i + 1))).trim() || ('tila' + (i + 1));
+      let ns = String(o.namespace || ('shared.' + wsSlug(o.name)));
+      if (!/^(meta|shared|member)\./.test(ns)) {
+        const tail = ns.includes('.') ? ns.slice(ns.indexOf('.') + 1) : ns;
+        const newNs = 'shared.' + (wsSlug(tail) || wsSlug(o.name));
+        if (schemas[o.namespace] && !schemas[newNs]) { schemas[newNs] = schemas[o.namespace]; delete schemas[o.namespace]; }
+        ns = newNs;
+      }
+      o.namespace = ns;
+      o.backing = o.backing === 'tasks' ? 'tasks' : 'memory';
+      o.writeRole = ['owner', 'admin', 'member'].includes(o.writeRole) ? o.writeRole : 'member';
+      o.cardinality = o.cardinality === 'one' ? 'one' : 'many';
+      o.versioned = o.versioned !== false;
+      o.schemaRef = o.schemaRef || ('schema:' + wsSlug(o.name) + '@1');
+      // Document-first: keep an explicit mode as the design gave it; for an UNSPECIFIED space default to a
+      // DOCUMENT (flexible information — the common case) unless the design clearly describes a record list
+      // (real fields, or a schema already supplied for it). A records space is for same-shaped, list-like
+      // data (actions/tasks/bugs/a pipeline/a tracker) only.
+      if (o.mode !== 'document' && o.mode !== 'records') {
+        o.mode = ((Array.isArray(o.fields) && o.fields.length) || schemas[ns]) ? 'records' : 'document';
+      }
+      if (o.mode !== 'document' && o.backing === 'memory' && !schemas[ns]) {
+        const props = {}; (o.fields || []).forEach((f) => { if (f && f.name) props[f.name] = { type: WS_TYPE_MAP[f.type] || 'string' }; });
+        if (!props.id) props.id = { type: 'string' };
+        schemas[ns] = { type: 'object', properties: props, required: ['id'] };
+      }
+      return o;
+    });
+    // Never-empty guarantee: every workspace needs at least one DOCUMENT space — a free-markdown "thinking
+    // home" the setup fill can always author grounded content into, even when the design gave only records
+    // spaces (records are real-data-only and legitimately start empty). Append a default document space when
+    // the design provided none. Additive + idempotent: only when no document space exists.
+    if (!manifest.objectTypes.some((o) => o.mode === 'document')) {
+      let dns = 'shared.muistiinpanot';
+      if (manifest.objectTypes.some((o) => o.namespace === dns)) dns = 'shared.muistiinpanot-' + wsSlug(name);
+      manifest.objectTypes.push({ name: 'Muistiinpanot', namespace: dns, backing: 'memory', writeRole: 'member', cardinality: 'many', versioned: true, schemaRef: 'schema:doc@1', mode: 'document' });
+    }
+  };
+  // A plain document space (free markdown) — the deterministic fallback so a workspace with no usable
+  // manifest still gets a valid structure at setup, without any AI call.
+  const docSpaceManifest = (wsId, name) => ({
+    manifest: { manifestVersion: '1.0', id: wsId, name, kind: 'notes', status: 'active',
+      objectTypes: [{ name: 'Dokumentit', namespace: 'shared.dokumentit', backing: 'memory', writeRole: 'member', cardinality: 'many', versioned: true, schemaRef: 'schema:doc@1', mode: 'document' }] },
+    schemas: {},
+  });
+  const genAndApplyManifest = useCallback(async (orgId, wsId, ws) => {
+    const name = String(ws.name || '').trim() || 'Työtila';
+    try {
+      // skipExamples: the Secretary fills workspaces with REAL content at setup (author-now), never fakes.
+      if (ws.manifest && typeof ws.manifest === 'object') {
+        const schemas = { ...(ws.schemas || {}) };
+        const manifest = JSON.parse(JSON.stringify(ws.manifest));
+        normalizeInlineManifest(manifest, schemas, wsId, name);
+        const provided = { manifest, schemas };
+        if (!validateGenerated(provided).length) { await applyGeneratedWorkspace(orgId, wsId, provided, { skipExamples: true }); return; }
+      }
+      // No usable inline manifest → a plain document space, applied deterministically (no AI).
+      await applyGeneratedWorkspace(orgId, wsId, docSpaceManifest(wsId, name), { skipExamples: true });
+    } catch { /* leave it manifest-less; the owner can set it up manually */ }
+  }, []);
+
+  const applyResult = useCallback(async (mode = 'off') => {
     setApplying(true);
     try {
       const json = extractJson(result);
@@ -177,6 +438,8 @@ export default function SecretaryView() {
       }
       const newBrain = { purpose: b.purpose, rules };
       const isNew = hireMode === 'new' || !active;
+      setSetupStep({ phase: 'structure' });   // live progress: building the space + workspaces
+      let fillTargets = [];                    // [{ id, name }] of new workspaces to fill one at a time
 
       let next;
       if (isNew) {
@@ -185,6 +448,7 @@ export default function SecretaryView() {
         const orgId = created && created.data && created.data.organism && created.data.organism.id;
         const wsSummary = [];
         if (orgId) {
+          const created = [];
           for (const ws of org.workspaces.slice(0, 12)) {
             const name = String(ws.name || '').trim();
             if (!name) continue;
@@ -192,35 +456,133 @@ export default function SecretaryView() {
             if (entry && entry.id && ws.purpose) {
               await apiPost('/v1/memory', { key: `organism.${orgId}.w.${entry.id}.meta.readme`, value: `# ${name}\n\n${ws.purpose}`, visibility: 'private' });
             }
+            if (entry && entry.id) created.push({ wsId: entry.id, ws });
             wsSummary.push({ name, purpose: ws.purpose || '' });
           }
+          // Design + apply each workspace's manifest in parallel so they come out usable, not empty shells.
+          await Promise.all(created.map((c) => genAndApplyManifest(orgId, c.wsId, c.ws)));
+          fillTargets = created.map((c) => ({ id: c.wsId, name: String((c.ws && c.ws.name) || '').trim() || c.wsId }));
         }
-        const ctx = { id: genCtxId(), name: org.name, brain: newBrain, organismId: orgId || null, organismName: org.name, workspaces: wsSummary, policy: defaultPolicy(), brainHistory: [] };
+        // B3: seed the brain-proposed quick actions — active on hire (run verbs are dropped by the sanitizer).
+        const quickActions = sanitizeQuickActions(json.quickActions, 'brain', 'active');
+        const ctxId = genCtxId();
+        // C3: seed the proposed goals FIRST (so the learning loop starts populated, not "no goals yet") and
+        // capture their ids, so each milestone's goalRefs (the AI links them by 1-based goal index) resolve
+        // to real goal ids — this is what lets a milestone auto-advance as its goals get done, instead of
+        // the owner ticking the linked goals by hand after setup.
+        const goalIds = await seedGoals(json.goals, ctxId, org.name);
+        const strategy = linkMilestoneGoals(normalizeStrategy(json.strategy), goalIds);
+        // Autonomy chosen in the setup step controls only how active the DAILY tick is (it watches, briefs,
+        // and proposes Work Briefs — it never authors content itself, so there is no "fill" band any more).
+        const policy = defaultPolicy();
+        const ctx = { id: ctxId, name: org.name, brain: newBrain, organismId: orgId || null, organismName: org.name, workspaces: wsSummary, policy, brainHistory: [], quickActions, strategy };
         next = { contexts: [...contexts, ctx], activeContextId: ctx.id };
       } else {
-        // Re-run on the active context: update its brain, snapshot the old one. Keep its organism.
+        // Re-run on the active context (reshape): update its brain, snapshot the old one, KEEP its
+        // organism. C1: ADD any newly-proposed workspaces (additive — never rename/remove existing;
+        // removal stays a manual decision in the Organisms view, so no data is ever auto-deleted).
         const prev = snapshotOf(active.brain);
         const history = [prev, ...(active.brainHistory || [])].filter(Boolean).slice(0, 10);
-        const updated = { ...active, brain: newBrain, brainHistory: history };
+        const existingNames = new Set((active.workspaces || []).map((w) => String(w.name).toLowerCase()));
+        const addedWs = [];
+        if (active.organismId && Array.isArray(org.workspaces)) {
+          const created = [];
+          for (const ws of org.workspaces.slice(0, 12)) {
+            const name = String(ws.name || '').trim();
+            if (!name || existingNames.has(name.toLowerCase())) continue;
+            const entry = await createWorkspace(active.organismId, name);
+            if (entry && entry.id && ws.purpose) {
+              await apiPost('/v1/memory', { key: `organism.${active.organismId}.w.${entry.id}.meta.readme`, value: `# ${name}\n\n${ws.purpose}`, visibility: 'private' });
+            }
+            if (entry && entry.id) created.push({ wsId: entry.id, ws });
+            addedWs.push({ name, purpose: ws.purpose || '' });
+          }
+          await Promise.all(created.map((c) => genAndApplyManifest(active.organismId, c.wsId, c.ws)));
+        }
+        // Strategy: if the reshape JSON proposes one, take it; otherwise keep what the context already had.
+        // Reshape doesn't re-seed goals, so a milestone's index-based goalRefs can't be resolved here —
+        // strip them (linkMilestoneGoals with no id list) rather than persist dangling references.
+        const strategy = json.strategy !== undefined ? linkMilestoneGoals(normalizeStrategy(json.strategy), []) : (active.strategy || normalizeStrategy(null));
+        const updated = { ...active, brain: newBrain, brainHistory: history, workspaces: [...(active.workspaces || []), ...addedWs], strategy };
         next = { ...config, contexts: contexts.map((c) => (c.id === active.id ? updated : c)) };
       }
       await persistConfig(next);
       await syncDirectives(newBrain);
-      showToast(t('secretary.hireDone'));
+      window.dispatchEvent(new CustomEvent('aimeat-live-update')); // refresh goals/learning + cards
+      // The Secretary NO LONGER authors content one-shot at handshake (the cheap model hallucinated and went
+      // "onto the Builders' turf"). Instead it now proposes grounded Work Briefs for the new (empty)
+      // workspaces — heavy work a Builder (a connected big AI via the appdev MCP tools) executes. Fast +
+      // deterministic (no slow model call); the dashboard's brief tray then offers "Open in Claude Desktop"
+      // / "Send to a connected Builder". Only on a fresh hire, so it never touches existing content.
+      if (isNew && fillTargets.length) {
+        setSetupStep({ phase: 'fill', done: 0, total: fillTargets.length, name: fillTargets[0].name });
+        const r = await api('/v1/secretary/brief', { method: 'POST', body: '{}', timeoutMs: 120000, retries: 1 }).catch(() => null);
+        const proposed = (r && r.data && typeof r.data.proposed === 'number') ? r.data.proposed : 0;
+        setSetupStep({ phase: 'done', done: fillTargets.length, total: fillTargets.length });
+        window.dispatchEvent(new CustomEvent('aimeat-live-update')); // briefs show up in the tray live
+        showToast(proposed ? `${t('secretary.briefsReady')} (${proposed})` : t('secretary.hireDone'));
+      } else {
+        showToast(t('secretary.hireDone'));
+      }
+      // If the owner chose an autonomous mode, turn the daily check-in ON for them — so it actually keeps
+      // working on its own (the band alone does nothing without a schedule). 'off' stays fully manual.
+      if (isNew && mode !== 'off') {
+        await apiPost('/v1/schedules', { kind: 'secretary', cron: '0 8 * * *', display_name: t('secretary.auto.scheduleName') }).catch(() => {});
+      }
       setResult(''); setNeeds(''); setShowHire(false);
     } catch (e) {
       showToast(`${t('secretary.hireError')}: ${e.message}`, true);
     } finally {
-      setApplying(false);
+      setApplying(false); setSetupStep(null);
+    }
+  }, [result, hireMode, active, contexts, config, persistConfig, syncDirectives, seedGoals, genAndApplyManifest, showToast]);
+
+  // "Set up my Secretary" no longer runs immediately — it first asks (one step, up front) HOW autonomous
+  // the owner wants it, explained in plain words, so nobody stumbles into Act bands later. The chosen mode
+  // is passed to applyResult. Only for a brand-new hire; re-running an existing context keeps its policy.
+  const startSetup = useCallback(() => {
+    if (!result.trim()) return;
+    try { extractJson(result); } catch { showToast(t('secretary.hireBadShape'), true); return; }
+    if (hireMode === 'new' || !active) { setSetupMode('draft'); setChooseMode(true); } else { applyResult('off'); }
+  }, [result, hireMode, active, applyResult, showToast]);
+  const confirmSetup = useCallback(() => { setChooseMode(false); applyResult(setupMode); }, [applyResult, setupMode]);
+
+  // C2 — direct brain editor: edit the active context's purpose + rules in place (no AI re-run).
+  const startBrainEdit = useCallback(() => {
+    if (!active) return;
+    setBrainDraft({ purpose: (active.brain && active.brain.purpose) || '', rules: ((active.brain && active.brain.rules) || []).map((r) => ({ id: r.id, description: r.description })) });
+  }, [active]);
+  const cancelBrainEdit = useCallback(() => setBrainDraft(null), []);
+  const saveBrain = useCallback(async () => {
+    if (!active || !brainDraft) return;
+    const purpose = String(brainDraft.purpose || '').trim();
+    if (!purpose) { showToast(t('secretary.brainEmptyPurpose'), true); return; }
+    const rules = (brainDraft.rules || [])
+      .map((r) => ({ id: r.id || ('r' + Math.random().toString(36).slice(2, 6)), description: String(r.description || '').trim() }))
+      .filter((r) => r.description);
+    setSavingBrain(true);
+    try {
+      const newBrain = { purpose, rules };
+      const prev = snapshotOf(active.brain);
+      const history = [prev, ...(active.brainHistory || [])].filter(Boolean).slice(0, 10);
+      const updated = { ...active, brain: newBrain, brainHistory: history };
+      await persistConfig({ ...config, contexts: contexts.map((c) => (c.id === active.id ? updated : c)) });
+      await syncDirectives(newBrain);
+      setBrainDraft(null);
+      showToast(t('secretary.brainSaved'));
+    } catch (e) {
+      showToast(`${t('secretary.hireError')}: ${e.message}`, true);
+    } finally {
+      setSavingBrain(false);
     }
-  }, [result, hireMode, active, contexts, config, persistConfig, syncDirectives, showToast]);
+  }, [active, brainDraft, config, contexts, persistConfig, syncDirectives, showToast]);
 
   const generateInApp = useCallback(async () => {
     if (!needs.trim()) return;
     setGenerating(true);
     try {
       // Long AI completion: low-level api() with a large timeout + no retries (apiPost's 30s would abort a slow model).
-      const r = await api('/v1/ai/complete', { method: 'POST', body: JSON.stringify({ prompt: buildDesignPrompt(owner, needs.trim()), app_id: 'secretary-setup' }), timeoutMs: 1_800_000, retries: 0 });
+      const r = await api('/v1/ai/complete', { method: 'POST', body: JSON.stringify({ prompt: buildDesignPrompt(owner, needs.trim(), hireMode === 'edit' ? active : null), app_id: 'secretary-setup' }), timeoutMs: 1_800_000, retries: 0 });
       const content = r && r.data && r.data.content;
       if (!content) throw new Error(t('secretary.inappEmpty'));
       setResult(content);
@@ -230,17 +592,18 @@ export default function SecretaryView() {
     } finally {
       setGenerating(false);
     }
-  }, [needs, owner, showToast]);
+  }, [needs, owner, hireMode, active, showToast]);
 
   /** One chat turn: assemble the active context's brain as the system prompt + the transcript,
    *  complete on the owner's key, append + persist. Per-context conversation (secretary.chat.{id}). */
-  const sendChat = useCallback(async () => {
-    const text = chatInput.trim();
+  const sendChat = useCallback(async (override) => {
+    // `override` lets a dynamic quick action (kind:'prompt') send a canned message without touching the input.
+    const text = (typeof override === 'string' ? override : chatInput).trim();
     if (!text || !active) return;
     setChatSending(true);
     const history = [...chat, { role: 'user', content: text }];
     setChat(history);
-    setChatInput('');
+    if (typeof override !== 'string') setChatInput('');
     try {
       const rules = (active.brain.rules || []).map((r) => '- ' + r.description).join('\n');
       const wsNames = (active.workspaces || []).map((w) => w.name).join(', ');
@@ -286,6 +649,286 @@ ${SECRETARY_AIMEAT_PRIMER}`;
     }
   }, [findQ, findScope, showToast]);
 
+  // ── B1/G3 dashboard freshness (lastScan + stale + the real discover Reconcile) — in its own hook ──
+  const { lastScan, stale, scanning, reconcile } = useFreshness({ active, config, contexts, persistConfig, auto, showToast });
+
+  // Quick-action "focus" verbs: smooth-scroll a working card into view and focus its input.
+  const focusInto = useCallback((sel, inputSel) => {
+    const el = document.querySelector(sel);
+    if (!el) return;
+    el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+    if (inputSel) { const i = el.querySelector(inputSel); if (i) setTimeout(() => i.focus(), 250); }
+  }, []);
+
+  // "Review decisions" is only offered when an open decision is due for its revisit.
+  const decisionsDue = useMemo(() => {
+    const now = Date.now();
+    return (learn.decisions || []).some((d) => d && d.status === 'open' && d.revisitWhen && new Date(d.revisitWhen).getTime() <= now);
+  }, [learn.decisions]);
+
+  // B3: active dynamic quick actions → row items. prompt → send a canned chat message; compose → focus an input.
+  const dynamicQuickItems = useMemo(() => qa.activeActions.map((a) => ({
+    key: a.id,
+    label: a.label,
+    title: a.kind === 'prompt' ? a.prompt : `${t('secretary.qa.composeTarget')}: ${a.target}`,
+    onClick: a.kind === 'prompt'
+      ? () => { focusInto('.sec-chat', null); sendChat(a.prompt); }
+      : () => focusInto(a.target === 'find' ? '.sec-find' : a.target === 'note' ? '.sec-note' : '.sec-next', a.target === 'find' ? '.sec-find-in' : 'textarea'),
+  })), [qa.activeActions, focusInto, sendChat]);
+
+  // Read what's ACTUALLY in the active context's workspaces (recent items per workspace) so the
+  // Secretary's answers reflect real content — not just goals/decisions/feed. One memory-list call.
+  const loadSpaceSnapshot = useCallback(async () => {
+    if (!active || !active.organismId) return '';
+    const r = await apiGet(`/v1/memory?prefix=${encodeURIComponent('organism.' + active.organismId + '.w.')}&_=${Date.now()}`).catch(() => null);
+    const items = (r && r.data && r.data.items) || [];
+    const byWs = {};
+    for (const it of items) {
+      const m = String(it.key || '').match(/\.w\.([^.]+)\.([^.]+)\./);
+      if (!m || m[2] === 'meta') continue; // skip per-workspace readme/meta records
+      const v = it.value || {};
+      const title = String(v.title || v.name || (v.body ? String(v.body).slice(0, 60) : '') || '').replace(/\s+/g, ' ').trim();
+      if (!title) continue;
+      (byWs[m[1]] = byWs[m[1]] || []).push(title);
+    }
+    return (wsList || []).map((w) => `- ${w.name}: ${(byWs[w.id] || []).slice(0, 6).join('; ') || '(empty)'}`).join('\n');
+  }, [active, wsList]);
+
+  // "Where do things stand?" — read-only orientation grounded in the brain + open goals/decisions +
+  // recent activity AND the real workspace content. No actions taken.
+  const runStand = useCallback(async () => {
+    if (!active) return;
+    setStand({ loading: true });
+    try {
+      // Quality policy: orientation needs a ≥200k model too (it reads the whole space). No big model →
+      // tell the owner instead of running a degraded read.
+      const cap = await getAiCapability();
+      if (!cap.bigEnough) { setStand({ needModel: true }); return; }
+      const openGoals = (learn.goals || []).filter((g) => g.status !== 'done').map((g) => '- ' + g.title).join('\n');
+      const openDecs = (learn.decisions || []).filter((d) => d.status !== 'reviewed').map((d) => '- ' + d.decision).join('\n');
+      const recent = (auto.feed || []).slice(0, 6).map((f) => '- ' + String(f.text || '').replace(/\s+/g, ' ').slice(0, 160)).join('\n');
+      const space = await loadSpaceSnapshot();
+      const wsUrl = (wsId) => (active.organismId ? `/v1/profile?tab=organisms&org=${encodeURIComponent(active.organismId)}${wsId ? `&ws=${encodeURIComponent(wsId)}` : ''}` : '');
+      const wsLinks = active.organismId ? (wsList || []).map((w) => `- "${w.name}" → ${wsUrl(w.id)}`).join('\n') : '';
+      const sys = `You are ${owner || 'the user'}'s personal Secretary in the "${active.name}" context. Give a SHORT, ORGANIZED orientation of where things stand right now. Use Markdown with 2–4 short sections or bullet groups (e.g. In progress / Open items / Needs attention / Recent) — NOT one long paragraph. Ground it in what's ACTUALLY in the workspaces below; do NOT say the space is empty if a workspace has content. When you mention a workspace, write it as a Markdown link using the "Workspace links" below so the owner can jump to it. Do NOT propose actions or claim to have done anything. Reply in ${getLocale() === 'fi' ? 'Finnish' : 'English'}.`;
+      const snapshot = `Context purpose: ${active.brain.purpose}\nWorkspace contents:\n${space || '(no workspaces)'}\nWorkspace links:\n${wsLinks || '(none)'}\nOpen goals:\n${openGoals || '(none)'}\nOpen decisions:\n${openDecs || '(none)'}\nRecent autonomous activity:\n${recent || '(none)'}`;
+      // Fact-based read → execution model, low temperature.
+      const r = await api('/v1/ai/complete', { method: 'POST', body: JSON.stringify({ prompt: snapshot, systemPrompt: sys, modelRole: 'execution', temperature: 0.2, app_id: 'secretary-orient' }), timeoutMs: 1_800_000, retries: 0 });
+      const text = ((r && r.data && r.data.content) || '…').trim();
+      // Verify the orientation against the facts (reasoning, temp 0) — flag any invented progress/items.
+      const check = await reasonJson('You fact-check a status orientation against the facts it was given. Return ONLY JSON {"ok":boolean,"issues":[string]}. ok=false if it states any progress, item, number, or outcome NOT present in the facts. Bracketed [placeholders] are fine.', `Facts:\n${snapshot}\n\nOrientation:\n${text}`, 'secretary-orient-verify');
+      const issues = (check && check.ok === false && Array.isArray(check.issues)) ? check.issues.slice(0, 5) : [];
+      const generatedAt = new Date().toISOString();
+      setStand({ text, generatedAt, issues });
+      // Persist so it stays visible across reloads (with its timestamp) — no need to regenerate each time.
+      if (active.id) await apiPost('/v1/memory', { key: `secretary.stand.${active.id}`, value: { text, generatedAt, issues }, visibility: 'private' }).catch(() => {});
+    } catch (e) {
+      setStand(null);
+      showToast(`${t('secretary.dash.standError')}: ${e.message}`, true);
+    }
+  }, [active, owner, learn.goals, learn.decisions, auto.feed, wsList, loadSpaceSnapshot, showToast]);
+
+  // "What's next?" — the Secretary proposes CONCRETE next actions it can DO (each with Do it / Skip),
+  // grounded in the real workspace content + goals/decisions/routines/follow-ups. Not prose to read —
+  // an actionable list. Doing one runs it (gather/file/surface); skipping drops it.
+  const NEXT_CAPS = ['discover', 'file_intake', 'curate_knowledge', 'briefing', 'reminders', 'create_resource', 'delegate'];
+  const runWhatsNext = useCallback(async () => {
+    if (!active) return;
+    setNextAns({ loading: true });
+    try {
+      // Deciding the next actions is a reasoning task → requires a ≥200k model. No big model → notice.
+      const cap = await getAiCapability();
+      if (!cap.bigEnough) { setNextAns({ needModel: true }); return; }
+      const openGoals = (learn.goals || []).filter((g) => g.status !== 'done').map((g) => '- ' + g.title).join('\n');
+      const dueDecs = (learn.decisions || []).filter((d) => d.status !== 'reviewed').map((d) => '- ' + d.decision).join('\n');
+      const routines = (next.activeRoutines || []).map((r) => { const s = next.nextPendingStep(r); return `- ${r.title}${s ? ` (next: ${s.summary})` : ''}`; }).join('\n');
+      const followups = (next.actionItems || []).map((a) => '- ' + (a.summary || a.text || '')).join('\n');
+      const space = await loadSpaceSnapshot();
+      const sys = `You are ${owner || 'the user'}'s personal Secretary in the "${active.name}" context. Propose the concrete NEXT ACTIONS to take now, grounded in the real workspace content + goals/decisions/routines/follow-ups below. Each action is something the owner can approve with one click. Return ONLY a JSON object EXACTLY like {"actions":[{"summary":"a short imperative action (in the user's language)","capability":"discover","why":"one short line why, in the user's language"}]}. Propose 2–5 actions. "capability" MUST be one of: ${NEXT_CAPS.join(', ')} — prefer "discover" to gather info on something, "file_intake"/"curate_knowledge" to record a plan/note, "reminders"/"briefing" to flag something. Do NOT invent capabilities. CRUCIAL: do NOT propose anything already present in the workspace content above — if a deliverable already exists there, propose the genuine NEXT step instead (use, refine, or move it forward), never redo it. Write every "summary" and "why" in ${getLocale() === 'fi' ? 'Finnish' : 'English'}. Output ONLY the JSON object.`;
+      const snapshot = `Context purpose: ${active.brain.purpose}\nWorkspace contents:\n${space || '(no workspaces)'}\nOpen goals:\n${openGoals || '(none)'}\nOpen decisions:\n${dueDecs || '(none)'}\nActive routines:\n${routines || '(none)'}\nOpen follow-ups:\n${followups || '(none)'}`;
+      // Reasoning/decision task → reasoning model, temperature 0 for sound, repeatable choices.
+      const r = await api('/v1/ai/complete', { method: 'POST', body: JSON.stringify({ prompt: snapshot, systemPrompt: sys, modelRole: 'reasoning', temperature: 0, app_id: 'secretary-next' }), timeoutMs: 1_800_000, retries: 0 });
+      let parsed = null;
+      try { parsed = extractJson((r && r.data && r.data.content) || ''); } catch { /* fall through */ }
+      const raw = (parsed && Array.isArray(parsed.actions)) ? parsed.actions : [];
+      const actions = raw.slice(0, 6).map((a) => ({
+        id: 'na-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 5),
+        summary: String((a && a.summary) || '').trim(),
+        capability: NEXT_CAPS.includes(a && a.capability) ? a.capability : 'file_intake',
+        why: String((a && a.why) || '').trim(),
+        status: 'open',
+      })).filter((a) => a.summary);
+      setNextAns({ actions, ctxId: active.id });
+    } catch (e) {
+      setNextAns(null);
+      showToast(`${t('secretary.next.error')}: ${e.message}`, true);
+    }
+  }, [active, owner, learn.goals, learn.decisions, next, loadSpaceSnapshot, showToast]);
+
+  // Carry out one proposed "What's next" action (band-spirit: gather/record/surface). Marks it done.
+  // ── Phase 3: "Design a workflow" — the Secretary composes a chain of agent+offer steps toward an
+  // outcome, proposes how to arm it, and saves it. ──
+  const openWfDesign = useCallback(() => setWfDesign((s) => s || { outcome: '' }), []);
+  const designWfFromStep = useCallback((step) => { setWfDesign({ outcome: (step && (step.summary || step.description)) || '' }); try { document.querySelector('.sec-wf')?.scrollIntoView({ behavior: 'smooth', block: 'center' }); } catch { /* noop */ } }, []);
+  const discardWfDesign = useCallback(() => setWfDesign(null), []);
+  const redoWfDesign = useCallback(() => setWfDesign((s) => ({ outcome: (s && s.outcome) || '' })), []);
+  const setWfOutcome = useCallback((v) => setWfDesign((s) => ({ ...(s || {}), outcome: v })), []);
+  const setWfTrigKind = useCallback((kind) => setWfDesign((s) => ({ ...s, trigger: kind === 'schedule' ? { kind: 'schedule', cron: (s.trigger && s.trigger.cron) || '0 9 * * *' } : kind === 'event' ? { kind: 'event', on: 'memory.write', match: {} } : { kind: 'manual' } })), []);
+  const setWfCron = useCallback((cron) => setWfDesign((s) => ({ ...s, trigger: { kind: 'schedule', cron } })), []);
+  const runWfDesign = useCallback(async () => {
+    const outcome = ((wfDesign && wfDesign.outcome) || '').trim();
+    if (!outcome) return;
+    setWfDesign((s) => ({ ...s, designing: true, error: null, draft: null }));
+    try {
+      const offers = await fetchWorkflowOffers();
+      const r = await designWorkflow({ outcome, offers, locale: getLocale() });
+      if (!r.ok) { setWfDesign((s) => ({ ...s, designing: false, error: r.error, title: r.title })); return; }
+      setWfDesign((s) => ({ ...s, designing: false, draft: r.def, trigger: r.def.trigger, errors: null }));
+    } catch (e) { setWfDesign((s) => ({ ...s, designing: false, error: 'fail' })); showToast(e.message, true); }
+  }, [wfDesign, showToast]);
+  const saveWfDesign = useCallback(async () => {
+    const d = wfDesign && wfDesign.draft;
+    if (!d) return;
+    setWfDesign((s) => ({ ...s, saving: true, errors: null }));
+    const id = slugifyWorkflowId(d.title || (wfDesign && wfDesign.outcome) || 'workflow');
+    const r = await saveDesignedWorkflow(id, { ...d, trigger: (wfDesign && wfDesign.trigger) || d.trigger });
+    if (!r.ok) { setWfDesign((s) => ({ ...s, saving: false, errors: r.errors })); return; }
+    setWfDesign((s) => ({ ...s, saving: false, saved: id }));
+    window.dispatchEvent(new CustomEvent('aimeat-live-update'));
+  }, [wfDesign]);
+
+  const doProposedAction = useCallback(async (action) => {
+    if (!active) return;
+    const patch = (st, extra) => setNextAns((s) => (s && s.actions) ? { ...s, actions: s.actions.map((a) => (a.id === action.id ? { ...a, status: st, ...extra } : a)) } : s);
+    patch('doing');
+    // Append a visible line to the Home feed ("What I've done") so every Do-it leaves a trail — with a
+    // link to where the result landed when there is one.
+    const feedLog = async (text, href) => {
+      const fr = await apiGet('/v1/memory/secretary.feed').catch(() => null);
+      const items = (fr && fr.data && fr.data.value && Array.isArray(fr.data.value.items)) ? fr.data.value.items : [];
+      const entry = { id: 'f-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 4), ts: new Date().toISOString(), kind: 'act', contextId: active.id, contextName: active.name || '', text, ...(href ? { href } : {}) };
+      await apiPost('/v1/memory', { key: 'secretary.feed', value: { items: [entry, ...items].slice(0, 50) }, visibility: 'private' });
+    };
+    // Best-matching workspace for the action (by word overlap with its summary).
+    const pickWs = () => {
+      const wsl = intake.wsList || [];
+      const words = new Set(String(action.summary).toLowerCase().split(/[^a-z0-9äöå]+/i).filter((w) => w.length >= 4));
+      let ws = wsl[0]; let best = -1;
+      for (const w of wsl) { let sc = 0; const hay = String(w.name).toLowerCase(); for (const wd of words) if (hay.includes(wd)) sc++; if (sc > best) { best = sc; ws = w; } }
+      return ws;
+    };
+    // Deep link that opens the organism + the exact workspace in Profile › Organisms (new tab).
+    const spaceUrl = (wsId) => (active.organismId ? `/v1/profile?tab=organisms&org=${encodeURIComponent(active.organismId)}${wsId ? `&ws=${encodeURIComponent(wsId)}` : ''}` : null);
+    const fileNote = async (ws, title, body) => {
+      const id = 'note-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 5);
+      const key = `organism.${active.organismId}.w.${ws.id}.notes.${id}`;
+      await apiPost('/v1/memory', { key, value: { id, title: String(title).slice(0, 80), body, createdAt: new Date().toISOString(), via: 'secretary-next' }, visibility: 'private' });
+      return key;
+    };
+    try {
+      const cap = action.capability;
+      let resultMsg = ''; let href = null; let preview = ''; let noteKey = null;
+      if (cap === 'discover') {
+        // Scout AND KEEP the results: file the top hits as a list the owner can open.
+        const d = await apiGet('/v1/discover?scope=public&per_page=10&q=' + encodeURIComponent(action.summary)).catch(() => null);
+        const entries = (d && d.data && Array.isArray(d.data.entries)) ? d.data.entries : [];
+        const ws = pickWs();
+        if (active.organismId && ws && entries.length) {
+          const list = entries.slice(0, 10).map((e) => `- ${e.title || e.id}${e.type ? ` (${e.type})` : ''}${e.url ? ` — ${e.url}` : ''}`).join('\n');
+          preview = `Found ${entries.length}:\n\n${list}`;
+          noteKey = await fileNote(ws, `Scouted: ${action.summary}`, preview);
+          resultMsg = t('secretary.next.didScoutedSaved', { n: entries.length, ws: ws.name }); href = spaceUrl(ws.id);
+        } else {
+          resultMsg = t('secretary.next.didDiscover', { n: entries.length });
+        }
+        await feedLog(`🔎 ${action.summary} — ${t('secretary.next.didDiscover', { n: entries.length })}`, href);
+      } else if (cap === 'briefing' || cap === 'reminders') {
+        await feedLog(`⚑ ${action.summary}`);
+        resultMsg = t('secretary.next.didSurface');
+      } else {
+        // file_intake / curate_knowledge / create_resource → run the multi-step QUALITY pipeline
+        // (triage → gather → produce → verify) on a ≥200k model, grounded + no fabrication. If no big
+        // model is configured, hand the owner a copy-paste prompt for the prompt-driven path instead.
+        const ws = pickWs();
+        const space = await loadSpaceSnapshot();
+        const runDiscover = async (q) => {
+          const d = await apiGet('/v1/discover?scope=public&per_page=10&q=' + encodeURIComponent(q)).catch(() => null);
+          const es = (d && d.data && Array.isArray(d.data.entries)) ? d.data.entries : [];
+          return es.slice(0, 10).map((e) => `- ${e.title || e.id}${e.type ? ` (${e.type})` : ''}${e.url ? ` — ${e.url}` : ''}`).join('\n');
+        };
+        const out = await produceDeliverable({ action, owner, contextName: active.name, locale: getLocale(), space, runDiscover });
+        if (out.mode === 'clarify') {
+          // Missing facts only the owner has → ask in the inbox (batch questions); the tick produces the
+          // deliverable once answered. Never guess.
+          await apiPost('/v1/secretary/clarify', { contextId: active.id, contextName: active.name || '', action: { summary: action.summary, why: action.why || '' }, questions: out.questions, facts: out.facts || space, organismId: active.organismId || '', wsId: (ws && ws.id) || '' });
+          patch('asked', {});
+          window.dispatchEvent(new CustomEvent('aimeat-live-update'));
+          return;
+        }
+        if (out.mode === 'prompt-driven') {
+          // No ≥200k model — never run a degraded completion; show the composed multi-step prompt to
+          // copy into a big AI chat, with a paste-back box to save the result.
+          patch('prompt', { promptText: out.prompt, expanded: true });
+          return;
+        }
+        preview = out.content;
+        const issues = (out.verify && out.verify.ok === false && Array.isArray(out.verify.issues)) ? out.verify.issues.slice(0, 6) : [];
+        if (active.organismId && ws) {
+          noteKey = await fileNote(ws, action.summary, out.content);
+          resultMsg = t('secretary.next.didDrafted', { ws: ws.name }); href = spaceUrl(ws.id);
+          await feedLog(`✍️ ${action.summary} — ${t('secretary.next.didDrafted', { ws: ws.name })}`, href);
+          patch('done', { result: resultMsg, href, preview, expanded: true, noteKey, issues });
+          window.dispatchEvent(new CustomEvent('aimeat-live-update'));
+          return;
+        }
+        resultMsg = t('secretary.next.didNoted');
+      }
+      patch('done', { result: resultMsg, href, preview, expanded: true, noteKey });
+      window.dispatchEvent(new CustomEvent('aimeat-live-update'));
+    } catch (e) {
+      patch('open');
+      showToast(`${t('secretary.next.error')}: ${e.message}`, true);
+    }
+  }, [active, owner, intake.wsList, loadSpaceSnapshot, showToast]);
+
+  const skipProposedAction = useCallback((action) => {
+    setNextAns((s) => (s && s.actions) ? { ...s, actions: s.actions.map((a) => (a.id === action.id ? { ...a, status: 'skipped' } : a)) } : s);
+  }, []);
+
+  // Show/hide the produced deliverable inline under a done action (no navigation needed).
+  const togglePreview = useCallback((action) => {
+    setNextAns((s) => (s && s.actions) ? { ...s, actions: s.actions.map((a) => (a.id === action.id ? { ...a, expanded: !a.expanded } : a)) } : s);
+  }, []);
+
+  const setPasteDraft = useCallback((id, v) => setPasteDrafts((m) => ({ ...m, [id]: v })), []);
+
+  // Prompt-driven path: file the result the owner pasted back from their big AI chat, as a note.
+  const savePromptResult = useCallback(async (action) => {
+    const text = (pasteDrafts[action.id] || '').trim();
+    if (!text || !active) return;
+    const wsl = intake.wsList || [];
+    const words = new Set(String(action.summary).toLowerCase().split(/[^a-z0-9äöå]+/i).filter((w) => w.length >= 4));
+    let ws = wsl[0]; let best = -1;
+    for (const w of wsl) { let sc = 0; const hay = String(w.name).toLowerCase(); for (const wd of words) if (hay.includes(wd)) sc++; if (sc > best) { best = sc; ws = w; } }
+    let noteKey = null;
+    if (active.organismId && ws) {
+      const id = 'note-' + Date.now().toString(36) + Math.random().toString(36).slice(2, 5);
+      noteKey = `organism.${active.organismId}.w.${ws.id}.notes.${id}`;
+      await apiPost('/v1/memory', { key: noteKey, value: { id, title: action.summary.slice(0, 80), body: text, createdAt: new Date().toISOString(), via: 'secretary-next' }, visibility: 'private' }).catch(() => {});
+    }
+    const href = active.organismId && ws ? `/v1/profile?tab=organisms&org=${encodeURIComponent(active.organismId)}&ws=${encodeURIComponent(ws.id)}` : null;
+    setNextAns((s) => (s && s.actions) ? { ...s, actions: s.actions.map((a) => (a.id === action.id ? { ...a, status: 'done', promptText: '', preview: text, expanded: true, noteKey, result: ws ? t('secretary.next.didDrafted', { ws: ws.name }) : t('secretary.next.didNoted'), href } : a)) } : s);
+    setPasteDraft(action.id, '');
+    window.dispatchEvent(new CustomEvent('aimeat-live-update'));
+  }, [pasteDrafts, active, intake.wsList, setPasteDraft]);
+
+  // Discard a produced deliverable that's no good (e.g. an off-base draft): delete the filed note and
+  // clear the result from the list.
+  const discardProposedAction = useCallback(async (action) => {
+    if (action.noteKey) await apiDelete(`/v1/memory/${encodeURIComponent(action.noteKey)}`).catch(() => {});
+    setNextAns((s) => (s && s.actions) ? { ...s, actions: s.actions.map((a) => (a.id === action.id ? { ...a, status: 'discarded', preview: '', result: '', href: null, noteKey: null, expanded: false } : a)) } : s);
+  }, []);
+
   const switchContext = useCallback(async (id) => {
     const ctx = contexts.find((c) => c.id === id);
     if (!ctx) return;
@@ -299,9 +942,56 @@ ${SECRETARY_AIMEAT_PRIMER}`;
     persistConfig({ ...config, contexts: contexts.map((c) => (c.id === active.id ? updated : c)) });
   };
   const setBand = (capId, band) => updateActivePolicy({ bands: { ...policy.bands, [capId]: band } });
+  // One autonomy toggle: 'suggest' (surface only) | 'assist' (handle the small stuff). Sets the band preset
+  // underneath, so the band machinery + parity tests are unchanged — the toggle is just the simple surface.
+  const setAutonomy = (level) => updateActivePolicy({ bands: autonomyPreset(level) });
   const toggleStop = () => updateActivePolicy({ stopSpending: !policy.stopSpending });
   const setBudget = (v) => updateActivePolicy({ dailyMorselBudget: v === '' ? null : Math.max(0, Math.floor(Number(v) || 0)) });
 
+  // Strategy (optional steering frame). Stored on the active context as `strategy = { enabled, vision,
+  // mission, principles[], risks[], current, target, milestones:[{id,title,enables,goalRefs[],criterion,status}] }`.
+  // Milestones are ordered gates (a checkpoint, not a task — tasks live in goals). Shows only filled parts.
+  const strategy = (active && active.strategy && active.strategy.enabled) ? normalizeStrategy(active.strategy) : null;
+  const goalsById = useMemo(() => { const m = {}; for (const g of (learn.goals || [])) if (g && g.id) m[g.id] = g; return m; }, [learn.goals]);
+  const commitStrategy = (next) => {
+    if (!active) return;
+    const updated = { ...active, strategy: normalizeStrategy(next) };
+    persistConfig({ ...config, contexts: contexts.map((c) => (c.id === active.id ? updated : c)) });
+  };
+  const curStrat = () => normalizeStrategy(active && active.strategy);
+  const startStratEdit = () => { const s = curStrat(); setStratEdit({ vision: s.vision, mission: s.mission, current: s.current, target: s.target, principles: s.principles.join('\n'), risks: s.risks.join('\n') }); };
+  const saveStratEdit = () => {
+    if (!stratEdit) return;
+    const s = curStrat();
+    const changedTarget = stratEdit.target.trim() !== (s.target || '').trim();
+    commitStrategy({ ...s, enabled: true, vision: stratEdit.vision, mission: stratEdit.mission, current: stratEdit.current, target: stratEdit.target, principles: stratEdit.principles.split('\n'), risks: stratEdit.risks.split('\n') });
+    setStratEdit(null);
+    // Changing the target state often means the rest of the plan should be re-proposed — offer it.
+    if (changedTarget && stratEdit.target.trim()) setReplan({ note: t('secretary.strat.targetChanged') });
+  };
+  const cycleMilestone = (i) => { const s = curStrat(); const ms = [...s.milestones]; if (!ms[i]) return; const ni = (MILESTONE_STATUSES.indexOf(ms[i].status) + 1) % MILESTONE_STATUSES.length; ms[i] = { ...ms[i], status: MILESTONE_STATUSES[ni] }; commitStrategy({ ...s, milestones: ms }); };
+  const addMilestone = () => { const title = msInput.trim(); if (!title) return; const s = curStrat(); commitStrategy({ ...s, milestones: [...s.milestones, { title, enables: '', goalRefs: [], criterion: '', status: 'not-started' }] }); setMsInput(''); };
+  const removeMilestone = (i) => { const s = curStrat(); commitStrategy({ ...s, milestones: s.milestones.filter((_, j) => j !== i) }); };
+  const moveMilestone = (i, delta) => { const s = curStrat(); const ms = [...s.milestones]; const j = i + delta; if (j < 0 || j >= ms.length) return; [ms[i], ms[j]] = [ms[j], ms[i]]; commitStrategy({ ...s, milestones: ms }); };
+  const toggleMilestoneGoal = (i, goalId) => { const s = curStrat(); const ms = [...s.milestones]; if (!ms[i]) return; const refs = new Set(ms[i].goalRefs || []); if (refs.has(goalId)) refs.delete(goalId); else refs.add(goalId); ms[i] = { ...ms[i], goalRefs: [...refs] }; commitStrategy({ ...s, milestones: ms }); };
+  const enableStrategy = () => commitStrategy({ ...curStrat(), enabled: true });
+  const disableStrategy = () => { commitStrategy({ ...curStrat(), enabled: false }); setStratEdit(null); };
+  // Re-plan: change something (e.g. the target), let the AI re-propose a coherent strategy you can apply/edit.
+  const startReplan = () => setReplan({ note: '' });
+  const runReplan = async () => {
+    const note = (replan && replan.note || '').trim(); if (!note) return;
+    setReplan((r) => ({ ...r, busy: true }));
+    try {
+      const prompt = buildStrategyReplanPrompt(owner, active && active.strategy, note, learn.goals);
+      const r = await api('/v1/ai/complete', { method: 'POST', body: JSON.stringify({ prompt, app_id: 'secretary-strategy-replan' }), timeoutMs: 1_800_000, retries: 0 });
+      const j = extractJson((r && r.data && r.data.content) || '');
+      // Re-plan links milestones to EXISTING goal ids — keep only refs that point at a real goal.
+      const draft = keepKnownGoalRefs(normalizeStrategy(j.strategy || j), (learn.goals || []).map((g) => g && g.id));
+      setReplan({ draft });
+    } catch (e) { showToast(`${t('secretary.strat.replanErr')}: ${e.message}`, true); setReplan(null); }
+  };
+  const applyReplan = () => { if (replan && replan.draft) commitStrategy(replan.draft); setReplan(null); };
+
   const restore = useCallback(async (snap) => {
     if (!active) return;
     setApplying(true);
@@ -339,30 +1029,132 @@ ${SECRETARY_AIMEAT_PRIMER}`;
       ${secretary === undefined
         ? html`<div class="sec-empty">…</div>`
         : secretary === null
-        ? html`<div class="sec-empty">${t('secretary.notReady')}</div>`
+        ? html`<div class="sec-empty">${hasOpenRouterKey ? t('secretary.provisioning') : t('secretary.notReady')}</div>`
         : html`
             ${hired ? contextSwitcher({ contexts, activeId, switchContext, openAdd }) : null}
-            ${showHirePanel ? hirePanel({ firstEver, hireMode, owner, needs, setNeeds, result, setResult, applying, generating, generateInApp, applyResult, onCancel: cancelHire }) : null}
+            ${showHirePanel ? hirePanel({ firstEver, hireMode, owner, current: hireMode === 'edit' ? active : null, needs, setNeeds, result, setResult, applying, setupStep, generating, generateInApp, applyResult: startSetup, onCancel: cancelHire }) : null}
             ${hired && !showHire && active ? html`
-              ${chatCard({ activeName: active.name, chat, chatSending, chatInput, setChatInput, sendChat, routeSuggestion, switchContext,
-                onAttach: intake.handleAttach, attaching: intake.attaching, attachResult: intake.attachResult, canAttach: intake.wsList.length > 0 })}
-              ${findCard({ findQ, setFindQ, findScope, setFindScope, finding, doFind, findResults })}
-              ${(findResults && findResults.length === 0) || create.draft || create.created ? createResourceCard({ ...create, query: findQ }) : null}
-              ${wsList.length > 0 ? noteCard(intake) : null}
-              ${knowledgeCard(knowledge)}
-              ${accessCard(access)}
-              ${crewCard(crew)}
-              ${guidedPlanCard(plan)}
-              ${intake.pendingIds.length > 0 ? decisionsCard(intake) : null}
-              ${goalsCard(learn)}
-              ${decisionLogCard(learn)}
-              ${automationCard({ ...auto, budgetInfo })}
-              ${feedCard(auto)}
-              ${brainCard({ brain, active, openEdit })}
-              ${operatingCard({ policy, toggleStop, setBudget, setBand })}
-              ${(Array.isArray(active.brainHistory) && active.brainHistory.length > 0) ? historyCard({ brainHistory: active.brainHistory, applying, restore }) : null}
-              ${metaCard({ secretary, reliability })}
+              ${/* Quick-action row (core verbs; dynamic actions arrive in B3) */ ''}
+              ${quickActionRow({ items: [
+                { key: 'next', label: t('secretary.next.title'), primary: true, disabled: !!(nextAns && nextAns.loading), title: t('secretary.next.hint'), onClick: runWhatsNext },
+                { key: 'stand', label: t('secretary.dash.quickStand'), disabled: !!(stand && stand.loading), onClick: runStand },
+                { key: 'find', label: t('secretary.dash.quickFind'), title: t('secretary.findTitle'), onClick: () => focusInto('.sec-find', '.sec-find-in') },
+                { key: 'note', label: t('secretary.dash.quickNote'), title: t('secretary.noteTitle'), hidden: wsList.length === 0, onClick: () => focusInto('.sec-note', 'textarea') },
+                { key: 'review', label: t('secretary.dash.quickReview'), title: t('secretary.learn.reviewNow'), hidden: !decisionsDue, onClick: () => focusInto('.sec-decisions-log', null) },
+                { key: 'design-wf', label: t('secretary.wf.quick'), title: t('secretary.wf.title'), onClick: openWfDesign },
+                ...dynamicQuickItems,
+                { key: 'manage-qa', label: '✎', title: t('secretary.qa.title'), onClick: qa.toggleManage },
+              ] })}
+              ${quickActionsManager(qa)}
+              ${workflowDesignPanel({ state: wfDesign, onOutcome: setWfOutcome, onDesign: runWfDesign, onTrigKind: setWfTrigKind, onCron: setWfCron, onSave: saveWfDesign, onRedo: redoWfDesign, onDiscard: discardWfDesign })}
+
+              ${/* Today — full-width status band, always on top */ ''}
+              ${dashStatus({ reliability, budgetInfo, schedule: auto.schedule, lastScan, stale, onReconcile: reconcile, scanning })}
+
+              ${/* Heavy work to hand off — the Work Brief tray (the light-vs-heavy seam made physical). */ ''}
+              ${briefTrayCard({ briefs, builders, dispatching, onDispatch: dispatchBrief, onResolve: resolveBrief })}
+
+              ${/* Customizable two-column dashboard (pin to column / reorder / hide per card; persisted). */ ''}
+              ${(() => {
+                const nodes = {
+                  strategy: strategy ? strategyCard({
+                    strategy, goals: learn.goals, goalsById,
+                    edit: stratEdit, onStartEdit: startStratEdit, onEditField: (k, v) => setStratEdit((d) => ({ ...(d || {}), [k]: v })), onSaveEdit: saveStratEdit, onCancelEdit: () => setStratEdit(null),
+                    onCycle: cycleMilestone, msInput, onMsInput: setMsInput, onAdd: addMilestone, onRemove: removeMilestone, onMove: moveMilestone, onToggleGoal: toggleMilestoneGoal,
+                    replan, onStartReplan: startReplan, onReplanNote: (v) => setReplan((r) => ({ ...(r || {}), note: v })), onRunReplan: runReplan, onApplyReplan: applyReplan, onCancelReplan: () => setReplan(null),
+                    onDisable: disableStrategy,
+                  }) : null,
+                  whatsNext: whatsNextPanel({ answer: nextAns, onDo: doProposedAction, onSkip: skipProposedAction, onTogglePreview: togglePreview, onDiscard: discardProposedAction, pasteDrafts, onPasteInput: setPasteDraft, onSavePrompt: savePromptResult, onDismiss: () => { setNextAns(null); if (activeId) apiDelete(`/v1/memory/${encodeURIComponent('secretary.next.' + activeId)}`).catch(() => {}); } }),
+                  stand: standPanel({ stand, onRefresh: runStand, onDismiss: () => setStand(null) }),
+                  actionItems: actionItemsCard(next),
+                  routines: routinesCard({ ...next, onDesignWorkflow: designWfFromStep }),
+                  decisions: intake.pendingIds.length > 0 ? decisionsCard(intake) : null,
+                  automation: automationCard({ ...auto, budgetInfo }),
+                  triggers: triggersCard({ ...trig, goals: learn.goals, routines: next.routines, specialists: spec.list }),
+                  specialists: specialistsCard({ ...spec }),
+                  calendar: calendarCard({ ...cal, feed: auto.feed, schedule: auto.schedule, routines: next.routines, triggers: trig.armed, onEventClick: setCalEvent }),
+                  feed: feedCard(auto),
+                  goals: goalsCard(learn),
+                  decisionLog: decisionLogCard(learn),
+                  chat: chatCard({ activeName: active.name, chat, chatSending, chatInput, setChatInput, sendChat, routeSuggestion, switchContext,
+                    onAttach: intake.handleAttach, attaching: intake.attaching, attachResult: intake.attachResult, canAttach: intake.wsList.length > 0 }),
+                  whatsNextCard: whatsNextCard({ ...next, agents: crew.agents }),
+                  find: findCard({ findQ, setFindQ, findScope, setFindScope, finding, doFind, findResults }),
+                  createResource: ((findResults && findResults.length === 0) || create.draft || create.created) ? createResourceCard({ ...create, query: findQ }) : null,
+                  note: wsList.length > 0 ? noteCard(intake) : null,
+                };
+                const present = lay.layout.filter((e) => nodes[e.key] != null && !e.hidden);
+                const mainCol = present.filter((e) => e.col === 'main');
+                const rightCol = present.filter((e) => e.col === 'right');
+                const renderCol = (list) => list.map((e, i) => LayoutCard({ entry: e, node: nodes[e.key], prevKey: i > 0 ? list[i - 1].key : null, nextKey: i < list.length - 1 ? list[i + 1].key : null, onSwap: lay.swap, onMoveCol: lay.moveCol, onHide: lay.hide }));
+                return html`
+                  <div class="sec-grid">
+                    <div class="sec-col sec-col-main">${renderCol(mainCol)}</div>
+                    <aside class="sec-col sec-col-right">${renderCol(rightCol)}</aside>
+                  </div>
+                  <div class="sec-layout-bar">
+                    ${lay.hidden.map((e) => html`<button class="sec-chip" key=${e.key} onClick=${() => lay.unhide(e.key)}>+ ${t('secretary.layout.section.' + e.key)}</button>`)}
+                    <button class="sec-linkbtn" onClick=${lay.reset}>${t('secretary.layout.reset')}</button>
+                  </div>`;
+              })()}
+
+              ${/* Manage & setup — collapsed disclosure (set up once) */ ''}
+              ${manageHeader({ open: manageOpen, onToggle: () => setManageOpen((v) => !v),
+                crewSummary: crew.agents && crew.agents.length ? `${crew.agents.length} ${t('secretary.dash.crewAgents')}` : '' })}
+              ${manageOpen ? html`
+                ${brainCard({ brain, active, openEdit, brainDraft, setBrainDraft, startBrainEdit, saveBrain, cancelBrainEdit, savingBrain })}
+                ${operatingCard({ policy, toggleStop, setBudget, setBand, setAutonomy })}
+                ${!strategy ? html`<section class="sec-card">
+                  <h2 class="sec-h2">${t('secretary.strat.title')}</h2>
+                  <p class="sec-hint">${t('secretary.strat.enableHint')}</p>
+                  <button class="btn-outline btn-sm" onClick=${enableStrategy}>${t('secretary.strat.enable')}</button>
+                </section>` : null}
+                ${crewCard(crew)}
+                ${knowledgeCard(knowledge)}
+                ${accessCard(access)}
+                ${(Array.isArray(active.brainHistory) && active.brainHistory.length > 0) ? historyCard({ brainHistory: active.brainHistory, applying, restore }) : null}
+                ${metaCard({ secretary, reliability })}
+                ${secretaryDangerCard({
+                  show: resetState.show, text: resetState.text, busy: resetState.busy,
+                  onOpen: () => setResetState({ show: true, text: '', busy: false }),
+                  onCancel: () => setResetState({ show: false, text: '', busy: false }),
+                  onText: (v) => setResetState((s) => ({ ...s, text: v })),
+                  onConfirm: doReset,
+                })}
+              ` : null}
             ` : null}`}
+      ${calEvent ? html`<${CalendarEventDialog} event=${calEvent} onClose=${() => setCalEvent(null)} triggers=${{ update: trig.updateTrigger, togglePause: trig.togglePause, remove: trig.removeTrigger }} workflows=${trig.workflows} specialists=${spec.list} routines=${{ setCadence: next.setRoutineCadence, setStatus: next.setRoutineStatus }} tick=${{ toggle: auto.toggleTick, run: auto.runTick }} feed=${{ remove: auto.deleteFeedItem }} />` : null}
+      ${chooseMode ? html`
+        <div class="sec-setup-overlay" onClick=${(e) => { if (e.target === e.currentTarget) setChooseMode(false); }}>
+          <div class="sec-setup-box sec-mode-box">
+            <h3 class="sec-h2">${t('secretary.mode.title')}</h3>
+            <p class="sec-desc">${t('secretary.mode.intro')}</p>
+            ${[['draft', t('secretary.mode.draftTitle'), t('secretary.mode.draftDesc')], ['act', t('secretary.mode.actTitle'), t('secretary.mode.actDesc')], ['off', t('secretary.mode.offTitle'), t('secretary.mode.offDesc')]].map(([val, title, desc]) => html`
+              <label class=${'sec-mode-opt' + (setupMode === val ? ' sec-mode-opt--on' : '')}>
+                <input type="radio" name="setupmode" checked=${setupMode === val} onChange=${() => setSetupMode(val)} />
+                <span><span class="sec-mode-opt-t">${title}</span><span class="sec-desc">${desc}</span></span>
+              </label>`)}
+            <p class="sec-hint">${t('secretary.mode.changeLater')}</p>
+            <div class="sec-actions">
+              <button class="btn-ghost btn-sm" onClick=${() => setChooseMode(false)}>${t('secretary.cancel')}</button>
+              <button class="btn-primary" onClick=${confirmSetup}>${t('secretary.apply')}</button>
+            </div>
+          </div>
+        </div>` : null}
+      ${applying && setupStep ? (() => {
+        // Top-level setup-progress overlay — stays visible across the hire→dashboard switch (persistConfig
+        // makes the Secretary "exist" before the slow fill, so a panel-local progress view would unmount).
+        const s = setupStep, pct = s.total ? Math.round(((s.done || 0) / s.total) * 100) : null;
+        const msg = s.phase === 'fill'
+          ? `${t('secretary.stepFilling')} ${(s.done || 0) + 1}/${s.total}${s.name ? ' · ' + s.name : ''}`
+          : (s.phase === 'done' ? t('secretary.stepDone') : t('secretary.stepStructure'));
+        return html`<div class="sec-setup-overlay"><div class="sec-setup-box">
+          <h3 class="sec-h2">${t('secretary.settingUpTitle')}</h3>
+          <div class="sec-setup-row"><span class="sec-spin"></span><span>${msg}</span></div>
+          ${pct != null ? html`<div class="sec-progress-bar"><div class="sec-progress-fill" style=${`width:${pct}%`}></div></div>` : null}
+          <p class="sec-desc">${t('secretary.settingUpHint')}</p>
+        </div></div>`;
+      })() : null}
       <${ToastContainer} />
     </div>`;
 }