@aitne/daemon 0.1.8 → 0.1.10

package/dist/core/wiki/multi-url-dispatch.js

@@ -54,19 +54,29 @@ export async function dispatchWikiUrlBatch(input) {
     }
     const cap = Math.max(1, Math.min(10, Math.floor(input.concurrencyCap)));
     let cursor = 0;
+    let aborted = false;
     async function worker() {
-        while (cursor < urls.length) {
+        while (!aborted && cursor < urls.length) {
             const url = urls[cursor++];
-            await input.enqueue(createWikiCommandEvent({
-                processKey: "wiki.ingest_url",
-                workspace: input.workspace,
-                sourceEvent: input.sourceEvent,
-                batchId,
-                data: { url },
-            }));
+            try {
+                await input.enqueue(createWikiCommandEvent({
+                    processKey: "wiki.ingest_url",
+                    workspace: input.workspace,
+                    sourceEvent: input.sourceEvent,
+                    batchId,
+                    data: { url },
+                }));
+            }
+            catch (err) {
+                // Honour the "abort the rest of the batch" contract: one failed
+                // enqueue stops sibling workers from claiming more URLs. Without
+                // this flag, Promise.all rejects fast but the other workers keep
+                // running, producing partial-then-unobserved enqueues.
+                aborted = true;
+                throw err;
+            }
         }
     }
     await Promise.all(Array.from({ length: Math.min(cap, urls.length) }, worker));
     return { batchId, queued: urls.length, mode: "parallel" };
 }
-//# sourceMappingURL=multi-url-dispatch.js.map

package/dist/core/wiki/wiki-fts.d.ts

