pi-harness-runtime 0.9.14 → 0.9.16

package/harness/auto-quota-resume.ts

@@ -0,0 +1,129 @@
+/**
+ * Auto Quota Resume — schedules automatic job resume when quota resets.
+ *
+ * Flow:
+ *   quota exhaustion detected
+ *     → read h5_resets_at_epoch from mirror
+ *     → compute resumeAt ISO timestamp
+ *     → call machine.setResumeTime(resumeAt)
+ *     → schedule setTimeout for auto-resume
+ *     → at timeout: machine.transition("running")
+ *
+ * Only the 5h window is auto-resumed (provider-reported, predictable).
+ * Weekly/monthly quota exhaustion requires human monitoring.
+ */
+
+import type { MirrorStore } from "../mirror.js";
+import type { JobStateMachine } from "./job-state-machine.js";
+
+/** Small buffer (ms) before the exact reset time to resume. */
+const RESUME_BUFFER_MS = 10_000; // 10 seconds — resume just before reset
+
+/** Minimum time to wait before auto-resuming (avoid immediate re-trigger). */
+const MIN_RESUME_DELAY_MS = 5_000; // 5 seconds
+
+/** Map of jobId → active auto-resume timer handle. */
+const activeTimers = new Map<
+	string,
+	{ timeout: ReturnType<typeof setTimeout>; resumeAt: number }
+>();
+
+/**
+ * Schedule an auto-resume for a job that was paused due to quota exhaustion.
+ *
+ * Reads the reset epoch from the mirror store for the given provider,
+ * computes the resume time, sets it on the checkpoint, and schedules
+ * a setTimeout to transition back to "running".
+ *
+ * Returns the scheduled resumeAt ISO string, or null if no epoch data
+ * is available (requires human resume).
+ */
+export function scheduleAutoResume(
+	provider: string,
+	machine: JobStateMachine,
+	mirrorStore: MirrorStore,
+): string | null {
+	const jobId = machine.getCheckpoint()?.jobId;
+	if (!jobId) return null;
+
+	// Cancel any existing timer for this job
+	cancelAutoResume(jobId);
+
+	const mirror = mirrorStore.readAll();
+	const record = mirror?.[provider];
+	if (!record) return null;
+
+	// Only auto-resume on 5h quota exhaustion (has precise epoch)
+	if (typeof record.h5_resets_at_epoch !== "number") return null;
+
+	const resetEpoch = record.h5_resets_at_epoch;
+	const now = Date.now();
+	const delayMs = Math.max(resetEpoch - now - RESUME_BUFFER_MS, MIN_RESUME_DELAY_MS);
+	const resumeAt = now + delayMs;
+	const resumeAtIso = new Date(resumeAt).toISOString();
+
+	// Persist to checkpoint so resumeAt survives worker restart
+	machine.setResumeTime(resumeAtIso);
+
+	console.log(
+		`[auto-quota-resume] ${provider} 5h quota exhausted.` +
+			` Auto-resume scheduled at ${resumeAtIso} (in ${Math.round(delayMs / 1000)}s)`,
+	);
+
+	const timeout = setTimeout(async () => {
+		activeTimers.delete(jobId);
+
+		const checkpoint = machine.getCheckpoint();
+		if (!checkpoint || checkpoint.status !== "paused_quota") {
+			// Job was manually resumed or cancelled
+			return;
+		}
+
+		// Check the mirror — if quota is still exhausted, shift the timer
+		const updated = mirrorStore.readAll()?.[provider];
+		if (updated?.h5_resets_at_epoch) {
+			const stillExhausted = Date.now() < updated.h5_resets_at_epoch;
+			if (stillExhausted) {
+				console.log(
+					`[auto-quota-resume] ${provider} still exhausted at scheduled time.` +
+						` Re-scheduling...`,
+				);
+				scheduleAutoResume(provider, machine, mirrorStore);
+				return;
+			}
+		}
+
+		const result = await machine.transition("running");
+		if (result.success) {
+			console.log(
+				`[auto-quota-resume] Job ${jobId} auto-resumed after ${provider} 5h quota reset.`,
+			);
+		} else {
+			console.error(
+				`[auto-quota-resume] Auto-resume failed for ${jobId}: ${result.error}`,
+			);
+		}
+	}, delayMs);
+
+	activeTimers.set(jobId, { timeout, resumeAt });
+	return resumeAtIso;
+}
+
+/**
+ * Cancel the auto-resume timer for a job.
+ * Call this when the job is manually resumed or cancelled.
+ */
+export function cancelAutoResume(jobId: string): void {
+	const existing = activeTimers.get(jobId);
+	if (existing) {
+		clearTimeout(existing.timeout);
+		activeTimers.delete(jobId);
+	}
+}
+
+/**
+ * Get the scheduled resume time for a job, or null if not scheduled.
+ */
+export function getScheduledResume(jobId: string): number | null {
+	return activeTimers.get(jobId)?.resumeAt ?? null;
+}

