@weapp-vite/acceptance 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WeappJS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,288 @@
+import { z } from "zod";
+//#region ../agent-core/dist/security-DIrnqlSa.d.mts
+//#region src/config.d.ts
+declare const verificationSchema: z.ZodObject<{
+  kind: z.ZodEnum<{
+    typecheck: "typecheck";
+    build: "build";
+    test: "test";
+    devtools: "devtools";
+  }>;
+  command: z.ZodString;
+  args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  timeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+declare const mcpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  name: z.ZodString;
+  transport: z.ZodLiteral<"stdio">;
+  command: z.ZodString;
+  args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+  name: z.ZodString;
+  transport: z.ZodLiteral<"http">;
+  url: z.ZodURL;
+  tokenEnv: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "transport">;
+declare const projectConfigSchema: z.ZodObject<{
+  version: z.ZodDefault<z.ZodLiteral<1>>;
+  model: z.ZodOptional<z.ZodObject<{
+    provider: z.ZodEnum<{
+      openai: "openai";
+      anthropic: "anthropic";
+      "openai-compatible": "openai-compatible";
+    }>;
+    name: z.ZodString;
+    baseURL: z.ZodOptional<z.ZodURL>;
+    apiKeyEnv: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  maxSteps: z.ZodDefault<z.ZodNumber>;
+  timeoutMs: z.ZodDefault<z.ZodNumber>;
+  contextCharacters: z.ZodDefault<z.ZodNumber>;
+  verification: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    kind: z.ZodEnum<{
+      typecheck: "typecheck";
+      build: "build";
+      test: "test";
+      devtools: "devtools";
+    }>;
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strict>>>;
+  mcp: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodLiteral<"http">;
+    url: z.ZodURL;
+    tokenEnv: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>], "transport">>>;
+  acceptance: z.ZodDefault<z.ZodObject<{
+    requiredChecks: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+      typecheck: "typecheck";
+      build: "build";
+      test: "test";
+      devtools: "devtools";
+    }>>>;
+    scenarios: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type ProjectConfig = z.infer<typeof projectConfigSchema>;
+type VerificationCommand = z.infer<typeof verificationSchema>;
+type McpConfig = z.infer<typeof mcpSchema>;
+declare function configurationSource(config: ProjectConfig): string | undefined;
+declare function loadAcceptanceConfig(root: string, explicit?: string): Promise<ProjectConfig | undefined>;
+declare function stateRoot(): string;
+declare function projectFingerprint(root: string, config: ProjectConfig): Promise<string>;
+//#endregion
+//#region src/types.d.ts
+interface ImageInput {
+  type: 'image';
+  data: string;
+  mediaType: string;
+}
+interface ToolResult {
+  text: string;
+  images?: ImageInput[];
+  data?: unknown;
+}
+interface Approval {
+  kind: 'trust' | 'command' | 'external' | 'mcp' | 'publish';
+  summary: string;
+  fingerprint: string;
+}
+type Approver = (request: Approval) => Promise<boolean>;
+interface ToolContext {
+  root: string;
+  signal: AbortSignal;
+  trusted: boolean;
+  approve: Approver;
+}
+interface Tool {
+  name: string;
+  description: string;
+  schema: z.ZodType;
+  /** Pure metadata. Every side effect still passes through execute's permission checks. */
+  mutates: boolean;
+  execute: (input: unknown, context: ToolContext) => Promise<ToolResult>;
+}
+interface ProjectInfo {
+  root: string;
+  kind: 'wevu' | 'native' | 'unknown';
+  packageManager: 'pnpm' | 'npm' | 'yarn' | 'bun';
+  sourceRoot: string;
+  outputRoot: string;
+  pages: string[];
+  subPackages: string[];
+  scripts: Record<string, string>;
+  weappViteVersion?: string;
+  warnings: string[];
+}
+declare function redactor(environment?: NodeJS.ProcessEnv): (text: string) => string;
+/** Canonicalize ancestors even for new files: symlink escapes cannot bypass the boundary. */
+declare function safePath(root: string, file: string): Promise<string>;
+declare function redactValue<T>(value: T, clean?: (text: string) => string): T;
+//#endregion
+//#region src/runtime.d.ts
+export interface RuntimeConnection {
+  tools: Tool[];
+  close: () => Promise<void>;
+}
+export type RuntimeConnector = (server: McpConfig, context: ToolContext, options: {
+  config: ProjectConfig;
+  fingerprint: string;
+  builtin: boolean;
+}) => Promise<RuntimeConnection>;
+//#endregion
+//#region src/scenario.d.ts
+export declare const scenarioSchema: z.ZodObject<{
+  version: z.ZodLiteral<1>;
+  name: z.ZodString;
+  steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"route">;
+    path: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"find">;
+    selector: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"tap">;
+    selector: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"input">;
+    selector: z.ZodString;
+    value: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"wait">;
+    selector: z.ZodString;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"assert">;
+    selector: z.ZodString;
+    text: z.ZodString;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"screenshot">;
+  }, z.core.$strict>], "action">>;
+}, z.core.$strict>;
+export type Scenario = z.infer<typeof scenarioSchema>;
+export interface ScenarioStepResult {
+  scenario: string;
+  index: number;
+  action: string;
+  status: 'running' | 'passed' | 'failed';
+  startedAt: string;
+  finishedAt?: string;
+  input: unknown;
+  actual?: unknown;
+  error?: string;
+}
+/** A task owns one connection; all operations use the same scoped runtime. */
+export declare function runtimeInvoker(connection: RuntimeConnection, context: ToolContext): (name: string, args: Record<string, unknown>) => Promise<Record<string, any>>;
+export declare function runScenario(scenario: Scenario, invoke: ReturnType<typeof runtimeInvoker>, context: ToolContext, onStep: (step: ScenarioStepResult) => Promise<void>, capture: () => Promise<string>): Promise<void>;
+//#endregion
+//#region src/verify.d.ts
+export interface CheckResult {
+  kind: VerificationCommand['kind'];
+  status: 'passed' | 'failed' | 'unverified';
+  command?: string;
+  exitCode?: number;
+  timedOut?: boolean;
+  output: string;
+}
+export interface VerificationReport {
+  passed: boolean;
+  checks: CheckResult[];
+}
+export declare function verifyProject(config: ProjectConfig, context: ToolContext, originalFingerprint: string, onCheck?: (check: CheckResult) => Promise<void>, skipKinds?: CheckResult['kind'][]): Promise<VerificationReport>;
+export declare function verificationTool(config: ProjectConfig, fingerprint: string): Tool;
+//#endregion
+//#region src/acceptance.d.ts
+export type AcceptanceStatus = 'running' | 'passed' | 'failed' | 'unverified' | 'action_required' | 'cancelled' | 'timed_out' | 'interrupted';
+export interface AcceptanceReport {
+  version: 2;
+  jobId: string;
+  root: string;
+  ownerPid: number;
+  status: AcceptanceStatus;
+  passed: boolean;
+  startedAt: string;
+  finishedAt?: string;
+  project: ProjectInfo;
+  requiredChecks: ProjectConfig['acceptance']['requiredChecks'];
+  checks: CheckResult[];
+  steps: ScenarioStepResult[];
+  artifacts: Array<{
+    name: string;
+    mediaType: string;
+  }>;
+  runtime: 'unverified' | 'wechat-devtools';
+  snapshot: {
+    before?: string;
+    after?: string;
+    current?: string;
+    stale: boolean;
+  };
+  reason?: string;
+  warnings: string[];
+}
+export declare function resolveProjectConfig(root: string, file?: string): Promise<ProjectConfig>;
+export interface AcceptanceOptions {
+  /** Explicit CLI startup authorization only; never accepted as an MCP tool argument. */
+  trust?: boolean;
+  connect?: RuntimeConnector;
+  configFile?: string;
+}
+export declare class AcceptanceService {
+  readonly root: string;
+  private directory;
+  private options;
+  private jobs;
+  private starting;
+  private closed;
+  private constructor();
+  static create(root: string, options?: AcceptanceOptions): Promise<AcceptanceService>;
+  private jobDirectory;
+  inspect(): Promise<{
+    version: number;
+    project: ProjectInfo;
+    supported: boolean;
+    modelRequired: boolean;
+    configurationSource: string;
+    trusted: boolean;
+    localMcp: boolean;
+    requiredChecks: ("typecheck" | "build" | "test" | "devtools")[];
+    configuredChecks: ("typecheck" | "build" | "test" | "devtools")[];
+    scenarios: string[];
+    scenarioProblems: string[];
+    hasTestAppId: boolean;
+    prerequisites: string[];
+  }>;
+  start(): Promise<AcceptanceReport>;
+  private startTask;
+  private execute;
+  report(jobId: string): Promise<AcceptanceReport>;
+  wait(jobId: string): Promise<AcceptanceReport>;
+  cancel(jobId: string): Promise<AcceptanceReport>;
+  artifact(jobId: string, name: string): Promise<{
+    mediaType: string;
+    data: string;
+  }>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/project.d.ts
+export declare function exists(file: string): Promise<boolean>;
+export declare function findProjectRoot(cwd: string): Promise<string>;
+export declare function detectProject(root: string): Promise<ProjectInfo>;
+export declare function defaultVerification(project: ProjectInfo): VerificationCommand[];
+export declare function projectInstructions(project: ProjectInfo): Promise<string>;
+//#endregion
+//#region src/snapshot.d.ts
+/** Include untracked source/config files, without executing Git hooks or Vite config. */
+export declare function sourceSnapshot(project: ProjectInfo): Promise<string>;
+//#endregion
+export { type ProjectConfig, type ToolContext, configurationSource, loadAcceptanceConfig, projectConfigSchema, projectFingerprint, redactValue, redactor, safePath, stateRoot };

package/dist/index.mjs

@@ -0,0 +1,1017 @@
+import { createHash, randomUUID } from "node:crypto";
+import { access, lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { setTimeout } from "node:timers/promises";
+import { execa } from "execa";
+//#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
+	})
+});
+projectConfigSchema.extend({ model: modelSchema });
+const configFilename = "weapp-agent.config.json";
+const acceptanceConfigFilename = "weapp-acceptance.config.json";
+const selectedConfigs = /* @__PURE__ */ new WeakMap();
+function configurationSource(config) {
+	return selectedConfigs.get(config);
+}
+async function loadAcceptanceConfig(root, explicit) {
+	for (const file of explicit ? [explicit] : [acceptanceConfigFilename, configFilename]) {
+		const target = await safePath(root, file);
+		let raw;
+		try {
+			raw = await readFile(target, "utf8");
+		} catch (error) {
+			if (!explicit && error.code === "ENOENT") continue;
+			throw error;
+		}
+		const schema = file === "weapp-agent.config.json" ? projectConfigSchema : projectConfigSchema.pick({
+			version: true,
+			verification: true,
+			acceptance: true
+		});
+		const config = projectConfigSchema.parse(schema.parse(JSON.parse(raw)));
+		selectedConfigs.set(config, path.relative(await realpath(root), target));
+		return 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 src/persistence.ts
+/** 通过一次临时文件写入和原子替换发布完整、已脱敏的报告。 */
+async function atomicJson(file, data, platform = process.platform) {
+	const temp = `${file}.${randomUUID()}.tmp`;
+	await writeFile(temp, JSON.stringify(redactValue(data), null, 2), { mode: 384 });
+	for (let retry = 0;; retry++) try {
+		await rename(temp, file);
+		return;
+	} catch (error) {
+		if (platform !== "win32" || retry >= 20 || ![
+			"EPERM",
+			"EACCES",
+			"EBUSY"
+		].includes(error.code ?? "")) throw error;
+		await setTimeout(Math.min((retry + 1) * 10, 100));
+	}
+}
+//#endregion
+//#region src/project.ts
+async function json(file) {
+	try {
+		return JSON.parse(await readFile(file, "utf8"));
+	} catch {
+		return {};
+	}
+}
+async function exists(file) {
+	try {
+		await access(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findProjectRoot(cwd) {
+	const start = await realpath(cwd);
+	let dir = start;
+	for (;;) {
+		const pkg = await json(path.join(dir, "package.json"));
+		if (await exists(path.join(dir, "weapp-agent.config.json")) || await exists(path.join(dir, "weapp-acceptance.config.json")) || pkg.dependencies?.["weapp-vite"] || pkg.devDependencies?.["weapp-vite"] || await exists(path.join(dir, "project.config.json"))) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return start;
+		dir = parent;
+	}
+}
+async function detectProject(root) {
+	root = await realpath(root);
+	const pkg = await json(path.join(root, "package.json"));
+	const config = await json(path.join(root, "project.config.json"));
+	const dependencies = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	let vite = "";
+	for (const file of [
+		"vite.config.ts",
+		"vite.config.js",
+		"vite.config.mts"
+	]) if (await exists(path.join(root, file))) vite = await readFile(path.join(root, file), "utf8");
+	const sourceRoot = vite.match(/\bsrcRoot\s*:\s*['"]([^'"]+)['"]/)?.[1] ?? (await exists(path.join(root, "src")) ? "src" : ".");
+	const outputRoot = vite.match(/\boutDir\s*:\s*['"]([^'"]+)['"]/)?.[1] ?? config.miniprogramRoot ?? (dependencies["weapp-vite"] ? "dist" : ".");
+	await safePath(root, sourceRoot);
+	await safePath(root, outputRoot);
+	const app = await json(path.join(root, sourceRoot, "app.json"));
+	const sources = [];
+	const scan = async (directory, depth = 0) => {
+		if (depth > 8 || sources.length > 2e3) return;
+		const entries = await readdir(await safePath(root, directory), { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			if (entry.isSymbolicLink() || entry.name.startsWith(".") || ["node_modules", "dist"].includes(entry.name)) continue;
+			const relative = path.join(directory, entry.name);
+			if (entry.isDirectory()) await scan(relative, depth + 1);
+			else if (/\.(?:vue|wxml)$/.test(entry.name)) sources.push(path.relative(sourceRoot, relative).split(path.sep).join("/"));
+		}
+	};
+	await scan(sourceRoot);
+	const hasVue = sources.some((file) => file.endsWith(".vue"));
+	const hasNative = sources.some((file) => file.endsWith(".wxml"));
+	const warnings = [];
+	if (vite && !/\bsrcRoot\s*:\s*['"]/.test(vite) && !await exists(path.join(root, sourceRoot, "app.json"))) warnings.push("Dynamic Vite configuration: source/output paths are inferred. Check project_info before editing.");
+	return {
+		root,
+		kind: hasVue && Boolean(dependencies.wevu) ? "wevu" : hasNative || dependencies["weapp-vite"] || config.appid || app.pages ? "native" : "unknown",
+		packageManager: String(pkg.packageManager ?? "").startsWith("yarn") ? "yarn" : String(pkg.packageManager ?? "").startsWith("bun") ? "bun" : await exists(path.join(root, "pnpm-lock.yaml")) || await exists(path.join(root, "pnpm-workspace.yaml")) || String(pkg.packageManager ?? "").startsWith("pnpm") ? "pnpm" : "npm",
+		sourceRoot,
+		outputRoot,
+		pages: Array.isArray(app.pages) ? app.pages : sources.filter((file) => file.startsWith("pages/")).map((file) => file.replace(/\.(vue|wxml)$/, "")),
+		subPackages: (app.subPackages ?? app.subpackages ?? []).map((p) => p.root),
+		scripts: pkg.scripts ?? {},
+		weappViteVersion: dependencies["weapp-vite"],
+		warnings
+	};
+}
+function defaultVerification(project) {
+	return [
+		"typecheck",
+		"build",
+		"test"
+	].filter((kind) => project.scripts[kind]).map((kind) => ({
+		kind,
+		command: project.packageManager,
+		args: ["run", kind],
+		timeoutMs: 12e4
+	}));
+}
+async function projectInstructions(project) {
+	const snippets = [];
+	const add = async (file) => {
+		try {
+			const target = await safePath(project.root, file);
+			snippets.push(`Instructions scoped to ${path.dirname(file)} (${file}):\n${bounded(await readFile(target, "utf8"), 12e3)}`);
+		} catch {}
+	};
+	await add("AGENTS.md");
+	await add("AGENTS.local.md");
+	const visit = async (directory, depth) => {
+		if (depth > 6 || snippets.join("").length > 32e3) return;
+		const entries = await readdir(await safePath(project.root, directory), { withFileTypes: true }).catch(() => []);
+		if (directory !== ".") {
+			if (entries.some((e) => e.name === "AGENTS.md")) await add(path.join(directory, "AGENTS.md"));
+			if (entries.some((e) => e.name === "AGENTS.local.md")) await add(path.join(directory, "AGENTS.local.md"));
+		}
+		for (const e of entries) if (e.isDirectory() && !e.isSymbolicLink() && !e.name.startsWith(".") && ![
+			"node_modules",
+			"dist",
+			"coverage"
+		].includes(e.name)) await visit(path.join(directory, e.name), depth + 1);
+	};
+	await visit(".", 0);
+	const docs = path.join(project.root, "node_modules/weapp-vite/dist/docs");
+	const names = await readdir(docs).catch(() => []);
+	for (const name of names.filter((n) => /^(?:README|ai|cli|getting-started|configuration).*\.md$/i.test(n)).slice(0, 4)) snippets.push(`Installed weapp-vite documentation (${name}):\n${bounded(await readFile(path.join(docs, name), "utf8"), 6e3)}`);
+	return `Project facts:\n${JSON.stringify(project)}\n${snippets.join("\n\n")}`;
+}
+//#endregion
+//#region src/scenario.ts
+const selector = z.string().trim().min(1);
+const timeoutMs = z.number().int().min(100).max(6e4).default(5e3);
+const scenarioSchema = z.strictObject({
+	version: z.literal(1),
+	name: z.string().min(1),
+	steps: z.array(z.discriminatedUnion("action", [
+		z.strictObject({
+			action: z.literal("route"),
+			path: z.string().startsWith("/")
+		}),
+		z.strictObject({
+			action: z.literal("find"),
+			selector
+		}),
+		z.strictObject({
+			action: z.literal("tap"),
+			selector
+		}),
+		z.strictObject({
+			action: z.literal("input"),
+			selector,
+			value: z.string()
+		}),
+		z.strictObject({
+			action: z.literal("wait"),
+			selector,
+			timeoutMs
+		}),
+		z.strictObject({
+			action: z.literal("assert"),
+			selector,
+			text: z.string(),
+			timeoutMs
+		}),
+		z.strictObject({ action: z.literal("screenshot") })
+	])).min(1).max(100)
+}).refine((s) => s.steps[0]?.action === "route", "Start each scenario with a route step").refine((s) => s.steps.some((step) => step.action === "assert"), "Each scenario requires an explicit assertion");
+/** A task owns one connection; all operations use the same scoped runtime. */
+function runtimeInvoker(connection, context) {
+	return async (name, args) => {
+		context.signal.throwIfAborted();
+		const tool = connection.tools.find((t) => t.name === `weapp__${name}`);
+		if (!tool) throw new Error(`Missing runtime capability: ${name}. Check the installed weapp-vite version.`);
+		const result = await tool.execute(args, context);
+		const data = result.data ?? JSON.parse(result.text);
+		if (!data || typeof data !== "object" || !("result" in data)) throw new Error(`Invalid runtime result: ${name}`);
+		return data.result;
+	};
+}
+async function runScenario(scenario, invoke, context, onStep, capture) {
+	const scope = {
+		projectPath: context.root,
+		preserveProjectRoot: true
+	};
+	for (const [index, step] of scenario.steps.entries()) {
+		context.signal.throwIfAborted();
+		const result = {
+			scenario: scenario.name,
+			index,
+			action: step.action,
+			input: step,
+			status: "running",
+			startedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await onStep(result);
+		try {
+			switch (step.action) {
+				case "route":
+					result.actual = await invoke("weapp_devtools_route", {
+						...scope,
+						path: step.path,
+						transition: "reLaunch"
+					});
+					break;
+				case "find":
+					result.actual = await invoke("weapp_runtime_find_node", {
+						...scope,
+						selector: step.selector
+					});
+					break;
+				case "tap":
+					result.actual = await invoke("weapp_runtime_tap_node", {
+						...scope,
+						selector: step.selector
+					});
+					break;
+				case "input":
+					result.actual = await invoke("weapp_runtime_input_node", {
+						...scope,
+						selector: step.selector,
+						value: step.value
+					});
+					break;
+				case "wait":
+					result.actual = await invoke("weapp_runtime_wait_node", {
+						...scope,
+						selector: step.selector,
+						timeoutMs: step.timeoutMs
+					});
+					break;
+				case "assert": {
+					const deadline = Date.now() + step.timeoutMs;
+					for (;;) {
+						const actual = await invoke("weapp_runtime_find_node", {
+							...scope,
+							selector: step.selector
+						});
+						result.actual = actual;
+						if (actual.text === step.text) break;
+						if (Date.now() >= deadline) throw new Error(`Assertion failed for ${step.selector}: expected ${JSON.stringify(step.text)}, received ${JSON.stringify(actual.text)}`);
+						await setTimeout(100, void 0, { signal: context.signal });
+					}
+					break;
+				}
+				case "screenshot": result.actual = {
+					artifact: await capture(),
+					purpose: "visual evidence, not a visual assertion"
+				};
+			}
+			result.status = "passed";
+		} catch (error) {
+			result.status = "failed";
+			result.error = error instanceof Error ? error.message : String(error);
+			throw error;
+		} finally {
+			result.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			await onStep(result);
+		}
+	}
+}
+//#endregion
+//#region src/snapshot.ts
+const excluded = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".weapp-agent",
+	".weapp-vite",
+	".turbo",
+	".cache",
+	".astro",
+	".DS_Store",
+	"coverage",
+	"artifacts"
+]);
+/** Include untracked source/config files, without executing Git hooks or Vite config. */
+async function sourceSnapshot(project) {
+	const hash = createHash("sha256");
+	const output = path.resolve(project.root, project.outputRoot);
+	const source = path.resolve(project.root, project.sourceRoot);
+	let files = 0;
+	const walk = async (directory) => {
+		const entries = (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+		for (const entry of entries) {
+			const target = path.join(directory, entry.name);
+			const relative = path.relative(project.root, target);
+			if (excluded.has(entry.name) || sensitive(relative) || output !== project.root && output !== source && target === output) continue;
+			if (entry.isSymbolicLink()) throw new Error(`Source snapshot does not support symlinks: ${relative} -> ${await readlink(target)}`);
+			if (entry.isDirectory()) await walk(target);
+			else if (entry.isFile()) {
+				if (++files > 2e4) throw new Error("Source snapshot exceeds 20000 files; select the mini-program package with -C.");
+				const bytes = await readFile(await safePath(project.root, relative));
+				hash.update(JSON.stringify([relative.split(path.sep).join("/"), bytes.length]));
+				hash.update(bytes);
+			}
+		}
+	};
+	await walk(project.root);
+	return hash.digest("hex");
+}
+//#endregion
+//#region src/verify.ts
+async function verifyProject(config, context, originalFingerprint, onCheck, skipKinds = []) {
+	await requireTrust(context);
+	const checks = [];
+	for (const command of config.verification.filter((c) => !skipKinds.includes(c.kind))) {
+		context.signal.throwIfAborted();
+		const current = await projectFingerprint(context.root, config);
+		if (current !== originalFingerprint || /publish|upload|deploy/i.test([command.command, ...command.args].join(" "))) await authorize(context, "command", `Verify: ${command.command} ${command.args.join(" ")}`, {
+			command,
+			fingerprint: current
+		});
+		const result = await execa(command.command, command.args, {
+			cwd: context.root,
+			cancelSignal: context.signal,
+			timeout: command.timeoutMs,
+			forceKillAfterDelay: 2e3,
+			reject: false,
+			maxBuffer: 2e6
+		});
+		context.signal.throwIfAborted();
+		checks.push({
+			kind: command.kind,
+			status: result.exitCode === 0 ? "passed" : "failed",
+			command: `${command.command} ${command.args.join(" ")}`,
+			exitCode: result.exitCode,
+			...result.timedOut ? { timedOut: true } : {},
+			output: bounded(result.timedOut ? `Verification command timed out after ${command.timeoutMs}ms.\n${result.stdout}\n${result.stderr}` : `${result.stdout}\n${result.stderr}`)
+		});
+		await onCheck?.(checks[checks.length - 1]);
+	}
+	for (const kind of [
+		"typecheck",
+		"build",
+		"test",
+		"devtools"
+	]) if (!checks.some((c) => c.kind === kind)) checks.push({
+		kind,
+		status: "unverified",
+		output: kind === "devtools" ? "No real DevTools verification command configured. Web preview is not WeChat runtime evidence." : "No verification command configured."
+	});
+	return {
+		passed: checks.some((c) => c.status === "passed") && !checks.some((c) => c.status === "failed"),
+		checks
+	};
+}
+function verificationTool(config, fingerprint) {
+	return {
+		name: "verify_project",
+		description: "Run configured typecheck/build/test/DevTools commands and return separate passed, failed and unverified results. Fix failures, then rerun. Missing checks are never considered passed.",
+		schema: z.strictObject({}),
+		mutates: true,
+		async execute(_input, context) {
+			const report = await verifyProject(config, context, fingerprint);
+			return {
+				text: JSON.stringify(report, null, 2),
+				data: report
+			};
+		}
+	};
+}
+//#endregion
+//#region src/acceptance.ts
+async function resolveProjectConfig(root, file) {
+	return await loadAcceptanceConfig(root, file) ?? projectConfigSchema.parse({ verification: defaultVerification(await detectProject(root)) });
+}
+function alive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+/** Locks survive server instances. Dead owners are inspected, never replayed. */
+async function lockProject(directory, jobId) {
+	const lock = path.join(directory, "lock");
+	try {
+		await mkdir(lock);
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		const recovery = path.join(directory, "lock-recovery");
+		try {
+			await mkdir(recovery);
+		} catch {
+			throw new ApprovalRequired("Project lock recovery is busy; retry after inspecting the previous task.");
+		}
+		try {
+			const owner = await readFile(path.join(lock, "owner.json"), "utf8").then(JSON.parse).catch(() => void 0);
+			if (!owner || alive(owner.pid)) throw new ApprovalRequired("Another acceptance task owns this project. Query/cancel that task before starting a new one.");
+			await rm(lock, {
+				recursive: true,
+				force: true
+			});
+		} finally {
+			await rm(recovery, {
+				recursive: true,
+				force: true
+			});
+		}
+		return lockProject(directory, jobId);
+	}
+	await atomicJson(path.join(lock, "owner.json"), {
+		pid: process.pid,
+		jobId
+	});
+	return async () => {
+		if (JSON.parse(await readFile(path.join(lock, "owner.json"), "utf8")).jobId === jobId) await rm(lock, {
+			recursive: true,
+			force: true
+		});
+	};
+}
+var AcceptanceService = class AcceptanceService {
+	root;
+	directory;
+	options;
+	jobs = /* @__PURE__ */ new Map();
+	starting = /* @__PURE__ */ new Set();
+	closed = false;
+	constructor(root, directory, options) {
+		this.root = root;
+		this.directory = directory;
+		this.options = options;
+	}
+	static async create(root, options = {}) {
+		root = await realpath(root);
+		const directory = path.join(stateRoot(), "acceptance", hash(root));
+		await mkdir(directory, {
+			recursive: true,
+			mode: 448
+		});
+		if (options.trust) {
+			const config = await resolveProjectConfig(root, options.configFile);
+			await trustProject(root, await projectFingerprint(root, config));
+		}
+		return new AcceptanceService(root, directory, options);
+	}
+	jobDirectory(jobId) {
+		if (!/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i.test(jobId)) throw new Error("Invalid acceptance job ID");
+		return path.join(this.directory, jobId);
+	}
+	async inspect() {
+		const project = await detectProject(this.root);
+		const config = await resolveProjectConfig(this.root, this.options.configFile);
+		const localMcp = Boolean(this.options.connect);
+		const trusted = await isTrusted(this.root, await projectFingerprint(this.root, config));
+		const scenarioProblems = [];
+		for (const file of config.acceptance.scenarios) try {
+			scenarioSchema.parse(JSON.parse(await readFile(await safePath(this.root, file), "utf8")));
+		} catch (error) {
+			scenarioProblems.push(`${file}: ${String(error)}`);
+		}
+		const missingChecks = config.acceptance.requiredChecks.filter((kind) => kind !== "devtools" && !config.verification.some((c) => c.kind === kind));
+		let hasTestAppId = false;
+		try {
+			const app = JSON.parse(await readFile(await safePath(this.root, "project.config.json"), "utf8"));
+			hasTestAppId = Boolean(app.appid && app.appid !== "touristappid");
+		} catch {}
+		return {
+			version: 2,
+			project,
+			supported: Boolean(project.weappViteVersion && project.kind !== "unknown"),
+			modelRequired: false,
+			configurationSource: configurationSource(config) ?? "auto",
+			trusted,
+			localMcp,
+			requiredChecks: config.acceptance.requiredChecks,
+			configuredChecks: config.verification.map((c) => c.kind),
+			scenarios: config.acceptance.scenarios,
+			scenarioProblems,
+			hasTestAppId,
+			prerequisites: [
+				...missingChecks.map((kind) => `Configure a ${kind} verification command in the selected acceptance configuration.`),
+				...scenarioProblems.map((problem) => `Repair scenario: ${problem}`),
+				...!trusted ? ["Review project scripts/configuration, then explicitly run wv accept --trust."] : [],
+				...!localMcp ? ["Install the project dependencies to provide the local weapp-vite MCP."] : [],
+				...!config.acceptance.scenarios.length ? ["Add acceptance.scenarios to the selected acceptance configuration for runtime assertions."] : [],
+				...!hasTestAppId ? ["Configure a real test AppID in project.config.json before runtime checks."] : [],
+				"Runtime checks require logged-in WeChat DevTools, its service port enabled, and a real test AppID. Connection has not been probed."
+			]
+		};
+	}
+	start() {
+		const pending = this.startTask();
+		this.starting.add(pending);
+		pending.then(() => this.starting.delete(pending), () => this.starting.delete(pending));
+		return pending;
+	}
+	async startTask() {
+		if (this.closed) throw new Error("Acceptance service is closed");
+		const project = await detectProject(this.root);
+		const config = await resolveProjectConfig(this.root, this.options.configFile);
+		const report = {
+			version: 2,
+			jobId: randomUUID(),
+			root: this.root,
+			ownerPid: process.pid,
+			status: "running",
+			passed: false,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			project,
+			requiredChecks: config.acceptance.requiredChecks,
+			checks: [],
+			steps: [],
+			artifacts: [],
+			runtime: "unverified",
+			snapshot: { stale: false },
+			warnings: [...project.warnings]
+		};
+		const directory = this.jobDirectory(report.jobId);
+		await mkdir(directory, { mode: 448 });
+		const persist = () => atomicJson(path.join(directory, "report.json"), report);
+		let release;
+		try {
+			if (!project.weappViteVersion || project.kind === "unknown") throw new ApprovalRequired("Acceptance supports weapp-vite native and Wevu projects on WeChat only.");
+			const fingerprint = await projectFingerprint(this.root, config);
+			if (!await isTrusted(this.root, fingerprint)) throw new ApprovalRequired("Review project scripts/configuration, then explicitly run wv accept --trust.");
+			release = await lockProject(this.directory, report.jobId);
+			if (this.closed) throw new Error("Acceptance service is shutting down; no checks were started");
+			const controller = new AbortController();
+			await persist();
+			const unlock = release;
+			const job = {
+				controller,
+				done: Promise.resolve(),
+				report,
+				persistenceFailed: false
+			};
+			job.done = this.execute(report, config, fingerprint, controller, persist).catch((error) => {
+				report.status = "failed";
+				report.passed = false;
+				report.reason = `Could not persist acceptance result: ${String(error)}`;
+			}).finally(async () => {
+				try {
+					await unlock();
+				} catch (error) {
+					report.warnings.push(`Project lock cleanup failed: ${String(error)}`);
+					report.status = "failed";
+					report.passed = false;
+					report.reason = "Project ownership could not be released; inspect the cleanup warning before retrying.";
+				}
+				await persist().catch((error) => {
+					job.persistenceFailed = true;
+					report.status = "failed";
+					report.passed = false;
+					report.reason = `Could not persist acceptance result: ${String(error)}`;
+				});
+				if (!job.persistenceFailed) this.jobs.delete(report.jobId);
+			});
+			this.jobs.set(report.jobId, job);
+		} catch (error) {
+			await release?.();
+			report.status = error instanceof ApprovalRequired ? "action_required" : "failed";
+			report.reason = error instanceof Error ? error.message : String(error);
+			report.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			await persist();
+		}
+		return redactValue(structuredClone(report));
+	}
+	async execute(report, config, fingerprint, controller, persist) {
+		const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(config.acceptance.timeoutMs)]);
+		const context = {
+			root: this.root,
+			trusted: true,
+			signal,
+			approve: async () => false
+		};
+		let connection;
+		const directory = this.jobDirectory(report.jobId);
+		const checkFreshness = async () => {
+			if (report.snapshot.before) report.snapshot.stale ||= report.snapshot.before !== await sourceSnapshot(report.project);
+		};
+		const recordCheck = async (check) => {
+			report.checks.push(check);
+			await checkFreshness();
+			await persist();
+		};
+		try {
+			report.snapshot.before = await sourceSnapshot(report.project);
+			const scenarios = [];
+			for (const file of config.acceptance.scenarios) scenarios.push(scenarioSchema.parse(JSON.parse(await readFile(await safePath(this.root, file), "utf8"))));
+			await persist();
+			if (new Set(scenarios.map((s) => s.name)).size !== scenarios.length) throw new Error("Scenario names must be unique within an acceptance task");
+			if (scenarios.length && this.options.connect) connection = await this.options.connect({
+				name: "weapp",
+				transport: "stdio",
+				command: "",
+				args: []
+			}, context, {
+				config,
+				fingerprint,
+				builtin: true
+			});
+			await verifyProject(config, context, fingerprint, recordCheck, ["devtools"]);
+			if (scenarios.length && report.checks.some((c) => c.kind === "build" && c.status === "passed") && !report.checks.some((c) => c.status === "failed")) {
+				if (await projectFingerprint(this.root, config) !== fingerprint) throw new ApprovalRequired("Project configuration changed during verification. Review it before another run.");
+				const connect = this.options.connect;
+				if (!connect) throw new ApprovalRequired("DevTools runtime adapter is unavailable. Use wv accept or the weapp-vite MCP.");
+				const app = JSON.parse(await readFile(await safePath(this.root, "project.config.json"), "utf8"));
+				if (!app.appid || app.appid === "touristappid") throw new ApprovalRequired("Configure a real test AppID in project.config.json and log into WeChat DevTools.");
+				connection ??= await connect({
+					name: "weapp",
+					transport: "stdio",
+					command: "",
+					args: []
+				}, context, {
+					config,
+					fingerprint,
+					builtin: true
+				});
+				const invoke = runtimeInvoker(connection, context);
+				const connected = await invoke("weapp_devtools_connect", {
+					projectPath: this.root,
+					preserveProjectRoot: true,
+					timeout: 6e4
+				});
+				const runtimeRoot = connected.resolvedProjectPath ?? connected.projectPath;
+				if (typeof runtimeRoot !== "string" || await realpath(runtimeRoot) !== this.root) throw new Error("DevTools connected to a different or unidentified project; evidence is unverified.");
+				if (connected.systemInfo?.platform !== "devtools") throw new Error("Runtime did not identify itself as WeChat DevTools; evidence is unverified.");
+				report.runtime = "wechat-devtools";
+				await persist();
+				let screenshot = 0;
+				const capture = async () => {
+					const name = `screenshot-${++screenshot}.png`;
+					const outputPath = `artifacts/weapp-agent/${report.jobId}/${name}`;
+					const target = await safePath(this.root, outputPath);
+					await mkdir(path.dirname(target), { recursive: true });
+					await invoke("weapp_devtools_capture", {
+						projectPath: this.root,
+						preserveProjectRoot: true,
+						outputPath
+					});
+					const bytes = await readFile(await safePath(this.root, outputPath));
+					if (bytes.length > 10485760 || bytes.subarray(0, 8).toString("hex") !== "89504e470d0a1a0a") throw new Error("Runtime screenshot is not a supported PNG artifact (maximum 10 MB)");
+					await writeFile(path.join(directory, name), bytes, { mode: 384 });
+					report.artifacts.push({
+						name,
+						mediaType: "image/png"
+					});
+					await persist();
+					return name;
+				};
+				try {
+					for (const scenario of scenarios) {
+						await runScenario(scenario, invoke, context, async (step) => {
+							await checkFreshness();
+							const previous = report.steps.findIndex((s) => s.scenario === step.scenario && s.index === step.index);
+							if (previous === -1) report.steps.push(structuredClone(step));
+							else report.steps[previous] = structuredClone(step);
+							await persist();
+						}, capture);
+						await capture();
+					}
+					await recordCheck({
+						kind: "devtools",
+						status: "passed",
+						output: `${scenarios.length} scenario(s) passed in WeChat DevTools. No physical-device or visual-regression claim.`
+					});
+				} catch (error) {
+					await recordCheck({
+						kind: "devtools",
+						status: "failed",
+						output: String(error)
+					});
+					if (!signal.aborted) await capture().catch((e) => report.warnings.push(`Failure screenshot unavailable: ${String(e)}`));
+					throw error;
+				} finally {
+					if (!signal.aborted) try {
+						const logs = await invoke("weapp_devtools_console", { projectPath: this.root });
+						await atomicJson(path.join(directory, "console.json"), logs);
+						report.artifacts.push({
+							name: "console.json",
+							mediaType: "application/json"
+						});
+					} catch (error) {
+						report.warnings.push(`Console evidence unavailable: ${String(error)}`);
+						report.checks.push({
+							kind: "devtools",
+							status: "unverified",
+							output: "Console evidence could not be collected."
+						});
+					}
+				}
+			}
+			for (const kind of [
+				"typecheck",
+				"build",
+				"test",
+				"devtools"
+			]) if (!report.checks.some((c) => c.kind === kind)) report.checks.push({
+				kind,
+				status: "unverified",
+				output: kind === "devtools" ? "Runtime scenarios were not executed. Configure scenarios and pass the build first." : "No verification command configured."
+			});
+			report.status = report.checks.some((c) => c.timedOut) ? "timed_out" : report.checks.some((c) => c.status === "failed") ? "failed" : report.requiredChecks.every((kind) => report.checks.some((c) => c.kind === kind && c.status === "passed") && !report.checks.some((c) => c.kind === kind && c.status !== "passed")) ? "passed" : "unverified";
+		} catch (error) {
+			report.status = signal.aborted ? controller.signal.aborted ? "cancelled" : "timed_out" : error instanceof ApprovalRequired ? "action_required" : "failed";
+			report.reason = error instanceof Error ? error.message : String(error);
+		} finally {
+			if (connection) await connection.close().catch((error) => report.warnings.push(`MCP cleanup: ${String(error)}`));
+			try {
+				report.snapshot.after = await sourceSnapshot(report.project);
+				report.snapshot.stale ||= Boolean(report.snapshot.before && report.snapshot.before !== report.snapshot.after);
+			} catch (error) {
+				report.snapshot.stale = true;
+				report.warnings.push(`Cannot validate source freshness: ${String(error)}`);
+			}
+			if (report.snapshot.stale && report.status === "passed") {
+				report.status = "unverified";
+				report.reason = "Source changed during acceptance. Run acceptance again against the current code.";
+			}
+			report.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			for (const kind of [
+				"typecheck",
+				"build",
+				"test",
+				"devtools"
+			]) if (!report.checks.some((c) => c.kind === kind)) report.checks.push({
+				kind,
+				status: "unverified",
+				output: "Check did not complete; inspect task status and reason."
+			});
+			report.passed = report.status === "passed" && !report.snapshot.stale;
+		}
+	}
+	async report(jobId) {
+		const file = path.join(this.jobDirectory(jobId), "report.json");
+		const live = this.jobs.get(jobId);
+		const report = live?.persistenceFailed ? structuredClone(live.report) : JSON.parse(await readFile(file, "utf8"));
+		if (report.root !== this.root || report.version !== 2) throw new Error("Report does not belong to this project or has an unsupported version");
+		if (report.status === "running" && !this.jobs.has(jobId) && !alive(report.ownerPid)) {
+			report.status = "interrupted";
+			report.reason = "Owner exited during acceptance. Inspect partial steps and current runtime state before starting a new task. No steps were replayed.";
+			report.passed = false;
+		}
+		if (report.snapshot.before) {
+			try {
+				report.snapshot.current = await sourceSnapshot(report.project);
+				report.snapshot.stale ||= report.snapshot.current !== report.snapshot.before;
+			} catch {
+				report.snapshot.stale = true;
+			}
+			if (report.snapshot.stale) {
+				report.passed = false;
+				if (report.status === "passed") {
+					report.status = "unverified";
+					report.reason = "Evidence is stale for the current source. Start a new acceptance task.";
+				}
+			}
+		}
+		return redactValue(report);
+	}
+	async wait(jobId) {
+		await this.jobs.get(jobId)?.done;
+		return this.report(jobId);
+	}
+	async cancel(jobId) {
+		const job = this.jobs.get(jobId);
+		if (job) {
+			job.controller.abort();
+			return this.wait(jobId);
+		}
+		const report = await this.report(jobId);
+		if (report.status === "running") throw new Error("Cancel this task through the MCP server/CLI process that started it.");
+		return report;
+	}
+	async artifact(jobId, name) {
+		const artifact = (await this.report(jobId)).artifacts.find((a) => a.name === name);
+		if (!artifact || !/^(?:screenshot-\d+\.png|console\.json)$/.test(name)) throw new Error("Unknown acceptance artifact");
+		const bytes = await readFile(path.join(this.jobDirectory(jobId), name));
+		if (bytes.length > 10485760) throw new Error("Artifact exceeds the 10 MB response limit");
+		return {
+			mediaType: artifact.mediaType,
+			data: artifact.mediaType === "image/png" ? bytes.toString("base64") : bytes.toString("utf8")
+		};
+	}
+	async close() {
+		this.closed = true;
+		await Promise.allSettled([...this.starting]);
+		for (const job of this.jobs.values()) job.controller.abort();
+		await Promise.allSettled([...this.jobs.values()].map((job) => job.done));
+	}
+};
+//#endregion
+export { AcceptanceService, configurationSource, defaultVerification, detectProject, exists, findProjectRoot, loadAcceptanceConfig, projectConfigSchema, projectFingerprint, projectInstructions, redactValue, redactor, resolveProjectConfig, runScenario, runtimeInvoker, safePath, scenarioSchema, sourceSnapshot, stateRoot, verificationTool, verifyProject };

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@weapp-vite/acceptance",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "0.0.0",
+  "description": "Deterministic mini-program acceptance and evidence",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/weapp-vite/weapp-vite.git",
+    "directory": "packages/acceptance"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "LICENSE",
+    "dist"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "dependencies": {
+    "execa": "9.6.0",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@weapp-agent/core": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "test:types": "tsd"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.