@aitne/daemon 0.1.8 → 0.1.9

package/dist/bootstrap/managed-chromium.js

@@ -0,0 +1,66 @@
+/**
+ * Boot-time wiring for the managed Chromium supervisor.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §7.1.
+ *
+ * - Reads the persisted `enabled` flag from runtime_state.
+ * - Resolves the host's sandbox primitive + Chromium binary.
+ * - Registers `ManagedChromiumSupervisor` with the daemon's
+ *   ObserverManager so it ticks alongside the other observers.
+ *
+ * Idempotent: if managed mode is disabled, this is a no-op. If enabled
+ * but the binary or sandbox is unavailable, the supervisor still
+ * registers (so the dashboard can surface the diagnostic) and writes
+ * the appropriate state-machine value into runtime_state.
+ */
+import { createLogger } from "../logging.js";
+import { readManagedChromiumState, updateManagedChromiumState, } from "../db/managed-chromium-state.js";
+import { createHostProfile } from "../services/browser-history/lifecycle/platform.js";
+import { ManagedChromiumSupervisor } from "../services/browser-history/managed-chromium/managed-chromium-supervisor.js";
+const logger = createLogger("bootstrap-managed-chromium");
+export async function maybeRegisterManagedChromium(deps) {
+    const state = readManagedChromiumState(deps.db);
+    if (!state.enabled) {
+        logger.info("managed Chromium disabled; supervisor not registered");
+        return;
+    }
+    const host = createHostProfile();
+    // Pre-flight: re-evaluate infra readiness on every boot so the state
+    // machine recovers from a prior `missing_binary` / `missing_sandbox`
+    // automatically (e.g. operator installed Chromium / bwrap between
+    // boots). Persisted `state` is allowed to advance freely between
+    // diagnostic states; transitions out of `ready` / `needs_reauth` only
+    // happen when the infra actually regressed.
+    const hasBinary = host.browserBinaryFor("chromium") !== null;
+    const hasSandbox = host.sandboxPrimitive.kind !== "none" || state.unsandboxedOptIn;
+    updateManagedChromiumState(deps.db, (draft) => {
+        if (!hasBinary) {
+            draft.state = "missing_binary";
+        }
+        else if (!hasSandbox) {
+            draft.state = "missing_sandbox";
+        }
+        else if (draft.state === "off"
+            || draft.state === "disconnected"
+            || draft.state === "missing_binary"
+            || draft.state === "missing_sandbox") {
+            // Infra is satisfied AND prior state was a diagnostic dead-end —
+            // graduate to needs_setup so the dashboard prompts the user. If
+            // the profile dir actually already contains a signed-in session,
+            // the supervisor's first tick will resolve to `ready` via the
+            // reauth-detector's healthy branch.
+            draft.state = "needs_setup";
+        }
+    });
+    const supervisor = new ManagedChromiumSupervisor({
+        db: deps.db,
+        paDataDir: deps.config.dataDir,
+        host,
+        messageHub: deps.messageHub,
+    });
+    deps.observerManager.register(supervisor);
+    logger.info({
+        sandboxKind: host.sandboxPrimitive.kind,
+        binaryFound: host.browserBinaryFor("chromium") !== null,
+    }, "managed Chromium supervisor registered");
+}

package/dist/bootstrap/observers.d.ts

@@ -145,4 +145,3 @@ export interface BootstrapObserversResult {
  * `scanAndRecordOrphanOverlays`, `McpAutoProbe`).
  */
 export declare function createObservers(deps: BootstrapObserversDeps): Promise<BootstrapObserversResult>;
-//# sourceMappingURL=observers.d.ts.map

package/dist/bootstrap/observers.js

@@ -79,6 +79,9 @@ import { ImminentEventScheduler } from "../observers/imminent-event-scheduler.js
 import { NotionPoller } from "../observers/notion-poller.js";
 import { MailPoller } from "../observers/mail-poller.js";
 import { MailReconciliationJob } from "../observers/mail-reconciliation.js";
