aimeat 1.33.2 → 1.35.0

package/dist/src/services/scheduler.js

@@ -5,6 +5,27 @@
  *   Supports special @activate trigger: runs on extension activation AND every server startup.
  *   Every execution creates an ExecutionLogEntry with timing, result, and memory I/O.
  * @version-history
+ *   v2.13.0 — 2026-07-01 — Light-vs-heavy seam: the tick no longer cheap-authors content (the one-shot
+ *     authoring in the now-removed secretary-authoring.ts hallucinated). It now detects STRUCTURAL gaps
+ *     (empty/thin workspaces, stale content, off-target KPIs) and proposes grounded Work Briefs a Builder
+ *     (a connected big AI via the appdev MCP tools) executes — proposeWorkBriefs in services/
+ *     secretary-workbrief.ts (deterministic, no paid call, deduped against open briefs). The cheap
+ *     Secretary watches + hands off; it never authors structure/data.
+ *   v2.12.0 — 2026-06-30 — Learning loop closes: (A) selectLessons threads the highest-signal reviewed-
+ *     decision scores into the tick's briefing/action prompt (repeat what worked, avoid what didn't);
+ *     (B) proposeLearnedRule — when a cluster of reviewed decisions scored poorly, the tick asks for ONE
+ *     durable operating rule and posts it as a GATED inbox card (brain-rule) the owner approves; never
+ *     auto-applied. Source decisions flagged proposalUsed so a cluster doesn't re-propose.
+ *   v2.11.0 — 2026-06-30 — Secretary autonomous authoring: a band-gated phase (`author_content`) fills
+ *     the active context's EMPTY workspaces — document spaces first, then records — toward the focus
+ *     milestone (services/secretary-authoring.ts). act → write + publish · draft/ask → leave drafts ·
+ *     off (default) → skip. Metered per workspace, capped by the same per-day morsel budget.
+ *   v2.10.0 — 2026-06-28 — Secretary Strategy: the tick reads the active context's optional `strategy`
+ *     (current → target + principles/risks + ordered milestones) and steers the briefing toward the
+ *     current focus milestone (first not-yet-reached), respecting the principles + flagging risks.
+ *   v2.9.0 — 2026-06-28 — Secretary bound triggers: a fired trigger can carry out a BOUND action —
+ *     start an Agent Workflow run, or queue + run a specialist task (its prompt) node-side this tick —
+ *     instead of only posting a reminder (fireBoundTriggerAction). Gated by the existing spend guards.
  *   v2.8.0 — 2026-06-24 — Secretary P5 (S-C): scheduled extension jobs decrypt `type: secret` config
  *     before the sandbox VM, and an instance-scoped job loads the instance's (decrypted) config so a
  *     cron sync uses the same bring-your-own-key secret a live action would. See extension-secrets.ts.
@@ -22,6 +43,9 @@
  *   v2.5.0 — 2026-06-24 — Add the `secretary` kind: the Secretary's autonomous tick (Phase 4) — runs
  *     the active context's brain on the owner's key and appends a briefing to `secretary.feed`;
  *     stop-spending skips the paid call.
+ *   v2.5.1 — 2026-06-29 — Secretary tick: pre-flight AI-availability guard — when the owner has no usable
+ *     AI key, skip the tick gracefully (like stop-spending/budget) instead of erroring every run once the
+ *     "daily check-in always briefs" change removed the idle early-out.
  *   v1.0.0 — 2026-03-01 — Initial implementation with croner
  *   v2.0.0 — 2026-03-15 — Add @activate trigger, execution log, memory access tracking
  *   v2.1.0 — 2026-06-05 — executeJob/triggerNow return a JobOutcome so a manual
@@ -42,11 +66,17 @@ import { executeExtensionAction, trackMemoryAccess } from './extension-runtime.j
 import { getEncryptionKey } from './encryption.js';
 import { getExtSecretKeys, getInstanceSecretKeys, decryptSecretFields } from './extension-secrets.js';
 import { completeForOwner } from './ai-completion.js';
+import { proposeWorkBriefs as buildContextBriefs, resolveCompletedBriefs } from './secretary-workbrief.js';
+import { notify } from './notify.js';
+import { appendSecretaryFeed } from './secretary-feed.js';
+import { produceClarifyDeliverable } from './secretary-clarify.js';
+import { listSpecialists } from './specialist.js';
+import { runAllSpecialists, runSpecialistQueue } from './specialist-runner.js';
 import { getActiveWorkflowEngine } from './workflow/engine.js';
 import { getActiveConnectTunnelManager } from './connect-tunnel.js';
 import { parseGaiiLoose, buildGEAI } from '../utils/gaii.js';
 import { evaluateConstraints, applyAfterRun } from './schedule-constraints.js';
-import { classifySecretaryActions, hasWorkToDo, ledgerSpentToday, budgetExceeded, bumpLedger, routeTickNote } from './secretary-tick.js';
+import { classifySecretaryActions, actionKind, ledgerSpentToday, budgetExceeded, bumpLedger, routeTickNote, deriveRoutineActions, actionItemKey, routineDueForRearm, rearmRoutine, isAllowedQuickAction, evaluateTriggers, settleFiredTrigger, selectLessons, poorDecisionCluster } from './secretary-tick.js';
 import { emitChange } from './event-bus.js';
 import { emitResourceUpdated } from '../mcp/index.js';
 import { logger } from '../utils/logger.js';
