@aitne/daemon 0.1.10 → 0.1.11

package/dist/core/dispatcher-scheduled-tasks.js

@@ -62,6 +62,9 @@ import { runRepositoryManagementInit, runRepositoryManagementScan, } from "./rep
 import { routineWindowKeyFromEvent } from "./routine-fetch-window-runner.js";
 import { routineHasWindows } from "./routine-windows.js";
 import { buildFeedbackWorksheet, gatherFeedbackWorksheetScopes, lessonCapsForScope, GLOBAL_LESSON_ENTRY_CAP, PER_AGENT_LESSON_ENTRY_CAP, } from "./feedback/consolidation-prep.js";
+import { buildSelfPerformanceBlock, gatherSelfPerformanceData, summarizeLessonStoreUtilization, } from "./feedback/self-performance-prep.js";
+import { TUNING_PENDING_CYCLE_STATE_KEY, buildTuningRecommendations, createPendingTuningCycle, gatherFailingRecurringSchedules, renderTuningRecommendationsBlock, } from "./feedback/tuning-recommender.js";
+import { readRuntimeState, writeRuntimeState } from "../db/runtime-state.js";
 import { buildRegeneralizationWorksheet, } from "./feedback/regeneralization-prep.js";
 import { isSafeAgentSlug, scopeStoreFile, } from "./feedback/scope-parser.js";
 import { feedbackRetentionCutoff, sweepConsumedFeedbackSignals, } from "../db/feedback-signals-store.js";
@@ -203,6 +206,33 @@ export const REFRESH_ARCHITECTURE_ALLOWED_TOOLS = [
     "Bash(curl http://localhost:8321/api/repositories/*/architecture-section*)",
     "Bash(jq *)",
 ];