+import { BrowserHistoryPoller } from "../observers/browser-history-poller.js";
+import { BrowserLifecycleSupervisor } from "../services/browser-history/lifecycle/supervisor.js";
+import { maybeRegisterManagedChromium } from "./managed-chromium.js";
 import { createLogger } from "../logging.js";
 const logger = createLogger("daemon-bootstrap-observers");
 /**
@@ -410,6 +413,32 @@ export async function createObservers(deps) {
             db,
         }));
     }
+    observerManager.register(new BrowserLifecycleSupervisor(db, config));
+    // MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §7.1 — managed Chromium
+    // supervisor. Registered as a sibling Observer; the boot helper
+    // pre-flights binary + sandbox availability and writes the
+    // diagnostic state-machine value before the supervisor's first tick
+    // so the dashboard surfaces "missing_binary" / "missing_sandbox"
+    // immediately. No-op when the master toggle (runtime_state) is off.
+    await maybeRegisterManagedChromium({
+        db,
+        config,
+        observerManager,
+        messageHub,
+    });
+    if (shouldStartObserversFor(db, "browser_history")) {
+        observerManager.register(new BrowserHistoryPoller(db, config, {
+            // BROWSER_HISTORY_INTEGRATION_PLAN §5.F1 (seventh-pass) —
+            // poller enqueues `routine.research_offer_dm` events instead
+            // of sending templated DMs. The lite-tier agent session
+            // composes the natural-language two-option DM from the
+            // OfferContext payload and dispatches via the standard
+            // notifier path.
+            enqueueEvent: async (event) => {
+                await eventBus.put(event);
+            },
+        }));
+    }
     // ── 7.04 Skill-curation observers (P22 — appendix p22-skill-self-optimization.md) ──
     // Hourly walker accumulates `structure_diff` signals for the curation
     // cohort. Outcomes/feedback collection was dropped from the Preview
@@ -555,4 +584,3 @@ export async function createObservers(deps) {
         setPromptContextChangedSink,
     };
 }
-//# sourceMappingURL=observers.js.map

package/dist/bootstrap/schedule-helpers.d.ts

@@ -137,4 +137,3 @@ export declare function getStalledMorningRoutineWake(db: Database.Database, agen
     dayBoundaryHour: number;
 }, thresholdMinutes: number, now?: Date): StalledMorningRoutineWake | null;
 export declare function readSkillCurationCadence(db: Database.Database): "daily" | "weekly" | "monthly";
-//# sourceMappingURL=schedule-helpers.d.ts.map

package/dist/bootstrap/schedule-helpers.js

@@ -138,7 +138,10 @@ export function hasFreshAgentDayTodayMd(todayMdPath, timezone, dayBoundaryHour,
     if (!existsSync(todayMdPath)) {
         return false;
     }
-    const firstLine = readFileSync(todayMdPath, "utf-8").split("\n")[0] ?? "";
+    // `String.split` always returns a non-empty array, so index 0 is
+    // defined for any contents — including the empty string. A `?? ""`
+    // fallback would be dead defensive code.
+    const firstLine = readFileSync(todayMdPath, "utf-8").split("\n")[0];
     const today = getAgentDayDateStr(timezone, dayBoundaryHour, now);
     return firstLine.includes(today);
 }
@@ -291,4 +294,3 @@ export function readSkillCurationCadence(db) {
         return "weekly";
     }
 }
-//# sourceMappingURL=schedule-helpers.js.map

package/dist/bootstrap/services.d.ts

@@ -57,4 +57,3 @@ export interface ServiceReloaders {
     reloadGitHubService(): Promise<void>;
 }
 export declare function createServiceReloaders(deps: BootstrapServiceDeps): ServiceReloaders;
-//# sourceMappingURL=services.d.ts.map

package/dist/bootstrap/services.js

@@ -187,16 +187,7 @@ export function createServiceReloaders(deps) {
         if (!token) {
             return;
         }
-        const githubService = new GitHubService(token, webhookSecret);
-        try {
-            await githubService.init();
-            services.github = githubService;
-        }
-        catch (err) {
-            const msg = err.message;
-            logger.error({ error: msg }, "GitHub service init failed, continuing without it");
-            services.errors.github = msg;
-        }
+        services.github = new GitHubService(token, webhookSecret);
     }
     return {
         refreshGoogleSecretState,
@@ -206,4 +197,3 @@ export function createServiceReloaders(deps) {
         reloadGitHubService,
     };
 }
-//# sourceMappingURL=services.js.map

package/dist/config.d.ts

@@ -117,7 +117,7 @@ export declare function validateExternalObsidianVaultPath(rawPath: string, confi
  * vault must also contain at least one canonical context marker so the
  * daemon does not resume writes into an empty or wrong directory.
  *
- * Bootstrapping bypass: if `rules/management.md` doesn't exist yet, setup
+ * Bootstrapping bypass: if `policies/management.md` doesn't exist yet, setup
  * hasn't run; honoring a null primaryVaultPath would break the initial-DM
  * setup flow (which writes via `/api/context/*`, gated by the 503
  * middleware). Skip degraded-mode entirely until setup completes. This
@@ -133,4 +133,3 @@ export declare function getDbPath(config: Pick<BootstrapConfig, "dataDir">): str
 export declare function getLogsDir(config: Pick<BootstrapConfig, "dataDir">): string;
 export declare function getTmpDir(config: Pick<BootstrapConfig, "dataDir">): string;
 export {};
-//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -3,7 +3,7 @@ import { config as loadDotenv } from "dotenv";
 import { basename, dirname, isAbsolute, normalize, parse, resolve } from "node:path";
 import { homedir } from "node:os";
 import { accessSync, constants as fsConstants, existsSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
-import { DEFAULT_AGENT_DISPLAY_NAME, normalizeAgentDisplayName, } from "@aitne/shared";
+import { DEFAULT_AGENT_DISPLAY_NAME, DEFAULT_API_PORT, normalizeAgentDisplayName, } from "@aitne/shared";
 import { RUNTIME_SETTING_KEYS, runtimeSettingsSchema, } from "./settings/runtime-settings.js";
 import { clearDegradedMode, getDegradedMode, isDegraded, isSetupCompleted, markSetupCompleted, setDegradedMode, } from "./db/runtime-state.js";
 import { CONTEXT_RELATIVE_PATHS } from "./core/context-paths.js";
@@ -18,7 +18,7 @@ function envOrDefault(key, defaultValue) {
 const bootstrapConfigSchema = z.object({
     dataDir: z.string().default("~/.personal-agent"),
     workspaceDir: z.string().default("."),
-    apiPort: z.number().int().positive().default(8321),
+    apiPort: z.number().int().positive().default(DEFAULT_API_PORT),
 });
 function expandHome(p) {
     if (p.startsWith("~/") || p.startsWith("~\\")) {
@@ -84,7 +84,7 @@ export function loadBootstrapConfig() {
     const config = bootstrapConfigSchema.parse({
         dataDir: envOrDefault("DATA_DIR", "~/.personal-agent"),
         workspaceDir: envOrDefault("WORKSPACE_DIR", "."),
-        apiPort: parseNumberOrDefault(env("API_PORT"), 8321),
+        apiPort: parseNumberOrDefault(env("API_PORT"), DEFAULT_API_PORT),
     });
     return {
         ...config,
@@ -618,7 +618,7 @@ function hasPrimaryVaultSchemaMarkers(primaryVaultPath) {
  * vault must also contain at least one canonical context marker so the
  * daemon does not resume writes into an empty or wrong directory.
  *
- * Bootstrapping bypass: if `rules/management.md` doesn't exist yet, setup
+ * Bootstrapping bypass: if `policies/management.md` doesn't exist yet, setup
  * hasn't run; honoring a null primaryVaultPath would break the initial-DM
  * setup flow (which writes via `/api/context/*`, gated by the 503
  * middleware). Skip degraded-mode entirely until setup completes. This
@@ -643,7 +643,7 @@ export function runVaultHealthProbe(config, db) {
     // disable degraded mode when the user most needs the banner.
     //
     // Second priority: if setup has never been marked complete, probe the
-    // filesystem. Setup is considered complete once `rules/management.md`
+    // filesystem. Setup is considered complete once `policies/management.md`
     // lands anywhere the user could plausibly have pointed their vault at:
     //   - the fallback (`<dataDir>/context`): fresh-install setup with
     //     null primaryVaultPath writes here
@@ -653,9 +653,10 @@ export function runVaultHealthProbe(config, db) {
     // forcing degraded on them would 503 the DM-driven setup flow before
     // they can configure anything.
     if (!isSetupCompleted(db)) {
-        const fallbackRulesPath = resolve(config.dataDir, "context", "rules", "management.md");
+        // CONTEXT_VAULT_REDESIGN: management.md lives under policies/.
+        const fallbackRulesPath = resolve(config.dataDir, "context", "policies", "management.md");
         const primaryRulesPath = config.primaryVaultPath
-            ? resolve(config.primaryVaultPath, "rules", "management.md")
+            ? resolve(config.primaryVaultPath, "policies", "management.md")
             : null;
         const setupIncomplete = !existsSync(fallbackRulesPath) &&
             (primaryRulesPath === null || !existsSync(primaryRulesPath));
@@ -666,9 +667,9 @@ export function runVaultHealthProbe(config, db) {
             }
             return { action: "noop" };
         }
-        // rules/management.md exists now — latch the marker so subsequent
-        // probes skip the filesystem check and treat any unreachability as
-        // genuine degradation.
+        // policies/management.md exists now — latch the marker so
+        // subsequent probes skip the filesystem check and treat any
+        // unreachability as genuine degradation.
         markSetupCompleted(db);
     }
     const currentState = getDegradedMode(db);
@@ -720,7 +721,7 @@ export function runVaultHealthProbe(config, db) {
     return { action: "noop" };
 }
 export function isRoadmapStale(contextDir, maxAgeDays = 15) {
-    const roadmapPath = resolve(contextDir, "roadmap.md");
+    const roadmapPath = resolve(contextDir, "plans", "roadmap.md");
     if (!existsSync(roadmapPath))
         return true;
     const content = readFileSync(roadmapPath, "utf-8");
@@ -739,4 +740,3 @@ export function getLogsDir(config) {
 export function getTmpDir(config) {
     return resolve(config.dataDir, "tmp");
 }
-//# sourceMappingURL=config.js.map

package/dist/core/abort-utils.d.ts

@@ -11,4 +11,3 @@
  * and unblock the next tick.
  */
 export declare function raceWithAbort<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;
