@aitne/daemon 0.1.9 → 0.1.11

package/dist/core/routine-acquisition-plan.js

@@ -111,7 +111,7 @@ function integrationsForWindow(symbol) {
  */
 function resolveFetchMode(integration, state, sessionBackend) {
     if (!state)
-        return null;
+        return "no_state";
     switch (state.mode) {
         case "direct":
             return "direct";
@@ -131,21 +131,31 @@ function resolveFetchMode(integration, state, sessionBackend) {
                 }
                 return "delegated-cross";
             }
-            return null;
+            return "no_binding";
         case "native":
             // Native binding must match the session backend. Otherwise the
             // partial's `mode:native:<key>` block would be filtered out by
             // `applyIntegrationModeFilter` anyway — skip the row to avoid
-            // emitting a `<fetch>` that no branch can handle.
+            // emitting a `<fetch>` that no branch can handle. With
+            // per-integration backend routing (`resolveIntegrationBackend`)
+            // the caller passes the integration's own `nativeBackend` here, so
+            // in practice this branch only drops rows whose binding is null.
             if (state.nativeBackend === sessionBackend)
                 return "native";
-            return null;
+            return "no_binding";
         case "disabled":
-            return null;
+            return "disabled";
         default:
-            return null;
+            return "unknown_mode";
     }
 }
+/** Narrow a `resolveFetchMode` result to the fetch-mode side of the union. */
+function isFetchMode(value) {
+    return (value === "direct"
+        || value === "delegated-same"
+        || value === "delegated-cross"
+        || value === "native");
+}
 /**
  * Resolve the backend the sub-session for this integration MUST run on
  * so that the partial body's resolved `mode:` block has a working wire
@@ -170,9 +180,9 @@ function resolveFetchMode(integration, state, sessionBackend) {
  *    backend keeps the pre-pass tier predictable.
  *  - `direct`: REST via curl to the daemon — sub-session stays on
  *    `defaultBackend`.
- *  - `disabled` / no state: irrelevant (`resolveFetchMode` returns
- *    `null` and the row is dropped before backend matters); returning
- *    `defaultBackend` is a no-op safety default.
+ *  - `disabled` / no state: irrelevant (`resolveFetchMode` returns a
+ *    drop reason and the row is dropped before backend matters);
+ *    returning `defaultBackend` is a no-op safety default.
  *
  * The function is intentionally `null`-free — every call site benefits
  * from a guaranteed backend so the per-integration spawn path never has
@@ -277,6 +287,11 @@ function renderFetchRow(row) {
     if (row.label !== undefined) {
         parts.push(`label="${xmlAttr(row.label)}"`);
     }
+    // `collectFetchRows` only attaches a non-empty allowlist (empty drops
+    // the row with `no_fetch_targets`), so defined ⇒ renderable.
+    if (row.fetchTargets !== undefined) {
+        parts.push(`targets='${xmlQueryAttr(JSON.stringify(row.fetchTargets))}'`);
+    }
     // Single-quote delimiter on `query=` — see `xmlQueryAttr` rationale.
     parts.push(`query='${xmlQueryAttr(row.query)}'`);
     return `  <fetch ${parts.join(" ")} />`;
@@ -291,31 +306,65 @@ function renderFetchRow(row) {
  * monolithic block and the union of per-integration sub-plan blocks
  * carry bit-identical row sequences.
  */
