@aitne/daemon 0.1.3 → 0.1.6

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

@@ -0,0 +1,210 @@
+/**
+ * Retry-policy helpers for the pre-pass fan-out coordinator.
+ *
+ * PRE_PASS_FAN_OUT_DESIGN.md §4.4 — the coordinator spawns a fresh Haiku
+ * sub-session per attempt and consults `defaultRetryDecision` (or any
+ * `RetryDecisionFn`) between attempts to choose whether to spawn the
+ * next one. Keeping the policy as pure data (decision matrix in
+ * TypeScript, not in agent prose) makes the loop deterministic,
+ * testable, and free of per-model variance.
+ *
+ * Phase 0 ships these helpers + their unit tests. The fan-out
+ * coordinator that consumes them lands in Phase 1.
+ */
+// ── Decision matrix (PRE_PASS_FAN_OUT_DESIGN.md §4.4) ─────────────────────
+/**
+ * Stable reason identifiers. Centralised so the dashboard / audit feed
+ * can render them consistently and so test assertions don't drift from
+ * runtime values.
+ */
+export const RETRY_REASONS = {
+    MAX_ATTEMPTS: "max-attempts-reached",
+    BUDGET_CAP: "per-integration-budget-cap",
+    FLIP_LOCKED: "flip-locked",
+    BUDGET_EXHAUSTED: "budget-exhausted",
+    AUTH_FAILED: "auth-failed",
+    FAILED_STATUS: "failed-status",
+    UPSTREAM_5XX: "upstream-5xx",
+    PARTIAL_NO_POST: "partial-no-post",
+    SUCCESS: "success",
+    PARTIAL_WITH_POST: "partial-with-progress",
+    SKIPPED: "skipped",
+    NO_PROGRESS: "no-progress",
+};
+/**
+ * Sum the cost across `priorAttempts` + the current `report`. Pure;
+ * exported for unit testing the budget-cap branch in isolation.
+ */
+export function cumulativeAttemptCost(report, priorAttempts) {
+    let total = report.costUsd;
+    for (const att of priorAttempts)
+        total += att.costUsd;
+    return total;
+}
+function isFetchFailedWithStatus(err, predicate) {
+    if (err.type !== "fetch-failed")
+        return false;
+    // `status` may arrive as number or string — MCP transports stringify
+    // upstream HTTP codes inconsistently.
+    const raw = err.status;
+    const status = typeof raw === "number"
+        ? raw
+        : typeof raw === "string" && /^\d+$/.test(raw)
+            ? Number.parseInt(raw, 10)
+            : NaN;
+    if (Number.isNaN(status))
+        return false;
+    return predicate(status);
+}
+/**
+ * Default retry policy from §4.4. Pure: decision is fully determined by
+ * the inputs, no side effects, no shared state. Decision order:
+ *
+ *  1. Attempts cap (no retry, reason `max-attempts-reached`).
+ *  2. Per-integration cumulative budget cap.
+ *  3. Terminal error classes — flip-lock, budget-exhausted, auth (401/403).
+ *  4. Retry-worthy outcomes — failed status, upstream 5xx, partial-no-post.
+ *  5. Non-retry-by-default — success, partial-with-progress, skipped, no-progress.
+ *
+ * The motivating §1.1 failure ("Unknown name "limit"") lands
+ * as `status="partial"` with `fetched > 0`, `posted === 0` and a
+ * `fetch-failed` error — rule (4)'s `partial-no-post` branch catches it.
+ */
+export const defaultRetryDecision = (report, attempt, policy, priorAttempts) => {
+    // (1) Attempts cap — the loop body checks this before spawning attempt N+1.
+    if (attempt >= policy.maxAttempts) {
+        return { retry: false, reason: RETRY_REASONS.MAX_ATTEMPTS };
+    }
+    // (2) Cumulative cost cap. Compare against the cost AFTER recording
+    // this attempt; if it's already at/over the cap, no point retrying.
+    const cumulative = cumulativeAttemptCost(report, priorAttempts);
+    if (cumulative >= policy.perIntegrationBudgetUsd) {
+        return { retry: false, reason: RETRY_REASONS.BUDGET_CAP };
+    }
+    // (3) Terminal error classes — first match wins.
+    for (const err of report.errors) {
+        if (err.type === "flip-locked") {
+            return { retry: false, reason: RETRY_REASONS.FLIP_LOCKED };
+        }
+        if (err.type === "budget-exhausted") {
+            return { retry: false, reason: RETRY_REASONS.BUDGET_EXHAUSTED };
+        }
+        if (isFetchFailedWithStatus(err, (s) => s === 401 || s === 403)) {
+            return { retry: false, reason: RETRY_REASONS.AUTH_FAILED };
+        }
+    }
+    // (4) Retry-worthy.
+    if (report.status === "failed") {
+        return { retry: true, reason: RETRY_REASONS.FAILED_STATUS };
+    }
+    for (const err of report.errors) {
+        if (isFetchFailedWithStatus(err, (s) => s >= 500 && s < 600)) {
+            return { retry: true, reason: RETRY_REASONS.UPSTREAM_5XX };
+        }
+    }
+    if (policy.retryOnPartial !== false
+        &&
+            report.status === "partial"
+        && report.posted === 0
+        && report.fetched > 0) {
+        return { retry: true, reason: RETRY_REASONS.PARTIAL_NO_POST };
+    }
+    // (5) Non-retry-by-default outcomes.
+    if (report.status === "success") {
+        return { retry: false, reason: RETRY_REASONS.SUCCESS };
+    }
+    if (report.status === "partial" && report.posted > 0) {
+        return { retry: false, reason: RETRY_REASONS.PARTIAL_WITH_POST };
+    }
+    if (report.status === "skipped") {
+        return { retry: false, reason: RETRY_REASONS.SKIPPED };
+    }
+    // Partial with fetched=0 and posted=0 — every fetch errored before
+    // returning items. The spec's matrix doesn't list this case; default
+    // to no-retry to keep the policy conservative (the §1.1 motivating
+    // failure is partial-no-post WITH fetched>0, which is already caught
+    // above). Operators who see this case in telemetry can override via
+    // `RetryPolicy.retryOn`.
+    return { retry: false, reason: RETRY_REASONS.NO_PROGRESS };
+};
+// ── Prior-attempt hint rendering (PRE_PASS_FAN_OUT_DESIGN.md §4.4) ────────
+function xmlAttr(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/"/g, "&quot;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function xmlText(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/**
+ * Generic MVP hint prose. §4.4 calls out the OQ-3 upgrade path
+ * (schema-aware classifier that promotes the hint to a specific
+ * substitution, e.g. `limit` → `maxResults`); the MVP stays generic so
+ * the hint-builder is not coupled to upstream argument-name schemas
+ * that drift independently.
+ */
+const GENERIC_HINT_PROSE = "The previous attempt's call returned the error above. Re-read the partial body and try a different argument shape — the partial is the source of truth for tool argument names, not your memory of prior calls.";
+function pickFirstError(errors) {
+    return errors.length > 0 ? errors[0] : undefined;
+}
+function renderErrorChild(err) {
+    const type = typeof err.type === "string" ? err.type : "unknown";
+    // Surface every string/number attribute (other than `type`) so the
+    // motivating §1.1 case carries `status="400"` and `message="…"`
+    // verbatim into the next attempt's prompt.
+    const attrEntries = Object.entries(err).filter(([k, v]) => k !== "type" && (typeof v === "string" || typeof v === "number"));
+    const attrs = attrEntries
+        .map(([k, v]) => `${xmlAttr(k)}="${xmlAttr(String(v))}"`)
+        .join(" ");
+    const tagName = xmlAttr(type.replace(/-/g, "_"));
+    return `<${tagName}${attrs ? " " + attrs : ""} />`;
+}
+function renderOnePriorAttempt(record, integrationKey) {
+    const openParts = [`attempt="${record.attempt}"`];
+    if (integrationKey !== undefined) {
+        openParts.push(`integration="${xmlAttr(integrationKey)}"`);
+    }
+    const lines = [`<prior_attempt_error ${openParts.join(" ")}>`];
+    const firstErr = pickFirstError(record.errors);
+    if (firstErr) {
+        lines.push(`  ${renderErrorChild(firstErr)}`);
+    }
+    else if (record.parseError) {
+        lines.push(`  <parse_failed reason="${xmlAttr(record.parseError)}" />`);
+    }
+    else {
+        // The attempt was retried but carried neither an explicit error nor
+        // a parseError — likely a coordinator-side timeout or quota error
+        // logged as a generic failed-status. Surface that explicitly so the
+        // model knows *something* went wrong, not just that retry was
+        // selected silently.
+        lines.push(`  <failed status="${xmlAttr(record.status)}" />`);
+    }
+    lines.push(`  <hint>${xmlText(GENERIC_HINT_PROSE)}</hint>`);
+    lines.push("</prior_attempt_error>");
+    return lines.join("\n");
+}
+/**
+ * Render the `<prior_attempt_error>` block sequence injected into a
+ * sub-session's prompt on attempt > 1. Returns the empty string when
+ * `attempts` is empty so callers can unconditionally concatenate the
+ * result.
+ *
+ * **Ordering.** Newest first — attempt N (most recent) appears before
+ * attempt N-1, etc. The model reads the most-recent failure top of
+ * page; deeper history is context-only.
+ */
+export function buildPriorAttemptHintBlock(attempts, integrationKey) {
+    if (attempts.length === 0)
+        return "";
+    const newestFirst = [...attempts].reverse();
+    return newestFirst
+        .map((att) => renderOnePriorAttempt(att, integrationKey))
+        .join("\n");
+}
+//# sourceMappingURL=routine-fetch-window-retry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routine-fetch-window-retry.js","sourceRoot":"","sources":["../../src/core/routine-fetch-window-retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA0DH,6EAA6E;AAE7E;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,YAAY,EAAE,sBAAsB;IACpC,UAAU,EAAE,4BAA4B;IACxC,WAAW,EAAE,aAAa;IAC1B,gBAAgB,EAAE,kBAAkB;IACpC,WAAW,EAAE,aAAa;IAC1B,aAAa,EAAE,eAAe;IAC9B,YAAY,EAAE,cAAc;IAC5B,eAAe,EAAE,iBAAiB;IAClC,OAAO,EAAE,SAAS;IAClB,iBAAiB,EAAE,uBAAuB;IAC1C,OAAO,EAAE,SAAS;IAClB,WAAW,EAAE,aAAa;CAClB,CAAC;AAEX;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,MAAwB,EACxB,aAA0C;IAE1C,IAAI,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC;IAC3B,KAAK,MAAM,GAAG,IAAI,aAAa;QAAE,KAAK,IAAI,GAAG,CAAC,OAAO,CAAC;IACtD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,uBAAuB,CAC9B,GAA4B,EAC5B,SAAsC;IAEtC,IAAI,GAAG,CAAC,IAAI,KAAK,cAAc;QAAE,OAAO,KAAK,CAAC;IAC9C,qEAAqE;IACrE,sCAAsC;IACtC,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC;IACvB,MAAM,MAAM,GAAG,OAAO,GAAG,KAAK,QAAQ;QACpC,CAAC,CAAC,GAAG;QACL,CAAC,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC;YAC5C,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC;YAC1B,CAAC,CAAC,GAAG,CAAC;IACV,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACvC,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAoB,CACnD,MAAM,EACN,OAAO,EACP,MAAM,EACN,aAAa,EACb,EAAE;IACF,4EAA4E;IAC5E,IAAI,OAAO,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;QAClC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,YAAY,EAAE,CAAC;IAC9D,CAAC;IAED,oEAAoE;IACpE,oEAAoE;IACpE,MAAM,UAAU,GAAG,qBAAqB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAChE,IAAI,UAAU,IAAI,MAAM,CAAC,uBAAuB,EAAE,CAAC;QACjD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,UAAU,EAAE,CAAC;IAC5D,CAAC;IAED,iDAAiD;IACjD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAChC,IAAI,GAAG,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;YAC/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,WAAW,EAAE,CAAC;QAC7D,CAAC;QACD,IAAI,GAAG,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;YACpC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,gBAAgB,EAAE,CAAC;QAClE,CAAC;QACD,IAAI,uBAAuB,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YAChE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,WAAW,EAAE,CAAC;QAC7D,CAAC;IACH,CAAC;IAED,oBAAoB;IACpB,IAAI,MAAM,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,aAAa,EAAE,CAAC;IAC9D,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAChC,IAAI,uBAAuB,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;YAC7D,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,YAAY,EAAE,CAAC;QAC7D,CAAC;IACH,CAAC;IACD,IACE,MAAM,CAAC,cAAc,KAAK,KAAK;;YAE/B,MAAM,CAAC,MAAM,KAAK,SAAS;WACxB,MAAM,CAAC,MAAM,KAAK,CAAC;WACnB,MAAM,CAAC,OAAO,GAAG,CAAC,EACrB,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,eAAe,EAAE,CAAC;IAChE,CAAC;IAED,qCAAqC;IACrC,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,OAAO,EAAE,CAAC;IACzD,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,iBAAiB,EAAE,CAAC;IACnE,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,OAAO,EAAE,CAAC;IACzD,CAAC;IACD,mEAAmE;IACnE,qEAAqE;IACrE,mEAAmE;IACnE,qEAAqE;IACrE,oEAAoE;IACpE,yBAAyB;IACzB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,WAAW,EAAE,CAAC;AAC7D,CAAC,CAAC;AAEF,6EAA6E;AAE7E,SAAS,OAAO,CAAC,KAAa;IAC5B,OAAO,KAAK;SACT,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;SACtB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC;SACvB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAC3B,CAAC;AAED,SAAS,OAAO,CAAC,KAAa;IAC5B,OAAO,KAAK;SACT,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;SACtB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,kBAAkB,GACpB,iNAAiN,CAAC;AAEtN,SAAS,cAAc,CACrB,MAA8C;IAE9C,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACnD,CAAC;AAED,SAAS,gBAAgB,CAAC,GAA4B;IACpD,MAAM,IAAI,GAAG,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,mEAAmE;IACnE,gEAAgE;IAChE,2CAA2C;IAC3C,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAC5C,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,CAAC,CAC7E,CAAC;IACF,MAAM,KAAK,GAAG,WAAW;SACtB,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;SACxD,IAAI,CAAC,GAAG,CAAC,CAAC;IACb,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC;IACjD,OAAO,IAAI,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;AACrD,CAAC;AAED,SAAS,qBAAqB,CAC5B,MAAwB,EACxB,cAA0C;IAE1C,MAAM,SAAS,GAAG,CAAC,YAAY,MAAM,CAAC,OAAO,GAAG,CAAC,CAAC;IAClD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;QACjC,SAAS,CAAC,IAAI,CAAC,gBAAgB,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;IAC7D,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,wBAAwB,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC/D,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC/C,IAAI,QAAQ,EAAE,CAAC;QACb,KAAK,CAAC,IAAI,CAAC,KAAK,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAChD,CAAC;SAAM,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;QAC7B,KAAK,CAAC,IAAI,CACR,2BAA2B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAC5D,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,oEAAoE;QACpE,kEAAkE;QAClE,oEAAoE;QACpE,8DAA8D;QAC9D,qBAAqB;QACrB,KAAK,CAAC,IAAI,CAAC,qBAAqB,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAChE,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,WAAW,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC5D,KAAK,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;IACrC,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,0BAA0B,CACxC,QAAqC,EACrC,cAA+B;IAE/B,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACrC,MAAM,WAAW,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC;IAC5C,OAAO,WAAW;SACf,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,qBAAqB,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;SACxD,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC"}

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

@@ -0,0 +1,427 @@
+/**
+ * `RoutineFetchWindowRunner` — pre-pass fan-out coordinator.
+ *
+ * ROUTINE_DATA_ACQUISITION_DESIGN.md §6.1.1 + PRE_PASS_FAN_OUT_DESIGN.md
+ * — every routine dispatcher (morning_routine, today_refresh,
+ * hourly_check, 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
+ *     integration state, fans rows out per-account where applicable,
+ *     resolves each row's predicate (`direct` / `delegated-same` /
+ *     `delegated-cross` / `native` / skip), and partitions the plan
+ *     by `IntegrationKey` via `splitAcquisitionPlanByIntegration`.
+ *  2. Spawns one lite-tier `routine.fetch_window` sub-session per
+ *     integration in parallel (bounded by `prePassFanOutConcurrency`).
+ *     Each sub-session sees exactly one partial — the
+ *     `{integration_partial}` placeholder in the
+ *     `routine.fetch_window` task-flow is replaced with the body of
+ *     `_partials/<integration prePassPartial>` so the lite-tier model
+ *     never has to disambiguate cross-API argument names. Each
+ *     sub-session runs through an independent retry loop bounded by
+ *     `prePassMaxAttemptsPerIntegration`, `prePassBackoffMs`, and the
+ *     per-integration / per-routine USD budget caps.
+ *  3. Merges the sub-reports into a single `FetchReport` (additive
+ *     `<integration>` children on the `<fetch_report>` XML block) and
+ *     returns it plus the rendered block.
+ *  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).
+ *
+ * Failure-mode contract (PRE_PASS_FAN_OUT_DESIGN.md §5):
+ *
+ *  - **No applicable rows** (routine has no windows in `ROUTINE_WINDOWS`,
+ *    every integration is disabled, every account list is empty) — the
+ *    runner returns an empty `<fetch_report>` with `status="skipped"` and
+ *    `fetched=posted=duplicates=0`. The parent routine still runs; the
+ *    block is informational only.
+ *  - **Pre-pass session errors** (binding resolve fails, agent throws,
+ *    JSON parse fails) — recorded per-attempt; the retry loop fires up
+ *    to `maxAttempts` before giving up. Final per-integration status
+ *    surfaces in `<integration status="failed">`. Pre-pass cost gains
+ *    are forfeit for that integration; siblings are unaffected.
+ *    Throwing here would otherwise propagate up and abort the parent
+ *    routine — the opposite of P3 ("Lite for Fetch, Medium for Decide").
+ *  - **Partial success** — the report's `errors` array carries per-row
+ *    failures (`no-surface`, `fetch-failed`, `budget-exhausted`,
+ *    `budget-cap`, `global-budget-cap`). The block surfaces them so the
+ *    parent prompt can decide whether to treat its observations view as
+ *    complete.
+ */
+import type Database from "better-sqlite3";
+import type { BackendId, Event, IntegrationKey, IntegrationState } from "@aitne/shared";
+import type { AgentConfig } from "../config.js";
+import type { MailAccount } from "../services/mail/provider.js";
+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";
+/**
+ * Structured form of the agent's single-line JSON output. Matches the
+ * contract in `agent-profiles/routine-fetch-window.md`:
+ *
+ * ```json
+ * {"fetched": <int>, "posted": <int>, "duplicates": <int>, "errors": [...]}
+ * ```
+ *
+ * `status` is the runner's classification of the run — `success` /
+ * `partial` (any errors) / `failed` (parse / agent / dispatch failure) /
+ * `skipped` (no applicable rows). Persisted in the `<fetch_report>`
+ * block so the parent routine can branch deterministically without
+ * re-counting the errors array.
+ */
+export interface FetchReport {
+    status: "success" | "partial" | "failed" | "skipped";
+    fetched: number;
+    posted: number;
+    duplicates: number;
+    errors: ReadonlyArray<Record<string, unknown>>;
+    /** True when the runner skipped dispatching a session entirely. */
+    skipped: boolean;
+    /** Set when status === "failed" — the message captured in the audit row. */
+    failureReason?: string;
+    /** Stable ID for telemetry tie-back; mirrors the fetcher event's correlationId. */
+    fetcherCorrelationId?: string;
+    /**
+     * PRE_PASS_FAN_OUT_DESIGN.md §4.5 — per-integration breakdown. Top-level
+     * counts above already aggregate the children; the breakdown lets
+     * downstream consumers (parent task-flow prose, dashboard renderers)
+     * branch per integration. Absent on the `skipped` / `failed` paths
+     * that short-circuit before fan-out (no-routine-key, no-windows,
+     * empty plan, plan-assembly-failed).
+     */
+    perIntegration?: ReadonlyArray<SubReport>;
+}
+/**
+ * PRE_PASS_FAN_OUT_DESIGN.md §4.3 — one attempt of one integration's
+ * sub-session. The fan-out coordinator records one of these per
+ * `agentRouter.execute` invocation; `defaultRetryDecision` consumes
+ * the latest record to decide whether to spawn another attempt.
+ */
+export interface SubAttemptRecord {
+    /** 1-indexed. */
+    attempt: number;
+    status: FetchReport["status"];
+    fetched: number;
+    posted: number;
+    duplicates: number;
+    errors: ReadonlyArray<Record<string, unknown>>;
+    /** Set when the agent's output failed strict-JSON parse. */
+    parseError?: string;
+    fetcherCorrelationId: string;
+    /** ISO 8601 UTC. */
+    startedAt: string;
+    /** ISO 8601 UTC. */
+    endedAt: string;
+    costUsd: number;
+    numTurns: number;
+}
+/**
+ * PRE_PASS_FAN_OUT_DESIGN.md §4.3 — final per-integration verdict the
+ * coordinator emits after its retry loop terminates. Mirrors the
+ * fields of the last `SubAttemptRecord` (the final attempt's outcome
+ * is the integration's effective outcome) plus the integration key
+ * and the full attempt history.
+ */
+export interface SubReport extends SubAttemptRecord {
+    integrationKey: IntegrationKey;
+    /** Full attempt history; `attempts[attempts.length - 1]` matches the inherited fields. */
+    attempts: ReadonlyArray<SubAttemptRecord>;
+    /**
+     * True iff the loop exhausted `maxAttempts` (or a budget/global cap
+     * tripped) without reaching a non-retryable success state.
+     */
+    retriesExhausted: boolean;
+}
+export interface RoutineFetchWindowResult {
+    report: FetchReport;
+    /** XML block to graft into the parent routine event's `event.data.fetchReportBlock`. */
+    block: string;
+}
+export interface RoutineFetchWindowRunnerDeps {
+    db: Database.Database;
+    config: AgentConfig;
+    contextBuilder: IContextBuilder;
+    agentRouter: IAgentRouter;
+    audit: IAuditLogger;
+    prompt: PromptAssembler;
+    /**
+     * Returns the active mail account list — used to fan rows out per
+     * account when `RoutineWindowSpec.perAccount === true`. Threads the
+     * dispatcher's existing `getActiveMailAccounts` closure so the runner
+     * doesn't need to depend on the registry directly.
+     */
+    getActiveMailAccounts: () => readonly MailAccount[];
+    /**
+     * Lazy accessor for the dashboard SSE event broadcaster (A2 / B2
+     * observability extension). When set, the runner emits
+     * `kind: "prepass_started"` / `"prepass_completed"` payloads to the
+     * default `event` SSE channel so the setup wizard can render the
+     * "Fetching your mail and Notion data…" sub-step distinctly from
+     * the parent routine's `routine_started` / `routine_completed`
+     * envelope. Returns `null` when the dispatcher has not wired a
+     * broadcaster yet (test paths, headless installs); the runner
+     * treats every call as fire-and-forget and never propagates a
+     * broadcaster failure into the parent dispatch.
+     *
+     * Optional — when undefined the runner runs exactly as it did
+     * pre-A2, including the empty-plan short-circuit.
+     */
+    getEventBroadcaster?: () => {
+        broadcastEvent: (data: unknown) => void;
+    } | null;
+}
+/**
+ * Compose the per-execute `allowedToolsOverride` for the pre-pass. The
+ * override REPLACES the SDK's default allowlist (no union per
+ * claude-code-core.ts:437) so the list must be exhaustive for every
+ * surface the partials use under any (integration, mode) cell. Mode
+ * coverage:
+ *
+ *  - `direct`: daemon REST → curl prefix.
+ *  - `delegated-same`: session backend MCP → integration tool name.
+ *  - `delegated-cross`: daemon delegation proxy → curl prefix
+ *    (`/api/integrations/<key>/exec`).
+ *  - `native` (descriptor-bound): session backend MCP → integration
+ *    tool name.
+ *  - `native` (user-managed) / no-surface: nothing in the override —
+ *    the partial records `no-surface` and the runner's report carries
+ *    the gap forward to the parent routine.
+ *
+ * `ToolSearch` is appended for Claude sessions whenever at least one
+ * descriptor-bound MCP tool is present. Claude Code 2.1+ defers large
+ * MCP tool manifests (`mcp__claude_ai_Gmail__*`,
+ * `mcp__claude_ai_Google_Calendar__*`, `mcp__claude_ai_Notion__*`, …)
+ * behind `ToolSearch`, so the model must call `ToolSearch` to load a
+ * deferred tool's schema before it can be invoked. Without `ToolSearch`
+ * allowed, the Haiku fetcher emits a denied ToolSearch call on its
+ * first turn, gives up, and returns text with no JSON — the parent
+ * routine then sees `<fetch_report status="failed" reason="no-json-object">`.
+ * Mirrors the same workaround in `claude-delegated.ts` (delegated proxy
+ * `allowedTools: [toolName, "ToolSearch"]`). Codex / Gemini have no
+ * per-spawn allowedTools surface today and ignore the override entirely
+ * (CLAUDE.md acknowledges the gap), so the `ToolSearch` widening is
+ * gated on `sessionBackend === "claude"` to keep the list minimal for
+ * other backends.
+ *
+ * Exported for unit testing — the runner consumes it via
+ * `composePrePassAllowedTools` at dispatch time.
+ */
+export declare function composePrePassAllowedTools(apiPort: number, integrations: Partial<Record<IntegrationKey, IntegrationState>>, sessionBackend: BackendId): readonly string[];
+/**
+ * Derive the canonical `RoutineWindowKey` from a routine event. The
+ * caller's intent is conveyed by `event.type` (always `routine.<name>`),
+ * with `RoutineEvent.routine` carrying the same suffix without the
+ * `routine.` prefix. Returns null for routines outside the catalog so
+ * the caller can short-circuit before touching plan assembly.
+ */
+export declare function routineWindowKeyFromEvent(event: Event): RoutineWindowKey | null;
+/**
+ * Walk `text` and return every balanced `{...}` slice (top-level objects
+ * only; nested braces are honoured). Strings are tracked so brace
+ * characters inside `"..."` literals don't unbalance the scan. Used by
+ * `parseFetchWindowOutput` to pick the LAST top-level object on stdout —
+ * agents occasionally emit a think-aloud line carrying a JSON snippet
+ * before the verdict, and the fetcher's contract is "the last
+ * top-level JSON object wins."
+ *
+ * Exported for direct unit testing; the runner consumes it via
+ * `parseFetchWindowOutput`.
+ */
+export declare function extractBalancedJsonObjects(text: string): string[];
+/** Strict-JSON parse of the fetcher's single-line output. */
+export declare function parseFetchWindowOutput(output: string): FetchReport | {
+    parseError: string;
+};
+/**
+ * Render the `<fetch_report>` XML block injected into the parent
+ * routine's prompt. Keep the schema narrow — every additional attribute
+ * costs prompt tokens on the cache-warm parent session.
+ *
+ * `meta.routine` accepts any string so the no-routine-key skip path can
+ * render the parent event's actual type (e.g. `routine.skill_curation`)
+ * instead of borrowing a catalog entry as a placeholder. The renderer
+ * strips the `routine.` prefix verbatim — callers may pass either the
+ * fully-qualified ProcessKey or a bare suffix.
+ */
+export declare function renderFetchReportBlock(report: FetchReport, meta: {
+    routine: RoutineWindowKey | string;
+    agentDay: string;
+}): string;
+/**
+ * Resolve the aggregate `<fetch_report>` status from a set of
+ * sub-reports' final statuses, per §4.5:
+ *
+ *  - `success` iff every non-skipped sub-report is `success`. Skipped
+ *    sub-reports do not count against success.
+ *  - `failed` iff every non-skipped sub-report is `failed`.
+ *  - `partial` for any other mix (incl. one success + one failed).
+ *  - `skipped` only when the input is empty (the caller handles
+ *    "every sub-report skipped" separately — the runner short-circuits
+ *    before fan-out when no integrations are active).
+ *
+ * Exported for unit testing the status-resolution branch in isolation.
+ */
+export declare function aggregateFanOutStatus(subReports: readonly SubReport[]): FetchReport["status"];
+/** Headline numbers for one integration's full retry chain. */
+export interface IntegrationSummary {
+    key: IntegrationKey;
+    status: FetchReport["status"];
+    attempts: number;
+    fetched: number;
+    posted: number;
+    duplicates: number;
+    costUsd: number;
+    durationMs: number;
+    /** Set only when status === "failed"; first error message of final attempt. */
+    finalError?: string;
+}
+/** Headline numbers for the whole fan-out routine. */
+export interface AggregateSummary {
+    status: FetchReport["status"];
+    fetched: number;
+    posted: number;
+    duplicates: number;
+    costUsd: number;
+}
+export declare function summarizeIntegrationReport(sub: SubReport): IntegrationSummary;
+export declare function summarizeFetchReport(report: FetchReport): AggregateSummary;
+/**
+ * Merge fan-out sub-reports into a single `FetchReport` + the rendered
+ * `<fetch_report>` XML block the parent routine sees. §4.5.
+ *
+ *  - Counts (`fetched`, `posted`, `duplicates`): arithmetic sum.
+ *  - `errors`: concatenation, each error tagged with
+ *    `integration: <key>` (and the per-attempt rows already carry
+ *    `attempt: <n>` via the runner's per-attempt error-recording —
+ *    `mergeSubReports` does not invent annotations beyond `integration`).
+ *  - `status`: `aggregateFanOutStatus`.
+ *  - `failureReason`: only when aggregate is `failed`; one-line summary
+ *    listing the failed integrations and their attempt counts.
+ *  - `perIntegration`: sorted by `INTEGRATION_KEYS` order regardless of
+ *    completion order (deterministic — §4.6).
+ *
+ * Pure function: no side effects, no DB / clock dependencies.
+ */
+export declare function mergeSubReports(subReports: readonly SubReport[], routine: RoutineWindowKey | string, agentDay: string): {
+    report: FetchReport;
+    block: string;
+};
+export declare class RoutineFetchWindowRunner {
+    private readonly db;
+    private readonly config;
+    private readonly contextBuilder;
+    private readonly agentRouter;
+    private readonly audit;
+    private readonly prompt;
+    private readonly getActiveMailAccounts;
+    private readonly getEventBroadcaster;
+    constructor(deps: RoutineFetchWindowRunnerDeps);
+    /**
+     * Broadcast a single pre-pass progress event to the dashboard SSE
+     * channel. Failure is contained — the broadcaster contract is
+     * fire-and-forget and a misbehaving writer must not affect the
+     * runner's return value or the parent routine's dispatch.
+     *
+     * Schema (default `event` SSE channel, matches existing
+     * `kind: "main_backend_changed"` / `"routine_started"` pattern):
+     *   { kind, routine, source, correlationId, timestamp, status? }
+     * `status` is set on `prepass_completed` only and reflects the
+     * FetchReport.status field (success / partial / failed / skipped).
+     */
+    private broadcastPrepassProgress;
+    /**
+     * Execute the pre-pass for `parentEvent`. Returns the fetch report
+     * and rendered `<fetch_report>` block; callers graft the block into
+     * the parent event's `event.data.fetchReportBlock` so ContextBuilder
+     * injects it into the parent prompt.
+     *
+     * `routineKey` overrides the auto-derived window key — used by
+     * morning_routine to opt into `routine.morning_routine_initial`'s
+     * plan when `yesterday.md` is absent (their plans currently coincide,
+     * but the seam exists for future divergence).
+     */
+    run(parentEvent: Event, routineKey?: RoutineWindowKey): Promise<RoutineFetchWindowResult>;
+    private runImpl;
+    private buildFanOutPlanContext;
+    /**
+     * §5 BackendQuotaError row + §4.4 retryEscalationTier — re-derive the
+     * per-integration sub-plan against the CURRENT attempt's binding so a
+     * cross-backend swap (escalation tier flips main backend, or
+     * `prePassRetryEscalationTier` swaps the per-attempt tier) keeps the
+     * plan's `<fetch mode="…">` attribute aligned with the partial body's
+     * remaining mode-branch (the partial is filtered for the new backend
+     * via `renderPartialForFanOut`). Returns null only when the
+     * integration becomes unreachable on the new backend (e.g. native
+     * mode bound to A but the attempt re-resolves to B); the runner
+     * passes the call through to record the original sub-plan and let
+     * the agent emit `no-surface` errors organically.
+     *
+     * Pure: snapshot inputs (`integrationsSnapshot`, `accounts`,
+     * `timestamps`) are frozen at run() entry; only `sessionBackend`
+     * varies across attempts. Re-derivation is cheap —
+     * `splitAcquisitionPlanByIntegration` walks `ROUTINE_WINDOWS[routine]`
+     * (a small constant) without I/O.
+     */
+    private rebuildSubPlanForBackend;
+    private buildRetryPolicy;
+    private fanOutConcurrency;
+    private retryEscalationTier;
+    private runFanOut;
+    private runOneIntegrationWithRetry;
+    /**
+     * Emit `prepass_subsession_started` for an attempt that is about to run.
+     * Called at the TOP of every loop iteration so the started/completed
+     * pair is symmetric across all paths — including binding-resolve-failed
+     * and budget-cap short-circuits, which previously emitted neither.
+     */
+    private emitSubSessionStarted;
+    /**
+     * Emit `prepass_subsession_completed` for an attempt that has just
+     * recorded its outcome. Mirror of `emitSubSessionStarted` — invoked
+     * once per iteration after every code path that pushes a record
+     * (success, parse error, agent throw, binding-resolve-failed,
+     * global-budget-cap, per-integration-budget-cap).
+     */
+    private emitSubSessionCompleted;
+    private createFanOutFetcherEvent;
+    private sliceIntegrationSnapshot;
+    private attemptRecordFromResult;
+    private failedAttemptRecord;
+    private budgetCapAttemptRecord;
+    private didExhaustRetries;
+    private backoffForAttempt;
+    /**
+     * Unified audit-row companion for every fan-out failure mode —
+     * binding-resolve-failed, global-budget-cap, budget-cap (per-integration),
+     * context-build-failed, and agent-execute-failed. Routes through
+     * `audit.logError` (writes `result='failed'`) with a `prePass` payload
+     * so `MetricsCollector.collectPrePassMetrics` can see every failure
+     * mode without a parallel `result='success'` row. Before this helper
+     * existed, the four pre-execute branches wrote nothing at all and the
+     * agent-execute path wrote a `failureKind`-only row that the aggregator
+     * silently skipped (it filters on `detail.prePass` being a non-null
+     * object). Cost / tokens are intentionally NOT supplied — pre-execute
+     * paths have zero cost, the agent-execute throw path has no usable
+     * AgentResult, so any figure here would be a guess; the aggregator
+     * coalesces missing `cost_usd` to 0.
+     */
+    private logFanOutFailure;
+    private logFanOutAttempt;
+    /**
+     * Helper for the failure paths — renders a `<fetch_report status="failed">`
+     * block and logs the underlying error. Never throws so the caller can
+     * always continue with the parent routine dispatch.
+     */
+    private fail;
+    /**
+     * Translate the mail registry's active-account list into the
+     * `AcquisitionAccount[]` shape `buildAcquisitionPlan` expects. Only
+     * accounts whose integration is currently non-disabled survive — a
+     * disabled gmail integration with five accounts produces zero rows,
+     * matching the partial's `<!-- mode:disabled:gmail -->` no-op.
+     */
+    private collectAccounts;
+}
+//# sourceMappingURL=routine-fetch-window-runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routine-fetch-window-runner.d.ts","sourceRoot":"","sources":["../../src/core/routine-fetch-window-runner.ts"],"names":[],"mappings":"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"}