-//# sourceMappingURL=abort-utils.d.ts.map

package/dist/core/abort-utils.js

@@ -33,4 +33,3 @@ function toAbortError(reason) {
         return reason;
     return new Error(typeof reason === "string" && reason.length > 0 ? reason : "aborted");
 }
-//# sourceMappingURL=abort-utils.js.map

package/dist/core/agent-core.d.ts

@@ -104,6 +104,20 @@ export interface AgentExecuteParams {
      *   - Allow-mode backends ignore the flag (external HTTP already works).
      */
     wikiUrlFetchEnabled?: boolean;
+    /**
+     * AGENT_DEFINITIONS_DESIGN.md §4.2 — the firing Agent's `tools.skills`.
+     * The dispatcher resolves these from the Agent's effective definition and
+     * the core forwards them into `createSessionWorkdir`, where
+     * `composeSkillSet` folds them onto the process-key default bundle (union,
+     * or replace when `skillsReplace` is set). Empty / undefined is a no-op, so
+     * non-Agent executes (DMs, built-in routines, managed tasks) are unaffected.
+     *
+     * Forwarded verbatim on both the main and fallback execute paths so an
+     * Agent's added skills survive a Claude → Codex fallback.
+     */
+    extraSkills?: readonly string[];
+    /** AGENT_DEFINITIONS_DESIGN.md §4.2 — `tools.skills_replace`. See `extraSkills`. */
+    skillsReplace?: boolean;
 }
 export interface AgentResumeParams {
     sessionId: string;
@@ -558,4 +572,3 @@ export declare class BackendDecisiveFailure extends Error {
     readonly cause: unknown;
     constructor(backendId: BackendId, kind: "quota" | "auth" | "max_turns" | "timeout" | "model_unavailable" | "policy_denied" | "other_non_retryable", cause: unknown);
 }
-//# sourceMappingURL=agent-core.d.ts.map

package/dist/core/agent-core.js

@@ -101,4 +101,3 @@ export class BackendDecisiveFailure extends Error {
         this.name = "BackendDecisiveFailure";
     }
 }