-function collectFetchRows(input) {
+function collectFetchRows(input, 
+/**
+ * N3 observability hook — invoked once per dropped (window ×
+ * integration) cell with the drop reason. Optional so the render-only
+ * consumers (`buildAcquisitionPlan`, `rebuildSubPlanForBackend`) pay
+ * nothing.
+ */
+onDrop) {
     const rows = [];
     const specs = ROUTINE_WINDOWS[input.routine];
     for (const spec of specs) {
         const integrations = integrationsForWindow(spec.window);
         for (const integration of integrations) {
             const state = input.integrations[integration];
+            // Notion rows carry the user's fetch-target allowlist (undefined
+            // for every other integration). Resolved up here — before the mode
+            // guards — but the empty-allowlist drop stays AFTER them, so a
+            // disabled / unbound Notion row keeps its mode-derived drop reason
+            // and `no_fetch_targets` means exactly "active but unconfigured".
+            const fetchTargets = integration === "notion" ? (state?.fetchTargets ?? []) : undefined;
             // Per-integration backend resolution. Was: `input.sessionBackend`
             // (single backend for the whole plan), which caused `resolveFetchMode`
-            // to return `null` for native bindings on a different backend —
-            // silently dropping the row. With `resolveIntegrationBackend` the
-            // sub-session is routed to the integration's actual bound backend
-            // (`nativeBackend`, or `delegatedBackend` for userManagedConnector),
-            // and `resolveFetchMode` then matches on the correct backend so the
+            // to drop rows for native bindings on a different backend. With
+            // `resolveIntegrationBackend` the sub-session is routed to the
+            // integration's actual bound backend (`nativeBackend`, or
+            // `delegatedBackend` for userManagedConnector), and
+            // `resolveFetchMode` then matches on the correct backend so the
             // row survives. The runner uses `requiredBackend` (bubbled up via
             // `FetchRow`) to spawn each sub-session on the right backend via
             // `BackendRouter.resolveBinding({ requestedBackendId })`.
             const requiredBackend = resolveIntegrationBackend(integration, state, input.sessionBackend);
             const fetchMode = resolveFetchMode(integration, state, requiredBackend);
-            if (fetchMode === null)
+            if (!isFetchMode(fetchMode)) {
+                onDrop?.({ integration, window: spec.window, reason: fetchMode });
                 continue;
+            }
             const queryTemplate = lookupQuery(spec.window, integration, fetchMode);
-            if (queryTemplate === undefined)
+            if (queryTemplate === undefined) {
+                // `integrationsForWindow` only yields integrations present in
+                // the catalog for this window, so an undefined template means
+                // the MODE cell is missing. For `direct` that is the documented
+                // intentional pattern (cf. `cal_morning_7d` in
+                // routine-windows.ts): the daemon serves the data inline, so the
+                // pre-pass must not double-fetch. Any other mode is a genuine
+                // catalog hole.
+                onDrop?.({
+                    integration,
+                    window: spec.window,
+                    reason: fetchMode === "direct"
+                        ? "direct_inline_prefetch"
+                        : "no_window_query",
+                });
                 continue;
+            }
             const query = substituteAcquisitionTokens(queryTemplate, input.timestamps);
+            if (fetchTargets !== undefined && fetchTargets.length === 0) {
+                onDrop?.({ integration, window: spec.window, reason: "no_fetch_targets" });
+                continue;
+            }
             // perAccount fan-out is meaningful only in `direct` mode, where the
             // daemon stores per-account OAuth tokens and polls each. In
             // `delegated-same` / `delegated-cross` / `native` the integration's
@@ -332,6 +381,9 @@ function collectFetchRows(input) {
             // surface so the partials never need to defend against them.
             if (spec.perAccount && fetchMode === "direct") {
                 const accountRows = input.accounts.filter((a) => a.integration === integration);
+                if (accountRows.length === 0) {
+                    onDrop?.({ integration, window: spec.window, reason: "no_accounts" });
+                }
                 for (const account of accountRows) {
                     rows.push({
                         integration,
@@ -340,6 +392,7 @@ function collectFetchRows(input) {
                         accountId: account.accountId,
                         label: account.label,
                         query,
+                        fetchTargets,
                         requiredBackend,
                     });
                 }
@@ -350,6 +403,7 @@ function collectFetchRows(input) {
                     mode: fetchMode,
                     window: spec.window,
                     query,
+                    fetchTargets,
                     requiredBackend,
                 });
             }
@@ -418,9 +472,13 @@ export function buildAcquisitionPlan(input) {
  * `scoped="<key>"` attribute and the partition itself.
  */
 export function splitAcquisitionPlanByIntegration(input) {
-    const rows = collectFetchRows(input);
+    return buildAcquisitionPlanAssembly(input).subPlans;
+}
+export function buildAcquisitionPlanAssembly(input) {
+    const drops = [];
+    const rows = collectFetchRows(input, (drop) => drops.push(drop));
     if (rows.length === 0)
-        return [];
+        return { subPlans: [], drops };
     // Group rows by integration while keeping insertion order inside each
     // group (the `ROUTINE_WINDOWS` walk order from `collectFetchRows`).
     const groups = new Map();
@@ -453,5 +511,5 @@ export function splitAcquisitionPlanByIntegration(input) {
             requiredBackend,
         });
     }
-    return out;
+    return { subPlans: out, drops };
 }

package/dist/core/routine-fetch-window-retry.js

@@ -84,10 +84,13 @@ function isFetchFailedWithStatus(err, predicate) {
 /**
  * Sentinel error-status strings the runner classifies as deterministic
  * (no point retrying — the next attempt re-emits the same bytes and
- * re-trips the same gate). Centralised so the partial author (who emits
- * these strings into `errors[*].status`), the runner (which interprets
- * them here), and any future telemetry that filters on them all reference
- * the same vocabulary.
+ * re-trips the same gate). The emitting side of the contract is the
+ * agent profile's `fetch-failed` bullet
+ * (`agent-assets/agent-profiles/routine-fetch-window.md`), which
+ * instructs the agent to set `status:"permission-denied"` when its own
+ * permission layer blocked a tool call; the runner interprets the
+ * strings here, and any future telemetry that filters on them
+ * references the same vocabulary.
  *
  * See `RETRY_REASONS.DETERMINISTIC_FAILURE` for the rationale and the
  * specific gates these sentinels are paired with — and for why

package/dist/core/routine-fetch-window-runner.d.ts

@@ -3,7 +3,7 @@
  *
  * docs/design/appendices/routine-data-acquisition.md §6.1.1 + docs/design/appendices/pre-pass-fan-out.md
  * — every routine dispatcher (morning_routine, today_refresh,
- * hourly_check, evening / weekly / monthly review) calls this runner
+ * activity_scan, evening / weekly / monthly review) calls this runner
  * immediately before dispatching the parent session. The runner:
  *
  *  1. Reads the per-routine plan from `ROUTINE_WINDOWS` and the current
@@ -27,7 +27,7 @@
  *  4. The caller grafts the block into the **parent** routine event's
  *     `event.data.fetchReportBlock`. ContextBuilder injects it verbatim
  *     into the parent session's prompt (mirrors the `<gate_decision>`
- *     pattern used by hourly_check Stage 3).
+ *     pattern used by activity_scan Stage 3).
  *
  * Failure-mode contract (docs/design/appendices/pre-pass-fan-out.md §5):
  *
@@ -57,6 +57,7 @@ import type { IAgentRouter } from "./backends/backend-router.js";
 import type { IAuditLogger, IContextBuilder } from "./dispatcher-types.js";
 import type { PromptAssembler } from "./dispatcher-prompt.js";
 import { type RoutineWindowKey } from "./routine-windows.js";
+import type { AutonomousSpawnGate } from "./spawn-gates.js";
 /**
  * Structured form of the agent's single-line JSON output. Matches the
  * contract in `agent-profiles/routine-fetch-window.md`:
@@ -142,7 +143,7 @@ export interface RoutineFetchWindowResult {
 /**
  * HOURLY_CHECK_GATE_REDESIGN_PLAN.md §3.4 — caller options for `run()`.
  *
- * The hourly_check coordinator passes `integrationKeyFilter` to restrict
+ * The activity_scan coordinator passes `integrationKeyFilter` to restrict
  * the fan-out to the subset of integrations whose freshness window has
  * elapsed. Morning_routine / evening_review / weekly_review call
  * `run()` without options so they fetch every integration the routine
@@ -194,6 +195,14 @@ export interface RoutineFetchWindowRunnerDeps {
     getEventBroadcaster?: () => {
         broadcastEvent: (data: unknown) => void;
     } | null;
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N2 — offline/auth spawn gate shared
+     * with the dispatcher. Evaluated per integration sub-session (the
+     * hourly `harvestForGate` path spawns the runner directly, bypassing
+     * the dispatcher's own gate). Optional: when undefined the runner
+     * spawns unconditionally, exactly as pre-N2.
+     */
+    spawnGate?: AutonomousSpawnGate;
 }
 /**
  * Compose the per-execute `allowedToolsOverride` for the pre-pass. The
@@ -340,6 +349,7 @@ export declare class RoutineFetchWindowRunner {
     private readonly prompt;
     private readonly getActiveMailAccounts;
     private readonly getEventBroadcaster;
+    private readonly spawnGate;
     constructor(deps: RoutineFetchWindowRunnerDeps);
     /**
      * Broadcast a single pre-pass progress event to the dashboard SSE
@@ -426,6 +436,32 @@ export declare class RoutineFetchWindowRunner {
     private budgetCapAttemptRecord;
     private didExhaustRetries;
     private backoffForAttempt;
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N2 — evaluate the offline/auth spawn
+     * gate for one integration's sub-session. Candidates are the
+     * pre-resolved binding's main + fallback backends; when pre-resolve
+     * failed, the sub-plan's `requiredBackend` is the only candidate the
+     * attempt loop could use. Fail-open on every error path (returns null).
+     */
+    private evaluateSpawnGate;
+    /**
+     * Build the `skipped` SubReport for a spawn-gate skip and write its
+     * audit row. Mirrors the empty-attempts synthetic record (attempt 0,
+     * no SSE sub-session emits — no session was spawned). The audit row is
+     * `result='skipped'` with `detail.prePass.skipReason` carrying N2's
+     * `offline` / `auth_unhealthy`, matching the N3 plan-drop row shape so
+     * all pre-pass skip telemetry is queryable through one path.
+     */
+    private spawnGateSkippedSubReport;
+    /**
+     * PREPASS_COST_REDUCTION_PLAN.md N3 — one `skipped` audit row per
+     * (integration × reason) group of plan-assembly drops, with the
+     * dropped windows listed in `detail.prePass.windows`. Grouped at
+     * integration granularity because that is the unit a session would
+     * have been spawned for (and the unit the deferred R5 streak skip
+     * will key on). Observability only — no skip behavior changes here.
+     */
+    private logPlanAssemblyDrops;
     /**
      * Unified audit-row companion for every fan-out failure mode —
      * binding-resolve-failed, global-budget-cap, budget-cap (per-integration),