package/harness/e2e/minimax-quota-scraper.ts

@@ -21,10 +21,14 @@ export interface MiniMaxQuotaData {
 	h5UsedPct: number;
 	/** When the 5h window resets (e.g., "in 4 hr 56 min") */
 	h5ResetsAt?: string;
+	/** Epoch ms when the 5h window resets — precise UTC timestamp. */
+	h5ResetsAtEpoch?: number;
 	/** Weekly usage percentage (0-100) */
 	weeklyUsedPct: number;
 	/** When the weekly window resets */
 	weeklyResetsAt?: string;
+	/** Epoch ms when the weekly window resets — precise UTC timestamp. */
+	weeklyResetsAtEpoch?: number;
 	/** Monthly usage percentage (0-100) */
 	monthlyUsedPct?: number;
 	/** When the monthly window resets */
@@ -301,10 +305,10 @@ export class MiniMaxQuotaScraper {
 		const weeklyUsedPct = parsePctStr(
 			general.current_weekly_used_percent as unknown,
 		);
-		const h5ResetsAt = formatRemainsMs(general.end_time as number | undefined);
-		const weeklyResetsAt = formatRemainsMs(
-			general.weekly_end_time as number | undefined,
-		);
+		const h5ResetsAtEpoch = general.end_time as number | undefined;
+		const h5ResetsAt = formatRemainsMs(h5ResetsAtEpoch);
+		const weeklyResetsAtEpoch = general.weekly_end_time as number | undefined;
+		const weeklyResetsAt = formatRemainsMs(weeklyResetsAtEpoch);
 
 		// Best-effort: token usage summary
 		let tokenUsage: MiniMaxQuotaData["tokenUsage"];
@@ -357,8 +361,10 @@ export class MiniMaxQuotaScraper {
 			provider: "minimax",
 			h5UsedPct: h5UsedPct ?? 0,
 			h5ResetsAt,
+			h5ResetsAtEpoch,
 			weeklyUsedPct: weeklyUsedPct ?? 0,
 			weeklyResetsAt,
+			weeklyResetsAtEpoch,
 			creditBalance,
 			tokenUsage,
 			apiEndpoints: [

package/harness/index.ts

@@ -54,6 +54,14 @@ export type { LoopResult, LoopCallbacks } from "./loop-runtime.js";
 export { RepairEngine } from "./repair-engine.js";
 export type { RepairResult } from "./repair-engine.js";
 
+// Auto Quota Resume (5h window auto-resume)
+export {
+	scheduleAutoResume,
+	cancelAutoResume,
+	getScheduledResume,
+} from "./auto-quota-resume.js";
+export type {} from "./auto-quota-resume.js";
+
 // Master Planner
 export { MasterPlanner } from "./master-planner.js";
 export type { PlanResult } from "./master-planner.js";

package/harness/loop-runtime.ts

@@ -26,6 +26,7 @@ import type {
 	CompactResult,
 	RuntimeEvent,
 } from "../packages/types/src/runtime-types.js";
+import { MirrorStore } from "../mirror.js";
 import {
 	JobStateMachine,
 	type CheckpointManager,
@@ -80,6 +81,14 @@ export interface LoopCallbacks {
 		event: "paused" | "resumed" | "exhausted",
 		provider?: string,
 	) => Promise<void>;
+	/** Get current checkpoint (used by auto-resume to read resumeAt) */
+	onGetCheckpoint?: () => Promise<RuntimeCheckpoint | null>;
+	/** Check mirror for a provider (used by auto-resume to detect early reset) */
+	onCheckMirror?: (
+		provider: string,
+	) => Promise<{ h5_used_pct?: number } | null>;
+	/** Generic notify (used by auto-resume to tell user wait time) */
+	onNotify?: (msg: string, type?: string) => Promise<void>;
 	/** Save checkpoint (call persistence layer) */
 	onCheckpoint?: (checkpoint: RuntimeCheckpoint) => Promise<void>;
 	/** Notify each loop iteration */
@@ -106,6 +115,7 @@ export class LoopRuntime {
 	private readonly config: Required<LoopConfig>;
 	private readonly state: LoopState;
 	private readonly jobState: JobStateMachine;
+	private readonly mirrorStore: MirrorStore;
 	private readonly callbacks: LoopCallbacks;
 	private running = false;
 	private paused = false;
@@ -172,6 +182,7 @@ export class LoopRuntime {
 				},
 			},
 		});
+		this.mirrorStore = new MirrorStore();
 
 		// Initialize session memory
 		this.sessionMemory = createSessionMemoryManager(config.jobId);
@@ -214,6 +225,35 @@ export class LoopRuntime {
 
 	async run(): Promise<LoopResult> {
 		this.running = true;
+
+		// ─── Auto-resume from quota pause ──────────────────────────────────
+		const checkpoint = await this.callbacks.onGetCheckpoint?.();
+		if (checkpoint?.status === "paused_quota" && checkpoint.resumeAt) {
+			const resumeMs = new Date(checkpoint.resumeAt).getTime();
+			const now = Date.now();
+			const waitMs = resumeMs - now;
+			if (waitMs > 0) {
+				const waitMin = Math.ceil(waitMs / 60_000);
+				const notify = this.callbacks.onNotify ?? (() => {});
+				await notify(
+					`Quota reset in ${waitMin} min — auto-resuming at ${checkpoint.resumeAt}`,
+					"info",
+				);
+				// Wait in 5-minute chunks so we don't block forever if quota resets early
+				while (this.running && Date.now() < resumeMs) {
+					await new Promise((r) => setTimeout(r, 5 * 60_000)); // 5 min
+					// Re-check mirror — quota may have reset early
+					const fresh = await this.callbacks.onCheckMirror?.("minimax");
+					if (fresh && fresh.h5_used_pct !== undefined && fresh.h5_used_pct < 100) {
+						break; // quota reset early, resume now
+					}
+				}
+				// Transition back to running
+				await this.jobState.transition("running");
+				this.callbacks.onQuotaEvent?.("resumed");
+			}
+		}
+
 		this.state.status = "running";
 
 		try {
@@ -652,6 +692,23 @@ export class LoopRuntime {
 		this.paused = true;
 		this.state.status = "paused_quota";
 		this.jobState.transition("paused_quota");
+
+		// Set resumeAt from the mirror's known reset epoch so the auto-resume
+		// timer knows when to wake this job up.
+		const mirror = this.mirrorStore.readProvider("minimax");
+		const epoch = mirror?.h5_resets_at_epoch;
+		if (epoch) {
+			const resumeAt = new Date(epoch).toISOString();
+			await this.jobState.setResumeTime(resumeAt);
+			console.log(
+				`[LoopRuntime] Paused for 5h quota. Auto-resume at ${resumeAt}`,
+			);
+		} else {
+			console.log(
+				"[LoopRuntime] Paused for quota but no reset time known yet.",
+			);
+		}
+
 		await this.callbacks.onQuotaEvent?.("paused");
 		await this.saveCheckpoint();
 	}

package/index.ts

@@ -62,6 +62,10 @@ import {
 	type SharedBlackboard,
 	createBlackboard,
 } from "./harness/blackboard.ts";
+import {
+	scheduleAutoResume,
+	cancelAutoResume,
+} from "./harness/index.js";
 import { homedir } from "node:os";
 import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -469,8 +473,10 @@ export default function (pi: ExtensionAPI) {
 				source: "scrape",
 				h5_used_pct: data.h5UsedPct,
 				h5_resets_at: data.h5ResetsAt,
+				h5_resets_at_epoch: data.h5ResetsAtEpoch,
 				weekly_used_pct: data.weeklyUsedPct,
 				weekly_resets_at: data.weeklyResetsAt,
+				weekly_resets_at_epoch: data.weeklyResetsAtEpoch,
 			});
 			return true;
 		} catch (error) {
@@ -794,25 +800,51 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
-			const checkpoint = currentSession.machine.getCheckpoint();
-			if (!checkpoint) {
-				ctx.ui.notify("Failed to get checkpoint.", "error");
-				return;
-			}
+		const checkpoint = currentSession.machine.getCheckpoint();
+		if (!checkpoint) {
+			ctx.ui.notify("Failed to get checkpoint.", "error");
+			return;
+		}
 
-			const result = await currentSession.machine.transition("paused_quota");
-			if (!result.success) {
-				ctx.ui.notify(`Failed to pause: ${result.error}`, "error");
-				return;
-			}
+		// Read 5h reset epoch from mirror so we can schedule auto-resume
+		const mirror = mirrorStore.readProvider("minimax");
+		const resumeAtIso = mirror?.h5_resets_at_epoch
+			? new Date(mirror.h5_resets_at_epoch).toISOString()
+			: undefined;
+
+		const result = await currentSession.machine.transition("paused_quota");
+		if (!result.success) {
+			ctx.ui.notify(`Failed to pause: ${result.error}`, "error");
+			return;
+		}
 
+		// Persist resumeAt so auto-resume survives worker restart
+		if (resumeAtIso) {
+			await currentSession.machine.setResumeTime(resumeAtIso);
+		}
+
+		// Schedule auto-resume for 5h quota
+		if (resumeAtIso) {
+			const scheduled = scheduleAutoResume(
+				"minimax",
+				currentSession.machine,
+				mirrorStore,
+			);
+			ctx.ui.notify(
+				`Job paused.\n` +
+					`Auto-resume at ${scheduled ?? resumeAtIso} (5h quota exhausted).\n` +
+					`Run /harness cancel to abort.`,
+				"info",
+			);
+		} else {
 			ctx.ui.notify(
 				`Job ${currentSession.jobId} paused.\n` +
 					`Current status: paused_quota\n` +
 					`Run /harness resume to continue.`,
 				"info",
 			);
-		},
+		}
+		}
 	});
 
 	// ─── /harness resume — Resume the harness job ───────────────────────
@@ -839,6 +871,9 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
+			// Cancel any scheduled auto-resume for this job
+			cancelAutoResume(currentSession.jobId);
+
 			ctx.ui.notify(
 				`Job ${currentSession.jobId} resumed.\n` +
 					`Current status: running\n` +
@@ -873,6 +908,7 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
+			cancelAutoResume(currentSession.jobId);
 			const sessionJobId = currentSession.jobId;
 			currentSession = null;
 

package/mirror.ts

@@ -32,6 +32,27 @@
 
 import { getMirrorPath, readJson, writeJson } from "./cli.ts";
 
+/**
+ * Canonical lowercase provider ids — mirrors the KNOWN_AI_PROVIDERS from
+ * packages/types/src/ai-providers.ts. Duplicated here to avoid import path
+ * resolution issues in the root workspace.
+ */
+const KNOWN_PROVIDER_IDS = [
+	"minimax",
+	"openai",
+	"anthropic",
+	"glm",
+	"openrouter",
+	"openai-codex",
+	"deepseek",
+	"gemini",
+	"kimi",
+] as const;
+
+function isKnownProvider(id: string): boolean {
+	return (KNOWN_PROVIDER_IDS as readonly string[]).includes(id);
+}
+
 /** Where a piece of data came from. */
 export type MirrorSource = "scrape" | "tui-signal" | "manual";
 
@@ -49,10 +70,14 @@ export interface ProviderMirrorRecord {
 	h5_used_pct?: number;
 	/** When the 5h window resets — human-readable or ISO. */
 	h5_resets_at?: string;
+	/** Epoch ms when the 5h window resets — precise UTC timestamp. */
+	h5_resets_at_epoch?: number;
 	/** Weekly used percent. */
 	weekly_used_pct?: number;
 	/** When the weekly window resets. */
 	weekly_resets_at?: string;
+	/** Epoch ms when the weekly window resets — precise UTC timestamp. */
+	weekly_resets_at_epoch?: number;
 	/** Set when a limit was hit and we have the exhaustion signal. */
 	exhausted?: boolean;
 	/** Limit type from TUI signal: tokens, context_window, rate_limit, unknown. */
@@ -81,15 +106,7 @@ export interface MirrorRecord {
 	weekly_resets_at?: string;
 }
 
-/** Known provider ids used as keys in the per-provider map. */
-export type KnownProviderId =
-	| "minimax"
-	| "openai"
-	| "openai-codex"
-	| "glm"
-	| "anthropic"
-	| "openrouter"
-	| (string & {}); // allow extension
+
 
 const STALE_WARN_MS = 30 * 60 * 1000; // 30 min → orange
 const STALE_ERROR_MS = 2 * 60 * 60 * 1000; // 2 h   → red
@@ -112,11 +129,12 @@ function isLegacyShape(raw: unknown): raw is MirrorRecord & {
 }
 
 /** Convert a legacy single-row record to per-provider shape. */
-function upgradeLegacyRecord(legacy: MirrorRecord): PerProviderMirror {
+function upgradeLegacyRecord(legacy: MirrorRecord): PerProviderMirror | null {
 	const provider = legacy.provider ?? "minimax";
+	const known = isKnownProvider(provider) ? provider : "minimax";
 	const rec: ProviderMirrorRecord = {
 		synced_at: legacy.synced_at ?? new Date().toISOString(),
-		provider,
+		provider: known,
 		source: "scrape", // legacy was always scrape
 		model: legacy.model,
 		h5_used_pct: legacy.h5_used_pct,
@@ -124,7 +142,7 @@ function upgradeLegacyRecord(legacy: MirrorRecord): PerProviderMirror {
 		weekly_used_pct: legacy.weekly_used_pct,
 		weekly_resets_at: legacy.weekly_resets_at,
 	};
-	return { [provider]: rec };
+	return { [known]: rec };
 }
 
 export class MirrorStore {
@@ -152,13 +170,17 @@ export class MirrorStore {
 
 		if (isLegacyShape(raw)) {
 			const upgraded = upgradeLegacyRecord(raw as MirrorRecord);
-			// Persist the upgrade so subsequent reads are fast.
-			try {
-				writeJson(this.path, upgraded);
-			} catch {
-				// best-effort
+			if (upgraded) {
+				// Persist the upgrade so subsequent reads are fast.
+				try {
+					writeJson(this.path, upgraded);
+				} catch {
+					// best-effort
+				}
+				return upgraded;
 			}
-			return upgraded;
+			// Unknown legacy provider — treat as absent.
+			return null;
 		}
 
 		// Already per-provider shape.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "0.9.14",
+  "version": "0.9.16",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/a2a-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/a2a-adapter",
-  "version": "0.9.11",
+  "version": "0.9.15",
   "type": "module",
   "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
   "main": "dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "0.9.11",
+  "version": "0.9.15",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-refactor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-refactor",
-  "version": "0.9.11",
+  "version": "0.9.15",
   "type": "module",
   "description": "Autonomous refactoring engine",
   "main": "dist/index.js",

package/packages/autonomous-runtime/README.md

@@ -0,0 +1,48 @@
+# Autonomous Runtime — RFC-0101
+
+Task Inbox, Task Lease, and worker supervision for autonomous post-session execution.
+
+## Package
+
+`@pi-harness/autonomous-runtime`
+
+## Concepts
+
+### Task Inbox
+
+Durable queue of tasks submitted by the harness master planner. Survives worker crashes, host reboots, and provider quota exhaustion.
+
+### Task Lease
+
+Atomic exclusive claim on a task. Guarantees **single-execution** under crash recovery. Other workers skip a leased task.
+
+### Worker
+
+Supervised process that reads from the inbox, claims tasks via leases, executes, and reports results.
+
+## Usage
+
+```ts
+import { TaskInbox, TaskLeaseManager, WORKER_ROOT } from "@pi-harness/autonomous-runtime";
+
+const inbox = new TaskInbox();
+const leaseMgr = new TaskLeaseManager();
+
+// Submit a task
+await inbox.submit({
+  title: "Fix login bug",
+  description: "Users cannot log in with SSO",
+  capability: "write",
+});
+
+// Worker: claim and work
+const task = await inbox.claimNext("worker-1", leaseMgr);
+if (task) {
+  // ... do work ...
+  await inbox.complete(task.id, { success: true });
+}
+```
+
+## Status
+
+**Phase 1 done.** Phases 2–10 pending implementation.

package/packages/autonomous-runtime/dist/inbox.d.ts

@@ -0,0 +1,75 @@
+import type { TaskRecord, TaskStatus, TaskEvent } from "./types.js";
+export declare class InboxError extends Error {
+    constructor(msg: string);
+}
+/**
+ * Manages the append-only task inbox at `~/.pi/harness/inbox/tasks.jsonl`.
+ *
+ * Storage layout:
+ * ```
+ * ~/.pi/harness/inbox/
+ * ├── tasks.jsonl   # append-only log (one JSON line per task)
+ * ├── claimed/      # active leases (one JSON file per task)
+ * └── BACKLOG.md   # human-friendly authoring surface (optional)
+ * ```
+ *
+ * Operations are:
+ * - **append**  — append a new task to tasks.jsonl
+ * - **list**    — read all tasks, filterable by status
+ * - **transition** — update a task's status in-place (rewrite)
+ * - **get**     — read one task by id
+ * - **reindex** — compact tasks.jsonl by rewriting it from in-memory state
+ */
+export declare class TaskInbox {
+    private readonly tasksPath;
+    private readonly inboxDir;
+    private _cache;
+    constructor(options?: {
+        tasksPath?: string;
+        inboxDir?: string;
+    });
+    /** Ensure the inbox directory exists. Call before any write. */
+    ensureDir(): void;
+    /**
+     * Append a new task to tasks.jsonl.
+     * The task is validated before writing. Duplicate ids are rejected.
+     *
+     * @throws {InboxError} if the task id already exists or validation fails
+     */
+    append(task: TaskRecord): void;
+    /**
+     * Read all tasks from tasks.jsonl.
+     * Results are sorted by priority ASC then createdAt ASC (oldest first).
+     *
+     * @param filter Optionally filter by status. If omitted, returns all.
+     */
+    list(filter?: {
+        status?: TaskStatus | TaskStatus[];
+    }): TaskRecord[];
+    /** Retrieve a single task by id, or null if not found. */
+    get(id: string): TaskRecord | null;
+    /**
+     * Update a task's status in-place inside tasks.jsonl.
+     *
+     * Uses read→parse→update→rewrite to avoid corrupting the JSONL file.
+     * The rewrite is atomic (write-tmp-then-rename).
+     *
+     * @param taskId       The id of the task to transition
+     * @param newStatus    The target status
+     * @param extra       Optional additional fields to merge into the task record
+     * @param event       Optional TaskEvent to append to the history
+     * @throws {InboxError} if the task does not exist
+     */
+    transition(taskId: string, newStatus: TaskStatus, extra?: Partial<TaskRecord>, event?: TaskEvent): TaskRecord;
+    /** Convenience: mark a task as completed with a result. */
+    complete(taskId: string, result: TaskRecord["result"]): TaskRecord;
+    /** Convenience: mark a task as failed with a reason. */
+    fail(taskId: string, reason: string): TaskRecord;
+    /** Rewrite tasks.jsonl from the given task list. */
+    private _rewriteAll;
+    /** Force a full reindex. Call after manual edits to tasks.jsonl. */
+    reindex(): void;
+    /** Return counts of tasks grouped by status. */
+    stats(): Record<TaskStatus, number>;
+}
+//# sourceMappingURL=inbox.d.ts.map

package/packages/autonomous-runtime/dist/inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.d.ts","sourceRoot":"","sources":["../src/inbox.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAKpE,qBAAa,UAAW,SAAQ,KAAK;IACpC,YAAY,GAAG,EAAE,MAAM,EAGtB;CACD;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,SAAS;IACrB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,MAAM,CAA6B;IAE3C,YAAY,OAAO,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO,EAGlE;IAED,gEAAgE;IAChE,SAAS,IAAI,IAAI,CAIhB;IAID;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAc7B;IAID;;;;;OAKG;IACH,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,UAAU,GAAG,UAAU,EAAE,CAAA;KAAE,GAAG,UAAU,EAAE,CAoClE;IAID,0DAA0D;IAC1D,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAGjC;IAID;;;;;;;;;;;OAWG;IACH,UAAU,CACT,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,UAAU,EACrB,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,EAC3B,KAAK,CAAC,EAAE,SAAS,GACf,UAAU,CAqCZ;IAID,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,UAAU,CAWjE;IAED,wDAAwD;IACxD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAe/C;IAID,oDAAoD;IACpD,OAAO,CAAC,WAAW;IAUnB,oEAAoE;IACpE,OAAO,IAAI,IAAI,CAKd;IAID,gDAAgD;IAChD,KAAK,IAAI,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAOlC;CACD"}