pi-harness-runtime 0.9.13 → 0.9.15

package/README.md

@@ -1,11 +1,11 @@
 # Pi Harness Runtime
 
-[![Beta](https://img.shields.io/badge/version-beta-orange?style=for-the-badge)](https://github.com/ManotLuijiu/pi-harness-runtime)
+[![Beta](https://img.shields.io/badge/version-0.9.13-orange?style=for-the-badge)](https://github.com/ManotLuijiu/pi-harness-runtime)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
 [![Platform](https://img.shields.io/badge/Platform-macOS%20|Linux-blue?style=for-the-badge)]()
 
 > ⚠️ **Beta Notice — Not Production Ready ⚠️**
-> This project is in active development. Core features work but E2E testing is not yet implemented.
+> This project is in active development. Core features work.
 
 **Autonomous AI coding harness for pi: local token tracking + provider mirror + task orchestration.**
 
@@ -31,7 +31,7 @@ Requires Pi v0.37.3+.
 
 ```bash
 /usage              # show full status (local tracking + provider mirror)
-/usage refresh     # force refresh quota from MiniMax console
+/usage refresh     # force refresh quota from provider console
 /usage today       # today's usage + 5h window
 /usage week        # this week's usage + lifetime totals
 /usage reset       # clear provider mirror
@@ -82,6 +82,8 @@ Requires Pi v0.37.3+.
 ```
 pi-harness-runtime/
 ├── index.ts                    # Extension entry point
+├── footer-status.ts            # Footer bar renderer (local vs. mirror mode)
+├── mirror.ts                   # Per-provider quota mirror (mirror.json)
 ├── harness/
 │   ├── job-state-machine.ts   # 14-state lifecycle machine
 │   ├── task-graph.ts           # DAG-based task management
@@ -92,13 +94,15 @@ pi-harness-runtime/
 │   ├── context-window-manager.ts # Context tracking
 │   ├── agent-handoff.ts        # Clean agent transitions
 │   ├── e2e/
-│   │   ├── test-engine.ts     # E2E test runner (coming soon)
-│   │   └── playwright-runner.ts # Browser automation
+│   │   ├── minimax-quota-scraper.ts  # Playwright MiniMax scraper
+│   │   └── playwright-runner.ts       # Browser automation
 │   └── project-detector/
 │       └── detector.ts         # Auto-detect project type
 ├── packages/
-│   ├── providers/adapters.ts   # MiniMax, OpenAI adapters
+│   ├── cookie-sanitizer/       # Live cookie-file sync via chokidar
+│   ├── providers/              # MiniMax, OpenAI, Codex adapters
 │   ├── quota-manager/          # Quota signal collection
+│   ├── auth/                   # MiniMax browser auth
 │   └── worktree/              # Git worktree per task
 └── skills/
     └── harness-runtime/
@@ -124,6 +128,7 @@ cancelled  blocked   waiting_human  repairing  ready_for_client
 - **Auto-repair**: Failure classification + retry with exponential backoff
 - **E2E testing**: Scenario-based Playwright integration (coming soon)
 - **Project detection**: Auto-detects Frappe, Next.js, React, Django, Laravel
+- **Per-provider mirror**: Each LLM provider maintains its own quota record
 
 ## Data Directory
 
@@ -133,7 +138,7 @@ All data stored locally in `~/.pi/`:
 ~/.pi/
 ├── usage-status/         # /usage data
 │   ├── usage.jsonl
-│   └── mirror.json
+│   └── mirror.json        # per-provider quota mirror
 ├── harness/            # /harness data
 │   └── jobs/
 │       └── <job-id>/
@@ -193,59 +198,58 @@ bun test   # 131+ tests passing
 
 Quota data is automatically surfaced per-provider:
 
-| Provider | Source | Cadence |
+| Provider | Source | Notes |
 |---|---|---|
-| MiniMax | Playwright + cookies (continuous scrape) | every ~15 min |
-| OpenAI / OpenAI Codex | TUI message capture (signal on limit) | on first limit hit |
-| GLM (Z.ai / Zhipu) | TUI message capture (signal on limit) | on first limit hit |
-| Anthropic | TUI message capture (signal on limit) | on first limit hit |
-| OpenRouter | TUI message capture (signal on limit) | on first limit hit |
+| MiniMax | Live cookie-file watch + Playwright scrape | Drop folder: `~/.pi-harness-runtime/cookies/` |
+| OpenAI / OpenAI Codex | TUI message capture | Signal on first limit hit |
+| GLM (Z.ai / Zhipu) | TUI message capture | Signal on first limit hit |
+| Anthropic | TUI message capture | Signal on first limit hit |
+| OpenRouter | TUI message capture | Signal on first limit hit |
 | Other / unknown | (no data — footer shows hint) | — |
 
 The footer line carries the provider label, so you always know which LLM the data is from:
 
 ```
-MiniMax:  5h: 92% left · week: 80% left           # continuous (scrape)
-OpenAI:   5h: -- · week: -- (no signal yet)        # pending first limit hit
+MiniMax:  5h: 92% left · week: 80% left            # continuous (cookie scrape)
+OpenAI:   5h: -- · week: -- (no signal yet)          # pending first limit hit
 GLM:      limit hit (tokens), reset 2026-07-23T17:28:00Z   # TUI signal observed
+MiniMax:  cookies not found — drop any cookie file into
+          ~/.pi-harness-runtime/cookies/
 ```
 
-1. **MiniMax setup** (one-time):
+### MiniMax Setup (one-time)
+
+The runtime watches `~/.pi-harness-runtime/cookies/` for cookie files. Drop any cookie export there — it syncs within ~1 second:
+
+1. **Install EditThisCookie** Chrome extension → export from `platform.minimax.io`
+2. **Create the drop folder:**
 
    ```bash
-   # Install EditThisCookie Chrome extension
-   # Go to platform.minimax.io
-   # Export cookies → Netscape format
-   # Save to ~/.config/minimax-cookies.txt
+   mkdir -p ~/.pi-harness-runtime/cookies
    ```
 
-   **Recommended:** drop the file into the dedicated cookie folder. The runtime
-   normalizes any format (Netscape or EditThisCookie JSON, any filename) on its own:
+3. **Drop your cookie file in the folder** — any filename, any format (Netscape `.txt` or EditThisCookie JSON `.json`):
 
    ```bash
-   # Save cookies as any name, any format into:
-   mkdir -p ~/.pi-harness-runtime/cookies
-   cp ~/Downloads/platform.minimax.io_cookies.txt ~/.pi-harness-runtime/cookies/
-   # …or use the EditThisCookie extension export (JSON) — same folder works.
+   cp ~/Downloads/platform.minimax.io_cookies.txt \
+      ~/.pi-harness-runtime/cookies/
+   # …or use the EditThisCookie JSON export — same folder works.
    ```
 
-   The `cookie-sanitizer` package (`@pi-harness/cookie-sanitizer`) runs chokidar v5 on this
+   The `cookie-sanitizer` package (`@pi-harness/cookie-sanitizer`) runs chokidar on this
    folder, normalizes everything to standard Netscape, and writes the canonical cache at
    `~/.config/minimax-cookies.txt`. Live update latency: <1 second after drop.
 
-2. **Other providers**: no setup needed. The runtime reads messages from the active
-   session and captures quota-exhaustion signals from the TUI. Once any limit is hit
-   (e.g. `OpenAI: context length exceeded, reset in 3 hr 27 min`), the footer updates
-   immediately and the data persists across `~/.pi/usage-status/mirror.json`.
+4. **Done!** Quota auto-refreshes every ~15 minutes. Cookie file changes sync immediately.
 
-3. **Environment** (optional override):
+**Override:** set `QUOTA_COOKIE_FILE=/path/to/your/cookies.txt` to bypass the sanitizer
+and read a specific file directly.
 
-   ```bash
-   export QUOTA_COOKIE_FILE=/path/to/your/cookies.txt
-   # When set, the sanitizer is bypassed and the scraper reads this file directly.
-   ```
+### Other Providers
 
-4. **Done!** Quota auto-refreshes every 5 minutes. Cookie file changes sync within ~1 second.
+No setup needed. The runtime reads TUI messages and captures quota-exhaustion signals.
+Once any limit is hit (e.g. `OpenAI: context length exceeded, reset in 3 hr 27 min`), the
+footer updates immediately and the data persists in `mirror.json`.
 
 ## Roadmap
 
@@ -254,9 +258,13 @@ GLM:      limit hit (tokens), reset 2026-07-23T17:28:00Z   # TUI signal observed
 - [x] Repair engine
 - [x] Shared blackboard
 - [x] MiniMax Web automatic quota detection
+- [x] Cookie-file drop folder + live sync (`cookie-sanitizer`)
+- [x] Per-provider quota mirror (`mirror.json` keyed by provider)
+- [x] Multi-provider TUI signal capture (OpenAI, GLM, Anthropic, OpenRouter)
 - [ ] E2E test engine integration
 - [ ] Claude adapter
 - [ ] Production stress testing
+- [ ] RFC-0101: Autonomous Operations Runtime (background execution, task inbox, lease protocol)
 
 ## License
 
@@ -268,17 +276,17 @@ MIT © 2026 MooCoding
 - [context-mode](https://github.com/MiniMax-AI/context-mode) — Context window tracking
 - [pi-web-access](https://github.com/nicobailon/pi-web-access) — Web search for pi
 
-Day 6 adds runtime recovery and remote-observability architecture.
-
 ## RFCs
 
-- RFC-0019 Auto Compact and Continue
-- RFC-0020 Output Token Limit Handler
-- RFC-0021 Partial Response Recovery
-- RFC-0022 Notification Center
-- RFC-0023 Local Browser Agent
+The project tracks 101 design documents:
+
+| RFC | Title | Status |
+|-----|-------|--------|
+| 0001–0034 | Loop Runtime, Provider Adapter, Quota Manager, Playwright, Git Worktree, Checkpoint, Scheduler, Provider Router, Shared Context, Context Window Manager, Shared Blackboard, Agent Handoff, E2E Test Engine, Project Detector, Job State Machine, Task Graph, Master Planner, Repair Engine, Auto Compact & Continue, Output Token Limit, Partial Response Recovery, Notification Center, Local Browser Agent, Local Runtime Agent, Command Executor, Workspace Manager, Runtime API, Policy Engine, DeepAgents Adapter, Agent Worker Interface, Provider Adapter SDK, Checkpoint Engine, Session Manager | Proposed |
+| 0035–0100 | Observability, Roadmap V1, Code Review, Code Generation, Framework Detector, Test Data Generator, Framework Plugin SDK, Prompt Compiler, Context Compiler, Requirement Compiler, Task Compiler, Project Analyzer, Dependency Analyzer, Repo Knowledge Graph, Code Merge Engine, Conflict Resolution, Documentation Generator, Capability Registry, Skill Registry, Model Registry, Cost Optimizer, Performance Optimizer, Evaluation Engine, Learning Engine, Experience Replay, Memory Engine OKF, Frappe/Next.js/React/Django/Laravel/Generic Web Plugins, CLI Plugin SDK, MCP Adapter, A2A Adapter, Codex Adapter, Requirement Intake, Project Bootstrap, Architecture Generator, Sprint Planner, Milestone Manager, Backlog Manager, Human Approval Gate, Release Manager, Version Manager, Deployment Pipeline, Multi-User Runtime, RBAC, Audit Trail, Dashboard, Analytics, Distributed Runtime, Cluster Manager, Runtime Federation, High Availability, Disaster Recovery, + 17 Autonomous Architectures | Proposed |
+| 0101 | [Autonomous Operations Runtime](RFC/0101_AUTONOMOUS_OPERATIONS_RUNTIME.md) — durable Task Inbox, Background Worker, Task Lease protocol, Privilege Broker, Approval Class policy engine, abstract Scheduler, Notification pipeline, Recovery semantics | Proposed |
 
-## Why this matters
+## Why This Matters
 
 These RFCs address real runtime failures:
 
@@ -287,3 +295,4 @@ These RFCs address real runtime failures:
 - Partial responses must be preserved and continued.
 - The human needs mobile/tablet notifications.
 - Headless servers cannot open interactive login windows for MiniMax usage console.
+- The runtime must continue executing after the chat session ends, the SSH session disconnects, or the provider quota exhausts.

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;