comisai 1.0.41 → 1.0.44

package/node_modules/@comis/daemon/dist/wiring/setup-schedulers.js

@@ -10,11 +10,51 @@
  * loops from the main daemon wiring sequence.
  * @module
  */
-import { safePath, SkillsConfigSchema, formatSessionKey, systemNowMs, systemSetTimeout } from "@comis/core";
+import { safePath, SkillsConfigSchema, formatSessionKey, systemNowMs, systemSetTimeout, resolveAutonomy } from "@comis/core";
 import { createSessionResetScheduler } from "@comis/agent";
-import { computeNextRunAtMs, createCronScheduler, createCronStore, createExecutionTracker, createTaskExtractor, createTaskStore, resolveEffectiveHeartbeatConfig, resolveHeartbeatSessionKey, } from "@comis/scheduler";
+import { computeNextRunAtMs, createCronScheduler, createCronStore, createExecutionTracker, resolveEffectiveHeartbeatConfig, resolveHeartbeatSessionKey, } from "@comis/scheduler";
+/**
+ * OBS-2/6b (hindsight-reflection-20260626): record a completed `__REFLECT__` run to the firing
+ * agent's execution tracker, so `cron.runs jobName "Reflection"` surfaces the reflection funnel
+ * VERDICT (the admissionOutcome + counts) AND the run is POLLABLE — instead of a daemon.log grep.
+ *
+ * WHY here (not the cron executeJob path): the reflect sentinel is a fire-and-forget `system_event`,
+ * so executeJob cannot await the ~22s reflection to record its result. Instead we fold the per-run
+ * record off the content-free `reflect:funnel` event (OBS-1 put the full funnel on it). `jobId` mirrors
+ * the reflect cron's id (`reflect-<agentId>`) so `resolveJobByName(scheduler,"Reflection")` resolves to
+ * this history. Content-free: the summary is the closed admissionOutcome enum + counts ONLY (INV-6 —
+ * never a doc body). `durationMs` is 0 (the event carries no duration; the verdict + ts are the value).
+ */
+export async function recordReflectFunnelRun(tracker, funnel, nowMs) {
+    if (tracker === undefined)
+        return; // unknown/unregistered agent → no-op (never throws)
+    // OBS-7: `topics=N` (distinctTopicKeys) + maxCard makes under-merge readable on `cron.runs`:
+    // admitted=0 with topics>1 & maxCard=1 = successes that didn't merge (vs topics=1 maxCard>=2 = corroborated).
+    const summary = `reflect: outcome=${funnel.admissionOutcome} admitted=${funnel.admitted}` +
+        ` maxCard=${funnel.maxClusterCardinality} topics=${funnel.distinctTopicKeys} untrustedDrops=${funnel.untrustedDrops}` +
+        ` src=${funnel.sourceTrajectoryCount}traj/${funnel.totalSourceChars}ch`;
+    await tracker.record({ ts: nowMs, jobId: `reflect-${funnel.agentId}`, status: "ok", durationMs: 0, summary });
+}
+/**
+ * OBS-2b (reflect-obs-20260627): record a completed `__MEMORY_LIFECYCLE__` sweep to the firing agent's
+ * execution tracker, so `cron.runs jobName "Memory lifecycle"` surfaces the sweep result (scanned/
+ * evicted/demoted/promoted) — instead of a `db.mjs` `evicted_at` poll. The parity recorder for the
+ * forget half of learning (reflection has recordReflectFunnelRun). `jobId` mirrors the lifecycle cron's
+ * id (`memory-lifecycle-<agentId>`) so `resolveJobByName(scheduler,"Memory lifecycle")` resolves to this
+ * history. Content-free: counts ONLY (INV-6). Recorded off the content-free `learning:lifecycle_swept`
+ * event (the sentinel is fire-and-forget, so executeJob can't await the sweep). `durationMs` is 0 (the
+ * event carries no duration; the counts + ts are the value).
+ */
+export async function recordLifecycleRun(tracker, swept, nowMs) {
+    if (tracker === undefined)
+        return; // unknown/unregistered agent → no-op (never throws)
+    const summary = `lifecycle: scanned=${swept.scanned} evicted=${swept.evicted}` +
+        ` demoted=${swept.demoted} promoted=${swept.promoted}`;
+    await tracker.record({ ts: nowMs, jobId: `memory-lifecycle-${swept.agentId}`, status: "ok", durationMs: 0, summary });
+}
 import { createBrowserService } from "@comis/skills";
 import * as fs from "node:fs/promises";
+import { emitMemoryCostFeatureNotice } from "./setup-memory-cost-notice.js";
 // ---------------------------------------------------------------------------
 // Setup function
 // ---------------------------------------------------------------------------
