aimeat 1.34.0 → 1.36.0

package/dist/public/views/secretary/cards.js

@@ -30,7 +30,7 @@ const html = htm.bind(h);
 import { t } from '/js/i18n.js';
 import { CopyButton } from '/components/CopyButton.js';
 import { Markdown } from '/components/Markdown.js';
-import { SECRETARY_CAPABILITIES, BANDS } from '/js/services/secretary-policy.js';
+import { SECRETARY_CAPABILITIES, BANDS, autonomyLevelOf } from '/js/services/secretary-policy.js';
 import { buildInterviewPrompt, groupFeedByDay } from '/js/services/secretary-helpers.js';
 
 /** Context "hats" switcher chips + add. */
@@ -227,9 +227,22 @@ export function brainCard(p) {
 /** Operating model: stop-spending + daily budget + per-capability autonomy bands. */
 export function operatingCard(p) {
   const policy = p.policy;
+  const level = autonomyLevelOf(policy.bands);   // 'suggest' | 'assist' — the single toggle's state
   return html`
     <section class="sec-card">
       <h2 class="sec-h2">${t('secretary.howIWork')}</h2>
+
+      ${/* ONE autonomy toggle (collapses the per-capability band sprawl). Heavy work is always a Work
+          Brief a Builder executes — never something the cheap Secretary does on its own. */ ''}
+      <div class="sec-autonomy">
+        ${[['suggest', 'secretary.autonomy.suggest', 'secretary.autonomy.suggestHint'],
+           ['assist', 'secretary.autonomy.assist', 'secretary.autonomy.assistHint']].map(([val, label, hint]) => html`
+          <label class=${'sec-auto-opt' + (level === val ? ' sec-auto-opt--on' : '')} key=${val}>
+            <input type="radio" name="sec-autonomy" checked=${level === val} onChange=${() => p.setAutonomy(val)} />
+            <span><strong>${t(label)}</strong><br/><span class="sec-hint">${t(hint)}</span></span>
+          </label>`)}
+      </div>
+
       <label class="sec-stop ${policy.stopSpending ? 'on' : ''}">
         <input type="checkbox" checked=${policy.stopSpending} onChange=${p.toggleStop} />
         <span><strong>${t('secretary.stopSpending')}</strong><br/><span class="sec-hint">${t('secretary.stopSpendingHint')}</span></span>
@@ -239,18 +252,24 @@ export function operatingCard(p) {
         <input type="number" min="0" class="sec-budget-in" value=${policy.dailyMorselBudget == null ? '' : policy.dailyMorselBudget} placeholder=${t('secretary.noLimit')} onChange=${(e) => p.setBudget(e.target.value)} />
         <span class="sec-hint">${t('secretary.dailyBudgetHint')}</span>
       </div>
-      <p class="sec-hint sec-bands-note">${t('secretary.bandsNote')}</p>
-      <ul class="sec-caps">
-        ${SECRETARY_CAPABILITIES.map((c) => html`
-          <li class="sec-cap" key=${c.id}>
-            <span class="sec-cap-label">${t('secretary.cap.' + c.id)}${c.costs ? html`<span class="sec-cap-tag">${t('secretary.capCosts')}</span>` : null}</span>
-            ${c.enterprise
-              ? html`<span class="sec-cap-locked sec-cap-ent">${t('secretary.enterprise')}</span>`
-              : c.locked
-              ? html`<span class="sec-cap-locked">${t('secretary.band.' + policy.bands[c.id])} · ${t('secretary.locked')}</span>`
-              : html`<select class="sec-band" value=${policy.bands[c.id]} onChange=${(e) => p.setBand(c.id, e.target.value)}>${BANDS.map((b) => html`<option value=${b} selected=${policy.bands[c.id] === b}>${t('secretary.band.' + b)}</option>`)}</select>`}
-          </li>`)}
-      </ul>
+
+      ${/* Per-capability bands are still here for power users, tucked behind an Advanced disclosure so the
+          default surface is just the one toggle above. */ ''}
+      <details class="sec-adv">
+        <summary>${t('secretary.advancedBands')}</summary>
+        <p class="sec-hint sec-bands-note">${t('secretary.bandsNote')}</p>
+        <ul class="sec-caps">
+          ${SECRETARY_CAPABILITIES.map((c) => html`
+            <li class="sec-cap" key=${c.id}>
+              <span class="sec-cap-label">${t('secretary.cap.' + c.id)}${c.costs ? html`<span class="sec-cap-tag">${t('secretary.capCosts')}</span>` : null}</span>
+              ${c.enterprise
+                ? html`<span class="sec-cap-locked sec-cap-ent">${t('secretary.enterprise')}</span>`
+                : c.locked
+                ? html`<span class="sec-cap-locked">${t('secretary.band.' + policy.bands[c.id])} · ${t('secretary.locked')}</span>`
+                : html`<select class="sec-band" value=${policy.bands[c.id]} onChange=${(e) => p.setBand(c.id, e.target.value)}>${BANDS.map((b) => html`<option value=${b} selected=${policy.bands[c.id] === b}>${t('secretary.band.' + b)}</option>`)}</select>`}
+            </li>`)}
+        </ul>
+      </details>
     </section>`;
 }
 
@@ -278,13 +297,25 @@ function routineStepRow(p, r, s) {
   const isDelegate = s.capability === 'delegate';
   const agents = p.agents || [];
   const workflows = p.workflows || [];
+  // Unblur the delegation target by ROLE: node-local Specialists vs connected big-AI Builders. The Secretary
+  // (the watcher) is never a delegation target. Same handler/value (agent name) — the optgroups just label
+  // which kind of agent each is, so "pick a specialist" no longer lumps Builders + specialists together.
+  const isSpecialist = (a) => (a.tags || []).includes('system:specialist');
+  const isSecretary = (a) => (a.tags || []).includes('system:secretary') || a.name === 'secretary';
+  const specialistAgents = agents.filter((a) => isSpecialist(a));
+  const builderAgents = agents.filter((a) => !isSpecialist(a) && !isSecretary(a));
   // B4: delegate to one agent (agent task) · G7: OR run an Agent Workflow chaining specialists.
   const delegateControl = html`
     <div class="sec-delegate">
-      ${agents.length > 0 ? html`
+      ${(specialistAgents.length + builderAgents.length) > 0 ? html`
         <select class="sec-band" value=${p.delegateAgent} onChange=${(e) => p.setDelegateAgent(e.target.value)}>
           <option value="" selected=${!p.delegateAgent}>${t('secretary.next.delegatePick')}</option>
-          ${agents.map((a) => html`<option value=${a.name} selected=${p.delegateAgent === a.name}>${(a.name)}</option>`)}
+          ${specialistAgents.length ? html`<optgroup label=${t('secretary.next.delegateSpecialists')}>
+            ${specialistAgents.map((a) => html`<option value=${a.name} selected=${p.delegateAgent === a.name}>${(a.name)}</option>`)}
+          </optgroup>` : null}
+          ${builderAgents.length ? html`<optgroup label=${t('secretary.next.delegateBuilders')}>
+            ${builderAgents.map((a) => html`<option value=${a.name} selected=${p.delegateAgent === a.name}>${(a.name)}</option>`)}
+          </optgroup>` : null}
         </select>
         <button class="btn-primary btn-sm" disabled=${busy || !p.delegateAgent} onClick=${() => p.approveStep(r, s, { agentName: p.delegateAgent })}>${busy ? t('secretary.next.running') : t('secretary.next.delegateGo')}</button>` : null}
       ${workflows.length > 0 ? html`

package/dist/public/views/secretary/dashboard.js

@@ -7,9 +7,13 @@
  *   collapsible "Manage & setup" disclosure header that tucks the set-up-once config cards away.
  *   The view (views/secretary.js) owns all state/handlers and passes them in; the config cards
  *   themselves still live in ./cards.js / ./cards-reach.js. Redesign: docs/internal/2026-06-25-secretary-view-redesign.md.
- * @structure quickActionRow · dashStatus · standPanel · actionItemsCard · routinesCard · quickActionsManager · manageHeader (one render function each)
- * @usage import { quickActionRow, dashStatus, standPanel, actionItemsCard, routinesCard, quickActionsManager, manageHeader } from '/views/secretary/dashboard.js';
+ * @structure quickActionRow · dashStatus · standPanel · briefTrayCard · actionItemsCard · routinesCard · quickActionsManager · manageHeader (one render function each)
+ * @usage import { quickActionRow, dashStatus, standPanel, briefTrayCard, actionItemsCard, routinesCard, quickActionsManager, manageHeader } from '/views/secretary/dashboard.js';
  * @version-history
+ *   v0.10.0 — 2026-07-01 — Light-vs-heavy seam: briefTrayCard — the Work Brief tray. The cheap Secretary
+ *     detects structural gaps and proposes grounded briefs; this renders each with "Open in Claude Desktop"
+ *     (CopyButton with an MCP preface + the brief) and "Send to a connected Builder" (lane b dispatch), so
+ *     heavy work goes to a big AI via MCP and never gets cheap-authored here.
  *   v0.9.0 — 2026-06-28 — strategyCard: optional steering frame (vision/mission/principles/risks +
  *     current→target + ordered milestone gates with status/focus/reorder/goal-linking + AI re-plan).
  *   v0.8.0 — 2026-06-28 — secretaryDangerCard: a guarded "Reset Secretary" control (type RESET to wipe
@@ -33,6 +37,7 @@ import htm from 'htm';
 const html = htm.bind(h);
 import { t } from '/js/i18n.js';
 import { Markdown } from '/components/Markdown.js';
+import { CopyButton } from '/components/CopyButton.js';
 
 /** Core (+ later dynamic) quick actions: a button row above the chat. `items` are descriptors
  *  `{ key, label, title?, primary?, disabled?, hidden?, onClick }` so B3 can extend with dynamic actions. */
@@ -106,6 +111,67 @@ export function standPanel(p) {
     </section>`;
 }
 
+/** Compose the paste a Builder receives in Claude Desktop: a connect-first preface + the full brief.
+ *  The preface tells the assistant to connect via the appdev MCP if it isn't already, so pasting into a
+ *  Claude Desktop that has NOT been wired to the node still leads somewhere instead of silently failing. */
+function heavyWorkPrompt(b) {
+  return `I'd like you to carry out a work brief on my AIMEAT node using the appdev MCP tools (the aimeat_* tools).
+
+FIRST — make sure you can reach my node: if you are not already connected to my AIMEAT node via the appdev MCP, connect now. In the AIMEAT app open Profile → Agents → "Connect a New Agent" for the exact device-authorization steps (or read the node's /llms.txt). You need the aimeat_* tools available before you can do any of the work below.
+
+THEN — carry out the brief end-to-end with those tools: build/fill via aimeat_workspace_* / aimeat_organism_*, ground everything in the real sources listed, and never invent facts. If a records space has no real data, leave it empty rather than make something up.
+
+${b.brief || ''}`;
+}
+
+/** One Work Brief row: objective + ws + a markdown preview + the two heavy-work lanes (Open in Claude
+ *  Desktop / Send to a connected Builder) + Done. The seam made physical — the cheap Secretary proposed
+ *  this; a Builder (a big AI via MCP) executes it. */
+function briefRow(b, p) {
+  const builders = p.builders || [];
+  const dispatched = b.status === 'dispatched';
+  return html`
+    <div class="sec-brief" key=${b.id}>
+      <div class="sec-brief-top">
+        <span class="sec-brief-badge ${dispatched ? 'is-dispatched' : ''}">${dispatched ? t('secretary.brief.dispatchedBadge') : t('secretary.brief.heavyBadge')}</span>
+        <span class="sec-brief-obj">${b.objective}</span>
+        ${b.wsName ? html`<span class="sec-hint sec-brief-ws">${b.wsName}</span>` : null}
+      </div>
+      <details class="sec-brief-detail">
+        <summary>${t('secretary.brief.preview')}</summary>
+        <div class="sec-brief-md"><${Markdown} text=${b.brief || ''} /></div>
+      </details>
+      ${dispatched ? html`<div class="sec-hint sec-brief-wait">${t('secretary.brief.dispatchedNote')}</div>` : null}
+      <div class="sec-brief-actions">
+        <${CopyButton} text=${heavyWorkPrompt(b)} className="btn-primary btn-sm" label=${t('secretary.brief.openClaude')} />
+        ${builders.length ? html`
+          <select class="sec-select" disabled=${dispatched || p.dispatching === b.id}
+            onChange=${(e) => { const v = e.target.value; e.target.value = ''; if (v) p.onDispatch(b.id, v); }}>
+            <option value="">${dispatched ? t('secretary.brief.waiting') : t('secretary.brief.sendBuilder')}</option>
+            ${builders.map((a) => html`<option value=${a.gaii} key=${a.gaii}>${a.name}</option>`)}
+          </select>` : html`<span class="sec-hint">${t('secretary.brief.noBuilder')}</span>`}
+        <button class="btn-ghost btn-sm" onClick=${() => p.onResolve(b.id)}>${t('secretary.brief.done')}</button>
+      </div>
+    </div>`;
+}
+
+/** The Work Brief tray: heavy work the Secretary detected and prepared for a Builder. Null when empty
+ *  (no gaps → nothing to hand off). The clear divide between "watch + propose" (cheap, here) and
+ *  "build + author" (a big AI via MCP). */
+export function briefTrayCard(p) {
+  const briefs = p.briefs || [];
+  if (!briefs.length) return null;
+  return html`
+    <section class="sec-card sec-brief-tray">
+      <div class="sec-card-head">
+        <h2 class="sec-h2">${t('secretary.brief.startHere')} ${t('secretary.brief.title')} <span class="sec-count">${briefs.length}</span></h2>
+        <span class="sec-hint">${t('secretary.brief.subtitle')}</span>
+      </div>
+      <p class="sec-brief-banner">${t('secretary.brief.mcpNote')} <a class="sec-linkbtn" href="/v1/profile">${t('secretary.brief.connectLink')}</a></p>
+      ${briefs.map((b) => briefRow(b, p))}
+    </section>`;
+}
+
 /** "What's next" — the Secretary's proposed next actions, each with Do it / Skip; doing one runs it. */
 export function whatsNextPanel(p) {
   const n = p.answer;

package/dist/public/views/secretary.js

@@ -11,6 +11,34 @@
  * @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.26.0 — 2026-07-01 — Opt-in feature: the Secretary is now gated on AIMEAT_SECRETARY_ENABLED (off by
+ *     default). The header nav link is hidden and this view redirects to /v1/profile when the node has it
+ *     disabled (flag read from /v1/site/header-nav `features.secretary`).
+ *   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.
@@ -73,12 +101,12 @@ 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, generateRaw, parseGenerated, validateGenerated, applyGeneratedWorkspace } from '/js/services/organisms.js';
-import { defaultPolicy, mergePolicy } from '/js/services/secretary-policy.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, whatsNextPanel, actionItemsCard, routinesCard, triggersCard, quickActionsManager, manageHeader, workflowDesignPanel, secretaryDangerCard, strategyCard } from '/views/secretary/dashboard.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';
@@ -106,13 +134,29 @@ export const SECRETARY_ICON = html`
 
 export default function SecretaryView() {
   useViewCSS('/css/views/secretary.css');
+  // Secretary is opt-in per node (AIMEAT_SECRETARY_ENABLED). If it's disabled but this view is reached
+  // via a direct URL/bookmark (no nav link is rendered when off), bounce back to the profile.
+  useEffect(() => {
+    let cancelled = false;
+    fetch('/v1/site/header-nav')
+      .then(r => r.json())
+      .then(d => { if (!cancelled && d?.ok && d.data?.features && d.data.features.secretary === false) window.location.replace('/v1/profile'); })
+      .catch(() => {});
+    return () => { cancelled = true; };
+  }, []);
   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)
@@ -161,17 +205,42 @@ export default function SecretaryView() {
     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
@@ -282,9 +351,14 @@ export default function SecretaryView() {
     return ids;
   }, []);
 
-  // Give a freshly-created workspace a PROPER manifest (AI-designed object types) so it's immediately
-  // usable, not an empty "set up workspace" shell. Reuses the proven organism workspace generator.
-  // Best-effort: a manifest-less workspace still exists and can be set up manually.
+  // ── 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';
@@ -293,25 +367,76 @@ export default function SecretaryView() {
     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();
+    const name = String(ws.name || '').trim() || 'Työtila';
     try {
-      // skipExamples: the Secretary fills workspaces with REAL content at setup (author-now), so it never
-      // wants fake "example-N" placeholder records (they read as disinformation, not examples).
-      // 1) Use a manifest the design JSON already carried (the prompt-driven path can include it inline).
-      if (ws.manifest) {
-        const provided = { manifest: ws.manifest, schemas: ws.schemas || {} };
-        backfillEnvelope(provided.manifest, wsId, name);
+      // 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; }
       }
-      // 2) Otherwise (or if the inline one was invalid) design it in-app with the workspace generator.
-      const generated = parseGenerated(await generateRaw(`${name} — ${ws.purpose || ''}`.trim(), null));
-      backfillEnvelope(generated && generated.manifest, wsId, name);
-      if (generated && !validateGenerated(generated).length) await applyGeneratedWorkspace(orgId, wsId, generated, { skipExamples: true });
+      // 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 () => {
+  const applyResult = useCallback(async (mode = 'off') => {
     setApplying(true);
     try {
       const json = extractJson(result);
@@ -326,6 +451,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) {
@@ -347,6 +474,7 @@ export default function SecretaryView() {
           }
           // 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 }));
         }
         // B3: seed the brain-proposed quick actions — active on hire (run verbs are dropped by the sanitizer).
         const quickActions = sanitizeQuickActions(json.quickActions, 'brain', 'active');
@@ -357,7 +485,10 @@ export default function SecretaryView() {
         // 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);
-        const ctx = { id: ctxId, name: org.name, brain: newBrain, organismId: orgId || null, organismName: org.name, workspaces: wsSummary, policy: defaultPolicy(), brainHistory: [], quickActions, strategy };
+        // 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 (reshape): update its brain, snapshot the old one, KEEP its
@@ -391,31 +522,44 @@ export default function SecretaryView() {
       await persistConfig(next);
       await syncDirectives(newBrain);
       window.dispatchEvent(new CustomEvent('aimeat-live-update')); // refresh goals/learning + cards
-      showToast(t('secretary.hireDone'));
-      setResult(''); setNeeds(''); setShowHire(false);
-      // Fill the brand-new workspaces with REAL content right at handshake (documents first), and drop any
-      // that stay empty ("empty workspace = useless"). A slow model can take a while — long timeout, no retry
-      // (the server already retries flaky models). Only on a fresh hire, so it never touches existing content.
-      if (isNew) {
-        showToast(t('secretary.fillingWorkspaces'));
-        try {
-          const r = await api('/v1/secretary/author-now', { method: 'POST', body: JSON.stringify({}), timeoutMs: 1_800_000, retries: 0 });
-          const d = (r && r.data) || {};
-          const filled = (d.authored || []).length;
-          const removed = (d.removedEmptyWorkspaces || []).length;
-          showToast(`${t('secretary.workspacesFilled')} (${filled})${removed ? ` — ${t('secretary.emptyRemoved')}: ${removed}` : ''}`);
-          window.dispatchEvent(new CustomEvent('aimeat-live-update'));
-        } catch (e) {
-          showToast(`${t('secretary.fillError')}: ${e.message}`, true);
-        }
+      // 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;
@@ -811,6 +955,9 @@ ${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)) });
 
@@ -898,7 +1045,7 @@ ${SECRETARY_AIMEAT_PRIMER}`;
         ? 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, current: hireMode === 'edit' ? active : null, 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`
               ${/* Quick-action row (core verbs; dynamic actions arrive in B3) */ ''}
               ${quickActionRow({ items: [
@@ -917,6 +1064,9 @@ ${SECRETARY_AIMEAT_PRIMER}`;
               ${/* 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 = {
@@ -966,7 +1116,7 @@ ${SECRETARY_AIMEAT_PRIMER}`;
                 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 })}
+                ${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>
@@ -987,6 +1137,37 @@ ${SECRETARY_AIMEAT_PRIMER}`;
               ` : 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>`;
 }