@@ -499,6 +529,14 @@ export class Scheduler {
             this.notifyOwner(job, 'Secretary paused for today', `daily budget reached (${spentToday}/${budget} morsels)`);
             return { reads: ['secretary.config'], writes: [], skipped: true, skipReason: `daily morsel budget reached (${spentToday}/${budget})` };
         }
+        // (2.5) AI-availability guard: the autonomous tick's core output is a PAID AI briefing — the daily
+        // check-in always briefs (there is no "nothing to do" early-out). If the owner has no usable AI key,
+        // no paid call can run this tick, so skip gracefully — exactly like the stop-spending / budget guards
+        // above — instead of letting completeForOwner throw NO_API_KEY and marking EVERY tick "failed" (which
+        // also fires a "Schedule failed" notification each run). The tick resumes once a key is set in Settings.
+        if (!(await this.ownerHasUsableAiKey(owner))) {
+            return { reads: ['secretary.config', 'openrouter.apikey'], writes: [], skipped: true, skipReason: 'no AI key configured' };
+        }
         // (3) Cheap "anything to do?" pre-check (P1-B): no open goals + no due decisions → skip the paid call.
         const goalRecs = await this.storage.listMemory(owner, { prefix: 'secretary.goal.' });
         const openGoals = goalRecs
@@ -509,12 +547,74 @@ export class Scheduler {
         const dueDecisions = decRecs
             .map((r) => (r.value ?? {}))
             .filter((d) => d.status === 'open' && typeof d.revisitWhen === 'string' && Date.parse(d.revisitWhen) <= nowMs);
-        if (!hasWorkToDo({ openGoals: openGoals.length, dueDecisions: dueDecisions.length })) {
-            return { reads: ['secretary.config', 'secretary.goal.*', 'secretary.decision.*'], writes: [], skipped: true, skipReason: 'nothing to do (no open goals or decisions due)' };
+        // (3a) G2: re-arm any RECURRING routine whose cadence has elapsed since its last completed run —
+        // reset its steps to 'pending' + re-activate it (FREE, no AI). Applied to the working `active` so the
+        // advancement pass below picks up the freshly-pending steps; persisted via persistTickState.
+        const rearmNowIso = new Date().toISOString();
+        const rearmNowMs = Date.now();
+        const rearmedRoutines = [];
+        if (Array.isArray(active.routines)) {
+            active.routines = active.routines.map((r) => {
+                if (r.id && routineDueForRearm(r, rearmNowMs)) {
+                    const armed = rearmRoutine(r, rearmNowIso, rearmNowMs);
+                    rearmedRoutines.push({ id: r.id, routine: armed });
+                    return armed;
+                }
+                return r;
+            });
         }
+        // (3a2) Triggers (Slice 2): evaluate the owner's triggers — fire any that are due (time/recurring),
+        // whose bound target completed, or whose condition is met. FREE (no AI). Signals from memory.
+        const trigRecs = await this.storage.listMemory(owner, { prefix: 'secretary.trigger.' });
+        const triggers = trigRecs.map((r) => (r.value ?? {})).filter((tr) => tr && tr.id);
+        let firedTriggers = [];
+        if (triggers.length) {
+            const completed = {};
+            for (const r of goalRecs) {
+                const g = (r.value ?? {});
+                if (g.id)
+                    completed[String(g.id)] = g.status === 'done';
+            }
+            for (const c of contexts)
+                for (const rt of (c.routines || []))
+                    if (rt.id)
+                        completed[rt.id] = rt.status === 'done';
+            const memoryCounts = {};
+            const lastActivityMs = {};
+            const prefixes = Array.from(new Set(triggers.filter((tr) => tr.kind === 'condition' && tr.condition?.prefix).map((tr) => tr.condition.prefix)));
+            for (const pfx of prefixes) {
+                const recs = await this.storage.listMemory(owner, { prefix: pfx });
+                memoryCounts[pfx] = recs.length;
+                let newest = 0;
+                for (const r of recs) {
+                    const ts = Date.parse(r.updatedAt || '');
+                    if (!Number.isNaN(ts) && ts > newest)
+                        newest = ts;
+                }
+                if (newest)
+                    lastActivityMs[pfx] = newest;
+            }
+            firedTriggers = evaluateTriggers(triggers, { completed, memoryCounts, lastActivityMs }, nowMs).map((f) => f.trigger);
+        }
+        // (3a2) Clarify jobs the owner may have answered: the Secretary asked questions instead of guessing;
+        // once answered (in the inbox) the tick produces the deliverable grounded in those answers.
+        const clarifyRecs = await this.storage.listMemory(owner, { prefix: 'secretary.clarify.' });
+        const askedClarify = clarifyRecs.map((r) => (r.value ?? {})).filter((j) => j && j.status === 'asked');
+        // (3a3) Specialists the Secretary directs: any with QUEUED tasks have node-run work to do this tick.
+        const specialistAgents = await listSpecialists(this.storage, owner.split('@')[0]);
+        const hasSpecialistWork = specialistAgents.length > 0
+            && (await Promise.all(specialistAgents.map((s) => this.storage.listAgentTasks(s.gaii, { status: 'queued', perPage: 1 })))).some((r) => r.total > 0);
+        // (3b) B5: band-driven routine advancement (FREE — no AI). Decide, from each active routine's next
+        // step band, what the tick should auto-run (act-band file steps) vs surface as a follow-up action-item.
+        const routineActions = deriveRoutineActions(active);
+        // The daily check-in always produces a briefing + proposed next actions (its whole purpose) — it never
+        // skips for "nothing to do". Cost is bounded by the earlier stop-spending + daily-budget guards.
         const ownerName = owner.split('@')[0];
         const writes = [];
         const newPending = {};
+        // B5: routine step completions (act-band file steps the tick ran) + the action-items it derived.
+        const stepCompletions = [];
+        let newActionItems = [];
         let paidMorsels = 0;
         try {
             // Learning loop (Phase 5): score any decisions whose revisit time passed (each = 1 morsel).
@@ -525,10 +625,76 @@ export class Scheduler {
                 await this.appendFeed(owner, { kind: 'review', contextId: active.id, contextName: active.name || '', text: `Reviewed ${reviewed.length} decision(s):\n${summary}` });
                 writes.push(...reviewed.map((r) => `secretary.decision.${r.id}`));
             }
+            // Learning loop (B): when a cluster of reviewed decisions scored poorly, propose ONE durable
+            // operating rule — GATED: posted as an inbox card the owner approves; never auto-applied to the brain.
+            const proposal = await this.proposeLearnedRule(owner, ownerName, active, cfg.pendingDecisions ?? {});
+            if (proposal) {
+                newPending[proposal.id] = proposal.pending;
+                paidMorsels += 1;
+                writes.push('agent-message', ...proposal.writes);
+            }
+            const wsList = await this.loadContextWorkspaces(owner, active);
+            // Resume any answered clarify jobs: produce the deliverable grounded in the owner's answers (+ facts).
+            const clarifyWrites = await this.resumeClarifyJobs(owner, ownerName, askedClarify);
+            writes.push(...clarifyWrites);
+            paidMorsels += clarifyWrites.filter((w) => w.startsWith('organism.')).length;
+            // Direct the specialists: run each specialist's queued tasks node-side (owner key + quality contract).
+            if (hasSpecialistWork) {
+                const specialistWrites = await runAllSpecialists(this.storage, this.config, owner, ownerName);
+                if (specialistWrites.length) {
+                    writes.push(...specialistWrites);
+                    paidMorsels += specialistWrites.length;
+                    await this.appendFeed(owner, { kind: 'act', contextId: active.id, contextName: active.name || '', text: `🧩 Specialists produced ${specialistWrites.length} deliverable(s)` });
+                    writes.push('secretary.feed');
+                }
+            }
+            // B5 routine pass (FREE — no AI): auto-run each act-band performable step + mark it done, and stamp
+            // the derived follow-up action-items. draft/ask/delegate steps were already turned into action-items
+            // by deriveRoutineActions — the owner handles those from the dashboard. G4: the step's kind comes
+            // from actionKind (note caps file a note; briefing/reminders append a feed entry) — performSecretaryAct
+            // carries out the right one, so briefing/reminders are FED here exactly as in the legacy action-loop.
+            const nowIso = new Date().toISOString();
+            for (const fs of routineActions.runSteps) {
+                const routine = (active.routines || []).find((r) => r.id === fs.routineId);
+                const step = (routine?.steps || []).find((s) => s.id === fs.stepId);
+                if (!step)
+                    continue;
+                const kind = actionKind(String(step.capability)); // 'note' | 'feed'
+                const a = { capability: String(step.capability), summary: String(step.summary || ''), payload: { note: String(step.summary || '') }, kind, band: 'act' };
+                writes.push(...await this.performSecretaryAct(owner, active, a, wsList));
+                const verb = kind === 'feed' ? 'Surfaced' : 'Filed';
+                stepCompletions.push({ routineId: fs.routineId, stepId: fs.stepId, status: 'done', summary: `${verb}: ${String(step.summary || '')}`.slice(0, 200) });
+            }
+            newActionItems = routineActions.items.map((it) => ({
+                id: 'ai-' + randomUUID().slice(0, 8), labelKind: it.labelKind, summary: it.summary, suggestedAction: it.suggestedAction, source: it.source, createdAt: nowIso, status: 'open',
+            }));
+            // Fire triggers (Slice 2 + bound actions): each fired trigger either just REMINDS (feed entry +
+            // action-item, the default) or carries out a BOUND action — start an Agent Workflow run, or queue +
+            // run a task for one of the owner's specialists. A bound action that ran does the work, so no
+            // follow-up action-item is added (the feed records what happened). Then the trigger settles
+            // (recurring re-arms with a new nextFireAt; one-off/completion/condition → 'fired'). Paid bound
+            // actions (workflow/specialist) are metered like any autonomous spend; the earlier stop-spending +
+            // daily-budget guards already gate this whole block.
+            for (const tr of firedTriggers) {
+                const label = String(tr.label || tr.action?.summary || 'Trigger').slice(0, 200);
+                const bound = await this.fireBoundTriggerAction(owner, ownerName, tr, label, specialistAgents, writes);
+                await this.appendFeed(owner, { kind: 'trigger', contextId: tr.contextId || active.id, contextName: active.name || '', text: bound ? `⏰ ${label} → ${bound.note}` : `⏰ ${label}` });
+                if (bound)
+                    paidMorsels += bound.morsels;
+                else
+                    newActionItems.push({ id: 'ai-' + randomUUID().slice(0, 8), text: label, suggestedAction: { kind: 'advance', routineId: '' }, source: 'trigger:' + tr.id, createdAt: nowIso, status: 'open' });
+                const settled = settleFiredTrigger(tr, nowMs);
+                const key = `secretary.trigger.${tr.id}`;
+                const ex = trigRecs.find((r) => r.key === key);
+                await this.storage.setMemory({ key, ownerGaii: owner, value: settled, visibility: 'private', tags: ['secretary', 'trigger', String(settled.status || '')], ttlHours: null, version: ex ? ex.version + 1 : 1, createdAt: ex?.createdAt ?? nowIso, updatedAt: nowIso });
+                writes.push(key);
+            }
             // Action generation (P1-A): ask the model for a STRUCTURED action list tied to the open goals +
             // a bounded slice of the self-organism (the context's workspaces). 1 paid morsel.
-            const wsList = await this.loadContextWorkspaces(owner, active);
-            const { systemPrompt, prompt } = this.buildTickPrompt(ownerName, active, openGoals, wsList);
+            // Learning loop (A): thread the highest-signal reviewed-decision lessons into the prompt so the next
+            // cycle repeats what scored well and avoids what scored poorly (the scores aren't a dead-end record).
+            const lessons = selectLessons(decRecs.map((r) => (r.value ?? {})), active.id);
+            const { systemPrompt, prompt } = this.buildTickPrompt(ownerName, active, openGoals, wsList, lessons);
             const result = await completeForOwner(this.storage, this.config, owner, { prompt, systemPrompt, appId: `schedule:${job.id}` });
             paidMorsels += 1;
             const parsed = extractJsonObject(result.content);
@@ -576,19 +742,64 @@ export class Scheduler {
             const feedText = deferred.length ? `${briefingText}\n\n${deferred.join('\n')}` : briefingText;
             await this.appendFeed(owner, { kind: 'briefing', contextId: active.id, contextName: active.name || '', text: feedText });
             writes.push('secretary.feed');
+            // Heavy work is DISPATCHED, not invented here. Instead of asking the cheap model to author content
+            // one-shot (which hallucinated and "went onto the Builders' turf"), the tick detects STRUCTURAL gaps
+            // (empty/thin workspaces, stale content, off-target KPIs) and proposes a grounded Work Brief a Builder
+            // — a connected big AI via the appdev MCP tools — executes (the owner pastes it into Claude Desktop,
+            // or dispatches it to a connected agent). Brief assembly is deterministic (no paid call), idempotent
+            // (deduped against open briefs by gap), and bounded per tick. The cheap Secretary never authors data.
+            // Self-heal first: a dispatched brief whose Builder task finished flips to 'done' so it leaves the tray.
+            await resolveCompletedBriefs(this.storage, owner).catch(() => 0);
+            const briefed = await this.proposeWorkBriefs(owner, ownerName, active, wsList, openGoals);
+            if (briefed.writes.length) {
+                writes.push(...briefed.writes);
+                for (const line of briefed.feedLines) {
+                    await this.appendFeed(owner, { kind: 'briefing', contextId: active.id, contextName: active.name || '', text: line, href: '/v1/secretary' });
+                }
+                writes.push('secretary.feed');
+                emitChange('agents', owner);
+                // Notify the owner (the header bell) when NEW heavy work is ready to hand off — so a brief the tick
+                // proposes overnight is actively surfaced, not just discovered on the next visit. Best-effort.
+                if (briefed.briefs.length) {
+                    await notify(this.storage, owner, {
+                        type: 'secretary_work_brief',
+                        title: briefed.briefs.length === 1 ? '1 work brief ready' : `${briefed.briefs.length} work briefs ready`,
+                        body: 'Heavy work the Secretary prepared — hand it to a Builder.',
+                        link: '/v1/secretary',
+                    });
+                }
+            }
         }
         finally {
-            // Persist the spend ledger (+ any new pending decisions) even if generation threw mid-way, so the
-            // soft budget reflects what was actually spent. Read-modify-write a fresh config to avoid clobber.
-            if (paidMorsels > 0 || Object.keys(newPending).length) {
-                await this.persistTickState(owner, active.id, today, paidMorsels, newPending);
+            // Persist the spend ledger (+ any new pending decisions, routine step completions, and derived
+            // action-items) even if generation threw mid-way, so the soft budget reflects what was actually
+            // spent. Read-modify-write a fresh config to avoid clobber.
+            if (paidMorsels > 0 || Object.keys(newPending).length || stepCompletions.length || newActionItems.length || rearmedRoutines.length) {
+                await this.persistTickState(owner, active.id, today, paidMorsels, newPending, stepCompletions, newActionItems, rearmedRoutines);
                 writes.push('secretary.config');
             }
         }
         if (Object.keys(newPending).length)
             emitChange('agent-messages');
+        if (stepCompletions.length || newActionItems.length || rearmedRoutines.length)
+            emitChange('agent-tasks', owner);
         return { reads: ['secretary.config', 'secretary.goal.*', 'secretary.decision.*'], writes };
     }
+    /**
+     * True when the owner has a usable AI key for autonomous completions. Mirrors the key resolution in
+     * completeForOwner(): the default 'openrouter' provider REQUIRES an encrypted key; other providers
+     * (e.g. a local model) may run keyless. Used as the Secretary tick's pre-flight guard so the tick
+     * skips rather than errors when no paid call is possible.
+     */
+    async ownerHasUsableAiKey(owner) {
+        const [keyRec, prefsRec] = await Promise.all([
+            this.storage.getMemory(owner, 'openrouter.apikey'),
+            this.storage.getMemory(owner, 'openrouter.settings'),
+        ]);
+        const provider = prefsRec?.value?.provider || 'openrouter';
+        const hasKey = !!keyRec?.value?.encrypted;
+        return provider !== 'openrouter' || hasKey;
+    }
     /** Read the active context's workspaces (id + name) from its self-organism registry. */
     async loadContextWorkspaces(owner, active) {
         if (!active.organismId)
@@ -597,15 +808,53 @@ export class Scheduler {
         const list = (rec?.value?.workspaces) ?? [];
         return list.filter((w) => w && w.id).map((w) => ({ id: w.id, name: w.name || w.id }));
     }
+    /**
+     * Detect structural gaps in the active context's workspaces and propose Work Briefs for a Builder to
+     * execute — heavy work is DISPATCHED, never invented by the cheap Secretary. Deterministic + idempotent:
+     * a gap already covered by an OPEN brief (proposed/dispatched) is skipped, so repeated ticks converge
+     * instead of spamming. Bounded to MAX_NEW_BRIEFS new briefs per tick. No paid AI call (storage reads +
+     * best-effort Discovery only). Briefs are persisted as secretary.brief.{id}; the view's brief tray reads
+     * them and offers "Open in Claude Desktop" / "Send to a connected Builder".
+     */
+    async proposeWorkBriefs(owner, ownerName, active, wsList, openGoals) {
+        const briefContext = { id: active.id, name: active.name, organismId: active.organismId, brain: active.brain, strategy: active.strategy };
+        const { writes, briefs } = await buildContextBriefs(this.storage, this.config, {
+            ownerGhii: owner, ownerName, active: briefContext, wsList, openGoals,
+        });
+        const feedLines = briefs.map((b) => `📋 Work brief ready — ${b.objective} Open it in the Secretary to hand to a Builder.`);
+        return { writes, feedLines, briefs };
+    }
     /** Build the tick's system + user prompt asking for a STRUCTURED action list (P1-A). */
-    buildTickPrompt(ownerName, active, openGoals, wsList) {
+    buildTickPrompt(ownerName, active, openGoals, wsList, lessons = []) {
         const rules = (active.brain?.rules || []).map((r) => '- ' + (r.description || '')).join('\n');
         const systemPrompt = `You are ${ownerName}'s personal Secretary, working in the "${active.name || 'personal'}" context.\n${active.brain?.purpose || ''}\n\nOperating rules:\n${rules || '(none)'}\n\nYou are doing an autonomous check-in for the owner (they are not present). Reply in the owner's language. Return ONLY a JSON object — no prose around it.`;
         const goalLines = openGoals.length
             ? openGoals.map((g) => `- ${String(g.title || '')}${g.why ? ` (why: ${String(g.why)})` : ''}`).join('\n')
             : '(no open goals)';
         const wsNames = wsList.map((w) => w.name).join(', ') || '(none yet)';
-        const prompt = `Open goals in this context:\n${goalLines}\n\nThe owner's filing space "${active.organismName || active.name}" has these workspaces: ${wsNames}.\n\nDecide what to do for the owner right now. Return a JSON object EXACTLY like:\n{\n  "briefing": "2-4 sentence check-in: what to focus on and anything needing attention",\n  "actions": [\n    { "capability": "file_intake", "summary": "short label", "payload": { "workspace": "<an existing workspace name>", "note": "the text to file" } },\n    { "capability": "reminders", "summary": "a concrete reminder for the owner", "payload": {} }\n  ]\n}\nRules for actions: propose 0-3 CONCRETE actions that move the open goals forward. Only use these capabilities: "file_intake"/"curate_knowledge" (file a note into a workspace — set payload.workspace to an existing workspace name and payload.note to the text) and "reminders"/"briefing" (surface a note to the owner — payload may be empty). Do not invent other capabilities. If nothing concrete is warranted, return an empty actions array.`;
+        // Optional strategy steering: if this context has a strategy, give the model the current → target,
+        // the principles/risks to respect, and the CURRENT FOCUS milestone (first not-yet-reached) so the
+        // briefing steers toward it and flags when it looks reached. Free text; never invents progress.
+        let strategyBlock = '';
+        const strat = active.strategy;
+        if (strat && strat.enabled) {
+            const msl = Array.isArray(strat.milestones) ? strat.milestones : [];
+            const focus = msl.find((m) => m && m.status !== 'reached');
+            const principles = (strat.principles || []).filter(Boolean);
+            const risks = (strat.risks || []).filter(Boolean);
+            strategyBlock = `\n\nStrategy for this area:\n- Current state: ${strat.current || '(unstated)'}\n- Target state: ${strat.target || '(unstated)'}\n- Current focus milestone: ${focus ? `${focus.title}${focus.enables ? ` (enables: ${focus.enables})` : ''}` : '(all milestones reached — suggest what the next target could be)'}`
+                + (principles.length ? `\n- Principles to respect: ${principles.join('; ')}` : '')
+                + (risks.length ? `\n- Risks to watch: ${risks.join('; ')}` : '')
+                + `\nSteer the briefing toward this focus milestone, respect the principles, and flag a risk if it is materialising. If recent activity suggests the milestone is reached, say so and point at the next one.`;
+        }
+        // Learning loop (A): the highest-signal lessons from past decisions the owner's reviews scored —
+        // repeat what worked, avoid what didn't. Free text; the model weighs them, nothing is auto-applied.
+        let lessonsBlock = '';
+        if (lessons.length) {
+            lessonsBlock = `\n\nLessons from your recently reviewed decisions (let these steer you — lean on what scored well, avoid repeating what scored poorly):\n`
+                + lessons.map((l) => `- [${l.score}/100] ${l.decision}${l.verdict ? ` — ${l.verdict}` : ''}`).join('\n');
+        }
+        const prompt = `Open goals in this context:\n${goalLines}\n\nThe owner's filing space "${active.organismName || active.name}" has these workspaces: ${wsNames}.${strategyBlock}${lessonsBlock}\n\nDecide what to do for the owner right now. Return a JSON object EXACTLY like:\n{\n  "briefing": "2-4 sentence check-in: what to focus on and anything needing attention",\n  "actions": [\n    { "capability": "file_intake", "summary": "short label", "payload": { "workspace": "<an existing workspace name>", "note": "the text to file" } },\n    { "capability": "reminders", "summary": "a concrete reminder for the owner", "payload": {} }\n  ]\n}\nRules for actions: propose 0-3 CONCRETE actions that move the open goals forward. Only use these capabilities: "file_intake"/"curate_knowledge" (file a note into a workspace — set payload.workspace to an existing workspace name and payload.note to the text) and "reminders"/"briefing" (surface a note to the owner — payload may be empty). Do not invent other capabilities. If nothing concrete is warranted, return an empty actions array.`;
         return { systemPrompt, prompt };
     }
     /** Best-match a workspace by (possibly fuzzy) name; falls back to the first workspace. */
@@ -623,6 +872,37 @@ export class Scheduler {
         }
         return wsList[0];
     }
+    /**
+     * Resume answered clarify jobs (ask-don't-hallucinate): for each job whose inbox questions the owner
+     * answered, produce the deliverable grounded ONLY in the stored facts + those answers, file it into the
+     * job's workspace, reply the outcome back into the thread, and mark the job done. Unanswered jobs are
+     * left untouched. Produce logic is shared with the live DM responder (services/secretary-clarify.ts).
+     */
+    async resumeClarifyJobs(owner, ownerName, jobs) {
+        const writes = [];
+        if (!jobs.length)
+            return writes;
+        const secretaryGaii = `secretary#${ownerName}@${this.config.nodeId}`;
+        // Local agent→owner delivery never touches federation peers, so an empty map is sufficient here.
+        const ctx = { config: this.config, storage: this.storage, peers: new Map() };
+        for (const job of jobs) {
+            const conversationId = job.conversationId;
+            const questionId = job.questionId;
+            if (!conversationId || !questionId)
+                continue;
+            const thread = await this.storage.listAgentDmThread(secretaryGaii, conversationId, { perPage: 50 }).catch(() => null);
+            const msgs = thread?.messages || [];
+            const ans = msgs.find((m) => m.interactive?.role === 'answers' && m.interactive.answersFor === questionId);
+            if (!ans || ans.interactive?.role !== 'answers')
+                continue; // not answered yet
+            const { writes: w } = await produceClarifyDeliverable(ctx, {
+                ownerGhii: owner, ownerName, agentGaii: secretaryGaii,
+                job: job, answers: ans.interactive.answers,
+            });
+            writes.push(...w);
+        }
+        return writes;
+    }
     /**
      * Perform an `act`-band action: file a note (note kind) or append a feed entry (feed kind). `ctx` is
      * the destination context — normally the active context, but for a G1 auto-routed note it is the
@@ -644,7 +924,7 @@ export class Scheduler {
                 const text = routedFrom
                     ? `Routed a note to ${ctx.name || ctx.id} → ${ws.name}: ${a.summary}`
                     : `Filed a note → ${ws.name}: ${a.summary}`;
-                await this.appendFeed(owner, { kind: 'act', contextId: ctx.id, contextName: ctx.name || '', text });
+                await this.appendFeed(owner, { kind: 'act', contextId: ctx.id, contextName: ctx.name || '', text, href: `/v1/profile?tab=organisms&org=${ctx.organismId}&ws=${ws.id}` });
                 return [key, 'secretary.feed'];
             }
         }
@@ -658,6 +938,69 @@ export class Scheduler {
         const map = rec?.value?.map;
         return (map && typeof map === 'object') ? map : {};
     }
+    /**
+     * Learning loop (B): when a CLUSTER of reviewed decisions in this context scored poorly, ask the model
+     * for ONE durable operating rule that would avoid repeating them, and post it as a GATED inbox decision
+     * card (type 'brain-rule'). The owner approves it in the inbox (applyDecision appends it to the brain) —
+     * it is NEVER auto-applied. The source decisions are flagged `proposalUsed` so the same cluster doesn't
+     * re-propose every tick. Returns the pending card (+ the keys written) or null when there isn't enough
+     * signal / a brain-rule proposal is already pending / the model returns nothing. One paid morsel on propose.
+     */
+    async proposeLearnedRule(owner, ownerName, active, existingPending) {
+        // One brain-rule proposal at a time — don't stack cards.
+        if (Object.values(existingPending).some((p) => p?.type === 'brain-rule'))
+            return null;
+        const recs = await this.storage.listMemory(owner, { prefix: 'secretary.decision.' });
+        const byId = new Map();
+        const values = [];
+        for (const r of recs) {
+            const d = (r.value ?? {});
+            if (d.id)
+                byId.set(String(d.id), r);
+            values.push(d);
+        }
+        const cluster = poorDecisionCluster(values, active.id);
+        if (!cluster.length)
+            return null;
+        const secretaryGaii = `secretary#${ownerName}@${this.config.nodeId}`;
+        const agent = await this.storage.getAgent(secretaryGaii);
+        if (!agent)
+            return null;
+        const systemPrompt = `You distil ONE durable operating rule for ${ownerName}'s Secretary from past decisions that turned out poorly. Reply in the owner's language. Return ONLY a JSON object: {"rule": "one concrete, actionable sentence the Secretary should follow from now on"}.`;
+        const prompt = `These past decisions scored poorly on review:\n${cluster.map((d, i) => `${i + 1}. ${String(d.decision || '')} — chosen: ${String(d.chosen || '')} — verdict: ${String(d.verdict || '')} (${d.score}/100)`).join('\n')}\n\nPropose ONE operating rule that, followed from now on, would avoid repeating these. Make it concrete and general enough to reuse — not a restatement of a single case.`;
+        let rule;
+        try {
+            const out = await completeForOwner(this.storage, this.config, owner, { prompt, systemPrompt, appId: 'schedule:learn:rule' });
+            rule = String(extractJsonObject(out.content)?.rule ?? '').trim().slice(0, 400);
+        }
+        catch {
+            return null;
+        }
+        if (!rule)
+            return null;
+        // Flag the source decisions so the cluster doesn't re-propose every tick.
+        const now = new Date().toISOString();
+        const writes = [];
+        for (const d of cluster) {
+            const rec = byId.get(String(d.id));
+            if (!rec)
+                continue;
+            await this.storage.setMemory({ key: rec.key, ownerGaii: owner, value: { ...d, proposalUsed: true }, visibility: 'private', tags: rec.tags ?? ['secretary', 'decision', 'reviewed', active.id], ttlHours: null, version: rec.version + 1, createdAt: rec.createdAt, updatedAt: now });
+            writes.push(rec.key);
+        }
+        const promptId = 'learn-' + randomUUID().slice(0, 8);
+        const question = `I noticed ${cluster.length} past decisions that went poorly. Add this rule to my brain so I avoid repeating them?\n\n"${rule}"`;
+        const pending = { type: 'brain-rule', rule, contextId: active.id, contextName: active.name || '', basisCount: cluster.length, question, createdAt: now };
+        const record = {
+            id: randomUUID(), agentGaii: secretaryGaii, threadId: randomUUID(), direction: 'outbound', senderGaii: owner,
+            content: `Proposed operating rule: ${rule}`, status: 'delivered',
+            metadata: { prompt: { promptId, question, options: ['Yes, add it', 'No'], allowOther: false } }, createdAt: now,
+        };
+        await this.storage.createMessage(record);
+        await this.appendFeed(owner, { kind: 'review', contextId: active.id, contextName: active.name || '', text: `💡 Proposed a learned rule from ${cluster.length} reviewed decisions — approve it in your inbox.` });
+        writes.push('secretary.feed');
+        return { id: promptId, pending, writes };
+    }
     /**
      * Post a draft/ask-band action as an inbox decision card (reusing the Phase-3b prompt rails) and
      * return the stashed pending action keyed by promptId. Note actions reuse the existing `file-note`
@@ -699,31 +1042,69 @@ export class Scheduler {
         await this.storage.createMessage(record);
         return { id: promptId, pending };
     }
-    /** Read-modify-write secretary.config to persist the day's spend ledger + any new pending decisions. */
-    async persistTickState(owner, contextId, today, morsels, newPending) {
+    /**
+     * Read-modify-write secretary.config to persist the day's spend ledger + any new pending decisions,
+     * plus (B5) routine step completions the tick performed and the action-items it derived. Applied to a
+     * FRESH read (targeted by routine/step id) to avoid clobbering concurrent view edits.
+     */
+    async persistTickState(owner, contextId, today, morsels, newPending, stepCompletions = [], newActionItems = [], rearmedRoutines = []) {
         const rec = await this.storage.getMemory(owner, 'secretary.config');
         const cfg = (rec?.value ?? {});
         const ledger = morsels > 0 ? bumpLedger(cfg.autonomousLedger, contextId, today, morsels) : cfg.autonomousLedger;
         const pending = Object.keys(newPending).length ? { ...(cfg.pendingDecisions ?? {}), ...newPending } : cfg.pendingDecisions;
-        const next = { ...cfg, autonomousLedger: ledger, pendingDecisions: pending };
         const now = new Date().toISOString();
+        // B5/G2: apply routine re-arms + step completions + merge action-items; G8: scrub quick actions.
+        let contexts = cfg.contexts;
+        if (Array.isArray(cfg.contexts)) {
+            contexts = cfg.contexts.map((c) => {
+                if (c.id !== contextId)
+                    return c;
+                // G8 defense-in-depth: drop any disallowed (e.g. smuggled 'run') quick action server-side.
+                const quickActions = Array.isArray(c.quickActions) ? c.quickActions.filter(isAllowedQuickAction) : c.quickActions;
+                let routines = c.routines;
+                // G2: replace re-armed routines first (steps reset to pending) so a same-tick file-step
+                // completion below lands on the freshly-armed step.
+                if (rearmedRoutines.length && Array.isArray(routines)) {
+                    routines = routines.map((r) => {
+                        const armed = rearmedRoutines.find((x) => x.id === r.id);
+                        return armed ? armed.routine : r;
+                    });
+                }
+                if (stepCompletions.length && Array.isArray(routines)) {
+                    routines = routines.map((r) => {
+                        const comps = stepCompletions.filter((sc) => sc.routineId === r.id);
+                        if (!comps.length)
+                            return r;
+                        const steps = (r.steps || []).map((s) => {
+                            const comp = comps.find((x) => x.stepId === s.id);
+                            return comp ? { ...s, status: comp.status, result: { summary: comp.summary, ts: now } } : s;
+                        });
+                        // B4 fix: a 'delegated' step is NOT settled (its task is still out) — the routine stays active.
+                        const settled = steps.every((s) => s.status !== 'pending' && s.status !== 'running' && s.status !== 'delegated');
+                        const results = [...comps.map((x) => ({ ts: now, summary: x.summary })), ...(r.results || [])].slice(0, 20);
+                        return { ...r, steps, results, lastRunAt: now, status: settled ? 'done' : r.status };
+                    });
+                }
+                let actionItems = c.actionItems;
+                if (newActionItems.length) {
+                    const existing = Array.isArray(c.actionItems) ? c.actionItems : [];
+                    const seenOpen = new Set(existing.filter((a) => a.status === 'open').map((a) => actionItemKey(a)));
+                    const fresh = newActionItems.filter((a) => !seenOpen.has(actionItemKey(a)));
+                    actionItems = [...fresh, ...existing].slice(0, 50);
+                }
+                return { ...c, routines, actionItems, quickActions };
+            });
+        }
+        const next = { ...cfg, contexts, autonomousLedger: ledger, pendingDecisions: pending };
         await this.storage.setMemory({
             key: 'secretary.config', ownerGaii: owner, value: next, visibility: 'private', tags: ['secretary', 'config'],
             ttlHours: null, version: rec ? rec.version + 1 : 1, createdAt: rec?.createdAt ?? now, updatedAt: now,
         });
     }
-    /** Append one entry to the owner's Home feed (`secretary.feed`, newest first, capped at 50). */
+    /** Append one entry to the owner's Home feed (`secretary.feed`, newest first, capped). Delegates to the
+     *  shared helper so the live DM responder / clarify-produce write the SAME feed. */
     async appendFeed(owner, entry) {
-        const feedKey = 'secretary.feed';
-        const existing = await this.storage.getMemory(owner, feedKey);
-        const list = Array.isArray(existing?.value?.items)
-            ? existing.value.items : [];
-        const now = new Date().toISOString();
-        const items = [{ id: randomUUID(), ts: now, ...entry }, ...list].slice(0, 50);
-        await this.storage.setMemory({
-            key: feedKey, ownerGaii: owner, value: { items }, visibility: 'private', tags: ['secretary', 'feed'],
-            ttlHours: null, version: existing ? existing.version + 1 : 1, createdAt: existing?.createdAt ?? now, updatedAt: now,
-        });
+        await appendSecretaryFeed(this.storage, owner, entry);
     }
     /**
      * Learning-loop review sweep (Phase 5): find open decision-log contracts whose `revisitWhen` has
@@ -766,6 +1147,53 @@ export class Scheduler {
         }
         return done;
     }
+    /**
+     * Carry out a fired trigger's BOUND action (if any). Returns null for a plain reminder (the caller then
+     * posts a follow-up action-item); otherwise `{ note, morsels }` describing what ran (the caller folds the
+     * note into the feed entry and meters the morsels). Two bindings:
+     *   - workflow: start the named Agent Workflow run via the deterministic engine.
+     *   - specialist: queue a task (the trigger's `prompt`, defaulting to its label) for the named specialist
+     *     and run it node-side now (owner key + quality contract), so the deliverable lands this same tick.
+     * Best-effort: any failure (unknown workflow/specialist, engine down, spend-pause) degrades to a plain
+     * reminder so a misconfigured binding never breaks the tick.
+     */
+    async fireBoundTriggerAction(owner, ownerName, tr, label, specialists, writes) {
+        const act = tr.action || {};
+        try {
+            if (act.kind === 'workflow' && act.workflowId) {
+                const engine = getActiveWorkflowEngine();
+                if (!engine)
+                    return null;
+                const r = await engine.startRun(owner, ownerName, String(act.workflowId), { mode: 'full-live' });
+                if ('error' in r) {
+                    logger.info('[secretary tick] bound workflow refused to start', { id: tr.id, wf: act.workflowId, err: r.error.join('; ') });
+                    return null;
+                }
+                writes.push(`workflows.run.${act.workflowId}.${r.runId}`);
+                return { note: `▶️ ${act.workflowId}`, morsels: 1 };
+            }
+            if (act.kind === 'specialist' && act.specialistName) {
+                const spec = specialists.find((s) => s.name === act.specialistName);
+                if (!spec)
+                    return null;
+                const now = new Date().toISOString();
+                await this.storage.createAgentTask({
+                    id: randomUUID(), agentGaii: spec.gaii, ownerGaii: owner,
+                    title: label, description: String(act.prompt || label).slice(0, 4000),
+                    scope: [], rules: [], verification: { userExpects: '', technicalChecks: [] }, todos: [],
+                    status: 'queued', parentTaskId: `trigger:${tr.id}`, createdAt: now, updatedAt: now,
+                });
+                const specWrites = await runSpecialistQueue(this.storage, this.config, owner, spec, { limit: 1 });
+                writes.push(...specWrites);
+                // 1 morsel for the specialist run even if it deferred (kept the queued task) — the run was attempted.
+                return { note: `🧩 ${spec.name}`, morsels: Math.max(1, specWrites.length) };
+            }
+        }
+        catch (e) {
+            logger.info('[secretary tick] bound trigger action failed', { id: tr.id, kind: act.kind, err: e.message });
+        }
+        return null;
+    }
     /**
      * `agent_task` kind: materialise an AgentTaskRecord into the target agent's
      * queue and wake it via the existing webhook/MCP/SSE fan-out. The schedule is