@@ -31,9 +71,18 @@ import * as fs from "node:fs/promises";
  * @param deps.skillsLogger     - Module-bound logger for skills subsystem
  */
 export async function setupSchedulers(deps) {
-    const { container, workspaceDirs, sessionStore, sessionManager, schedulerLogger, agentLogger, skillsLogger, subprocessEnv, systemEventQueue, onCronWake, timers } = deps;
+    const { container, workspaceDirs, sessionStore, sessionManager, schedulerLogger, agentLogger, skillsLogger, subprocessEnv, systemEventQueue, onCronWake, clock, timers, leaseManager, boundedAutonomyHolder } = deps;
     const agents = container.config.agents; // Always populated after schema transform
     const schedulerConfig = container.config.scheduler;
+    // Master cost-feature kill switch (opt-out posture; renamed from memory.costFeatures.enabled to
+    // memory.enabled in Phase 226). When the operator sets memory.enabled:false, EVERY LLM
+    // cost-bearing memory cron is force-disabled at its registration site below — regardless of the
+    // agent's own per-feature opt-in. The gated set: memoryReview, memoryUsefulnessJudge, the
+    // __REFLECT__ reflection cron. NOT gated: the $0 keyless memoryLifecycle sweep. (The
+    // socialModeling cron was DELETED in Phase 226 SIMPLIFY-03 with the rest of that subsystem.)
+    // Default true (schema default) ⇒ byte-identical registration. Read defensively (`!== false`) so an
+    // unexpectedly-absent block fails OPEN to the prior behavior rather than silently disabling features.
+    const costFeaturesEnabled = container.config.memory?.enabled !== false;
     /** Resolve the formatted session key for an agent's main heartbeat session. */
     function resolveMainSessionKey(agentId) {
         const agentConfig = agents[agentId];
@@ -51,6 +100,7 @@ export async function setupSchedulers(deps) {
             continue;
         const agentWorkspace = workspaceDirs.get(agentId);
         const agentSchedulerDir = safePath(agentWorkspace, ".scheduler");
+        // fs-safe-allowed: per-agent scheduler dir under operator-configured workspace (`<agentWorkspace>/.scheduler`); not ~/.comis/ directly
         await fs.mkdir(agentSchedulerDir, { recursive: true });
         const cronStorePath = safePath(agentSchedulerDir, "cron-jobs.json");
         const agentCronStore = createCronStore(cronStorePath, schedulerLogger.child({ agentId }));
@@ -86,6 +136,34 @@ export async function setupSchedulers(deps) {
                     // --- Existing isolated/direct path below (unchanged) ---
                     const resultText = job.payload.kind === "system_event" ? job.payload.text : job.payload.message;
                     if (!job.deliveryTarget) {
+                        // system_event jobs STILL emit scheduler:job_result (live finding
+                        // 2026-06-11): the memory crons (review / consolidation /
+                        // reasoning / user-representation / usefulness-judge) are
+                        // deliveryTarget-less __SENTINEL__ jobs whose
+                        // actual WORK rides the scheduler:job_result listener
+                        // (setup-channels-credentials). The old return-before-emit made
+                        // every memory cron complete "ok" nightly while doing NOTHING.
+                        // The sentinel listeners return before delivery; a non-sentinel
+                        // deliveryTarget-less system_event hits the listener's own
+                        // skip-delivery warn — no delivery is ever attempted either way.
+                        if (job.payload.kind === "system_event") {
+                            container.eventBus.emit("scheduler:job_result", {
+                                jobId: job.id,
+                                jobName: job.name,
+                                agentId: job.agentId,
+                                result: resultText,
+                                success: true,
+                                timestamp: systemNowMs(),
+                                payloadKind: job.payload.kind,
+                                sessionStrategy: job.sessionStrategy,
+                                maxHistoryTurns: job.maxHistoryTurns,
+                                cadenceMs: job.schedule?.kind === "every" ? job.schedule.everyMs : undefined,
+                                cacheRetention: job.cacheRetention,
+                                toolPolicy: job.toolPolicy,
+                            });
+                            await agentExecTracker.record({ ts: systemNowMs(), jobId: job.id, status: "ok", durationMs: systemNowMs() - startTs, summary: "No delivery target (event emitted)" });
+                            return { status: "ok", summary: "No delivery target (event emitted)" };
+                        }
                         jobLogger.warn({ payloadKind: job.payload.kind, hint: "Job has no delivery target — result cannot be delivered. Was the job created from a channel context?", errorKind: "config" }, "Cron job has no delivery target, skipping delivery");
                         await agentExecTracker.record({ ts: systemNowMs(), jobId: job.id, status: "ok", durationMs: systemNowMs() - startTs, summary: "No delivery target" });
                         return { status: "ok", summary: "No delivery target" };
@@ -98,6 +176,40 @@ export async function setupSchedulers(deps) {
                     const deferredPromise = isAgentTurn
                         ? new Promise((resolve) => { deferredResolve = resolve; })
                         : undefined;
+                    // Phase 213-08 (RATE-02): a cron-FIRED agent_turn run mints a FRESH lease
+                    // scoped to the JOB's agentId + the agent's RESOLVED caps (NOT operator/
+                    // system) + a fresh root-cron-* id (a new root, no parentLeaseId), then
+                    // registerRoot anchors it. STRICTLY gated on agent_turn (system_event memory
+                    // crons do NOT mint). Best-effort: absent leaseManager/holder → skip (byte-
+                    // identical to pre-213 unbounded cron); a mint throw is WARN-logged + job STILL runs.
+                    // WR-04 (213-REVIEW): the cron-fired run dispatches via `scheduler:job_result` (not `runner.spawn`), so it deliberately does NOT consult CEIL-01. Cron fan-out is already triple-bounded — `cron.maxConcurrentRuns` (caps simultaneous fires, `cron-scheduler.ts:99`), the per-root budget this mint anchors (token+wall-clock), and `cronSelfMax` (caps self-owned job count). A cron-spawned sub-agent is still CEIL-01-bound via session.spawn→resolveRootRunId (a distinct per-session root; correlating it to this `root-cron-*` is a future enhancement, not an M1 gap).
+                    const capLayer = boundedAutonomyHolder?.current;
+                    if (isAgentTurn && leaseManager && capLayer) {
+                        try {
+                            const resolved = resolveAutonomy(agents[job.agentId]?.autonomy);
+                            if (resolved.enabled) {
+                                const rootRunId = `root-cron-${job.id}-${systemNowMs().toString(36)}`;
+                                const issued = leaseManager.mintLease({
+                                    agentId: job.agentId, // the JOB's agent — the attenuation identity (NOT operator/system)
+                                    caps: resolved.capabilities, // attenuated to the agent's OWN resolved caps
+                                    budgetRef: `run-cron-${job.id}-${systemNowMs().toString(36)}`,
+                                    sessionKey: resolveMainSessionKey(job.agentId),
+                                    rootRunId,
+                                    // no parentLeaseId — a cron-fired run is a NEW root
+                                });
+                                capLayer.registerRoot(rootRunId, issued.leaseId);
+                                jobLogger.info({ rootRunId, agentId: job.agentId, hint: "cron-fired run minted a fresh attenuated lease" }, "Cron run lease minted");
+                            }
+                        }
+                        catch (mintErr) {
+                            jobLogger.warn({
+                                err: mintErr,
+                                agentId: job.agentId,
+                                hint: "cron-fire lease mint failed; the job still runs but is not bound by the per-root ceiling/budget this run (degraded to pre-213 unbounded-cron behavior)",
+                                errorKind: "internal",
+                            }, "Cron-fire lease mint failed (degrading to unbounded cron run)");
+                        }
+                    }
                     container.eventBus.emit("scheduler:job_result", {
                         jobId: job.id,
                         jobName: job.name,
@@ -174,8 +286,10 @@ export async function setupSchedulers(deps) {
         cronSchedulers.set(agentId, scheduler);
         schedulerLogger.debug({ agentId }, "Per-agent CronScheduler started");
         // -- Memory review cron job --
+        // Gated by the master cost-feature kill switch (memory.costFeatures.enabled) AND the
+        // per-agent opt-in. Switch off ⇒ NOT registered even if the agent enabled it.
         const memoryReviewConfig = agentConfig.memoryReview;
-        if (memoryReviewConfig?.enabled) {
+        if (costFeaturesEnabled && memoryReviewConfig?.enabled) {
             const memReviewJobId = `memory-review-${agentId}`;
             const existingJobs = scheduler.getJobs();
             const alreadyRegistered = existingJobs.some((j) => j.id === memReviewJobId);
@@ -197,7 +311,139 @@ export async function setupSchedulers(deps) {
                 schedulerLogger.info({ agentId, schedule: memoryReviewConfig.schedule ?? "0 2 * * *" }, "Registered memory review cron job");
             }
         }
+        // -- (Phase 225 FOLD §3.2) The standalone __MEMORY_CONSOLIDATION__ / __MEMORY_REASONING__ /
+        //    __USER_REPRESENTATION__ cron registrations were REMOVED here: their work folds into the
+        //    ONE __REFLECT__ cron (which now reflects skill + profile + topic in one pass, Plan 04). The
+        //    I1 model — the old crons are GONE, not run in parallel. (Their now-dead job BODIES are
+        //    deleted in Plan 05; this plan removes the registrations + the sentinel intercepts so they
+        //    never fire.) __SOCIAL_MODELING__ was DELETED in Phase 226-04 (the block below).
+        // (The social-modeling cron — __SOCIAL_MODELING__, gated by socialModeling.enabled +
+        // a recorded privacyReviewSignedOffBy — was DELETED in Phase 226 SIMPLIFY-03 with the
+        // ENTIRE social-modeling subsystem (the runRelationshipBuild offline directional-edge
+        // builder, the createRelationshipSeam cheap-model seam, the RelationshipStore port +
+        // sqlite adapter, the `relationship` table, the relationship-block prompt injection).
+        // The per-agent socialModeling config key is gone — a config carrying it is now rejected
+        // at parse (the D-01a operator-update path). Deleting it removes a prompt-injected
+        // relationship-model attack surface; no dormant seam left behind (full delete, I1).
+        // After this, the learning crons are exactly 3: __REFLECT__ + __MEMORY_LIFECYCLE__ +
+        // the event-driven OutcomeSignalPort.resolve path (__MEMORY_REVIEW__ stays accumulate-tier).)
+        // (The usefulness-judge cron — __USEFULNESS_JUDGE__, gated by memoryUsefulnessJudge.enabled
+        // — was DELETED in Phase 226 SIMPLIFY-03 (D-03). It was a dormant cost-gated cheap-model
+        // seam that fed recordUsage; the FORGET-02 reward write lives in setup-learning.ts and is
+        // unaffected. The per-agent memoryUsefulnessJudge config key is gone — a config carrying it
+        // is now rejected at parse, the D-01a operator-update path.)
+        // (The online-tuning bandit cron — __ONLINE_TUNING__, gated by memoryOnlineTuning.enabled
+        // — was DELETED in Phase 224. The UCB recall bandit is gone; recall scoring is the fixed
+        // config.rag.scoring alphas, with no offline tuned-alpha write job.)
+        // -- Memory lifecycle cron job --
+        // OPT-IN, OFF by default. A DETERMINISTIC + KEYLESS (no LLM call, no API key — the sentinel
+        // dispatch makes NO model resolution) sweep, so enabling it is a behavior opt-in, not a cost opt-in.
+        // Registered ONLY when the operator sets memoryLifecycle.enabled; a default agent
+        // registers NO job → byte-identical with the config absent. Default schedule 0 9 * * *
+        // runs AFTER online-tuning's 0 8 so the FEED + tuned alphas it reads have settled. Job
+        // options mirror the online-tuning job 1:1 (isolated / next-heartbeat / no forward-to-main
+        // / fresh). The __MEMORY_LIFECYCLE__ sentinel (setup-channels-memory-crons → the DORMANT
+        // runLifecycleSweep) re-checks the knob; even when on, the SCAFFOLD evicts/demotes NOTHING
+        // (the live policy is the deferred operator step — OD4).
+        const memoryLifecycleConfig = agentConfig.memoryLifecycle;
+        if (memoryLifecycleConfig?.enabled) {
+            const memLifecycleJobId = `memory-lifecycle-${agentId}`;
+            const existingJobs = scheduler.getJobs();
+            const alreadyRegistered = existingJobs.some((j) => j.id === memLifecycleJobId);
+            if (!alreadyRegistered) {
+                await scheduler.addJob({
+                    id: memLifecycleJobId,
+                    name: "Memory lifecycle",
+                    agentId,
+                    schedule: { kind: "cron", expr: memoryLifecycleConfig.schedule ?? "0 9 * * *" },
+                    payload: { kind: "system_event", text: "__MEMORY_LIFECYCLE__" },
+                    sessionTarget: "isolated",
+                    wakeMode: "next-heartbeat",
+                    forwardToMain: false,
+                    sessionStrategy: "fresh",
+                    consecutiveErrors: 0,
+                    enabled: true,
+                    createdAtMs: systemNowMs(),
+                });
+                schedulerLogger.info({ agentId, schedule: memoryLifecycleConfig.schedule ?? "0 9 * * *" }, "Registered memory lifecycle cron job");
+            }
+        }
+        // (The memory triple-extraction cron — __MEMORY_TRIPLE_EXTRACTION__, gated by
+        // memoryTripleExtraction.enabled — was DELETED in Phase 226 SIMPLIFY-03 (D-03). It scheduled
+        // a no-op scaffold whose `extract` returned [] (no triples were ever written). The per-agent
+        // memoryTripleExtraction config key is gone — a config carrying it is now rejected at parse,
+        // the D-01a operator-update path. The TripleStorePort + its sqlite adapter + the graphSpread
+        // recall lane SURVIVE — only the dormant extraction JOB went, not the read lane.)
+        // -- Reflection cron job (v2.31 Reflection, Phase 223, REFLECT-01) --
+        // The reflect-engine replacement for the dead procedural-synthesis clustering cron.
+        // OPT-IN, DEFAULT OFF (the byte-identity guarantee depends on it). Registered ONLY when the
+        // operator sets learning.enabled AND the master cost kill switch is on; a default agent
+        // registers NO job → byte-identical with the config absent. The schedule comes from
+        // learning.reflect.schedule (Phase 226 — was a hardcoded 30 9; default every 3h `0 */3 * * *`). Job
+        // options mirror the other memory crons 1:1 (isolated / next-heartbeat / no forward-to-main /
+        // fresh). The __REFLECT__ sentinel (setup-channels-memory-crons-wire.ts) re-checks the knob +
+        // injects the @comis/memory mental-model store + the trusted-origin source into runReflection,
+        // then emits the reflect:* counts (reflect:admitted + reflect:funnel — renamed from the old
+        // learning:skill_* funnel in Phase 226). A reflected candidate is admitted at state:candidate.
+        const learningCfg = agentConfig.learning;
+        if (costFeaturesEnabled && learningCfg?.enabled) {
+            const reflectJobId = `reflect-${agentId}`;
+            const reflectSchedule = learningCfg.reflect?.schedule ?? "0 3 * * *";
+            if (!scheduler.getJobs().some((j) => j.id === reflectJobId)) {
+                await scheduler.addJob({
+                    id: reflectJobId,
+                    name: "Reflection",
+                    agentId,
+                    schedule: { kind: "cron", expr: reflectSchedule },
+                    payload: { kind: "system_event", text: "__REFLECT__" },
+                    sessionTarget: "isolated",
+                    wakeMode: "next-heartbeat",
+                    forwardToMain: false,
+                    sessionStrategy: "fresh",
+                    consecutiveErrors: 0,
+                    enabled: true,
+                    createdAtMs: systemNowMs(),
+                });
+                schedulerLogger.info({ agentId, schedule: reflectSchedule }, "Registered reflection cron job");
+            }
+        }
     }
+    // First-run cost-disclosure notice (opt-out posture). Once per startup, right after the
+    // cron-registration sweep: when the kill switch is ON (the default) AND at least one LLM
+    // cost-bearing memory feature is active for some agent, emit ONE prominent WARN naming the
+    // active features + the one-line off-switch. Today's default bare config emits nothing. Lives
+    // here (not daemon.ts, which is at its 3000-line cap) — the natural cron-wiring seam, with the
+    // agents map + config + logger already in scope.
+    emitMemoryCostFeatureNotice({ agents, costFeaturesEnabled, logger: schedulerLogger });
+    // OBS-2/6b (hindsight-reflection-20260626): fold each completed __REFLECT__ run onto the firing
+    // agent's cron run history, so `cron.runs jobName "Reflection"` answers "why did the last reflection
+    // admit / not-admit" in one call (the funnel verdict + counts) AND the run is pollable — instead of
+    // a daemon.log grep for "Reflection complete". The reflect sentinel is fire-and-forget (system_event),
+    // so we record off the content-free `reflect:funnel` event (recordReflectFunnelRun). One subscriber
+    // for all agents (it resolves the agent's tracker per event); the record is non-fatal/best-effort.
+    container.eventBus.on("reflect:funnel", (funnel) => {
+        void recordReflectFunnelRun(executionTrackers.get(funnel.agentId), funnel, systemNowMs());
+    });
+    // OBS-2b (reflect-obs-20260627): the parity recorder for the forget sweep — fold each completed
+    // __MEMORY_LIFECYCLE__ run onto the firing agent's cron run history, so `cron.runs jobName "Memory
+    // lifecycle"` answers "what did the sweep evict/demote" in one call (was a db.mjs evicted_at poll).
+    // Recorded off the content-free `learning:lifecycle_swept` event (the sentinel is fire-and-forget).
+    container.eventBus.on("learning:lifecycle_swept", (swept) => {
+        void recordLifecycleRun(executionTrackers.get(swept.agentId), swept, systemNowMs());
+    });
+    // OUTCOME-09 boot posture: `learningOutcome` (Verified Learning WS1) is NOT a cron — it is the
+    // bus-wired observe/resolve subscriber stood up in setup-memory.ts (wireLearningOutcome). It is
+    // force-disabled by the SAME master cost switch as the six cost crons above: the effective enable
+    // is `costFeaturesEnabled && agents[id].learningOutcome.enabled` (default OFF → byte-identical).
+    // Surface the effective gate state once at boot so an operator can confirm the shadow signal's
+    // posture without a live repro (the gate itself is applied at the wiring site, not here).
+    const learningOutcomeEnabled = (agentId) => costFeaturesEnabled && agents[agentId]?.learningOutcome?.enabled === true;
+    const learningOutcomeAgents = Object.keys(agents).filter((id) => learningOutcomeEnabled(id));
+    schedulerLogger.debug({
+        costFeaturesEnabled,
+        enabledAgentCount: learningOutcomeAgents.length,
+        enabledAgents: learningOutcomeAgents,
+    }, "Outcome-signal (learningOutcome) boot posture");
     /** Resolve the CronScheduler for a given agent ID. Throws descriptive error if not found. */
     function getAgentCronScheduler(agentId) {
         const scheduler = cronSchedulers.get(agentId);
@@ -253,7 +499,7 @@ export async function setupSchedulers(deps) {
                 return currentAgents[agentId]?.session?.resetPolicy;
             },
             computeDailyResetNextRun,
-            nowMs: undefined, // Use real clock in production
+            nowMs: clock.now.bind(clock),
             timers,
         });
         scheduler.start();
@@ -269,75 +515,3 @@ export async function setupSchedulers(deps) {
         getAgentBrowserService,
     };
 }
-// ---------------------------------------------------------------------------
-// Setup function
-// ---------------------------------------------------------------------------
-/**
- * Create per-agent task extractors and return an extraction callback
- * for the execution pipeline.
- * The extraction callback is safe to call unconditionally -- it checks
- * the feature gate internally and returns immediately if disabled.
- */
-export function setupTaskExtraction(deps) {
-    const { container, workspaceDirs, schedulerLogger } = deps;
-    const tasksConfig = container.config.scheduler.tasks;
-    const agents = container.config.agents;
-    const taskExtractors = new Map();
-    if (!tasksConfig.enabled) {
-        schedulerLogger.debug("Task extraction disabled globally");
-        return {
-            taskExtractors,
-            extractFromConversation: async () => { },
-        };
-    }
-    for (const [agentId] of Object.entries(agents)) {
-        const agentWorkspace = workspaceDirs.get(agentId);
-        if (!agentWorkspace)
-            continue;
-        const storePath = safePath(agentWorkspace, ".scheduler", "tasks.json");
-        const store = createTaskStore(storePath);
-        // Pluggable extraction function -- in production this would wrap an LLM call.
-        // For now, create a placeholder that returns empty tasks. The daemon can
-        // override this with a real LLM-based extraction when the agent executor
-        // integration is fully wired.
-        const extractFn = async () => {
-            // TODO: Wire to agent executor LLM call for real extraction
-            return { tasks: [], reasoning: "Extraction function not yet wired to LLM" };
-        };
-        const extractor = createTaskExtractor({
-            extractFn,
-            store,
-            logger: schedulerLogger.child({ agentId, component: "task-extractor" }),
-            config: {
-                enabled: tasksConfig.enabled,
-                confidenceThreshold: tasksConfig.confidenceThreshold,
-            },
-            eventBus: container.eventBus,
-        });
-        taskExtractors.set(agentId, extractor);
-        schedulerLogger.debug({ agentId }, "Task extractor created");
-    }
-    if (taskExtractors.size > 0) {
-        schedulerLogger.info({ extractorCount: taskExtractors.size }, "Task extraction enabled for agents");
-    }
-    async function extractFromConversation(conversationText, sessionKey, agentId) {
-        const extractor = taskExtractors.get(agentId);
-        if (!extractor)
-            return;
-        try {
-            const tasks = await extractor.extract(conversationText, sessionKey);
-            if (tasks.length > 0) {
-                schedulerLogger.info({ agentId, taskCount: tasks.length, sessionKey }, "Tasks extracted from conversation");
-            }
-        }
-        catch (err) {
-            schedulerLogger.warn({
-                agentId,
-                err: err instanceof Error ? err.message : String(err),
-                hint: "Task extraction failed but does not block message processing",
-                errorKind: "internal",
-            }, "Task extraction error");
-        }
-    }
-    return { taskExtractors, extractFromConversation };
-}

package/node_modules/@comis/daemon/dist/wiring/setup-secret-manager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Construct the shared-backing-map SecretManager and the daemon-owned MutableSecretManager handle.
+ *
+ * The returned `secretManager` is passed into `BootstrapOptions.secretManager` so the AppContainer
+ * holds the SAME object whose backing Map the handlers can write via `mutableHandle`. After any
+ * `mutableHandle.upsert(key, value)`, the broker and exec — which hold `container.secretManager`
+ * and call `.get()` per request — observe the new value on their next invocation with no restart.
+ *
+ * The daemon composition root holds `mutableHandle` and threads it to handler deps only.
+ * It must NEVER appear on AppContainer or any agent-accessible path.
+ *
+ * @module
+ */
+import { type MutableSecretManager, type SecretManager } from "@comis/core";
+/**
+ * Constructs the shared SecretManager + daemon-owned MutableSecretManager over ONE backing Map.
+ *
+ * Called once in `bootFoundation` BEFORE `bootstrap()`. The returned `secretManager` is injected
+ * via `BootstrapOptions.secretManager` so `AppContainer.secretManager` shares the same Map that
+ * the RPC handlers write to via `mutableHandle`.
+ */
+export declare function setupSecretManager(env: Record<string, string | undefined>): {
+    secretManager: SecretManager;
+    mutableHandle: MutableSecretManager;
+};

package/node_modules/@comis/daemon/dist/wiring/setup-secret-manager.js

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+// @allow-throw: composition-root helper — errors propagate to bootFoundation which catches + exits.
+/**
+ * Construct the shared-backing-map SecretManager and the daemon-owned MutableSecretManager handle.
+ *
+ * The returned `secretManager` is passed into `BootstrapOptions.secretManager` so the AppContainer
+ * holds the SAME object whose backing Map the handlers can write via `mutableHandle`. After any
+ * `mutableHandle.upsert(key, value)`, the broker and exec — which hold `container.secretManager`
+ * and call `.get()` per request — observe the new value on their next invocation with no restart.
+ *
+ * The daemon composition root holds `mutableHandle` and threads it to handler deps only.
+ * It must NEVER appear on AppContainer or any agent-accessible path.
+ *
+ * @module
+ */
+import { createSecretManagerWithMutableHandle, } from "@comis/core";
+/**
+ * Constructs the shared SecretManager + daemon-owned MutableSecretManager over ONE backing Map.
+ *
+ * Called once in `bootFoundation` BEFORE `bootstrap()`. The returned `secretManager` is injected
+ * via `BootstrapOptions.secretManager` so `AppContainer.secretManager` shares the same Map that
+ * the RPC handlers write to via `mutableHandle`.
+ */
+export function setupSecretManager(env) {
+    return createSecretManagerWithMutableHandle(env);
+}

package/node_modules/@comis/daemon/dist/wiring/setup-shutdown.d.ts

@@ -1,7 +1,11 @@
 /**
- * Shutdown setup: graceful shutdown with ordered teardown sequence.
- * Extracted from daemon.ts step 8 to isolate shutdown registration and
- * signal handlers from the main wiring sequence.
+ * Shutdown setup: sole owner of the daemon teardown chain. Owns SIGTERM/
+ * SIGINT/SIGUSR2 handler registration, the `shuttingDown` re-entrancy
+ * guard, the 30s hard timeout, the per-step 5s timeout (`STEP_TIMEOUT_MS`),
+ * logger.flush, exit-code dispatch, the `process.on("exit", ...)` safety
+ * net, and the ordered teardown of all 30+ subsystems. Inlines the
+ * `process/graceful-shutdown.ts` body into this file so the entire chain
+ * is legible in one place.
  * @module
  */
 import type { AppContainer, ApprovalGate, SecretStorePort } from "@comis/core";
@@ -10,13 +14,24 @@ import type { GatewayServerHandle } from "@comis/gateway";
 import type { HeartbeatRunner, CronScheduler, WakeCoalescer, PerAgentHeartbeatRunner } from "@comis/scheduler";
 import type { BrowserService, MediaTempManager } from "@comis/skills";
 import type { SessionResetScheduler } from "@comis/agent";
+export { STEP_TIMEOUT_MS } from "./shutdown-step-timeout.js";
 import type { ProcessMonitor } from "../process/process-monitor.js";
-import { registerGracefulShutdown, type ShutdownHandle } from "../process/graceful-shutdown.js";
 import type { RestartContinuationTracker } from "./restart-continuation.js";
 import type { TokenTracker } from "../observability/token-tracker.js";
 import type { DiagnosticCollector } from "../observability/diagnostic-collector.js";
 import type { ChannelActivityTracker } from "../observability/channel-activity-tracker.js";
 import type { DeliveryTracer } from "../observability/delivery-tracer.js";
+/**
+ * Handle for the daemon shutdown orchestrator. `isShuttingDown` exposes
+ * the closure-scoped re-entrancy flag. `trigger(signal)` runs the shutdown
+ * body programmatically (used by integration tests). `dispose()`
+ * removes the SIGTERM/SIGINT listeners (test cleanup).
+ */
+export interface ShutdownHandle {
+    readonly isShuttingDown: boolean;
+    trigger(signal: string): Promise<void>;
+    dispose(): void;
+}
 /** Dependencies for shutdown setup. */
 export interface ShutdownDeps {
     /** Root logger for shutdown progress messages. */
@@ -29,8 +44,8 @@ export interface ShutdownDeps {
     container: AppContainer;
     /** Override process.exit for testability. */
     exitFn: (code: number) => void;
-    /** Factory function for graceful shutdown (from DaemonOverrides pattern). */
-    _registerGracefulShutdown: typeof registerGracefulShutdown;
+    /** Hard-timeout (ms) before shutdown force-exits with code 1. Default 30_000; must be < systemd TimeoutStopSec. */
+    timeoutMs?: number;
     /** In-flight gateway executions for shutdown observability. */
     activeExecutions?: Map<string, {
         agentId: string;
@@ -83,6 +98,7 @@ export interface ShutdownDeps {
     };
     /** Coordinated embedding dispose callback: L1 -> L2 flush -> provider dispose */
     disposeEmbedding?: () => Promise<void>;
+    disposeReranker?: () => Promise<void>;
     /** Per-agent skill watcher handles for shutdown cleanup. */
     skillWatcherHandles?: Map<string, {
         close: () => Promise<void>;
@@ -99,35 +115,73 @@ export interface ShutdownDeps {
     injectionRateLimiter?: {
         destroy: () => void;
     };
+    /** WR-01 (Phase 199): tear down the reaction/session trajectory maps + dedicated reaction rate limiter (optional). */ destroyReactionWiring?: () => void;
     /** Periodic lock cleanup timer (from setupAgents). */
     lockCleanupTimer?: import("@comis/core").TimerHandle;
     /** Data directory for restart continuation file (optional). */
     dataDir?: string;
+    /**
+     * Boot-resolved data dir (COMIS_DATA_DIR ?? ~/.comis) where the D14 lock
+     * was acquired — `dataDir` above is config-resolved and diverges whenever
+     * COMIS_DATA_DIR is set; releasing there leaks the real lock. Falls back
+     * to `dataDir` when unset.
+     */
+    lockDataDir?: string;
     /** Restart continuation tracker for capturing active sessions before shutdown (optional). */
     continuationTracker?: RestartContinuationTracker;
     /** Lifecycle reactors for cleanup on shutdown */
     lifecycleReactors?: Array<{
         destroy: () => void;
     }>;
-    /** Observability persistence write buffers for shutdown drain */
-    obsPersistence?: {
+    /** Observability persistence write buffers for shutdown drain */ obsPersistence?: {
         drainAll(): void;
         snapshotTimer: ReturnType<typeof setInterval>;
     };
+    disposeActivityStream?: () => void;
+    otelShutdown?: () => Promise<void>;
     /** Context pipeline collector for shutdown cleanup */
     contextPipelineCollector?: {
         dispose(): void;
     };
     /** Gemini CachedContent lifecycle manager for shutdown disposal. */
     geminiCacheManager?: import("@comis/agent").GeminiCacheManager;
+    /**
+     * Session-scoped trajectory recorder registry. Shutdown drains every
+     * open per-session recorder via `closeAll()` — flushes the JSONL tail
+     * and writes the `trace.truncated` sentinel for any dropped events.
+     * Constructed in setupAgents and surfaced on AgentsResult.
+     */
+    trajectoryRegistry?: import("@comis/observability").SessionTrajectoryHandleRegistry;
+    /** Drain per-agent background-process registries (from setupTools). */
+    shutdownBackgroundProcesses?: () => Promise<void>;
+    /** Disconnect MCP clients. */
+    mcpClientManagerDisconnectAll?: () => Promise<void>;
+    /** Drain background completion runner. */
+    bgCompletionRunnerShutdown?: () => Promise<void>;
+    /** Drain the terminal wake-FSM — unsubscribe from the bus + await in-flight woken turns (124-09). */
+    terminalWakeShutdown?: () => Promise<void>;
+    /** Cleanup proxy typing controllers + sweep timer (from registerProxyTypingListeners). */
+    proxyTypingCleanup?: () => void;
+    /** Stop the delivery queue (from setupDeliveryQueue). */
+    shutdownDeliveryQueue?: () => void;
+    /** Stop the background video poller — sweeper interval + in-flight loops (189). */
+    shutdownVideoPoller?: () => void;
+    durableResumeShutdown?: () => void;
+    /** Stop the delivery mirror (from setupDeliveryMirror). */
+    shutdownDeliveryMirror?: () => void;
+    /** Stop the output retention housekeeper (from setupOutputRetention). */ outputRetentionShutdown?: () => void;
+    /** Stop the channel health monitor (from setupChannelHealthMonitor). */
+    stopChannelHealthMonitor?: () => void;
+    /** Unsubscribe health budget aggregator. */ unsubscribeHealthAggregator?: () => void;
+    /** Stop the credential broker (TCP + unix socket teardown). Only present when executor.broker is configured. */
+    brokerStop?: () => Promise<void>;
+    capEndpointStop?: () => Promise<void>;
 }
 /** All services produced by the shutdown setup phase. */
 export interface ShutdownResult {
     /** Graceful shutdown orchestrator. */
     shutdownHandle: ShutdownHandle;
 }
-/** Per-step timeout budget (5s). The outer 30s hard timeout in graceful-shutdown.ts remains unchanged. */
-export declare const STEP_TIMEOUT_MS = 5000;
 /**
  * Register graceful shutdown with ordered teardown sequence, SIGUSR2 restart
  * handler, and unhandledRejection safety net.