-//# sourceMappingURL=agent-core.js.map

package/dist/core/agent-execution-recorder.d.ts

@@ -0,0 +1,78 @@
+import type Database from "better-sqlite3";
+import { type CompleteExecutionInput, type StartExecutionInput, type SweepAbandonedResult } from "../db/agent-executions-store.js";
+/**
+ * Per-firing execution recorder (AGENT_DEFINITIONS_DESIGN.md §8.2 / §7.4).
+ *
+ * A thin lifecycle wrapper over the Phase-2 `agent-executions-store.ts` (which
+ * owns the raw `agent_executions` SQL). The store is a faithful column writer
+ * and intentionally does NOT know about two things the recorder adds:
+ *
+ *   1. **The agent-day `{date}` label**, computed once at `start` and pinned to
+ *      the execution's `started_at` instant. Pinning at start (not at eval
+ *      time) matters: a long routine that begins at 03:55 and finishes at 04:05
+ *      must still evaluate its `{date}`-keyed criteria against the agent-day it
+ *      *started* in, not the one the 04:00 boundary rolled into mid-run. The
+ *      label is returned in the `StartedExecution` handle and threaded into
+ *      success-criteria evaluation by the dispatcher (§8.3) — it is derivable
+ *      from `started_at` so it is intentionally not persisted.
+ *   2. **The same-transaction `agents.last_execution_id` update** at `complete`,
+ *      so a dashboard read can never observe a finished execution whose owning
+ *      Agent still points at the previous run.
+ *
+ * Synchronous by design: better-sqlite3 is synchronous and every store function
+ * is too, so the original Promise-returning design sketch was an artifact (the
+ * design doc §8.2 was reconciled to the shipped sync interface).
+ */
+/** Constructor dependencies. `now`/`timezone` are injectable for tests. */
+export interface AgentExecutionRecorderDeps {
+    db: Database.Database;
+    /** IANA zone (config.timezone). `undefined` → host system zone. */
+    timezone?: string;
+    /** Agent-day boundary hour (config.dayBoundaryHour; 4 in production). */
+    dayBoundaryHour: number;
+    /** Epoch-ms clock; defaults to `Date.now`. */
+    now?: () => number;
+}
+/**
+ * Handle returned by `start`. The dispatcher holds it for the run's duration and
+ * threads `dateStr` / `startedAt` (with the resolved `agentId`) into the
+ * success-criteria evaluator at completion (§8.3).
+ */
+export interface StartedExecution {
+    /** New `agent_executions.id`. */
+    executionId: number;
+    /** Epoch-ms start instant — identical to the persisted `started_at`. */
+    startedAt: number;
+    /** Agent-day `YYYY-MM-DD` label pinned to `startedAt`, reused per criterion. */
+    dateStr: string;
+}
+export declare class AgentExecutionRecorder {
+    private readonly db;
+    private readonly timezone?;
+    private readonly dayBoundaryHour;
+    private readonly now;
+    constructor(deps: AgentExecutionRecorderDeps);
+    /**
+     * Open a new in-flight execution: INSERT a row with `result = NULL` and
+     * compute the agent-day label once. The `agent_id` FK requires the Agent row
+     * to already exist (the loader upserts it at boot / the API at create-time).
+     */
+    start(input: StartExecutionInput): StartedExecution;
+    /**
+     * Finalise an execution and re-point `agents.last_execution_id` at it, both
+     * inside a single transaction (§7.4). The owning slug is read back from the
+     * just-updated row — the FK is the single source of truth, so the caller
+     * cannot mis-attribute the pointer. `last_execution_id` is updated for every
+     * terminal result (success, error, timeout, skipped) so the dashboard's
+     * "last run" reflects failures too. Returns false when no row matched the id
+     * (nothing is updated in that case).
+     */
+    complete(input: CompleteExecutionInput): boolean;
+    /**
+     * Boot-time crash janitor (§7.4): flip every still-in-flight row started
+     * before `beforeTs` (the daemon boot instant) to `error / crash`. Delegates
+     * to the store so the recorder is the single start/complete/sweep lifecycle
+     * surface the daemon wires (Phase 7 `bootstrap/db.ts`).
+     */
+    sweepAbandoned(beforeTs: number): SweepAbandonedResult;
+}

