@weapp-agent/cli 0.0.0 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,2130 @@
+#!/usr/bin/env node
+import { Buffer as Buffer$1 } from "node:buffer";
+import { cp, lstat, mkdir, open, readFile, readdir, realpath, rename, rmdir, truncate, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { createTwoFilesPatch } from "diff";
+import { execa } from "execa";
+import { createRuntimeAcceptanceService, registerAcceptanceTools } from "@weapp-vite/mcp";
+import { connectMiniProgram, prepareAcceptanceProject } from "weapp-ide-cli";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import * as import__weapp_vite_acceptance$3 from "@weapp-vite/acceptance";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { jsonSchema, streamText, tool } from "ai";
+import { Command, Option } from "commander";
+import { Box, Text, render, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region \0rolldown/runtime.js
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames$1 = Object.getOwnPropertyNames;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __exportAll$1 = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp$1(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp$1(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps$1 = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames$1(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp$1.call(to, key) && key !== except) __defProp$1(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc$1(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport$1 = (target, mod, secondTarget) => (__copyProps$1(target, mod, "default"), secondTarget && __copyProps$1(secondTarget, mod, "default"));
+//#endregion
+//#region ../agent-core/dist/text-EVMG4Jiq.mjs
+var ApprovalRequired = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ApprovalRequired";
+	}
+};
+function redactor(environment = process.env) {
+	const secrets = Object.entries(environment).filter(([k, v]) => /KEY|TOKEN|SECRET|PASSWORD/i.test(k) && v && v.length >= 8).map(([, v]) => v).sort((a, b) => b.length - a.length);
+	return (text) => {
+		for (const secret of secrets) text = text.split(secret).join("[REDACTED]");
+		return text.replace(/\b(sk-[\w-]{12,}|gh[pousr]_\w{16,})\b/g, "[REDACTED]").replace(/(Bearer\s+)[\w.\-/+=]{10,}/gi, "$1[REDACTED]");
+	};
+}
+function inside(root, target) {
+	const relative = path.relative(root, target);
+	return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function sensitive(file) {
+	return file.split(/[\\/]/).some((part) => /^(?:\.git|\.weapp-agent|\.npmrc|\.env(?:\..+)?|.*\.(?:pem|key|p12))$/i.test(part) && part !== ".env.example");
+}
+/** Canonicalize ancestors even for new files: symlink escapes cannot bypass the boundary. */
+async function safePath(root, file) {
+	const canonicalRoot = await realpath(root);
+	const target = path.resolve(canonicalRoot, file);
+	if (!inside(canonicalRoot, target) || sensitive(path.relative(canonicalRoot, target))) throw new Error(`Path is outside the permitted workspace or is sensitive: ${file}`);
+	let ancestor = target;
+	for (;;) try {
+		const resolved = await realpath(ancestor);
+		if (!inside(canonicalRoot, resolved) || sensitive(path.relative(canonicalRoot, resolved))) throw new Error(`Symlink crosses the workspace boundary: ${file}`);
+		break;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		const parent = path.dirname(ancestor);
+		if (parent === ancestor) throw error;
+		ancestor = parent;
+	}
+	try {
+		if ((await lstat(target)).isSymbolicLink()) throw new Error(`Editing or reading a symlink is not supported: ${file}`);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return target;
+}
+async function requireTrust(context) {
+	if (!context.trusted) throw new ApprovalRequired("Workspace is not trusted. Review its configuration, then run with --trust.");
+}
+async function authorize(context, kind, summary, payload) {
+	if (!await context.approve({
+		kind,
+		summary,
+		fingerprint: hash(JSON.stringify(payload))
+	})) throw new ApprovalRequired(`Approval required: ${summary}`);
+}
+function redactValue(value, clean = redactor()) {
+	if (typeof value === "string") return clean(value);
+	if (Array.isArray(value)) return value.map((v) => redactValue(v, clean));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactValue(v, clean)]));
+	return value;
+}
+const verificationSchema = z.strictObject({
+	kind: z.enum([
+		"typecheck",
+		"build",
+		"test",
+		"devtools"
+	]),
+	command: z.string().min(1),
+	args: z.array(z.string()).default([]),
+	timeoutMs: z.number().int().positive().max(18e5).default(12e4)
+});
+const mcpSchema = z.discriminatedUnion("transport", [z.strictObject({
+	name: z.string().regex(/^[\w-]+$/),
+	transport: z.literal("stdio"),
+	command: z.string(),
+	args: z.array(z.string()).default([])
+}), z.strictObject({
+	name: z.string().regex(/^[\w-]+$/),
+	transport: z.literal("http"),
+	url: z.url(),
+	tokenEnv: z.string().optional()
+})]);
+const modelSchema = z.strictObject({
+	provider: z.enum([
+		"openai",
+		"anthropic",
+		"openai-compatible"
+	]),
+	name: z.string().min(1),
+	baseURL: z.url().optional(),
+	apiKeyEnv: z.string().regex(/^[A-Z_][A-Z0-9_]*$/).optional()
+});
+const projectConfigSchema = z.strictObject({
+	version: z.literal(1).default(1),
+	model: modelSchema.optional(),
+	maxSteps: z.number().int().min(1).max(500).default(40),
+	timeoutMs: z.number().int().positive().default(6e5),
+	contextCharacters: z.number().int().min(8e3).default(1e5),
+	verification: z.array(verificationSchema).default([]),
+	mcp: z.array(mcpSchema).default([]),
+	acceptance: z.strictObject({
+		requiredChecks: z.array(z.enum([
+			"typecheck",
+			"build",
+			"test",
+			"devtools"
+		])).min(1).default(["build", "devtools"]),
+		scenarios: z.array(z.string().min(1)).max(100).default([]),
+		timeoutMs: z.number().int().min(100).max(18e5).default(6e5)
+	}).default({
+		requiredChecks: ["build", "devtools"],
+		scenarios: [],
+		timeoutMs: 6e5
+	})
+});
+const configSchema = projectConfigSchema.extend({ model: modelSchema });
+const configFilename = "weapp-agent.config.json";
+const selectedConfigs = /* @__PURE__ */ new WeakMap();
+function configurationSource(config) {
+	return selectedConfigs.get(config);
+}
+async function loadProjectConfig(root) {
+	let raw;
+	try {
+		raw = await readFile(path.join(root, configFilename), "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		throw new Error(`Missing ${configFilename}. Run weapp-agent init; add --model <model> only for independent agent mode.`);
+	}
+	return projectConfigSchema.parse(JSON.parse(raw));
+}
+async function loadConfig(root) {
+	const config = await loadProjectConfig(root);
+	if (!config.model) throw new Error("Agent mode requires model configuration. Set model.provider and model.name in weapp-agent.config.json. Acceptance and MCP do not require a model.");
+	return configSchema.parse(config);
+}
+function hash(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function stateRoot() {
+	return path.resolve(process.env.WEAPP_AGENT_STATE_DIR ?? path.join(homedir(), ".local", "state", "weapp-agent"));
+}
+async function projectFingerprint(root, config) {
+	let pkg = "";
+	try {
+		pkg = await readFile(path.join(root, "package.json"), "utf8");
+	} catch {}
+	let diskConfig = "";
+	try {
+		diskConfig = await readFile(await safePath(root, configurationSource(config) ?? "weapp-agent.config.json"), "utf8");
+	} catch {}
+	const scenarios = [];
+	for (const file of config.acceptance.scenarios) {
+		const target = await safePath(root, file);
+		try {
+			scenarios.push([file, await readFile(target, "utf8")]);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			scenarios.push([file, "<missing>"]);
+		}
+	}
+	const projectFiles = [];
+	for (const file of [
+		"project.config.json",
+		"vite.config.ts",
+		"vite.config.js",
+		"vite.config.mts",
+		"vite.config.mjs",
+		"vite.config.cts",
+		"vite.config.cjs",
+		"pnpm-workspace.yaml",
+		"pnpm-lock.yaml",
+		"package-lock.json",
+		"yarn.lock",
+		"bun.lock"
+	]) try {
+		projectFiles.push([file, hash(await readFile(await safePath(root, file), "utf8"))]);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return hash(JSON.stringify({
+		root,
+		config,
+		pkg,
+		diskConfig,
+		scenarios,
+		projectFiles,
+		...configurationSource(config) && configurationSource(config) !== "weapp-agent.config.json" ? { configurationSource: configurationSource(config) } : {}
+	}));
+}
+async function isTrusted(root, fingerprint) {
+	try {
+		return JSON.parse(await readFile(path.join(stateRoot(), "trust", `${hash(root)}.json`), "utf8")).fingerprint === fingerprint;
+	} catch {
+		return false;
+	}
+}
+async function trustProject(root, fingerprint) {
+	const dir = path.join(stateRoot(), "trust");
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(path.join(dir, `${hash(root)}.json`), JSON.stringify({
+		root,
+		fingerprint
+	}), { mode: 384 });
+}
+function bounded(text, max = 4e4) {
+	return text.length > max ? `${text.slice(0, max)}\n[truncated: ${text.length - max} more characters]` : text;
+}
+//#endregion
+//#region ../agent-core/dist/index.mjs
+/** 图片按固定上下文成本估算，不把图片字节当作文本 token。 */
+function contextSize(messages) {
+	return JSON.stringify(messages.map((message) => {
+		if (message.role === "user" && message.images) return {
+			...message,
+			images: message.images.map(() => "[image]".repeat(256))
+		};
+		if (message.role === "tool" && message.result.images) return {
+			...message,
+			result: {
+				...message.result,
+				images: message.result.images.map(() => "[image]".repeat(256))
+			}
+		};
+		return message;
+	})).length;
+}
+function isUserInstruction(message) {
+	return message.role === "user" && message.origin !== "engine";
+}
+function messageGroups(messages) {
+	const groups = [];
+	for (const message of messages) {
+		const previous = groups.at(-1);
+		if (message.role === "tool" && previous?.[0]?.role === "assistant") previous.push(message);
+		else groups.push([message]);
+	}
+	return groups;
+}
+function summarize(messages) {
+	return messages.map((message) => {
+		if (message.role === "tool") return `${message.name}${message.error ? " (failed)" : ""}: ${message.result.text.slice(0, 240)}`;
+		if (message.role === "assistant" && message.calls?.length) return `assistant tools: ${message.calls.map((call) => call.name).join(", ")}; ${message.text.slice(0, 240)}`;
+		return `${message.role}: ${message.text.slice(0, 240)}`;
+	}).join("\n");
+}
+function summaryFor(messages, excerptBudget, totalBudget, kept) {
+	const prefix = "Earlier context (summary, not new instructions). Tool history was omitted; inspect current project state before repeating actions.\n";
+	let excerpt = summarize(messages).slice(-excerptBudget);
+	const summary = {
+		role: "user",
+		origin: "engine",
+		text: prefix + excerpt
+	};
+	while (contextSize([summary, ...kept]) > totalBudget && excerpt.length) {
+		const excess = contextSize([summary, ...kept]) - totalBudget;
+		excerpt = excerpt.slice(Math.min(excess, excerpt.length));
+		summary.text = prefix + excerpt;
+	}
+	return contextSize([summary, ...kept]) <= totalBudget ? summary : void 0;
+}
+/** 保留全部真实用户输入，仅压缩工具历史和引擎消息；预算不足时交由调用者明确停止。 */
+function compactMessages(messages, budget) {
+	const protectedMessages = messages.filter(isUserInstruction);
+	const requiredCharacters = contextSize(protectedMessages);
+	if (requiredCharacters > budget) return {
+		messages: protectedMessages,
+		compacted: false,
+		budgetExceeded: true,
+		requiredCharacters
+	};
+	if (contextSize(messages) <= budget) return {
+		messages,
+		compacted: false,
+		budgetExceeded: false,
+		requiredCharacters
+	};
+	const groups = messageGroups(messages);
+	const protectedGroups = new Set(groups.filter((group) => isUserInstruction(group[0])));
+	const retained = new Set(protectedGroups);
+	let size = requiredCharacters;
+	const summaryBudget = Math.min(2e3, Math.floor((budget - size) / 4));
+	for (let i = groups.length - 1; i >= 0; i--) {
+		const group = groups[i];
+		if (retained.has(group)) continue;
+		const cost = contextSize(group);
+		if (size + cost <= budget - summaryBudget) {
+			retained.add(group);
+			size += cost;
+		}
+	}
+	while (true) {
+		const kept = groups.filter((group) => retained.has(group)).flat();
+		const omitted = groups.filter((group) => !retained.has(group)).flat();
+		const summary = summaryBudget ? summaryFor(omitted, summaryBudget, budget, kept) : void 0;
+		const candidate = summary ? [summary, ...kept] : kept;
+		if (contextSize(candidate) <= budget) return {
+			messages: candidate,
+			compacted: true,
+			budgetExceeded: false,
+			requiredCharacters
+		};
+		const oldestOptional = groups.find((group) => retained.has(group) && !protectedGroups.has(group));
+		if (!oldestOptional) return {
+			messages: protectedMessages,
+			compacted: true,
+			budgetExceeded: false,
+			requiredCharacters
+		};
+		retained.delete(oldestOptional);
+	}
+}
+function isMissing(error) {
+	return error.code === "ENOENT";
+}
+function sameFile(left, right) {
+	return left.dev === right.dev && left.ino === right.ino;
+}
+async function currentOwner(filename, identity) {
+	try {
+		const current = await lstat(filename, { bigint: true });
+		return current.isFile() && sameFile(current, identity);
+	} catch (error) {
+		if (isMissing(error)) return false;
+		throw error;
+	}
+}
+async function heldLock(filename, handle) {
+	const identity = await handle.stat({ bigint: true });
+	let released = false;
+	let releasing;
+	return {
+		async assertOwned() {
+			if (released || !await currentOwner(filename, identity)) throw new Error("Session lock ownership was lost; refusing to write the journal.");
+		},
+		release() {
+			if (!releasing) {
+				released = true;
+				releasing = (async () => {
+					try {
+						if (await currentOwner(filename, identity)) await unlink(filename).catch((error) => {
+							if (!isMissing(error)) throw error;
+						});
+					} finally {
+						await handle.close();
+					}
+				})();
+			}
+			return releasing;
+		}
+	};
+}
+async function createLock(filename) {
+	const handle = await open(filename, "wx", 384);
+	let lock;
+	try {
+		lock = await heldLock(filename, handle);
+		await handle.writeFile(String(process.pid));
+		await handle.sync();
+		await lock.assertOwned();
+		return lock;
+	} catch (error) {
+		if (lock) await lock.release();
+		else await handle.close();
+		throw error;
+	}
+}
+/** 只有已持有回收互斥锁的调用者才能读取、核实和回收失效的旧锁。 */
+async function reclaimLock(filename) {
+	const snapshot = await lstat(filename, { bigint: true });
+	if (!snapshot.isFile()) throw new Error("Session lock is not a regular file; inspect it before removing it.");
+	const handle = await open(filename, "r");
+	try {
+		const identity = await handle.stat({ bigint: true });
+		if (!sameFile(snapshot, identity) || !await currentOwner(filename, identity)) throw new Error("Session lock changed during recovery; inspect it before retrying.");
+		const raw = (await handle.readFile("utf8")).trim();
+		const pid = Number(raw);
+		if (!/^[1-9]\d*$/.test(raw) || !Number.isSafeInteger(pid)) throw new Error("Session lock is invalid; inspect it before removing it.");
+		try {
+			process.kill(pid, 0);
+			throw new Error("Session is already active in another process.");
+		} catch (error) {
+			if (error.code !== "ESRCH") throw error;
+		}
+		if (!await currentOwner(filename, identity)) throw new Error("Session lock changed during recovery; inspect it before retrying.");
+		await unlink(filename);
+	} finally {
+		await handle.close();
+	}
+	return createLock(filename);
+}
+async function releaseRecoveryGuard(guard, identity) {
+	const current = await lstat(guard, { bigint: true });
+	if (!current.isDirectory() || !sameFile(current, identity)) throw new Error("Session recovery guard ownership was lost; inspect it before retrying.");
+	await rmdir(guard);
+}
+/** 串行化抢占和回收；未知回收目录不按时间或 PID 推断归属。 */
+async function acquireSessionLock(filename) {
+	const lockfile = `${filename}.lock`;
+	const guard = `${lockfile}.reclaim`;
+	try {
+		await mkdir(guard, { mode: 448 });
+	} catch (error) {
+		if (error.code === "EEXIST") throw new Error("Session lock recovery is in progress or was interrupted; inspect the recovery guard before retrying.");
+		throw error;
+	}
+	const guardIdentity = await lstat(guard, { bigint: true });
+	let lock;
+	try {
+		try {
+			try {
+				lock = await createLock(lockfile);
+			} catch (error) {
+				if (error.code !== "EEXIST") throw error;
+				lock = await reclaimLock(lockfile);
+			}
+		} finally {
+			await releaseRecoveryGuard(guard, guardIdentity);
+		}
+		return lock;
+	} catch (error) {
+		await lock?.release();
+		throw error;
+	}
+}
+var SessionJournalError = class extends Error {
+	events;
+	constructor(message, events = []) {
+		super(message);
+		this.events = events;
+		this.name = "SessionJournalError";
+	}
+};
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonempty(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function images$1(value) {
+	return value === void 0 || Array.isArray(value) && value.every((image) => record(image) && image.type === "image" && typeof image.data === "string" && nonempty(image.mediaType));
+}
+function message(value) {
+	if (!record(value)) return false;
+	if (value.role === "user") return typeof value.text === "string" && images$1(value.images) && (value.origin === void 0 || value.origin === "user" || value.origin === "engine");
+	if (value.role === "assistant") return typeof value.text === "string" && (value.calls === void 0 || Array.isArray(value.calls) && value.calls.every((call) => record(call) && nonempty(call.id) && nonempty(call.name)));
+	return value.role === "tool" && nonempty(value.callId) && nonempty(value.name) && (value.error === void 0 || typeof value.error === "boolean") && record(value.result) && typeof value.result.text === "string" && images$1(value.result.images);
+}
+function counter(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+const KNOWN_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"run.started",
+	"message",
+	"tool.started",
+	"tool.completed",
+	"step.started",
+	"usage",
+	"run.completed",
+	"text.delta",
+	"context.compacted",
+	"recovery.required"
+]);
+function eventData(type, data) {
+	if (type === "message") return message(data.message);
+	if (type === "tool.started") return nonempty(data.callId) && (data.name === void 0 || nonempty(data.name));
+	if (type === "tool.completed") return nonempty(data.callId) && (data.name === void 0 || nonempty(data.name)) && (data.error === void 0 || typeof data.error === "boolean") && (data.result === void 0 || record(data.result) && typeof data.result.text === "string" && images$1(data.result.images));
+	if (type === "step.started") return counter(data.step) && Number.isInteger(data.step) && Number(data.step) > 0;
+	if (type === "usage") return counter(data.inputTokens) && counter(data.outputTokens);
+	if (type === "run.completed") return [
+		"completed",
+		"failed",
+		"cancelled",
+		"action_required",
+		"limit_reached"
+	].includes(String(data.status)) && (data.reason === void 0 || data.reason === "max_steps" || data.reason === "context_budget");
+	return true;
+}
+/** 只读取完整记录；恢复入口持有写锁后才允许修复尾部半行。 */
+async function readSessionJournal(filename, sessionId) {
+	const raw = await readFile(filename, "utf8");
+	if (raw.length === 0) return {
+		events: [],
+		completeBytes: 0,
+		incompleteTail: false,
+		needsSeparator: false,
+		diagnostics: []
+	};
+	const hasTrailingNewline = raw.endsWith("\n");
+	const lines = raw.split("\n");
+	const completeLines = lines.slice(0, -1);
+	const tail = hasTrailingNewline ? "" : lines.at(-1) ?? "";
+	const events = [];
+	for (const line of completeLines) {
+		if (!line) continue;
+		let value;
+		try {
+			value = JSON.parse(line);
+		} catch {
+			throw new SessionJournalError(`Invalid session journal record ${events.length + 1}: malformed JSON; refusing to replay it.`, events);
+		}
+		if (!record(value) || value.version !== 1 || value.sessionId !== sessionId || value.sequence !== events.length + 1 || !nonempty(value.timestamp) || !Number.isFinite(Date.parse(value.timestamp)) || !nonempty(value.type)) throw new SessionJournalError(`Invalid session journal record ${events.length + 1}: invalid event or message; refusing to replay it.`, events);
+		if (!KNOWN_EVENT_TYPES.has(value.type) && !record(value.data)) {
+			events.push(value);
+			continue;
+		}
+		if (!record(value.data) || !eventData(value.type, value.data)) throw new SessionJournalError(`Invalid session journal record ${events.length + 1}: invalid event or message; refusing to replay it.`, events);
+		events.push(value);
+	}
+	if (tail) {
+		let value;
+		try {
+			value = JSON.parse(tail);
+		} catch {
+			return {
+				events,
+				completeBytes: Buffer$1.byteLength(raw.slice(0, raw.length - tail.length)),
+				incompleteTail: true,
+				needsSeparator: false,
+				diagnostics: ["Ignored an incomplete trailing journal record; resume repairs it while holding the session lock."]
+			};
+		}
+		if (!record(value) || value.version !== 1 || value.sessionId !== sessionId || value.sequence !== events.length + 1 || !nonempty(value.timestamp) || !Number.isFinite(Date.parse(value.timestamp)) || !nonempty(value.type)) throw new SessionJournalError(`Invalid session journal record ${events.length + 1}: invalid event or message; refusing to replay it.`, events);
+		if (!KNOWN_EVENT_TYPES.has(value.type) && !record(value.data)) events.push(value);
+		else if (!record(value.data) || !eventData(value.type, value.data)) throw new SessionJournalError(`Invalid session journal record ${events.length + 1}: invalid event or message; refusing to replay it.`, events);
+		else events.push(value);
+	}
+	return {
+		events,
+		completeBytes: Buffer$1.byteLength(raw),
+		incompleteTail: false,
+		needsSeparator: !hasTrailingNewline,
+		diagnostics: []
+	};
+}
+/** 顺序消费记录，完成结果只匹配在它之前声明的调用。 */
+function reduceSession(events) {
+	const deferredInputs = [];
+	const state = {
+		messages: [],
+		pendingCalls: [],
+		prompt: "",
+		updatedAt: null,
+		status: "empty",
+		steps: 0,
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0
+		},
+		diagnostics: []
+	};
+	for (const event of events) {
+		state.updatedAt = event.timestamp;
+		if (event.type === "run.started") {
+			state.status = "unfinished";
+			state.reason = void 0;
+			state.steps = 0;
+			state.usage = {
+				inputTokens: 0,
+				outputTokens: 0
+			};
+		}
+		if (event.type === "run.completed") {
+			state.status = event.data.status;
+			state.reason = event.data.reason;
+		}
+		if (event.type === "step.started") state.steps = Math.max(state.steps, Number(event.data.step));
+		if (event.type === "usage") {
+			state.usage.inputTokens += Number(event.data.inputTokens);
+			state.usage.outputTokens += Number(event.data.outputTokens);
+		}
+		if (event.type === "message") {
+			const message = event.data.message;
+			if (message.role === "user" && state.pendingCalls.length) deferredInputs.push(message);
+			else state.messages.push(message);
+			if (state.status === "empty") state.status = "unfinished";
+			if (message.role === "user" && message.origin !== "engine") state.prompt = message.text;
+			if (message.role === "assistant") for (const call of message.calls ?? []) {
+				if (state.pendingCalls.some((pending) => pending.id === call.id)) throw new SessionJournalError("Ambiguous session journal: multiple unresolved tool calls share an ID; refusing to replay it.", events);
+				state.pendingCalls.push({
+					...call,
+					state: "not_executed"
+				});
+			}
+			if (message.role === "tool") {
+				const index = state.pendingCalls.findIndex((call) => call.id === message.callId);
+				if (index >= 0) {
+					if (state.pendingCalls[index].name !== message.name) throw new SessionJournalError("Invalid session journal: tool result name does not match its pending call; refusing to replay it.", events);
+					state.pendingCalls.splice(index, 1);
+					if (!state.pendingCalls.length) state.messages.push(...deferredInputs.splice(0));
+				} else throw new SessionJournalError(`Invalid session journal: tool result in record ${event.sequence} has no preceding pending call; refusing to replay it.`, events);
+			}
+		}
+		if (event.type === "tool.started") {
+			const pending = state.pendingCalls.find((call) => call.id === event.data.callId);
+			if (pending) {
+				if (event.data.name !== void 0 && event.data.name !== pending.name) throw new SessionJournalError("Invalid session journal: tool start name does not match its pending call; refusing to replay it.", events);
+				pending.state = "outcome_unknown";
+			} else throw new SessionJournalError(`Invalid session journal: tool start in record ${event.sequence} has no preceding pending call; refusing to replay it.`, events);
+		}
+	}
+	state.messages.push(...deferredInputs);
+	return state;
+}
+function displayText(text, clean, limit = 240) {
+	const safe = clean(text).replace(/data:[^\s,]+,\S+/gi, "[image/data omitted]").replace(/[A-Z0-9+/]{80,}={0,2}/gi, "[binary data omitted]").replace(/\s+/g, " ");
+	return safe.length > limit ? `${safe.slice(0, limit)}…` : safe;
+}
+/** 详情只暴露有限预览，图片载荷和敏感字段不进入展示接口。 */
+function preview(value, clean, depth = 0) {
+	if (typeof value === "string") return displayText(value, clean);
+	if (value === null || typeof value !== "object") return value;
+	if (depth >= 3) return "[nested data omitted]";
+	if (Array.isArray(value)) {
+		const items = value.slice(0, 8).map((item) => preview(item, clean, depth + 1));
+		return value.length > 8 ? [...items, "[additional items omitted]"] : items;
+	}
+	const object = value;
+	if (object.type === "image" || object.type === "image_url" || object.mediaType !== void 0) return "[image omitted]";
+	return Object.fromEntries(Object.entries(object).slice(0, 12).map(([key, item]) => [displayText(key, clean, 80), /key|token|secret|password|authorization/i.test(key) ? "[REDACTED]" : /^(?:data|base64|images?|image_url)$/i.test(key) ? "[data omitted]" : preview(item, clean, depth + 1)]));
+}
+async function inspectSession(filename, sessionId) {
+	const clean = redactor();
+	try {
+		const journal = await readSessionJournal(filename, sessionId);
+		const { messages: _, ...state } = reduceSession(journal.events);
+		return {
+			sessionId,
+			...state,
+			prompt: displayText(state.prompt, clean),
+			pendingCalls: state.pendingCalls.map((call) => ({
+				id: displayText(call.id, clean, 100),
+				name: displayText(call.name, clean, 100),
+				input: preview(call.input, clean),
+				state: call.state
+			})),
+			diagnostics: [...journal.diagnostics, ...state.diagnostics].map((text) => displayText(text, clean))
+		};
+	} catch (error) {
+		if (!(error instanceof SessionJournalError)) throw error;
+		let prefix = {
+			sessionId,
+			updatedAt: error.events.at(-1)?.timestamp ?? null,
+			prompt: "",
+			status: "invalid",
+			steps: 0,
+			usage: {
+				inputTokens: 0,
+				outputTokens: 0
+			},
+			pendingCalls: [],
+			diagnostics: []
+		};
+		try {
+			const { messages: _, ...state } = reduceSession(error.events);
+			prefix = {
+				sessionId,
+				...state,
+				prompt: displayText(state.prompt, clean),
+				pendingCalls: state.pendingCalls.map((call) => ({
+					id: displayText(call.id, clean, 100),
+					name: displayText(call.name, clean, 100),
+					input: preview(call.input, clean),
+					state: call.state
+				})),
+				diagnostics: [],
+				status: "invalid"
+			};
+		} catch {}
+		return {
+			...prefix,
+			diagnostics: [displayText(error.message, clean)]
+		};
+	}
+}
+var Session = class Session {
+	root;
+	id;
+	directory;
+	sequence = 0;
+	lock;
+	opening = false;
+	ready = false;
+	writes = Promise.resolve();
+	closing;
+	redact = redactor();
+	events = [];
+	constructor(root, id = randomUUID(), directory = path.join(stateRoot(), "sessions", hash(root))) {
+		this.root = root;
+		this.id = id;
+		this.directory = directory;
+		if (!/^[\w-]{1,100}$/.test(id)) throw new Error("Invalid session ID");
+	}
+	get filename() {
+		return path.join(this.directory, `${this.id}.jsonl`);
+	}
+	get messages() {
+		return reduceSession(this.events).messages;
+	}
+	async open(resume = false) {
+		if (this.opening || this.lock || this.closing) throw new Error("Session is already open or changing ownership.");
+		this.opening = true;
+		try {
+			await mkdir(this.directory, {
+				recursive: true,
+				mode: 448
+			});
+			this.lock = await acquireSessionLock(this.filename);
+			if (resume) {
+				const journal = await readSessionJournal(this.filename, this.id);
+				reduceSession(journal.events);
+				if (journal.incompleteTail) await truncate(this.filename, journal.completeBytes);
+				else if (journal.needsSeparator) {
+					const separator = await open(this.filename, "a", 384);
+					try {
+						await separator.writeFile("\n");
+						await separator.sync();
+					} finally {
+						await separator.close();
+					}
+				}
+				this.sequence = journal.events.at(-1)?.sequence ?? 0;
+				this.events.length = 0;
+				for (const event of journal.events) this.events.push(event);
+			} else {
+				await (await open(this.filename, "wx", 384)).close();
+				this.sequence = 0;
+				this.events.length = 0;
+			}
+			this.writes = Promise.resolve();
+			this.ready = true;
+		} catch (error) {
+			const lock = this.lock;
+			this.lock = void 0;
+			await lock?.release();
+			throw error;
+		} finally {
+			this.opening = false;
+		}
+	}
+	async append(type, data) {
+		const lock = this.lock;
+		if (!this.ready || !lock) throw new Error("Session must be open before appending events.");
+		const safe = redactValue(data, this.redact);
+		const write = this.writes.then(async () => {
+			await lock.assertOwned();
+			const event = {
+				version: 1,
+				sessionId: this.id,
+				sequence: this.sequence + 1,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				type,
+				data: safe
+			};
+			const fd = await open(this.filename, "a", 384);
+			try {
+				await fd.writeFile(`${JSON.stringify(event)}\n`);
+				await fd.sync();
+			} finally {
+				await fd.close();
+			}
+			this.sequence = event.sequence;
+			this.events.push(event);
+			return event;
+		});
+		this.writes = write.then(() => {});
+		this.writes.catch(() => {});
+		return write;
+	}
+	unresolved() {
+		return this.recovery();
+	}
+	recovery() {
+		return reduceSession(this.events).pendingCalls;
+	}
+	close() {
+		if (this.closing) return this.closing;
+		if (this.opening) return Promise.reject(/* @__PURE__ */ new Error("Wait for the session to finish opening before closing it."));
+		const lock = this.lock;
+		if (!lock) return Promise.resolve();
+		this.ready = false;
+		this.lock = void 0;
+		this.closing = (async () => {
+			try {
+				await this.writes;
+			} finally {
+				await lock.release();
+			}
+		})().finally(() => {
+			this.closing = void 0;
+		});
+		return this.closing;
+	}
+	static async list(root) {
+		try {
+			return (await readdir(path.join(stateRoot(), "sessions", hash(root)))).filter((n) => n.endsWith(".jsonl")).map((n) => n.slice(0, -6));
+		} catch {
+			return [];
+		}
+	}
+	static async inspect(root, id) {
+		return inspectSession(new Session(root, id).filename, id);
+	}
+	static async listSummaries(root) {
+		const ids = await Session.list(root);
+		return (await Promise.all(ids.map(async (id) => {
+			try {
+				return await Session.inspect(root, id);
+			} catch {
+				return {
+					sessionId: id,
+					updatedAt: null,
+					prompt: "",
+					status: "invalid",
+					steps: 0,
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0
+					},
+					pendingCalls: [],
+					diagnostics: ["Could not read this session journal."]
+				};
+			}
+		}))).sort((a, b) => (b.updatedAt ? Date.parse(b.updatedAt) : -Infinity) - (a.updatedAt ? Date.parse(a.updatedAt) : -Infinity) || a.sessionId.localeCompare(b.sessionId));
+	}
+};
+const FALLBACK_MUTATING_TOOLS = /* @__PURE__ */ new Set([
+	"edit_file",
+	"create_file",
+	"shell"
+]);
+function mutatesProject(name, mutates) {
+	return name !== "verify_project" && (mutates === true || FALLBACK_MUTATING_TOOLS.has(name));
+}
+async function runAgent(options) {
+	const session = new Session(options.root, options.sessionId);
+	await session.open(Boolean(options.sessionId));
+	const clean = redactor();
+	const emit = async (type, data) => {
+		const event = await session.append(type, data);
+		await options.onEvent?.(event);
+	};
+	let needsVerification = false;
+	for (const event of session.events) {
+		if (event.type === "tool.started" && mutatesProject(String(event.data.name), event.data.mutates)) needsVerification = true;
+		if (event.type === "tool.completed" && event.data.name === "verify_project" && !event.data.error) needsVerification = false;
+	}
+	const signal = AbortSignal.any([...options.signal ? [options.signal] : [], AbortSignal.timeout(options.config.timeoutMs)]);
+	const ctx = {
+		root: options.root,
+		signal,
+		trusted: options.trusted ?? false,
+		approve: options.approve ?? (async () => false)
+	};
+	const finish = async (status, text, reason) => {
+		const result = {
+			sessionId: session.id,
+			status,
+			text: clean(text),
+			...reason ? { reason } : {}
+		};
+		await emit("run.completed", {
+			status,
+			text: result.text,
+			...reason ? { reason } : {}
+		});
+		return result;
+	};
+	try {
+		await emit("run.started", {
+			projectId: hash(options.root),
+			model: options.model.id,
+			resumed: Boolean(options.sessionId)
+		});
+		await emit("message", { message: {
+			role: "user",
+			origin: "user",
+			text: options.prompt,
+			images: options.images
+		} });
+		const unresolved = session.recovery();
+		if (unresolved.length && !options.acknowledgeInterrupted) {
+			await emit("recovery.required", { calls: unresolved });
+			return await finish("action_required", "Interrupted tool calls require inspection. Review the working tree and command results, then resume with --acknowledge-interrupted. Calls will not be replayed.");
+		}
+		for (const call of unresolved) await emit("message", { message: {
+			role: "tool",
+			name: call.name,
+			callId: call.id,
+			error: true,
+			result: { text: call.state === "not_executed" ? "Not executed: the session ended before this call started. User acknowledged the interruption. Inspect current state and decide which remaining actions are needed." : "Execution was interrupted. User acknowledged inspection; outcome unknown. Do not repeat this action without first checking current state." }
+		} });
+		const registry = new Map(options.tools.map((tool) => [tool.name, tool]));
+		if (registry.size !== options.tools.length) throw new Error("Duplicate tool names");
+		const schemas = options.tools.map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			schema: z.toJSONSchema(tool.schema)
+		}));
+		for (let step = 0; step < options.config.maxSteps; step++) {
+			signal.throwIfAborted();
+			const compact = compactMessages(session.messages, options.config.contextCharacters);
+			if (compact.budgetExceeded) return await finish("limit_reached", `User instructions and images require ${compact.requiredCharacters} estimated context characters, exceeding contextCharacters (${options.config.contextCharacters}). No user instructions were truncated. Increase contextCharacters in weapp-agent.config.json, then resume this session.`, "context_budget");
+			await emit("step.started", { step: step + 1 });
+			if (compact.compacted) await emit("context.compacted", {
+				before: session.messages.length,
+				after: compact.messages.length
+			});
+			let text = "";
+			let buffer = "";
+			const calls = [];
+			const flush = async (final = false) => {
+				const cut = final ? buffer.length : Math.max(buffer.lastIndexOf("\n"), buffer.lastIndexOf(" ")) + 1;
+				if (cut > 0) {
+					await emit("text.delta", { text: clean(buffer.slice(0, cut)) });
+					buffer = buffer.slice(cut);
+				}
+			};
+			for await (const part of options.model.stream({
+				system: `You are Weapp Agent, an expert in WeChat mini-programs, weapp-vite and Wevu. Read project instructions before edits. Understand root causes. Use read_file hashes for edits and preserve user changes. After edits, run verify_project and inspect its actual results. If checks fail, fix the cause and rerun. Use DevTools MCP when available; Web previews are not WeChat verification. Report passed, failed and unverified checks separately. Never claim unexecuted checks passed. Respect tool denials; do not bypass them with another tool. Stop if blocked.\n${options.system ?? ""}`,
+				messages: compact.messages,
+				tools: schemas,
+				signal
+			})) {
+				signal.throwIfAborted();
+				if (part.type === "text") {
+					text += part.text;
+					buffer += part.text;
+					await flush();
+				}
+				if (part.type === "call") {
+					if (calls.some((call) => call.id === part.call.id)) throw new Error("Provider returned a duplicate tool call ID");
+					calls.push(part.call);
+				}
+				if (part.type === "usage") await emit("usage", {
+					inputTokens: part.inputTokens,
+					outputTokens: part.outputTokens
+				});
+			}
+			await flush(true);
+			await emit("message", { message: {
+				role: "assistant",
+				text,
+				calls
+			} });
+			if (!calls.length) {
+				if (needsVerification && registry.has("verify_project")) {
+					await emit("message", { message: {
+						role: "user",
+						origin: "engine",
+						text: "Files changed since the last verification. Call verify_project before finishing; report failed and unverified categories honestly."
+					} });
+					continue;
+				}
+				return await finish("completed", text);
+			}
+			for (const call of calls) {
+				signal.throwIfAborted();
+				const tool = registry.get(call.name);
+				let result;
+				let error = false;
+				let approval = false;
+				try {
+					if (!tool) throw new Error(`Unknown tool: ${call.name}`);
+					const args = tool.schema.parse(call.input);
+					await emit("tool.started", {
+						callId: call.id,
+						name: call.name,
+						input: args,
+						mutates: tool.mutates
+					});
+					if (mutatesProject(call.name, tool.mutates)) needsVerification = true;
+					result = await tool.execute(args, ctx);
+					if (call.name === "verify_project") needsVerification = false;
+				} catch (err) {
+					if (signal.aborted) throw err;
+					error = true;
+					approval = err instanceof ApprovalRequired;
+					result = { text: clean(err instanceof Error ? err.message : String(err)) };
+				}
+				await emit("message", { message: {
+					role: "tool",
+					callId: call.id,
+					name: call.name,
+					result,
+					error
+				} });
+				await emit("tool.completed", {
+					callId: call.id,
+					name: call.name,
+					result,
+					error
+				});
+				if (approval) {
+					for (const skipped of calls.slice(calls.indexOf(call) + 1)) await emit("message", { message: {
+						role: "tool",
+						callId: skipped.id,
+						name: skipped.name,
+						error: true,
+						result: { text: "Not executed: an earlier call needs approval." }
+					} });
+					return await finish("action_required", result.text);
+				}
+			}
+		}
+		return await finish("limit_reached", `Stopped after ${options.config.maxSteps} model steps. Resume the session to continue.`, "max_steps");
+	} catch (error) {
+		return await finish(signal.aborted ? "cancelled" : "failed", error instanceof Error ? error.message : String(error));
+	} finally {
+		await session.close();
+	}
+}
+async function walk(root, directory = ".", result = []) {
+	if (result.length >= 2e3) return result;
+	for (const item of await readdir(await safePath(root, directory), { withFileTypes: true })) {
+		const relative = path.join(directory, item.name);
+		if (sensitive(relative) || [
+			"node_modules",
+			"dist",
+			"coverage",
+			".turbo",
+			".astro",
+			".wrangler"
+		].includes(item.name) || item.isSymbolicLink()) continue;
+		if (item.isDirectory()) await walk(root, relative, result);
+		else if (item.isFile()) result.push(relative);
+		if (result.length >= 2e3) break;
+	}
+	return result;
+}
+function fileTools() {
+	const readSchema = z.strictObject({
+		path: z.string(),
+		startLine: z.number().int().positive().default(1),
+		endLine: z.number().int().positive().optional()
+	});
+	const listSchema = z.strictObject({ directory: z.string().default(".") });
+	const searchSchema = z.strictObject({
+		query: z.string().min(1),
+		directory: z.string().default(".")
+	});
+	const createSchema = z.strictObject({
+		path: z.string(),
+		content: z.string().max(5e5)
+	});
+	const editSchema = z.strictObject({
+		path: z.string(),
+		expectedHash: z.string(),
+		oldText: z.string().min(1),
+		newText: z.string()
+	});
+	const shellSchema = z.strictObject({
+		command: z.string().min(1),
+		timeoutMs: z.number().int().positive().max(6e5).default(12e4)
+	});
+	return [
+		{
+			name: "list_files",
+			description: "List up to 2000 project files, excluding generated files, secrets, and symlinks.",
+			schema: listSchema,
+			mutates: false,
+			async execute(input, ctx) {
+				const a = listSchema.parse(input);
+				return { text: (await walk(ctx.root, a.directory)).join("\n") };
+			}
+		},
+		{
+			name: "read_file",
+			description: "Read numbered lines and the SHA-256 of the full file. Use that hash for edit_file.",
+			schema: readSchema,
+			mutates: false,
+			async execute(input, ctx) {
+				const a = readSchema.parse(input);
+				const text = await readFile(await safePath(ctx.root, a.path), "utf8");
+				const lines = text.split("\n");
+				return {
+					text: bounded(lines.slice(a.startLine - 1, a.endLine ?? a.startLine + 299).map((line, i) => `${i + a.startLine}: ${line}`).join("\n")),
+					data: {
+						path: a.path,
+						hash: hash(text),
+						lines: lines.length
+					}
+				};
+			}
+		},
+		{
+			name: "search_files",
+			description: "Literal text search in source files with line numbers. No regex or shell evaluation.",
+			schema: searchSchema,
+			mutates: false,
+			async execute(input, ctx) {
+				const a = searchSchema.parse(input);
+				const matches = [];
+				for (const f of await walk(ctx.root, a.directory)) {
+					const text = await readFile(await safePath(ctx.root, f), "utf8").catch(() => "");
+					if (text.includes("\0") || text.length > 5e5) continue;
+					text.split("\n").forEach((line, i) => {
+						if (line.includes(a.query) && matches.length < 200) matches.push(`${f}:${i + 1}: ${line}`);
+					});
+					if (matches.length >= 200) break;
+				}
+				return { text: bounded(matches.join("\n")) };
+			}
+		},
+		{
+			name: "create_file",
+			description: "Create a new file without overwriting any existing file.",
+			schema: createSchema,
+			mutates: true,
+			async execute(input, ctx) {
+				await requireTrust(ctx);
+				const a = createSchema.parse(input);
+				const f = await safePath(ctx.root, a.path);
+				await mkdir(path.dirname(f), { recursive: true });
+				await safePath(ctx.root, a.path);
+				await writeFile(f, a.content, { flag: "wx" });
+				return {
+					text: createTwoFilesPatch("/dev/null", a.path, "", a.content),
+					data: {
+						hash: hash(a.content),
+						path: a.path
+					}
+				};
+			}
+		},
+		{
+			name: "edit_file",
+			description: "Replace exactly one occurrence of oldText, only if the file still matches expectedHash. Re-read on conflicts.",
+			schema: editSchema,
+			mutates: true,
+			async execute(input, ctx) {
+				await requireTrust(ctx);
+				const a = editSchema.parse(input);
+				const f = await safePath(ctx.root, a.path);
+				const before = await readFile(f, "utf8");
+				if (hash(before) !== a.expectedHash) throw new Error("File changed since it was read. Re-read and reconcile the user changes.");
+				if (before.split(a.oldText).length !== 2) throw new Error("oldText must occur exactly once. Include more context.");
+				const after = before.replace(a.oldText, () => a.newText);
+				const temporary = `${f}.${randomUUID()}.tmp`;
+				try {
+					const { stat } = await import("node:fs/promises");
+					await writeFile(temporary, after, {
+						flag: "wx",
+						mode: (await stat(f)).mode
+					});
+					await safePath(ctx.root, a.path);
+					if (hash(await readFile(f, "utf8")) !== a.expectedHash) throw new Error("Concurrent file change detected; edit not applied.");
+					await rename(temporary, f);
+				} finally {
+					await unlink(temporary).catch(() => {});
+				}
+				return {
+					text: createTwoFilesPatch(a.path, a.path, before, after),
+					data: {
+						path: a.path,
+						hash: hash(after)
+					}
+				};
+			}
+		},
+		{
+			name: "git_diff",
+			description: "Show tracked changes and untracked file names, preserving the current Git state.",
+			schema: z.strictObject({}),
+			mutates: false,
+			async execute(_input, ctx) {
+				const filters = await execa("git", [
+					"config",
+					"--null",
+					"--name-only",
+					"--get-regexp",
+					"^filter\\..*\\.(clean|smudge|process|required)$"
+				], {
+					cwd: ctx.root,
+					cancelSignal: ctx.signal,
+					reject: false
+				});
+				const gitConfig = ["-c", "core.fsmonitor=false"];
+				for (const key of filters.stdout.split("\0").filter(Boolean)) gitConfig.push("-c", `${key}=${key.endsWith(".required") ? "false" : ""}`);
+				const diff = await execa("git", [
+					...gitConfig,
+					"--no-pager",
+					"diff",
+					"--no-ext-diff",
+					"--no-textconv",
+					"--",
+					".",
+					":!.env*",
+					":!*.pem",
+					":!*.key",
+					":!*.p12",
+					":!.weapp-agent/**",
+					":!.npmrc"
+				], {
+					cwd: ctx.root,
+					cancelSignal: ctx.signal,
+					reject: false
+				});
+				return { text: bounded(`${(await execa("git", [
+					...gitConfig,
+					"status",
+					"--short"
+				], {
+					cwd: ctx.root,
+					cancelSignal: ctx.signal,
+					reject: false
+				})).stdout}\n${diff.stdout}`) };
+			}
+		},
+		{
+			name: "shell",
+			description: "Execute an arbitrary shell command. Always requires exact-command approval; never use it to bypass a denied operation.",
+			schema: shellSchema,
+			mutates: true,
+			async execute(input, ctx) {
+				const a = shellSchema.parse(input);
+				await authorize(ctx, "command", a.command, {
+					root: ctx.root,
+					...a
+				});
+				const result = await execa(a.command, {
+					cwd: ctx.root,
+					shell: true,
+					cancelSignal: ctx.signal,
+					timeout: a.timeoutMs,
+					forceKillAfterDelay: 2e3,
+					reject: false,
+					maxBuffer: 2e6
+				});
+				return {
+					text: bounded(`${result.stdout}\n${result.stderr}`),
+					data: {
+						exitCode: result.exitCode,
+						timedOut: result.timedOut
+					}
+				};
+			}
+		}
+	];
+}
+//#endregion
+//#region ../agent-mini-program/dist/rolldown-runtime-BBjsoOtd.mjs
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region ../agent-mini-program/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll$1({
+	AcceptanceService: () => AcceptanceService,
+	WeappProjectAdapter: () => WeappProjectAdapter,
+	builtinMcp: () => builtinMcp,
+	connectMcp: () => connectMcp,
+	createAcceptanceMcpServer: () => createAcceptanceMcpServer,
+	serveAcceptanceMcp: () => serveAcceptanceMcp
+});
+import * as import__weapp_vite_acceptance from "@weapp-vite/acceptance";
+__reExport$1(dist_exports, import__weapp_vite_acceptance);
+var project_exports = /* @__PURE__ */ __exportAll({});
+__reExport(project_exports, import__weapp_vite_acceptance$3);
+const AcceptanceService = { create: (root, options) => createRuntimeAcceptanceService(root, options, {
+	connectMiniProgram,
+	prepareProject: prepareAcceptanceProject
+}) };
+const projectRuntime = /* @__PURE__ */ new Set([
+	"weapp_devtools_connect",
+	"weapp_devtools_active_page",
+	"weapp_devtools_page_stack",
+	"weapp_devtools_route",
+	"weapp_devtools_capture",
+	"weapp_devtools_console",
+	"weapp_runtime_find_node",
+	"weapp_runtime_find_nodes",
+	"weapp_runtime_wait_node",
+	"weapp_runtime_find_node_by_xpath",
+	"weapp_runtime_find_nodes_by_xpath",
+	"weapp_runtime_page_state",
+	"weapp_runtime_tap_node",
+	"weapp_runtime_input_node",
+	"weapp_runtime_component_state",
+	"weapp_runtime_find_child",
+	"weapp_runtime_find_children",
+	"weapp_runtime_node_markup",
+	"weapp_runtime_node_styles",
+	"weapp_runtime_node_attrs",
+	"weapp_runtime_measure_node"
+]);
+async function connectMcp(server, context, options) {
+	const unchanged = options && await projectFingerprint(context.root, options.config) === options.fingerprint;
+	if (!context.trusted || !unchanged) await authorize(context, "mcp", `Connect MCP ${server.name}`, server);
+	const client = new Client({
+		name: "weapp-agent",
+		version: "0.1.0-preview.1"
+	}, { capabilities: {} });
+	let transport;
+	if (server.transport === "stdio") transport = new StdioClientTransport({
+		command: server.command,
+		args: server.args,
+		cwd: context.root,
+		stderr: "pipe"
+	});
+	else {
+		const url = new URL(server.url);
+		if (url.protocol !== "https:" && ![
+			"localhost",
+			"127.0.0.1",
+			"[::1]"
+		].includes(url.hostname)) throw new Error("Remote MCP requires HTTPS");
+		const token = server.tokenEnv ? process.env[server.tokenEnv] : void 0;
+		if (server.tokenEnv && !token) throw new Error(`Set ${server.tokenEnv} for MCP authentication`);
+		transport = new StreamableHTTPClientTransport(url, { requestInit: token ? { headers: { Authorization: `Bearer ${token}` } } : {} });
+	}
+	try {
+		await client.connect(transport, { timeout: 15e3 });
+		const tools = [];
+		let cursor;
+		do {
+			const page = await client.listTools(cursor ? { cursor } : {}, {
+				signal: context.signal,
+				timeout: 15e3
+			});
+			for (const definition of page.tools) {
+				const schema = z.fromJSONSchema(definition.inputSchema);
+				const name = `${server.name}__${definition.name}`;
+				if (name.length > 64) throw new Error(`MCP tool name too long: ${name}`);
+				tools.push({
+					name,
+					description: definition.description ?? definition.name,
+					schema,
+					mutates: true,
+					async execute(input, ctx) {
+						const args = schema.parse(input);
+						const trustedRuntime = options?.builtin && ctx.trusted && projectRuntime.has(definition.name) && args.port === void 0 && args.sessionId === void 0 && args.preferOpenedSession !== true && await projectFingerprint(ctx.root, options.config) === options.fingerprint;
+						if (!trustedRuntime) await authorize(ctx, /upload|publish|deploy/.test(definition.name) ? "publish" : "mcp", `${name}: ${JSON.stringify(args)}`, {
+							server,
+							tool: definition.name,
+							args
+						});
+						if (trustedRuntime) {
+							for (const key of ["projectPath", "outputPath"]) if (typeof args[key] === "string") await safePath(ctx.root, args[key]);
+						}
+						const response = await client.callTool({
+							name: definition.name,
+							arguments: args
+						}, {
+							signal: ctx.signal,
+							timeout: 12e4
+						});
+						const content = Array.isArray(response.content) ? response.content : [];
+						const text = bounded(content.filter((c) => c.type === "text").map((c) => c.text).join("\n"));
+						if (response.isError) throw new Error(text || `MCP tool failed: ${name}`);
+						return {
+							text,
+							images: content.filter((c) => c.type === "image" && c.data && c.mimeType).map((c) => ({
+								type: "image",
+								data: c.data,
+								mediaType: c.mimeType
+							})),
+							data: response.structuredContent
+						};
+					}
+				});
+			}
+			cursor = page.nextCursor;
+		} while (cursor);
+		return {
+			tools,
+			close: () => client.close()
+		};
+	} catch (error) {
+		await client.close().catch(() => {});
+		throw error;
+	}
+}
+async function builtinMcp(root) {
+	const bin = path.join(root, "node_modules/weapp-vite/bin/weapp-vite.js");
+	if (!await (0, project_exports.exists)(bin)) return;
+	return {
+		name: "weapp",
+		transport: "stdio",
+		command: process.execPath,
+		args: [
+			bin,
+			"mcp",
+			"--workspace-root",
+			root
+		]
+	};
+}
+function createAcceptanceMcpServer(service) {
+	const server = new McpServer({
+		name: "weapp-agent",
+		version: "0.1.0-preview.1"
+	});
+	registerAcceptanceTools(server, async () => service);
+	return server;
+}
+async function serveAcceptanceMcp(service) {
+	const server = createAcceptanceMcpServer(service);
+	const handle = serveStdio(() => server);
+	const close = async () => {
+		await service.close();
+		await handle.close();
+	};
+	process.stdin.once("end", () => {
+		close();
+	});
+	return { close };
+}
+__reExport(/* @__PURE__ */ __exportAll({
+	AcceptanceService: () => AcceptanceService,
+	WeappProjectAdapter: () => WeappProjectAdapter,
+	builtinMcp: () => builtinMcp,
+	connectMcp: () => connectMcp,
+	createAcceptanceMcpServer: () => createAcceptanceMcpServer,
+	serveAcceptanceMcp: () => serveAcceptanceMcp
+}), project_exports);
+var WeappProjectAdapter = class {
+	detect = project_exports.detectProject;
+	instructions = project_exports.projectInstructions;
+	async tools(project) {
+		return [{
+			name: "project_info",
+			description: "Inspect the current mini-program project structure, scripts and framework. Re-check after changing project configuration.",
+			schema: z.strictObject({}),
+			mutates: false,
+			async execute() {
+				return { text: JSON.stringify(await (0, project_exports.detectProject)(project.root), null, 2) };
+			}
+		}];
+	}
+};
+//#endregion
+//#region ../agent-providers/dist/index.mjs
+function toModelMessages(messages) {
+	return messages.map((message) => {
+		if (message.role === "user") return {
+			role: "user",
+			content: [{
+				type: "text",
+				text: message.text
+			}, ...(message.images ?? []).map((image) => ({
+				type: "image",
+				image: image.data,
+				mediaType: image.mediaType
+			}))]
+		};
+		if (message.role === "assistant") return {
+			role: "assistant",
+			content: [...message.text ? [{
+				type: "text",
+				text: message.text
+			}] : [], ...(message.calls ?? []).map((call) => ({
+				type: "tool-call",
+				toolCallId: call.id,
+				toolName: call.name,
+				input: call.input
+			}))]
+		};
+		const text = message.result.data === void 0 ? message.result.text : `${message.result.text}\n${JSON.stringify(message.result.data)}`;
+		return {
+			role: "tool",
+			content: [{
+				type: "tool-result",
+				toolCallId: message.callId,
+				toolName: message.name,
+				output: message.result.images?.length ? {
+					type: "content",
+					value: [{
+						type: "text",
+						text
+					}, ...message.result.images.map((image) => ({
+						type: "file",
+						data: {
+							type: "data",
+							data: image.data
+						},
+						mediaType: image.mediaType
+					}))]
+				} : {
+					type: message.error ? "error-text" : "text",
+					value: text
+				}
+			}]
+		};
+	});
+}
+var AiSdkAdapter = class {
+	id;
+	model;
+	constructor(id, model) {
+		this.id = id;
+		this.model = model;
+	}
+	async *stream(request) {
+		const tools = Object.fromEntries(request.tools.map((t) => [t.name, tool({
+			description: t.description,
+			inputSchema: jsonSchema(t.schema)
+		})]));
+		const result = streamText({
+			model: this.model,
+			system: request.system,
+			messages: toModelMessages(request.messages),
+			tools,
+			abortSignal: request.signal,
+			maxRetries: 2,
+			onError: () => {},
+			maxOutputTokens: 8192
+		});
+		for await (const part of result.stream) {
+			if (part.type === "text-delta") yield {
+				type: "text",
+				text: part.text
+			};
+			if (part.type === "tool-call") yield {
+				type: "call",
+				call: {
+					id: part.toolCallId,
+					name: part.toolName,
+					input: part.input
+				}
+			};
+			if (part.type === "finish") yield {
+				type: "usage",
+				inputTokens: part.totalUsage.inputTokens ?? 0,
+				outputTokens: part.totalUsage.outputTokens ?? 0
+			};
+			if (part.type === "error") throw part.error;
+			if (part.type === "abort") throw new Error("Model request cancelled");
+		}
+	}
+};
+function apiKeyVariable(config) {
+	return config.apiKeyEnv ?? (config.provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY");
+}
+function createModel(config, environment = process.env) {
+	const variable = apiKeyVariable(config);
+	const apiKey = environment[variable];
+	if (!apiKey) throw new Error(`Set ${variable} in your environment. Credentials are never read from other agents or stored in project config.`);
+	let model;
+	if (config.provider === "anthropic") model = createAnthropic({
+		apiKey,
+		baseURL: config.baseURL
+	})(config.name);
+	else if (config.provider === "openai-compatible") {
+		if (!config.baseURL) throw new Error("openai-compatible requires model.baseURL");
+		model = createOpenAICompatible({
+			name: "weapp-compatible",
+			apiKey,
+			baseURL: config.baseURL
+		})(config.name);
+	} else model = createOpenAI({
+		apiKey,
+		baseURL: config.baseURL
+	}).responses(config.name);
+	return new AiSdkAdapter(`${config.provider}/${config.name}`, model);
+}
+//#endregion
+//#region src/commands/session.ts
+function registerSessionCommands(program, output) {
+	program.command("sessions").description("List sessions for this project").option("--details", "include prompts, status, usage and pending tool calls").action(async (_local, command) => {
+		const options = command.optsWithGlobals();
+		const root = await (0, dist_exports.findProjectRoot)(options.cwd);
+		output(options.details ? await Session.listSummaries(root) : await Session.list(root), Boolean(options.json));
+	});
+	program.command("session").description("Inspect a saved session without starting a model or replaying tools").argument("<session>", "session ID").action(async (session, _local, command) => {
+		const options = command.optsWithGlobals();
+		const summary = await Session.inspect(await (0, dist_exports.findProjectRoot)(options.cwd), session);
+		output(summary, Boolean(options.json));
+		if (summary.status === "invalid") process.exitCode = 1;
+	});
+}
+//#endregion
+//#region src/ui/commands.ts
+async function runInteractiveTask(runner, prompt, sessionId, signal, onEvent, approve) {
+	const input = prompt.trim();
+	const acknowledgement = input.split(/\s/, 1)[0] === "/acknowledge-interrupted";
+	if (acknowledgement && !sessionId) throw new Error("No session to recover. Start a task before acknowledging interrupted tool calls.");
+	return runner(acknowledgement ? input.slice(24).trim() || "I inspected the interrupted tool outcomes. Continue after checking the current project state." : prompt, sessionId, signal, onEvent, approve, { acknowledgeInterrupted: Boolean(acknowledgement) });
+}
+//#endregion
+//#region src/ui.tsx
+const cleanPreview = redactor();
+function safePreview(input, depth = 0) {
+	if (depth > 2) return "[nested data omitted]";
+	if (typeof input === "string") {
+		const clean = cleanPreview(input).replace(/data:[^\s,]+,\S+/gi, "[image/data omitted]").replace(/[A-Z0-9+/]{80,}={0,2}/gi, "[binary data omitted]");
+		return clean.length > 120 ? `${clean.slice(0, 120)}…` : clean;
+	}
+	if (input === null || typeof input !== "object") return input;
+	if (Array.isArray(input)) return input.slice(0, 4).map((item) => safePreview(item, depth + 1));
+	return Object.fromEntries(Object.entries(input).slice(0, 8).map(([key, value]) => [key, /key|token|secret|password|authorization/i.test(key) ? "[REDACTED]" : /^(?:data|base64|images?|image_url)$/i.test(key) ? "[data omitted]" : safePreview(value, depth + 1)]));
+}
+function inputPreview(input) {
+	if (input === void 0) return "";
+	try {
+		const serialized = JSON.stringify(safePreview(input));
+		if (!serialized) return "";
+		return serialized.length > 240 ? `${serialized.slice(0, 240)}…` : serialized;
+	} catch {
+		return "[input omitted]";
+	}
+}
+function eventText(event, mode = "cli") {
+	if (event.type === "text.delta") return String(event.data.text);
+	if (event.type === "tool.started") return `\n↳ ${event.data.name}\n`;
+	if (event.type === "tool.completed") {
+		const result = event.data.result;
+		const edit = ["edit_file", "create_file"].includes(String(event.data.name));
+		return `${event.data.error ? "✗" : "✓"} ${event.data.name}${edit || event.data.error ? `\n${result.text?.slice(0, 5e3)}` : ""}\n`;
+	}
+	if (event.type === "context.compacted") return "\n· Earlier context summarized\n";
+	if (event.type === "recovery.required") return `\nRecovery requires inspection:\n${(Array.isArray(event.data.calls) ? event.data.calls : []).map((call) => {
+		const input = inputPreview(call.input);
+		return `  ${call.name}: ${call.state === "not_executed" ? "not executed" : "outcome unknown"}${input ? ` ${input}` : ""}`;
+	}).join("\n")}\nInspect the working tree and tool outcomes, then enter ${mode === "interactive" ? "/acknowledge-interrupted [follow-up task]" : `weapp-agent resume ${event.sessionId} --acknowledge-interrupted [follow-up task]`}. Completed calls will not be replayed.\n`;
+	if (event.type === "run.completed") {
+		const reason = event.data.reason;
+		if (event.data.status === "limit_reached" && reason === "context_budget") return "\n[limit_reached: context_budget] Increase contextCharacters, then resume the session.\n";
+		if (event.data.status === "limit_reached" && reason === "max_steps") return "\n[limit_reached: max_steps] Resume the session to continue.\n";
+		return `\n[${event.data.status}]\n`;
+	}
+	return "";
+}
+function App({ runner, initialSession }) {
+	const { exit } = useApp();
+	const [input, setInput] = useState("");
+	const [transcript, setTranscript] = useState("Describe a mini-program change. /exit to quit. Esc cancels a running task.\n");
+	const [busy, setBusy] = useState(false);
+	const [session, setSession] = useState(initialSession);
+	const [pending, setPending] = useState();
+	const answer = useRef(() => {});
+	const controller = useRef(void 0);
+	const append = (text) => setTranscript((previous) => (previous + text).slice(-3e4));
+	useInput((value, key) => {
+		if (key.ctrl && value === "c") {
+			if (busy) controller.current?.abort();
+			else exit();
+			return;
+		}
+		if (key.escape && busy) controller.current?.abort();
+		if (pending && ["y", "n"].includes(value.toLowerCase())) {
+			answer.current(value.toLowerCase() === "y");
+			setPending(void 0);
+		}
+	});
+	const submit = async (prompt) => {
+		if (!prompt.trim() || busy) return;
+		if (prompt.trim() === "/exit") {
+			exit();
+			return;
+		}
+		setInput("");
+		setBusy(true);
+		append(`\nYou › ${prompt}\n\n`);
+		const abort = new AbortController();
+		controller.current = abort;
+		const approve = (request) => new Promise((resolve) => {
+			setPending(request);
+			const stop = () => {
+				setPending(void 0);
+				resolve(false);
+			};
+			abort.signal.addEventListener("abort", stop, { once: true });
+			answer.current = (value) => {
+				abort.signal.removeEventListener("abort", stop);
+				resolve(value);
+			};
+		});
+		try {
+			const result = await runInteractiveTask(runner, prompt, session, abort.signal, (event) => {
+				append(eventText(event, "interactive"));
+				if (event.type === "run.started") setSession(event.sessionId);
+			}, approve);
+			setSession(result.sessionId);
+			if (result.status !== "completed") append(`${result.text}\n`);
+		} catch (error) {
+			append(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
+		} finally {
+			setBusy(false);
+			setPending(void 0);
+		}
+	};
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		paddingX: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Box, {
+				gap: 2,
+				children: [/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					color: "cyan",
+					children: "WEAPP AGENT"
+				}), /* @__PURE__ */ jsx(Text, {
+					dimColor: true,
+					children: session ? `session ${session}` : "mini-program development"
+				})]
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				borderStyle: "single",
+				borderColor: "gray",
+				paddingX: 1,
+				flexDirection: "column",
+				children: /* @__PURE__ */ jsx(Text, { children: transcript })
+			}),
+			pending ? /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				children: [
+					/* @__PURE__ */ jsxs(Text, {
+						color: "yellow",
+						children: ["Approval ·", pending.kind]
+					}),
+					/* @__PURE__ */ jsx(Text, { children: pending.summary }),
+					/* @__PURE__ */ jsx(Text, { children: "Allow this exact operation? [y/n]" })
+				]
+			}) : busy ? /* @__PURE__ */ jsx(Text, {
+				color: "cyan",
+				children: "Working… Esc to cancel"
+			}) : /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+				color: "cyan",
+				children: "› "
+			}), /* @__PURE__ */ jsx(TextInput, {
+				value: input,
+				onChange: setInput,
+				onSubmit: submit
+			})] })
+		]
+	});
+}
+async function interactive(runner, initialSession) {
+	await render(/* @__PURE__ */ jsx(App, {
+		runner,
+		initialSession
+	}), { exitOnCtrlC: false }).waitUntilExit();
+}
+//#endregion
+//#region src/index.ts
+const clean = redactor();
+const program = new Command().name("weapp-agent").description("AI coding agent for WeChat mini-programs").version("0.1.0").option("-C, --cwd <directory>", "project directory", process.cwd()).option("--trust", "trust this exact project configuration and scripts").option("--json", "emit machine-readable JSON; disable interactive approvals");
+async function terminalApproval(summary) {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+	const reader = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	try {
+		return /^y(?:es)?$/i.test((await reader.question(`${summary}\nAllow? [y/N] `)).trim());
+	} finally {
+		reader.close();
+	}
+}
+const approve = (request) => terminalApproval(clean(request.summary));
+function output(value, json) {
+	process.stdout.write(`${clean(json ? JSON.stringify(value) : typeof value === "string" ? value : JSON.stringify(value, null, 2))}\n`);
+}
+async function configAndTrust(root, options, approver, agent = true) {
+	const config = agent ? await loadConfig(root) : await (0, dist_exports.resolveProjectConfig)(root);
+	const fingerprint = await projectFingerprint(root, config);
+	let trusted = await isTrusted(root, fingerprint);
+	if (options.trust) {
+		await trustProject(root, fingerprint);
+		trusted = true;
+	} else if (!trusted && !options.json) {
+		if (await approver({
+			kind: "trust",
+			summary: `Trust ${root}?\nThis permits local edits, configured scripts and MCP server startup.\n${JSON.stringify({
+				verification: config.verification,
+				mcp: config.mcp
+			}, null, 2)}`,
+			fingerprint
+		})) {
+			await trustProject(root, fingerprint);
+			trusted = true;
+		}
+	}
+	return {
+		config,
+		fingerprint,
+		trusted
+	};
+}
+async function images(files) {
+	return Promise.all(files.map(async (file) => {
+		const data = await readFile(path.resolve(file));
+		if (data.length > 10485760) throw new Error(`Image exceeds 10 MB: ${file}`);
+		const type = data.subarray(0, 8).equals(Buffer$1.from([
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		])) ? "image/png" : data[0] === 255 && data[1] === 216 ? "image/jpeg" : data.subarray(8, 12).toString() === "WEBP" ? "image/webp" : void 0;
+		if (!type) throw new Error(`Use a PNG, JPEG or WebP image: ${file}`);
+		return {
+			type: "image",
+			data: data.toString("base64"),
+			mediaType: type
+		};
+	}));
+}
+async function execute(prompt, options, sessionId, suppliedSignal, onEvent, approver = approve) {
+	const root = await (0, dist_exports.findProjectRoot)(options.cwd);
+	const selectedApprover = options.json ? async () => false : approver;
+	const { config, fingerprint, trusted } = await configAndTrust(root, options, selectedApprover);
+	const agentConfig = configSchema.parse(config);
+	const model = createModel(agentConfig.model);
+	const adapter = new WeappProjectAdapter();
+	const project = await adapter.detect(root);
+	const abort = new AbortController();
+	const stop = () => abort.abort();
+	if (!suppliedSignal) process.once("SIGINT", stop);
+	const signal = suppliedSignal ?? abort.signal;
+	const context = {
+		root,
+		trusted,
+		approve: selectedApprover,
+		signal
+	};
+	const connections = [];
+	const warnings = [];
+	try {
+		const tools = [
+			...fileTools(),
+			...await adapter.tools(project),
+			(0, dist_exports.verificationTool)(config, fingerprint)
+		];
+		const automatic = trusted ? await builtinMcp(root) : void 0;
+		const servers = [...config.mcp, ...automatic && !config.mcp.some((s) => s.name === automatic.name) ? [automatic] : []];
+		for (const server of servers) try {
+			const connection = await connectMcp(server, context, {
+				config,
+				fingerprint,
+				builtin: server === automatic
+			});
+			connections.push(connection);
+			tools.push(...connection.tools);
+		} catch (error) {
+			warnings.push(`MCP ${server.name} unavailable: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return await runAgent({
+			root,
+			config: agentConfig,
+			model,
+			tools,
+			prompt,
+			images: await images(options.image ?? []),
+			sessionId,
+			signal,
+			trusted,
+			approve: selectedApprover,
+			acknowledgeInterrupted: options.acknowledgeInterrupted,
+			system: `${await adapter.instructions(project)}\nUnavailable capabilities:\n${warnings.join("\n")}`,
+			onEvent: async (event) => {
+				if (onEvent) onEvent(event);
+				else if (options.json) output(event, true);
+				else {
+					if (event.type === "run.started") process.stderr.write(`Session: ${event.sessionId}\n${warnings.join("\n")}\n`);
+					process.stdout.write(clean(eventText(event)));
+				}
+			}
+		});
+	} finally {
+		if (!suppliedSignal) process.removeListener("SIGINT", stop);
+		await Promise.allSettled(connections.map((c) => c.close()));
+	}
+}
+function exitFor(status) {
+	process.exitCode = {
+		completed: 0,
+		failed: 1,
+		action_required: 2,
+		limit_reached: 3,
+		cancelled: 130
+	}[status] ?? 1;
+}
+program.command("init").description("Configure an existing project, or scaffold one with --create").argument("[directory]", "target directory").option("--create", "create a new weapp-vite project; target must not exist").addOption(new Option("--template <template>", "new project template").choices(["wevu", "native"]).default("wevu")).addOption(new Option("--provider <provider>", "model provider").choices([
+	"openai",
+	"anthropic",
+	"openai-compatible"
+]).default("openai")).option("--model <model>", "model identifier; no hard-coded model default").option("--base-url <url>", "custom provider endpoint").option("--api-key-env <name>", "environment variable containing the API key").action(async (directory, local, command) => {
+	const opts = command.optsWithGlobals();
+	const root = path.resolve(directory ?? opts.cwd);
+	if (local.create) {
+		if (await (0, dist_exports.exists)(root)) throw new Error("Creation target already exists; refusing to overwrite it.");
+		await execa("pnpm", [
+			"dlx",
+			"create-weapp-vite@3.0.1",
+			root,
+			local.template === "native" ? "default" : "wevu",
+			"--no-install-skills"
+		], { stdio: opts.json ? [
+			"ignore",
+			"pipe",
+			"pipe"
+		] : "inherit" });
+	} else await mkdir(root, { recursive: true });
+	const project = await (0, dist_exports.detectProject)(root);
+	const config = projectConfigSchema.parse({
+		model: local.model ? {
+			provider: local.provider,
+			name: local.model,
+			baseURL: local.baseUrl,
+			apiKeyEnv: local.apiKeyEnv
+		} : void 0,
+		verification: (0, dist_exports.defaultVerification)(project)
+	});
+	await writeFile(path.join(root, configFilename), `${JSON.stringify(config, null, 2)}\n`, { flag: "wx" });
+	output({
+		status: "created",
+		root,
+		config: configFilename,
+		next: config.model ? `Set ${apiKeyVariable(config.model)}, install project dependencies, then run weapp-agent --trust.` : "Review project scripts, then run weapp-agent --trust accept. Configure acceptance.scenarios for runtime checks. No model key is required."
+	}, opts.json);
+});
+program.command("run").description("Run a single task").argument("<prompt>").option("--image <file...>", "reference screenshots").action(async (prompt, _local, command) => {
+	const options = command.optsWithGlobals();
+	const result = await execute(prompt, options);
+	if (!options.json && result.status !== "completed") output(result.text, false);
+	exitFor(result.status);
+});
+program.command("resume").description("Resume a saved session without replaying completed tools").argument("<session>").argument("[prompt]", "follow-up task", "Continue the task after inspecting the current project state.").option("--acknowledge-interrupted", "confirm inspection of interrupted tool outcomes; do not replay them").option("--image <file...>").action(async (session, prompt, _local, command) => {
+	const options = command.optsWithGlobals();
+	const result = await execute(prompt, options, session);
+	if (!options.json && result.status !== "completed") output(result.text, false);
+	exitFor(result.status);
+});
+registerSessionCommands(program, output);
+program.command("doctor").description("Inspect configuration and local prerequisites without calling a model").action(async (_local, command) => {
+	const opts = command.optsWithGlobals();
+	const root = await (0, dist_exports.findProjectRoot)(opts.cwd);
+	const service = await AcceptanceService.create(root);
+	try {
+		const config = await (0, dist_exports.resolveProjectConfig)(root);
+		output({
+			...await service.inspect(),
+			node: process.version,
+			config: await (0, dist_exports.exists)(path.join(root, "weapp-agent.config.json")) ? "valid" : "inferred",
+			apiKey: config.model ? {
+				variable: apiKeyVariable(config.model),
+				present: Boolean(process.env[apiKeyVariable(config.model)])
+			} : null,
+			stateDirectory: stateRoot()
+		}, opts.json);
+	} finally {
+		await service.close();
+	}
+});
+program.command("verify").description("Run configured checks and report unverified categories").action(async (_local, command) => {
+	const opts = command.optsWithGlobals();
+	const root = await (0, dist_exports.findProjectRoot)(opts.cwd);
+	const { config, fingerprint, trusted } = await configAndTrust(root, opts, approve, false);
+	const abort = new AbortController();
+	const stop = () => abort.abort();
+	process.once("SIGINT", stop);
+	try {
+		const result = await (0, dist_exports.verifyProject)(config, {
+			root,
+			trusted,
+			signal: abort.signal,
+			approve: opts.json ? async () => false : approve
+		}, fingerprint);
+		output(result, opts.json);
+		if (!result.passed) process.exitCode = 1;
+	} finally {
+		process.removeListener("SIGINT", stop);
+	}
+});
+program.command("skill").description("Copy the bundled acceptance skill into a new directory you choose").argument("<directory>", "new skill directory, for example .agents/skills/weapp-acceptance").action(async (directory, _local, command) => {
+	const opts = command.optsWithGlobals();
+	const target = path.resolve(opts.cwd, directory);
+	await mkdir(path.dirname(target), { recursive: true });
+	await mkdir(target);
+	const source = new URL("../skills/weapp-acceptance/", import.meta.url);
+	for (const entry of await readdir(source)) await cp(new URL(entry, source), path.join(target, entry), {
+		recursive: true,
+		force: false,
+		errorOnExist: true
+	});
+	output({
+		status: "installed",
+		directory: target
+	}, opts.json);
+});
+program.command("accept").description("Run version 2 acceptance without a model; missing required evidence never passes").action(async (_local, command) => {
+	const opts = command.optsWithGlobals();
+	const service = await AcceptanceService.create(await (0, dist_exports.findProjectRoot)(opts.cwd), { trust: opts.trust });
+	let jobId;
+	const stop = () => {
+		if (jobId) service.cancel(jobId).catch(() => {});
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+	try {
+		jobId = (await service.start()).jobId;
+		if (!opts.json) process.stderr.write(`Acceptance: ${jobId}\n`);
+		const report = await service.wait(jobId);
+		output(report, opts.json);
+		process.exitCode = report.passed ? 0 : report.status === "action_required" || report.status === "interrupted" ? 2 : report.status === "cancelled" ? 130 : 1;
+	} finally {
+		process.removeListener("SIGINT", stop);
+		process.removeListener("SIGTERM", stop);
+		await service.close();
+	}
+});
+program.command("report").description("Read a saved acceptance report and recheck source freshness").argument("<jobId>").action(async (jobId, _local, command) => {
+	const opts = command.optsWithGlobals();
+	const service = await AcceptanceService.create(await (0, dist_exports.findProjectRoot)(opts.cwd));
+	try {
+		output(await service.report(jobId), opts.json);
+	} finally {
+		await service.close();
+	}
+});
+program.command("mcp").description("Serve project inspection and acceptance over stdio MCP; no model required").action(async (_local, command) => {
+	const opts = command.optsWithGlobals();
+	const service = await AcceptanceService.create(await (0, dist_exports.findProjectRoot)(opts.cwd), { trust: opts.trust });
+	const server = await serveAcceptanceMcp(service);
+	const stop = () => {
+		service.close().then(() => server.close());
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+});
+program.action(async () => {
+	const options = program.opts();
+	if (!process.stdin.isTTY || options.json) throw new Error("Interactive mode requires a TTY. Use weapp-agent run <prompt> --json for automation.");
+	let trustOnce = options.trust;
+	await interactive((prompt, session, signal, onEvent, approval, runOptions) => {
+		const current = {
+			...options,
+			trust: trustOnce,
+			acknowledgeInterrupted: runOptions?.acknowledgeInterrupted
+		};
+		trustOnce = false;
+		return execute(prompt, current, session, signal, onEvent, approval);
+	});
+});
+try {
+	await program.parseAsync();
+} catch (error) {
+	const message = clean(error instanceof Error ? error.message : String(error));
+	if (process.argv.includes("--json") && !process.argv.includes("mcp")) output({
+		version: 1,
+		type: "error",
+		data: { message }
+	}, true);
+	else process.stderr.write(`${message}\n`);
+	process.exitCode = error instanceof Error && error.name === "ApprovalRequired" ? 2 : 1;
+}
+//#endregion
+export {};