@harmonyos-arkts/droid2hmos 0.0.7 → 0.0.9

package/dist/cli.js

@@ -12,19 +12,19 @@ function quoteWinArg(arg) {
   if (!/[\s"&|<>()^%]/.test(arg)) return arg;
   return `"${arg.replace(/"/g, '""')}"`;
 }
-function windowsCommandLine(command3, args) {
-  return [command3, ...args].map((value) => quoteWinArg(String(value))).join(" ");
+function windowsCommandLine(command2, args) {
+  return [command2, ...args].map((value) => quoteWinArg(String(value))).join(" ");
 }
-function resolveSpawnCommand(command3, args, platform = process.platform) {
-  if (platform !== "win32") return { command: command3, args: [...args], shell: false };
-  return { command: windowsCommandLine(command3, args), args: [], shell: true };
+function resolveSpawnCommand(command2, args, platform = process.platform) {
+  if (platform !== "win32") return { command: command2, args: [...args], shell: false };
+  return { command: windowsCommandLine(command2, args), args: [], shell: true };
 }
-function spawnCommandSync(command3, args, options = {}) {
-  const invocation = resolveSpawnCommand(command3, args);
+function spawnCommandSync(command2, args, options = {}) {
+  const invocation = resolveSpawnCommand(command2, args);
   return nodeSpawnSync(invocation.command, invocation.args, { ...options, shell: invocation.shell });
 }
-function spawnCommand(command3, args, options = {}) {
-  const invocation = resolveSpawnCommand(command3, args);
+function spawnCommand(command2, args, options = {}) {
+  const invocation = resolveSpawnCommand(command2, args);
   return nodeSpawn(invocation.command, invocation.args, { ...options, shell: invocation.shell });
 }
 
@@ -110,7 +110,7 @@ function checkAndroidBuild(argv) {
     present,
     kind: "android-apk-inventory",
     status,
-    summary: present ? `\u53D1\u73B0 ${artifacts.length} \u4E2A APK \u6784\u5EFA\u4EA7\u7269\uFF0C\u53EF\u7528\u4E8E Android/HarmonyOS \u53CC\u7AEF\u8FD0\u884C\u5BF9\u7167` : "\u672A\u53D1\u73B0 APK \u6784\u5EFA\u4EA7\u7269\uFF08\u8FC1\u79FB\u4E0D\u4F9D\u8D56 Android \u7F16\u8BD1\uFF09\uFF1B\u53CC\u7AEF\u9875\u9762\u5BF9\u7167\u5C06\u4EE5\u6E90\u7801\u4E0E\u9759\u6001 facts \u4E3A\u57FA\u51C6",
+    summary: present ? `\u53D1\u73B0 ${artifacts.length} \u4E2A APK \u6784\u5EFA\u4EA7\u7269\uFF08\u4EC5\u4F5C\u53C2\u8003\u4FE1\u606F\uFF09` : "\u672A\u53D1\u73B0 APK \u6784\u5EFA\u4EA7\u7269\uFF08\u8FC1\u79FB\u4E0D\u4F9D\u8D56 Android \u7F16\u8BD1\uFF09",
     artifacts: artifacts.length,
     report: reportPath
   };
@@ -138,8 +138,8 @@ function sourceRoots(projectRootArgument) {
   const projectRoot = path3.resolve(projectRootArgument);
   const config = readJson(path3.join(migrationDirectory(projectRoot), "config.json"));
   const androidRoot = path3.resolve(projectRoot, config?.androidProject ?? projectRoot);
-  const harmonyRoot = path3.resolve(projectRoot, config?.harmonyProject ?? "ohos");
-  return { projectRoot, androidRoot, harmonyRoot };
+  const harmonyRoot2 = path3.resolve(projectRoot, config?.harmonyProject ?? "ohos");
+  return { projectRoot, androidRoot, harmonyRoot: harmonyRoot2 };
 }
 function inside(root, absolute) {
   const relative2 = path3.relative(root, absolute);
@@ -147,10 +147,10 @@ function inside(root, absolute) {
 }
 function sourceFile(projectRoot, value) {
   if (typeof value !== "string" || !value.trim()) throw new Error("Android source path must be a non-empty string");
-  const { androidRoot, harmonyRoot } = sourceRoots(projectRoot);
+  const { androidRoot, harmonyRoot: harmonyRoot2 } = sourceRoots(projectRoot);
   const absolute = path3.resolve(androidRoot, value);
   if (!inside(androidRoot, absolute)) throw new Error(`Android source must stay inside the managed Android project: ${value}`);
-  if (inside(harmonyRoot, absolute)) throw new Error(`Android source cannot point into the HarmonyOS project: ${value}`);
+  if (inside(harmonyRoot2, absolute)) throw new Error(`Android source cannot point into the HarmonyOS project: ${value}`);
   if (!fs3.existsSync(absolute) || !fs3.statSync(absolute).isFile()) throw new Error(`Android source file not found: ${value}`);
   const realRoot = fs3.realpathSync(androidRoot);
   const realFile = fs3.realpathSync(absolute);
@@ -161,12 +161,12 @@ function sourceFile(projectRoot, value) {
 }
 function managedHarmonyFile(projectRootArgument, value) {
   if (typeof value !== "string" || !value.trim()) throw new Error("HarmonyOS path must be a non-empty string");
-  const { projectRoot, harmonyRoot } = sourceRoots(projectRootArgument);
+  const { projectRoot, harmonyRoot: harmonyRoot2 } = sourceRoots(projectRootArgument);
   const absolute = path3.resolve(projectRoot, value);
-  if (!inside(harmonyRoot, absolute)) throw new Error(`HarmonyOS file must stay inside the configured HarmonyOS project: ${value}`);
+  if (!inside(harmonyRoot2, absolute)) throw new Error(`HarmonyOS file must stay inside the configured HarmonyOS project: ${value}`);
   if (!fs3.existsSync(absolute) || !fs3.statSync(absolute).isFile()) throw new Error(`HarmonyOS file not found: ${value}`);
-  if (!fs3.existsSync(harmonyRoot) || !fs3.statSync(harmonyRoot).isDirectory()) throw new Error(`Configured HarmonyOS project not found: ${harmonyRoot}`);
-  const realRoot = fs3.realpathSync(harmonyRoot);
+  if (!fs3.existsSync(harmonyRoot2) || !fs3.statSync(harmonyRoot2).isDirectory()) throw new Error(`Configured HarmonyOS project not found: ${harmonyRoot2}`);
+  const realRoot = fs3.realpathSync(harmonyRoot2);
   const realFile = fs3.realpathSync(absolute);
   if (!inside(realRoot, realFile)) throw new Error(`HarmonyOS file resolves outside the configured HarmonyOS project: ${value}`);
   return { absolute, relative: path3.relative(projectRoot, absolute).replaceAll("\\", "/") };
@@ -183,14 +183,14 @@ function provenanceForFiles(projectRoot, values) {
   return [...result.values()].sort((left, right) => left.androidFile.localeCompare(right.androidFile));
 }
 function managedSourceManifest(projectRootArgument) {
-  const { projectRoot, androidRoot, harmonyRoot } = sourceRoots(projectRootArgument);
+  const { projectRoot, androidRoot, harmonyRoot: harmonyRoot2 } = sourceRoots(projectRootArgument);
   if (!fs3.existsSync(androidRoot) || !fs3.statSync(androidRoot).isDirectory()) throw new Error(`Managed Android project not found: ${androidRoot}`);
   const members = [];
   const visit = (directory) => {
     for (const entry of fs3.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
       if (ignoredSourceParts.has(entry.name)) continue;
       const absolute = path3.join(directory, entry.name);
-      if (inside(harmonyRoot, absolute)) continue;
+      if (inside(harmonyRoot2, absolute)) continue;
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) visit(absolute);
       else if (entry.isFile()) {
@@ -387,7 +387,9 @@ function auditSourceOrder(projectRootArgument, items, options = {}) {
 }
 function auditSourceClosure(projectRootArgument, items) {
   const projectRoot = path3.resolve(projectRootArgument);
-  const graph = readJson(path3.join(migrationDirectory(projectRoot), "tasks", "graph.json"));
+  const tasksRoot = path3.join(migrationDirectory(projectRoot), "tasks");
+  const executionGraph = path3.join(tasksRoot, "execution-graph.json");
+  const graph = readJson(fs3.existsSync(executionGraph) ? executionGraph : path3.join(tasksRoot, "graph.json"));
   const auditable = items.filter((item) => ["implemented", "verified"].includes(item?.status) && item?.kind !== "feature");
   if (!graph || !Array.isArray(graph.tasks)) return { auditVersion: "1.0.0", status: "unavailable", auditedRefs: [], findings: ["Task Plan source closure is unavailable; sourceProvenance hashes remain enforceable"] };
   const findings = [];
@@ -496,7 +498,7 @@ function initMigrationReport(argv) {
   const fail = (message) => {
     throw new Error(message);
   };
-  const readJson8 = (file) => JSON.parse(fs4.readFileSync(file, "utf8"));
+  const readJson9 = (file) => JSON.parse(fs4.readFileSync(file, "utf8"));
   const writeJson2 = (file, value) => {
     fs4.mkdirSync(path4.dirname(file), { recursive: true });
     fs4.writeFileSync(file, `${JSON.stringify(value, null, 2)}
@@ -510,7 +512,7 @@ function initMigrationReport(argv) {
   const relReport = (file) => path4.relative(reportRoot, file).replaceAll("\\", "/");
   const relProject = (file) => path4.relative(workspaceRoot, file).replaceAll("\\", "/");
   const reportItemValues = (document) => [document.page, ...document.controls ?? [], ...document.entries ?? [], ...document.interactions ?? [], ...document.items ?? []].filter(Boolean);
-  const confinedReportFile = (relative2) => {
+  const confinedReportFile2 = (relative2) => {
     if (typeof relative2 !== "string" || !relative2.trim() || path4.isAbsolute(relative2)) fail(`Legacy report shard path must be report-relative: ${String(relative2)}`);
     const absolute = path4.resolve(reportRoot, relative2);
     const relation = path4.relative(reportRoot, absolute);
@@ -523,18 +525,18 @@ function initMigrationReport(argv) {
     return realFile;
   };
   if (!fs4.existsSync(indexPath)) fail(`Deterministic SPEC index not found: ${indexPath}`);
-  const specIndex = readJson8(indexPath);
+  const specIndex = readJson9(indexPath);
   if (specIndex.shardFormatVersion !== "2.0.0" || !specIndex.files?.facts) fail("report init requires deterministic SPEC facts in shardFormatVersion 2.0.0");
   if (!specIndex.factsSha256) fail("SPEC index does not contain factsSha256");
   const specFile = (file) => path4.join(specRoot, file);
   const files = specIndex.files.facts;
-  const appFacts = readJson8(specFile(files.app));
-  const pageIndex = readJson8(specFile(files.pages));
-  const interactionFacts = readJson8(specFile(files.interactions));
-  const unresolvedFacts = readJson8(specFile(files.unresolved));
+  const appFacts = readJson9(specFile(files.app));
+  const pageIndex = readJson9(specFile(files.pages));
+  const interactionFacts = readJson9(specFile(files.interactions));
+  const unresolvedFacts = readJson9(specFile(files.unresolved));
   const reportIndexPath = path4.join(reportRoot, "index.json");
   if (fs4.existsSync(reportIndexPath)) {
-    const previous = readJson8(reportIndexPath);
+    const previous = readJson9(reportIndexPath);
     if (previous.baseline?.factsSha256 !== specIndex.factsSha256) fail(`Existing report targets facts ${previous.baseline?.factsSha256 ?? "<unknown>"}; current facts are ${specIndex.factsSha256}. Remove .migration/report or preserve it under another run.`);
     if (previous.reportVersion === "1.1.0") {
       const shardFiles = [
@@ -543,10 +545,10 @@ function initMigrationReport(argv) {
         previous.interactionsFile,
         previous.discoveriesFile
       ].filter(Boolean);
-      const migrationTargets = shardFiles.map((relative2) => confinedReportFile(relative2));
+      const migrationTargets = shardFiles.map((relative2) => confinedReportFile2(relative2));
       let migratedFiles = 0;
       for (const file of migrationTargets) {
-        const document = readJson8(file);
+        const document = readJson9(file);
         for (const value of reportItemValues(document)) if (!Array.isArray(value.sourceProvenance)) value.sourceProvenance = [];
         if (document.reportShardVersion === "1.1.0") document.reportShardVersion = REPORT_VERSION;
         writeJson2(file, document);
@@ -579,7 +581,7 @@ function initMigrationReport(argv) {
   const pages = [];
   for (const descriptor of pageIndex.pages ?? []) {
     const factPath = specFile(descriptor.file);
-    const facts = readJson8(factPath);
+    const facts = readJson9(factPath);
     if (!facts.surface?.surfaceRef) fail(`Invalid surface facts shard: ${factPath}`);
     const output = path4.join(reportRoot, "pages", path4.basename(descriptor.file));
     const controlRefByCarrier = new Map((facts.controls ?? []).map((value) => [value.sourceCarrierRef, value.controlRef]));
@@ -605,7 +607,7 @@ function initMigrationReport(argv) {
   let unassignedEntriesFile = null;
   if (pageIndex.unassignedEntriesFile) {
     const factPath = specFile(pageIndex.unassignedEntriesFile);
-    const facts = readJson8(factPath);
+    const facts = readJson9(factPath);
     const output = path4.join(reportRoot, "pages", "unassigned.json");
     const shard = { reportShardVersion: REPORT_VERSION, kind: "unassigned-entry-report", factsFile: relProject(factPath), entries: (facts.entries ?? []).map((value) => item(value.entryRef, "entry", value.displayLabel || value.event || value.entryRef, { controlRef: null })) };
     if (writeIfMissing(output, shard)) createdFiles++;
@@ -2147,9 +2149,12 @@ function initHmosProject(options) {
 // src/commands/run-appgraph.ts
 import { rmSync } from "fs";
 import { join, resolve as resolve2 } from "path";
-function runAppGraph(argv) {
+function runAppGraph(argv, runCommand = spawnCommandSync) {
+  if (argv.some((arg) => arg === "--resolve-dependencies" || arg.startsWith("--resolve-dependencies="))) {
+    throw new Error("Android Gradle \u4F9D\u8D56\u5206\u6790\u5165\u53E3\u6682\u65F6\u5173\u95ED\uFF0C\u8BF7\u79FB\u9664 --resolve-dependencies \u540E\u6267\u884C\u6E90\u7801\u9759\u6001\u5206\u6790\u3002");
+  }
   const runManaged = (args) => {
-    const result = spawnCommandSync("appgraph", args, { stdio: "inherit" });
+    const result = runCommand("appgraph", args, { stdio: "inherit" });
     if (result.error) {
       throw new Error(`\u65E0\u6CD5\u6267\u884C appgraph \u547D\u4EE4\uFF1A${result.error.message}\u3002\u8BF7\u5148\u5B89\u88C5 AppGraph \u5E76\u786E\u4FDD appgraph \u5728 PATH \u4E2D\u3002`);
     }
@@ -2164,10 +2169,10 @@ function runAppGraph(argv) {
   const projectRoot = resolve2(projectPath);
   ensureMigrationWorkspace(projectRoot);
   const outputPath = join(migrationDirectory(projectRoot), "spec");
-  const command3 = ["spec-analysis", projectRoot, "--out", outputPath];
+  const command2 = ["spec-analysis", projectRoot, "--out", outputPath];
   const graphIndex = argv.indexOf("--graph");
-  if (graphIndex >= 0 && argv[graphIndex + 1]) command3.push("--graph", argv[graphIndex + 1]);
-  const analysis = runManaged(command3);
+  if (graphIndex >= 0 && argv[graphIndex + 1]) command2.push("--graph", argv[graphIndex + 1]);
+  const analysis = runManaged(command2);
   if ((analysis.status ?? 1) !== 0) return analysis.status ?? 1;
   console.log(JSON.stringify(renderSpecHtml([join(outputPath, "index.json"), join(outputPath, "spec.html")]), null, 2));
   const legacyDirectory = join(projectRoot, ".migration", "appgraph");
@@ -2177,18 +2182,19 @@ function runAppGraph(argv) {
   return 0;
 }
 
+// src/commands/harmony-toolchain.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import path15 from "path";
+import JSON52 from "json5";
+
 // src/commands/run-config-command.ts
 import { closeSync as closeSync2, createWriteStream, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname2, isAbsolute, join as join2, resolve as resolve3 } from "path";
 import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-function androidProjectRoot(absoluteConfig, androidProject) {
-  const workspaceParent = resolve3(dirname2(absoluteConfig), "..", "..");
-  return typeof androidProject === "string" && androidProject ? resolve3(workspaceParent, androidProject) : workspaceParent;
-}
 var DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
-var COMMAND_KEYS = /* @__PURE__ */ new Set(["androidTest", "androidBuild", "harmonyStatic"]);
-function validateFiniteCommand(command3) {
-  const value = String(command3 ?? "").trim();
+function validateFiniteCommand(command2) {
+  const value = String(command2 ?? "").trim();
   const errors = [];
   if (!value) return ["\u547D\u4EE4\u4E3A\u7A7A"];
   if (value.includes("|")) errors.push("\u7981\u6B62\u5728\u53D7\u7BA1\u547D\u4EE4\u4E2D\u4F7F\u7528\u8F93\u51FA\u7BA1\u9053\uFF1B\u65E5\u5FD7\u7531\u8FD0\u884C\u5668\u76F4\u63A5\u5199\u6587\u4EF6");
@@ -2205,47 +2211,9 @@ function validateFiniteCommand(command3) {
   }
   return errors;
 }
-function runConfigCommand({ configPath, key, timeoutMs = DEFAULT_TIMEOUT_MS, runner = spawnSync2, replacements = {}, requiredTokens = [] }) {
-  if (!configPath || !key) throw new Error("\u7F3A\u5C11 configPath \u6216 command key");
-  if (!COMMAND_KEYS.has(key)) throw new Error(`\u4E0D\u652F\u6301\u7684 command key: ${key}`);
-  const absoluteConfig = resolve3(configPath);
-  const config = JSON.parse(readFileSync2(absoluteConfig, "utf8"));
-  const configuredCommand = config.commands?.[key];
-  if (configuredCommand === null) return { status: "not_applicable", key, summary: `${key} \u672A\u914D\u7F6E` };
-  for (const token of requiredTokens) {
-    if (!String(configuredCommand).includes(token)) {
-      return { status: "rejected", key, errors: [`${key} \u7F3A\u5C11\u5FC5\u8981\u6A21\u677F ${token}`], summary: `${key} \u4E0D\u652F\u6301\u672C\u6B21\u589E\u91CF\u9009\u62E9\u5668` };
-    }
-  }
-  let command3 = String(configuredCommand);
-  for (const [token, value] of Object.entries(replacements)) command3 = command3.replaceAll(token, String(value));
-  const projectRoot = androidProjectRoot(absoluteConfig, config.androidProject);
-  const configuredCwd = key.startsWith("android") ? config.androidProject : config.harmonyProject;
-  const cwd = isAbsolute(configuredCwd) ? configuredCwd : resolve3(projectRoot, configuredCwd);
-  return runFiniteCommand({ command: command3, key, cwd, projectRoot, timeoutMs, runner });
-}
-function runConfigCommandAsync({ configPath, key, timeoutMs = DEFAULT_TIMEOUT_MS, replacements = {}, requiredTokens = [] }) {
-  if (!configPath || !key) throw new Error("\u7F3A\u5C11 configPath \u6216 command key");
-  if (!COMMAND_KEYS.has(key)) throw new Error(`\u4E0D\u652F\u6301\u7684 command key: ${key}`);
-  const absoluteConfig = resolve3(configPath);
-  const config = JSON.parse(readFileSync2(absoluteConfig, "utf8"));
-  const configuredCommand = config.commands?.[key];
-  if (configuredCommand === null) return Promise.resolve({ status: "not_applicable", key, summary: `${key} \u672A\u914D\u7F6E` });
-  for (const token of requiredTokens) {
-    if (!String(configuredCommand).includes(token)) {
-      return Promise.resolve({ status: "rejected", key, errors: [`${key} \u7F3A\u5C11\u5FC5\u8981\u6A21\u677F ${token}`], summary: `${key} \u4E0D\u652F\u6301\u672C\u6B21\u589E\u91CF\u9009\u62E9\u5668` });
-    }
-  }
-  let command3 = String(configuredCommand);
-  for (const [token, value] of Object.entries(replacements)) command3 = command3.replaceAll(token, String(value));
-  const projectRoot = androidProjectRoot(absoluteConfig, config.androidProject);
-  const configuredCwd = key.startsWith("android") ? config.androidProject : config.harmonyProject;
-  const cwd = isAbsolute(configuredCwd) ? configuredCwd : resolve3(projectRoot, configuredCwd);
-  return runFiniteCommandAsync({ command: command3, key, cwd, projectRoot, timeoutMs });
-}
-function runFiniteCommand({ command: command3, key, cwd, projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS, runner = spawnSync2 }) {
+function runFiniteCommand({ command: command2, key, cwd, projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS, runner = spawnSync2 }) {
   if (!key || !cwd || !projectRoot) throw new Error("\u7F3A\u5C11 key\u3001cwd \u6216 projectRoot");
-  const errors = validateFiniteCommand(command3);
+  const errors = validateFiniteCommand(command2);
   if (errors.length) return { status: "rejected", key, errors, summary: `${key} \u547D\u4EE4\u8FDD\u53CD\u6D41\u7A0B\u5B58\u6D3B\u95E8\u7981` };
   if (!existsSync2(cwd)) throw new Error(`${key} \u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728: ${cwd}`);
   const logDir = join2(migrationDirectory(projectRoot), "preflight-logs");
@@ -2257,7 +2225,7 @@ function runFiniteCommand({ command: command3, key, cwd, projectRoot, timeoutMs
   let result;
   try {
     const executable = process.platform === "win32" ? "powershell.exe" : "/bin/sh";
-    const args = process.platform === "win32" ? ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", command3] : ["-lc", command3];
+    const args = process.platform === "win32" ? ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", command2] : ["-lc", command2];
     result = runner(executable, args, {
       cwd,
       windowsHide: true,
@@ -2329,69 +2297,6 @@ function runFiniteExecutable({ executable, args, key, cwd, projectRoot, timeoutM
     })()
   };
 }
-async function runFiniteCommandAsync({ command: command3, key, cwd, projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS }) {
-  if (!key || !cwd || !projectRoot) throw new Error("\u7F3A\u5C11 key\u3001cwd \u6216 projectRoot");
-  const errors = validateFiniteCommand(command3);
-  if (errors.length) return { status: "rejected", key, errors, summary: `${key} \u547D\u4EE4\u8FDD\u53CD\u6D41\u7A0B\u5B58\u6D3B\u95E8\u7981` };
-  if (!existsSync2(cwd)) throw new Error(`${key} \u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728: ${cwd}`);
-  const logDir = join2(migrationDirectory(projectRoot), "preflight-logs");
-  mkdirSync2(logDir, { recursive: true });
-  const stdoutPath = join2(logDir, `${key}.stdout.log`);
-  const stderrPath = join2(logDir, `${key}.stderr.log`);
-  const stdout = createWriteStream(stdoutPath, { flags: "w" });
-  const stderr = createWriteStream(stderrPath, { flags: "w" });
-  const executable = process.platform === "win32" ? "powershell.exe" : "/bin/sh";
-  const args = process.platform === "win32" ? ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", command3] : ["-lc", command3];
-  const child = spawn2(executable, args, {
-    cwd,
-    windowsHide: true,
-    shell: false,
-    detached: process.platform !== "win32",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  child.stdout.pipe(stdout);
-  child.stderr.pipe(stderr);
-  let timedOut = false;
-  const timer = setTimeout(() => {
-    timedOut = true;
-    if (process.platform !== "win32" && child.pid) {
-      try {
-        process.kill(-child.pid, "SIGKILL");
-      } catch {
-        child.kill("SIGKILL");
-      }
-    } else child.kill("SIGKILL");
-  }, Number(timeoutMs));
-  const exitCode = await new Promise((resolveExit) => {
-    child.once("error", () => resolveExit(null));
-    child.once("close", (code) => resolveExit(code));
-  });
-  clearTimeout(timer);
-  await Promise.all([
-    new Promise((done) => stdout.end(done)),
-    new Promise((done) => stderr.end(done))
-  ]);
-  return {
-    status: !timedOut && exitCode === 0 ? "passed" : "failed",
-    key,
-    exitCode,
-    timedOut,
-    timeoutMs: Number(timeoutMs),
-    cwd,
-    stdout: stdoutPath,
-    stderr: stderrPath,
-    summary: timedOut ? `${key} \u8D85\u8FC7 ${timeoutMs}ms\uFF0C\u5DF2\u7EC8\u6B62\u53D7\u7BA1\u547D\u4EE4` : (() => {
-      if (exitCode === 0) return `${key} \u6267\u884C\u6210\u529F`;
-      return `${key} \u6267\u884C\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode ?? "unknown"}`;
-    })()
-  };
-}
-
-// src/commands/harmony-toolchain.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import path15 from "path";
-import JSON52 from "json5";
 
 // src/commands/check-hmos-device.ts
 import { spawnSync as spawnSync3 } from "child_process";
@@ -2490,6 +2395,14 @@ import { existsSync as existsSync3, readdirSync, statSync } from "fs";
 import path13 from "path";
 var DEVECO_CLI_PACKAGE = "@deveco/deveco-cli@latest";
 var DEVECO_CLI_INSTALL_COMMAND = `npm install -g ${DEVECO_CLI_PACKAGE}`;
+var NODE_INSPECTOR_OPTION = /(?:^|\s)--inspect(?:-brk|-port|-wait)?(?:=(?:"[^"]*"|'[^']*'|\S+))?(?=\s|$)/gu;
+function devEcoCliEnvironment(environment = process.env) {
+  const result = { ...environment, DEVECO_CLI_SKIP_VERSION_CHECK: "1" };
+  const nodeOptions = String(environment.NODE_OPTIONS ?? "").replace(NODE_INSPECTOR_OPTION, "").trim();
+  if (nodeOptions) result.NODE_OPTIONS = nodeOptions;
+  else delete result.NODE_OPTIONS;
+  return result;
+}
 function executableName() {
   return process.env.DEVECO_CLI_BINARY || "devecocli";
 }
@@ -2497,14 +2410,14 @@ function devEcoCliSpawn(executable, args) {
   const scriptWrapper = /\.m?js$/i.test(executable);
   return scriptWrapper ? [process.execPath, executable, ...args] : [executable, ...args];
 }
-function runDevEcoCli(args, { executable = executableName(), runner = spawnCommandSync, timeoutMs = 15e3 } = {}, cwd) {
-  const [command3, ...commandArgs] = devEcoCliSpawn(executable, args);
-  const result = runner(command3, commandArgs, {
+function runDevEcoCli(args, { executable = executableName(), runner = spawnCommandSync, timeoutMs = 15e3, environment = process.env } = {}, cwd) {
+  const [command2, ...commandArgs] = devEcoCliSpawn(executable, args);
+  const result = runner(command2, commandArgs, {
     cwd,
     encoding: "utf8",
     timeout: timeoutMs,
     windowsHide: true,
-    env: { ...process.env, DEVECO_CLI_SKIP_VERSION_CHECK: "1" }
+    env: devEcoCliEnvironment(environment)
   });
   return {
     executable,
@@ -2516,13 +2429,13 @@ function runDevEcoCli(args, { executable = executableName(), runner = spawnComma
     errorCode: result.error && "code" in result.error ? result.error.code : null
   };
 }
-async function runDevEcoCliAsync(args, { executable = executableName(), timeoutMs = 15e3 } = {}, cwd) {
-  const [command3, ...commandArgs] = devEcoCliSpawn(executable, args);
-  const child = spawnCommand(command3, commandArgs, {
+async function runDevEcoCliAsync(args, { executable = executableName(), timeoutMs = 15e3, environment = process.env } = {}, cwd) {
+  const [command2, ...commandArgs] = devEcoCliSpawn(executable, args);
+  const child = spawnCommand(command2, commandArgs, {
     cwd,
     windowsHide: true,
     detached: process.platform !== "win32",
-    env: { ...process.env, DEVECO_CLI_SKIP_VERSION_CHECK: "1" },
+    env: devEcoCliEnvironment(environment),
     stdio: ["ignore", "pipe", "pipe"]
   });
   let stdout = "";
@@ -2603,7 +2516,7 @@ function checkDevEcoCliAuth(cli = {}) {
   const result = runDevEcoCli(["auth", "status"], cli);
   const output = [result.stdout, result.stderr].map((value) => value.trim()).filter(Boolean).join("\n");
   const loggedOut = /(?:^|\n)Not logged in(?:\n|$)/i.test(output);
-  const currentUser = output.match(/(?:^|\n)Current user:\s*(.+?)(?:\n|$)/i)?.[1]?.trim();
+  const currentUser = output.match(/Current user:\s*([^\r\n]+)/i)?.[1]?.trim();
   if (result.status !== "passed" || loggedOut || !currentUser) {
     return {
       status: "failed",
@@ -2773,8 +2686,8 @@ function isRealDeviceTarget(target) {
   }
   return true;
 }
-function readSigningMaterialFingerprints(harmonyRoot) {
-  const profile = path14.join(harmonyRoot, "build-profile.json5");
+function readSigningMaterialFingerprints(harmonyRoot2) {
+  const profile = path14.join(harmonyRoot2, "build-profile.json5");
   if (!fs13.existsSync(profile)) return [];
   let parsed;
   try {
@@ -2783,7 +2696,7 @@ function readSigningMaterialFingerprints(harmonyRoot) {
     return [];
   }
   const signingConfigs = parsed?.app?.signingConfigs ?? [];
-  const files = [...new Set(signingConfigs.flatMap((config) => [config?.material?.certpath, config?.material?.profile, config?.material?.storeFile]).filter((file) => typeof file === "string" && file.length > 0).map((file) => path14.isAbsolute(file) ? file : path14.resolve(harmonyRoot, file)))];
+  const files = [...new Set(signingConfigs.flatMap((config) => [config?.material?.certpath, config?.material?.profile, config?.material?.storeFile]).filter((file) => typeof file === "string" && file.length > 0).map((file) => path14.isAbsolute(file) ? file : path14.resolve(harmonyRoot2, file)))];
   return [...new Set(files)].flatMap((file) => {
     if (!fs13.existsSync(file)) return [];
     const stat = fs13.statSync(file);
@@ -2900,10 +2813,10 @@ function detectDeviceSdkVersion(target) {
     diverged: systemAbc !== null && systemAbc.major < claimedApiLevel
   };
 }
-function ensureDeviceInstallable(harmonyRoot, target) {
+function ensureDeviceInstallable(harmonyRoot2, target) {
   const device = detectDeviceSdkVersion(target);
   if (!device) return { status: "skipped", changed: false, summary: "\u65E0\u6CD5\u8BFB\u53D6\u771F\u673A\u7CFB\u7EDF\u7248\u672C\uFF0C\u8DF3\u8FC7\u517C\u5BB9\u7248\u672C\u68C0\u67E5" };
-  const capped = capCompatibleSdkVersionTo(harmonyRoot, device.sdkVersion);
+  const capped = capCompatibleSdkVersionTo(harmonyRoot2, device.sdkVersion);
   const divergence = device.diverged ? `\uFF1B\u771F\u673A param \u58F0\u79F0 API ${device.claimedApiLevel}\uFF0C\u4F46\u7CFB\u7EDF ABC \u5B57\u8282\u7801\u4E0A\u9650\u4E3A ${device.systemAbcVersion}\uFF08log \u7248\u955C\u50CF\u5E38\u89C1\u865A\u62A5\uFF09\uFF0C\u5DF2\u6309\u8FD0\u884C\u65F6\u5B9E\u9645\u80FD\u529B\u53D6 API ${device.apiLevel}` : "";
   return {
     ...capped,
@@ -2994,10 +2907,10 @@ function readJson5(file) {
 function firstExisting(values) {
   return values.find((value) => Boolean(value && existsSync4(value)));
 }
-function pathLookup(command3) {
+function pathLookup(command2) {
   try {
     const lookup = process.platform === "win32" ? "where.exe" : "which";
-    return execFileSync(lookup, [command3], { encoding: "utf8", windowsHide: true }).split(/\r?\n/).map((value) => value.trim()).find(Boolean);
+    return execFileSync(lookup, [command2], { encoding: "utf8", windowsHide: true }).split(/\r?\n/).map((value) => value.trim()).find(Boolean);
   } catch {
     return null;
   }
@@ -3158,8 +3071,8 @@ function runHarmonyTest({ projectRoot, harmonyProject, timeoutMs, testClass = nu
   if (appBuild.status !== "passed") return { status: "failed", key: "harmonyTest", stage: "app-build", appBuild };
   const ohpmInstall = ensureOhpmDependencies({ projectRoot, harmonyProject, timeoutMs });
   if (ohpmInstall.status !== "passed") return { status: "failed", key: "harmonyTest", stage: "ohpm-install", appBuild, ohpmInstall };
-  const { info, command: command3 } = buildHarmonyTestCommand({ projectRoot, harmonyProject });
-  const testBuild = runFiniteCommand({ command: command3, key: "harmonyTest-build", cwd: info.root, projectRoot, timeoutMs });
+  const { info, command: command2 } = buildHarmonyTestCommand({ projectRoot, harmonyProject });
+  const testBuild = runFiniteCommand({ command: command2, key: "harmonyTest-build", cwd: info.root, projectRoot, timeoutMs });
   if (testBuild.status !== "passed") return { status: "failed", key: "harmonyTest", stage: "test-build", appBuild, testBuild };
   const testArtifact = newestHap(info.moduleRoot, (name) => name.toLowerCase().includes(info.testTarget.toLowerCase()));
   if (!testArtifact) return { status: "failed", key: "harmonyTest", stage: "test-artifact", summary: "Hvigor \u8FD4\u56DE\u6210\u529F\uFF0C\u4F46\u6CA1\u6709\u53EF\u5B89\u88C5\u7684\u6D4B\u8BD5 HAP", appBuild, testBuild };
@@ -3345,8 +3258,8 @@ function detectHarmonySdk({ project, sdkPath, writeConfig = false, env = process
   push(sdkPath, "explicit");
   push(config?.harmonySdk?.path, "existing-config");
   const configuredHarmony = config?.harmonyProject ?? defaultHarmonyProjectPath(projectRoot);
-  const harmonyRoot = path17.isAbsolute(configuredHarmony) ? configuredHarmony : path17.resolve(projectRoot, configuredHarmony);
-  const localProperties = path17.join(harmonyRoot, "local.properties");
+  const harmonyRoot2 = path17.isAbsolute(configuredHarmony) ? configuredHarmony : path17.resolve(projectRoot, configuredHarmony);
+  const localProperties = path17.join(harmonyRoot2, "local.properties");
   if (fs14.existsSync(localProperties)) {
     const properties = parseProperties(fs14.readFileSync(localProperties, "utf8"));
     push(properties["sdk.dir"] ?? properties["harmony.sdk.dir"] ?? properties["ohos.sdk.dir"], "local-properties");
@@ -3485,22 +3398,19 @@ var atomicJson = (file, value) => {
 `, "utf8");
   fs15.renameSync(temporary, file);
 };
-function defaultAndroidBuild(_projectRoot, _platform = process.platform) {
-  return null;
-}
-function normalizeAndroidBuildCommand(command3, platform = process.platform) {
-  if (typeof command3 !== "string") return command3;
+function normalizeAndroidBuildCommand(command2, platform = process.platform) {
+  if (typeof command2 !== "string") return command2;
   if (platform === "win32") {
-    return command3.replace(/^(\s*)(?:&\s*)?["']?\.\/gradlew["']?(?=\s|$)/i, "$1.\\gradlew.bat");
+    return command2.replace(/^(\s*)(?:&\s*)?["']?\.\/gradlew["']?(?=\s|$)/i, "$1.\\gradlew.bat");
   }
-  return command3.replace(/^(\s*)(?:&\s*)?["']?(?:\.\\gradlew(?:\.bat)?|gradlew\.bat)["']?(?=\s|$)/i, "$1./gradlew");
+  return command2.replace(/^(\s*)(?:&\s*)?["']?(?:\.\\gradlew(?:\.bat)?|gradlew\.bat)["']?(?=\s|$)/i, "$1./gradlew");
 }
-function validateAndroidBuildPlatform(command3, platform = process.platform) {
-  if (typeof command3 !== "string") return null;
-  if (platform === "win32" && /(?:^|\s)\.\/gradlew(?:\s|$)/i.test(command3)) {
+function validateAndroidBuildPlatform(command2, platform = process.platform) {
+  if (typeof command2 !== "string") return null;
+  if (platform === "win32" && /(?:^|\s)\.\/gradlew(?:\s|$)/i.test(command2)) {
     return "commands.androidBuild uses a Unix Gradle wrapper on Windows; use .\\gradlew.bat";
   }
-  if (platform !== "win32" && /(?:gradlew\.bat|\.\\gradlew)(?:\s|$)/i.test(command3)) {
+  if (platform !== "win32" && /(?:gradlew\.bat|\.\\gradlew)(?:\s|$)/i.test(command2)) {
     return `commands.androidBuild uses a Windows Gradle wrapper on ${platform}; use ./gradlew`;
   }
   return null;
@@ -3522,12 +3432,12 @@ function validateMigrationConfigValue(config, projectRoot) {
     if (path19.isAbsolute(config.androidProject)) return config.androidProject;
     return path19.resolve(projectRoot, config.androidProject);
   })() : null;
-  const harmonyRoot = config?.harmonyProject ? (() => {
+  const harmonyRoot2 = config?.harmonyProject ? (() => {
     if (path19.isAbsolute(config.harmonyProject)) return config.harmonyProject;
     return path19.resolve(projectRoot, config.harmonyProject);
   })() : null;
   if (androidRoot && (!fs15.existsSync(androidRoot) || !fs15.statSync(androidRoot).isDirectory())) errors.push(`androidProject directory not found: ${androidRoot}`);
-  return { valid: errors.length === 0, errors, projectRoot, androidRoot, harmonyRoot };
+  return { valid: errors.length === 0, errors, projectRoot, androidRoot, harmonyRoot: harmonyRoot2 };
 }
 function initMigrationConfig(options) {
   const projectRoot = path19.resolve(options.project);
@@ -3536,7 +3446,6 @@ function initMigrationConfig(options) {
   const configPath = path19.join(migrationDirectory(projectRoot), "config.json");
   const created = !fs15.existsSync(configPath);
   const existing = created ? {} : JSON.parse(fs15.readFileSync(configPath, "utf8"));
-  const configuredAndroidBuild = options.androidBuild ?? existing.commands?.androidBuild ?? defaultAndroidBuild(projectRoot);
   const config = {
     ...existing,
     configVersion: existing.configVersion ?? "1.0.0",
@@ -3545,8 +3454,8 @@ function initMigrationConfig(options) {
     ...existing.harmonySdk ? { harmonySdk: existing.harmonySdk } : {},
     commands: {
       ...existing.commands ?? {},
-      androidBuild: normalizeAndroidBuildCommand(configuredAndroidBuild),
-      androidTest: options.androidTest ?? existing.commands?.androidTest ?? null,
+      androidBuild: normalizeAndroidBuildCommand(existing.commands?.androidBuild ?? null),
+      androidTest: existing.commands?.androidTest ?? null,
       harmonyStatic: existing.commands?.harmonyStatic ?? null
     }
   };
@@ -3570,7 +3479,7 @@ function validateMigrationConfig(project) {
 
 // src/commands/preflight.ts
 import fs20 from "fs";
-import path24 from "path";
+import path23 from "path";
 
 // src/commands/detect-android-ui-stack.ts
 import fs16 from "fs";
@@ -3641,69 +3550,13 @@ function detectAndroidUiStack(projectRoot) {
   };
 }
 
-// src/commands/check-android-emulator.ts
-import { spawnSync as spawnSync5 } from "child_process";
-var READY_MARKER2 = "A2H_ANDROID_EMULATOR_READY";
-function command2(executable, args, runner) {
-  const result = runner(executable, args, { encoding: "utf8", shell: false, timeout: 15e3 });
-  return {
-    exitCode: Number.isInteger(result.status) ? result.status : 1,
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? result.error?.message ?? ""
-  };
-}
-function parseAdbDevices(output) {
-  const devices = [];
-  for (const rawLine of String(output).split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("List of devices attached")) continue;
-    const [serial, state] = line.split(/\s+/, 2);
-    if (serial && state) devices.push({ serial, state });
-  }
-  return devices;
-}
-function checkAndroidEmulator({ adb = process.env.ADB_BINARY || "adb", runner = spawnSync5 } = {}) {
-  const list = command2(adb, ["devices"], runner);
-  if (list.exitCode !== 0) {
-    return optionalResult(adb, [], [], "ADB \u4E0D\u53EF\u7528\uFF0C\u672A\u68C0\u6D4B Android \u6A21\u62DF\u5668\uFF1B\u5EFA\u8BAE\u5B89\u88C5 Android SDK Platform-Tools \u548C Android \u6A21\u62DF\u5668\uFF0C\u540E\u7EED\u53EF\u8FDB\u884C Android/HarmonyOS \u5BF9\u7167\u9A8C\u8BC1", [list.stderr || list.stdout]);
-  }
-  const devices = parseAdbDevices(list.stdout).filter((device) => device.state === "device");
-  const probes = devices.map((device) => {
-    const qemu = command2(adb, ["-s", device.serial, "shell", "getprop", "ro.kernel.qemu"], runner);
-    return { ...device, qemu, isEmulator: qemu.exitCode === 0 && qemu.stdout.trim() === "1" };
-  });
-  const emulators = probes.filter((probe2) => probe2.isEmulator).map((probe2) => probe2.serial);
-  if (!emulators.length) {
-    return optionalResult(adb, devices.map((device) => device.serial), [], "\u672A\u68C0\u6D4B\u5230 Android \u6A21\u62DF\u5668\uFF08\u53EF\u9009\uFF09\uFF1B\u5EFA\u8BAE\u5B89\u88C5\u5E76\u542F\u52A8\u6A21\u62DF\u5668\uFF0C\u4EE5\u4FBF\u8FC1\u79FB\u65F6\u5BF9\u7167 Android \u4E0E HarmonyOS \u9875\u9762", [list.stdout || "adb devices returned no emulator"]);
-  }
-  const shellProbes = emulators.map((serial) => ({
-    serial,
-    result: command2(adb, ["-s", serial, "shell", "echo", READY_MARKER2], runner)
-  }));
-  const responsiveEmulators = shellProbes.filter(({ result }) => result.exitCode === 0 && result.stdout.includes(READY_MARKER2)).map(({ serial }) => serial);
-  if (!responsiveEmulators.length) {
-    return optionalResult(adb, emulators, [], "\u68C0\u6D4B\u5230 Android \u6A21\u62DF\u5668\u4F46 Shell \u65E0\u54CD\u5E94\uFF08\u53EF\u9009\uFF09\uFF1B\u5EFA\u8BAE\u4FEE\u590D\u6216\u91CD\u542F\u6A21\u62DF\u5668\uFF0C\u4EE5\u4FBF\u8FDB\u884C\u53CC\u7AEF\u9875\u9762\u5BF9\u7167", shellProbes.map(({ serial, result }) => `${serial}: ${result.stderr || result.stdout || `exit ${result.exitCode}`}`));
-  }
-  return {
-    status: "passed",
-    adb,
-    emulators,
-    responsiveEmulators,
-    summary: `\u53D1\u73B0 ${responsiveEmulators.length} \u4E2A\u53EF\u54CD\u5E94\u7684 Android \u6A21\u62DF\u5668\uFF0C\u53EF\u7528\u4E8E Android/HarmonyOS \u5BF9\u7167\u9A8C\u8BC1`,
-    evidence: responsiveEmulators
-  };
-}
-function optionalResult(adb, emulators, responsiveEmulators, summary, evidence2) {
-  return { status: "not_applicable", adb, emulators, responsiveEmulators, summary, evidence: evidence2 };
-}
-
 // src/commands/git-checkpoint.ts
 import path21 from "path";
 import fs17 from "fs";
 import { createHash as createHash5 } from "crypto";
-import { spawnSync as spawnSync6 } from "child_process";
+import { spawnSync as spawnSync5 } from "child_process";
 function git(projectRoot, args) {
-  const result = spawnSync6("git", ["-C", projectRoot, ...args], { encoding: "utf8", shell: false, timeout: 3e4, windowsHide: true });
+  const result = spawnSync5("git", ["-C", projectRoot, ...args], { encoding: "utf8", shell: false, timeout: 3e4, windowsHide: true });
   return {
     ok: !result.error && result.status === 0,
     exitCode: Number.isInteger(result.status) ? result.status : null,
@@ -3733,17 +3586,17 @@ function unstage(root, files) {
   if (head.ok) git(root, ["restore", "--staged", "--", ...files]);
   else git(root, ["rm", "--cached", "-r", "--ignore-unmatch", "--", ...files]);
 }
-function initializeHarmonyRepository(androidRoot, harmonyRoot) {
-  const existing = repositoryRoot(harmonyRoot);
+function initializeHarmonyRepository(androidRoot, harmonyRoot2) {
+  const existing = repositoryRoot(harmonyRoot2);
   if (existing) return { root: existing, initialized: false };
   const androidBranch = git(androidRoot, ["branch", "--show-current"]).stdout || "main";
-  const initialized = git(harmonyRoot, ["init", "-b", androidBranch]);
-  if (!initialized.ok) throw new Error(initialized.stderr || `Cannot initialize HarmonyOS Git repository: ${harmonyRoot}`);
+  const initialized = git(harmonyRoot2, ["init", "-b", androidBranch]);
+  if (!initialized.ok) throw new Error(initialized.stderr || `Cannot initialize HarmonyOS Git repository: ${harmonyRoot2}`);
   for (const key of ["user.name", "user.email"]) {
     const value = git(androidRoot, ["config", "--get", key]);
-    if (value.ok && value.stdout) git(harmonyRoot, ["config", key, value.stdout]);
+    if (value.ok && value.stdout) git(harmonyRoot2, ["config", key, value.stdout]);
   }
-  return { root: path21.resolve(harmonyRoot), initialized: true };
+  return { root: path21.resolve(harmonyRoot2), initialized: true };
 }
 function relevantStatus(status, ignoreUntrackedRoots = []) {
   const ignored = ignoreUntrackedRoots.map((value) => value.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, ""));
@@ -3756,8 +3609,8 @@ function relevantStatus(status, ignoreUntrackedRoots = []) {
 }
 function gitWorkspaceStatus(project, options = {}) {
   const projectRoot = path21.resolve(project);
-  const inside4 = git(projectRoot, ["rev-parse", "--is-inside-work-tree"]);
-  if (!inside4.ok || inside4.stdout !== "true") return { status: "failed", repository: false, projectRoot, errors: [inside4.stderr || "not a Git worktree"] };
+  const inside5 = git(projectRoot, ["rev-parse", "--is-inside-work-tree"]);
+  if (!inside5.ok || inside5.stdout !== "true") return { status: "failed", repository: false, projectRoot, errors: [inside5.stderr || "not a Git worktree"] };
   const head = git(projectRoot, ["rev-parse", "HEAD"]);
   const branch = git(projectRoot, ["branch", "--show-current"]);
   const porcelain = git(projectRoot, ["status", "--porcelain=v1", "--untracked-files=all"]);
@@ -3777,13 +3630,13 @@ function createGitCheckpoint(options) {
   const projectRoot = fs17.realpathSync(path21.resolve(options.project));
   const requestedHarmonyRoot = options.harmonyProject ? path21.resolve(options.harmonyProject) : null;
   if (requestedHarmonyRoot && (!fs17.existsSync(requestedHarmonyRoot) || !fs17.statSync(requestedHarmonyRoot).isDirectory())) throw new Error(`HarmonyOS project not found: ${requestedHarmonyRoot}`);
-  const harmonyRoot = requestedHarmonyRoot ? fs17.realpathSync(requestedHarmonyRoot) : null;
+  const harmonyRoot2 = requestedHarmonyRoot ? fs17.realpathSync(requestedHarmonyRoot) : null;
   if (!options.message?.trim()) throw new Error("checkpoint create requires --message");
   if (!options.all && options.include.length === 0) throw new Error("checkpoint create requires at least one --include or explicit --all");
   const baseline = gitWorkspaceStatus(projectRoot);
   if (!baseline.repository) throw new Error(baseline.errors?.[0] ?? "not a Git repository");
   const androidRepository = repositoryRoot(projectRoot);
-  const harmonyRepository = harmonyRoot ? repositoryRoot(harmonyRoot) ?? initializeHarmonyRepository(androidRepository, harmonyRoot).root : androidRepository;
+  const harmonyRepository = harmonyRoot2 ? repositoryRoot(harmonyRoot2) ?? initializeHarmonyRepository(androidRepository, harmonyRoot2).root : androidRepository;
   const repositories = [.../* @__PURE__ */ new Set([androidRepository, harmonyRepository])];
   for (const root of repositories) {
     const before = stagedFiles(root);
@@ -3796,18 +3649,18 @@ function createGitCheckpoint(options) {
     if (options.all) {
       const androidAdd = git(projectRoot, ["add", "-A", "--", ".", ":!.migration"]);
       if (!androidAdd.ok) throw new Error(androidAdd.stderr || "git add failed for Android project");
-      if (harmonyRoot && harmonyRepository !== androidRepository) {
-        const harmonyAdd = git(harmonyRoot, ["add", "-A", "--", ".", ":!.migration"]);
+      if (harmonyRoot2 && harmonyRepository !== androidRepository) {
+        const harmonyAdd = git(harmonyRoot2, ["add", "-A", "--", ".", ":!.migration"]);
         if (!harmonyAdd.ok) throw new Error(harmonyAdd.stderr || "git add failed for HarmonyOS project");
-      } else if (harmonyRoot && !inside2(projectRoot, harmonyRoot)) {
-        const harmonyPath = normalized(path21.relative(androidRepository, harmonyRoot));
+      } else if (harmonyRoot2 && !inside2(projectRoot, harmonyRoot2)) {
+        const harmonyPath = normalized(path21.relative(androidRepository, harmonyRoot2));
         const harmonyAdd = git(androidRepository, ["add", "-A", "--", harmonyPath]);
         if (!harmonyAdd.ok) throw new Error(harmonyAdd.stderr || "git add failed for HarmonyOS project");
       }
     } else {
       for (const value of options.include) {
         const absolute = path21.resolve(projectRoot, value);
-        const root = harmonyRoot && inside2(harmonyRoot, absolute) ? harmonyRepository : (() => {
+        const root = harmonyRoot2 && inside2(harmonyRoot2, absolute) ? harmonyRepository : (() => {
           if (inside2(projectRoot, absolute)) return androidRepository;
           return null;
         })();
@@ -3829,7 +3682,7 @@ function createGitCheckpoint(options) {
     try {
       committedFiles = [...new Map((options.provenanceFiles ?? []).map((item) => [`${item.role}:${item.file}`, item])).values()].sort((left, right) => left.file.localeCompare(right.file) || left.role.localeCompare(right.role)).map((item) => {
         const absolute = path21.resolve(projectRoot, item.file);
-        const expectedRoot = item.role === "harmony-implementation" ? harmonyRoot : projectRoot;
+        const expectedRoot = item.role === "harmony-implementation" ? harmonyRoot2 : projectRoot;
         const root = item.role === "harmony-implementation" ? harmonyRepository : androidRepository;
         const relative2 = normalized(path21.relative(projectRoot, absolute));
         if (!expectedRoot || !inside2(expectedRoot, absolute) || !fs17.existsSync(absolute) || !fs17.statSync(absolute).isFile()) {
@@ -3859,12 +3712,12 @@ function createGitCheckpoint(options) {
       committedFiles,
       repositories: {
         android: { root: ".", gitRoot: normalized(path21.relative(projectRoot, androidRepository)) || "." },
-        harmony: harmonyRoot ? { root: normalized(path21.relative(projectRoot, harmonyRoot)), gitRoot: normalized(path21.relative(projectRoot, harmonyRepository)) } : null
+        harmony: harmonyRoot2 ? { root: normalized(path21.relative(projectRoot, harmonyRoot2)), gitRoot: normalized(path21.relative(projectRoot, harmonyRepository)) } : null
       }
     };
   }
   const commitResults = [];
-  const separateHarmony = harmonyRoot && harmonyRepository !== androidRepository;
+  const separateHarmony = harmonyRoot2 && harmonyRepository !== androidRepository;
   if (separateHarmony) {
     const files2 = stagedFiles(harmonyRepository);
     if (files2.length) {
@@ -3886,9 +3739,9 @@ function createGitCheckpoint(options) {
     commitResults.push({ kind: "android", root: androidRepository, commit: git(androidRepository, ["rev-parse", "HEAD"]).stdout, files: androidFiles, summary: androidCommit.stdout });
   }
   const androidCheckpoint = commitResults.find((item) => item.kind === "android");
-  if (harmonyRoot && harmonyRepository === androidRepository) {
-    commitResults.push({ kind: "harmony", root: harmonyRepository, commit: androidCheckpoint.commit, files: androidFiles.filter((file) => inside2(harmonyRoot, path21.resolve(harmonyRepository, file))), summary: androidCheckpoint.summary });
-  } else if (harmonyRoot && !commitResults.some((item) => item.kind === "harmony")) {
+  if (harmonyRoot2 && harmonyRepository === androidRepository) {
+    commitResults.push({ kind: "harmony", root: harmonyRepository, commit: androidCheckpoint.commit, files: androidFiles.filter((file) => inside2(harmonyRoot2, path21.resolve(harmonyRepository, file))), summary: androidCheckpoint.summary });
+  } else if (harmonyRoot2 && !commitResults.some((item) => item.kind === "harmony")) {
     const harmonyHead = git(harmonyRepository, ["rev-parse", "HEAD"]).stdout;
     if (harmonyHead) commitResults.push({ kind: "harmony", root: harmonyRepository, commit: harmonyHead, files: [], summary: "HarmonyOS repository already clean" });
   }
@@ -3921,12 +3774,10 @@ function createGitCheckpoint(options) {
 
 // src/commands/system-checks.ts
 import fs18 from "fs";
-import os3 from "os";
-import path22 from "path";
-function probe(command3, args, timeout = 15e3) {
-  const result = spawnCommandSync(command3, args, { encoding: "utf8", timeout, windowsHide: true });
+function probe(command2, args, timeout = 15e3) {
+  const result = spawnCommandSync(command2, args, { encoding: "utf8", timeout, windowsHide: true });
   return {
-    command: command3,
+    command: command2,
     available: !result.error && result.status === 0,
     exitCode: Number.isInteger(result.status) ? result.status : null,
     output: String(result.stdout || result.stderr || result.error?.message || "").trim().split(/\r?\n/)[0] ?? ""
@@ -3935,8 +3786,7 @@ function probe(command3, args, timeout = 15e3) {
 function firstDirectory(values) {
   return values.find((value) => Boolean(value && fs18.existsSync(value) && fs18.statSync(value).isDirectory())) ?? null;
 }
-function checkToolchain(project, env = process.env) {
-  const projectRoot = path22.resolve(project);
+function checkToolchain(_project, env = process.env) {
   const pythonCandidates = [
     env.PYTHON_BINARY,
     process.platform === "win32" ? "python" : "python3",
@@ -3956,23 +3806,14 @@ function checkToolchain(project, env = process.env) {
     java: probe("java", ["-version"]),
     appgraph: probe("appgraph", ["--version"])
   };
-  const androidSdk = firstDirectory([
-    env.ANDROID_SDK_ROOT,
-    env.ANDROID_HOME,
-    process.platform === "darwin" ? path22.join(os3.homedir(), "Library", "Android", "sdk") : null,
-    process.platform === "win32" && env.LOCALAPPDATA ? path22.join(env.LOCALAPPDATA, "Android", "Sdk") : null
-  ]);
   const devecoHome = firstDirectory([
     env.DEVECO_STUDIO_HOME,
     env.DEVECO_HOME,
     process.platform === "darwin" ? "/Applications/DevEco-Studio.app/Contents" : null
   ]);
-  const androidBuildEntry = ["gradlew", "gradlew.bat", "settings.gradle", "settings.gradle.kts"].map((name) => path22.join(projectRoot, name)).find((file) => fs18.existsSync(file)) ?? null;
   const checks = [
     ...Object.entries(commands).map(([id, value]) => ({ id, status: value.available ? "passed" : "failed", summary: value.available ? value.output || `${id} available` : `${id} unavailable`, evidence: [value.command] })),
-    { id: "android-sdk", status: androidSdk ? "passed" : "failed", summary: androidSdk ?? "Android SDK not found", evidence: androidSdk ? [androidSdk] : [] },
-    { id: "deveco", status: devecoHome ? "passed" : "failed", summary: devecoHome ?? "DevEco Studio not found", evidence: devecoHome ? [devecoHome] : [] },
-    { id: "android-build-entry", status: androidBuildEntry ? "passed" : "failed", summary: androidBuildEntry ?? "Android build entry not found", evidence: androidBuildEntry ? [androidBuildEntry] : [] }
+    { id: "deveco", status: devecoHome ? "passed" : "failed", summary: devecoHome ?? "DevEco Studio not found", evidence: devecoHome ? [devecoHome] : [] }
   ];
   const nodeMajor = Number.parseInt(process.versions.node.split(".")[0], 10);
   const pythonMatch = commands.python.output.match(/(\d+)\.(\d+)/);
@@ -3981,7 +3822,7 @@ function checkToolchain(project, env = process.env) {
   if (nodeCheck && (nodeMajor < 20 || nodeMajor > 24)) Object.assign(nodeCheck, { status: "failed", summary: `Node.js ${process.versions.node} is outside supported range 20-24` });
   const pythonCheck = checks.find((item) => item.id === "python");
   if (pythonCheck && !pythonSupported) Object.assign(pythonCheck, { status: "failed", summary: `${commands.python.output || "Python unavailable"}; Python 3.10+ is required` });
-  return { status: checks.some((item) => item.status === "failed") ? "failed" : "passed", checks, commands, androidSdk, devecoHome, androidBuildEntry };
+  return { status: checks.some((item) => item.status === "failed") ? "failed" : "passed", checks, commands, devecoHome };
 }
 function checkAppGraphHealth() {
   const version = probe("appgraph", ["--version"]);
@@ -3993,7 +3834,7 @@ function checkAppGraphHealth() {
 
 // src/commands/preflight-checklist.ts
 import fs19 from "fs";
-import path23 from "path";
+import path22 from "path";
 var PREFLIGHT_CHECKS = [
   { id: "android-ui-stack", name: "Android UI \u6280\u672F\u6808", required: true },
   { id: "git", name: "Git \u4ED3\u5E93\u548C\u5DE5\u4F5C\u533A", required: true },
@@ -4027,7 +3868,7 @@ function validateChecklist(value) {
   return value;
 }
 function loadPreflightChecklist(file) {
-  const checklistPath = path23.resolve(file);
+  const checklistPath = path22.resolve(file);
   if (!fs19.existsSync(checklistPath)) throw new Error(`Preflight checklist not found: ${checklistPath}`);
   let checklist;
   try {
@@ -4045,7 +3886,7 @@ function loadPreflightChecklist(file) {
 
 // src/commands/preflight.ts
 var atomicJson2 = (file, value) => {
-  fs20.mkdirSync(path24.dirname(file), { recursive: true });
+  fs20.mkdirSync(path23.dirname(file), { recursive: true });
   const temporary = `${file}.${process.pid}.tmp`;
   fs20.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}
 `, "utf8");
@@ -4059,7 +3900,7 @@ function check(id, result, required = true) {
   return entry;
 }
 async function runPreflight(options) {
-  const projectRoot = path24.resolve(options.project);
+  const projectRoot = path23.resolve(options.project);
   if (!fs20.existsSync(projectRoot) || !fs20.statSync(projectRoot).isDirectory()) throw new Error(`Android project directory not found: ${projectRoot}`);
   const timeoutMs = options.timeoutMs ?? 30 * 60 * 1e3;
   const checks = [];
@@ -4071,7 +3912,7 @@ async function runPreflight(options) {
   const enabled = (id) => checklist.isEnabled(id);
   const skip = (id) => checks.push(check(id, { status: "skipped", summary: "Skipped by preflight checklist", evidence: [checklist.checklistPath] }, required(id)));
   const environmentRemediation2 = {
-    toolchain: "\u4E3B\u673A\u5DE5\u5177\u94FE\u4E0D\u5B8C\u6574\u3002\u8BF7\u5B89\u88C5/\u914D\u7F6E\u7F3A\u5931\u7EC4\u4EF6\uFF08git\u3001Node.js 20-24\u3001npm\u3001Python 3.10+\u3001JDK\u3001Android SDK\u3001DevEco \u5DE5\u5177\u94FE\uFF09\uFF0C\u7136\u540E\u91CD\u65B0\u8FD0\u884C droid2hmos preflight\u3002",
+    toolchain: "\u4E3B\u673A\u5DE5\u5177\u94FE\u4E0D\u5B8C\u6574\u3002\u8BF7\u5B89\u88C5/\u914D\u7F6E\u7F3A\u5931\u7EC4\u4EF6\uFF08git\u3001Node.js 20-24\u3001npm\u3001Python 3.10+\u3001JDK\u3001DevEco \u5DE5\u5177\u94FE\uFF09\uFF0C\u7136\u540E\u91CD\u65B0\u8FD0\u884C droid2hmos preflight\u3002",
     appgraph: "appgraph CLI \u4E0D\u53EF\u7528\u6216\u4E0D\u517C\u5BB9\u3002\u8BF7\u5148\u6267\u884C npm install -g @harmonyos-arkts/appgraph@latest --force\uFF0C\u7136\u540E\u91CD\u65B0\u8FD0\u884C droid2hmos preflight\u3002",
     "harmony-sdk": "\u672A\u53D1\u73B0\u53EF\u7528\u7684 HarmonyOS SDK\u3002\u8BF7\u5728 DevEco Studio \u4E2D\u5B89\u88C5 SDK\uFF0C\u7136\u540E\u91CD\u65B0\u8FD0\u884C droid2hmos preflight\u3002",
     "harmony-device": "\u672A\u53D1\u73B0\u53EF\u54CD\u5E94\u7684 HarmonyOS \u8BBE\u5907/\u6A21\u62DF\u5668\u3002\u8BF7\u8FDE\u63A5\u5E76\u6388\u6743\u771F\u673A\u6216\u542F\u52A8\u6A21\u62DF\u5668\uFF0C\u786E\u4FDD DevEco CLI \u53EF\u53D1\u73B0\u4E14 shell \u53EF\u54CD\u5E94\uFF0C\u7136\u540E\u91CD\u65B0\u8FD0\u884C droid2hmos preflight\u3002"
@@ -4104,12 +3945,12 @@ async function runPreflight(options) {
   let harmonyProject = defaultHarmonyProjectPath(projectRoot);
   let existingConfig = null;
   try {
-    existingConfig = JSON.parse(fs20.readFileSync(path24.join(migrationDirectory(projectRoot), "config.json"), "utf8"));
+    existingConfig = JSON.parse(fs20.readFileSync(path23.join(migrationDirectory(projectRoot), "config.json"), "utf8"));
     const configuredHarmony = existingConfig.harmonyProject ?? defaultHarmonyProjectPath(projectRoot);
-    harmonyProject = path24.isAbsolute(configuredHarmony) ? configuredHarmony : path24.resolve(projectRoot, configuredHarmony);
+    harmonyProject = path23.isAbsolute(configuredHarmony) ? configuredHarmony : path23.resolve(projectRoot, configuredHarmony);
   } catch {
   }
-  const relativeHarmony = path24.relative(projectRoot, harmonyProject).replaceAll("\\", "/");
+  const relativeHarmony = path23.relative(projectRoot, harmonyProject).replaceAll("\\", "/");
   const ignoreUntrackedRoots = existingConfig && relativeHarmony && !relativeHarmony.startsWith("../") ? [relativeHarmony] : [];
   git2 = gitWorkspaceStatus(projectRoot, { ignoreUntrackedRoots });
   const hasRequiredFailures = () => checks.some((item) => item.required && item.status !== "passed" && item.status !== "skipped");
@@ -4126,7 +3967,7 @@ async function runPreflight(options) {
       result,
       checks: checks.map(({ id, status, summary, evidence: evidence2, retry }) => retry ? { id, status, summary, evidence: evidence2, retry } : { id, status, summary, evidence: evidence2 })
     };
-    const reportPath = path24.join(migrationDirectory(projectRoot), "preflight-report.json");
+    const reportPath = path23.join(migrationDirectory(projectRoot), "preflight-report.json");
     atomicJson2(reportPath, report);
     if (showProgress) progressOutput.write(`[preflight] \u5B8C\u6210: ${result}\uFF08\u5171 ${checks.length} \u9879\u68C0\u67E5\uFF0C\u5FC5\u9700\u5931\u8D25 ${requiredFailures.length} \u9879\uFF09\uFF0C\u62A5\u544A: ${reportPath}
 `);
@@ -4174,7 +4015,7 @@ async function runPreflight(options) {
   let configInit;
   if (enabled("config")) displayGate("config");
   try {
-    const existingConfigPath = path24.join(migrationDirectory(projectRoot), "config.json");
+    const existingConfigPath = path23.join(migrationDirectory(projectRoot), "config.json");
     configInit = !enabled("config") && fs20.existsSync(existingConfigPath) ? { configPath: existingConfigPath, config: JSON.parse(fs20.readFileSync(existingConfigPath, "utf8")) } : initMigrationConfig({ project: projectRoot });
   } catch (error) {
     checks.push(check("config", { status: "failed", summary: error instanceof Error ? error.message : String(error) }));
@@ -4182,26 +4023,27 @@ async function runPreflight(options) {
   }
   const configPath = configInit.configPath;
   const config = configInit.config;
-  const configuredHarmonyProject = typeof config.harmonyProject === "string" ? config.harmonyProject : path24.relative(projectRoot, defaultHarmonyProjectPath(projectRoot));
-  harmonyProject = path24.isAbsolute(configuredHarmonyProject) ? configuredHarmonyProject : path24.resolve(projectRoot, configuredHarmonyProject);
+  const configuredHarmonyProject = typeof config.harmonyProject === "string" ? config.harmonyProject : path23.relative(projectRoot, defaultHarmonyProjectPath(projectRoot));
+  harmonyProject = path23.isAbsolute(configuredHarmonyProject) ? configuredHarmonyProject : path23.resolve(projectRoot, configuredHarmonyProject);
   if (enabled("config")) checks.push(check("config", { ...validateMigrationConfig(projectRoot), summary: "Migration config initialized and validated", evidence: [configPath] }));
   else skip("config");
   if (hasRequiredFailures()) return finish();
   if (!enabled("android-build")) skip("android-build");
-  else if (config.commands?.androidBuild) {
-    const androidBuild = await displayBuildProgress("android-build", () => runConfigCommandAsync({ configPath, key: "androidBuild", timeoutMs }));
-    checks.push(check("android-build", androidBuild, required("android-build")));
-  } else {
+  else {
     displayGate("android-build");
     checks.push(check("android-build", {
       status: "not_applicable",
-      summary: "Android \u6784\u5EFA\u672A\u914D\u7F6E\uFF08\u8FC1\u79FB\u9ED8\u8BA4\u4E0D\u7F16\u8BD1 Android \u5DE5\u7A0B\uFF09\uFF1B\u5982\u9700\u53CC\u7AEF\u8FD0\u884C\u5BF9\u7167\u53EF\u663E\u5F0F\u914D\u7F6E commands.androidBuild"
+      summary: "Android \u6784\u5EFA\u80FD\u529B\u5DF2\u79FB\u9664\uFF08\u8FC1\u79FB\u6D41\u7A0B\u4E0D\u4F9D\u8D56 Android \u7F16\u8BD1\u73AF\u5883\uFF09\uFF1B\u53CC\u7AEF\u5BF9\u7167\u4EE5\u6E90\u7801\u4E0E\u9759\u6001 facts \u4E3A\u57FA\u51C6"
     }, required("android-build")));
   }
-  if (enabled("android-emulator")) {
+  if (!enabled("android-emulator")) skip("android-emulator");
+  else {
     displayGate("android-emulator");
-    checks.push(check("android-emulator", checkAndroidEmulator(), false));
-  } else skip("android-emulator");
+    checks.push(check("android-emulator", {
+      status: "not_applicable",
+      summary: "Android \u6A21\u62DF\u5668\u68C0\u6D4B\u5DF2\u79FB\u9664\uFF08\u8FC1\u79FB\u6D41\u7A0B\u4E0D\u4F9D\u8D56 Android \u8FD0\u884C\u73AF\u5883\uFF09"
+    }, required("android-emulator")));
+  }
   if (hasRequiredFailures()) return finish();
   if (enabled("harmony-project")) {
     displayGate("harmony-project");
@@ -4240,9 +4082,9 @@ async function runPreflight(options) {
 }
 
 // src/commands/deveco-auth-login.ts
-import { spawn as spawn3, spawnSync as spawnSync7 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 import { closeSync as closeSync3, existsSync as existsSync6, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
-import path25 from "path";
+import path24 from "path";
 import { setTimeout as delay2 } from "timers/promises";
 var MANAGED_LOGIN_SERVICE_NAME = "devecocli-auth";
 var LOGIN_URL_PATTERN = /https?:\/\/[^\s"'<>]+/i;
@@ -4251,13 +4093,13 @@ function isDevEcoCliLoginCommand(commandLine) {
   return DEVECO_LOGIN_COMMAND_PATTERN.test(commandLine);
 }
 function managedLoginStatePaths(project) {
-  const directory = path25.join(migrationDirectory(project), "services");
-  const pidFile = path25.join(directory, `${MANAGED_LOGIN_SERVICE_NAME}.pid`);
+  const directory = path24.join(migrationDirectory(project), "services");
+  const pidFile = path24.join(directory, `${MANAGED_LOGIN_SERVICE_NAME}.pid`);
   return {
     directory,
     pidFile,
-    stdoutLog: path25.join(directory, `${MANAGED_LOGIN_SERVICE_NAME}.stdout.log`),
-    stderrLog: path25.join(directory, `${MANAGED_LOGIN_SERVICE_NAME}.stderr.log`),
+    stdoutLog: path24.join(directory, `${MANAGED_LOGIN_SERVICE_NAME}.stdout.log`),
+    stderrLog: path24.join(directory, `${MANAGED_LOGIN_SERVICE_NAME}.stderr.log`),
     exitFile: `${pidFile}.exit`,
     errorFile: `${pidFile}.error`
   };
@@ -4288,7 +4130,7 @@ function tailFile(file, maxChars) {
   }
 }
 function listPosixProcesses() {
-  const result = spawnSync7("ps", ["-eo", "pid=,command="], { encoding: "utf8", timeout: 15e3 });
+  const result = spawnSync6("ps", ["-eo", "pid=,command="], { encoding: "utf8", timeout: 15e3 });
   if (result.error || result.status !== 0) return [];
   return result.stdout.split("\n").flatMap((line) => {
     const trimmed = line.trim();
@@ -4296,15 +4138,15 @@ function listPosixProcesses() {
     const separator = trimmed.indexOf(" ");
     if (separator <= 0) return [];
     const pid = Number.parseInt(trimmed.slice(0, separator), 10);
-    const command3 = trimmed.slice(separator + 1);
-    return Number.isInteger(pid) && pid > 0 ? [{ pid, command: command3 }] : [];
+    const command2 = trimmed.slice(separator + 1);
+    return Number.isInteger(pid) && pid > 0 ? [{ pid, command: command2 }] : [];
   });
 }
 function listWindowsProcesses() {
   const source = 'Get-CimInstance Win32_Process -Filter "CommandLine IS NOT NULL" | ForEach-Object { "$($_.ProcessId)`t$($_.CommandLine)" }';
   const encoded = Buffer.from(source, "utf16le").toString("base64");
-  const powershell = process.env.SystemRoot ? path25.resolve(process.env.SystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
-  const result = spawnSync7(powershell, ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", encoded], {
+  const powershell = process.env.SystemRoot ? path24.resolve(process.env.SystemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
+  const result = spawnSync6(powershell, ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", encoded], {
     encoding: "utf8",
     timeout: 3e4,
     windowsHide: true
@@ -4314,8 +4156,8 @@ function listWindowsProcesses() {
     const separator = line.indexOf("	");
     if (separator <= 0) return [];
     const pid = Number.parseInt(line.slice(0, separator), 10);
-    const command3 = line.slice(separator + 1);
-    return Number.isInteger(pid) && pid > 0 ? [{ pid, command: command3 }] : [];
+    const command2 = line.slice(separator + 1);
+    return Number.isInteger(pid) && pid > 0 ? [{ pid, command: command2 }] : [];
   });
 }
 function listDevEcoCliLoginProcesses(options = {}) {
@@ -4327,7 +4169,7 @@ function listDevEcoCliLoginProcesses(options = {}) {
 }
 async function terminateProcessTree(pid) {
   if (process.platform === "win32") {
-    spawnSync7("taskkill", ["/PID", String(pid), "/T", "/F"], { encoding: "utf8", timeout: 15e3, windowsHide: true });
+    spawnSync6("taskkill", ["/PID", String(pid), "/T", "/F"], { encoding: "utf8", timeout: 15e3, windowsHide: true });
     return;
   }
   try {
@@ -4345,7 +4187,7 @@ async function terminateProcessTree(pid) {
   }
 }
 async function killOrphanDevEcoCliLogins(options) {
-  const state = managedLoginStatePaths(path25.resolve(options.project));
+  const state = managedLoginStatePaths(path24.resolve(options.project));
   const terminate = options.terminator ?? terminateProcessTree;
   const targets = /* @__PURE__ */ new Set();
   const managedPid = readPidFile(state.pidFile);
@@ -4373,12 +4215,12 @@ async function killOrphanDevEcoCliLogins(options) {
 }
 function runDetachedDevEcoAuthHost(requestPath) {
   const request = JSON.parse(readFileSync5(requestPath, "utf8"));
-  mkdirSync3(path25.dirname(request.stdout), { recursive: true });
-  mkdirSync3(path25.dirname(request.stderr), { recursive: true });
+  mkdirSync3(path24.dirname(request.stdout), { recursive: true });
+  mkdirSync3(path24.dirname(request.stderr), { recursive: true });
   const stdout = openSync3(request.stdout, "a");
   const stderr = openSync3(request.stderr, "a");
   try {
-    const child = spawn3(request.command[0], request.command.slice(1), {
+    const child = spawnCommand(request.command[0], request.command.slice(1), {
       cwd: request.cwd,
       detached: true,
       env: { ...process.env, ...request.env ?? {} },
@@ -4386,6 +4228,13 @@ function runDetachedDevEcoAuthHost(requestPath) {
       windowsHide: true
     });
     const stdin = child.stdin;
+    if (!stdin) {
+      try {
+        child.kill();
+      } catch {
+      }
+      throw new Error("DevEco CLI \u767B\u5F55\u8FDB\u7A0B\u7684 stdin \u4E0D\u53EF\u7528");
+    }
     stdin.on("error", () => {
     });
     stdin.write("\n");
@@ -4437,7 +4286,7 @@ async function managedDevEcoCliLogin(options) {
   const statusTimeoutMs = options.statusTimeoutMs ?? 15e3;
   const progress = options.onProgress ?? (() => {
   });
-  const projectRoot = path25.resolve(options.project);
+  const projectRoot = path24.resolve(options.project);
   const state = managedLoginStatePaths(projectRoot);
   const failure = (summary, extra = {}) => ({
     status: "failed",
@@ -4476,7 +4325,7 @@ async function managedDevEcoCliLogin(options) {
     stdout: state.stdoutLog,
     stderr: state.stderrLog,
     command: devEcoCliSpawn(executable, ["auth", "login"]),
-    env: { DEVECO_CLI_SKIP_VERSION_CHECK: "1" }
+    env: devEcoCliEnvironment()
   }, null, 2), "utf8");
   launchHostOutsideRunner(requestPath, options.hostCommand);
   progress(`\u5DF2\u6301\u4E45\u62C9\u8D77\u767B\u5F55\u8FDB\u7A0B\uFF08\u56DE\u8C03\u670D\u52A1\u5668\u968F\u8FDB\u7A0B\u5B58\u6D3B\uFF09\uFF0C\u65E5\u5FD7: ${state.stdoutLog}`);
@@ -4531,17 +4380,17 @@ async function managedDevEcoCliLogin(options) {
 
 // src/commands/device-evidence.ts
 import fs21 from "fs";
-import path26 from "path";
+import path25 from "path";
 import { createHash as createHash6 } from "crypto";
-import { spawnSync as spawnSync8 } from "child_process";
+import { spawnSync as spawnSync7 } from "child_process";
 import { inflateSync } from "zlib";
 function safeName(value) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value)) throw new Error("evidence name must use letters, digits, dot, underscore, or dash");
   return value;
 }
-function run(command3, args, encoding = "utf8") {
-  const script = /\.m?js$/i.test(command3);
-  const result = spawnSync8(script ? process.execPath : command3, script ? [command3, ...args] : args, {
+function run(command2, args, encoding = "utf8") {
+  const script = /\.m?js$/i.test(command2);
+  const result = spawnSync7(script ? process.execPath : command2, script ? [command2, ...args] : args, {
     encoding: encoding === "buffer" ? null : encoding,
     shell: false,
     timeout: 3e4,
@@ -4553,7 +4402,7 @@ function run(command3, args, encoding = "utf8") {
     status: Number.isInteger(result.status) ? result.status : null,
     stdout: result.stdout ?? (encoding === "buffer" ? Buffer.alloc(0) : ""),
     stderr: String(result.stderr ?? result.error?.message ?? ""),
-    invocation: [command3, ...args]
+    invocation: [command2, ...args]
   };
 }
 function writeResult(file, result) {
@@ -4649,72 +4498,39 @@ function pixelMetrics(leftFile, rightFile) {
     return null;
   }
 }
-function selectTarget(command3, listArgs, explicit) {
-  if (explicit) return explicit;
-  const listed = run(command3, listArgs);
-  if (!listed.ok) throw new Error(`${command3} target discovery failed: ${listed.stderr}`);
-  const lines = String(listed.stdout).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  if (command3 === "adb") {
-    const found = lines.filter((line) => !line.startsWith("List of devices")).map((line) => line.split(/\s+/)).find((parts) => parts[1] === "device");
-    if (found) return found[0];
-  } else {
-    const found = lines.find((line) => !/^\[?empty\]?$/i.test(line) && !/^list of targets/i.test(line));
-    if (found) return found;
-  }
-  throw new Error(`No responsive ${command3} target found`);
-}
 function captureDeviceEvidence(options) {
-  const projectRoot = path26.resolve(options.project);
+  const projectRoot = path25.resolve(options.project);
   const migrationRoot = migrationDirectory(projectRoot);
   const workspaceRoot = migrationWorkspaceRoot(projectRoot);
   const name = safeName(options.name);
   const capturedAt = /* @__PURE__ */ new Date();
-  const directory = path26.join(migrationRoot, "evidence", name, options.platform);
+  const directory = path25.join(migrationRoot, "evidence", name, options.platform);
   fs21.mkdirSync(directory, { recursive: true });
-  const screenshot = path26.join(directory, "screenshot.png");
-  const layout = path26.join(directory, options.platform === "android" ? "layout.xml" : "layout.json");
-  const logs = path26.join(directory, "device.log");
+  const screenshot = path25.join(directory, "screenshot.png");
+  const layout = path25.join(directory, "layout.json");
+  const logs = path25.join(directory, "device.log");
   const commands = [];
   let target;
-  if (options.platform === "android") {
-    const adb = options.adb ?? process.env.ADB_BINARY ?? "adb";
-    target = selectTarget(adb, ["devices"], options.target);
-    const prefix = ["-s", target];
-    const shot = run(adb, [...prefix, "exec-out", "screencap", "-p"], "buffer");
-    commands.push(shot);
-    writeResult(screenshot, shot);
-    const remote = `/sdcard/droid2hmos-${process.pid}.xml`;
-    const dump = run(adb, [...prefix, "shell", "uiautomator", "dump", remote]);
-    commands.push(dump);
-    const tree = run(adb, [...prefix, "exec-out", "cat", remote]);
-    commands.push(tree);
-    writeResult(layout, tree);
-    run(adb, [...prefix, "shell", "rm", "-f", remote]);
-    const log = run(adb, [...prefix, "logcat", "-d", "-t", "1000"]);
-    commands.push(log);
-    writeResult(logs, log);
-  } else {
-    const hdc = options.hdc ?? process.env.HDC_BINARY ?? "hdc";
-    const listed = run(hdc, ["list", "targets"]);
-    const candidates = String(listed.stdout).split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !/^\[?empty\]?$/i.test(line) && !/^list of targets/i.test(line));
-    if (!listed.ok || !candidates.length) throw new Error(`${hdc} target discovery failed: ${listed.stderr || "no targets"}`);
-    target = options.target ?? process.env.DROID2HMOS_HDC_TARGET ?? selectPreferredTarget(candidates);
-    const prefix = ["-t", target];
-    const remoteShot = `/data/local/tmp/droid2hmos-${process.pid}.png`;
-    const remoteLayout = `/data/local/tmp/droid2hmos-${process.pid}.json`;
-    const shot = run(hdc, [...prefix, "shell", "snapshot_display", "-f", remoteShot]);
-    commands.push(shot);
-    const recvShot = run(hdc, [...prefix, "file", "recv", remoteShot, screenshot]);
-    commands.push(recvShot);
-    const dump = run(hdc, [...prefix, "shell", "uitest", "dumpLayout", "-p", remoteLayout]);
-    commands.push(dump);
-    const recvLayout = run(hdc, [...prefix, "file", "recv", remoteLayout, layout]);
-    commands.push(recvLayout);
-    run(hdc, [...prefix, "shell", "rm", "-f", remoteShot, remoteLayout]);
-    const log = run(hdc, [...prefix, "shell", "hilog", "-x"]);
-    commands.push(log);
-    writeResult(logs, log);
-  }
+  const hdc = options.hdc ?? process.env.HDC_BINARY ?? "hdc";
+  const listed = run(hdc, ["list", "targets"]);
+  const candidates = String(listed.stdout).split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !/^\[?empty\]?$/i.test(line) && !/^list of targets/i.test(line));
+  if (!listed.ok || !candidates.length) throw new Error(`${hdc} target discovery failed: ${listed.stderr || "no targets"}`);
+  target = options.target ?? process.env.DROID2HMOS_HDC_TARGET ?? selectPreferredTarget(candidates);
+  const prefix = ["-t", target];
+  const remoteShot = `/data/local/tmp/droid2hmos-${process.pid}.png`;
+  const remoteLayout = `/data/local/tmp/droid2hmos-${process.pid}.json`;
+  const shot = run(hdc, [...prefix, "shell", "snapshot_display", "-f", remoteShot]);
+  commands.push(shot);
+  const recvShot = run(hdc, [...prefix, "file", "recv", remoteShot, screenshot]);
+  commands.push(recvShot);
+  const dump = run(hdc, [...prefix, "shell", "uitest", "dumpLayout", "-p", remoteLayout]);
+  commands.push(dump);
+  const recvLayout = run(hdc, [...prefix, "file", "recv", remoteLayout, layout]);
+  commands.push(recvLayout);
+  run(hdc, [...prefix, "shell", "rm", "-f", remoteShot, remoteLayout]);
+  const log = run(hdc, [...prefix, "shell", "hilog", "-x"]);
+  commands.push(log);
+  writeResult(logs, log);
   const artifacts = [screenshot, layout, logs].map(fileInfo).filter(Boolean);
   const failures = commands.filter((item) => !item.ok).map((item) => ({ invocation: item.invocation, status: item.status, stderr: item.stderr }));
   const metadata = {
@@ -4724,10 +4540,10 @@ function captureDeviceEvidence(options) {
     target,
     capturedAt: capturedAt.toISOString(),
     status: failures.length === 0 && artifacts.length === 3 ? "passed" : "failed",
-    artifacts: artifacts.map((item) => ({ ...item, path: path26.relative(workspaceRoot, item.path).replaceAll("\\", "/") })),
+    artifacts: artifacts.map((item) => ({ ...item, path: path25.relative(workspaceRoot, item.path).replaceAll("\\", "/") })),
     failures
   };
-  const metadataPath = path26.join(directory, "evidence.json");
+  const metadataPath = path25.join(directory, "evidence.json");
   fs21.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}
 `, "utf8");
   return { ...metadata, metadataPath };
@@ -4737,24 +4553,24 @@ function tokens(file) {
   return new Set(fs21.readFileSync(file, "utf8").toLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []);
 }
 function compareEvidence(options) {
-  const projectRoot = path26.resolve(options.project);
+  const projectRoot = path25.resolve(options.project);
   const migrationRoot = migrationDirectory(projectRoot);
   const resolveEvidence = (value) => {
     const normalized2 = value.replaceAll("\\", "/");
-    const root = path26.isAbsolute(value) ? value : (() => {
-      if (normalized2.startsWith(".migration/")) return path26.resolve(migrationWorkspaceRoot(projectRoot), value);
-      return path26.resolve(projectRoot, value);
+    const root = path25.isAbsolute(value) ? value : (() => {
+      if (normalized2.startsWith(".migration/")) return path25.resolve(migrationWorkspaceRoot(projectRoot), value);
+      return path25.resolve(projectRoot, value);
     })();
-    return fs21.statSync(root).isDirectory() ? root : path26.dirname(root);
+    return fs21.statSync(root).isDirectory() ? root : path25.dirname(root);
   };
   const androidRoot = resolveEvidence(options.android);
-  const harmonyRoot = resolveEvidence(options.harmony);
-  const androidShot = fileInfo(path26.join(androidRoot, "screenshot.png"));
-  const harmonyShot = fileInfo(path26.join(harmonyRoot, "screenshot.png"));
-  const pixels = pixelMetrics(path26.join(androidRoot, "screenshot.png"), path26.join(harmonyRoot, "screenshot.png"));
-  const layoutFile = (root) => [path26.join(root, "layout.json"), path26.join(root, "layout.xml")].find((file) => fs21.existsSync(file)) ?? path26.join(root, "layout.json");
+  const harmonyRoot2 = resolveEvidence(options.harmony);
+  const androidShot = fileInfo(path25.join(androidRoot, "screenshot.png"));
+  const harmonyShot = fileInfo(path25.join(harmonyRoot2, "screenshot.png"));
+  const pixels = pixelMetrics(path25.join(androidRoot, "screenshot.png"), path25.join(harmonyRoot2, "screenshot.png"));
+  const layoutFile = (root) => [path25.join(root, "layout.json"), path25.join(root, "layout.xml")].find((file) => fs21.existsSync(file)) ?? path25.join(root, "layout.json");
   const left = tokens(layoutFile(androidRoot));
-  const right = tokens(layoutFile(harmonyRoot));
+  const right = tokens(layoutFile(harmonyRoot2));
   const intersection = [...left].filter((value) => right.has(value));
   const union = /* @__PURE__ */ new Set([...left, ...right]);
   const result = {
@@ -4762,7 +4578,7 @@ function compareEvidence(options) {
     name: safeName(options.name),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     android: { root: androidRoot, screenshot: androidShot, layoutTokens: left.size },
-    harmony: { root: harmonyRoot, screenshot: harmonyShot, layoutTokens: right.size },
+    harmony: { root: harmonyRoot2, screenshot: harmonyShot, layoutTokens: right.size },
     screenshot: {
       sameBytes: Boolean(androidShot && harmonyShot && androidShot.sha256 === harmonyShot.sha256),
       sameDimensions: Boolean(androidShot && harmonyShot && androidShot.width === harmonyShot.width && androidShot.height === harmonyShot.height),
@@ -4771,27 +4587,27 @@ function compareEvidence(options) {
     layout: { sharedTokens: intersection.length, unionTokens: union.size, jaccard: union.size ? intersection.length / union.size : 1 },
     limitation: "This deterministic comparison checks PNG pixels when decodable plus screenshot identity/dimensions and layout-token overlap; semantic visual parity still requires image inspection."
   };
-  const output = path26.join(migrationRoot, "evidence", safeName(options.name), "comparison.json");
-  fs21.mkdirSync(path26.dirname(output), { recursive: true });
+  const output = path25.join(migrationRoot, "evidence", safeName(options.name), "comparison.json");
+  fs21.mkdirSync(path25.dirname(output), { recursive: true });
   fs21.writeFileSync(output, `${JSON.stringify(result, null, 2)}
 `, "utf8");
   return { status: "passed", output, result };
 }
 function writeFlowBundle(options) {
-  const projectRoot = path26.resolve(options.project);
+  const projectRoot = path25.resolve(options.project);
   const migrationRoot = migrationDirectory(projectRoot);
-  const output = path26.join(migrationRoot, "evidence", safeName(options.name), "flow.json");
+  const output = path25.join(migrationRoot, "evidence", safeName(options.name), "flow.json");
   const value = {
     flowVersion: "1.0.0",
     name: options.name,
     platform: options.platform,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     status: options.before.status === "passed" && options.execution.status === "passed" && options.after.status === "passed" ? "passed" : "failed",
-    before: path26.relative(migrationWorkspaceRoot(projectRoot), options.before.metadataPath).replaceAll("\\", "/"),
+    before: path25.relative(migrationWorkspaceRoot(projectRoot), options.before.metadataPath).replaceAll("\\", "/"),
     execution: options.execution,
-    after: path26.relative(migrationWorkspaceRoot(projectRoot), options.after.metadataPath).replaceAll("\\", "/")
+    after: path25.relative(migrationWorkspaceRoot(projectRoot), options.after.metadataPath).replaceAll("\\", "/")
   };
-  fs21.mkdirSync(path26.dirname(output), { recursive: true });
+  fs21.mkdirSync(path25.dirname(output), { recursive: true });
   fs21.writeFileSync(output, `${JSON.stringify(value, null, 2)}
 `, "utf8");
   return { ...value, output };
@@ -4799,7 +4615,7 @@ function writeFlowBundle(options) {
 
 // src/commands/report-update.ts
 import fs22 from "fs";
-import path27 from "path";
+import path26 from "path";
 var allowedStatuses = /* @__PURE__ */ new Set(["pending", "implemented", "verified", "blocked"]);
 function readJson3(file) {
   return JSON.parse(fs22.readFileSync(file, "utf8"));
@@ -4811,48 +4627,48 @@ function atomicJson3(file, value) {
   fs22.renameSync(temporary, file);
 }
 function readHarmonyRoot(projectRoot) {
-  const configPath = path27.join(migrationDirectory(projectRoot), "config.json");
+  const configPath = path26.join(migrationDirectory(projectRoot), "config.json");
   if (!fs22.existsSync(configPath)) return null;
   const config = readJson3(configPath);
   const harmonyProject = config?.harmonyProject;
   if (typeof harmonyProject !== "string" || !harmonyProject) return null;
-  const harmonyRoot = path27.isAbsolute(harmonyProject) ? harmonyProject : path27.resolve(projectRoot, harmonyProject);
-  return fs22.existsSync(harmonyRoot) ? harmonyRoot : null;
+  const harmonyRoot2 = path26.isAbsolute(harmonyProject) ? harmonyProject : path26.resolve(projectRoot, harmonyProject);
+  return fs22.existsSync(harmonyRoot2) ? harmonyRoot2 : null;
 }
-function insideProject(projectRoot, harmonyRoot, workspaceRoot, value, mustExist) {
-  const absolute = value.replaceAll("\\", "/").startsWith(".migration/") ? path27.resolve(workspaceRoot, value) : path27.resolve(projectRoot, value);
-  const relative2 = path27.relative(projectRoot, absolute).replaceAll("\\", "/");
-  const inProject = !!relative2 && !relative2.startsWith("../") && !path27.isAbsolute(relative2);
+function insideProject(projectRoot, harmonyRoot2, workspaceRoot, value, mustExist) {
+  const absolute = value.replaceAll("\\", "/").startsWith(".migration/") ? path26.resolve(workspaceRoot, value) : path26.resolve(projectRoot, value);
+  const relative2 = path26.relative(projectRoot, absolute).replaceAll("\\", "/");
+  const inProject = !!relative2 && !relative2.startsWith("../") && !path26.isAbsolute(relative2);
   let inHarmony = false;
-  if (!inProject && harmonyRoot) {
-    const relativeHarmony = path27.relative(harmonyRoot, absolute).replaceAll("\\", "/");
-    inHarmony = !!relativeHarmony && !relativeHarmony.startsWith("../") && !path27.isAbsolute(relativeHarmony) && !relative2.startsWith("/");
+  if (!inProject && harmonyRoot2) {
+    const relativeHarmony = path26.relative(harmonyRoot2, absolute).replaceAll("\\", "/");
+    inHarmony = !!relativeHarmony && !relativeHarmony.startsWith("../") && !path26.isAbsolute(relativeHarmony) && !relative2.startsWith("/");
   }
-  const migrationRelative = path27.relative(workspaceRoot, absolute).replaceAll("\\", "/");
-  const inMigration = !!migrationRelative && !migrationRelative.startsWith("../") && !path27.isAbsolute(migrationRelative);
+  const migrationRelative = path26.relative(workspaceRoot, absolute).replaceAll("\\", "/");
+  const inMigration = !!migrationRelative && !migrationRelative.startsWith("../") && !path26.isAbsolute(migrationRelative);
   if (!inProject && !inHarmony && !inMigration) throw new Error(`Path must be inside the project: ${value}`);
   if (mustExist && !fs22.existsSync(absolute)) throw new Error(`Referenced file not found: ${migrationRelative !== "" && inMigration ? migrationRelative : relative2}`);
   return inMigration ? migrationRelative : relative2;
 }
 function updateReportItem(options) {
   if (!options.status && options.harmonyosFiles === void 0 && options.androidSourceFiles === void 0 && options.sourceProvenance === void 0 && options.testEvidence === void 0 && options.difference === void 0) throw new Error("report update requires at least one mutable field");
-  const projectRoot = path27.resolve(options.project);
-  const harmonyRoot = readHarmonyRoot(projectRoot);
-  const reportRoot = path27.join(migrationDirectory(projectRoot), "report");
-  const indexPath = path27.join(reportRoot, "index.json");
+  const projectRoot = path26.resolve(options.project);
+  const harmonyRoot2 = readHarmonyRoot(projectRoot);
+  const reportRoot = path26.join(migrationDirectory(projectRoot), "report");
+  const indexPath = path26.join(reportRoot, "index.json");
   if (!fs22.existsSync(indexPath)) throw new Error("Migration report is not initialized");
   if (options.status && !allowedStatuses.has(options.status)) throw new Error(`Invalid report status: ${options.status}`);
   const index = readJson3(indexPath);
   const reportFile = (value) => {
-    if (typeof value !== "string" || !value.trim() || path27.isAbsolute(value)) throw new Error(`Report shard path must be report-relative: ${String(value)}`);
-    const absolute = path27.resolve(reportRoot, value);
-    const relation = path27.relative(reportRoot, absolute);
-    if (!relation || relation === ".." || relation.startsWith(`..${path27.sep}`) || path27.isAbsolute(relation)) throw new Error(`Report shard escapes report root: ${value}`);
+    if (typeof value !== "string" || !value.trim() || path26.isAbsolute(value)) throw new Error(`Report shard path must be report-relative: ${String(value)}`);
+    const absolute = path26.resolve(reportRoot, value);
+    const relation = path26.relative(reportRoot, absolute);
+    if (!relation || relation === ".." || relation.startsWith(`..${path26.sep}`) || path26.isAbsolute(relation)) throw new Error(`Report shard escapes report root: ${value}`);
     if (!fs22.existsSync(absolute) || !fs22.statSync(absolute).isFile()) throw new Error(`Report shard not found: ${value}`);
     const realRoot = fs22.realpathSync(reportRoot);
     const realFile = fs22.realpathSync(absolute);
-    const realRelation = path27.relative(realRoot, realFile);
-    if (realRelation === ".." || realRelation.startsWith(`..${path27.sep}`) || path27.isAbsolute(realRelation)) throw new Error(`Report shard resolves outside report root: ${value}`);
+    const realRelation = path26.relative(realRoot, realFile);
+    if (realRelation === ".." || realRelation.startsWith(`..${path26.sep}`) || path26.isAbsolute(realRelation)) throw new Error(`Report shard resolves outside report root: ${value}`);
     return realFile;
   };
   const candidates = [
@@ -4875,19 +4691,19 @@ function updateReportItem(options) {
   if (options.harmonyosFiles) match.item.harmonyosFiles = [...new Set(options.harmonyosFiles.map((file) => managedHarmonyFile(projectRoot, file).relative))];
   if (options.androidSourceFiles) match.item.sourceProvenance = provenanceForFiles(projectRoot, options.androidSourceFiles);
   if (options.sourceProvenance) match.item.sourceProvenance = options.sourceProvenance;
-  if (options.testEvidence) match.item.testEvidence = [...new Set(options.testEvidence.map((file) => insideProject(projectRoot, harmonyRoot, workspaceRoot, file, true)))];
+  if (options.testEvidence) match.item.testEvidence = [...new Set(options.testEvidence.map((file) => insideProject(projectRoot, harmonyRoot2, workspaceRoot, file, true)))];
   if (options.difference !== void 0) match.item.difference = options.difference?.trim() || null;
   if (["implemented", "verified"].includes(match.item.status) && !match.item.harmonyosFiles?.length) throw new Error(`${match.item.status} requires at least one HarmonyOS implementation file`);
   if (["implemented", "verified"].includes(match.item.status) && !match.item.sourceProvenance?.length) throw new Error(`${match.item.status} requires at least one Android source provenance entry`);
   if (match.item.status === "verified" && !match.item.testEvidence?.length) throw new Error("verified requires at least one test evidence file");
   if (match.item.status === "blocked" && !match.item.difference) throw new Error("blocked requires --difference");
   atomicJson3(match.file, match.document);
-  return { status: "passed", ref: options.ref, file: path27.relative(projectRoot, match.file).replaceAll("\\", "/"), item: match.item };
+  return { status: "passed", ref: options.ref, file: path26.relative(projectRoot, match.file).replaceAll("\\", "/"), item: match.item };
 }
 
 // src/commands/mock-server-generator.ts
 import fs23 from "fs";
-import path28 from "path";
+import path27 from "path";
 var requiredScenarios = ["success", "empty", "business-failure", "boundary"];
 function validateSpec(spec) {
   const errors = [];
@@ -4947,21 +4763,21 @@ const server = http.createServer(async (request, response) => {
 server.listen(port, host, () => console.log(JSON.stringify({ status: "ready", host, port })));
 `;
 function generateMockServer(options) {
-  const projectRoot = path28.resolve(options.project);
-  const specFile = path28.resolve(options.specFile);
+  const projectRoot = path27.resolve(options.project);
+  const specFile = path27.resolve(options.specFile);
   if (!fs23.existsSync(specFile)) throw new Error(`Protocol spec not found: ${specFile}`);
   const spec = JSON.parse(fs23.readFileSync(specFile, "utf8"));
   const errors = validateSpec(spec);
   if (errors.length) throw new Error(`Invalid protocol spec: ${errors.join("; ")}`);
-  const root = path28.join(projectRoot, "mock-server");
+  const root = path27.join(projectRoot, "mock-server");
   if (fs23.existsSync(root) && fs23.readdirSync(root).length && !options.force) throw new Error(`Mock server directory is not empty: ${root}; use --force to replace generated files`);
   fs23.mkdirSync(root, { recursive: true });
-  fs23.writeFileSync(path28.join(root, "scenarios.json"), `${JSON.stringify(spec, null, 2)}
+  fs23.writeFileSync(path27.join(root, "scenarios.json"), `${JSON.stringify(spec, null, 2)}
 `, "utf8");
-  fs23.writeFileSync(path28.join(root, "server.mjs"), serverSource, "utf8");
-  fs23.writeFileSync(path28.join(root, "README.md"), `# Mock Server
+  fs23.writeFileSync(path27.join(root, "server.mjs"), serverSource, "utf8");
+  fs23.writeFileSync(path27.join(root, "README.md"), `# Mock Server
 
-Generated from \`${path28.relative(projectRoot, specFile).replaceAll("\\", "/")}\`.
+Generated from \`${path27.relative(projectRoot, specFile).replaceAll("\\", "/")}\`.
 
 Start safely:
 
@@ -4976,16 +4792,16 @@ Select a scenario with query parameter \`?scenario=empty\` or header \`x-droid2h
 
 // src/commands/logs.ts
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync3 } from "fs";
-import path29 from "path";
+import path28 from "path";
 function loadRecords(projectRoot) {
-  const directory = path29.join(migrationDirectory(projectRoot), "logs", "daily");
+  const directory = path28.join(migrationDirectory(projectRoot), "logs", "daily");
   if (!existsSync7(directory)) return [];
   return readdirSync3(directory).filter((file) => file.endsWith(".jsonl")).sort().flatMap(
-    (file) => readFileSync6(path29.join(directory, file), "utf8").split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line))
+    (file) => readFileSync6(path28.join(directory, file), "utf8").split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line))
   );
 }
 function queryCommandLogs(project, action, value) {
-  const projectRoot = path29.resolve(project);
+  const projectRoot = path28.resolve(project);
   const records = loadRecords(projectRoot);
   if (action === "list") {
     const selected = value ? records.filter((record) => record.date === value) : records;
@@ -5016,7 +4832,7 @@ function queryCommandLogs(project, action, value) {
 // src/logging/command-log.ts
 import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync4, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
 import { randomUUID } from "crypto";
-import path30 from "path";
+import path29 from "path";
 var COMMAND_LOG_SCHEMA_VERSION = 1;
 var SECRET_OPTIONS = /^(--?(?:password|pass|token|secret|api[-_]?key|access[-_]?key|signing[-_]?key))$/i;
 function localDate(date) {
@@ -5056,10 +4872,10 @@ function discoverProjectRoot(argv, cwd = process.cwd()) {
       continue;
     }
     if (argument.startsWith("-") || reserved.has(argument)) continue;
-    const candidate = path30.resolve(cwd, argument);
+    const candidate = path29.resolve(cwd, argument);
     if (existsSync8(candidate)) return candidate;
   }
-  return path30.resolve(cwd);
+  return path29.resolve(cwd);
 }
 function knownArtifacts(projectRoot) {
   const candidates = [
@@ -5072,12 +4888,12 @@ function knownArtifacts(projectRoot) {
     ["managed-evidence", ".migration/evidence/index.json"]
   ];
   const workspaceRoot = migrationWorkspaceRoot(projectRoot);
-  return candidates.filter(([, relative2]) => existsSync8(path30.join(workspaceRoot, relative2))).map(([kind, relative2]) => ({ kind, path: relative2.replaceAll("\\", "/") }));
+  return candidates.filter(([, relative2]) => existsSync8(path29.join(workspaceRoot, relative2))).map(([kind, relative2]) => ({ kind, path: relative2.replaceAll("\\", "/") }));
 }
 function commandName(argv) {
-  const command3 = argv[0] ?? "unknown";
+  const command2 = argv[0] ?? "unknown";
   const grouped = /* @__PURE__ */ new Set(["analyze", "report", "build", "test", "tools", "config", "checkpoint", "device", "evidence", "mock", "service"]);
-  return grouped.has(command3) && argv[1] ? `${command3} ${argv[1]}` : command3;
+  return grouped.has(command2) && argv[1] ? `${command2} ${argv[1]}` : command2;
 }
 function atomicJson4(file, value) {
   const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
@@ -5120,18 +4936,18 @@ async function withCommandLog(argv, version, execute) {
         artifacts: knownArtifacts(projectRoot)
       };
       ensureMigrationWorkspace(projectRoot);
-      const logsRoot = path30.join(migrationWorkspaceRoot(projectRoot), ".migration", "logs");
-      const runDirectory = path30.join(logsRoot, "runs", date);
-      const dailyDirectory = path30.join(logsRoot, "daily");
+      const logsRoot = path29.join(migrationWorkspaceRoot(projectRoot), ".migration", "logs");
+      const runDirectory = path29.join(logsRoot, "runs", date);
+      const dailyDirectory = path29.join(logsRoot, "daily");
       mkdirSync4(runDirectory, { recursive: true });
       mkdirSync4(dailyDirectory, { recursive: true });
-      atomicJson4(path30.join(runDirectory, `${runId}.json`), record);
-      appendFileSync(path30.join(dailyDirectory, `${date}.jsonl`), `${JSON.stringify(record)}
+      atomicJson4(path29.join(runDirectory, `${runId}.json`), record);
+      appendFileSync(path29.join(dailyDirectory, `${date}.jsonl`), `${JSON.stringify(record)}
 `, "utf8");
-      atomicJson4(path30.join(logsRoot, "index.json"), {
+      atomicJson4(path29.join(logsRoot, "index.json"), {
         schemaVersion: COMMAND_LOG_SCHEMA_VERSION,
         lastRunId: runId,
-        lastRun: path30.relative(path30.dirname(logsRoot), path30.join(runDirectory, `${runId}.json`)).replaceAll("\\", "/"),
+        lastRun: path29.relative(path29.dirname(logsRoot), path29.join(runDirectory, `${runId}.json`)).replaceAll("\\", "/"),
         updatedAt: finished.toISOString()
       });
     } catch (logError) {
@@ -5142,30 +4958,30 @@ async function withCommandLog(argv, version, execute) {
 
 // src/runtime-paths.ts
 import fs24 from "fs";
-import path31 from "path";
+import path30 from "path";
 import { fileURLToPath } from "url";
 function resolveRuntimePaths(entryUrl) {
   const entryFile = fileURLToPath(entryUrl);
-  const directory = path31.dirname(entryFile);
-  const roots = [path31.resolve(directory, ".."), directory];
-  const packageRoot = roots.find((candidate) => fs24.existsSync(path31.join(candidate, "package.json")));
-  const runtimeRoot = packageRoot ?? path31.resolve(directory, "..");
+  const directory = path30.dirname(entryFile);
+  const roots = [path30.resolve(directory, ".."), directory];
+  const packageRoot = roots.find((candidate) => fs24.existsSync(path30.join(candidate, "package.json")));
+  const runtimeRoot = packageRoot ?? path30.resolve(directory, "..");
   const templatesRoot = [
-    packageRoot && path31.join(packageRoot, "templates")
+    packageRoot && path30.join(packageRoot, "templates")
   ].filter(Boolean).find((candidate) => fs24.existsSync(candidate));
-  const preflightChecklistPath = packageRoot && path31.join(packageRoot, "config", "preflight-checklist.json");
+  const preflightChecklistPath = packageRoot && path30.join(packageRoot, "config", "preflight-checklist.json");
   return { entryFile, runtimeRoot, packageRoot, templatesRoot, preflightChecklistPath };
 }
 
 // src/kernel/migration-kernel.ts
 import { createHash as createHash8, randomUUID as randomUUID2 } from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
-import fs28 from "fs";
+import fs29 from "fs";
 import path35 from "path";
 
 // src/planning/facts/reader.ts
 import fs25 from "fs";
-import path32 from "path";
+import path31 from "path";
 
 // src/planning/util.ts
 import { createHash as createHash7 } from "crypto";
@@ -5210,17 +5026,17 @@ function readJson4(file) {
 }
 function inside3(root, relative2, label) {
   if (typeof relative2 !== "string" || !relative2.trim()) throw new PlanningFactsError("FACTS_SHARD_MISSING", `${label} path is missing`);
-  const resolvedRoot = path32.resolve(root);
-  const absolute = path32.resolve(resolvedRoot, relative2);
-  const rel = path32.relative(resolvedRoot, absolute);
-  if (!rel || rel.startsWith(`..${path32.sep}`) || path32.isAbsolute(rel)) {
+  const resolvedRoot = path31.resolve(root);
+  const absolute = path31.resolve(resolvedRoot, relative2);
+  const rel = path31.relative(resolvedRoot, absolute);
+  if (!rel || rel.startsWith(`..${path31.sep}`) || path31.isAbsolute(rel)) {
     throw new PlanningFactsError("FACTS_PATH_OUTSIDE_ROOT", `${label} must stay inside ${resolvedRoot}: ${relative2}`);
   }
   if (!fs25.existsSync(absolute) || !fs25.statSync(absolute).isFile()) throw new PlanningFactsError("FACTS_SHARD_MISSING", `${label} not found: ${absolute}`);
   const realRoot = fs25.realpathSync(resolvedRoot);
   const realFile = fs25.realpathSync(absolute);
-  const realRelative = path32.relative(realRoot, realFile);
-  if (!realRelative || realRelative.startsWith(`..${path32.sep}`) || path32.isAbsolute(realRelative)) {
+  const realRelative = path31.relative(realRoot, realFile);
+  if (!realRelative || realRelative.startsWith(`..${path31.sep}`) || path31.isAbsolute(realRelative)) {
     throw new PlanningFactsError("FACTS_PATH_OUTSIDE_ROOT", `${label} resolves outside ${realRoot}: ${relative2}`);
   }
   return realFile;
@@ -5233,9 +5049,9 @@ function requireVersion(value, expected, label) {
   if (value !== expected) throw new PlanningFactsError("FACTS_VERSION_UNSUPPORTED", `${label} must be ${expected}; found ${value ?? "<missing>"}`);
 }
 function readFactsBundleV2(project) {
-  const projectRoot = path32.resolve(project);
-  const specRoot = path32.join(migrationDirectory(projectRoot), "spec");
-  const indexFile = path32.join(specRoot, "index.json");
+  const projectRoot = path31.resolve(project);
+  const specRoot = path31.join(migrationDirectory(projectRoot), "spec");
+  const indexFile = path31.join(specRoot, "index.json");
   if (!fs25.existsSync(indexFile)) throw new PlanningFactsError("FACTS_SHARD_MISSING", `SPEC index not found: ${indexFile}`);
   const index = readJson4(indexFile);
   requireVersion(index.specVersion, "2.0.0", "SPEC specVersion");
@@ -5303,17 +5119,30 @@ function readFactsBundleV2(project) {
 }
 
 // src/planning/types.ts
-var TASK_PLAN_VERSION = "1.0.0";
-var TASK_ENVELOPE_VERSION = "1.0.0";
-var PLANNING_MODEL_VERSION = "1.0.0";
+var TASK_PLAN_VERSION = "2.3.0";
+var TASK_ENVELOPE_VERSION = "3.0.0";
+var BEHAVIOR_PLAN_VERSION = "1.0.0";
+var EXECUTION_PLAN_VERSION = "1.3.0";
+var PLANNING_MODEL_VERSION = "2.0.0";
 var FACTS_ADAPTER_VERSION = "1.0.0";
-var PLANNER_POLICY_VERSION = "1.1.0";
+var PLANNER_POLICY_VERSION = "2.3.0";
 var DEFAULT_CLOSURE_BUDGET = {
   maxFactCount: 30,
   maxSourceFileCount: 15,
   maxTraceNodeCount: 50,
   maxEstimatedFactTokens: 12e3
 };
+var DEFAULT_EXECUTION_BUDGET = {
+  maxBehaviorCount: 5,
+  maxObservableOutcomeCount: 3,
+  maxProductionFileCount: 4,
+  maxTestFileCount: 2,
+  maxCapabilityCount: 2,
+  maxFactCount: 45,
+  maxSourceFileCount: 8,
+  maxTraceNodeCount: 60,
+  maxEstimatedFactTokens: 14e3
+};
 
 // src/planning/facts/v2-adapter.ts
 function evidence(values) {
@@ -5617,7 +5446,8 @@ function candidateForEntry(entryId, facts) {
     ...effects.flatMap((effect) => [effect.id, effect.targetId])
   ]));
   const issues = facts.issues.filter((issue) => issue.relatedRefs.some((ref) => related.has(ref)));
-  const blocking = issues.some((issue) => issue.blocking && !issue.resolved);
+  const unresolvedIssues = issues.filter((issue) => issue.blocking && !issue.resolved);
+  const blocking = unresolvedIssues.length > 0;
   const isLaunch = facts.app.launcherEntryIds.includes(entry.id) || entry.triggerCategory === "application" && entry.event === "launch";
   const type = blocking ? "resolution" : (() => {
     if (isLaunch) return "bootstrap";
@@ -5650,7 +5480,7 @@ function candidateForEntry(entryId, facts) {
     surfaceRefs: new Set(surfaces),
     controlRefs: new Set(controls.map((control) => control.id)),
     interactionRefs: new Set(effects.map((effect) => effect.id)),
-    issueRefs: new Set(issues.map((issue) => issue.id)),
+    issueRefs: new Set(unresolvedIssues.map((issue) => issue.id)),
     warningRefs: new Set(warningRefs),
     sourceSurfaceRefs: new Set(entry.ownerSurfaceId ? [entry.ownerSurfaceId] : []),
     targetEdges: effects.flatMap((effect) => targetSurfaceIds(effect, facts).map((targetSurfaceRef) => ({ sourceSurfaceRef: entry.ownerSurfaceId, targetSurfaceRef, effectRef: effect.id }))),
@@ -5658,7 +5488,7 @@ function candidateForEntry(entryId, facts) {
       ...entry.evidence,
       ...controls.flatMap((control) => control.evidence),
       ...effects.flatMap((effect) => effect.evidence),
-      ...issues.flatMap((issue) => issue.evidence)
+      ...unresolvedIssues.flatMap((issue) => issue.evidence)
     ], evidenceKey),
     codeRefs: entry.trace.codeRefs,
     requiresSourceReview: effects.length === 0 || blocking || entry.trace.warnings.length > 0,
@@ -5954,8 +5784,8 @@ function chooseSurfaceOwners(candidates, facts) {
 function reportableRefs(facts) {
   return new Set(facts.requiredFactRefs);
 }
-function taskIdFor(candidate) {
-  return `task:${sha2562({
+function behaviorIdFor(candidate) {
+  return `behavior:${sha2562({
     type: candidate.type,
     primaryFactRefs: uniqueSorted(candidate.primary),
     path: {
@@ -5967,7 +5797,7 @@ function taskIdFor(candidate) {
 }
 function downstreamCounts(tasks) {
   const children = /* @__PURE__ */ new Map();
-  for (const task of tasks) for (const dependency of task.dependsOnTaskIds) children.set(dependency, [...children.get(dependency) ?? [], task.id]);
+  for (const task of tasks) for (const dependency of task.dependsOnBehaviorIds) children.set(dependency, [...children.get(dependency) ?? [], task.id]);
   const out = /* @__PURE__ */ new Map();
   for (const task of tasks) {
     const seen = /* @__PURE__ */ new Set();
@@ -5982,7 +5812,7 @@ function downstreamCounts(tasks) {
   }
   return out;
 }
-function compileFromPlanningFacts(facts, androidFingerprint) {
+function compileBehaviorPlanFromPlanningFacts(facts, androidFingerprint) {
   let candidates = mergeCompatibleEntryCandidates(facts.entries.map((entry) => candidateForEntry(entry.id, facts)), facts);
   for (const surfaceRef of facts.app.launcherSurfaceIds) {
     if (!candidates.some((candidate) => candidate.type === "bootstrap" && candidate.surfaceRefs.has(surfaceRef))) {
@@ -6036,8 +5866,8 @@ function compileFromPlanningFacts(facts, androidFingerprint) {
     const closureRefs = /* @__PURE__ */ new Set([...candidate.entryRefs, ...candidate.surfaceRefs, ...candidate.controlRefs, ...candidate.interactionRefs, ...candidate.issueRefs]);
     candidate.supporting = new Set([...closureRefs].filter((ref) => !candidate.primary.has(ref)));
   }
-  const idByKey = new Map(candidates.map((candidate) => [candidate.key, taskIdFor(candidate)]));
-  if (new Set(idByKey.values()).size !== candidates.length) throw new Error("Task ID collision while compiling plan");
+  const idByKey = new Map(candidates.map((candidate) => [candidate.key, behaviorIdFor(candidate)]));
+  if (new Set(idByKey.values()).size !== candidates.length) throw new Error("Behavior ID collision while compiling plan");
   const launcherResolvers = candidates.filter((candidate) => candidate.type === "resolution" && candidate.issueRefs.has("issue:launcher-unresolved"));
   const taskDrafts = candidates.map((candidate) => {
     const dependencies = /* @__PURE__ */ new Set();
@@ -6049,11 +5879,11 @@ function compileFromPlanningFacts(facts, androidFingerprint) {
       }
       if (facts.app.launcherOrigin === "unresolved") for (const resolver of launcherResolvers) dependencies.add(idByKey.get(resolver.key));
     }
-    return { candidate, id: idByKey.get(candidate.key), dependsOnTaskIds: uniqueSorted(dependencies) };
+    return { candidate, id: idByKey.get(candidate.key), dependsOnBehaviorIds: uniqueSorted(dependencies) };
   });
   const downstream = downstreamCounts(taskDrafts);
   const reportable = reportableRefs(facts);
-  const tasks = taskDrafts.map(({ candidate, id, dependsOnTaskIds }) => {
+  const responsibilities = taskDrafts.map(({ candidate, id, dependsOnBehaviorIds }) => {
     const primaryFactRefs = uniqueSorted(candidate.primary);
     const supportingFactRefs = uniqueSorted(candidate.supporting);
     const core = {
@@ -6070,7 +5900,7 @@ function compileFromPlanningFacts(facts, androidFingerprint) {
       title: candidate.title,
       primaryFactRefs,
       supportingFactRefs,
-      dependsOnTaskIds,
+      dependsOnBehaviorIds,
       closure: {
         entryRefs: core.entries,
         surfaceRefs: core.surfaces,
@@ -6098,12 +5928,12 @@ function compileFromPlanningFacts(facts, androidFingerprint) {
     };
   }).sort((a, b) => typeOrder[a.type] - typeOrder[b.type] || a.id.localeCompare(b.id));
   const primaryOwnerByFactRef = Object.fromEntries([...ownerKeyByFactRef.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([ref, key]) => [ref, idByKey.get(key)]));
-  const supportingTaskIdsByFactRef = {};
-  for (const task of tasks) for (const ref of task.supportingFactRefs) supportingTaskIdsByFactRef[ref] = uniqueSorted([...supportingTaskIdsByFactRef[ref] ?? [], task.id]);
+  const supportingBehaviorIdsByFactRef = {};
+  for (const responsibility of responsibilities) for (const ref of responsibility.supportingFactRefs) supportingBehaviorIdsByFactRef[ref] = uniqueSorted([...supportingBehaviorIdsByFactRef[ref] ?? [], responsibility.id]);
   const planningWarnings = [...facts.diagnostics];
-  for (const task of tasks.filter((item) => item.closure.requiresSourceReview && item.type !== "resolution")) planningWarnings.push({ code: "SOURCE_REVIEW_REQUIRED", message: `${task.id} has no direct observable interaction and requires Android source review`, relatedRefs: task.closure.entryRefs });
+  for (const responsibility of responsibilities.filter((item) => item.closure.requiresSourceReview && item.type !== "resolution")) planningWarnings.push({ code: "SOURCE_REVIEW_REQUIRED", message: `${responsibility.id} has no direct observable interaction and requires Android source review`, relatedRefs: responsibility.closure.entryRefs });
   return {
-    taskPlanVersion: TASK_PLAN_VERSION,
+    behaviorPlanVersion: BEHAVIOR_PLAN_VERSION,
     planningModelVersion: PLANNING_MODEL_VERSION,
     factsAdapterVersion: FACTS_ADAPTER_VERSION,
     plannerPolicyVersion: PLANNER_POLICY_VERSION,
@@ -6119,22 +5949,716 @@ function compileFromPlanningFacts(facts, androidFingerprint) {
       launcherEntryRefs: facts.app.launcherEntryIds,
       origin: facts.app.launcherOrigin
     },
-    tasks,
-    ownership: { primaryOwnerByFactRef, supportingTaskIdsByFactRef: Object.fromEntries(Object.entries(supportingTaskIdsByFactRef).sort(([a], [b]) => a.localeCompare(b))) },
+    responsibilities,
+    ownership: { primaryOwnerByFactRef, supportingBehaviorIdsByFactRef: Object.fromEntries(Object.entries(supportingBehaviorIdsByFactRef).sort(([a], [b]) => a.localeCompare(b))) },
     planningWarnings: uniqueBy(planningWarnings, (item) => `${item.code}:${item.message}:${item.relatedRefs.join(",")}`)
   };
 }
 
-// src/planning/storage.ts
+// src/planning/execution-context.ts
 import fs26 from "fs";
+import path32 from "path";
+function readJson6(file) {
+  try {
+    return JSON.parse(fs26.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function inside4(root, target) {
+  const relative2 = path32.relative(root, target);
+  return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${path32.sep}`) && !path32.isAbsolute(relative2);
+}
+function validatedHarmonyFile(projectRoot, root, value) {
+  if (typeof value !== "string" || !value.trim()) throw new Error("Report HarmonyOS mapping must be a non-empty string");
+  const absolute = path32.resolve(projectRoot, value);
+  if (!inside4(root, absolute)) throw new Error(`Report HarmonyOS mapping escapes the configured project: ${value}`);
+  if (!fs26.existsSync(absolute) || !fs26.statSync(absolute).isFile()) throw new Error(`Report HarmonyOS mapping does not exist: ${value}`);
+  const realRoot = fs26.realpathSync(root);
+  const realFile = fs26.realpathSync(absolute);
+  if (!inside4(realRoot, realFile)) throw new Error(`Report HarmonyOS mapping resolves outside the configured project: ${value}`);
+  return path32.relative(projectRoot, absolute).replaceAll("\\", "/");
+}
+function confinedReportFile(reportRoot, relative2) {
+  if (!relative2.trim() || path32.isAbsolute(relative2)) throw new Error(`Report shard path must be relative: ${relative2}`);
+  const absolute = path32.resolve(reportRoot, relative2);
+  if (!inside4(reportRoot, absolute) || absolute === reportRoot) throw new Error(`Report shard escapes report root: ${relative2}`);
+  if (!fs26.existsSync(absolute) || !fs26.statSync(absolute).isFile()) throw new Error(`Report shard does not exist: ${relative2}`);
+  const realRoot = fs26.realpathSync(reportRoot);
+  const realFile = fs26.realpathSync(absolute);
+  if (!inside4(realRoot, realFile)) throw new Error(`Report shard resolves outside report root: ${relative2}`);
+  return realFile;
+}
+function reportHarmonyFiles(projectRoot, root) {
+  const reportRoot = path32.join(migrationDirectory(projectRoot), "report");
+  const index = readJson6(path32.join(reportRoot, "index.json"));
+  if (!index) return {};
+  const shardFiles = [
+    ...(index.pages ?? []).map((item) => item.file),
+    index.unassignedEntriesFile,
+    index.interactionsFile,
+    index.discoveriesFile
+  ].filter((value) => typeof value === "string");
+  const result = {};
+  for (const relative2 of shardFiles) {
+    const document = readJson6(confinedReportFile(reportRoot, relative2));
+    if (!document) continue;
+    const items = [
+      document.page,
+      ...document.controls ?? [],
+      ...document.entries ?? [],
+      ...document.interactions ?? [],
+      ...document.items ?? []
+    ].filter(Boolean);
+    for (const item of items) {
+      if (typeof item.ref !== "string" || !Array.isArray(item.harmonyosFiles)) continue;
+      result[item.ref] = uniqueSorted(item.harmonyosFiles.map((value) => validatedHarmonyFile(projectRoot, root, value)));
+    }
+  }
+  return Object.fromEntries(Object.entries(result).sort(([left], [right]) => left.localeCompare(right)));
+}
+function harmonyRoot(projectRoot) {
+  const config = readJson6(path32.join(migrationDirectory(projectRoot), "config.json"));
+  const configured = typeof config?.harmonyProject === "string" ? config.harmonyProject : "ohos";
+  return path32.isAbsolute(configured) ? configured : path32.resolve(projectRoot, configured);
+}
+function existingGlobalHotspots(projectRoot) {
+  const root = harmonyRoot(projectRoot);
+  if (!fs26.existsSync(root) || !fs26.statSync(root).isDirectory()) return [];
+  const relativeRoot = path32.relative(projectRoot, root).replaceAll("\\", "/");
+  const candidates = [
+    "build-profile.json5",
+    "AppScope/app.json5",
+    "oh-package.json5",
+    "entry/oh-package.json5",
+    "entry/src/main/module.json5",
+    "entry/src/main/resources/base/profile/main_pages.json",
+    "entry/src/main/ets/entryability/EntryAbility.ets",
+    "entry/src/main/ets/pages/Index.ets",
+    "entry/src/main/ets/common/RouteConstants.ets"
+  ];
+  return candidates.filter((relative2) => fs26.existsSync(path32.join(root, relative2))).map((relative2) => `${relativeRoot}/${relative2}`.replace(/^\.\//, "")).sort();
+}
+function loadExecutionPlanningContext(projectRootArgument) {
+  const projectRoot = path32.resolve(projectRootArgument);
+  const root = harmonyRoot(projectRoot);
+  const rootAvailable = fs26.existsSync(root) && fs26.statSync(root).isDirectory();
+  return {
+    harmonyFilesByFactRef: rootAvailable ? reportHarmonyFiles(projectRoot, root) : {},
+    globalHotspotFiles: existingGlobalHotspots(projectRoot)
+  };
+}
+var emptyExecutionPlanningContext = {
+  harmonyFilesByFactRef: {},
+  globalHotspotFiles: []
+};
+
+// src/planning/execution-planner.ts
+var typeOrder2 = {
+  resolution: 0,
+  bootstrap: 1,
+  capability: 2,
+  journey: 3,
+  assembly: 4,
+  regression: 5
+};
+function isReusableSurface(kind) {
+  return /(?:list[-_ ]?item|item|reusable|layout|custom[-_ ]?view|cell|row)/i.test(kind);
+}
+function isHostedOverlay(kind) {
+  return /(?:dialog|bottom[-_ ]?sheet|sheet|popup|overlay)/i.test(kind);
+}
+function canonicalPageRefs(facts) {
+  const byId = new Map(facts.surfaces.map((surface) => [surface.id, surface]));
+  const memo = /* @__PURE__ */ new Map();
+  const resolve4 = (surfaceRef, visiting = /* @__PURE__ */ new Set()) => {
+    if (memo.has(surfaceRef)) return memo.get(surfaceRef);
+    const surface = byId.get(surfaceRef);
+    if (!surface || visiting.has(surfaceRef)) return surfaceRef;
+    visiting.add(surfaceRef);
+    const parentPages = uniqueSorted(surface.parentSurfaceIds.filter((ref) => byId.has(ref)).map((ref) => resolve4(ref, visiting)));
+    const canonical2 = parentPages.length === 1 && (isReusableSurface(surface.kind) || isHostedOverlay(surface.kind) || !surface.topLevel) ? parentPages[0] : surfaceRef;
+    visiting.delete(surfaceRef);
+    memo.set(surfaceRef, canonical2);
+    return canonical2;
+  };
+  for (const surface of facts.surfaces) resolve4(surface.id);
+  return Object.fromEntries([...memo.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+function behaviorSourceSurfaceRefs(behavior, facts) {
+  const entryRefs = new Set(behavior.closure.entryRefs);
+  const fromEntries = facts.entries.filter((entry) => entryRefs.has(entry.id) && entry.ownerSurfaceId).map((entry) => entry.ownerSurfaceId);
+  if (fromEntries.length) return uniqueSorted(fromEntries);
+  const primarySurfaces = behavior.primaryFactRefs.filter((ref) => facts.surfaces.some((surface) => surface.id === ref));
+  return uniqueSorted(primarySurfaces.length ? primarySurfaces : behavior.closure.surfaceRefs);
+}
+function behaviorCanonicalPage(behavior, facts, canonicalBySurface) {
+  const pages = uniqueSorted(behaviorSourceSurfaceRefs(behavior, facts).map((ref) => canonicalBySurface[ref] ?? ref));
+  return pages[0] ?? null;
+}
+function codeRefKey(value) {
+  if (typeof value.id === "string") return value.id;
+  return stableJson(Object.fromEntries(["file", "name", "symbol", "kind", "type", "capabilityRef"].filter((key) => value[key] !== void 0).map((key) => [key, value[key]])));
+}
+function behaviorCapabilityRefs(behavior) {
+  return uniqueSorted(behavior.closure.codeRefs.flatMap((item) => {
+    if (typeof item.capabilityRef === "string" && item.capabilityRef.length > 0) return [item.capabilityRef];
+    if (item.kind === "capability" && typeof item.id === "string" && item.id.length > 0) return [item.id];
+    return [];
+  }));
+}
+function candidateForBehavior(behavior, facts, canonicalBySurface) {
+  const effectRefs = new Set(behavior.closure.interactionRefs);
+  const targets = facts.effects.filter((effect) => effectRefs.has(effect.id) && effect.targetKind === "surface").map((effect) => canonicalBySurface[effect.targetId] ?? effect.targetId);
+  return {
+    behaviorIds: [behavior.id],
+    canonicalPageRef: behaviorCanonicalPage(behavior, facts, canonicalBySurface),
+    type: behavior.type,
+    sourceFiles: uniqueSorted([
+      ...behavior.closure.sourceEvidence.map((item) => item.file),
+      ...behavior.closure.codeRefs.flatMap((item) => typeof item.file === "string" ? [item.file] : [])
+    ]),
+    targetPageRefs: uniqueSorted(targets),
+    codeRefKeys: uniqueSorted(behavior.closure.codeRefs.map(codeRefKey)),
+    capabilityRefs: behaviorCapabilityRefs(behavior)
+  };
+}
+function combineCandidates2(left, right) {
+  return {
+    behaviorIds: uniqueSorted([...left.behaviorIds, ...right.behaviorIds]),
+    canonicalPageRef: left.canonicalPageRef,
+    type: left.type,
+    sourceFiles: uniqueSorted([...left.sourceFiles, ...right.sourceFiles]),
+    targetPageRefs: uniqueSorted([...left.targetPageRefs, ...right.targetPageRefs]),
+    codeRefKeys: uniqueSorted([...left.codeRefKeys, ...right.codeRefKeys]),
+    capabilityRefs: uniqueSorted([...left.capabilityRefs, ...right.capabilityRefs])
+  };
+}
+function intersects(left, right) {
+  const values = new Set(left);
+  return right.some((value) => values.has(value));
+}
+function behaviorRefs(candidate, behaviors) {
+  return candidate.behaviorIds.map((id) => behaviors.get(id)).filter(Boolean);
+}
+function isRoutingAssembly(candidate) {
+  return candidate.type === "journey" && candidate.targetPageRefs.some((target) => target !== candidate.canonicalPageRef);
+}
+function routingHotspotFiles(context) {
+  return context.globalHotspotFiles.filter((file) => /(?:main_pages\.json|RouteConstants\.ets|\/pages\/Index\.ets)$/i.test(file));
+}
+function mappedTargetFiles(candidate, primaryRefs, context) {
+  const mapped = uniqueSorted(primaryRefs.flatMap((ref) => context.harmonyFilesByFactRef[ref] ?? []));
+  if (candidate.type === "bootstrap") return uniqueSorted([...mapped, ...context.globalHotspotFiles]);
+  if (isRoutingAssembly(candidate)) return uniqueSorted([...mapped, ...routingHotspotFiles(context)]);
+  return mapped;
+}
+function executionCost(candidate, behaviors, context) {
+  const members = behaviorRefs(candidate, behaviors);
+  const factRefs = uniqueSorted(members.flatMap((item) => [...item.primaryFactRefs, ...item.supportingFactRefs]));
+  const mappedFiles = mappedTargetFiles(candidate, factRefs, context);
+  const productionFiles = mappedFiles.filter((file) => !/(?:^|\/)(?:ohosTest|test|tests)(?:\/|$)|(?:Test|\.test)\.(?:ets|ts)$/i.test(file));
+  const testFiles = mappedFiles.filter((file) => !productionFiles.includes(file));
+  return {
+    behaviorCount: members.length,
+    observableOutcomeCount: uniqueSorted(members.map((item) => item.acceptance.observableOutcome)).length,
+    productionFileCount: productionFiles.length,
+    testFileCount: testFiles.length,
+    capabilityCount: candidate.capabilityRefs.length,
+    factCount: new Set(members.flatMap((item) => [...item.primaryFactRefs, ...item.supportingFactRefs])).size,
+    sourceFileCount: uniqueSorted(members.flatMap((item) => [
+      ...item.closure.sourceEvidence.map((evidence2) => evidence2.file),
+      ...item.closure.codeRefs.flatMap((codeRef) => typeof codeRef.file === "string" ? [codeRef.file] : [])
+    ])).length,
+    traceNodeCount: uniqueBy(members.flatMap((item) => item.closure.codeRefs), codeRefKey).length,
+    estimatedFactTokens: members.reduce((total, item) => total + item.estimate.estimatedFactTokens, 0)
+  };
+}
+function withinExecutionBudget(candidate, behaviors, context) {
+  const cost = executionCost(candidate, behaviors, context);
+  return cost.behaviorCount <= DEFAULT_EXECUTION_BUDGET.maxBehaviorCount && cost.observableOutcomeCount <= DEFAULT_EXECUTION_BUDGET.maxObservableOutcomeCount && cost.productionFileCount <= DEFAULT_EXECUTION_BUDGET.maxProductionFileCount && cost.testFileCount <= DEFAULT_EXECUTION_BUDGET.maxTestFileCount && cost.capabilityCount <= DEFAULT_EXECUTION_BUDGET.maxCapabilityCount && cost.factCount <= DEFAULT_EXECUTION_BUDGET.maxFactCount && cost.sourceFileCount <= DEFAULT_EXECUTION_BUDGET.maxSourceFileCount && cost.traceNodeCount <= DEFAULT_EXECUTION_BUDGET.maxTraceNodeCount && cost.estimatedFactTokens <= DEFAULT_EXECUTION_BUDGET.maxEstimatedFactTokens;
+}
+function shouldMerge(left, right, behaviors, facts, context) {
+  if (left.type !== "journey" || right.type !== "journey" || left.canonicalPageRef !== right.canonicalPageRef) return false;
+  const members = [...behaviorRefs(left, behaviors), ...behaviorRefs(right, behaviors)];
+  if (members.some((item) => item.closure.requiresSourceReview || item.closure.unresolvedRefs.length > 0)) return false;
+  const combined = combineCandidates2(left, right);
+  if (!withinExecutionBudget(combined, behaviors, context)) return false;
+  const behaviorEntries = (candidate) => uniqueSorted(behaviorRefs(candidate, behaviors).flatMap((item) => item.closure.entryRefs));
+  const targetedEntries = (candidate) => {
+    const effects = new Set(behaviorRefs(candidate, behaviors).flatMap((item) => item.closure.interactionRefs));
+    return uniqueSorted([...effects].flatMap((effectRef) => {
+      const effect = facts.effects.find((item) => item.id === effectRef);
+      return effect?.targetKind === "entry" ? [effect.targetId] : [];
+    }));
+  };
+  const callbackLinked = intersects(targetedEntries(left), behaviorEntries(right)) || intersects(targetedEntries(right), behaviorEntries(left));
+  if (callbackLinked || intersects(left.codeRefKeys, right.codeRefKeys)) return true;
+  const sharedSource = intersects(left.sourceFiles, right.sourceFiles);
+  const sharedTarget = left.targetPageRefs.length > 0 && right.targetPageRefs.length > 0 && intersects(left.targetPageRefs, right.targetPageRefs);
+  const sharedCapability = intersects(left.capabilityRefs, right.capabilityRefs);
+  return sharedSource && (sharedTarget || sharedCapability);
+}
+function clusterBehaviors(plan, facts, context) {
+  const behaviors = new Map(plan.responsibilities.map((item) => [item.id, item]));
+  const canonicalBySurface = canonicalPageRefs(facts);
+  const clusters = [];
+  for (const next of plan.responsibilities.map((item) => candidateForBehavior(item, facts, canonicalBySurface))) {
+    const compatible = clusters.findIndex((current) => shouldMerge(current, next, behaviors, facts, context));
+    if (compatible < 0) clusters.push(next);
+    else clusters[compatible] = combineCandidates2(clusters[compatible], next);
+  }
+  return clusters;
+}
+function workPackageId(candidate) {
+  if (candidate.type === "resolution") return null;
+  return `package:${sha2562({ kind: "page", page: candidate.canonicalPageRef ?? "unassigned" }).slice(0, 16)}`;
+}
+function taskId(candidate) {
+  return `task:${sha2562({ page: candidate.canonicalPageRef, type: candidate.type, behaviorIds: candidate.behaviorIds }).slice(0, 16)}`;
+}
+function taskTitle(candidate, members, facts) {
+  if (members.length === 1) return members[0].title;
+  const pageName = facts.surfaces.find((surface) => surface.id === candidate.canonicalPageRef)?.name ?? candidate.canonicalPageRef ?? "\u672A\u5F52\u5C5E\u6A21\u5757";
+  return `${pageName}\uFF1A\u5B8C\u6210 ${members.length} \u4E2A\u76F8\u5173\u884C\u4E3A\u95ED\u73AF`;
+}
+function aggregateClosure(members) {
+  return {
+    entryRefs: uniqueSorted(members.flatMap((item) => item.closure.entryRefs)),
+    surfaceRefs: uniqueSorted(members.flatMap((item) => item.closure.surfaceRefs)),
+    controlRefs: uniqueSorted(members.flatMap((item) => item.closure.controlRefs)),
+    interactionRefs: uniqueSorted(members.flatMap((item) => item.closure.interactionRefs)),
+    sourceEvidence: uniqueBy(members.flatMap((item) => item.closure.sourceEvidence), (item) => `${item.file}:${item.symbol ?? ""}:${item.line ?? ""}:${item.endLine ?? ""}`),
+    codeRefs: uniqueBy(members.flatMap((item) => item.closure.codeRefs), codeRefKey),
+    unresolvedRefs: uniqueSorted(members.flatMap((item) => item.closure.unresolvedRefs)),
+    warningRefs: uniqueSorted(members.flatMap((item) => item.closure.warningRefs)),
+    requiresSourceReview: members.some((item) => item.closure.requiresSourceReview)
+  };
+}
+function primaryModule(candidate) {
+  if (candidate.type === "bootstrap") return "foundation:application-shell";
+  if (candidate.type === "resolution") return `resolution:${candidate.behaviorIds[0]}`;
+  if (isRoutingAssembly(candidate)) return "assembly:routing";
+  return candidate.canonicalPageRef ? `page:${candidate.canonicalPageRef}` : "page:unassigned";
+}
+function initialTasks(clusters, behaviorPlan, facts, canonicalBySurface, context) {
+  const behaviors = new Map(behaviorPlan.responsibilities.map((item) => [item.id, item]));
+  return clusters.map((candidate) => {
+    const members = behaviorRefs(candidate, behaviors);
+    const primaryFactRefs = uniqueSorted(members.flatMap((item2) => item2.primaryFactRefs));
+    const supportingFactRefs = uniqueSorted(members.flatMap((item2) => item2.supportingFactRefs).filter((ref) => !primaryFactRefs.includes(ref)));
+    const mappedFiles = mappedTargetFiles(candidate, [...primaryFactRefs, ...supportingFactRefs], context);
+    let ownedFiles;
+    if (candidate.type === "resolution") ownedFiles = [];
+    else if (candidate.type === "bootstrap") ownedFiles = mappedFiles;
+    else ownedFiles = mappedFiles.filter((file) => isRoutingAssembly(candidate) || !context.globalHotspotFiles.includes(file));
+    const cost = executionCost(candidate, behaviors, context);
+    const outcomes = uniqueSorted(members.map((item2) => item2.acceptance.observableOutcome));
+    const closure = aggregateClosure(members);
+    const pageScopes = uniqueSorted(closure.surfaceRefs.map((surfaceRef) => `page:${canonicalBySurface[surfaceRef] ?? surfaceRef}`));
+    const exclusiveScopes = candidate.type === "resolution" ? [`resolution:${candidate.behaviorIds[0]}`] : uniqueSorted([
+      ...candidate.type === "bootstrap" ? ["foundation:application-shell"] : [],
+      ...isRoutingAssembly(candidate) ? ["assembly:routing"] : [],
+      ...pageScopes,
+      ...pageScopes.length === 0 ? [candidate.canonicalPageRef ? `page:${candidate.canonicalPageRef}` : `${candidate.type}:unassigned`] : []
+    ]);
+    const item = {
+      id: taskId(candidate),
+      type: candidate.type,
+      title: taskTitle(candidate, members, facts),
+      workPackageId: workPackageId(candidate),
+      canonicalPageRef: candidate.canonicalPageRef,
+      primaryModule: primaryModule(candidate),
+      behaviorIds: candidate.behaviorIds,
+      primaryFactRefs,
+      supportingFactRefs,
+      dependsOnTaskIds: [],
+      conflictsWithTaskIds: [],
+      writeOwnership: {
+        ownedFiles,
+        readOnlyFiles: [],
+        exclusiveScopes,
+        forbiddenGlobalFiles: candidate.type === "bootstrap" ? [] : context.globalHotspotFiles.filter((file) => !ownedFiles.includes(file))
+      },
+      dependencyInterfaces: [],
+      readyGate: {
+        semanticsResolved: candidate.type === "resolution" || closure.unresolvedRefs.length === 0,
+        dependencyInterfacesStable: true,
+        writeOwnershipResolved: ownedFiles.length > 0 || exclusiveScopes.length > 0,
+        contextWithinBudget: members.length === 1 || withinExecutionBudget(candidate, behaviors, context),
+        acceptanceExecutable: members.every((member) => member.acceptance.verificationRequirements.length > 0)
+      },
+      closure,
+      acceptance: {
+        observableOutcome: outcomes.join("\uFF1B"),
+        observableOutcomes: outcomes,
+        requiredFactRefs: uniqueSorted(members.flatMap((item2) => item2.acceptance.requiredFactRefs)),
+        verificationRequirements: uniqueSorted(members.flatMap((item2) => item2.acceptance.verificationRequirements)),
+        reportRefs: uniqueSorted(members.flatMap((item2) => item2.acceptance.reportRefs))
+      },
+      estimate: {
+        factCount: cost.factCount,
+        sourceFileCount: cost.sourceFileCount,
+        traceNodeCount: cost.traceNodeCount,
+        estimatedFactTokens: cost.estimatedFactTokens,
+        downstreamUnlockCount: 0,
+        behaviorCount: cost.behaviorCount,
+        observableOutcomeCount: cost.observableOutcomeCount,
+        productionFileCount: cost.productionFileCount,
+        testFileCount: cost.testFileCount,
+        capabilityCount: cost.capabilityCount
+      }
+    };
+    return item;
+  }).sort((left, right) => typeOrder2[left.type] - typeOrder2[right.type] || left.id.localeCompare(right.id));
+}
+function hasPath(tasks, from, to) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...tasks.get(from)?.dependsOnTaskIds ?? []];
+  while (queue.length) {
+    const next = queue.shift();
+    if (next === to) return true;
+    if (seen.has(next)) continue;
+    seen.add(next);
+    queue.push(...tasks.get(next)?.dependsOnTaskIds ?? []);
+  }
+  return false;
+}
+function addDependency(tasks, taskId2, dependencyId) {
+  if (taskId2 === dependencyId || hasPath(tasks, dependencyId, taskId2)) return;
+  const task = tasks.get(taskId2);
+  task.dependsOnTaskIds = uniqueSorted([...task.dependsOnTaskIds, dependencyId]);
+}
+function orderPackageLane(items) {
+  const ids = new Set(items.map((item) => item.id));
+  const remaining = new Set(ids);
+  const result = [];
+  while (remaining.size) {
+    const ready = items.filter((item) => remaining.has(item.id) && item.dependsOnTaskIds.filter((dependency) => ids.has(dependency)).every((dependency) => !remaining.has(dependency))).sort((left, right) => typeOrder2[left.type] - typeOrder2[right.type] || left.id.localeCompare(right.id));
+    const selected = ready[0] ?? items.filter((item) => remaining.has(item.id)).sort((left, right) => left.id.localeCompare(right.id))[0];
+    result.push(selected);
+    remaining.delete(selected.id);
+  }
+  return result;
+}
+function packageSerializationRanks(tasks) {
+  const packageIds = uniqueSorted(tasks.flatMap((task) => task.workPackageId ? [task.workPackageId] : []));
+  const taskById = new Map(tasks.map((task) => [task.id, task]));
+  const dependencies = new Map(packageIds.map((packageId) => [packageId, /* @__PURE__ */ new Set()]));
+  for (const task of tasks) {
+    if (!task.workPackageId) continue;
+    for (const dependencyId of task.dependsOnTaskIds) {
+      const dependencyPackageId = taskById.get(dependencyId)?.workPackageId;
+      if (dependencyPackageId && dependencyPackageId !== task.workPackageId) dependencies.get(task.workPackageId).add(dependencyPackageId);
+    }
+  }
+  const remaining = new Set(packageIds);
+  const ranks = /* @__PURE__ */ new Map();
+  while (remaining.size) {
+    const ready = packageIds.filter((packageId) => remaining.has(packageId) && [...dependencies.get(packageId)].every((dependencyId) => !remaining.has(dependencyId)));
+    const selected = ready[0] ?? packageIds.find((packageId) => remaining.has(packageId));
+    ranks.set(selected, ranks.size);
+    remaining.delete(selected);
+  }
+  return ranks;
+}
+function conflictReasons(left, right) {
+  const ownedOverlap = left.writeOwnership.ownedFiles.filter((file) => right.writeOwnership.ownedFiles.includes(file)).map((file) => `owned-file:${file}`);
+  const scopeOverlap = left.writeOwnership.exclusiveScopes.filter((scope) => right.writeOwnership.exclusiveScopes.includes(scope)).map((scope) => `exclusive-scope:${scope}`);
+  return uniqueSorted([...ownedOverlap, ...scopeOverlap]);
+}
+function wireDependenciesAndConflicts(tasks, behaviorPlan) {
+  const byId = new Map(tasks.map((item) => [item.id, item]));
+  const taskByBehavior = new Map(tasks.flatMap((item) => item.behaviorIds.map((behaviorId) => [behaviorId, item.id])));
+  const behaviorById = new Map(behaviorPlan.responsibilities.map((item) => [item.id, item]));
+  for (const task of tasks) {
+    const dependencies = task.behaviorIds.flatMap((behaviorId) => behaviorById.get(behaviorId)?.dependsOnBehaviorIds ?? []).map((behaviorId) => taskByBehavior.get(behaviorId)).filter((id) => Boolean(id) && id !== task.id);
+    task.dependsOnTaskIds = uniqueSorted(dependencies);
+  }
+  const packages = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (task.workPackageId === null) continue;
+    packages.set(task.workPackageId, [...packages.get(task.workPackageId) ?? [], task]);
+  }
+  for (const items of packages.values()) {
+    const lane = orderPackageLane(items);
+    for (let index = 1; index < lane.length; index++) addDependency(byId, lane[index].id, lane[index - 1].id);
+  }
+  const packageRanks = packageSerializationRanks(tasks);
+  const edges = [];
+  for (let leftIndex = 0; leftIndex < tasks.length; leftIndex++) {
+    for (let rightIndex = leftIndex + 1; rightIndex < tasks.length; rightIndex++) {
+      const left = tasks[leftIndex];
+      const right = tasks[rightIndex];
+      const reasons = conflictReasons(left, right);
+      if (!reasons.length) continue;
+      edges.push({ leftTaskId: left.id, rightTaskId: right.id, reasons });
+      left.conflictsWithTaskIds = uniqueSorted([...left.conflictsWithTaskIds, right.id]);
+      right.conflictsWithTaskIds = uniqueSorted([...right.conflictsWithTaskIds, left.id]);
+      if (hasPath(byId, left.id, right.id) || hasPath(byId, right.id, left.id)) continue;
+      const leftPackageRank = left.workPackageId ? packageRanks.get(left.workPackageId) : void 0;
+      const rightPackageRank = right.workPackageId ? packageRanks.get(right.workPackageId) : void 0;
+      if (leftPackageRank !== void 0 && rightPackageRank !== void 0 && leftPackageRank !== rightPackageRank) {
+        const [later, earlier] = leftPackageRank > rightPackageRank ? [left, right] : [right, left];
+        addDependency(byId, later.id, earlier.id);
+      } else {
+        addDependency(byId, right.id, left.id);
+      }
+    }
+  }
+  for (const task of tasks) {
+    const providers = task.dependsOnTaskIds.map((id) => byId.get(id)).filter((item) => Boolean(item));
+    const businessProviderIds = new Set(task.behaviorIds.flatMap((behaviorId) => behaviorById.get(behaviorId)?.dependsOnBehaviorIds ?? []).map((behaviorId) => taskByBehavior.get(behaviorId)).filter((id) => Boolean(id)));
+    task.writeOwnership.readOnlyFiles = uniqueSorted(providers.flatMap((provider) => provider.writeOwnership.ownedFiles).filter((file) => !task.writeOwnership.ownedFiles.includes(file)));
+    task.dependencyInterfaces = providers.map((provider) => {
+      const kind = businessProviderIds.has(provider.id) ? "module" : "ordering";
+      return {
+        kind,
+        ref: kind === "module" ? `interface:${provider.primaryModule}` : `ordering:${provider.id}`,
+        providerTaskId: provider.id,
+        files: provider.writeOwnership.ownedFiles.filter((file) => !task.writeOwnership.ownedFiles.includes(file)),
+        errorModes: kind === "module" ? ["provider task is not locally verified", "provider Interface changed after this execution plan was generated"] : ["serialized predecessor is not locally verified", "write ownership changed after this execution plan was generated"],
+        orderingConstraints: [`${provider.id} must be locally verified before ${task.id}`]
+      };
+    });
+  }
+  return edges.sort((left, right) => `${left.leftTaskId}:${left.rightTaskId}`.localeCompare(`${right.leftTaskId}:${right.rightTaskId}`));
+}
+function downstreamCounts2(tasks) {
+  const children = /* @__PURE__ */ new Map();
+  for (const task of tasks) for (const dependency of task.dependsOnTaskIds) children.set(dependency, [...children.get(dependency) ?? [], task.id]);
+  const result = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [...children.get(task.id) ?? []];
+    while (queue.length) {
+      const next = queue.shift();
+      if (seen.has(next)) continue;
+      seen.add(next);
+      queue.push(...children.get(next) ?? []);
+    }
+    result.set(task.id, seen.size);
+  }
+  return result;
+}
+function pageWorkPackages(tasks, facts, canonicalBySurface) {
+  const grouped = /* @__PURE__ */ new Map();
+  const taskById = new Map(tasks.map((task) => [task.id, task]));
+  for (const task of tasks) {
+    if (task.workPackageId === null) continue;
+    grouped.set(task.workPackageId, [...grouped.get(task.workPackageId) ?? [], task]);
+  }
+  return [...grouped.entries()].map(([id, items]) => {
+    const canonicalPageRef = items[0]?.canonicalPageRef ?? null;
+    const title = facts.surfaces.find((surface) => surface.id === canonicalPageRef)?.name ?? canonicalPageRef ?? "Unassigned";
+    const ordered = orderPackageLane(items);
+    return {
+      id,
+      canonicalPageRef,
+      title: `${title} Page Work Package`,
+      surfaceRefs: uniqueSorted(facts.surfaces.filter((surface) => (canonicalBySurface[surface.id] ?? surface.id) === canonicalPageRef).map((surface) => surface.id)),
+      workItemIds: ordered.map((item) => item.id),
+      dependsOnPackageIds: uniqueSorted(items.flatMap((item) => item.dependsOnTaskIds).map((taskId2) => taskById.get(taskId2)?.workPackageId).filter((packageId) => Boolean(packageId && packageId !== id))),
+      serialLane: true,
+      exclusiveScopes: uniqueSorted(items.flatMap((item) => item.writeOwnership.exclusiveScopes))
+    };
+  }).sort((left, right) => left.id.localeCompare(right.id));
+}
+function compileExecutionPlan(behaviorPlan, facts, context = emptyExecutionPlanningContext) {
+  const planningPhase = behaviorPlan.responsibilities.some((behavior) => behavior.type === "resolution") ? "resolution" : "execution";
+  const activeBehaviorPlan = planningPhase === "resolution" ? { ...behaviorPlan, responsibilities: behaviorPlan.responsibilities.filter((behavior) => behavior.type === "resolution") } : behaviorPlan;
+  const canonicalBySurface = canonicalPageRefs(facts);
+  const clusters = planningPhase === "resolution" ? activeBehaviorPlan.responsibilities.map((behavior) => candidateForBehavior(behavior, facts, canonicalBySurface)) : clusterBehaviors(activeBehaviorPlan, facts, context);
+  const tasks = initialTasks(clusters, activeBehaviorPlan, facts, canonicalBySurface, context);
+  const fileConflictEdges = wireDependenciesAndConflicts(tasks, activeBehaviorPlan);
+  const downstream = downstreamCounts2(tasks);
+  for (const task of tasks) task.estimate.downstreamUnlockCount = downstream.get(task.id) ?? 0;
+  const taskByBehavior = new Map(tasks.flatMap((task) => task.behaviorIds.map((behaviorId) => [behaviorId, task.id])));
+  const primaryOwnerByFactRef = Object.fromEntries(Object.entries(behaviorPlan.ownership.primaryOwnerByFactRef).flatMap(([ref, behaviorId]) => {
+    const taskId2 = taskByBehavior.get(behaviorId);
+    return taskId2 ? [[ref, taskId2]] : [];
+  }).sort(([left], [right]) => left.localeCompare(right)));
+  const supportingTaskIdsByFactRef = {};
+  for (const task of tasks) for (const ref of task.supportingFactRefs) supportingTaskIdsByFactRef[ref] = uniqueSorted([...supportingTaskIdsByFactRef[ref] ?? [], task.id]);
+  return {
+    taskPlanVersion: TASK_PLAN_VERSION,
+    executionPlanVersion: EXECUTION_PLAN_VERSION,
+    planningModelVersion: behaviorPlan.planningModelVersion,
+    factsAdapterVersion: behaviorPlan.factsAdapterVersion,
+    plannerPolicyVersion: behaviorPlan.plannerPolicyVersion,
+    baseline: behaviorPlan.baseline,
+    planningPhase,
+    entryResolution: behaviorPlan.entryResolution,
+    behaviorResponsibilities: behaviorPlan.responsibilities,
+    pageWorkPackages: pageWorkPackages(tasks, facts, canonicalBySurface),
+    tasks,
+    ownership: {
+      primaryOwnerByFactRef,
+      supportingTaskIdsByFactRef: Object.fromEntries(Object.entries(supportingTaskIdsByFactRef).sort(([left], [right]) => left.localeCompare(right)))
+    },
+    behaviorOwnership: behaviorPlan.ownership,
+    fileConflictEdges,
+    planningWarnings: behaviorPlan.planningWarnings
+  };
+}
+function compileFromPlanningFacts(facts, androidFingerprint, context = emptyExecutionPlanningContext) {
+  return compileExecutionPlan(compileBehaviorPlanFromPlanningFacts(facts, androidFingerprint), facts, context);
+}
+
+// src/planning/storage.ts
+import fs27 from "fs";
 import path33 from "path";
 function taskPlanRoot(projectRoot) {
   return path33.join(migrationDirectory(projectRoot), "tasks");
 }
-function taskArtifactStem(taskId) {
-  return taskId.replace(/^task:/, "");
+function taskArtifactStem(taskId2) {
+  return taskId2.replace(/^task:/, "");
+}
+function workPackageArtifactStem(workPackageId2) {
+  return workPackageId2.replace(/^package:/, "");
+}
+function codeRefIndex(value) {
+  const allowed = ["id", "file", "name", "symbol", "kind", "type", "capabilityRef", "line", "startLine", "endLine"];
+  return Object.fromEntries(allowed.filter((key) => value[key] !== void 0).map((key) => [key, value[key]]));
 }
-function renderTaskBrief(task) {
+function taskContractView(task) {
+  return { ...task, closure: { ...task.closure, codeRefs: task.closure.codeRefs.map(codeRefIndex) } };
+}
+function coreFactsForTask(task, facts) {
+  return coreFactsForRefs([...task.primaryFactRefs, ...task.supportingFactRefs], task.closure.unresolvedRefs, facts);
+}
+function coreFactsForRefs(refsInput, unresolvedRefs, facts) {
+  const refs = new Set(refsInput);
+  return [
+    ...facts.surfaces.filter((item) => refs.has(item.id)).map((value) => ({ kind: "surface", value })),
+    ...facts.controls.filter((item) => refs.has(item.id)).map((value) => ({ kind: "control", value })),
+    ...facts.entries.filter((item) => refs.has(item.id)).map((value) => ({
+      kind: "entry",
+      value: { ...value, trace: { ...value.trace, codeRefs: value.trace.codeRefs.map(codeRefIndex) } }
+    })),
+    ...facts.effects.filter((item) => refs.has(item.id)).map((value) => ({ kind: "effect", value })),
+    ...facts.issues.filter((item) => refs.has(item.id) || unresolvedRefs.includes(item.id)).map((value) => ({ kind: "issue", value }))
+  ];
+}
+function sourceContextForTask(task) {
+  return uniqueBy([
+    ...task.closure.sourceEvidence.map((value) => ({ kind: "source-evidence", value })),
+    ...task.closure.codeRefs.map((value) => ({ kind: "code-ref", value: codeRefIndex(value) }))
+  ], stableJson);
+}
+function tasksForPackage(workPackage, plan) {
+  const byId = new Map(plan.tasks.map((task) => [task.id, task]));
+  return workPackage.workItemIds.map((id) => byId.get(id)).filter((task) => Boolean(task));
+}
+function effectOutcome2(effectRef, facts) {
+  const effect = facts.effects.find((item) => item.id === effectRef);
+  if (!effect) return effectRef;
+  const target = effect.targetKind === "surface" ? facts.surfaces.find((surface) => surface.id === effect.targetId)?.name : effect.targetKind === "entry" ? facts.entries.find((entry) => entry.id === effect.targetId)?.label : null;
+  const label = target ?? effect.targetId;
+  if (effect.kind === "opens") return `\u6253\u5F00 ${label}`;
+  if (effect.kind === "navigates-to") return `\u8FDB\u5165 ${label}`;
+  if (effect.kind === "launches-for-result") return `\u542F\u52A8 ${label} \u5E76\u5904\u7406\u8FD4\u56DE\u7ED3\u679C`;
+  return `\u5904\u7406 ${label}`;
+}
+function pageWorkPackageContractView(workPackage, plan, facts) {
+  const tasks = tasksForPackage(workPackage, plan);
+  const taskByBehavior = new Map(tasks.flatMap((task) => task.behaviorIds.map((behaviorId) => [behaviorId, task])));
+  const behaviorById = new Map(plan.behaviorResponsibilities.map((behavior) => [behavior.id, behavior]));
+  const orderedBehaviors = tasks.flatMap((task) => task.behaviorIds.map((id) => behaviorById.get(id))).filter((item) => Boolean(item));
+  const ownedFiles = uniqueSorted(tasks.flatMap((task) => task.writeOwnership.ownedFiles));
+  const packageByTask = new Map(plan.tasks.flatMap((task) => task.workPackageId ? [[task.id, task.workPackageId]] : []));
+  const dependencyGroups = /* @__PURE__ */ new Map();
+  for (const task of tasks) for (const dependency of task.dependencyInterfaces) {
+    const providerTaskId = dependency.providerTaskId;
+    const providerPackageId = providerTaskId ? packageByTask.get(providerTaskId) : null;
+    if (!providerTaskId || !providerPackageId || providerPackageId === workPackage.id) continue;
+    const key = `${dependency.kind}:${dependency.ref}:${providerPackageId}`;
+    const current = dependencyGroups.get(key) ?? {
+      kind: dependency.kind,
+      ref: dependency.ref,
+      providerPackageId,
+      providerWorkItemIds: [],
+      files: [],
+      errorModes: [],
+      orderingConstraints: []
+    };
+    current.providerWorkItemIds = uniqueSorted([...current.providerWorkItemIds, providerTaskId]);
+    current.files = uniqueSorted([...current.files, ...dependency.files]);
+    current.errorModes = uniqueSorted([...current.errorModes, ...dependency.errorModes]);
+    current.orderingConstraints = uniqueSorted([...current.orderingConstraints, ...dependency.orderingConstraints]);
+    dependencyGroups.set(key, current);
+  }
+  const sourceFiles = uniqueSorted(tasks.flatMap((task) => [
+    ...task.closure.sourceEvidence.map((item) => item.file),
+    ...task.closure.codeRefs.flatMap((item) => typeof item.file === "string" ? [item.file] : [])
+  ]));
+  return {
+    ...workPackage,
+    behaviorIds: orderedBehaviors.map((behavior) => behavior.id),
+    workItems: tasks.map((task, index) => ({
+      ordinal: index + 1,
+      id: task.id,
+      type: task.type,
+      title: task.title,
+      behaviorIds: task.behaviorIds
+    })),
+    features: orderedBehaviors.map((behavior, index) => ({
+      ordinal: index + 1,
+      behaviorId: behavior.id,
+      workItemId: taskByBehavior.get(behavior.id).id,
+      type: behavior.type,
+      title: behavior.title,
+      triggerLabels: uniqueSorted(facts.entries.filter((entry) => behavior.closure.entryRefs.includes(entry.id)).map((entry) => entry.label)),
+      controlNames: uniqueSorted(facts.controls.filter((control) => behavior.closure.controlRefs.includes(control.id)).map((control) => control.name)),
+      interactionOutcomes: uniqueSorted(behavior.closure.interactionRefs.map((ref) => effectOutcome2(ref, facts))),
+      entryRefs: behavior.closure.entryRefs,
+      surfaceRefs: behavior.closure.surfaceRefs,
+      controlRefs: behavior.closure.controlRefs,
+      interactionRefs: behavior.closure.interactionRefs,
+      unresolvedRefs: behavior.closure.unresolvedRefs,
+      primaryFactRefs: behavior.primaryFactRefs,
+      supportingFactRefs: behavior.supportingFactRefs,
+      requiresSourceReview: behavior.closure.requiresSourceReview,
+      observableOutcome: behavior.acceptance.observableOutcome,
+      requiredFactRefs: behavior.acceptance.requiredFactRefs,
+      verificationRequirements: behavior.acceptance.verificationRequirements,
+      reportRefs: behavior.acceptance.reportRefs
+    })),
+    writeOwnership: {
+      ownedFiles,
+      readOnlyFiles: uniqueSorted(tasks.flatMap((task) => task.writeOwnership.readOnlyFiles).filter((file) => !ownedFiles.includes(file))),
+      exclusiveScopes: workPackage.exclusiveScopes,
+      forbiddenGlobalFiles: uniqueSorted(tasks.flatMap((task) => task.writeOwnership.forbiddenGlobalFiles).filter((file) => !ownedFiles.includes(file)))
+    },
+    dependencyInterfaces: [...dependencyGroups.values()].sort((left, right) => `${left.providerPackageId}:${left.ref}`.localeCompare(`${right.providerPackageId}:${right.ref}`)),
+    acceptance: {
+      observableOutcomes: uniqueSorted(orderedBehaviors.map((behavior) => behavior.acceptance.observableOutcome)),
+      requiredFactRefs: uniqueSorted(orderedBehaviors.flatMap((behavior) => behavior.acceptance.requiredFactRefs)),
+      verificationRequirements: uniqueSorted(orderedBehaviors.flatMap((behavior) => behavior.acceptance.verificationRequirements)),
+      reportRefs: uniqueSorted(orderedBehaviors.flatMap((behavior) => behavior.acceptance.reportRefs))
+    },
+    estimate: {
+      behaviorCount: orderedBehaviors.length,
+      workItemCount: tasks.length,
+      factCount: uniqueSorted(tasks.flatMap((task) => [...task.primaryFactRefs, ...task.supportingFactRefs])).length,
+      sourceFileCount: sourceFiles.length,
+      traceNodeCount: uniqueBy(tasks.flatMap((task) => task.closure.codeRefs), stableJson).length,
+      estimatedFactTokens: tasks.reduce((total, task) => total + task.estimate.estimatedFactTokens, 0),
+      productionFileCount: uniqueSorted(tasks.flatMap((task) => task.writeOwnership.ownedFiles).filter((file) => !/(^|\/)(test|ohosTest)(\/|$)|\.(test|spec)\./i.test(file))).length,
+      testFileCount: uniqueSorted(tasks.flatMap((task) => task.writeOwnership.ownedFiles).filter((file) => /(^|\/)(test|ohosTest)(\/|$)|\.(test|spec)\./i.test(file))).length,
+      capabilityCount: tasks.reduce((total, task) => total + task.estimate.capabilityCount, 0)
+    }
+  };
+}
+function coreFactsForPageWorkPackage(workPackage, facts) {
+  const tasksRefs = workPackage.features.flatMap((feature) => [...feature.primaryFactRefs, ...feature.supportingFactRefs]);
+  return coreFactsForRefs(tasksRefs, workPackage.features.flatMap((feature) => feature.unresolvedRefs), facts);
+}
+function sourceContextForPageWorkPackage(workPackage, plan) {
+  return uniqueBy(tasksForPackage(workPackage, plan).flatMap(sourceContextForTask), stableJson);
+}
+function renderResolutionTaskBrief(task, plan) {
+  if (task.type !== "resolution") throw new Error("Resolution brief requires a Resolution Task");
   const list = (values) => values.length ? values.map((value) => `- \`${value}\``).join("\n") : "- \u65E0";
   const sourceLocations = [.../* @__PURE__ */ new Set([
     ...task.closure.sourceEvidence.map((item) => `${item.file}${item.line ? `:${item.line}${(() => {
@@ -6152,15 +6676,54 @@ function renderTaskBrief(task) {
       return "";
     })()}`] : [])
   ])].sort();
-  return `# ${task.title}
+  const sourcePreview = sourceLocations.slice(0, 20);
+  const hiddenSourceCount = sourceLocations.length - sourcePreview.length;
+  const taskKind = "Resolution Task";
+  const identity = [
+    `- ${taskKind} ID\uFF1A\`${task.id}\``,
+    `- Execution Plan Hash\uFF1A\`${sha2562(plan)}\``,
+    `- Facts SHA256\uFF1A\`${plan.baseline.factsSha256}\``,
+    `- Android Fingerprint\uFF1A${plan.baseline.androidFingerprint ? `\`${plan.baseline.androidFingerprint}\`` : "\u672A\u63D0\u4F9B"}`,
+    `- Behavior IDs\uFF1A${task.behaviorIds.map((id) => `\`${id}\``).join("\u3001")}`,
+    `- Primary Page / Module\uFF1A\`${task.canonicalPageRef ?? "unassigned"}\` / \`${task.primaryModule}\``
+  ].join("\n");
+  const ownership = (values, fallback) => values.length ? values.map((value) => `- \`${value}\``).join("\n") : `- ${fallback}`;
+  return `# ${taskKind}\uFF1A${task.title}
 
-## \u76EE\u6807
+## 1. \u6700\u7EC8\u76EE\u6807
 
 ${task.acceptance.observableOutcome}
 
-## \u884C\u4E3A\u95ED\u5305
+## 2. \u8EAB\u4EFD\u4E0E\u57FA\u7EBF
+
+${identity}
+
+## 3. \u5B8C\u6210\u5B9A\u4E49
+
+${task.acceptance.observableOutcomes.map((outcome) => `- ${outcome}`).join("\n")}
+
+## 4. \u5199\u5165\u6240\u6709\u6743
+
+### \u5141\u8BB8\u4FEE\u6539
+
+${ownership(task.writeOwnership.ownedFiles, `\u65E0\uFF1B\`${task.writeOwnership.exclusiveScopes.join("\u3001")}\` \u662F\u88C1\u51B3\u4E92\u65A5\u8303\u56F4\uFF0C\u4E0D\u6388\u4E88 HarmonyOS \u6587\u4EF6\u5199\u5165\u6743`)}
+
+### \u53EA\u8BFB\u4F9D\u8D56
+
+${ownership(task.writeOwnership.readOnlyFiles, "\u65E0")}
+
+### \u7981\u6B62\u4FEE\u6539
+
+${ownership(task.writeOwnership.forbiddenGlobalFiles, "\u65E0")}
+
+## 5. \u524D\u7F6E\u4F9D\u8D56\u4E0E Interface
+
+${task.dependencyInterfaces.length ? task.dependencyInterfaces.map((item) => `- ${item.kind === "module" ? "Module Interface" : "\u8C03\u5EA6\u987A\u5E8F"} \`${item.ref}\`\uFF0C\u63D0\u4F9B\u8005\uFF1A${item.providerTaskId ? `\`${item.providerTaskId}\`` : "\u5916\u90E8\u7A33\u5B9A Interface"}\uFF1B\u987A\u5E8F\uFF1A${item.orderingConstraints.join("\uFF1B") || "\u65E0"}\uFF1B\u9519\u8BEF\u6A21\u5F0F\uFF1A${item.errorModes.join("\uFF1B") || "\u65E0"}`).join("\n") : "- \u65E0"}
+
+## 6. \u884C\u4E3A\u4E0E\u72B6\u6001\u673A
 
 - Task \u7C7B\u578B\uFF1A\`${task.type}\`
+- Work Package\uFF1A${task.workPackageId ? `\`${task.workPackageId}\`` : "\u4E0D\u9002\u7528\uFF08Resolution Task \u4E0D\u53C2\u4E0E Coding Work Package\uFF09"}
 - \u5165\u53E3\u6570\uFF1A${task.closure.entryRefs.length}
 - \u9875\u9762\u6570\uFF1A${task.closure.surfaceRefs.length}
 - \u63A7\u4EF6\u6570\uFF1A${task.closure.controlRefs.length}
@@ -6172,171 +6735,388 @@ ${task.acceptance.observableOutcome}
 - \u4EA4\u4E92\uFF1A${task.closure.interactionRefs.map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}
 - \u9700\u8981\u6E90\u7801\u590D\u6838\uFF1A${task.closure.requiresSourceReview ? "\u662F" : "\u5426"}
 
-## \u6E90\u7801\u4E0A\u4E0B\u6587
+## 7. Android \u8BC1\u636E
+
+${sourcePreview.length ? `${sourcePreview.map((value) => `- ${value}`).join("\n")}${hiddenSourceCount > 0 ? `
+- \u5176\u4F59 ${hiddenSourceCount} \u4E2A\u4F4D\u7F6E\u89C1 source-context.json \u6216 task show \u5206\u9875` : ""}` : "- \u65E0\u76F4\u63A5\u6E90\u7801\u4F4D\u7F6E\uFF0C\u8BF7\u4ECE coreFacts \u548C unresolvedRefs \u5F00\u59CB\u88C1\u51B3"}
 
-${sourceLocations.length ? sourceLocations.map((value) => `- ${value}`).join("\n") : "- \u65E0\u76F4\u63A5\u6E90\u7801\u4F4D\u7F6E\uFF0C\u8BF7\u4ECE coreFacts \u548C unresolvedRefs \u5F00\u59CB\u88C1\u51B3"}
+## 8. Facts \u95ED\u5305
 
-## \u5F85\u88C1\u51B3\u95EE\u9898
+### \u5F85\u88C1\u51B3\u95EE\u9898
 
 ${list(task.closure.unresolvedRefs)}
 
-## \u4E3B\u6240\u6709\u6743 Facts
+### \u4E3B\u6240\u6709\u6743 Facts
 
 ${list(task.primaryFactRefs)}
 
-## \u652F\u6301 Facts
+### Supporting Facts
 
 ${list(task.supportingFactRefs)}
 
-## \u4F9D\u8D56 Task
+## 9. \u5B9E\u73B0\u7EA6\u675F
+
+- \u672C Resolution Task \u53EA\u88C1\u51B3 Planning Facts\uFF1B\u4E0D\u5F97\u4FEE\u6539 HarmonyOS \u4E1A\u52A1\u5B9E\u73B0\u3002
+- \u5FC5\u987B\u628A\u7ED3\u8BBA\u5199\u5165\u53D7\u7BA1 fact correction \u6216 unresolved review\uFF1BReport discovery \u4E0D\u80FD\u5355\u72EC\u89E3\u9664\u89C4\u5212\u963B\u585E\u3002
+- \u89C4\u5212\u8F93\u5165\u53D8\u5316\u540E\u5FC5\u987B\u91CD\u65B0\u751F\u6210 Behavior Plan \u4E0E Resolution Plan\uFF1B\u53EA\u6709 Resolution \u6E05\u96F6\u540E\u624D\u7EC4\u88C5 Coding Work Item\u3002
+- Ready Gate\uFF1A\u8BED\u4E49=${task.readyGate.semanticsResolved ? "\u901A\u8FC7" : "\u672A\u901A\u8FC7"}\uFF0C\u4F9D\u8D56 Interface=${task.readyGate.dependencyInterfacesStable ? "\u7A33\u5B9A" : "\u4E0D\u7A33\u5B9A"}\uFF0C\u5199\u5165\u6240\u6709\u6743=${task.readyGate.writeOwnershipResolved ? "\u5DF2\u786E\u5B9A" : "\u672A\u786E\u5B9A"}\uFF0C\u4E0A\u4E0B\u6587\u9884\u7B97=${task.readyGate.contextWithinBudget ? "\u901A\u8FC7" : "\u8D85\u9650"}\uFF0C\u9A8C\u6536=${task.readyGate.acceptanceExecutable ? "\u53EF\u6267\u884C" : "\u4E0D\u53EF\u6267\u884C"}\u3002
+
+## 10. \u975E\u76EE\u6807
+
+- \u4E0D\u6269\u5927\u5230\u5F53\u524D Behavior IDs \u4E4B\u5916\u7684\u72EC\u7ACB\u4E1A\u52A1\u7ED3\u679C\u3002
+- \u4E0D\u7F16\u5199 ArkTS/ArkUI\uFF0C\u4E0D\u628A\u6E90\u7801\u9605\u8BFB\u672C\u8EAB\u89C6\u4E3A\u88C1\u51B3\u5B8C\u6210\u3002
+- \u4E0D\u4EE5\u62A5\u544A\u5B57\u6BB5\u3001\u6CE8\u91CA\u3001\u6869\u4EE3\u7801\u6216\u4EC5\u7F16\u8BD1\u6210\u529F\u66FF\u4EE3\u771F\u5B9E\u884C\u4E3A\u5B9E\u73B0\u3002
+
+## 11. \u9A8C\u6536\u547D\u4EE4\u4E0E\u573A\u666F
+
+${task.acceptance.verificationRequirements.map((value) => `- ${value}`).join("\n")}
+
+\u9A8C\u6536\u5FC5\u987B\u8986\u76D6\u7684 Report refs\uFF1A${task.acceptance.reportRefs.map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}\u3002
 
-${list(task.dependsOnTaskIds)}
+## 12. \u5B8C\u6210\u56DE\u62A5\u683C\u5F0F
+
+- \u88C1\u51B3\u7684 issue refs\u3001\u8BFB\u53D6\u7684 Android \u6E90\u7801/\u8FD0\u884C\u8BC1\u636E\uFF0C\u4EE5\u53CA\u5199\u5165\u7684 correction/review\u3002
+- \u6BCF\u4E2A Behavior ID \u5BF9\u5E94\u7684\u88C1\u51B3\u7ED3\u679C\u3002
+- \u91CD\u65B0\u89C4\u5212\u540E\u7684 Plan Hash\u3001planningPhase\uFF0C\u4EE5\u53CA\u662F\u5426\u4ECD\u6709 Resolution\uFF1B\u6E05\u96F6\u540E\u8BB0\u5F55\u65B0\u751F\u6210\u7684\u51BB\u7ED3 Coding Plan Hash\u3002
+- \u672A\u89E3\u51B3\u95EE\u9898\uFF1B\u6CA1\u6709\u5219\u660E\u786E\u5199\u201C\u65E0\u201D\u3002
 
 ## \u5DE5\u4F5C\u91CF\u63D0\u793A
 
 - Fact \u6570\uFF1A${task.estimate.factCount}
+- Behavior \u6570\uFF1A${task.estimate.behaviorCount}
+- \u53EF\u89C2\u5BDF\u7ED3\u679C\u6570\uFF1A${task.estimate.observableOutcomeCount}
 - \u6E90\u7801\u6587\u4EF6\u6570\uFF1A${task.estimate.sourceFileCount}
+- \u751F\u4EA7\u4EE3\u7801\u6587\u4EF6\u6570\uFF1A${task.estimate.productionFileCount}
+- \u6D4B\u8BD5\u6587\u4EF6\u6570\uFF1A${task.estimate.testFileCount}
+- Capability \u6570\uFF1A${task.estimate.capabilityCount}
 - \u8C03\u7528\u94FE\u8282\u70B9\u6570\uFF1A${task.estimate.traceNodeCount}
 - \u4F30\u7B97 Facts Token\uFF1A${task.estimate.estimatedFactTokens}
 - \u53EF\u89E3\u9501\u4E0B\u6E38 Task\uFF1A${task.estimate.downstreamUnlockCount}
+`;
+}
+function renderPageWorkPackageBrief(workPackage, plan, facts) {
+  const quoteList = (values, fallback = "\u65E0") => values.length ? values.map((value) => `- \`${value}\``).join("\n") : `- ${fallback}`;
+  const surfaceNames = workPackage.surfaceRefs.map((ref) => `${facts.surfaces.find((surface) => surface.id === ref)?.name ?? ref}\uFF08\`${ref}\`\uFF09`);
+  const featureSections = workPackage.features.map((feature) => {
+    const behavior = plan.behaviorResponsibilities.find((item) => item.id === feature.behaviorId);
+    const sources = uniqueSorted([
+      ...behavior.closure.sourceEvidence.map((item) => `${item.file}${item.line ? `:${item.line}${item.endLine && item.endLine !== item.line ? `-${item.endLine}` : ""}` : ""}${item.symbol ? ` \u2014 ${item.symbol}` : ""}`),
+      ...behavior.closure.codeRefs.flatMap((item) => typeof item.file === "string" ? [`${item.file}${typeof item.startLine === "number" ? `:${item.startLine}${typeof item.endLine === "number" && item.endLine !== item.startLine ? `-${item.endLine}` : ""}` : ""}${typeof item.name === "string" ? ` \u2014 ${item.name}` : ""}`] : [])
+    ]);
+    return `### F-${String(feature.ordinal).padStart(3, "0")}\uFF1A${feature.title}
 
-## \u9A8C\u6536\u8981\u6C42
+- Behavior / Work Item\uFF1A\`${feature.behaviorId}\` / \`${feature.workItemId}\`
+- \u89E6\u53D1\uFF1A${feature.triggerLabels.join("\u3001") || "\u7531 Android \u6E90\u7801\u5165\u53E3\u786E\u5B9A"}
+- \u63A7\u4EF6\uFF1A${feature.controlNames.join("\u3001") || "\u65E0\u663E\u5F0F\u63A7\u4EF6"}
+- \u4EA4\u4E92\u7ED3\u679C\uFF1A${feature.interactionOutcomes.join("\u3001") || "\u5FC5\u987B\u6CBF\u6E90\u7801\u8C03\u7528\u94FE\u786E\u8BA4\u72B6\u6001\u3001\u6570\u636E\u6216\u7CFB\u7EDF\u526F\u4F5C\u7528"}
+- \u5B9E\u73B0\u7ED3\u679C\uFF1A${feature.observableOutcome}
+- Required Fact refs\uFF1A${feature.requiredFactRefs.map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}
+- \u6E90\u7801\u590D\u6838\uFF1A${feature.requiresSourceReview ? "\u5FC5\u987B\uFF1BFacts \u672A\u5B8C\u6574\u8868\u8FBE\u53EF\u89C2\u5BDF\u7ED3\u679C\u6216\u5206\u652F" : "\u5FC5\u987B\u8BFB\u53D6\u4E0B\u5217\u8BC1\u636E\u5E76\u8986\u76D6\u5176\u4E2D\u5168\u90E8\u5B9E\u9645\u5206\u652F"}
+- Android \u8BC1\u636E\uFF1A
+${sources.length ? sources.map((value) => `  - ${value}`).join("\n") : "  - \u65E0\u76F4\u63A5\u4F4D\u7F6E\uFF1B\u4E0D\u5F97\u731C\u6D4B\u5B9E\u73B0\uFF0C\u5148\u4ECE\u5BF9\u5E94 core facts \u7EE7\u7EED\u5B9A\u4F4D"}
+- Report refs\uFF1A${feature.reportRefs.map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}`;
+  }).join("\n\n");
+  const tasksById = new Map(plan.tasks.map((task) => [task.id, task]));
+  const packageTaskIds = new Set(workPackage.workItemIds);
+  const internalSequence = workPackage.workItems.map((item) => {
+    const dependencies = (tasksById.get(item.id)?.dependsOnTaskIds ?? []).filter((id) => packageTaskIds.has(id));
+    return `${item.ordinal}. \`${item.id}\` \u2014 ${item.title}${dependencies.length ? `\uFF1B\u9875\u9762\u5185\u524D\u7F6E\uFF1A${dependencies.map((id) => `\`${id}\``).join("\u3001")}` : ""}`;
+  }).join("\n");
+  const dependencyText = workPackage.dependencyInterfaces.length ? workPackage.dependencyInterfaces.map((item) => `- \`${item.providerPackageId}\` \u63D0\u4F9B ${item.kind === "module" ? "Module Interface" : "\u8C03\u5EA6\u524D\u7F6E"} \`${item.ref}\`\uFF1B\u6765\u6E90 Work Items\uFF1A${item.providerWorkItemIds.map((id) => `\`${id}\``).join("\u3001")}\uFF1B\u9519\u8BEF\u6A21\u5F0F\uFF1A${item.errorModes.join("\uFF1B") || "\u65E0"}`).join("\n") : "- \u65E0";
+  const acceptanceSequences = workPackage.features.map((feature) => `### F-${String(feature.ordinal).padStart(3, "0")}
 
-${task.acceptance.verificationRequirements.map((value) => `- ${value}`).join("\n")}
+1. \u4ECE\u771F\u5B9E\u5E94\u7528\u5165\u53E3\u5230\u8FBE\u672C Page Work Package \u627F\u8F7D\u9762\u3002
+2. \u89E6\u53D1\u201C${feature.triggerLabels.join(" / ") || feature.title}\u201D\u3002
+3. \u65AD\u8A00\uFF1A${feature.observableOutcome}
+4. \u6309 Android \u8BC1\u636E\u8986\u76D6\u6210\u529F\u3001\u53D6\u6D88\u3001\u5931\u8D25\u3001\u7A7A\u503C\u548C\u7CFB\u7EDF\u56DE\u8C03\u5206\u652F\u4E2D\u5B9E\u9645\u5B58\u5728\u7684\u573A\u666F\uFF1B\u4E0D\u5F97\u7528\u6869\u4EE3\u7801\u6216\u4EC5\u7F16\u8BD1\u6210\u529F\u4EE3\u66FF\u3002`).join("\n\n");
+  return `# Page Work Package\uFF1A${workPackage.title.replace(/ Page Work Package$/, "")}
+
+> \u672C Markdown \u662F execution \u9636\u6BB5\u4E00\u6B21\u6A21\u578B\u8C03\u7528\u7684\u6700\u7EC8\u9875\u9762\u5B9E\u73B0\u8F93\u5165\uFF0C\u7531\u51BB\u7ED3\u7684 Execution Plan \u548C Canonical Facts \u786E\u5B9A\u6027\u751F\u6210\u3002Work Item \u4E0E Behavior \u4EC5\u4F5C\u4E3A\u672C\u5305\u5185\u90E8\u987A\u5E8F\u3001\u8BC1\u636E\u548C\u9A8C\u6536\u8D23\u4EFB\uFF0C\u4E0D\u518D\u5206\u522B\u751F\u6210\u53EF\u6267\u884C Markdown\u3002
+
+## 1. \u9875\u9762\u6267\u884C\u5951\u7EA6
+
+- Page Work Package ID\uFF1A\`${workPackage.id}\`
+- Execution Plan Hash\uFF1A\`${sha2562(plan)}\`
+- Facts SHA256\uFF1A\`${plan.baseline.factsSha256}\`
+- Android Fingerprint\uFF1A${plan.baseline.androidFingerprint ? `\`${plan.baseline.androidFingerprint}\`` : "\u672A\u63D0\u4F9B"}
+- Canonical Page\uFF1A\`${workPackage.canonicalPageRef ?? "unassigned"}\`
+- \u627F\u8F7D\u9762\uFF1A${surfaceNames.join("\u3001") || "\u65E0"}
+- Work Item \u6570\uFF1A${workPackage.workItems.length}
+- Behavior / \u9875\u9762\u529F\u80FD\u6570\uFF1A${workPackage.features.length}
+
+## 2. \u9875\u9762\u8303\u56F4\u4E0E\u6700\u7EC8\u76EE\u6807
+
+\u672C\u5305\u5FC5\u987B\u5728\u540C\u4E00\u4E2A\u5B9E\u73B0 epoch \u5185\u5B8C\u6210\u4EE5\u4E0B\u5168\u90E8\u9875\u9762\u529F\u80FD\uFF0C\u5E76\u4FDD\u6301\u9875\u9762\u5185\u987A\u5E8F\u3002\u627F\u8F7D\u9762\u5185\u7684 Dialog\u3001Sheet \u6216\u7CFB\u7EDF\u56DE\u8C03\u5C5E\u4E8E\u672C\u5305\uFF1B\u672A\u51FA\u73B0\u5728\u529F\u80FD\u5217\u8868\u548C Facts \u95ED\u5305\u4E2D\u7684\u72EC\u7ACB\u4E1A\u52A1\u7ED3\u679C\u4E0D\u5C5E\u4E8E\u672C\u5305\u3002
+
+${workPackage.acceptance.observableOutcomes.map((outcome) => `- ${outcome}`).join("\n")}
+
+## 3. \u5177\u4F53\u5B9E\u73B0\u529F\u80FD
+
+${featureSections}
+
+## 4. \u9875\u9762\u72B6\u6001\u4E0E Facts \u95ED\u5305
+
+- Entry refs\uFF1A${uniqueSorted(workPackage.features.flatMap((feature) => feature.entryRefs)).map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}
+- Surface refs\uFF1A${uniqueSorted(workPackage.features.flatMap((feature) => feature.surfaceRefs)).map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}
+- Control refs\uFF1A${uniqueSorted(workPackage.features.flatMap((feature) => feature.controlRefs)).map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}
+- Interaction refs\uFF1A${uniqueSorted(workPackage.features.flatMap((feature) => feature.interactionRefs)).map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}
+- \u5F85\u88C1\u51B3 refs\uFF1A${uniqueSorted(workPackage.features.flatMap((feature) => feature.unresolvedRefs)).map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}
+
+\u5B9E\u73B0\u524D\u5FC5\u987B\u6CBF source-context \u7D22\u5F15\u8BFB\u53D6\u5F53\u524D\u9875\u9762\u6D89\u53CA\u7684 Android \u6E90\u7801\u4E0E\u5FC5\u8981\u8C03\u7528\u94FE\uFF1B\u672C\u8282\u7684 refs \u548C\u6458\u8981\u4E0D\u80FD\u66FF\u4EE3\u6E90\u7801\u9605\u8BFB\u3002
+
+## 5. \u9875\u9762\u5185\u5B9E\u65BD\u987A\u5E8F
+
+${internalSequence}
+
+\u9875\u9762\u5185 Work Item \u987A\u5E8F\u662F\u51BB\u7ED3\u8BA1\u5212\u7684\u4E00\u90E8\u5206\u3002\u53EF\u4EE5\u5728\u4E00\u6B21\u6A21\u578B\u8C03\u7528\u4E2D\u8FDE\u7EED\u5B8C\u6210\uFF0C\u4F46\u4E0D\u5F97\u9057\u6F0F\u3001\u91CD\u6392\u6216\u628A\u5176\u4E2D\u4E00\u9879\u5355\u72EC\u58F0\u660E\u4E3A\u6574\u4E2A\u9875\u9762\u5B8C\u6210\u3002
+
+## 6. \u5199\u5165\u6240\u6709\u6743
+
+### \u5141\u8BB8\u4FEE\u6539
+
+${quoteList(workPackage.writeOwnership.ownedFiles, `\u5C1A\u65E0\u5DF2\u5B58\u5728\u6587\u4EF6\uFF1B\u4EC5\u53EF\u5728\u72EC\u5360\u8303\u56F4 ${workPackage.writeOwnership.exclusiveScopes.map((scope) => `\`${scope}\``).join("\u3001")} \u5185\u521B\u5EFA\u6216\u8BA4\u9886\u6587\u4EF6`)}
+
+### \u53EA\u8BFB\u4F9D\u8D56
+
+${quoteList(workPackage.writeOwnership.readOnlyFiles)}
+
+### \u7981\u6B62\u4FEE\u6539
+
+${quoteList(workPackage.writeOwnership.forbiddenGlobalFiles)}
+
+### \u72EC\u5360\u8303\u56F4
+
+${quoteList(workPackage.writeOwnership.exclusiveScopes)}
+
+## 7. \u8DE8\u9875\u9762\u4F9D\u8D56\u4E0E Interface
 
-## \u975E\u76EE\u6807
+${dependencyText}
 
-- \u4E0D\u6269\u5927\u5230\u5F53\u524D\u884C\u4E3A\u95ED\u5305\u4E4B\u5916\u7684\u72EC\u7ACB\u5165\u53E3\u3002
-- \u4E0D\u4EE5\u62A5\u544A\u5B57\u6BB5\u3001\u6CE8\u91CA\u6216\u6869\u4EE3\u7801\u66FF\u4EE3\u771F\u5B9E HarmonyOS \u5B9E\u73B0\u3002
-- \u4E0D\u4EE5\u7F16\u8BD1\u6210\u529F\u66FF\u4EE3\u8BBE\u5907\u7AEF\u53EF\u89C2\u5BDF\u7ED3\u679C\u9A8C\u8BC1\u3002
+\u53EA\u6709\u5168\u90E8\u524D\u7F6E Page Work Package \u5DF2\u53D6\u5F97\u65B0\u9C9C\u7684\u672C\u5730\u9A8C\u8BC1\u8BC1\u636E\uFF0C\u5F53\u524D\u5305\u624D\u53EF\u6267\u884C\u3002\u4E0D\u5F97\u901A\u8FC7\u4FEE\u6539\u4E0A\u6E38\u5B9E\u73B0\u7ED5\u8FC7 Interface\u3002
+
+## 8. UI \u64CD\u4F5C\u4E0E\u9A8C\u6536\u5E8F\u5217
+
+${acceptanceSequences}
+
+\u901A\u7528\u9A8C\u8BC1\u8981\u6C42\uFF1A
+
+${workPackage.acceptance.verificationRequirements.map((value) => `- ${value}`).join("\n")}
+
+\u9A8C\u6536\u5FC5\u987B\u8986\u76D6\u7684 Report refs\uFF1A${workPackage.acceptance.reportRefs.map((ref) => `\`${ref}\``).join("\u3001") || "\u65E0"}\u3002
+
+## 9. \u975E\u76EE\u6807\u4E0E\u5B9E\u73B0\u7EA6\u675F
+
+- \u4E0D\u6269\u5927\u5230\u672C\u5305 Behavior IDs \u4E4B\u5916\u7684\u72EC\u7ACB\u4E1A\u52A1\u7ED3\u679C\u3002
+- \u4E0D\u4FEE\u6539\u53EA\u8BFB\u6216\u7981\u6B62\u6587\u4EF6\uFF0C\u4E0D\u91CD\u6784\u4E0A\u6E38 Module \u7684 Implementation\u3002
+- \u4E0D\u9884\u5148\u865A\u6784\u5C1A\u65E0\u8BC1\u636E\u7684 ArkTS \u6587\u4EF6\u540D\u3001\u72B6\u6001\u5B57\u6BB5\u6216\u5931\u8D25\u884C\u4E3A\u3002
+- \u4E0D\u4EE5\u62A5\u544A\u5B57\u6BB5\u3001\u6CE8\u91CA\u3001\u6869\u4EE3\u7801\u6216\u4EC5\u7F16\u8BD1\u6210\u529F\u66FF\u4EE3\u771F\u5B9E\u884C\u4E3A\u5B9E\u73B0\u3002
+- \u53D1\u73B0 Facts\u3001\u9875\u9762\u5F52\u5C5E\u6216 Android \u884C\u4E3A\u9519\u8BEF\u65F6\uFF0C\u7EC8\u6B62\u5F53\u524D execution epoch \u5E76\u8FD4\u56DE\u89C4\u5212\u9636\u6BB5\uFF0C\u4E0D\u5728\u5B9E\u73B0\u4E2D\u6539\u5199\u6D3E\u751F\u8BA1\u5212\u3002
+
+## 10. \u5B8C\u6210\u56DE\u62A5\u683C\u5F0F
+
+- \u4FEE\u6539\u6587\u4EF6\u53CA\u5BF9\u5E94\u5199\u5165\u6240\u6709\u6743\u3002
+- F-001 \u81F3 F-${String(workPackage.features.length).padStart(3, "0")} \u6BCF\u9879\u7684\u5B9E\u73B0\u3001\u6D4B\u8BD5\u548C Report refs \u7ED3\u679C\u3002
+- \u6784\u5EFA\u3001\u5355\u5143\u6D4B\u8BD5\u3001\u9875\u9762/Journey \u6D4B\u8BD5\u547D\u4EE4\u4E0E\u7ED3\u679C\u3002
+- \u672A\u89E3\u51B3\u95EE\u9898\uFF1B\u6CA1\u6709\u5219\u660E\u786E\u5199\u201C\u65E0\u201D\u3002
+
+## \u5DE5\u4F5C\u91CF\u63D0\u793A
+
+- Work Item \u6570\uFF1A${workPackage.estimate.workItemCount}
+- Behavior \u6570\uFF1A${workPackage.estimate.behaviorCount}
+- Fact \u6570\uFF1A${workPackage.estimate.factCount}
+- \u6E90\u7801\u6587\u4EF6\u6570\uFF1A${workPackage.estimate.sourceFileCount}
+- \u751F\u4EA7\u4EE3\u7801\u6587\u4EF6\u6570\uFF1A${workPackage.estimate.productionFileCount}
+- \u6D4B\u8BD5\u6587\u4EF6\u6570\uFF1A${workPackage.estimate.testFileCount}
+- Capability \u6570\uFF1A${workPackage.estimate.capabilityCount}
+- \u8C03\u7528\u94FE\u8282\u70B9\u6570\uFF1A${workPackage.estimate.traceNodeCount}
+- \u4F30\u7B97 Facts Token\uFF1A${workPackage.estimate.estimatedFactTokens}
 `;
 }
 function writeFile(file, content) {
-  fs26.mkdirSync(path33.dirname(file), { recursive: true });
-  fs26.writeFileSync(file, content, "utf8");
+  fs27.mkdirSync(path33.dirname(file), { recursive: true });
+  fs27.writeFileSync(file, content, "utf8");
 }
-function writeTaskPlan(projectRoot, plan) {
+function writeTaskPlan(projectRoot, plan, facts) {
   const root = taskPlanRoot(projectRoot);
   const parent = path33.dirname(root);
-  fs26.mkdirSync(parent, { recursive: true });
+  fs27.mkdirSync(parent, { recursive: true });
   const temporary = path33.join(parent, `tasks.${process.pid}.${Date.now()}.tmp`);
   const backup = path33.join(parent, `tasks.${process.pid}.backup`);
-  fs26.mkdirSync(path33.join(temporary, "briefs"), { recursive: true });
-  fs26.mkdirSync(path33.join(temporary, "acceptance"), { recursive: true });
-  const graphFile = path33.join(temporary, "graph.json");
-  writeFile(graphFile, prettyStableJson(plan));
+  fs27.mkdirSync(temporary, { recursive: true });
   const taskPlanSha256 = sha2562(plan);
-  const descriptors = plan.tasks.map((task) => {
+  const graphFile = path33.join(temporary, "execution-graph.json");
+  writeFile(graphFile, prettyStableJson(plan));
+  writeFile(path33.join(temporary, "behavior-plan.json"), prettyStableJson({
+    behaviorPlanVersion: BEHAVIOR_PLAN_VERSION,
+    planningModelVersion: plan.planningModelVersion,
+    factsAdapterVersion: plan.factsAdapterVersion,
+    plannerPolicyVersion: plan.plannerPolicyVersion,
+    baseline: plan.baseline,
+    entryResolution: plan.entryResolution,
+    responsibilities: plan.behaviorResponsibilities,
+    ownership: plan.behaviorOwnership,
+    planningWarnings: plan.planningWarnings
+  }));
+  const resolutionTargets = plan.tasks.filter((task) => task.type === "resolution").map((task) => {
     const stem = taskArtifactStem(task.id);
-    const briefFile = `briefs/${stem}.md`;
-    const acceptanceFile = `acceptance/${stem}.json`;
-    writeFile(path33.join(temporary, briefFile), renderTaskBrief(task));
+    const taskRoot = `resolution-tasks/${stem}`;
+    const briefFile = `${taskRoot}/brief.md`;
+    const contractFile = `${taskRoot}/contract.json`;
+    const coreFactsFile = `${taskRoot}/core-facts.json`;
+    const sourceContextFile = `${taskRoot}/source-context.json`;
+    const acceptanceFile = `${taskRoot}/acceptance.json`;
+    writeFile(path33.join(temporary, briefFile), renderResolutionTaskBrief(task, plan));
+    writeFile(path33.join(temporary, contractFile), prettyStableJson({ executionPlanSha256: taskPlanSha256, baseline: plan.baseline, task: taskContractView(task) }));
+    writeFile(path33.join(temporary, coreFactsFile), prettyStableJson(coreFactsForTask(task, facts)));
+    writeFile(path33.join(temporary, sourceContextFile), prettyStableJson(sourceContextForTask(task)));
     writeFile(path33.join(temporary, acceptanceFile), prettyStableJson(task.acceptance));
-    return { id: task.id, type: task.type, title: task.title, briefFile, acceptanceFile };
+    return { id: task.id, kind: "resolution-task", title: task.title, briefFile, contractFile, coreFactsFile, sourceContextFile, acceptanceFile };
+  });
+  const pageWorkPackageTargets = plan.pageWorkPackages.map((workPackage) => {
+    const stem = workPackageArtifactStem(workPackage.id);
+    const packageRoot = `page-work-packages/${stem}`;
+    const briefFile = `page-work-packages/${stem}.md`;
+    const contractFile = `${packageRoot}/contract.json`;
+    const coreFactsFile = `${packageRoot}/core-facts.json`;
+    const sourceContextFile = `${packageRoot}/source-context.json`;
+    const acceptanceFile = `${packageRoot}/acceptance.json`;
+    const contract = pageWorkPackageContractView(workPackage, plan, facts);
+    writeFile(path33.join(temporary, briefFile), renderPageWorkPackageBrief(contract, plan, facts));
+    writeFile(path33.join(temporary, contractFile), prettyStableJson({ executionPlanSha256: taskPlanSha256, baseline: plan.baseline, pageWorkPackage: contract }));
+    writeFile(path33.join(temporary, coreFactsFile), prettyStableJson(coreFactsForPageWorkPackage(contract, facts)));
+    writeFile(path33.join(temporary, sourceContextFile), prettyStableJson(sourceContextForPageWorkPackage(workPackage, plan)));
+    writeFile(path33.join(temporary, acceptanceFile), prettyStableJson(contract.acceptance));
+    return { id: workPackage.id, kind: "page-work-package", title: workPackage.title, workItemIds: workPackage.workItemIds, briefFile, contractFile, coreFactsFile, sourceContextFile, acceptanceFile };
   });
+  const targets = plan.planningPhase === "resolution" ? resolutionTargets : pageWorkPackageTargets;
   const index = {
     taskPlanVersion: plan.taskPlanVersion,
     taskPlanSha256,
     baseline: plan.baseline,
-    graphFile: "graph.json",
+    executionPlanVersion: plan.executionPlanVersion,
+    planningPhase: plan.planningPhase,
+    graphFile: "execution-graph.json",
+    behaviorPlanFile: "behavior-plan.json",
     counts: {
       total: plan.tasks.length,
       resolution: plan.tasks.filter((task) => task.type === "resolution").length,
       bootstrap: plan.tasks.filter((task) => task.type === "bootstrap").length,
-      journey: plan.tasks.filter((task) => task.type === "journey").length
+      journey: plan.tasks.filter((task) => task.type === "journey").length,
+      workPackages: plan.pageWorkPackages.length,
+      behaviors: plan.behaviorResponsibilities.length,
+      executionTargets: targets.length
     },
-    tasks: descriptors
+    targets,
+    workItems: plan.planningPhase === "execution" ? plan.tasks.map((task) => ({ id: task.id, type: task.type, title: task.title, workPackageId: task.workPackageId, behaviorIds: task.behaviorIds })) : []
   };
   writeFile(path33.join(temporary, "index.json"), prettyStableJson(index));
   try {
-    if (fs26.existsSync(backup)) fs26.rmSync(backup, { recursive: true, force: true });
-    if (fs26.existsSync(root)) fs26.renameSync(root, backup);
-    fs26.renameSync(temporary, root);
-    if (fs26.existsSync(backup)) fs26.rmSync(backup, { recursive: true, force: true });
+    if (fs27.existsSync(backup)) fs27.rmSync(backup, { recursive: true, force: true });
+    if (fs27.existsSync(root)) fs27.renameSync(root, backup);
+    fs27.renameSync(temporary, root);
+    if (fs27.existsSync(backup)) fs27.rmSync(backup, { recursive: true, force: true });
   } catch (error) {
-    if (!fs26.existsSync(root) && fs26.existsSync(backup)) fs26.renameSync(backup, root);
-    if (fs26.existsSync(temporary)) fs26.rmSync(temporary, { recursive: true, force: true });
+    if (!fs27.existsSync(root) && fs27.existsSync(backup)) fs27.renameSync(backup, root);
+    if (fs27.existsSync(temporary)) fs27.rmSync(temporary, { recursive: true, force: true });
     throw error;
   }
   return {
     taskPlanSha256,
-    graph: path33.relative(path33.resolve(projectRoot), path33.join(root, "graph.json")).replaceAll("\\", "/"),
+    graph: path33.relative(path33.resolve(projectRoot), path33.join(root, "execution-graph.json")).replaceAll("\\", "/"),
     index: path33.relative(path33.resolve(projectRoot), path33.join(root, "index.json")).replaceAll("\\", "/")
   };
 }
 function readTaskPlan(projectRoot) {
-  const file = path33.join(taskPlanRoot(projectRoot), "graph.json");
-  if (!fs26.existsSync(file)) return null;
-  return JSON.parse(fs26.readFileSync(file, "utf8"));
+  const root = taskPlanRoot(projectRoot);
+  const file = fs27.existsSync(path33.join(root, "execution-graph.json")) ? path33.join(root, "execution-graph.json") : path33.join(root, "graph.json");
+  if (!fs27.existsSync(file)) return null;
+  return JSON.parse(fs27.readFileSync(file, "utf8"));
 }
 function hasTaskPlan(projectRoot) {
-  return fs26.existsSync(path33.join(taskPlanRoot(projectRoot), "graph.json"));
+  return fs27.existsSync(path33.join(taskPlanRoot(projectRoot), "execution-graph.json")) || fs27.existsSync(path33.join(taskPlanRoot(projectRoot), "graph.json"));
 }
 
 // src/planning/materialize.ts
-function cursorFor(taskId, taskPlanSha256, offset) {
-  return Buffer.from(JSON.stringify({ taskId, taskPlanSha256, offset }), "utf8").toString("base64url");
+function cursorFor(targetId, taskPlanSha256, offset) {
+  return Buffer.from(JSON.stringify({ targetId, taskPlanSha256, offset }), "utf8").toString("base64url");
 }
-function cursorOffset(cursor, taskId, taskPlanSha256) {
+function cursorOffset(cursor, targetId, taskPlanSha256) {
   if (!cursor) return 0;
   try {
     const value = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-    if (value.taskId !== taskId || value.taskPlanSha256 !== taskPlanSha256 || !Number.isInteger(value.offset) || value.offset < 0) throw new Error("mismatch");
+    if (value.targetId !== targetId || value.taskPlanSha256 !== taskPlanSha256 || !Number.isInteger(value.offset) || value.offset < 0) throw new Error("mismatch");
     return value.offset;
   } catch {
     throw new Error("Invalid or stale task envelope cursor");
   }
 }
-function codeRefIndex(value) {
-  const allowed = ["id", "file", "name", "symbol", "kind", "type", "line", "startLine", "endLine"];
-  return Object.fromEntries(allowed.filter((key) => value[key] !== void 0).map((key) => [key, value[key]]));
-}
-function materializeEnvelope(plan, facts, taskId, options = {}) {
-  const task = plan.tasks.find((item) => item.id === taskId);
-  if (!task) throw new Error(`Task not found: ${taskId}`);
+function materializeEnvelope(plan, facts, targetId, options = {}) {
   const taskPlanSha256 = sha2562(plan);
-  const refs = /* @__PURE__ */ new Set([...task.primaryFactRefs, ...task.supportingFactRefs]);
-  const coreFacts = [
-    ...facts.surfaces.filter((item) => refs.has(item.id)).map((value) => ({ kind: "surface", value })),
-    ...facts.controls.filter((item) => refs.has(item.id)).map((value) => ({ kind: "control", value })),
-    ...facts.entries.filter((item) => refs.has(item.id)).map((value) => ({
-      kind: "entry",
-      value: { ...value, trace: { ...value.trace, codeRefs: value.trace.codeRefs.map(codeRefIndex) } }
-    })),
-    ...facts.effects.filter((item) => refs.has(item.id)).map((value) => ({ kind: "effect", value })),
-    ...facts.issues.filter((item) => refs.has(item.id) || task.closure.unresolvedRefs.includes(item.id)).map((value) => ({ kind: "issue", value }))
-  ];
-  const envelopeTask = { ...task, closure: { ...task.closure, codeRefs: task.closure.codeRefs.map(codeRefIndex) } };
-  const sourceContext = uniqueBy([
-    ...task.closure.sourceEvidence.map((value) => ({ kind: "source-evidence", value })),
-    ...task.closure.codeRefs.map((value) => ({ kind: "code-ref", value: codeRefIndex(value) }))
-  ], stableJson);
   const limit = Math.max(1, Math.min(200, Math.floor(options.maxSourceContext ?? 25)));
-  const offset = cursorOffset(options.cursor, taskId, taskPlanSha256);
+  const offset = cursorOffset(options.cursor, targetId, taskPlanSha256);
+  const task = plan.tasks.find((item) => item.id === targetId);
+  if (task) {
+    if (plan.planningPhase !== "resolution" || task.type !== "resolution") throw new Error("Execution phase materializes a Page Work Package, not an internal Coding Work Item");
+    const coreFacts2 = coreFactsForTask(task, facts);
+    const envelopeTask = taskContractView(task);
+    const sourceContext2 = sourceContextForTask(task);
+    if (offset > sourceContext2.length) throw new Error("Task envelope cursor is past the available source context");
+    const page2 = sourceContext2.slice(offset, offset + limit);
+    const nextOffset2 = offset + page2.length;
+    return {
+      taskEnvelopeVersion: TASK_ENVELOPE_VERSION,
+      taskPlanSha256,
+      targetKind: "resolution-task",
+      targetId,
+      task: envelopeTask,
+      pageWorkPackage: null,
+      contract: { executionPlanSha256: taskPlanSha256, baseline: plan.baseline, task: envelopeTask },
+      brief: renderResolutionTaskBrief(task, plan),
+      coreFacts: coreFacts2,
+      dependencyInterfaces: task.dependencyInterfaces,
+      acceptance: task.acceptance,
+      sourceContext: page2,
+      continuation: {
+        cursor: nextOffset2 < sourceContext2.length ? cursorFor(targetId, taskPlanSha256, nextOffset2) : null,
+        remainingSourceContext: Math.max(0, sourceContext2.length - nextOffset2)
+      }
+    };
+  }
+  const workPackage = plan.pageWorkPackages.find((item) => item.id === targetId);
+  if (!workPackage) throw new Error(`Execution target not found: ${targetId}`);
+  if (plan.planningPhase !== "execution") throw new Error("Resolution phase materializes a Resolution Task, not a Page Work Package");
+  const contract = pageWorkPackageContractView(workPackage, plan, facts);
+  const coreFacts = coreFactsForPageWorkPackage(contract, facts);
+  const sourceContext = sourceContextForPageWorkPackage(workPackage, plan);
   if (offset > sourceContext.length) throw new Error("Task envelope cursor is past the available source context");
   const page = sourceContext.slice(offset, offset + limit);
   const nextOffset = offset + page.length;
   return {
     taskEnvelopeVersion: TASK_ENVELOPE_VERSION,
     taskPlanSha256,
-    task: envelopeTask,
-    brief: renderTaskBrief(task),
+    targetKind: "page-work-package",
+    targetId,
+    task: null,
+    pageWorkPackage: contract,
+    contract: { executionPlanSha256: taskPlanSha256, baseline: plan.baseline, pageWorkPackage: contract },
+    brief: renderPageWorkPackageBrief(contract, plan, facts),
     coreFacts,
+    dependencyInterfaces: contract.dependencyInterfaces,
+    acceptance: contract.acceptance,
     sourceContext: page,
     continuation: {
-      cursor: nextOffset < sourceContext.length ? cursorFor(taskId, taskPlanSha256, nextOffset) : null,
+      cursor: nextOffset < sourceContext.length ? cursorFor(targetId, taskPlanSha256, nextOffset) : null,
       remainingSourceContext: Math.max(0, sourceContext.length - nextOffset)
     }
   };
 }
 
 // src/planning/runtime.ts
-import fs27 from "fs";
+import fs28 from "fs";
 import path34 from "path";
 
 // src/planning/validate.ts
-function findCycle(plan) {
-  const dependencies = new Map(plan.tasks.map((task) => [task.id, task.dependsOnTaskIds]));
+function findDependencyCycle(dependencies) {
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const stack = [];
@@ -6360,33 +7140,101 @@ function findCycle(plan) {
   }
   return null;
 }
+function findCycle(plan) {
+  return findDependencyCycle(new Map(plan.tasks.map((task) => [task.id, task.dependsOnTaskIds])));
+}
+function hasDependencyPath(plan, from, to) {
+  const byId = new Map(plan.tasks.map((task) => [task.id, task]));
+  const queue = [...byId.get(from)?.dependsOnTaskIds ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length) {
+    const next = queue.shift();
+    if (next === to) return true;
+    if (seen.has(next)) continue;
+    seen.add(next);
+    queue.push(...byId.get(next)?.dependsOnTaskIds ?? []);
+  }
+  return false;
+}
 function validateTaskPlan(plan, facts, androidFingerprint) {
   const errors = [];
   const warnings = [];
   if (plan.taskPlanVersion !== TASK_PLAN_VERSION) errors.push(`taskPlanVersion must be ${TASK_PLAN_VERSION}`);
+  if (plan.executionPlanVersion !== EXECUTION_PLAN_VERSION) errors.push(`executionPlanVersion must be ${EXECUTION_PLAN_VERSION}`);
   if (plan.planningModelVersion !== PLANNING_MODEL_VERSION) errors.push(`planningModelVersion must be ${PLANNING_MODEL_VERSION}`);
   if (plan.factsAdapterVersion !== FACTS_ADAPTER_VERSION) errors.push(`factsAdapterVersion must be ${FACTS_ADAPTER_VERSION}`);
   if (plan.plannerPolicyVersion !== PLANNER_POLICY_VERSION) errors.push(`plannerPolicyVersion must be ${PLANNER_POLICY_VERSION}`);
   const fresh = plan.baseline?.factsSha256 === facts.baseline.factsSha256 && plan.baseline?.planningInputSha256 === facts.baseline.planningInputSha256 && plan.baseline?.factsWireVersion === facts.baseline.wireVersion && plan.baseline?.androidFingerprint === androidFingerprint;
   if (!fresh) warnings.push("Task plan baseline does not match current Facts, planning inputs, or Android source fingerprint");
+  const behaviorIds = /* @__PURE__ */ new Set();
+  for (const behavior of plan.behaviorResponsibilities ?? []) {
+    if (!/^behavior:[a-f0-9]{16}$/.test(behavior.id)) errors.push(`invalid behavior id ${behavior.id}`);
+    if (behaviorIds.has(behavior.id)) errors.push(`duplicate behavior id ${behavior.id}`);
+    else behaviorIds.add(behavior.id);
+    if (!behavior.primaryFactRefs?.length) errors.push(`${behavior.id}: primaryFactRefs must not be empty`);
+    if (!behavior.acceptance?.observableOutcome?.trim()) errors.push(`${behavior.id}: observableOutcome is required`);
+    for (const ref of behavior.supportingFactRefs ?? []) if (behavior.primaryFactRefs.includes(ref)) errors.push(`${behavior.id}: ${ref} cannot be both primary and supporting`);
+  }
+  for (const behavior of plan.behaviorResponsibilities ?? []) for (const dependency of behavior.dependsOnBehaviorIds ?? []) {
+    if (!behaviorIds.has(dependency)) errors.push(`${behavior.id}: unknown behavior dependency ${dependency}`);
+    if (dependency === behavior.id) errors.push(`${behavior.id}: behavior cannot depend on itself`);
+  }
+  const expectedPlanningPhase = (plan.behaviorResponsibilities ?? []).some((behavior) => behavior.type === "resolution") ? "resolution" : "execution";
+  if (plan.planningPhase !== expectedPlanningPhase) errors.push(`planningPhase must be ${expectedPlanningPhase}`);
+  const activeBehaviors = (plan.behaviorResponsibilities ?? []).filter((behavior) => expectedPlanningPhase === "execution" || behavior.type === "resolution");
+  const activeBehaviorIds = new Set(activeBehaviors.map((behavior) => behavior.id));
+  if (expectedPlanningPhase === "resolution" && (plan.tasks ?? []).some((task) => task.type !== "resolution")) {
+    errors.push("resolution phase must materialize only Resolution Tasks; Coding Work Items are assembled after Resolution is cleared");
+  }
+  if (expectedPlanningPhase === "execution" && (plan.tasks ?? []).some((task) => task.type === "resolution")) {
+    errors.push("execution phase must not contain Resolution Tasks");
+  }
+  if (expectedPlanningPhase === "resolution" && (plan.pageWorkPackages ?? []).length > 0) {
+    errors.push("resolution phase must not materialize Coding Work Packages");
+  }
+  const behaviorOwners = /* @__PURE__ */ new Map();
+  const behaviorSupporters = /* @__PURE__ */ new Map();
+  for (const behavior of plan.behaviorResponsibilities ?? []) for (const ref of behavior.primaryFactRefs ?? []) behaviorOwners.set(ref, [...behaviorOwners.get(ref) ?? [], behavior.id]);
+  for (const behavior of plan.behaviorResponsibilities ?? []) for (const ref of behavior.supportingFactRefs ?? []) behaviorSupporters.set(ref, [...behaviorSupporters.get(ref) ?? [], behavior.id]);
   const taskIds = /* @__PURE__ */ new Set();
   for (const task of plan.tasks ?? []) {
     if (!/^task:[a-f0-9]{16}$/.test(task.id)) errors.push(`invalid task id ${task.id}`);
     if (taskIds.has(task.id)) errors.push(`duplicate task id ${task.id}`);
     else taskIds.add(task.id);
     if (!task.title?.trim()) errors.push(`${task.id}: title is required`);
+    if (expectedPlanningPhase === "resolution" && task.workPackageId !== null) errors.push(`${task.id}: Resolution Task must not belong to a Work Package`);
+    if (expectedPlanningPhase === "execution" && !task.workPackageId?.trim()) errors.push(`${task.id}: Coding Work Item requires workPackageId`);
+    if (!task.primaryModule?.trim()) errors.push(`${task.id}: primaryModule is required`);
+    if (!task.behaviorIds?.length) errors.push(`${task.id}: behaviorIds must not be empty`);
+    if (expectedPlanningPhase === "resolution" && task.behaviorIds?.length !== 1) errors.push(`${task.id}: Resolution Task must project exactly one Resolution Behavior`);
+    for (const behaviorId of task.behaviorIds ?? []) if (!behaviorIds.has(behaviorId)) errors.push(`${task.id}: unknown behavior ${behaviorId}`);
     if (!task.primaryFactRefs?.length) errors.push(`${task.id}: primaryFactRefs must not be empty`);
     if (!task.acceptance?.observableOutcome?.trim()) errors.push(`${task.id}: observableOutcome is required`);
     if (!task.acceptance?.verificationRequirements?.length) errors.push(`${task.id}: verificationRequirements must not be empty`);
-    const overBudget = task.estimate.factCount > DEFAULT_CLOSURE_BUDGET.maxFactCount || task.estimate.sourceFileCount > DEFAULT_CLOSURE_BUDGET.maxSourceFileCount || task.estimate.traceNodeCount > DEFAULT_CLOSURE_BUDGET.maxTraceNodeCount || task.estimate.estimatedFactTokens > DEFAULT_CLOSURE_BUDGET.maxEstimatedFactTokens;
-    const sourceEntryCount = new Set(task.closure.interactionRefs.map((ref) => facts.effects.find((effect) => effect.id === ref)?.sourceEntryId).filter(Boolean)).size;
-    if (overBudget && sourceEntryCount > 1) errors.push(`${task.id}: merged closure exceeds the planning budget`);
-    else if (overBudget) warnings.push(`${task.id}: single-entry closure exceeds the soft budget and requires paged source context`);
+    const overBudget = task.estimate.behaviorCount > DEFAULT_EXECUTION_BUDGET.maxBehaviorCount || task.estimate.observableOutcomeCount > DEFAULT_EXECUTION_BUDGET.maxObservableOutcomeCount || task.estimate.productionFileCount > DEFAULT_EXECUTION_BUDGET.maxProductionFileCount || task.estimate.testFileCount > DEFAULT_EXECUTION_BUDGET.maxTestFileCount || task.estimate.capabilityCount > DEFAULT_EXECUTION_BUDGET.maxCapabilityCount || task.estimate.factCount > DEFAULT_EXECUTION_BUDGET.maxFactCount || task.estimate.sourceFileCount > DEFAULT_EXECUTION_BUDGET.maxSourceFileCount || task.estimate.traceNodeCount > DEFAULT_EXECUTION_BUDGET.maxTraceNodeCount || task.estimate.estimatedFactTokens > DEFAULT_EXECUTION_BUDGET.maxEstimatedFactTokens;
+    if (overBudget && (task.behaviorIds?.length ?? 0) > 1) errors.push(`${task.id}: merged Coding Work Item exceeds the execution budget`);
+    else if (overBudget) warnings.push(`${task.id}: single-Behavior ${task.type === "resolution" ? "Resolution Task" : "Coding Work Item"} exceeds a soft execution budget; responsibility is preserved and source context must be paged`);
+    const owned = task.writeOwnership?.ownedFiles ?? [];
+    const readOnly = task.writeOwnership?.readOnlyFiles ?? [];
+    const forbidden = task.writeOwnership?.forbiddenGlobalFiles ?? [];
+    for (const file of owned) if (readOnly.includes(file)) errors.push(`${task.id}: ${file} cannot be both owned and read-only`);
+    for (const file of owned) if (forbidden.includes(file)) errors.push(`${task.id}: ${file} cannot be both owned and forbidden`);
+    if (!(task.writeOwnership?.exclusiveScopes?.length || owned.length)) errors.push(`${task.id}: write ownership requires ownedFiles or an exclusive scope`);
+    if (task.readyGate?.writeOwnershipResolved !== Boolean(task.writeOwnership?.exclusiveScopes?.length || owned.length)) errors.push(`${task.id}: writeOwnershipResolved gate disagrees with the contract`);
+    if (task.readyGate?.semanticsResolved !== (task.type === "resolution" || task.closure.unresolvedRefs.length === 0)) errors.push(`${task.id}: semanticsResolved gate disagrees with unresolved refs`);
+    if (task.readyGate?.contextWithinBudget !== (!overBudget || (task.behaviorIds?.length ?? 0) === 1)) errors.push(`${task.id}: contextWithinBudget gate disagrees with execution estimate`);
   }
   for (const task of plan.tasks ?? []) for (const dependency of task.dependsOnTaskIds ?? []) {
     if (!taskIds.has(dependency)) errors.push(`${task.id}: unknown dependency ${dependency}`);
     if (dependency === task.id) errors.push(`${task.id}: task cannot depend on itself`);
   }
+  for (const task of plan.tasks ?? []) {
+    const interfaceProviders = (task.dependencyInterfaces ?? []).map((item) => item.providerTaskId).filter((id) => Boolean(id)).sort();
+    if (JSON.stringify(interfaceProviders) !== JSON.stringify([...task.dependsOnTaskIds ?? []].sort())) errors.push(`${task.id}: dependencyInterfaces do not match dependsOnTaskIds`);
+    for (const dependencyInterface of task.dependencyInterfaces ?? []) {
+      if (dependencyInterface.providerTaskId && !taskIds.has(dependencyInterface.providerTaskId)) errors.push(`${task.id}: dependency Interface references unknown provider ${dependencyInterface.providerTaskId}`);
+    }
+  }
   const cycle = findCycle(plan);
   if (cycle) errors.push(`task dependency cycle: ${cycle.join(" -> ")}`);
   const owners = /* @__PURE__ */ new Map();
@@ -6398,14 +7246,20 @@ function validateTaskPlan(plan, facts, androidFingerprint) {
       supporters.set(ref, [...supporters.get(ref) ?? [], task.id]);
     }
   }
-  const orphanFactRefs = facts.requiredFactRefs.filter((ref) => (owners.get(ref) ?? []).length === 0);
-  for (const ref of orphanFactRefs) errors.push(`required fact has no primary owner: ${ref}`);
+  const activePrimaryFactRefs = uniqueSorted(activeBehaviors.flatMap((behavior) => behavior.primaryFactRefs));
+  const behaviorOrphanFactRefs = facts.requiredFactRefs.filter((ref) => (behaviorOwners.get(ref) ?? []).length === 0);
+  const activeTaskOrphanFactRefs = activePrimaryFactRefs.filter((ref) => (owners.get(ref) ?? []).length === 0);
+  const orphanFactRefs = uniqueSorted([
+    ...behaviorOrphanFactRefs,
+    ...activeTaskOrphanFactRefs.filter((ref) => facts.requiredFactRefs.includes(ref))
+  ]);
+  for (const ref of activeTaskOrphanFactRefs) errors.push(`active Behavior fact has no primary Task owner: ${ref}`);
   for (const [ref, ownerIds] of owners) if (ownerIds.length > 1) errors.push(`fact has multiple primary owners: ${ref} -> ${ownerIds.join(", ")}`);
   for (const [ref, ownerId] of Object.entries(plan.ownership?.primaryOwnerByFactRef ?? {})) {
     if (!taskIds.has(ownerId)) errors.push(`ownership ${ref} references unknown task ${ownerId}`);
     if (!(owners.get(ref) ?? []).includes(ownerId)) errors.push(`ownership map disagrees with task primaryFactRefs for ${ref}`);
   }
-  for (const ref of facts.requiredFactRefs) if (plan.ownership?.primaryOwnerByFactRef?.[ref] !== owners.get(ref)?.[0]) errors.push(`ownership map is missing or incorrect for ${ref}`);
+  for (const ref of activePrimaryFactRefs) if (plan.ownership?.primaryOwnerByFactRef?.[ref] !== owners.get(ref)?.[0]) errors.push(`active Task ownership map is missing or incorrect for ${ref}`);
   for (const [ref, taskIdsForRef] of Object.entries(plan.ownership?.supportingTaskIdsByFactRef ?? {})) {
     const expected = [...supporters.get(ref) ?? []].sort();
     const actual = [...taskIdsForRef ?? []].sort();
@@ -6414,6 +7268,125 @@ function validateTaskPlan(plan, facts, androidFingerprint) {
   for (const [ref, expectedIds] of supporters) {
     if (!(ref in (plan.ownership?.supportingTaskIdsByFactRef ?? {}))) errors.push(`supporting ownership map is missing for ${ref}: ${[...expectedIds].sort().join(", ")}`);
   }
+  const behaviorMembership = /* @__PURE__ */ new Map();
+  for (const task of plan.tasks ?? []) for (const behaviorId of task.behaviorIds ?? []) behaviorMembership.set(behaviorId, [...behaviorMembership.get(behaviorId) ?? [], task.id]);
+  for (const behavior of plan.behaviorResponsibilities ?? []) {
+    const ownersForBehavior = behaviorMembership.get(behavior.id) ?? [];
+    const expectedMembership = activeBehaviorIds.has(behavior.id) ? 1 : 0;
+    if (ownersForBehavior.length !== expectedMembership) errors.push(`${behavior.id}: must belong to ${expectedMembership} ${expectedPlanningPhase === "resolution" ? "Resolution Task" : "Coding Work Item"}, found ${ownersForBehavior.length}`);
+    const task = plan.tasks.find((item) => item.id === ownersForBehavior[0]);
+    if (!task) continue;
+    for (const ref of behavior.primaryFactRefs) if (!task.primaryFactRefs.includes(ref)) errors.push(`${task.id}: missing primary fact ${ref} from ${behavior.id}`);
+    for (const ref of behavior.closure.entryRefs) if (!task.closure.entryRefs.includes(ref)) errors.push(`${task.id}: missing entry ${ref} from ${behavior.id}`);
+    for (const ref of behavior.closure.interactionRefs) if (!task.closure.interactionRefs.includes(ref)) errors.push(`${task.id}: missing interaction ${ref} from ${behavior.id}`);
+  }
+  const behaviorById = new Map((plan.behaviorResponsibilities ?? []).map((behavior) => [behavior.id, behavior]));
+  for (const task of plan.tasks ?? []) {
+    const members = (task.behaviorIds ?? []).map((id) => behaviorById.get(id)).filter((item) => Boolean(item));
+    const expectedPrimary = uniqueSorted(members.flatMap((item) => item.primaryFactRefs));
+    const expectedSupporting = uniqueSorted(members.flatMap((item) => item.supportingFactRefs).filter((ref) => !expectedPrimary.includes(ref)));
+    if (JSON.stringify(expectedPrimary) !== JSON.stringify([...task.primaryFactRefs ?? []].sort())) errors.push(`${task.id}: primaryFactRefs disagree with member Behaviors`);
+    if (JSON.stringify(expectedSupporting) !== JSON.stringify([...task.supportingFactRefs ?? []].sort())) errors.push(`${task.id}: supportingFactRefs disagree with member Behaviors`);
+    for (const key of ["entryRefs", "surfaceRefs", "controlRefs", "interactionRefs", "unresolvedRefs", "warningRefs"]) {
+      const expected = uniqueSorted(members.flatMap((item) => item.closure[key]));
+      if (JSON.stringify(expected) !== JSON.stringify([...task.closure?.[key] ?? []].sort())) errors.push(`${task.id}: closure.${key} disagrees with member Behaviors`);
+    }
+    const expectedOutcomes = uniqueSorted(members.map((item) => item.acceptance.observableOutcome));
+    const expectedRequired = uniqueSorted(members.flatMap((item) => item.acceptance.requiredFactRefs));
+    const expectedReports = uniqueSorted(members.flatMap((item) => item.acceptance.reportRefs));
+    if (JSON.stringify(expectedOutcomes) !== JSON.stringify([...task.acceptance?.observableOutcomes ?? []].sort())) errors.push(`${task.id}: observableOutcomes disagree with member Behaviors`);
+    if (JSON.stringify(expectedRequired) !== JSON.stringify([...task.acceptance?.requiredFactRefs ?? []].sort())) errors.push(`${task.id}: requiredFactRefs disagree with member Behaviors`);
+    if (JSON.stringify(expectedReports) !== JSON.stringify([...task.acceptance?.reportRefs ?? []].sort())) errors.push(`${task.id}: reportRefs disagree with member Behaviors`);
+    if (members.some((member) => member.type !== task.type)) errors.push(`${task.id}: task type disagrees with a member Behavior`);
+  }
+  for (const ref of facts.requiredFactRefs) {
+    const expectedBehavior = behaviorOwners.get(ref)?.[0];
+    if (!expectedBehavior || behaviorOwners.get(ref)?.length !== 1) errors.push(`required fact must have exactly one Behavior owner: ${ref}`);
+    if (plan.behaviorOwnership?.primaryOwnerByFactRef?.[ref] !== expectedBehavior) errors.push(`behavior ownership map is missing or incorrect for ${ref}`);
+  }
+  for (const [ref, behaviorId] of Object.entries(plan.behaviorOwnership?.primaryOwnerByFactRef ?? {})) {
+    if (!behaviorIds.has(behaviorId)) errors.push(`behavior ownership ${ref} references unknown Behavior ${behaviorId}`);
+    if (!(behaviorOwners.get(ref) ?? []).includes(behaviorId)) errors.push(`behavior ownership map disagrees with Behavior primaryFactRefs for ${ref}`);
+  }
+  for (const [ref, expectedIds] of behaviorSupporters) {
+    const actual = [...plan.behaviorOwnership?.supportingBehaviorIdsByFactRef?.[ref] ?? []].sort();
+    if (JSON.stringify(actual) !== JSON.stringify([...expectedIds].sort())) errors.push(`behavior supporting ownership map is missing or incorrect for ${ref}`);
+  }
+  for (const [ref, actualIds] of Object.entries(plan.behaviorOwnership?.supportingBehaviorIdsByFactRef ?? {})) {
+    const expected = [...behaviorSupporters.get(ref) ?? []].sort();
+    if (JSON.stringify([...actualIds].sort()) !== JSON.stringify(expected)) errors.push(`behavior supporting ownership map disagrees with Behaviors for ${ref}`);
+  }
+  const packageIds = /* @__PURE__ */ new Set();
+  const knownPackageIds = new Set((plan.pageWorkPackages ?? []).map((workPackage) => workPackage.id));
+  const packageMembership = /* @__PURE__ */ new Map();
+  const canonicalBySurface = canonicalPageRefs(facts);
+  for (const workPackage of plan.pageWorkPackages ?? []) {
+    if (!/^package:[a-f0-9]{16}$/.test(workPackage.id)) errors.push(`invalid work package id ${workPackage.id}`);
+    if (packageIds.has(workPackage.id)) errors.push(`duplicate work package id ${workPackage.id}`);
+    else packageIds.add(workPackage.id);
+    for (const dependency of workPackage.dependsOnPackageIds ?? []) {
+      if (!knownPackageIds.has(dependency)) errors.push(`${workPackage.id}: unknown Page Work Package dependency ${dependency}`);
+      if (dependency === workPackage.id) errors.push(`${workPackage.id}: Page Work Package cannot depend on itself`);
+    }
+    for (const taskId2 of workPackage.workItemIds ?? []) {
+      if (!taskIds.has(taskId2)) errors.push(`${workPackage.id}: unknown Coding Work Item ${taskId2}`);
+      packageMembership.set(taskId2, [...packageMembership.get(taskId2) ?? [], workPackage.id]);
+    }
+    if ((workPackage.workItemIds ?? []).some((taskId2) => plan.tasks.find((task) => task.id === taskId2)?.type === "resolution")) errors.push(`${workPackage.id}: Resolution Tasks must not enter a Coding Work Package`);
+    if (workPackage.canonicalPageRef !== null && !facts.surfaces.some((surface) => surface.id === workPackage.canonicalPageRef)) errors.push(`${workPackage.id}: unknown canonical page ${workPackage.canonicalPageRef}`);
+    for (const surfaceRef of workPackage.surfaceRefs ?? []) {
+      if (!facts.surfaces.some((surface) => surface.id === surfaceRef)) errors.push(`${workPackage.id}: unknown surface ${surfaceRef}`);
+      if ((canonicalBySurface[surfaceRef] ?? surfaceRef) !== workPackage.canonicalPageRef) errors.push(`${workPackage.id}: ${surfaceRef} does not belong to canonical page ${workPackage.canonicalPageRef}`);
+    }
+    if (workPackage.serialLane) for (let index = 1; index < workPackage.workItemIds.length; index++) {
+      if (!hasDependencyPath(plan, workPackage.workItemIds[index], workPackage.workItemIds[index - 1])) errors.push(`${workPackage.id}: serial lane is missing dependency ${workPackage.workItemIds[index]} -> ${workPackage.workItemIds[index - 1]}`);
+    }
+    const expectedScopes = [...new Set(plan.tasks.filter((task) => task.workPackageId === workPackage.id).flatMap((task) => task.writeOwnership?.exclusiveScopes ?? []))].sort();
+    if (JSON.stringify([...workPackage.exclusiveScopes ?? []].sort()) !== JSON.stringify(expectedScopes)) errors.push(`${workPackage.id}: exclusiveScopes disagree with member Work Items`);
+    const expectedDependencies = uniqueSorted((workPackage.workItemIds ?? []).flatMap((taskId2) => plan.tasks.find((task) => task.id === taskId2)?.dependsOnTaskIds ?? []).map((taskId2) => plan.tasks.find((task) => task.id === taskId2)?.workPackageId).filter((packageId) => Boolean(packageId && packageId !== workPackage.id)));
+    if (JSON.stringify([...workPackage.dependsOnPackageIds ?? []].sort()) !== JSON.stringify(expectedDependencies)) errors.push(`${workPackage.id}: dependsOnPackageIds disagree with cross-package Work Item dependencies`);
+  }
+  const packageCycle = findDependencyCycle(new Map((plan.pageWorkPackages ?? []).map((workPackage) => [workPackage.id, workPackage.dependsOnPackageIds ?? []])));
+  if (packageCycle) errors.push(`Page Work Package dependency cycle: ${packageCycle.join(" -> ")}`);
+  for (const task of plan.tasks ?? []) {
+    const memberships = packageMembership.get(task.id) ?? [];
+    if (task.type === "resolution") {
+      if (memberships.length > 0 || task.workPackageId !== null) errors.push(`${task.id}: Resolution Task must not have Work Package membership`);
+      continue;
+    }
+    if (memberships.length !== 1 || memberships[0] !== task.workPackageId) errors.push(`${task.id}: work package membership is missing or inconsistent`);
+    const workPackage = plan.pageWorkPackages?.find((item) => item.id === task.workPackageId);
+    if (workPackage && workPackage.canonicalPageRef !== task.canonicalPageRef) errors.push(`${task.id}: canonicalPageRef disagrees with its Work Package`);
+  }
+  const conflictEdges = /* @__PURE__ */ new Map();
+  for (const edge of plan.fileConflictEdges ?? []) {
+    if (!taskIds.has(edge.leftTaskId) || !taskIds.has(edge.rightTaskId)) errors.push(`file conflict references an unknown task: ${edge.leftTaskId}, ${edge.rightTaskId}`);
+    if (edge.leftTaskId === edge.rightTaskId) errors.push(`${edge.leftTaskId}: file conflict cannot reference itself`);
+    if (!edge.reasons?.length) errors.push(`${edge.leftTaskId}/${edge.rightTaskId}: file conflict requires a reason`);
+    const key = [edge.leftTaskId, edge.rightTaskId].sort().join(":");
+    if (conflictEdges.has(key)) errors.push(`duplicate file conflict edge: ${key}`);
+    else conflictEdges.set(key, edge);
+  }
+  for (let leftIndex = 0; leftIndex < (plan.tasks ?? []).length; leftIndex++) for (let rightIndex = leftIndex + 1; rightIndex < plan.tasks.length; rightIndex++) {
+    const left = plan.tasks[leftIndex];
+    const right = plan.tasks[rightIndex];
+    const leftOwned = left.writeOwnership?.ownedFiles ?? [];
+    const rightOwned = right.writeOwnership?.ownedFiles ?? [];
+    const leftScopes = left.writeOwnership?.exclusiveScopes ?? [];
+    const rightScopes = right.writeOwnership?.exclusiveScopes ?? [];
+    const overlappingFiles = leftOwned.filter((file) => rightOwned.includes(file));
+    const overlappingScopes = leftScopes.filter((scope) => rightScopes.includes(scope));
+    const hasConflict = overlappingFiles.length > 0 || overlappingScopes.length > 0;
+    const edge = conflictEdges.get([left.id, right.id].sort().join(":"));
+    if (hasConflict && !edge) errors.push(`${left.id} and ${right.id}: overlapping write ownership requires a conflict edge`);
+    if (!hasConflict && edge) errors.push(`${left.id} and ${right.id}: file conflict edge has no overlapping write ownership`);
+    if (edge) {
+      const expectedReasons = [...overlappingFiles.map((file) => `owned-file:${file}`), ...overlappingScopes.map((scope) => `exclusive-scope:${scope}`)].sort();
+      if (JSON.stringify([...edge.reasons].sort()) !== JSON.stringify(expectedReasons)) errors.push(`${left.id} and ${right.id}: file conflict reasons disagree with write ownership`);
+    }
+    if (hasConflict && !(hasDependencyPath(plan, left.id, right.id) || hasDependencyPath(plan, right.id, left.id))) errors.push(`${left.id} and ${right.id}: file conflict is not serialized`);
+    if ((left.conflictsWithTaskIds ?? []).includes(right.id) !== hasConflict || (right.conflictsWithTaskIds ?? []).includes(left.id) !== hasConflict) errors.push(`${left.id} and ${right.id}: conflictsWithTaskIds disagrees with write ownership`);
+  }
   const knownRefs = /* @__PURE__ */ new Set([...facts.requiredFactRefs, ...facts.issues.map((issue) => issue.id)]);
   const entryRefs = new Set(facts.entries.map((entry) => entry.id));
   const surfaceRefs = new Set(facts.surfaces.map((surface) => surface.id));
@@ -6447,16 +7420,16 @@ function validateTaskPlan(plan, facts, androidFingerprint) {
 }
 
 // src/planning/runtime.ts
-function readJson6(file) {
+function readJson7(file) {
   try {
-    return JSON.parse(fs27.readFileSync(file, "utf8"));
+    return JSON.parse(fs28.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
 }
 function reportItems(projectRoot) {
   const root = path34.join(migrationDirectory(projectRoot), "report");
-  const index = readJson6(path34.join(root, "index.json"));
+  const index = readJson7(path34.join(root, "index.json"));
   const out = /* @__PURE__ */ new Map();
   if (!index) return out;
   const files = [
@@ -6466,7 +7439,7 @@ function reportItems(projectRoot) {
     index.discoveriesFile
   ].filter((value) => typeof value === "string");
   for (const relative2 of files) {
-    const document = readJson6(path34.join(root, relative2));
+    const document = readJson7(path34.join(root, relative2));
     if (!document) continue;
     const values = [document.page, ...document.controls ?? [], ...document.entries ?? [], ...document.interactions ?? [], ...document.items ?? []].filter(Boolean);
     for (const item of values) if (typeof item.ref === "string") out.set(item.ref, { ref: item.ref, status: item.status ?? "pending", testEvidence: Array.isArray(item.testEvidence) ? item.testEvidence : [] });
@@ -6477,7 +7450,7 @@ function managedReceipt(projectRoot, reference) {
   const managedRoot = path34.resolve(migrationDirectory(projectRoot), "evidence", "managed");
   const absolute = reference.replaceAll("\\", "/").startsWith(".migration/") ? path34.resolve(migrationWorkspaceRoot(projectRoot), reference) : path34.resolve(projectRoot, reference);
   if (absolute !== managedRoot && !absolute.startsWith(`${managedRoot}${path34.sep}`)) return null;
-  return readJson6(absolute);
+  return readJson7(absolute);
 }
 function freshTaskEvidence(projectRoot, reference, factsSha256, harmonyFingerprint) {
   const receipt = managedReceipt(projectRoot, reference);
@@ -6503,7 +7476,24 @@ function stateReasons(task, state, dependencyStates) {
     })(),
     task.estimate.downstreamUnlockCount > 0 ? `\u5B8C\u6210\u540E\u53EF\u89E3\u9664 ${task.estimate.downstreamUnlockCount} \u4E2A\u4E0B\u6E38\u4EFB\u52A1` : null
   ]);
-  if (state === "blocked") return dependencyStates.length ? ["\u4F9D\u8D56\u4EFB\u52A1\u5C1A\u672A\u53D6\u5F97\u65B0\u9C9C\u7684\u5B9A\u5411\u9A8C\u8BC1\u8BC1\u636E"] : ["\u4EFB\u52A1\u5BF9\u5E94\u7684\u62A5\u544A\u9879\u6216\u8BA1\u5212\u6821\u9A8C\u4ECD\u5904\u4E8E\u963B\u585E\u72B6\u6001"];
+  if (state === "blocked") {
+    const gate = task.readyGate ?? {
+      semanticsResolved: false,
+      dependencyInterfacesStable: false,
+      writeOwnershipResolved: false,
+      contextWithinBudget: false,
+      acceptanceExecutable: false
+    };
+    return uniqueSorted([
+      dependencyStates.length ? "\u4F9D\u8D56\u4EFB\u52A1\u5C1A\u672A\u53D6\u5F97\u65B0\u9C9C\u7684\u5B9A\u5411\u9A8C\u8BC1\u8BC1\u636E" : null,
+      !gate.semanticsResolved ? "\u4ECD\u6709\u672A\u88C1\u51B3\u8BED\u4E49\u95EE\u9898" : null,
+      !gate.dependencyInterfacesStable ? "\u4E0A\u6E38 Module Interface \u5C1A\u672A\u7A33\u5B9A" : null,
+      !gate.writeOwnershipResolved ? "\u5199\u5165\u6587\u4EF6\u6216\u72EC\u5360\u8303\u56F4\u5C1A\u672A\u5206\u914D" : null,
+      !gate.contextWithinBudget ? "\u5185\u90E8 Work Item \u95ED\u5305\u8D85\u51FA\u5F53\u524D\u6267\u884C\u9884\u7B97" : null,
+      !gate.acceptanceExecutable ? "\u9A8C\u6536\u6761\u4EF6\u5F53\u524D\u4E0D\u53EF\u6267\u884C" : null,
+      !dependencyStates.length && Object.values(gate).every(Boolean) ? "\u4EFB\u52A1\u5BF9\u5E94\u7684\u62A5\u544A\u9879\u6216\u8BA1\u5212\u6821\u9A8C\u4ECD\u5904\u4E8E\u963B\u585E\u72B6\u6001" : null
+    ]);
+  }
   if (state === "implemented") return ["\u5B9E\u73B0\u6620\u5C04\u5DF2\u5B58\u5728\uFF0C\u4F46\u5B9A\u5411\u8BBE\u5907\u9A8C\u8BC1\u5C1A\u672A\u5B8C\u6210"];
   if (state === "stale") return ["\u62A5\u544A\u58F0\u660E\u7684\u6D4B\u8BD5\u8BC1\u636E\u4E0E\u5F53\u524D Facts \u6216 HarmonyOS \u6E90\u7801\u4E0D\u4E00\u81F4"];
   if (state === "locally-verified") return ["\u5F53\u524D\u4EFB\u52A1\u5DF2\u6709\u65B0\u9C9C\u5B9A\u5411\u8BBE\u5907\u8BC1\u636E"];
@@ -6512,25 +7502,72 @@ function stateReasons(task, state, dependencyStates) {
 }
 function rankReady(tasks, states) {
   const priority = (task) => {
-    if (task.type === "resolution") {
-      const blocksLauncher = task.closure.unresolvedRefs.some((ref) => ref.includes("launcher"));
-      return blocksLauncher || task.estimate.downstreamUnlockCount > 0 ? 0 : 5;
-    }
+    if (task.type === "resolution") return 0;
     const order = { bootstrap: 1, journey: 2, capability: 3, assembly: 4, regression: 6 };
     return order[task.type] ?? 6;
   };
   return tasks.filter((task) => states.get(task.id) === "ready").sort((a, b) => priority(a) - priority(b) || b.estimate.downstreamUnlockCount - a.estimate.downstreamUnlockCount || a.estimate.estimatedFactTokens - b.estimate.estimatedFactTokens || a.id.localeCompare(b.id));
 }
+function completedState(state) {
+  return ["locally-verified", "globally-verified"].includes(state);
+}
+function aggregatePackageOwnState(states) {
+  if (states.length > 0 && states.every((state) => state === "globally-verified")) return "globally-verified";
+  if (states.length > 0 && states.every(completedState)) return "locally-verified";
+  if (states.some((state) => state === "blocked")) return "blocked";
+  if (states.some((state) => state === "stale")) return "stale";
+  if (states.length > 0 && states.every((state) => ["implemented", "locally-verified", "globally-verified"].includes(state))) return "implemented";
+  return "pending";
+}
+function packageStateReasons(workPackage, state, dependencyStates, ownStates) {
+  if (state === "ready") return [
+    `\u9875\u9762\u5305\u5C06\u5728\u4E00\u6B21\u5B9E\u73B0 epoch \u5185\u6309\u51BB\u7ED3\u987A\u5E8F\u5B8C\u6210 ${workPackage.workItemIds.length} \u4E2A Work Item`,
+    "\u8DE8\u9875\u9762\u4F9D\u8D56\u5DF2\u6EE1\u8DB3\uFF0C\u53EF\u52A0\u8F7D\u9875\u9762\u7EA7\u6A21\u578B\u8F93\u5165"
+  ];
+  if (state === "blocked") return uniqueSorted([
+    dependencyStates.some((dependency) => !completedState(dependency)) ? "\u524D\u7F6E Page Work Package \u5C1A\u672A\u53D6\u5F97\u65B0\u9C9C\u7684\u5B9A\u5411\u9A8C\u8BC1\u8BC1\u636E" : null,
+    ownStates.some((own) => own === "blocked") ? "\u9875\u9762\u5305\u5185\u5B58\u5728\u88AB\u62A5\u544A\u6807\u8BB0\u4E3A blocked \u7684\u884C\u4E3A" : null,
+    !dependencyStates.length && !ownStates.some((own) => own === "blocked") ? "\u9875\u9762\u5305\u7684\u9759\u6001 Ready Gate \u672A\u5168\u90E8\u901A\u8FC7" : null
+  ]);
+  if (state === "implemented") return ["\u9875\u9762\u5305\u5185\u5168\u90E8\u884C\u4E3A\u5DF2\u6709\u5B9E\u73B0\u6620\u5C04\uFF0C\u4F46\u4ECD\u7F3A\u5C11\u5B8C\u6574\u7684\u5B9A\u5411\u8BBE\u5907\u9A8C\u8BC1"];
+  if (state === "stale") return ["\u9875\u9762\u5305\u5185\u81F3\u5C11\u4E00\u9879\u9A8C\u8BC1\u8BC1\u636E\u4E0E\u5F53\u524D Facts \u6216 HarmonyOS \u6E90\u7801\u4E0D\u4E00\u81F4"];
+  if (state === "locally-verified") return ["\u9875\u9762\u5305\u5185\u5168\u90E8\u884C\u4E3A\u5747\u6709\u65B0\u9C9C\u5B9A\u5411\u8BBE\u5907\u8BC1\u636E"];
+  if (state === "globally-verified") return ["\u9875\u9762\u5305\u5185\u5168\u90E8\u884C\u4E3A\u53CA\u5168\u91CF\u56DE\u5F52\u8BC1\u636E\u5747\u65B0\u9C9C"];
+  return [];
+}
+function packageDownstreamCounts(packages) {
+  const children = /* @__PURE__ */ new Map();
+  for (const workPackage of packages) for (const dependency of workPackage.dependsOnPackageIds) children.set(dependency, [...children.get(dependency) ?? [], workPackage.id]);
+  const result = /* @__PURE__ */ new Map();
+  for (const workPackage of packages) {
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [...children.get(workPackage.id) ?? []];
+    while (queue.length) {
+      const next = queue.shift();
+      if (seen.has(next)) continue;
+      seen.add(next);
+      queue.push(...children.get(next) ?? []);
+    }
+    result.set(workPackage.id, seen.size);
+  }
+  return result;
+}
 function emptyTaskPlanSnapshot(error) {
   return {
     present: false,
     valid: false,
     fresh: false,
     taskPlanSha256: null,
+    planningPhase: null,
     totalTasks: 0,
+    resolutionTasks: 0,
+    totalTargets: 0,
+    readyTargets: 0,
+    completedTargets: 0,
     readyTasks: 0,
     blockedTasks: 0,
     completedTasks: 0,
+    recommendedTargetId: null,
     recommendedTaskId: null,
     alternatives: [],
     reasons: {},
@@ -6539,7 +7576,8 @@ function emptyTaskPlanSnapshot(error) {
     orphanFactRefs: [],
     errors: error ? [error] : [],
     warnings: [],
-    tasks: []
+    tasks: [],
+    targets: []
   };
 }
 function inspectCompiledTaskPlan(projectRootArgument, facts, source) {
@@ -6548,6 +7586,7 @@ function inspectCompiledTaskPlan(projectRootArgument, facts, source) {
   if (!plan) return emptyTaskPlanSnapshot();
   const validation = validateTaskPlan(plan, facts, source.androidFingerprint);
   const reports = reportItems(projectRoot);
+  const ownStates = new Map(plan.tasks.map((task) => [task.id, initialState(task, reports, projectRoot, plan, source)]));
   const states = /* @__PURE__ */ new Map();
   const resolving = /* @__PURE__ */ new Set();
   const byId = new Map(plan.tasks.map((task) => [task.id, task]));
@@ -6557,12 +7596,13 @@ function inspectCompiledTaskPlan(projectRootArgument, facts, source) {
     if (!validation.fresh) return "stale";
     if (resolving.has(task.id)) return "blocked";
     resolving.add(task.id);
-    const own = initialState(task, reports, projectRoot, plan, source);
+    const own = ownStates.get(task.id);
     let state = own;
     if (own === "pending") {
       const dependencyStates = task.dependsOnTaskIds.map((id) => byId.get(id)).filter((item) => Boolean(item)).map(resolveState);
       const satisfied = dependencyStates.every((value) => ["locally-verified", "globally-verified"].includes(value));
-      state = satisfied ? "ready" : "blocked";
+      const readyGatePassed = Object.values(task.readyGate).every(Boolean);
+      state = satisfied && readyGatePassed ? "ready" : "blocked";
     }
     resolving.delete(task.id);
     states.set(task.id, state);
@@ -6575,8 +7615,59 @@ function inspectCompiledTaskPlan(projectRootArgument, facts, source) {
     const dependencyStates = task.dependsOnTaskIds.map((id) => states.get(id)).filter(Boolean);
     return { taskId: task.id, state, reasons: stateReasons(task, state, dependencyStates) };
   });
-  const reasons = Object.fromEntries(runtimeItems.filter((item) => item.reasons.length).map((item) => [item.taskId, item.reasons]));
-  const ownerCount = facts.requiredFactRefs.filter((ref) => plan.ownership.primaryOwnerByFactRef[ref]).length;
+  let targets;
+  let orderedReadyTargetIds;
+  if (plan.planningPhase === "resolution") {
+    targets = runtimeItems.map((item) => ({ targetId: item.taskId, kind: "resolution-task", state: item.state, reasons: item.reasons, workItemIds: [item.taskId] }));
+    orderedReadyTargetIds = ready.map((task) => task.id);
+  } else {
+    const packageById = new Map(plan.pageWorkPackages.map((workPackage) => [workPackage.id, workPackage]));
+    const packageStates = /* @__PURE__ */ new Map();
+    const packageResolving = /* @__PURE__ */ new Set();
+    const resolvePackageState = (workPackage) => {
+      if (packageStates.has(workPackage.id)) return packageStates.get(workPackage.id);
+      if (!validation.valid) return "blocked";
+      if (!validation.fresh) return "stale";
+      if (packageResolving.has(workPackage.id)) return "blocked";
+      packageResolving.add(workPackage.id);
+      const memberTasks = workPackage.workItemIds.map((id) => byId.get(id)).filter((task) => Boolean(task));
+      const memberOwnStates = memberTasks.map((task) => ownStates.get(task.id));
+      const own = aggregatePackageOwnState(memberOwnStates);
+      let state = own;
+      if (own === "pending") {
+        const dependencyStates = workPackage.dependsOnPackageIds.map((id) => packageById.get(id)).filter((item) => Boolean(item)).map(resolvePackageState);
+        const dependenciesSatisfied = dependencyStates.every(completedState);
+        const readyGatePassed = memberTasks.every((task) => Object.values(task.readyGate).every(Boolean));
+        state = dependenciesSatisfied && readyGatePassed ? "ready" : "blocked";
+      }
+      packageResolving.delete(workPackage.id);
+      packageStates.set(workPackage.id, state);
+      return state;
+    };
+    for (const workPackage of plan.pageWorkPackages) resolvePackageState(workPackage);
+    targets = plan.pageWorkPackages.map((workPackage) => {
+      const state = packageStates.get(workPackage.id);
+      const dependencyStates = workPackage.dependsOnPackageIds.map((id) => packageStates.get(id)).filter(Boolean);
+      const memberOwnStates = workPackage.workItemIds.map((id) => ownStates.get(id)).filter(Boolean);
+      return { targetId: workPackage.id, kind: "page-work-package", state, reasons: packageStateReasons(workPackage, state, dependencyStates, memberOwnStates), workItemIds: workPackage.workItemIds };
+    });
+    const downstream = packageDownstreamCounts(plan.pageWorkPackages);
+    const targetById = new Map(targets.map((target) => [target.targetId, target]));
+    orderedReadyTargetIds = plan.pageWorkPackages.filter((workPackage) => targetById.get(workPackage.id)?.state === "ready").sort((left, right) => {
+      const leftTasks = left.workItemIds.map((id) => byId.get(id)).filter((task) => Boolean(task));
+      const rightTasks = right.workItemIds.map((id) => byId.get(id)).filter((task) => Boolean(task));
+      const leftBootstrap = leftTasks.some((task) => task.type === "bootstrap") ? 0 : 1;
+      const rightBootstrap = rightTasks.some((task) => task.type === "bootstrap") ? 0 : 1;
+      const leftTokens = leftTasks.reduce((total, task) => total + task.estimate.estimatedFactTokens, 0);
+      const rightTokens = rightTasks.reduce((total, task) => total + task.estimate.estimatedFactTokens, 0);
+      return leftBootstrap - rightBootstrap || (downstream.get(right.id) ?? 0) - (downstream.get(left.id) ?? 0) || leftTokens - rightTokens || left.id.localeCompare(right.id);
+    }).map((workPackage) => workPackage.id);
+  }
+  const reasons = Object.fromEntries([
+    ...runtimeItems.filter((item) => item.reasons.length).map((item) => [item.taskId, item.reasons]),
+    ...targets.filter((item) => item.reasons.length).map((item) => [item.targetId, item.reasons])
+  ]);
+  const ownerCount = facts.requiredFactRefs.filter((ref) => plan.behaviorOwnership.primaryOwnerByFactRef[ref]).length;
   const behaviorTasks = plan.tasks.filter((task) => task.type !== "resolution");
   const closedTasks = behaviorTasks.filter((task) => !task.closure.requiresSourceReview && (task.closure.interactionRefs.length > 0 || task.type === "bootstrap" && task.closure.surfaceRefs.length > 0)).length;
   return {
@@ -6584,19 +7675,26 @@ function inspectCompiledTaskPlan(projectRootArgument, facts, source) {
     valid: validation.valid,
     fresh: validation.fresh,
     taskPlanSha256: validation.taskPlanSha256,
+    planningPhase: plan.planningPhase,
     totalTasks: plan.tasks.length,
+    resolutionTasks: plan.tasks.filter((task) => task.type === "resolution").length,
+    totalTargets: targets.length,
+    readyTargets: orderedReadyTargetIds.length,
+    completedTargets: targets.filter((item) => completedState(item.state)).length,
     readyTasks: ready.length,
     blockedTasks: runtimeItems.filter((item) => ["blocked", "stale"].includes(item.state)).length,
-    completedTasks: runtimeItems.filter((item) => ["locally-verified", "globally-verified"].includes(item.state)).length,
-    recommendedTaskId: ready[0]?.id ?? null,
-    alternatives: ready.slice(1, 4).map((task) => task.id),
+    completedTasks: runtimeItems.filter((item) => completedState(item.state)).length,
+    recommendedTargetId: orderedReadyTargetIds[0] ?? null,
+    recommendedTaskId: plan.planningPhase === "resolution" ? orderedReadyTargetIds[0] ?? null : null,
+    alternatives: orderedReadyTargetIds.slice(1, 4),
     reasons,
     ownershipCoverage: facts.requiredFactRefs.length ? ownerCount / facts.requiredFactRefs.length : 1,
-    closureCoverage: behaviorTasks.length ? closedTasks / behaviorTasks.length : 1,
+    closureCoverage: plan.planningPhase === "resolution" ? 0 : behaviorTasks.length ? closedTasks / behaviorTasks.length : 1,
     orphanFactRefs: validation.orphanFactRefs,
     errors: validation.errors,
     warnings: validation.warnings,
-    tasks: runtimeItems
+    tasks: runtimeItems,
+    targets
   };
 }
 
@@ -6605,10 +7703,10 @@ function createTaskPlanningModule(factsSource = v2PlanningFactsSource) {
   return {
     compile(projectRoot, options) {
       const facts = factsSource.load(projectRoot);
-      const plan = compileFromPlanningFacts(facts, options.androidFingerprint);
+      const plan = compileFromPlanningFacts(facts, options.androidFingerprint, loadExecutionPlanningContext(projectRoot));
       const validation = validateTaskPlan(plan, facts, options.androidFingerprint);
       if (!validation.valid || !validation.fresh) throw new Error(`Task plan compilation failed: ${[...validation.errors, ...validation.warnings].join("; ")}`);
-      writeTaskPlan(projectRoot, plan);
+      writeTaskPlan(projectRoot, plan, facts);
       return plan;
     },
     inspect(projectRoot, source) {
@@ -6620,19 +7718,19 @@ function createTaskPlanningModule(factsSource = v2PlanningFactsSource) {
         return { ...emptyTaskPlanSnapshot(error instanceof Error ? error.message : String(error)), present: hasTaskPlan(projectRoot) };
       }
     },
-    materialize(projectRoot, task, request) {
+    materialize(projectRoot, target, request) {
       const facts = factsSource.load(projectRoot);
       const plan = readTaskPlan(projectRoot);
       if (!plan) throw new Error("Task plan is not present; run droid2hmos task plan first");
       const validation = validateTaskPlan(plan, facts, request.source.androidFingerprint);
       if (!validation.valid || !validation.fresh) throw new Error(`Task plan is invalid or stale: ${[...validation.errors, ...validation.warnings].join("; ")}`);
-      let taskId = task;
-      if (task === "next") {
+      let targetId = target;
+      if (target === "next") {
         const snapshot = inspectCompiledTaskPlan(projectRoot, facts, request.source);
-        if (!snapshot.recommendedTaskId) throw new Error("No ready task is available");
-        taskId = snapshot.recommendedTaskId;
+        if (!snapshot.recommendedTargetId) throw new Error("No ready execution target is available");
+        targetId = snapshot.recommendedTargetId;
       }
-      return materializeEnvelope(plan, facts, taskId, request);
+      return materializeEnvelope(plan, facts, targetId, request);
     }
   };
 }
@@ -6648,9 +7746,7 @@ var actions = [
   "init",
   "analyze:android",
   "analyze:harmony",
-  "build:android",
   "build:harmony",
-  "test:android",
   "test:harmony:targeted",
   "test:harmony:all",
   "report:init",
@@ -6672,9 +7768,9 @@ var actions = [
   "complete"
 ];
 var ignoredDirectories = /* @__PURE__ */ new Set([".git", ".gradle", ".hvigor", ".idea", ".migration", ".codegraph-appgraph", "build", "node_modules", "oh_modules"]);
-function readJson7(file) {
+function readJson8(file) {
   try {
-    return JSON.parse(fs28.readFileSync(file, "utf8"));
+    return JSON.parse(fs29.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
@@ -6691,11 +7787,11 @@ function sha2563(value) {
   return createHash8("sha256").update(typeof value === "string" ? value : stableJson2(value)).digest("hex");
 }
 function hashDirectory(root, excludedRoots = []) {
-  if (!root || !fs28.existsSync(root) || !fs28.statSync(root).isDirectory()) return null;
+  if (!root || !fs29.existsSync(root) || !fs29.statSync(root).isDirectory()) return null;
   const excluded = excludedRoots.map((value) => path35.resolve(value));
   const hash2 = createHash8("sha256");
   const visit = (directory) => {
-    const entries = fs28.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    const entries = fs29.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
       const absolute = path35.join(directory, entry.name);
       if (entry.isDirectory() && (ignoredDirectories.has(entry.name) || excluded.some((value) => absolute === value || absolute.startsWith(`${value}${path35.sep}`)))) continue;
@@ -6705,10 +7801,10 @@ function hashDirectory(root, excludedRoots = []) {
         hash2.update(`d:${relative2}\0`);
         visit(absolute);
       } else if (entry.isSymbolicLink()) {
-        hash2.update(`l:${relative2}\0${fs28.readlinkSync(absolute)}\0`);
+        hash2.update(`l:${relative2}\0${fs29.readlinkSync(absolute)}\0`);
       } else if (entry.isFile()) {
         hash2.update(`f:${relative2}\0`);
-        hash2.update(fs28.readFileSync(absolute));
+        hash2.update(fs29.readFileSync(absolute));
         hash2.update("\0");
       }
     }
@@ -6732,21 +7828,21 @@ function androidProjectFor(projectRoot, config) {
   return path35.isAbsolute(configured) ? configured : path35.resolve(projectRoot, configured);
 }
 function isAndroidProject(root) {
-  if (!fs28.existsSync(root) || !fs28.statSync(root).isDirectory()) return false;
-  const hasBuildRoot = ["settings.gradle", "settings.gradle.kts", "build.gradle", "build.gradle.kts", "gradlew", "gradlew.bat"].some((name) => fs28.existsSync(path35.join(root, name)));
+  if (!fs29.existsSync(root) || !fs29.statSync(root).isDirectory()) return false;
+  const hasBuildRoot = ["settings.gradle", "settings.gradle.kts", "build.gradle", "build.gradle.kts", "gradlew", "gradlew.bat"].some((name) => fs29.existsSync(path35.join(root, name)));
   if (!hasBuildRoot) return false;
-  if (fs28.existsSync(path35.join(root, "app", "src", "main", "AndroidManifest.xml"))) return true;
-  return fs28.readdirSync(root, { withFileTypes: true }).some((entry) => entry.isDirectory() && !ignoredDirectories.has(entry.name) && fs28.existsSync(path35.join(root, entry.name, "src", "main", "AndroidManifest.xml")));
+  if (fs29.existsSync(path35.join(root, "app", "src", "main", "AndroidManifest.xml"))) return true;
+  return fs29.readdirSync(root, { withFileTypes: true }).some((entry) => entry.isDirectory() && !ignoredDirectories.has(entry.name) && fs29.existsSync(path35.join(root, entry.name, "src", "main", "AndroidManifest.xml")));
 }
 function androidProjectCandidates(root) {
-  if (!fs28.existsSync(root) || !fs28.statSync(root).isDirectory()) return [];
-  return fs28.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !ignoredDirectories.has(entry.name)).map((entry) => path35.join(root, entry.name)).filter(isAndroidProject).sort();
+  if (!fs29.existsSync(root) || !fs29.statSync(root).isDirectory()) return [];
+  return fs29.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !ignoredDirectories.has(entry.name)).map((entry) => path35.join(root, entry.name)).filter(isAndroidProject).sort();
 }
 function evidenceRoot(projectRoot) {
   return path35.join(migrationDirectory(projectRoot), "evidence");
 }
 function evidenceIndex(projectRoot) {
-  return readJson7(path35.join(evidenceRoot(projectRoot), "index.json")) ?? { evidenceIndexVersion: "1.0.0", latestByAction: {} };
+  return readJson8(path35.join(evidenceRoot(projectRoot), "index.json")) ?? { evidenceIndexVersion: "1.0.0", latestByAction: {} };
 }
 function projectRelative(projectRoot, absolute) {
   return path35.relative(projectRoot, absolute).replaceAll("\\", "/");
@@ -6759,7 +7855,7 @@ function managedReceipt2(projectRoot, reference) {
   const root = path35.resolve(evidenceRoot(projectRoot), "managed");
   const absolute = path35.resolve(migrationWorkspaceRoot(projectRoot), reference);
   if (absolute !== root && !absolute.startsWith(`${root}${path35.sep}`)) return null;
-  return readJson7(absolute);
+  return readJson8(absolute);
 }
 function reportClaims(projectRoot, reportIndex) {
   if (!reportIndex) return [];
@@ -6775,16 +7871,16 @@ function reportClaims(projectRoot, reportIndex) {
     });
   };
   for (const descriptor of reportIndex.pages ?? []) {
-    const shard = readJson7(path35.join(reportRoot, descriptor.file));
+    const shard = readJson8(path35.join(reportRoot, descriptor.file));
     if (!shard) continue;
     addItems([shard.page], descriptor.file);
     addItems(shard.controls, descriptor.file);
     addItems(shard.entries, descriptor.file);
   }
-  if (reportIndex.unassignedEntriesFile) addItems(readJson7(path35.join(reportRoot, reportIndex.unassignedEntriesFile))?.entries, reportIndex.unassignedEntriesFile);
-  if (reportIndex.interactionsFile) addItems(readJson7(path35.join(reportRoot, reportIndex.interactionsFile))?.interactions, reportIndex.interactionsFile);
-  if (reportIndex.discoveriesFile) addItems(readJson7(path35.join(reportRoot, reportIndex.discoveriesFile))?.items, "discoveries", true);
-  const acceptance = reportIndex.finalAcceptanceFile ? readJson7(path35.join(reportRoot, reportIndex.finalAcceptanceFile)) : null;
+  if (reportIndex.unassignedEntriesFile) addItems(readJson8(path35.join(reportRoot, reportIndex.unassignedEntriesFile))?.entries, reportIndex.unassignedEntriesFile);
+  if (reportIndex.interactionsFile) addItems(readJson8(path35.join(reportRoot, reportIndex.interactionsFile))?.interactions, reportIndex.interactionsFile);
+  if (reportIndex.discoveriesFile) addItems(readJson8(path35.join(reportRoot, reportIndex.discoveriesFile))?.items, "discoveries", true);
+  const acceptance = reportIndex.finalAcceptanceFile ? readJson8(path35.join(reportRoot, reportIndex.finalAcceptanceFile)) : null;
   for (const [index, test] of (acceptance?.tests ?? []).entries()) claims.push({
     ref: test?.ref ?? `final-acceptance:${test?.name ?? index + 1}`,
     source: reportIndex.finalAcceptanceFile,
@@ -6799,8 +7895,8 @@ function receiptArtifactsAreIntact(projectRoot, receipt) {
   return receipt.artifacts.every((artifact) => {
     if (!artifact || typeof artifact.path !== "string" || !/^[a-f0-9]{64}$/.test(artifact.sha256) || !Number.isInteger(artifact.size)) return false;
     const absolute = path35.resolve(migrationWorkspaceRoot(projectRoot), artifact.path);
-    if (!absolute.startsWith(`${blobsRoot}${path35.sep}`) || !fs28.existsSync(absolute) || !fs28.statSync(absolute).isFile()) return false;
-    const content = fs28.readFileSync(absolute);
+    if (!absolute.startsWith(`${blobsRoot}${path35.sep}`) || !fs29.existsSync(absolute) || !fs29.statSync(absolute).isFile()) return false;
+    const content = fs29.readFileSync(absolute);
     return content.byteLength === artifact.size && createHash8("sha256").update(content).digest("hex") === artifact.sha256;
   });
 }
@@ -6862,7 +7958,7 @@ function actionRequirements(action, snapshot) {
   if (action === "config:init" && snapshot.workspace.configPresent) missing.push(unmet("config-present", ".migration/config.json \u5DF2\u5B58\u5728"));
   if (action === "config:validate") requireConfig();
   if (action === "init" && snapshot.workspace.harmonyProjectPresent) missing.push(unmet("harmony-project-present", "HarmonyOS \u5DE5\u7A0B\u5DF2\u5B58\u5728\uFF0C\u65E0\u9700\u91CD\u590D\u521D\u59CB\u5316"));
-  if (["analyze:android", "analyze:harmony", "build:android", "build:harmony", "test:android", "test:harmony:targeted", "test:harmony:all", "evidence:flow"].includes(action)) requireConfig();
+  if (["analyze:android", "analyze:harmony", "build:harmony", "test:harmony:targeted", "test:harmony:all", "evidence:flow"].includes(action)) requireConfig();
   if (["analyze:harmony", "build:harmony", "test:harmony:targeted", "test:harmony:all"].includes(action)) requireHarmony();
   if (action === "report:init") {
     requireFacts();
@@ -6874,6 +7970,10 @@ function actionRequirements(action, snapshot) {
     requireFacts();
     requireReport();
     requireFreshAnalysis();
+    if (snapshot.planning.present && snapshot.planning.valid && snapshot.planning.fresh) {
+      const message = snapshot.planning.planningPhase === "execution" ? "\u5DF2\u6709\u65B0\u9C9C\u7684\u51BB\u7ED3 Execution Plan\uFF1B\u5B9E\u73B0\u9636\u6BB5\u5FC5\u987B\u4E25\u683C\u6267\u884C\u73B0\u6709 Page Work Package\uFF0C\u7981\u6B62\u52A8\u6001 task plan" : "\u5DF2\u6709\u65B0\u9C9C\u7684 Resolution Plan\uFF1B\u5FC5\u987B\u5148\u5199\u5165\u6709\u6548 correction/review \u4F7F\u8BA1\u5212\u8FC7\u671F\uFF0C\u518D\u91CD\u65B0 task plan";
+      missing.push(unmet("task-plan-already-fresh", message));
+    }
   }
   if (action === "task:validate" && !snapshot.planning.present) missing.push(unmet("task-plan-missing", "Task Plan \u5C1A\u672A\u751F\u6210"));
   if (action === "checkpoint:create") {
@@ -6897,14 +7997,14 @@ function derivePhase(snapshot) {
 function inspectMigration(project = ".") {
   const projectRoot = path35.resolve(project);
   const migrationRoot = migrationDirectory(projectRoot);
-  const config = readJson7(path35.join(migrationRoot, "config.json"));
+  const config = readJson8(path35.join(migrationRoot, "config.json"));
   const harmonyProject = harmonyProjectFor(projectRoot, config);
   const androidProject = androidProjectFor(projectRoot, config);
   const projectPresent = isAndroidProject(androidProject);
   const projectCandidates = projectPresent ? [] : androidProjectCandidates(projectRoot);
-  const preflight = readJson7(path35.join(migrationRoot, "preflight-report.json"));
-  const specIndex = readJson7(path35.join(migrationRoot, "spec", "index.json"));
-  const reportIndex = readJson7(path35.join(migrationRoot, "report", "index.json"));
+  const preflight = readJson8(path35.join(migrationRoot, "preflight-report.json"));
+  const specIndex = readJson8(path35.join(migrationRoot, "spec", "index.json"));
+  const reportIndex = readJson8(path35.join(migrationRoot, "report", "index.json"));
   let validation;
   try {
     validation = validateMigrationReport([projectRoot], { writeResult: false });
@@ -6928,7 +8028,7 @@ function inspectMigration(project = ".") {
       projectCandidates,
       configPresent: Boolean(config),
       harmonyProject,
-      harmonyProjectPresent: fs28.existsSync(harmonyProject) && fs28.statSync(harmonyProject).isDirectory(),
+      harmonyProjectPresent: fs29.existsSync(harmonyProject) && fs29.statSync(harmonyProject).isDirectory(),
       gitHead: projectPresent ? gitHead(androidProject) : null
     },
     preflight: {
@@ -6960,10 +8060,16 @@ function inspectMigration(project = ".") {
       valid: false,
       fresh: false,
       taskPlanSha256: null,
+      planningPhase: null,
       totalTasks: 0,
+      resolutionTasks: 0,
+      totalTargets: 0,
+      readyTargets: 0,
+      completedTargets: 0,
       readyTasks: 0,
       blockedTasks: 0,
       completedTasks: 0,
+      recommendedTargetId: null,
       recommendedTaskId: null,
       alternatives: [],
       reasons: {},
@@ -6972,7 +8078,8 @@ function inspectMigration(project = ".") {
       orphanFactRefs: [],
       errors: [],
       warnings: [],
-      tasks: []
+      tasks: [],
+      targets: []
     },
     evidence: {
       androidAnalysis: { reference: null, present: false, passed: false, fresh: false },
@@ -7018,7 +8125,7 @@ function inspectMigration(project = ".") {
   else {
     if (!snapshot.planning.valid) completionUnmet.push(unmet("task-plan-invalid", "Task Plan \u5B8C\u6574\u6027\u6821\u9A8C\u5931\u8D25"));
     if (!snapshot.planning.fresh) completionUnmet.push(unmet("task-plan-stale", "Task Plan \u4E0E\u5F53\u524D Facts\u3001\u5BA1\u6838\u8F93\u5165\u6216 Android \u6E90\u7801\u4E0D\u4E00\u81F4"));
-    if (snapshot.planning.completedTasks !== snapshot.planning.totalTasks) completionUnmet.push(unmet("task-plan-incomplete", `${snapshot.planning.totalTasks - snapshot.planning.completedTasks} \u4E2A Task \u5C1A\u672A\u53D6\u5F97\u65B0\u9C9C\u5B9A\u5411\u9A8C\u8BC1\u8BC1\u636E`));
+    if (snapshot.planning.completedTasks !== snapshot.planning.totalTasks) completionUnmet.push(unmet("task-plan-incomplete", `${snapshot.planning.totalTasks - snapshot.planning.completedTasks} \u4E2A\u5185\u90E8 Work Item \u5C1A\u672A\u53D6\u5F97\u65B0\u9C9C\u5B9A\u5411\u9A8C\u8BC1\u8BC1\u636E`));
     if (snapshot.planning.orphanFactRefs.length) completionUnmet.push(unmet("task-plan-orphans", `${snapshot.planning.orphanFactRefs.length} \u4E2A\u5FC5\u8981 Fact \u6CA1\u6709\u4E3B\u6240\u6709\u6743`));
   }
   if (!snapshot.evidence.fullRegression.fresh) completionUnmet.push(unmet("full-regression-missing-or-stale", "\u7F3A\u5C11\u4E0E\u5F53\u524D facts \u548C HarmonyOS \u6E90\u7801\u4E00\u81F4\u7684\u5168\u91CF\u53D7\u7BA1\u56DE\u5F52\u8BC1\u636E"));
@@ -7104,13 +8211,13 @@ function archiveArtifacts(projectRoot, artifacts) {
   const archived = [];
   for (const value of artifacts) {
     const absolute = path35.isAbsolute(value) ? value : path35.resolve(projectRoot, value);
-    if (!fs28.existsSync(absolute) || !fs28.statSync(absolute).isFile()) continue;
-    const content = fs28.readFileSync(absolute);
+    if (!fs29.existsSync(absolute) || !fs29.statSync(absolute).isFile()) continue;
+    const content = fs29.readFileSync(absolute);
     const digest = createHash8("sha256").update(content).digest("hex");
     const destination = path35.join(evidenceRoot(projectRoot), "blobs", digest, path35.basename(absolute));
-    fs28.mkdirSync(path35.dirname(destination), { recursive: true });
-    const existingIsIntact = fs28.existsSync(destination) && fs28.statSync(destination).isFile() && fs28.statSync(destination).size === content.byteLength && createHash8("sha256").update(fs28.readFileSync(destination)).digest("hex") === digest;
-    if (!existingIsIntact) fs28.copyFileSync(absolute, destination);
+    fs29.mkdirSync(path35.dirname(destination), { recursive: true });
+    const existingIsIntact = fs29.existsSync(destination) && fs29.statSync(destination).isFile() && fs29.statSync(destination).size === content.byteLength && createHash8("sha256").update(fs29.readFileSync(destination)).digest("hex") === digest;
+    if (!existingIsIntact) fs29.copyFileSync(absolute, destination);
     archived.push({
       path: workspaceRelative(projectRoot, destination),
       source: projectRelative(projectRoot, absolute),
@@ -7135,11 +8242,11 @@ function receiptResult(action, result) {
   };
 }
 function writeJsonAtomic(file, value) {
-  fs28.mkdirSync(path35.dirname(file), { recursive: true });
+  fs29.mkdirSync(path35.dirname(file), { recursive: true });
   const temporary = `${file}.${process.pid}.tmp`;
-  fs28.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}
+  fs29.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}
 `, "utf8");
-  fs28.renameSync(temporary, file);
+  fs29.renameSync(temporary, file);
 }
 function recordObservation(options) {
   const projectRoot = path35.resolve(options.project ?? ".");
@@ -7201,9 +8308,8 @@ Usage:
   droid2hmos complete [project]
   droid2hmos analyze <android|harmony|all> [project]
   droid2hmos preflight [project] [--sdk-path <path>] [--timeout-ms <ms>] [--no-init-harmony]
-  droid2hmos config <init|validate> [project] [--harmony-project <path>] [--android-build <command>] [--android-test <command>]
-  droid2hmos build <android|harmony|all> [project] [--timeout-ms <ms>]
-  droid2hmos test android [project] [--task <task>] [--timeout-ms <ms>]
+  droid2hmos config <init|validate> [project] [--harmony-project <path>]
+  droid2hmos build harmony [project] [--timeout-ms <ms>]
   droid2hmos test harmony [project] [--runner arkts] (--class <class> [--case <case>] | --all) [--target <serial>] [--case-timeout-ms <ms>] [--ref <report-ref>...] [--timeout-ms <ms>]
   droid2hmos test harmony [project] --runner python --hypium-project <path> --test-list <name>... [--target <serial>] [--python <path>] [--report-path <path>] [--ref <report-ref>...] [--timeout-ms <ms>]
   droid2hmos report [project] [--require-complete]
@@ -7212,16 +8318,16 @@ Usage:
   droid2hmos task plan [project]
   droid2hmos task status [project]
   droid2hmos task next [project]
-  droid2hmos task show [project] <task-id> [--cursor <cursor>] [--max-source-context <count>]
+  droid2hmos task show [project] <task-or-package-id> [--cursor <cursor>] [--max-source-context <count>]
   droid2hmos task validate [project]
   droid2hmos checkpoint status [project]
   droid2hmos checkpoint create [project] --message <message> (--include <path>...|--all)
-  droid2hmos device check <android|harmony> [--adb <path>|--hdc <path>]
+  droid2hmos device check harmony [--hdc <path>]
   droid2hmos auth login [project] [--timeout-ms <ms>]
   droid2hmos sign [project] [--target <serial>] [--force] [--timeout-ms <ms>]
-  droid2hmos evidence capture <android|harmony> [project] --name <name> [--target <id>]
+  droid2hmos evidence capture harmony [project] --name <name> [--target <id>]
   droid2hmos evidence compare [project] --name <name> --android <evidence-dir> --harmony <evidence-dir>
-  droid2hmos evidence flow <android|harmony> [project] --name <name> [--target <id>] [--task <task>|--class <class> [--case <case>]|--all] [--case-timeout-ms <ms>] [--ref <report-ref>...]
+  droid2hmos evidence flow harmony [project] --name <name> [--target <id>] [--class <class> [--case <case>]|--all] [--case-timeout-ms <ms>] [--ref <report-ref>...]
   droid2hmos mock init [project] --spec <protocol-spec.json> [--force]
   droid2hmos logs <list|show|failures|stats> [project] [value]
   droid2hmos upgrade
@@ -7274,13 +8380,13 @@ function observed(project, action, result, scope, guardResult) {
 }
 async function runCli(argv, runtime) {
   const args = [...argv];
-  let command3 = args.shift();
-  if (command3 && ["-v", "--version"].includes(command3)) {
-    if (args.length > 0) throw new CliError(`${command3} does not accept arguments`);
+  let command2 = args.shift();
+  if (command2 && ["-v", "--version"].includes(command2)) {
+    if (args.length > 0) throw new CliError(`${command2} does not accept arguments`);
     console.log(readPackageMetadata(runtime.packageRoot).version);
     return 0;
   }
-  if (!command3 || ["help", "-h", "--help"].includes(command3)) {
+  if (!command2 || ["help", "-h", "--help"].includes(command2)) {
     console.log(HELP);
     return 0;
   }
@@ -7288,13 +8394,13 @@ async function runCli(argv, runtime) {
     console.log(HELP);
     return 0;
   }
-  if (command3 === "status") {
+  if (command2 === "status") {
     const projects = positionals(args);
     if (projects.length > 1) throw new CliError("status accepts at most one project directory");
     json(inspectMigration(projects[0] ?? "."));
     return 0;
   }
-  if (command3 === "complete") {
+  if (command2 === "complete") {
     const projects = positionals(args);
     if (projects.length > 1) throw new CliError("complete accepts at most one project directory");
     const project = projects[0] ?? ".";
@@ -7309,7 +8415,7 @@ async function runCli(argv, runtime) {
     if (exitCode !== 0) return exitCode;
     return 0;
   }
-  if (command3 === "init") {
+  if (command2 === "init") {
     const projects = positionals(args, ["--target"]);
     if (projects.length > 1) throw new Error("init accepts at most one Android project directory");
     if (!runtime.templatesRoot) throw new Error(`Cannot locate bundled HarmonyOS template (templates/ohos) from ${runtime.entryFile}`);
@@ -7335,28 +8441,26 @@ async function runCli(argv, runtime) {
     json(observed(project, "init", { ...result, signature }, { target: optionValue(args, "--target") ?? null }, guardResult));
     return 0;
   }
-  if (command3 === "upgrade") {
+  if (command2 === "upgrade") {
     if (args.length > 0) throw new CliError("upgrade does not accept arguments");
     json(upgradeCli({ packageRoot: runtime.packageRoot }));
     return 0;
   }
-  if (command3 === "config") {
+  if (command2 === "config") {
     const action = args.shift();
     if (!(/* @__PURE__ */ new Set(["init", "validate"])).has(action)) throw new CliError("config requires init or validate");
-    const projects = positionals(args, ["--harmony-project", "--android-build", "--android-test"]);
+    const projects = positionals(args, ["--harmony-project"]);
     if (projects.length > 1) throw new CliError("config accepts at most one project directory");
     const project = projects[0] ?? ".";
     const guardResult = guard(`config:${action}`, project);
     const result = action === "init" ? initMigrationConfig({
       project,
-      harmonyProject: optionValue(args, "--harmony-project"),
-      androidBuild: optionValue(args, "--android-build"),
-      androidTest: optionValue(args, "--android-test")
+      harmonyProject: optionValue(args, "--harmony-project")
     }) : validateMigrationConfig(project);
     json(observed(project, `config:${action}`, result, null, guardResult));
     return action === "validate" && !result.valid ? 1 : 0;
   }
-  if (command3 === "preflight") {
+  if (command2 === "preflight") {
     const projects = positionals(args, ["--sdk-path", "--timeout-ms"]);
     if (projects.length > 1) throw new CliError("preflight accepts at most one project directory");
     if (!runtime.templatesRoot) throw new Error("Cannot locate bundled HarmonyOS template");
@@ -7368,7 +8472,7 @@ async function runCli(argv, runtime) {
     json(observed(project, "preflight", result, { initializeHarmony: !args.includes("--no-init-harmony") }, guardResult));
     return result.status === "passed" ? 0 : 1;
   }
-  if (command3 === "analyze") {
+  if (command2 === "analyze") {
     const target = args.shift();
     if (!(/* @__PURE__ */ new Set(["android", "harmony", "all"])).has(target)) throw new CliError("analyze target must be android, harmony, or all");
     const projects = positionals(args);
@@ -7401,7 +8505,7 @@ async function runCli(argv, runtime) {
     }
     return 0;
   }
-  if (command3 === "report") {
+  if (command2 === "report") {
     const explicitAction = ["init", "validate", "render", "update"].includes(args[0] ?? "") ? args.shift() : null;
     const action = explicitAction ?? "render";
     const projects = positionals(args, ["--ref", "--status", "--harmony-file", "--android-source", "--evidence", "--difference"]);
@@ -7464,19 +8568,19 @@ async function runCli(argv, runtime) {
     }
     throw new Error("report requires init, validate, or render");
   }
-  if (command3 === "task") {
+  if (command2 === "task") {
     const action = args.shift();
     if (!(/* @__PURE__ */ new Set(["plan", "status", "next", "show", "validate"])).has(action)) throw new CliError("task requires plan, status, next, show, or validate");
     if (action === "show") {
       const values = positionals(args, ["--cursor", "--max-source-context"]);
-      if (values.length < 1 || values.length > 2) throw new CliError("task show requires [project] <task-id>");
+      if (values.length < 1 || values.length > 2) throw new CliError("task show requires [project] <task-or-package-id>");
       const project2 = values.length === 2 ? values[0] : ".";
-      const taskId = values.at(-1);
-      if (!/^task:[a-f0-9]{16}$/.test(taskId)) throw new CliError("task show requires a valid task id");
+      const targetId = values.at(-1);
+      if (!/^(task|package):[a-f0-9]{16}$/.test(targetId)) throw new CliError("task show requires a valid Resolution Task or Page Work Package id");
       const maxSourceContext = Number(optionValue(args, "--max-source-context") ?? 25);
       if (!Number.isInteger(maxSourceContext) || maxSourceContext <= 0 || maxSourceContext > 200) throw new CliError("--max-source-context must be an integer from 1 to 200");
       const snapshot2 = inspectMigration(project2);
-      json(taskPlanning.materialize(project2, taskId, {
+      json(taskPlanning.materialize(project2, targetId, {
         source: {
           androidFingerprint: snapshot2.source.androidFingerprint,
           harmonyFingerprint: snapshot2.source.harmonyFingerprint,
@@ -7498,8 +8602,13 @@ async function runCli(argv, runtime) {
       const result = {
         status: planning.valid && planning.fresh ? "passed" : "failed",
         taskPlanVersion: plan.taskPlanVersion,
+        executionPlanVersion: plan.executionPlanVersion,
+        planningPhase: plan.planningPhase,
         taskPlanSha256: planning.taskPlanSha256,
         totalTasks: plan.tasks.length,
+        behaviorResponsibilities: plan.behaviorResponsibilities.length,
+        pageWorkPackages: plan.pageWorkPackages.length,
+        executionTargets: plan.planningPhase === "resolution" ? plan.tasks.length : plan.pageWorkPackages.length,
         resolutionTasks: plan.tasks.filter((task) => task.type === "resolution").length,
         errors: planning.errors,
         warnings: planning.warnings
@@ -7525,19 +8634,19 @@ async function runCli(argv, runtime) {
     }
     const allComplete = snapshot.totalTasks > 0 && snapshot.completedTasks === snapshot.totalTasks;
     json({
-      status: snapshot.recommendedTaskId ? "ready" : (() => {
+      status: snapshot.recommendedTargetId ? "ready" : (() => {
         if (allComplete) return "complete";
         return "blocked";
       })(),
-      recommended: snapshot.recommendedTaskId,
+      recommended: snapshot.recommendedTargetId,
       alternatives: snapshot.alternatives,
       reasons: snapshot.reasons
     });
-    return snapshot.recommendedTaskId || allComplete ? 0 : 1;
+    return snapshot.recommendedTargetId || allComplete ? 0 : 1;
   }
-  if (command3 === "build") {
+  if (command2 === "build") {
     const target = args.shift();
-    if (!(/* @__PURE__ */ new Set(["android", "harmony", "all"])).has(target)) throw new CliError("build target must be android, harmony, or all");
+    if (target !== "harmony") throw new CliError("build target must be harmony (Android \u6784\u5EFA\u5DF2\u79FB\u9664\uFF1A\u8FC1\u79FB\u6D41\u7A0B\u4E0D\u4F9D\u8D56 Android \u7F16\u8BD1\u73AF\u5883)");
     const projects = positionals(args, ["--timeout-ms"]);
     if (projects.length > 1) throw new CliError("build accepts at most one project directory");
     const projectRoot = path36.resolve(projects[0] ?? ".");
@@ -7545,52 +8654,29 @@ async function runCli(argv, runtime) {
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new CliError("--timeout-ms must be a positive number");
     const configPath = path36.join(migrationDirectory(projectRoot), "config.json");
     if (!existsSync9(configPath)) throw new Error(`Migration config not found: ${configPath}`);
-    const keys = target === "all" ? ["androidBuild", "harmonyBuild"] : [`${target}Build`];
-    for (const key of keys) {
-      const action = key === "harmonyBuild" ? "build:harmony" : "build:android";
-      const guardResult = guard(action, projectRoot);
-      const config = JSON.parse(readFileSync7(configPath, "utf8"));
-      const configuredHarmony = config.harmonyProject ?? defaultHarmonyProjectPath(projectRoot);
-      const harmonyProject = path36.isAbsolute(configuredHarmony) ? configuredHarmony : path36.resolve(projectRoot, configuredHarmony);
-      let result;
-      try {
-        result = key === "harmonyBuild" ? runHarmonyBuild({ projectRoot, harmonyProject, timeoutMs }) : runConfigCommand({ configPath, key, timeoutMs });
-      } catch (error) {
-        result = { status: "failed", key, summary: error?.message ?? String(error) };
-      }
-      if (key === "androidBuild" && result?.status === "not_applicable") {
-        result = {
-          ...result,
-          summary: 'androidBuild \u672A\u914D\u7F6E\uFF08\u8FC1\u79FB\u9ED8\u8BA4\u4E0D\u7F16\u8BD1 Android \u5DE5\u7A0B\uFF09\u3002\u5982\u9700 Android/HarmonyOS \u53CC\u7AEF\u8FD0\u884C\u5BF9\u7167\uFF0C\u53EF\u8FD0\u884C droid2hmos config init <project> --android-build "./gradlew --no-daemon assembleDebug" \u663E\u5F0F\u542F\u7528\u3002'
-        };
-      }
-      result = observed(projectRoot, action, result, null, guardResult);
-      json(result);
-      if (result.status !== "passed") return 1;
+    const guardResult = guard("build:harmony", projectRoot);
+    const config = JSON.parse(readFileSync7(configPath, "utf8"));
+    const configuredHarmony = config.harmonyProject ?? defaultHarmonyProjectPath(projectRoot);
+    const harmonyProject = path36.isAbsolute(configuredHarmony) ? configuredHarmony : path36.resolve(projectRoot, configuredHarmony);
+    let result;
+    try {
+      result = runHarmonyBuild({ projectRoot, harmonyProject, timeoutMs });
+    } catch (error) {
+      result = { status: "failed", key: "harmonyBuild", summary: error?.message ?? String(error) };
     }
-    return 0;
+    result = observed(projectRoot, "build:harmony", result, null, guardResult);
+    json(result);
+    return result.status === "passed" ? 0 : 1;
   }
-  if (command3 === "test") {
+  if (command2 === "test") {
     const target = args.shift();
-    if (!(/* @__PURE__ */ new Set(["android", "harmony"])).has(target)) throw new CliError("test target must be android or harmony");
-    const projects = positionals(args, ["--timeout-ms", "--case-timeout-ms", "--class", "--case", "--task", "--target", "--ref", "--runner", "--hypium-project", "--test-list", "--python", "--report-path"]);
+    if (target !== "harmony") throw new CliError("test target must be harmony (Android \u6D4B\u8BD5\u5DF2\u79FB\u9664\uFF1A\u8FC1\u79FB\u6D41\u7A0B\u4E0D\u4F9D\u8D56 Android \u8FD0\u884C\u73AF\u5883)");
+    const projects = positionals(args, ["--timeout-ms", "--case-timeout-ms", "--class", "--case", "--target", "--ref", "--runner", "--hypium-project", "--test-list", "--python", "--report-path"]);
     if (projects.length > 1) throw new CliError("test accepts at most one project directory");
     const projectRoot = path36.resolve(projects[0] ?? ".");
     const timeoutMs = Number(optionValue(args, "--timeout-ms") ?? 30 * 60 * 1e3);
     const harmonyTarget = optionValue(args, "--target") ?? null;
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new CliError("--timeout-ms must be a positive number");
-    if (target === "android") {
-      const guardResult2 = guard("test:android", projectRoot);
-      if (args.includes("--runner")) throw new CliError("--runner is only supported by test harmony");
-      const configPath2 = path36.join(migrationDirectory(projectRoot), "config.json");
-      if (!existsSync9(configPath2)) throw new Error(`Migration config not found: ${configPath2}`);
-      const task = optionValue(args, "--task");
-      if (task && !/^[A-Za-z0-9_:.-]+$/.test(task)) throw new CliError("--task contains unsupported characters");
-      let result2 = runConfigCommand({ configPath: configPath2, key: "androidTest", timeoutMs, replacements: task ? { "{task}": task } : {}, requiredTokens: task ? ["{task}"] : [] });
-      result2 = observed(projectRoot, "test:android", result2, { task: task ?? null }, guardResult2);
-      json(result2);
-      return result2.status === "passed" || result2.status === "not_applicable" ? 0 : 1;
-    }
     const runner = optionValue(args, "--runner") ?? "arkts";
     if (!(/* @__PURE__ */ new Set(["arkts", "python"])).has(runner)) throw new CliError("--runner must be arkts or python");
     const testClass = optionValue(args, "--class") ?? null;
@@ -7651,7 +8737,7 @@ async function runCli(argv, runtime) {
     json(result);
     return result.status === "passed" ? 0 : 1;
   }
-  if (command3 === "checkpoint") {
+  if (command2 === "checkpoint") {
     const action = args.shift();
     if (!(/* @__PURE__ */ new Set(["status", "create"])).has(action)) throw new CliError("checkpoint requires status or create");
     const projects = positionals(args, ["--message", "--include"]);
@@ -7688,16 +8774,16 @@ async function runCli(argv, runtime) {
     json(createGitCheckpoint({ project, harmonyProject: roots.harmonyRoot, message: optionValue(args, "--message") ?? "", include: optionValues(args, "--include"), all: args.includes("--all"), provenanceReceipt, provenanceFiles }));
     return 0;
   }
-  if (command3 === "device") {
+  if (command2 === "device") {
     if (args.shift() !== "check") throw new CliError("device requires check");
     const platform = args.shift();
-    if (!(/* @__PURE__ */ new Set(["android", "harmony"])).has(platform)) throw new CliError("device check requires android or harmony");
+    if (platform !== "harmony") throw new CliError("device check requires harmony (Android \u8BBE\u5907\u68C0\u6D4B\u5DF2\u79FB\u9664)");
     guard("device:check", ".");
-    const result = platform === "android" ? checkAndroidEmulator({ adb: optionValue(args, "--adb") }) : checkHarmonyDevice({ hdc: optionValue(args, "--hdc") });
+    const result = checkHarmonyDevice({ hdc: optionValue(args, "--hdc") });
     json(result);
     return result.status === "failed" ? 1 : 0;
   }
-  if (command3 === "auth") {
+  if (command2 === "auth") {
     if (args.shift() !== "login") throw new CliError("auth requires login");
     const projects = positionals(args, ["--timeout-ms"]);
     if (projects.length > 1) throw new CliError("auth accepts at most one project directory");
@@ -7712,7 +8798,7 @@ async function runCli(argv, runtime) {
     json(result);
     return result.status === "passed" ? 0 : 1;
   }
-  if (command3 === "sign") {
+  if (command2 === "sign") {
     const projects = positionals(args, ["--target", "--timeout-ms"]);
     if (projects.length > 1) throw new CliError("sign accepts at most one project directory");
     const project = projects[0] ?? ".";
@@ -7734,7 +8820,7 @@ async function runCli(argv, runtime) {
     json(result);
     return result.status === "passed" || result.status === "skipped" ? 0 : 1;
   }
-  if (command3 === "evidence") {
+  if (command2 === "evidence") {
     const action = args.shift();
     if (!(/* @__PURE__ */ new Set(["capture", "compare", "flow"])).has(action)) throw new CliError("evidence requires capture, compare, or flow");
     if (action === "compare") {
@@ -7749,8 +8835,8 @@ async function runCli(argv, runtime) {
       return 0;
     }
     const platform = args.shift();
-    if (!(/* @__PURE__ */ new Set(["android", "harmony"])).has(platform)) throw new CliError(`evidence ${action} requires android or harmony`);
-    const projects = positionals(args, ["--name", "--target", "--class", "--case", "--task", "--timeout-ms", "--case-timeout-ms", "--ref"]);
+    if (platform !== "harmony") throw new CliError(`evidence ${action} requires harmony (Android \u8BC1\u636E\u91C7\u96C6\u5DF2\u79FB\u9664)`);
+    const projects = positionals(args, ["--name", "--target", "--class", "--case", "--timeout-ms", "--case-timeout-ms", "--ref"]);
     const project = projects[0] ?? ".";
     const name = optionValue(args, "--name");
     if (!name) throw new CliError(`evidence ${action} requires --name`);
@@ -7766,11 +8852,7 @@ async function runCli(argv, runtime) {
     const timeoutMs = Number(optionValue(args, "--timeout-ms") ?? 30 * 60 * 1e3);
     let execution;
     if (before.status !== "passed") execution = { status: "failed", skipped: true, summary: "Baseline evidence capture failed; interaction was not executed" };
-    else if (platform === "android") {
-      const task = optionValue(args, "--task");
-      if (task && !/^[A-Za-z0-9_:.-]+$/.test(task)) throw new CliError("--task contains unsupported characters");
-      execution = runConfigCommand({ configPath: path36.join(migrationDirectory(projectRoot), "config.json"), key: "androidTest", timeoutMs, replacements: task ? { "{task}": task } : {}, requiredTokens: task ? ["{task}"] : [] });
-    } else {
+    else {
       const config = JSON.parse(readFileSync7(path36.join(migrationDirectory(projectRoot), "config.json"), "utf8"));
       const harmonyProject = path36.isAbsolute(config.harmonyProject) ? config.harmonyProject : path36.resolve(projectRoot, config.harmonyProject);
       const testClass = optionValue(args, "--class") ?? null;
@@ -7782,7 +8864,7 @@ async function runCli(argv, runtime) {
     }
     const after = captureDeviceEvidence({ project, platform, name: `${name}-after`, target: optionValue(args, "--target") });
     let result = writeFlowBundle({ project, name, platform, before, execution, after });
-    if (platform === "harmony") {
+    {
       const testAction = args.includes("--all") ? "test:harmony:all" : "test:harmony:targeted";
       result = observed(project, testAction, result, {
         evidenceFlow: name,
@@ -7797,7 +8879,7 @@ async function runCli(argv, runtime) {
     json(result);
     return result.status === "passed" ? 0 : 1;
   }
-  if (command3 === "mock") {
+  if (command2 === "mock") {
     if (args.shift() !== "init") throw new CliError("mock requires init");
     const projects = positionals(args, ["--spec"]);
     const specFile = optionValue(args, "--spec");
@@ -7807,14 +8889,14 @@ async function runCli(argv, runtime) {
     json(generateMockServer({ project, specFile, force: args.includes("--force") }));
     return 0;
   }
-  if (command3 === "logs") {
+  if (command2 === "logs") {
     const action = args.shift();
     if (!(/* @__PURE__ */ new Set(["list", "show", "failures", "stats"])).has(action)) throw new CliError("logs requires list, show, failures, or stats");
     const project = args.shift() ?? ".";
     json(queryCommandLogs(project, action, args.shift()));
     return 0;
   }
-  if (command3 === "service") {
+  if (command2 === "service") {
     const action = args.shift();
     if (!(/* @__PURE__ */ new Set(["start", "status", "stop"])).has(action)) throw new CliError("service action must be start, status, or stop");
     const name = args.shift();
@@ -7858,7 +8940,7 @@ async function runCli(argv, runtime) {
     }));
     return 0;
   }
-  if (command3 === "internal") {
+  if (command2 === "internal") {
     const action = args.shift();
     if (action === "detect-harmony-sdk") {
       const projects = positionals(args, ["--sdk-path"]);
@@ -7890,14 +8972,14 @@ async function runCli(argv, runtime) {
     }
     throw new Error("unknown internal command");
   }
-  if (command3 === "dev") {
+  if (command2 === "dev") {
     const action = args.shift();
     if (!runtime.packageRoot || action !== "build") throw new Error("dev requires build from a source checkout");
     const result = spawnCommandSync("npm", ["run", "build"], { cwd: runtime.packageRoot, stdio: "inherit" });
     if (result.error) throw result.error;
     return result.status ?? 1;
   }
-  throw new CliError(`Unknown command: ${command3}`);
+  throw new CliError(`Unknown command: ${command2}`);
 }
 var entryHref = import.meta.url;
 var invokedHref = (() => {