@aitne/daemon 0.1.10 → 0.1.11

package/dist/core/drift-effects.js

@@ -224,7 +224,7 @@ function recordCoalescedObservation(db, params) {
         // novelty_score populated. Without this, coalesced inserts only get
         // summarized via the daemon-startup reclaim sweep — a row that lands
         // mid-run sits at `summary_status='pending'` forever and the
-        // hourly_check skill is forced into the legacy fetch-on-doubt path.
+        // activity_scan skill is forced into the legacy fetch-on-doubt path.
         if (inserted)
             notifyObservationSummarizer(inserted.id);
         return 1;
@@ -257,7 +257,7 @@ function recordCoalescedObservation(db, params) {
     // summary describes obsolete content. Reset the summarizer-owned columns
     // to mirror `recordObservation`'s UPSERT on payload change — without
     // this, `summary_text` / `novelty_score` linger from the prior payload
-    // and the hourly_check skill consumes a stale summary as if it were
+    // and the activity_scan skill consumes a stale summary as if it were
     // current (`summary_status='done'` with `summaryStale=false`).
     db.prepare(`UPDATE observations
      SET change_type = ?,

package/dist/core/feedback/consolidation-prep.js

@@ -99,10 +99,14 @@ function round2(value) {
 function storeFileAttr(scope) {
     return scopeStoreFile(scope) ?? "";
 }
-/** Collapse a one-line excerpt of a signal/lesson for an XML text node. */
+/** Collapse a one-line excerpt of a signal/lesson for an XML text node.
+ *  The clip strips a trailing lone high surrogate so cutting through an
+ *  astral char (emoji) can't leave a U+FFFD in the worksheet. */
 function inline(text, max = 300) {
     const flat = text.replace(/\s+/g, " ").trim();
-    const clipped = flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+    const clipped = flat.length > max
+        ? `${flat.slice(0, max - 1).replace(/[\uD800-\uDBFF]$/, "")}…`
+        : flat;
     return xmlEscape(clipped);
 }
 /** Authority ranking for picking a candidate's representative `src=` trailer. */
@@ -154,12 +158,20 @@ function renderLessonsScope(input, opts, out) {
         ? extractMarkdownSection(input.existingFileMd, "Lessons")
         : null;
     const existing = sectionBody ? parseLessonsSection(sectionBody) : [];
-    const currentBytes = input.existingFileMd
-        ? Buffer.byteLength(input.existingFileMd, "utf-8")
+    // `current_bytes` measures the on-disk `## Lessons` SECTION body — the
+    // §6 cap unit (`lessonsSectionByteLength` in lesson-format.ts), the same
+    // unit `enforceCaps` below derives `over_cap` from. Measuring the whole
+    // file here while `over_cap` measured the section produced a
+    // self-contradictory tag (and disagreed with the §6 unit the eviction
+    // engine actually controls).
+    const currentBytes = sectionBody
+        ? Buffer.byteLength(sectionBody, "utf-8")
         : 0;
     // Eviction ranking: ascending score → rank 1 = evict-first. The plan
     // (post-dedupe) tells the LLM whether the store is already over cap.
-    const plan = enforceCaps(existing, { maxBytes: input.caps.capBytes, maxEntries: input.caps.maxEntries }, opts.nowIso, { scopeLabel: label });
+    // Pass the same half-life the displayed `ranked` scores use so the plan
+    // and the ranking can never derive from two different scorings.
+    const plan = enforceCaps(existing, { maxBytes: input.caps.capBytes, maxEntries: input.caps.maxEntries }, opts.nowIso, { scopeLabel: label }, undefined, halfLife);
     const ranked = [...existing].sort((a, b) => scoreLesson(a, opts.nowIso, undefined, halfLife) -
         scoreLesson(b, opts.nowIso, undefined, halfLife));
     out.push(`  <scope label="${xmlEscape(label)}" store="${xmlEscape(storeFile)}" ` +

package/dist/core/feedback/eviction-scorer.js

@@ -103,9 +103,13 @@ export function enforceCaps(lessons, cap, nowIso, opts, weights = DEFAULT_EVICTI
         scoreLesson(a, nowIso, weights, halfLifeDays));
     const evicted = [];
     let keep = sorted;
-    // Entry cap first — cheap, and shrinks the byte-cap work.
+    // Entry cap first — cheap, and shrinks the byte-cap work. Reverse the
+    // overflow slice (it comes off the descending-sorted array) so `evicted`
+    // honours its documented lowest-scored-first order; the byte-cap loop
+    // below already pushes lowest-first, so the combined array stays
+    // ascending by score.
     if (keep.length > cap.maxEntries) {
-        evicted.push(...keep.slice(cap.maxEntries));
+        evicted.push(...keep.slice(cap.maxEntries).reverse());
         keep = keep.slice(0, cap.maxEntries);
     }
     const sectionOpts = {

package/dist/core/feedback/lesson-format.js

@@ -152,13 +152,18 @@ export function parseLessonsSection(sectionBody) {
             flush();
             continue;
         }
-        if (current && (line.startsWith("  ") || line.trim().length > 0)) {
-            // Continuation of the current lesson (indented, or a trailer comment
-            // the author placed on its own non-indented line).
+        if (current &&
+            (line.startsWith("  ") || line.trim().startsWith("<!--"))) {
+            // Continuation of the current lesson: indented prose, or a trailer
+            // comment the author placed on its own non-indented line.
             current.buffer.push(line.trim());
         }
         else if (current) {
-            // Blank line ends the current lesson.
+            // Blank line or non-indented stray prose ends the current lesson.
+            // The stray line itself is ignored (module contract: non-lesson
+            // lines are ignored) — folding it into the preceding lesson would
+            // absorb a hand-written note into an injectable directive and
+            // re-serialize it permanently on the next consolidation.
             flush();
         }
     }

package/dist/core/feedback/lesson-injection.d.ts

@@ -37,7 +37,7 @@
  */
 /**
  * Hard inject-time byte cap for the slim hourly notify-discipline variant (§6
- * table: "slim notify-discipline subset injected to hourly_check · hard 2048 at
+ * table: "slim notify-discipline subset injected to activity_scan · hard 2048 at
  * inject"). Exported so the builder and tests share one constant.
  */
 export declare const AGENT_LESSONS_SLIM_CAP_BYTES = 2048;

package/dist/core/feedback/lesson-injection.js

@@ -39,7 +39,7 @@ import { extractMarkdownSection, parseLessonsSection, } from "./lesson-format.js
 import { scoreLesson } from "./eviction-scorer.js";
 /**
  * Hard inject-time byte cap for the slim hourly notify-discipline variant (§6
- * table: "slim notify-discipline subset injected to hourly_check · hard 2048 at
+ * table: "slim notify-discipline subset injected to activity_scan · hard 2048 at
  * inject"). Exported so the builder and tests share one constant.
  */
 export const AGENT_LESSONS_SLIM_CAP_BYTES = 2048;
@@ -69,9 +69,24 @@ function activeLessons(fileMd) {
         return [];
     return parseLessonsSection(section).filter((lesson) => !lesson.provisional && lesson.text.length > 0);
 }
+/**
+ * Neutralise XML-tag breakout in lesson prose. Lesson text is
+ * LLM-synthesized during consolidation from signals that can carry
+ * untrusted excerpts, and the rendered block is framed to the model as
+ * standing directives — a body containing `</agent_lessons>` must not be
+ * able to close the wrapper and forge a sibling high-trust block. Same
+ * escape set the worksheet builders' `xmlEscape` applies to the same text
+ * on the consolidation side (`consolidation-prep.ts`).
+ */
+function escapeLessonText(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
 /** One lesson as an agent-facing bullet (trailer + date stripped). */
 function bulletFor(lesson) {
-    return `- ${lesson.text}`;
+    return `- ${escapeLessonText(lesson.text)}`;
 }
 function wrap(style, bullets) {
     return [style.openTag, style.preamble, ...bullets, "</agent_lessons>"].join("\n");

package/dist/core/feedback/lesson-store-overview.d.ts

@@ -13,7 +13,7 @@
  * (here, 100% covered), while the route owns only the FS read + JSON assembly.
  */
 export interface LessonStoreSummary {
-    /** UTF-8 byte size of the whole file (the cap unit, §6). */
+    /** UTF-8 byte size of the on-disk `## Lessons` section (the cap unit, §6). */
     bytes: number;
     /** Per-scope byte cap. */
     capBytes: number;
@@ -32,9 +32,13 @@ export interface LessonStoreSummary {
  * Summarise one lesson store from its raw file contents. A file with no
  * `## Lessons` section (or an empty one) reports zero entries — never throws,
  * so a hand-edited or partially-written file degrades to "empty store" rather
- * than breaking the overview. `bytes` is measured against the *whole* file
- * because that is what the consolidation cap and the eviction scorer both
- * guard, matching what lands on disk.
+ * than breaking the overview. `bytes` measures the on-disk `## Lessons`
+ * section body — the §6 cap unit (`lessonsSectionByteLength` in
+ * lesson-format.ts) the eviction scorer and the nightly worksheet's
+ * `over_cap` enforce. Measuring the whole file here previously reported a
+ * permanently-stuck `overCap: true` in the band where the section fit the
+ * cap but frontmatter + heading overhead pushed the file past it — a state
+ * no enforcement actor would ever clear.
  */
 export declare function summarizeLessonStore(fileMd: string, caps: {
     capBytes: number;

package/dist/core/feedback/lesson-store-overview.js

@@ -17,15 +17,19 @@ import { extractMarkdownSection, parseLessonsSection, } from "./lesson-format.js
  * Summarise one lesson store from its raw file contents. A file with no
  * `## Lessons` section (or an empty one) reports zero entries — never throws,
  * so a hand-edited or partially-written file degrades to "empty store" rather
- * than breaking the overview. `bytes` is measured against the *whole* file
- * because that is what the consolidation cap and the eviction scorer both
- * guard, matching what lands on disk.
+ * than breaking the overview. `bytes` measures the on-disk `## Lessons`
+ * section body — the §6 cap unit (`lessonsSectionByteLength` in
+ * lesson-format.ts) the eviction scorer and the nightly worksheet's
+ * `over_cap` enforce. Measuring the whole file here previously reported a
+ * permanently-stuck `overCap: true` in the band where the section fit the
+ * cap but frontmatter + heading overhead pushed the file past it — a state
+ * no enforcement actor would ever clear.
  */
 export function summarizeLessonStore(fileMd, caps) {
     const sectionBody = extractMarkdownSection(fileMd, "Lessons");
     const lessons = sectionBody ? parseLessonsSection(sectionBody) : [];
     const provisional = lessons.filter((lesson) => lesson.provisional).length;
-    const bytes = Buffer.byteLength(fileMd, "utf-8");
+    const bytes = sectionBody ? Buffer.byteLength(sectionBody, "utf-8") : 0;
     return {
         bytes,
         capBytes: caps.capBytes,

package/dist/core/feedback/regeneralization-prep.js

@@ -54,25 +54,32 @@ function xmlEscape(value) {
 function round2(value) {
     return (Math.round(value * 100) / 100).toFixed(2);
 }
-/** Collapse a one-line excerpt of a lesson for an XML text node. */
+/** Collapse a one-line excerpt of a lesson for an XML text node.
+ *  The clip strips a trailing lone high surrogate so cutting through an
+ *  astral char (emoji) can't leave a U+FFFD in the worksheet. */
 function inline(text, max = 300) {
     const flat = text.replace(/\s+/g, " ").trim();
-    const clipped = flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+    const clipped = flat.length > max
+        ? `${flat.slice(0, max - 1).replace(/[\uD800-\uDBFF]$/, "")}…`
+        : flat;
     return xmlEscape(clipped);
 }
-function parseScopeLessons(existingFileMd) {
-    const sectionBody = extractMarkdownSection(existingFileMd, "Lessons");
-    return sectionBody ? parseLessonsSection(sectionBody) : [];
-}
-function renderScope(input, activeLessons, totalEntries, opts, out) {
+function renderScope(input, sectionBody, activeLessons, totalEntries, opts, out) {
     const label = formatScope(input.scope);
     const section = scopeSectionSlug(input.scope);
     const halfLife = opts.recencyHalfLifeDays ?? DEFAULT_RECENCY_HALFLIFE_DAYS;
-    const currentBytes = Buffer.byteLength(input.existingFileMd, "utf-8");
-    // `current_bytes` / `current_entries` describe the WHOLE on-disk file
-    // (active + provisional), because that is exactly what the byte/entry caps
-    // guard (§6). `over_cap` therefore reflects the real file state, not the
-    // collapsible subset — the LLM's Step-12 eviction targets the disk cap.
+    // `current_bytes` / `current_entries` describe the on-disk `## Lessons`
+    // SECTION (active + provisional) — the §6 cap unit
+    // (`lessonsSectionByteLength` in lesson-format.ts), the same unit the
+    // nightly worksheet's `over_cap` and the eviction engine measure. The
+    // whole-file measure used previously disagreed with the nightly pass in a
+    // narrow band (frontmatter + `# heading` overhead), making the two
+    // worksheets contradict each other on the same store. `over_cap` covers
+    // the full entry set, not just the collapsible active subset — the LLM's
+    // Step-12 eviction targets the disk cap. The caller extracted
+    // `sectionBody` once during eligibility (a scope is only eligible when
+    // its `## Lessons` section parsed), so it is measured here verbatim.
+    const currentBytes = Buffer.byteLength(sectionBody, "utf-8");
     const overCap = currentBytes > input.caps.capBytes || totalEntries > input.caps.maxEntries;
     const provisionalHeld = totalEntries - activeLessons.length;
     // Ascending score → rank 1 = lowest score = drop-first, the same convention
@@ -111,13 +118,19 @@ function renderScope(input, activeLessons, totalEntries, opts, out) {
 export function buildRegeneralizationWorksheet(scopes, opts) {
     const eligible = [];
     for (const input of scopes) {
-        const allLessons = parseScopeLessons(input.existingFileMd);
+        // Single extraction per scope — `renderScope` reuses this body for its
+        // `current_bytes` measure instead of re-extracting (the old double
+        // extraction left renderScope with an unreachable missing-section arm).
+        const sectionBody = extractMarkdownSection(input.existingFileMd, "Lessons");
+        if (!sectionBody)
+            continue;
+        const allLessons = parseLessonsSection(sectionBody);
         // Collapse the ACTIVE set only — provisional lessons are owned by the
         // evening promotion gate (see module header); merging them here would
         // bypass the `ignored`-only-never-promotes guard.
         const active = allLessons.filter((lesson) => !lesson.provisional);
         if (active.length >= MIN_LESSONS_FOR_REGENERALIZATION) {
-            eligible.push({ input, active, totalEntries: allLessons.length });
+            eligible.push({ input, sectionBody, active, totalEntries: allLessons.length });
         }
     }
     if (eligible.length === 0)
@@ -126,8 +139,8 @@ export function buildRegeneralizationWorksheet(scopes, opts) {
     out.push(`<feedback_regeneralization generated_at="${xmlEscape(opts.nowIso)}" ` +
         `scopes="${eligible.length}">`);
     let lessonCount = 0;
-    for (const { input, active, totalEntries } of eligible) {
-        renderScope(input, active, totalEntries, opts, out);
+    for (const { input, sectionBody, active, totalEntries } of eligible) {
+        renderScope(input, sectionBody, active, totalEntries, opts, out);
         lessonCount += active.length;
     }
     out.push("</feedback_regeneralization>");

package/dist/core/feedback/self-performance-prep.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Self-Tuning Review Cycle — Measure stage (SELF_TUNING_REVIEW_CYCLE_DESIGN.md
+ * §3.1, Phase 1).
+ *
+ * The daemon-side, deterministic Measure step ($0 — LLM tokens buy judgment
+ * only, P1). On the weekly-review dispatch it computes SQL aggregates over
+ * `agent_actions`, `notification_log`, and the `runtime_state` self-tuning
+ * ledger for a 7-day window plus a 7-day-prior baseline (trend column), and
+ * renders one compact `<self_performance>` block — hard-capped at
+ * {@link SELF_PERFORMANCE_MAX_BYTES} — so the weekly review's "Metrics (agent
+ * side)" section copies daemon-computed facts instead of paying Sonnet prices
+ * to re-count them.
+ *
+ * Two layers, mirroring `consolidation-prep.ts`:
+ *   - {@link gatherSelfPerformanceData} — the single DB read (side-effect
+ *     free): per-`action_type` run/cost/duration aggregates (`agent_actions`
+ *     has no process_key column; `action_type` carries the routine identity),
+ *     the `routine.fetch_window` empty-run rate per integration (from the
+ *     fan-out audit rows' `detail.prePass` payload the runner persists), the
+ *     `activity_scan.gate` stage distribution (from `buildGateAuditDetail`'s
+ *     historical per-tick rows), per-notification-type `user_reaction`
+ *     breakdowns (the first reader of the column `signal-detector.ts`
+ *     populates), and the `runtime_state.self_tuning:*` ledger.
+ *   - {@link buildSelfPerformanceBlock} — pure renderer. Deterministic
+ *     byte-capped output: per-section row budgets shrink one row at a time
+ *     (largest section first) until the block fits the cap, and clipped rows
+ *     surface as `omitted="N"` so truncation is never silent.
+ *
+ * Phase 1 carries no actuator: nothing here writes config, schedules, or
+ * lessons. Later phases (Recommend / Judge / Actuate) consume the same data
+ * shape; {@link SELF_TUNING_LEDGER_PREFIX} is exported so the Phase 3
+ * actuator writes the ledger keys this module already reads.
+ */
+import type Database from "better-sqlite3";
+/** Measurement window length; the baseline is the same span immediately prior. */
+export declare const SELF_PERFORMANCE_WINDOW_DAYS = 7;
+/** §3.1 — hard cap on the rendered `<self_performance>` block, in UTF-8 bytes. */
+export declare const SELF_PERFORMANCE_MAX_BYTES = 1500;
+/**
+ * §3.4 ledger key prefix. Phase 3's actuator writes
+ * `runtime_state.self_tuning:<key> = {prev, applied_at, baselineMetric, rule}`;
+ * Phase 1 already reads (and renders) whatever sits under the prefix so the
+ * weekly review sees applied changes the cycle they land.
+ */
+export declare const SELF_TUNING_LEDGER_PREFIX = "self_tuning:";
+/** Fan-out audit rows carry the fetcher event's type as `action_type`. */
+export declare const FETCH_WINDOW_ACTION_TYPE = "routine.fetch_window";
+/** Per-tick gate audit rows (`buildGateAuditDetail` payload in `detail`). */
+export declare const ACTIVITY_SCAN_GATE_ACTION_TYPE = "activity_scan.gate";
+export interface ActionTypeStats {
+    actionType: string;
+    runs: number;
+    success: number;
+    partial: number;
+    failed: number;
+    skipped: number;
+    costUsd: number;
+    /** Median over rows with a non-null `duration_ms`; null when none have one. */
+    p50DurationMs: number | null;
+}
+export interface FetchWindowIntegrationStats {
+    integrationKey: string;
+    /** Completed fan-out attempts (prePass status success|partial). */
+    runs: number;
+    /** Completed attempts with `fetched=0 ∧ posted=0` (§3.1 empty-run def). */
+    empty: number;
+}
+export interface HourlyGateStats {
+    /** Every audited cron tick, including rows whose detail failed to parse. */
+    ticks: number;
+    stage0: number;
+    /**
+     * Lite-triage ticks that stayed silent. The writer persists the alias
+     * `stage2_log_only` verbatim (`dispatcher-activity-scan.ts:logGateAuditRow`
+     * overrides `stage_reached` with the applied decision, and a Stage-2 tick
+     * only ever settles to log_only-silent or stage3); a bare `stage2` is
+     * accepted defensively but never occurs in production rows.
+     */
+    stage2: number;
+    /**
+     * Full-session escalations that actually ran. Rows the legacy
+     * min-observations floor short-circuited (`result='skipped'` with
+     * `stage_reached='stage3'`) are excluded — no session ran, no spend.
+     */
+    stage3: number;
+    /**
+     * …of those, ticks whose `gate_reason` was the low-signal fallback (R3).
+     * Forced ticks (`!run` / run-now, `detail.forced=true`) are excluded:
+     * they escalate at any signal level and say nothing about the gate.
+     */
+    stage3LowSignal: number;
+    /** …of those, ticks whose snapshot max novelty was ≤ 1 (null counts as ≤1). */
+    stage3LowSignalLowNovelty: number;
+}
+export interface NotificationTypeStats {
+    notificationType: string;
+    /** Rows with status delivered|batched (suppressed/failed are not "sent"). */
+    sent: number;
+    replied: number;
+    acted: number;
+    corrected: number;
+    ignored: number;
+    /** No-reaction-yet (incl. unrecognised reaction values, clamped ≥ 0). */
+    pending: number;
+}
+export interface SelfPerformanceWindow {
+    actions: ActionTypeStats[];
+    fetchWindow: FetchWindowIntegrationStats[];
+    gate: HourlyGateStats;
+    notifications: NotificationTypeStats[];
+}
+export interface SelfTuningLedgerEntry {
+    /** Knob name — the runtime_state key with the prefix stripped. */
+    key: string;
+    prev: unknown;
+    appliedAt: string | null;
+    rule: string | null;
+    /**
+     * §3.4 — the rule's target metric captured at apply time, so the weekly
+     * review can compare it against the current `<self_performance>` numbers
+     * (the "measured effect" §3.1 asks the ledger section to carry). Absent
+     * until Phase 3's actuator writes it.
+     */
+    baselineMetric?: unknown;
+    /**
+     * §3.4 — stamped by the Phase 3 auto-revert monitor. Present means the
+     * change regressed and was rolled back; the Phase 2 recommender reads it
+     * to apply the extended 28-day cool-down (vs the normal 14-day
+     * hysteresis) so the apply→revert→re-apply cycle can't flap.
+     */
+    revertedAt?: string;
+    /**
+     * §3.4 — stamped by the auto-revert monitor after a clean 7-day verify
+     * window (`pass`, `no_baseline`, …). Rendered so the weekly judge can
+     * tell a verified-clean change from one still inside its window.
+     */
+    verifyResult?: string;
+}
+export interface SelfPerformanceData {
+    windowDays: number;
+    current: SelfPerformanceWindow;
+    baseline: SelfPerformanceWindow;
+    ledger: SelfTuningLedgerEntry[];
+}
+/** §3.5 — lesson-store byte pressure, the standing cost multiplier to watch. */
+export interface LessonStoreUtilization {
+    /** Canonical scope label — `agent` or `agent:<slug>`. */
+    scope: string;
+    /** UTF-8 byte size of the `## Lessons` section body (the §6 cap unit). */
+    bytes: number;
+    capBytes: number;
+    entries: number;
+    /** Median `ev=` across all entries (R5's evidence signal); null when empty. */
+    medianEv: number | null;
+}
+/**
+ * The single DB read. Computes the current window `[now − windowDays, now)`
+ * and the baseline window `[now − 2·windowDays, now − windowDays)` over
+ * `agent_actions` / `notification_log` (both store SQLite UTC
+ * `YYYY-MM-DD HH:MM:SS` timestamps, so lexicographic comparison against
+ * `formatSqliteDatetime` cutoffs is exact), plus the self-tuning ledger.
+ */
+export declare function gatherSelfPerformanceData(db: Database.Database, opts: {
+    now: Date;
+    windowDays?: number;
+}): SelfPerformanceData;
+/**
+ * §3.5 — summarise one lesson store's byte pressure from its raw file
+ * contents. Pure (the caller does the FS read); a file with no `## Lessons`
+ * section degrades to an empty store, never a throw. `medianEv` carries the
+ * evidence signal R5's Phase 2 rule keys on (utilization > 90% with median
+ * evidence ≤ 1), so the measurement lands one phase ahead of the rule.
+ */
+export declare function summarizeLessonStoreUtilization(scope: string, fileMd: string, capBytes: number): LessonStoreUtilization;
+/**
+ * Compose the `<self_performance>` block. Returns `null` when there is no
+ * telemetry at all (fresh install) so the caller stamps nothing — no empty
+ * block in the prompt. The byte cap is a hard guarantee: row budgets shrink
+ * until the block fits; in the (synthetic) case where even the skeleton
+ * exceeds the cap, a minimal self-closing element is emitted instead.
+ */
+export declare function buildSelfPerformanceBlock(data: SelfPerformanceData, opts: {
+    generatedAt: string;
+    lessonStores?: ReadonlyArray<LessonStoreUtilization>;
+    maxBytes?: number;
+}): string | null;