package/dist/core/agent-execution-recorder.js

@@ -0,0 +1,60 @@
+import { getAgentDayDateStr } from "@aitne/shared";
+import { completeExecution, getExecution, startExecution, sweepAbandoned as sweepAbandonedRows, } from "../db/agent-executions-store.js";
+import { disableOneShotAfterFire, setLastExecutionId } from "../db/agents-store.js";
+export class AgentExecutionRecorder {
+    db;
+    timezone;
+    dayBoundaryHour;
+    now;
+    constructor(deps) {
+        this.db = deps.db;
+        this.timezone = deps.timezone;
+        this.dayBoundaryHour = deps.dayBoundaryHour;
+        this.now = deps.now ?? Date.now;
+    }
+    /**
+     * Open a new in-flight execution: INSERT a row with `result = NULL` and
+     * compute the agent-day label once. The `agent_id` FK requires the Agent row
+     * to already exist (the loader upserts it at boot / the API at create-time).
+     */
+    start(input) {
+        const startedAt = this.now();
+        const executionId = startExecution(this.db, input, startedAt);
+        const dateStr = getAgentDayDateStr(this.timezone, this.dayBoundaryHour, new Date(startedAt));
+        return { executionId, startedAt, dateStr };
+    }
+    /**
+     * Finalise an execution and re-point `agents.last_execution_id` at it, both
+     * inside a single transaction (§7.4). The owning slug is read back from the
+     * just-updated row — the FK is the single source of truth, so the caller
+     * cannot mis-attribute the pointer. `last_execution_id` is updated for every
+     * terminal result (success, error, timeout, skipped) so the dashboard's
+     * "last run" reflects failures too. Returns false when no row matched the id
+     * (nothing is updated in that case).
+     */
+    complete(input) {
+        const stamp = this.now();
+        const apply = this.db.transaction(() => {
+            const changed = completeExecution(this.db, input, stamp);
+            if (!changed)
+                return false;
+            // changed === true ⇒ the UPDATE matched, so the row is present.
+            const row = getExecution(this.db, input.executionId);
+            setLastExecutionId(this.db, row.agentId, input.executionId, stamp);
+            // §16 Q8: a one_shot Agent disables itself once it has fired, becoming a
+            // re-runnable record (run-now re-fires it). No-op for cron / event Agents.
+            disableOneShotAfterFire(this.db, row.agentId, stamp);
+            return true;
+        });
+        return apply();
+    }
+    /**
+     * Boot-time crash janitor (§7.4): flip every still-in-flight row started
+     * before `beforeTs` (the daemon boot instant) to `error / crash`. Delegates
+     * to the store so the recorder is the single start/complete/sweep lifecycle
+     * surface the daemon wires (Phase 7 `bootstrap/db.ts`).
+     */
+    sweepAbandoned(beforeTs) {
+        return sweepAbandonedRows(this.db, beforeTs, this.now());
+    }
+}