@@ -72,4 +72,3 @@ export declare function backfillWikiFulltext(db: Database.Database, workspaces:
  * route module from a core helper (one-way dependency: routes → core).
  */
 export declare function classifyWikiPathForFts(relPath: string): WikiFtsLayer | null;
-//# sourceMappingURL=wiki-fts.d.ts.map

package/dist/core/wiki/wiki-fts.js

@@ -110,15 +110,22 @@ function extractTitleAndBody(content) {
     return { title, body };
 }
 function stripFrontmatter(content) {
-    if (!content.startsWith("---\n")) {
-        return { frontmatterKeys: {}, body: content };
+    // Obsidian vaults authored/synced on Windows (or checked out under
+    // git core.autocrlf=true) are CRLF. The frontmatter fence gate below is
+    // LF-only, so without this normalize a `---\r\n…---\r\n` block leaks into
+    // the indexed body and the title fallback never populates. Indexed
+    // body/title are search tokens only and never round-trip to disk, so
+    // collapsing interior CRLF to LF is harmless (LF input is unchanged).
+    const normalized = content.replace(/\r\n/g, "\n");
+    if (!normalized.startsWith("---\n")) {
+        return { frontmatterKeys: {}, body: normalized };
     }
-    const end = content.indexOf("\n---\n", 4);
+    const end = normalized.indexOf("\n---\n", 4);
     if (end < 0) {
-        return { frontmatterKeys: {}, body: content };
+        return { frontmatterKeys: {}, body: normalized };
     }
-    const frontmatter = content.slice(4, end);
-    const body = content.slice(end + 5);
+    const frontmatter = normalized.slice(4, end);
+    const body = normalized.slice(end + 5);
     const keys = {};
     for (const line of frontmatter.split("\n")) {
         const match = line.match(/^title:\s*(.*?)\s*$/);
@@ -262,4 +269,3 @@ export function classifyWikiPathForFts(relPath) {
             return null;
     }
 }
-//# sourceMappingURL=wiki-fts.js.map

package/dist/core/wiki/workspaces.d.ts

@@ -26,7 +26,23 @@ export interface WikiWorkspaceRow {
     created_at: string;
     updated_at: string;
 }
-export declare function defaultWikiRoot(dataDir: string): string;
+/**
+ * Fresh-install default root for internal wiki workspaces.
+ *
+ * CONTEXT_VAULT_REDESIGN_PLAN.md v4 V12 — the internal wiki workspace
+ * tree moves under the vault at `<contextDir>/knowledge/wiki/`. The
+ * vault-restructure migration moves any pre-existing internal
+ * workspaces and rewrites `wiki_workspaces.root_path` for them. Fresh
+ * installs land directly on the new layout via this helper.
+ *
+ * The function accepts an `AgentConfig` so it can resolve the runtime
+ * `contextDir` (which may live inside an external Obsidian vault when
+ * `vaultMode="obsidian"`). The legacy `defaultWikiRoot(dataDir)` shape
+ * is preserved for callers that haven't been migrated yet — it falls
+ * back to `<dataDir>/context/knowledge/wiki`, matching the canonical
+ * destination of pre-migration `<dataDir>/wiki/` content.
+ */
+export declare function defaultWikiRoot(configOrDataDir: AgentConfig | string): string;
 export declare function ensureDefaultWikiWorkspace(db: Database.Database, config: AgentConfig): WikiWorkspaceRow;
 /**
  * Create (or re-activate) an external-mode wiki workspace pointed at a
@@ -98,4 +114,3 @@ export interface WikiWorkspaceStats {
     lastCompileAt: string | null;
 }
 export declare function buildWikiWorkspaceStats(row: WikiWorkspaceRow): WikiWorkspaceStats;
-//# sourceMappingURL=workspaces.d.ts.map

package/dist/core/wiki/workspaces.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
-import { validatePrimaryVaultPath } from "../../config.js";
+import { getContextDir, validatePrimaryVaultPath } from "../../config.js";
 import { writeFileAtomically } from "../atomic-write.js";
 export const DEFAULT_WIKI_WORKSPACE_NAME = "default";
 export const DEFAULT_WIKI_SCHEMA_VERSION = 1;
@@ -56,28 +56,41 @@ const FALLBACK_SEEDS = {
         "",
     ].join("\n"),
 };
-export function defaultWikiRoot(dataDir) {
-    return resolve(dataDir, "wiki");
+/**
+ * Fresh-install default root for internal wiki workspaces.
+ *
+ * CONTEXT_VAULT_REDESIGN_PLAN.md v4 V12 — the internal wiki workspace
+ * tree moves under the vault at `<contextDir>/knowledge/wiki/`. The
+ * vault-restructure migration moves any pre-existing internal
+ * workspaces and rewrites `wiki_workspaces.root_path` for them. Fresh
+ * installs land directly on the new layout via this helper.
+ *
+ * The function accepts an `AgentConfig` so it can resolve the runtime
+ * `contextDir` (which may live inside an external Obsidian vault when
+ * `vaultMode="obsidian"`). The legacy `defaultWikiRoot(dataDir)` shape
+ * is preserved for callers that haven't been migrated yet — it falls
+ * back to `<dataDir>/context/knowledge/wiki`, matching the canonical
+ * destination of pre-migration `<dataDir>/wiki/` content.
+ */
+export function defaultWikiRoot(configOrDataDir) {
+    if (typeof configOrDataDir === "string") {
+        return resolve(configOrDataDir, "context", "knowledge", "wiki");
+    }
+    return resolve(getContextDir(configOrDataDir), "knowledge", "wiki");
 }
 export function ensureDefaultWikiWorkspace(db, config) {
-    const rootPath = defaultWikiRoot(config.dataDir);
+    const rootPath = defaultWikiRoot(config);
     // §P5.C — multi-workspace: check the named default specifically
     // rather than "first active workspace". With multiple active rows,
     // `readDefaultWikiWorkspace` returns the oldest active row by id,
     // which may not be the named default at all.
+    //
+    // If the row exists (in any state — including archived `active=0` or
+    // re-targeted to an external path) we leave it alone: the operator
+    // owns that state. Only insert when the row is genuinely missing.
     const existing = readWikiWorkspaceByName(db, DEFAULT_WIKI_WORKSPACE_NAME);
     if (!existing) {
-        const existingNamed = readWikiWorkspaceByName(db, DEFAULT_WIKI_WORKSPACE_NAME);
-        if (existingNamed) {
-            db.prepare(`UPDATE wiki_workspaces
-         SET active = 1,
-             kind = 'internal',
-             root_path = ?,
-             updated_at = CURRENT_TIMESTAMP
-         WHERE name = ?`).run(rootPath, DEFAULT_WIKI_WORKSPACE_NAME);
-        }
-        else {
-            db.prepare(`INSERT INTO wiki_workspaces (
+        db.prepare(`INSERT INTO wiki_workspaces (
          name,
          kind,
          root_path,
@@ -91,7 +104,6 @@ export function ensureDefaultWikiWorkspace(db, config) {
          active,
          updated_at
         ) VALUES (?, 'internal', ?, ?, 'parallel', 3, 0, 0, ?, ?, 1, CURRENT_TIMESTAMP)`).run(DEFAULT_WIKI_WORKSPACE_NAME, rootPath, DEFAULT_WIKI_LANGUAGE, DEFAULT_WIKI_FULL_COMPILE_APPROVAL_USD, DEFAULT_WIKI_SCHEMA_VERSION);
-        }
     }
     seedWikiWorkspaceFiles(rootPath, config.workspaceDir);
     return readWikiWorkspaceByName(db, DEFAULT_WIKI_WORKSPACE_NAME) ?? {
@@ -349,4 +361,3 @@ function writeIfMissing(path, content) {
     }
     writeFileAtomically(path, content.endsWith("\n") ? content : `${content}\n`);
 }
-//# sourceMappingURL=workspaces.js.map

package/dist/core/wiki/write-strategy.d.ts

@@ -67,4 +67,3 @@ export declare function probeWikiWriteStrategyHealth(workspace: WikiWorkspaceRow
  */
 export declare function resolveWikiPath(workspace: WikiWorkspaceRow, relPath: string): string;
 export declare function indexCachePathFor(workspace: WikiWorkspaceRow): string;
-//# sourceMappingURL=write-strategy.d.ts.map

package/dist/core/wiki/write-strategy.js

@@ -1,4 +1,4 @@
-import { dirname, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { writeFileAtomically } from "../atomic-write.js";
 const FALLBACK_ERROR_CODES = new Set(["EPERM", "EACCES", "EROFS", "EBUSY"]);
 export class WikiWriteStrategyResolver {
@@ -44,6 +44,10 @@ export class WikiWriteStrategyResolver {
             return { strategy: "fs", durationMs: Date.now() - start };
         }
         catch (err) {
+            // Errors thrown from atomic-write / fs always carry a `code`; the
+            // `?? ""` fallback is a defensive guard against future callers that
+            // throw a non-fs Error here. Unreachable from the public surface.
+            /* c8 ignore next */
             const code = err.code ?? "";
             if (!FALLBACK_ERROR_CODES.has(code))
                 throw err;
@@ -65,6 +69,12 @@ export class WikiWriteStrategyResolver {
         await this.deps.obsidian.updateNote(input.relPath, ensureTrailingNewline(input.content));
     }
     persistResolved(workspace, strategy) {
+        // Idempotent guard for concurrent auto-mode writes — the caller path
+        // enters this method only when `resolveStrategy` returned "auto",
+        // which by construction means `write_strategy === 'auto'` is the only
+        // pre-state. Hence `'auto' === ('fs'|'cli')` is always false here.
+        // Preserve the guard so two in-flight writes don't double-UPDATE.
+        /* c8 ignore next */
         if (workspace.write_strategy === strategy)
             return;
         this.deps.db
@@ -96,7 +106,14 @@ function ensureTrailingNewline(content) {
 }
 function ensureWithinRoot(root, fullPath) {
     const rel = relative(root, fullPath);
-    return !rel.startsWith("..") && !rel.startsWith("/");
+    // `relative()` returns an absolute path when the two paths are on
+    // different Windows drive letters (e.g. C:\ → D:\evil). The `..` and
+    // empty-string checks are not sufficient there — `isAbsolute` catches
+    // it across platforms. An empty `rel` means fullPath === root, which
+    // is a directory write and never a legal file target.
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel))
+        return false;
+    return true;
 }
 /**
  * Resolve the workspace-relative directory of a vault-local file. Exposed
@@ -109,4 +126,3 @@ export function resolveWikiPath(workspace, relPath) {
 export function indexCachePathFor(workspace) {
     return dirname(resolveWikiPath(workspace, "20_wiki/_index.md"));
 }
-//# sourceMappingURL=write-strategy.js.map

package/dist/core/workdir.d.ts

@@ -93,6 +93,14 @@ export declare function createSessionWorkdir(projectRoot: string, eventType: str
     /** Inbound DM message text for the *ForDm trigger-phrase fallback.
      *  Undefined / null for routine and scheduled events. */
     messageText?: string | null;
+    /** AGENT_DEFINITIONS_DESIGN.md §4.2 — the firing Agent's `tools.skills`,
+     *  composed onto the process-key bundle by `materializeSessionBundle`
+     *  (union, or replace when `skillsReplace`). Empty/undefined is a no-op.
+     *  This disposable path is the ONLY one that carries the override —
+     *  every Agent firing runs in a fresh temp dir created here. */
+    extraSkills?: readonly string[];
+    /** AGENT_DEFINITIONS_DESIGN.md §4.2 — `tools.skills_replace`. */
+    skillsReplace?: boolean;
 }): string;
 export declare function ensureSessionWorkdir(projectRoot: string, dataDir: string, dbSessionId: number, eventType: string, options?: {
     backendId?: BackendId;
@@ -163,7 +171,7 @@ export declare function cleanupStaleWorkdirs(dataDir: string, activeSessionIds:
  * pass `getContextDir(config, db)` — without it, a fallback re-materialize
  * for evening_review evaluates the gate as "rulebook inactive" and drops
  * `notify` from the fallback backend's manifest even when the operator's
- * `routines/evening.md` is active, breaking the contract that the
+ * `policies/routines/evening.md` is active, breaking the contract that the
  * fallback backend behaves identically to the main one
  * (`evening-review-slimdown.md` §3.5).
  */
@@ -274,4 +282,3 @@ export declare function buildConfiguredServices(config: {
     calendar?: unknown;
     github?: unknown;
 }): Set<string>;
-//# sourceMappingURL=workdir.d.ts.map

package/dist/core/workdir.js

@@ -22,7 +22,9 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { DASHBOARD_CHAT_SCOPE, OWNER_DM_SCOPE, } from "../messaging/constants.js";
 import { createLogger } from "../logging.js";
-import { SkillsCompiler, renderMailAccountsMd, refreshSkillIndexBlock, EMPTY_MAIL_ACCOUNTS_MD, } from "./skills-compiler.js";
+import { SkillsCompiler } from "./skills-compiler.js";
+import { EMPTY_MAIL_ACCOUNTS_MD, renderMailAccountsMd, } from "./skills-compiler-tree.js";
+import { refreshSkillIndexBlock } from "./skills-compiler-skill-index.js";
 import { getProfileForEvent, resolveSkillManifest, resolveSkillManifestForProcess, } from "./skills-manifest.js";
 import { ensureDaemonApiCli } from "./daemon-api-cli.js";
 import { computeInstructionAssetStatus, readInstructionStampManifest, sessionInstructionAssetsStale, writeInstructionAssetStamp, } from "./release-assets.js";
@@ -237,6 +239,10 @@ export function createSessionWorkdir(projectRoot, eventType, userSkillsDir, opti
             ...(options?.contextDir ? { contextDir: options.contextDir } : {}),
             ...(options?.db !== undefined ? { db: options.db } : {}),
             ...(options?.messageText !== undefined ? { messageText: options.messageText } : {}),
+            ...(options?.extraSkills && options.extraSkills.length > 0
+                ? { extraSkills: options.extraSkills }
+                : {}),
+            ...(options?.skillsReplace ? { skillsReplace: true } : {}),
         });
         writeInstructionAssetStamp(sessionDir, computeInstructionAssetStatus(projectRoot), 
         // docs/design/appendices/skills-unification.md Phase 1 item 14 — record the manifest
@@ -331,6 +337,11 @@ function resolveManifestDriftAgainstStamp(sessionDir, eventType, options) {
         ...(options?.messageText !== undefined ? { messageText: options.messageText } : {}),
     };
     const hasManifestOpts = Object.keys(manifestOpts).length > 0;
+    // Agent `tools.skills` overrides are NOT composed here: they only ever ride
+    // the disposable `createSessionWorkdir` path (one fresh temp dir per Agent
+    // firing, never re-checked for drift). The persistent `ensureSessionWorkdir`
+    // path — DMs / resumable Opus sessions — is never an Agent firing, so its
+    // stamp never carries an extra-skill set and the live resolve below matches.
     const liveSlugs = options?.processKey
         ? resolveSkillManifestForProcess(options.processKey, hasManifestOpts ? manifestOpts : undefined)
         : resolveSkillManifest(eventType, hasManifestOpts ? manifestOpts : undefined);
@@ -400,7 +411,14 @@ export function ensureSessionWorkdir(projectRoot, dataDir, dbSessionId, eventTyp
         ensureDaemonApiCli(sessionDir);
         // User-authored skills — initial population via the manifest-backed sync
         // so subsequent mid-session calls (from dispatcher) share the same state.
-        const userSkillsDir = join(dataDir, "skills");
+        // CONTEXT_VAULT_REDESIGN_PLAN.md v4 V11 — user skills root moved to
+        // `<contextDir>/policies/skills`. We derive from `options.contextDir`
+        // when the caller provides it; otherwise fall back to the default
+        // `<dataDir>/context/policies/skills` (matches `getContextDir`'s plain
+        // vault-mode default). The legacy `<dataDir>/skills` path is dead post
+        // CONTEXT_VAULT_REDESIGN — falling back there would resurrect the
+        // Obsidian-mode divergence bug v4 V11 fixed.
+        const userSkillsDir = join(options?.contextDir ?? join(dataDir, "context"), "policies", "skills");
         const userSync = syncAllUserSkills(sessionDir, userSkillsDir);
         // docs/design/appendices/skills-unification.md Phase 1 §R4 — fold user-authored slugs
         // into the `<skill-index>` block now that they're on disk. Idempotent
@@ -556,7 +574,7 @@ export function cleanupStaleWorkdirs(dataDir, activeSessionIds) {
  * pass `getContextDir(config, db)` — without it, a fallback re-materialize
  * for evening_review evaluates the gate as "rulebook inactive" and drops
  * `notify` from the fallback backend's manifest even when the operator's
- * `routines/evening.md` is active, breaking the contract that the
+ * `policies/routines/evening.md` is active, breaking the contract that the
  * fallback backend behaves identically to the main one
  * (`evening-review-slimdown.md` §3.5).
  */
@@ -690,4 +708,3 @@ export function buildConfiguredServices(config, serviceAvailability) {
     }
     return services;
 }
-//# sourceMappingURL=workdir.js.map

package/dist/db/agent-executions-store.d.ts

@@ -0,0 +1,149 @@
+import type Database from "better-sqlite3";
+/**
+ * Agent executions store — the per-firing rollup layer
+ * (AGENT_DEFINITIONS_DESIGN.md §5.2 / §7.4). One row per fired Execution:
+ * inserted at start (`result = NULL`), updated at completion, and force-closed
+ * by the boot-time janitor if a crash leaves it non-terminal.
+ *
+ * This module is the persistence layer the Phase-6 recorder
+ * (`core/agent-execution-recorder.ts`) wraps — the recorder owns agent-day
+ * stamping and the same-transaction `agents.last_execution_id` update; this
+ * store owns the raw `agent_executions` SQL.
+ *
+ * Timestamps (`started_at` / `ended_at`) are epoch-millisecond integers, so
+ * the metrics windows are plain `now - days * 86_400_000` cutoffs and the
+ * crash janitor compares against `daemon_boot_time` directly (§5.1 note).
+ */
+export type AgentExecutionTrigger = "cron" | "manual" | "event" | "self";
+export type AgentExecutionResult = "success" | "error" | "skipped" | "timeout";
+/** Raw row as stored in SQLite. */
+export interface AgentExecutionRow {
+    id: number;
+    agent_id: string;
+    schedule_row_id: number | null;
+    trigger: AgentExecutionTrigger;
+    started_at: number;
+    ended_at: number | null;
+    result: AgentExecutionResult | null;
+    error_kind: string | null;
+    error_message: string | null;
+    cost_usd: number | null;
+    tokens_input: number | null;
+    tokens_output: number | null;
+    turns: number | null;
+    success_criteria_json: string | null;
+    output_summary: string | null;
+    metadata_json: string;
+}
+/** Parsed, camelCase view returned to callers. */
+export interface AgentExecutionDTO {
+    id: number;
+    agentId: string;
+    scheduleRowId: number | null;
+    trigger: AgentExecutionTrigger;
+    startedAt: number;
+    endedAt: number | null;
+    result: AgentExecutionResult | null;
+    errorKind: string | null;
+    errorMessage: string | null;
+    costUsd: number | null;
+    tokensInput: number | null;
+    tokensOutput: number | null;
+    turns: number | null;
+    /** Per-criterion hit map; `null` until the criteria are evaluated. */
+    successCriteria: Record<string, boolean> | null;
+    outputSummary: string | null;
+}
+export interface StartExecutionInput {
+    agentId: string;
+    scheduleRowId?: number | null;
+    trigger: AgentExecutionTrigger;
+}
+export interface ExecutionCost {
+    usd?: number | null;
+    tokensIn?: number | null;
+    tokensOut?: number | null;
+    turns?: number | null;
+}
+export interface CompleteExecutionInput {
+    executionId: number;
+    result: AgentExecutionResult;
+    errorKind?: string | null;
+    errorMessage?: string | null;
+    cost?: ExecutionCost;
+    successCriteriaHits?: Record<string, boolean>;
+    outputSummary?: string | null;
+}
+export interface ListExecutionsOptions {
+    /** Max rows (default 25). */
+    limit?: number;
+    /** Keyset cursor — return rows with `id < before`. */
+    before?: number;
+    /** Filter by terminal result. */
+    result?: AgentExecutionResult;
+}
+/** Per-window metrics (§9.1 / §9.2). */
+export interface AgentMetricsWindow {
+    /** Rows fired in the window (any result, incl. in-flight). */
+    executions: number;
+    /** errors / terminal rows; 0 when there are no terminal rows. */
+    errorRate: number;
+    /** Mean `cost_usd` over rows that recorded one; null when none did. */
+    avgCostUsd: number | null;
+    /** Σtrue / Σtotal across recorded criteria maps; null when none recorded. */
+    criteriaHitRate: number | null;
+    /**
+     * p95 of (ended-started)/1000 over completed rows; null when none.
+     * Crash-swept rows (`error_kind = 'crash'`) are EXCLUDED: their `ended_at`
+     * is the daemon's boot instant stamped by `sweepAbandoned`, not the real
+     * runtime, so a long daemon outage would otherwise inflate the percentile
+     * with a fictional multi-hour/day "duration". They still count toward
+     * `errorRate` (they are genuine failures) — only the duration sample drops
+     * them.
+     */
+    p95DurationSeconds: number | null;
+}
+export interface SweepAbandonedResult {
+    count: number;
+    ids: number[];
+}
+/**
+ * Insert a new in-flight Execution (`result = NULL`). Returns the new id.
+ * The `agent_id` FK requires the Agent row to already exist — the recorder
+ * always upserts the Agent first.
+ */
+export declare function startExecution(db: Database.Database, input: StartExecutionInput, now?: number): number;
+/**
+ * Finalise an Execution row with its result, cost, criteria, and summary.
+ * Returns true when a row matched the id. Does NOT touch
+ * `agents.last_execution_id` — the recorder pairs this with
+ * `agents-store.setLastExecutionId` in one transaction (§8.2).
+ */
+export declare function completeExecution(db: Database.Database, input: CompleteExecutionInput, now?: number): boolean;
+/**
+ * Boot-time crash janitor (§7.4). Flips every still-in-flight row whose
+ * `started_at` predates `beforeTs` (the daemon boot instant) to
+ * `error / crash`, stamping `ended_at = now`. Returns the affected ids so the
+ * caller can surface an audit line. Idempotent: a second call finds nothing
+ * left non-terminal.
+ */
+export declare function sweepAbandoned(db: Database.Database, beforeTs: number, now?: number): SweepAbandonedResult;
+export declare function getExecution(db: Database.Database, id: number): AgentExecutionDTO | null;
+/**
+ * Paginated execution history for one Agent, newest first (§9.3). `before` is
+ * a keyset cursor on `id`; `result` filters by terminal state.
+ */
+export declare function listExecutions(db: Database.Database, agentId: string, opts?: ListExecutionsOptions): AgentExecutionDTO[];
+/**
+ * Rollup metrics over the trailing `days` window (§9.1 / §9.2). All derived
+ * fields are computed in JS over a single `(agent_id, started_at DESC)` index
+ * scan so the math (error_rate, avg_cost, criteria_hit_rate, p95) stays
+ * unit-testable without SQL fixtures.
+ */
+export declare function metricsWindow(db: Database.Database, agentId: string, days: number, now?: number): AgentMetricsWindow;
+/**
+ * Count of error executions grouped by `error_kind` over the trailing `days`
+ * window (§9.2 `by_error_kind_7d`). A NULL `error_kind` is bucketed as
+ * `"unknown"`.
+ */
+export declare function byErrorKind(db: Database.Database, agentId: string, days: number, now?: number): Record<string, number>;