+/**
+ * BACKGROUND_TASK_RUNNER_DESIGN.md §4.5 / §4.5-bis / Phase 4 — the active
+ * delivery turn is a NO-TOOL DM turn. Its sole job is to weave the
+ * already-injected artifact (`taskContext.task_delivery.report` carries the
+ * full verbatim result) into the live conversation; the agent's reply text
+ * IS the DM (recorded by the result processor) and any deliverable files
+ * are attached by the daemon, not by the agent. So the turn needs no tools
+ * at all — and an EMPTY override structurally prevents it from taking
+ * "further action" (spawning another task, writing memory, sending mail)
+ * during what should be a pure phrasing turn. Follow-up turns ("what did it
+ * find?") are ordinary DM turns and keep the full envelope, including the
+ * `GET /api/background-task/:id` read affordance.
+ */
+export const TASK_DELIVERY_TURN_ALLOWED_TOOLS = [];
+/**
+ * True when `taskCtx` is a synthetic `scheduled.dm` event minted by the
+ * task-delivery handler (`createScheduledDmDeliveryEvent`) — the only place
+ * that sets the `task_delivery` block. Used to pin the no-tool clamp above.
+ * Keying off this structural marker (not `event.source`) is fail-safe: the
+ * clamp only ever NARROWS the envelope, so a false positive degrades a turn
+ * to no-tool rather than widening anything.
+ */
+export function isTaskDeliveryTurn(taskCtx) {
+    return (!!taskCtx
+        && typeof taskCtx === "object"
+        && "task_delivery" in taskCtx);
+}
 /**
  * Backends that honor the per-execute `allowedToolsOverride` clamp end-to-
  * end. Claude consumes the list verbatim through the SDK's `dontAsk` +
@@ -214,6 +244,14 @@ export const REFRESH_ARCHITECTURE_ALLOWED_TOOLS = [
  * envelope; the operator sees an `agent_actions` row of action_type
  * `scheduled_task_clamp_unsupported` and a clear log line.
  *
+ * Exception — the Phase-4 task-delivery turn (`isTaskDeliveryTurn`)
+ * consumes this same set but DEGRADES rather than refuses: when the
+ * resolved backend can't enforce `[]` it still runs the delivery turn
+ * with the default envelope (logged), because failing to deliver the
+ * owner's result is worse than running the phrasing turn untooled. The
+ * clamp is keyed off `binding.main.backendId`, so — as with the refuse
+ * path — a runtime fallback to a non-claude backend is not re-evaluated.
+ *
  * Add a backend here only after verifying its core threads
  * `allowedToolsOverride` through to its concrete deny enforcement layer
  * — NOT just into the CLI flag set.
@@ -461,6 +499,23 @@ export class ScheduledTaskRunner {
             this.markScheduledTaskCompleted(event);
             return;
         }
+        // BACKGROUND_TASK_RUNNER_DESIGN.md §4.5 / Phase 4 — pin the no-tool
+        // clamp on the active delivery turn. Mutually exclusive with the
+        // refresh-architecture clamp (a delivery turn is never that process
+        // key). Unlike the safety-critical refresh/curation clamps, this is a
+        // HARDENING: when the resolved backend can't enforce a per-execute
+        // clamp we DEGRADE (deliver with the default envelope) rather than
+        // refuse — failing to deliver the owner's result would be the worse
+        // outcome. The degrade is logged per the "no silent drops" posture.
+        const taskDeliveryToolClamp = isTaskDeliveryTurn(taskCtx)
+            ? TOOL_CLAMP_SUPPORTING_BACKENDS.has(binding.main.backendId)
+                ? TASK_DELIVERY_TURN_ALLOWED_TOOLS
+                : undefined
+            : undefined;
+        if (isTaskDeliveryTurn(taskCtx) && taskDeliveryToolClamp === undefined) {
+            logger.info({ backendId: binding.main.backendId, correlationId: event.correlationId }, "task.delivery active turn: resolved backend does not honor the per-execute tool clamp; delivering with the default DM envelope (degraded, not refused)");
+        }
+        const effectiveAllowedToolsOverride = refreshArchitectureOverride ?? taskDeliveryToolClamp;
         // AGENT_DEFINITIONS_DESIGN.md §4.2 — fold the firing Agent's
         // `tools.skills` onto the process-key skill bundle. `undefined` for every
         // non-Agent firing (managed task, git project doc, automation trigger) and
@@ -474,8 +529,8 @@ export class ScheduledTaskRunner {
             requestedTier,
             preResolvedBinding: binding,
             reassemblePrompt,
-            ...(refreshArchitectureOverride
-                ? { allowedToolsOverride: refreshArchitectureOverride }
+            ...(effectiveAllowedToolsOverride
+                ? { allowedToolsOverride: effectiveAllowedToolsOverride }
                 : {}),
             ...(agentSkillOverride
                 ? {
@@ -808,7 +863,7 @@ export class ScheduledTaskRunner {
         //     row insert (today.md is fresh, audit row is missing);
         //   - the user manually edits today.md to the current date (CLAUDE.md
         //     calls this out as a documented edit path).
-        // In both, the hourly_check pre-routine gate (`morningRoutineRanToday`)
+        // In both, the activity_scan pre-routine gate (`morningRoutineRanToday`)
         // would keep refusing to run because the audit row is absent, the
         // pre-routine gate kept enqueuing wake rows, and each wake row was
         // fast-path completed here — never producing the audit row that would
@@ -844,6 +899,15 @@ export class ScheduledTaskRunner {
         // carries the previous attempt so executeMorningRoutine → scheduleMorningRetry
         // can increment properly. correlationId tracks back to the original
         // cron morning_routine for log correlation.
+        //
+        // `agentId` is carried over from the wake event (stamped there by
+        // `Dispatcher.beginAgentExecution` via `task_context.agent_id` /
+        // `task_context.routine`): the cron path's RoutineEvent gets the stamp
+        // directly, so dropping it here would make run-now / retry firings
+        // ignore the morning-routine Agent's overrides + lesson injection while
+        // cron firings honour them — the same manual-vs-cron divergence class
+        // AGENT_DEFINITIONS_KNOWN_LIMITATIONS §1 fixed for user Agents.
+        const wakeAgentId = event.data?.agentId;
         const synthEvent = {
             ...createEvent({
                 type: "routine.morning_routine",
@@ -855,12 +919,15 @@ export class ScheduledTaskRunner {
                 priority: retryCount > 0 ? EventPriority.NORMAL : EventPriority.HIGH,
                 correlationId: taskCtx.originalCorrelationId ?? event.correlationId,
                 data: {
+                    ...(typeof wakeAgentId === "string" && wakeAgentId.length > 0
+                        ? { agentId: wakeAgentId }
+                        : {}),
                     ...(retryCount > 0 ? { retryCount, isRetry: true } : {}),
                     ...(Array.isArray(taskCtx.postCatchupRoutines)
                         ? { postCatchupRoutines: taskCtx.postCatchupRoutines }
                         : {}),
-                    ...(taskCtx.postCatchupHourlyCheck === true
-                        ? { postCatchupHourlyCheck: true }
+                    ...(taskCtx.postCatchupActivityScan === true
+                        ? { postCatchupActivityScan: true }
                         : {}),
                     ...(typeof taskCtx.source === "string"
                         ? { queuedSource: taskCtx.source }
@@ -1068,7 +1135,7 @@ export class ScheduledTaskRunner {
         try {
             // docs/design/appendices/routine-data-acquisition.md Phase 4 / D4 — pre-pass for
             // routine events whose ProcessKey appears in `ROUTINE_WINDOWS`
-            // (today_refresh, evening_review, weekly_review). The hourly_check
+            // (today_refresh, evening_review, weekly_review). The activity_scan
             // and morning_routine dispatch paths attach their own
             // `fetchReportBlock` upstream (D2 / D3); we honour an existing
             // attachment to avoid double-spawning the fetcher. `monthly_review`
@@ -1179,6 +1246,36 @@ export class ScheduledTaskRunner {
             if (isRoutineEvent(effectiveEvent)
                 && effectiveEvent.routine === "weekly_review") {
                 this.runWeeklyInterestsReflectionPreHook(effectiveEvent);
+                // SELF_TUNING_REVIEW_CYCLE_DESIGN.md §3.1 + §3.2 / Phases 1–2 —
+                // deterministic Measure + Recommend pre-steps for
+                // `routine.weekly_review`. Run synchronously BEFORE
+                // `contextBuilder.build` so the `<self_performance>` block (7-day
+                // per-routine run/cost/duration aggregates + fetch_window empty-run
+                // rates + hourly-gate stage distribution + notification reaction
+                // breakdown + self-tuning ledger) and the `<tuning_recommendations>`
+                // block (Phase 2 rule-table output for the Phase 3c verdict step)
+                // land in the weekly session's context. Both share one gather pass;
+                // each is independently failure-isolated inside
+                // `prepareSelfTuningBlocks` — a throw is swallowed and the review
+                // still ships. Either block is omitted entirely when empty (no
+                // empty XML in the prompt).
+                const selfTuning = this.prepareSelfTuningBlocks();
+                if (selfTuning.selfPerformanceBlock || selfTuning.tuningRecommendationsBlock) {
+                    effectiveEvent = {
+                        ...effectiveEvent,
+                        data: {
+                            ...effectiveEvent.data,
+                            ...(selfTuning.selfPerformanceBlock
+                                ? { selfPerformanceBlock: selfTuning.selfPerformanceBlock }
+                                : {}),
+                            ...(selfTuning.tuningRecommendationsBlock
+                                ? {
+                                    tuningRecommendationsBlock: selfTuning.tuningRecommendationsBlock,
+                                }
+                                : {}),
+                        },
+                    };
+                }
             }
             const context = await this.contextBuilder.build(effectiveEvent);
             const processKey = resolveProcessKey(effectiveEvent);
@@ -1453,6 +1550,116 @@ export class ScheduledTaskRunner {
             return null;
         }
     }
+    /**
+     * SELF_TUNING_REVIEW_CYCLE_DESIGN.md §3.1 + §3.2 / Phases 1–2 — the
+     * deterministic Measure + Recommend pre-steps. Computes the 7-day window +
+     * 7-day-prior baseline SQL aggregates over `agent_actions` /
+     * `notification_log` / the `runtime_state.self_tuning:*` ledger, reads each
+     * lesson store's byte pressure (§3.5), and composes the
+     * `<self_performance>` block via the pure
+     * `core/feedback/self-performance-prep.ts` module. The same gathered data
+     * then feeds the Phase 2 rule table (`core/feedback/tuning-recommender.ts`):
+     * the resulting pending cycle is persisted to
+     * `runtime_state.self_tuning.pending_cycle` — overwriting (and thereby
+     * expiring, §3.4 single-use ids) the previous cycle even when this week
+     * produced zero recommendations — and rendered as the
+     * `<tuning_recommendations>` block for the Phase 3c verdict step.
+     *
+     * Either field is `null` when there is nothing to inject or its step threw —
+     * the caller simply skips stamping and the weekly review proceeds
+     * unchanged. The Recommend step is failure-isolated from the Measure step:
+     * a recommender throw never drops the `<self_performance>` block.
+     *
+     * The DB handle + lesson-file FS reads live here (the dispatcher is
+     * coverage-excluded); the byte-deterministic aggregation, rule table, and
+     * rendering live in the pure modules, which are 100% unit-tested. Unlike
+     * the consolidation/re-generalization pre-steps this is NOT gated on
+     * `feedbackLearningEnabled` — it measures core daemon telemetry, not the
+     * lesson loop; nor on `selfTuningEnabled` — that flag gates Phase 3
+     * *actuation* only, while recommendation generation + verdict recording IS
+     * the Phase 2 shadow period (§7). An unreadable lesson store only drops the
+     * `<lesson_stores>` rows / the R5 input, never the whole block.
+     */
+    prepareSelfTuningBlocks() {
+        try {
+            const now = new Date();
+            const data = gatherSelfPerformanceData(this.db, { now });
+            const lessonStores = [];
+            const contextDir = getContextDir(this.config, this.db);
+            const readStoreFile = (rel) => {
+                const full = join(contextDir, rel);
+                if (!existsSync(full))
+                    return null;
+                try {
+                    return readFileSync(full, "utf-8");
+                }
+                catch (err) {
+                    logger.warn({ err, path: rel }, "Skipping lesson store in self-performance block — file present but unreadable");
+                    return null;
+                }
+            };
+            const globalMd = readStoreFile(CONTEXT_RELATIVE_PATHS.agentLessons);
+            if (globalMd !== null) {
+                lessonStores.push(summarizeLessonStoreUtilization("agent", globalMd, this.config.feedbackLessonMaxBytesGlobal));
+            }
+            const agentsDir = join(contextDir, "policies", "agents");
+            if (existsSync(agentsDir)) {
+                for (const entry of readdirSync(agentsDir, { withFileTypes: true })) {
+                    if (!entry.isDirectory() || !isSafeAgentSlug(entry.name))
+                        continue;
+                    const md = readStoreFile(agentLessonsPath(entry.name));
+                    if (md === null)
+                        continue;
+                    lessonStores.push(summarizeLessonStoreUtilization(`agent:${entry.name}`, md, this.config.feedbackLessonMaxBytesPerAgent));
+                }
+            }
+            const selfPerformanceBlock = buildSelfPerformanceBlock(data, {
+                generatedAt: now.toISOString(),
+                lessonStores,
+            });
+            // Phase 2 Recommend step — isolated so a recommender failure cannot
+            // cost the weekly session its Measure block.
+            let tuningRecommendationsBlock = null;
+            try {
+                const recommendations = buildTuningRecommendations({
+                    data,
+                    knobs: {
+                        activityScanPrePassFreshnessMinutes: this.config.activityScanPrePassFreshnessMinutes,
+                        activityScanLowSignalPendingCeiling: this.config.activityScanLowSignalPendingCeiling,
+                        feedbackLessonMaxBytesGlobal: this.config.feedbackLessonMaxBytesGlobal,
+                    },
+                    lessonStores,
+                    failingSchedules: gatherFailingRecurringSchedules(this.db),
+                    now,
+                });
+                // Read the outgoing blob before overwriting: a SAME-day re-run
+                // (manual `!run` / crash retry) regenerates the same cycle id and
+                // ids, and verdicts already recorded against them must survive —
+                // otherwise the re-run session re-verdicts judged ids and
+                // double-posts rejection self_critique signals. A prior-day blob
+                // is ignored inside createPendingTuningCycle (§3.4 expiry).
+                const previousCycle = readRuntimeState(this.db, TUNING_PENDING_CYCLE_STATE_KEY);
+                const cycle = createPendingTuningCycle(recommendations, now.toISOString(), previousCycle);
+                // Always persist — an empty cycle still expires last week's
+                // single-use verdict ids (§3.4).
+                writeRuntimeState(this.db, TUNING_PENDING_CYCLE_STATE_KEY, cycle);
+                // Phase 3 — the block's `mode` attribute tells the weekly session
+                // whether apply verdicts actuate (`live`) or are recorded only
+                // (`shadow`), so the task-flow never has to guess the flag state.
+                tuningRecommendationsBlock = renderTuningRecommendationsBlock(cycle, {
+                    mode: this.config.selfTuningEnabled === true ? "live" : "shadow",
+                });
+            }
+            catch (err) {
+                logger.warn({ err }, "Failed to prepare tuning recommendations");
+            }
+            return { selfPerformanceBlock, tuningRecommendationsBlock };
+        }
+        catch (err) {
+            logger.warn({ err }, "Failed to prepare self-performance block");
+            return { selfPerformanceBlock: null, tuningRecommendationsBlock: null };
+        }
+    }
     /**
      * FEEDBACK_LEARNING_LOOP_DESIGN.md §4 "Monthly re-generalization" / Phase 5 —
      * the deterministic monthly pre-step. Enumerates the consolidated lesson

package/dist/core/dispatcher-task-delivery.d.ts

@@ -0,0 +1,105 @@
+import type Database from "better-sqlite3";
+import type { AgentTaskEvent, TaskDeliveryAsset, TaskDeliveryEvent } from "@aitne/shared";
+import type { AgentConfig } from "../config.js";
+import type { OutboundAttachmentRef } from "../adapters/types.js";
+import type { INotificationManager } from "./dispatcher-types.js";
+export declare const TASK_DELIVERY_GATE_KEYS: readonly ["owner_dm:owner", "dashboard_chat:dashboard"];
+export interface BrowserTaskDeliveryEventInput {
+    taskId: string;
+    originatingChannel: string | null;
+    title: string;
+}
+export declare function createBrowserTaskResultDeliveryEvent(input: BrowserTaskDeliveryEventInput & {
+    report: string;
+    screenshotKeys?: readonly string[];
+}): TaskDeliveryEvent;
+export declare function createBrowserTaskClarificationDeliveryEvent(input: BrowserTaskDeliveryEventInput & {
+    clarificationId: string;
+    question: string;
+    contextSummary: string | null;
+    screenshotKey: string | null;
+}): TaskDeliveryEvent;
+export interface BackgroundTaskResultDeliveryInput {
+    taskId: string;
+    originatingChannel: string | null;
+    title: string;
+    /** Worker-authored summary — the idle-send body / active-turn grounding. */
+    draft: string;
+    /** Verbatim result — injected into the active delivery turn so the DM
+     *  agent can weave full detail without a tool round-trip. */
+    report: string;
+    /** Worker-produced deliverable files (PDF / PPTX / PNG / docs) to attach
+     *  to the result DM. Omit / empty when the task produced no files. */
+    assets?: readonly TaskDeliveryAsset[];
+}
+export declare function createBackgroundTaskResultDeliveryEvent(input: BackgroundTaskResultDeliveryInput): TaskDeliveryEvent;
+export declare function createBackgroundTaskClarificationDeliveryEvent(input: {
+    taskId: string;
+    originatingChannel: string | null;
+    title: string;
+    clarificationId: string;
+    question: string;
+    contextSummary: string | null;
+}): TaskDeliveryEvent;
+/**
+ * BACKGROUND_TASK_RUNNER_DESIGN.md §2.3 / §13 Decision 4 (Phase 4, opt-in)
+ * — wrap a routine autonomous forward as a `task.delivery` event so it
+ * flows through the same gate + activity-branch machinery: an active owner
+ * gets a woven delivery turn, an idle owner the verbatim send + record.
+ * Carries no DB row (synthetic id, no `delivered_at` recovery — autonomous
+ * forwards are fire-and-forget, exactly as the verbatim path is today).
+ */
+export declare function createAutonomousForwardDeliveryEvent(input: {
+    content: string;
+    originatingChannel: string | null;
+    title?: string;
+    correlationId?: string | null;
+}): TaskDeliveryEvent;
+export interface TaskDeliveryHandlerDeps {
+    db: Database.Database;
+    config: AgentConfig;
+    notificationMgr: INotificationManager;
+    executeScheduledTask(event: AgentTaskEvent): Promise<void>;
+    /**
+     * Resolve a task's deliverable assets (browser-task trace screenshots
+     * and/or worker-written files: PDF / PPTX / PNG / docs) to outbound
+     * attachments for the platform the DM lands on. Used by BOTH the idle
+     * direct-send and the active delivery turn so the owner receives the
+     * actual files inline (BACKGROUND_TASK_RUNNER_DESIGN.md Phase 1 — delivery
+     * assets). Injected from bootstrap (closure over `paDataDir` + the
+     * dashboard ingest hook); absent in unit tests, where assets are simply
+     * omitted. Best-effort — must resolve to `[]` rather than throw.
+     */
+    resolveAssets?(platform: string, assets: readonly TaskDeliveryAsset[]): Promise<readonly OutboundAttachmentRef[]>;
+    nowFn?: () => number;
+}
+/** The asset key the dispatch arm puts resolved refs under on the
+ *  synthetic `scheduled.dm` event so the result processor can attach them
+ *  to the woven reply. */
+export declare const TASK_DELIVERY_ATTACHMENTS_KEY = "task_delivery_attachments";
+export declare function handleTaskDeliveryInsideGate(deps: TaskDeliveryHandlerDeps, event: TaskDeliveryEvent): Promise<void>;
+export declare function enqueueUndeliveredBrowserTaskDeliveries(params: {
+    db: Database.Database;
+    eventBus: {
+        put(event: TaskDeliveryEvent): Promise<void>;
+    };
+    nowMs?: number;
+    limit?: number;
+}): Promise<number>;
+/**
+ * BACKGROUND_TASK_RUNNER_DESIGN.md §10.2 — delivery recovery sweep for
+ * background tasks. Re-enqueues `task.delivery` events for completed
+ * notify=true artifacts whose DM was never sent/recorded
+ * (`delivered_at IS NULL`) plus undelivered open clarifications. Run on
+ * the housekeeping tick (boot + periodic). Idempotent against the
+ * in-gate message-existence dedup — a re-enqueue after a successful send
+ * only back-fills `delivered_at`, never double-sends (§4.4).
+ */
+export declare function enqueueUndeliveredBackgroundTaskDeliveries(params: {
+    db: Database.Database;
+    eventBus: {
+        put(event: TaskDeliveryEvent): Promise<void>;
+    };
+    nowMs?: number;
+    limit?: number;
+}): Promise<number>;