package/dist/core/agents/agent-execution-tracker.d.ts

@@ -0,0 +1,91 @@
+import type Database from "better-sqlite3";
+import type { SuccessCriterion } from "@aitne/shared";
+import type { AgentExecutionTrigger } from "../../db/agent-executions-store.js";
+import type { AgentExecutionRecorder } from "../agent-execution-recorder.js";
+import { createLogger } from "../../logging.js";
+import { type AgentIdResolutionInput } from "./agent-id-resolver.js";
+type TrackerLogger = Pick<ReturnType<typeof createLogger>, "warn" | "debug">;
+/** Terminal outcome the result-processor records before the dispatch settles. */
+export interface AgentExecutionOutcome {
+    /** `AgentResult.isError` — a soft failure that did not throw. */
+    isError: boolean;
+    costUsd?: number | null;
+    tokensIn?: number | null;
+    tokensOut?: number | null;
+    turns?: number | null;
+    outputSummary?: string | null;
+}
+export interface AgentExecutionTrackerDeps {
+    db: Database.Database;
+    recorder: AgentExecutionRecorder;
+    /** Resolved context-vault root for `file_*` success criteria. */
+    contextDir: string;
+    /** SSE emitter for the dashboard's live execution feed (§9.8). */
+    emitSse: (event: string, payload: unknown) => void;
+    /** Loads an Agent's `success_criteria` from its definition file (§8.3). */
+    loadCriteria: (definitionPath: string) => SuccessCriterion[];
+    logger?: TrackerLogger;
+}
+export declare class AgentExecutionTracker {
+    private readonly db;
+    private readonly recorder;
+    private readonly contextDir;
+    private readonly emitSse;
+    private readonly loadCriteria;
+    private readonly logger;
+    private readonly active;
+    constructor(deps: AgentExecutionTrackerDeps);
+    /**
+     * Open an execution for a firing. Resolves the owning Agent (§8.1); when none
+     * resolves, returns `null` and records nothing (legacy task, no-LLM pass).
+     * Otherwise starts the `agent_executions` row, caches the loaded criteria,
+     * and emits `agent.execution.started`. Returns the resolved Agent slug so the
+     * dispatcher can short-circuit stamping when there is no Agent.
+     */
+    begin(correlationId: string, resolution: AgentIdResolutionInput, opts: {
+        scheduleRowId?: number | null;
+        trigger: AgentExecutionTrigger;
+    }): string | null;
+    /**
+     * Record the terminal LLM-level outcome (cost / soft-error) before the
+     * dispatch boundary settles the row. No-op when no execution is active.
+     *
+     * A single-session firing calls this exactly once (merge == replace). A
+     * **multi-stage** firing — today only the morning routine, whose Stage A
+     * (today.md) and Stage B (daily journal) are two separate LLM sessions that
+     * both funnel through the shared `ResultProcessor` carrying the
+     * parent's `correlationId` — calls it once per stage. The outcomes are
+     * therefore *folded* (see {@link mergeOutcome}): cost / tokens / turns are
+     * SUMMED so the rollup reflects the firing's total spend rather than the
+     * last (race-ordered) stage's, and `isError` is sticky-OR.
+     */
+    recordOutcome(correlationId: string, outcome: AgentExecutionOutcome): void;
+    /** The Agent slug currently executing for this correlation id, for
+     *  `agent_actions.agent_id` stamping. `null` when no execution is active. */
+    currentAgentId(correlationId: string): string | null;
+    /**
+     * Settle the active execution as a deliberate skip (AGENT_DEFINITIONS_DESIGN.md
+     * §5.2 — `result='skipped'` is a reserved non-error terminal that does NOT
+     * count toward `errorRate`). Called from a dispatch path that opened a row via
+     * {@link begin} but then decided not to run the routine this tick — e.g. a
+     * review routine blocked by the morning-routine-pending gate, or skill
+     * curation when the optimizer workdir is unwired. Success criteria are NOT
+     * evaluated (the run never happened); `reason` is recorded in `output_summary`
+     * so the dashboard can show why. Idempotent — consumes the map entry, so the
+     * trailing `completeFromDispatch` in `dispatchSafe` is a no-op. No-op when no
+     * execution is active (the firing resolved to no Agent, so `begin` opened no
+     * row).
+     */
+    markSkipped(correlationId: string, reason?: string): void;
+    /**
+     * Settle the active execution at the dispatch boundary. Idempotent — the map
+     * entry is consumed, so a later call (e.g. the error path after the success
+     * path already completed) is a no-op. Evaluates success criteria, writes the
+     * terminal row (+ `agents.last_execution_id`), and emits
+     * `agent.execution.completed`.
+     */
+    completeFromDispatch(correlationId: string, opts?: {
+        thrown?: unknown;
+    }): void;
+}
+export {};