android2harmony 0.1.6 → 0.1.8

package/skills/a2h-spec-implement/scripts/ledger/aggregate_run.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+/**
+ * aggregate_run.mjs
+ * Run-level defect aggregation from the ledger (convergence.jsonl).
+ *
+ * Replaces the former aggregate_wave.mjs + manifest/aggregate_pipeline.mjs pair:
+ * both carried a line-for-line duplicate of getTerminalVerdict() and of the
+ * defect arithmetic, differing only in whether they derived the case roster from
+ * the ledger or from the plan. One scenario roster, one implementation.
+ *
+ * Inputs (CLI args):
+ *   --ledger       path to convergence.jsonl
+ *   --scenarios    path to logic/scenarios.json (the delivery roster)
+ *   --rounds       rounds_executed (integer)
+ *   --stop-reason  all_passed | no_confirmed_defects | no_progress | max_rounds_reached
+ *   --output       optional path to also write the result JSON to
+ *
+ * The roster is authoritative for the pass-rate denominator. Scenarios listed
+ * under `skipped` are excluded from both denominators: they were never delivered,
+ * so counting them would understate the rate of the work actually attempted.
+ *
+ * Outputs (stdout JSON):
+ * {
+ *   ok, defect_row, per_case[], invariant_holds, env_false_positive_count,
+ *   total_cases, terminal_passed_count, defects_found, defects_fixed,
+ *   defects_remaining, pass_rate_quality, pass_rate_operational
+ * }
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+
+// ── CLI ──────────────────────────────────────────────────────────────────────
+const args = {};
+for (let i = 0; i < process.argv.length; i++) {
+  const arg = process.argv[i];
+  if (arg.startsWith('--')) {
+    const key = arg.slice(2);
+    args[key] = process.argv[i + 1];
+    if (args[key]?.startsWith('--')) {
+      args[key] = true; // flag without value
+      i--;
+    }
+  }
+}
+
+const {
+  ledger: ledgerPath,
+  scenarios: scenariosPath,
+  rounds,
+  'stop-reason': stopReason,
+  output: outputPath,
+} = args;
+
+if (!ledgerPath || !scenariosPath || rounds === undefined || !stopReason) {
+  console.error(JSON.stringify({ ok: false, error: 'Usage: aggregate_run --ledger <path> --scenarios <path> --rounds <n> --stop-reason <reason> [--output <path>]' }));
+  process.exit(1);
+}
+
+const roundsNum = parseInt(rounds, 10);
+
+// ── Parse scenario roster ────────────────────────────────────────────────────
+let roster;
+try {
+  roster = JSON.parse(readFileSync(scenariosPath, 'utf8'));
+} catch (e) {
+  console.error(JSON.stringify({ ok: false, error: `Cannot read scenarios roster ${scenariosPath}: ${e.message}` }));
+  process.exit(1);
+}
+
+const deliveredCases = Array.isArray(roster.scenarios) ? roster.scenarios : [];
+if (deliveredCases.length === 0) {
+  console.error(JSON.stringify({ ok: false, error: `Scenario roster ${scenariosPath} lists no delivered scenarios` }));
+  process.exit(1);
+}
+// Skipped scenarios are recorded for traceability but never scored.
+const skippedCases = new Set(
+  (Array.isArray(roster.skipped) ? roster.skipped : []).map(s => (typeof s === 'string' ? s : s.case_id))
+);
+
+// ── Parse ledger ─────────────────────────────────────────────────────────────
+const ledgerLines = readFileSync(ledgerPath, 'utf8').trim().split('\n').filter(Boolean);
+const allLines = ledgerLines
+  .map(l => { try { return JSON.parse(l); } catch { return null; } })
+  .filter(l => l !== null);
+
+// ── Group by case ─────────────────────────────────────────────────────────────
+const caseMap = {}; // case_id -> array of ledger lines
+for (const line of allLines) {
+  const id = line.case_id;
+  if (!caseMap[id]) caseMap[id] = [];
+  caseMap[id].push(line);
+}
+
+// ── Source priority for terminal verdict ─────────────────────────────────────
+// Priority: integration(3) > uitest(2) > unit(1) > review(0)
+// "last non-fixer verdict in source-priority order" means:
+//   1. pick the most recent entry by timestamp
+//   2. if tie on timestamp, pick highest priority source
+// This must stay identical to SKILL.md 阶段2 步骤⑤ — a divergence between the
+// in-round decision and these stats makes the two disagree about convergence.
+const SOURCE_PRIORITY = { review: 0, unit: 1, uitest: 2, integration: 3 };
+
+function getTerminalVerdict(lines) {
+  const nonFixer = lines.filter(l => l.source !== 'fixer');
+  if (nonFixer.length === 0) return null;
+  const sorted = [...nonFixer].sort((a, b) => {
+    const tA = new Date(a.ts).getTime();
+    const tB = new Date(b.ts).getTime();
+    if (tB !== tA) return tB - tA; // most recent first
+    return (SOURCE_PRIORITY[b.source] ?? 0) - (SOURCE_PRIORITY[a.source] ?? 0); // highest priority wins
+  });
+  return sorted[0];
+}
+
+// ── Compute stats over the delivered roster ──────────────────────────────────
+const VERDICTS_FAIL = new Set(['FAIL', 'PARTIAL', 'BLOCKED']);
+const VERDICTS_PASS = new Set(['PASS']);
+
+let defectsFound = 0;
+let defectsFixed = 0;
+let envFalsePositiveCount = 0;
+let terminalPassed = 0;
+
+const perCase = [];
+
+for (const caseId of deliveredCases) {
+  if (skippedCases.has(caseId)) continue; // never delivered — not scored
+  const lines = caseMap[caseId] || [];
+  const terminal = getTerminalVerdict(lines);
+  const verdict = terminal?.verdict ?? 'UNKNOWN';
+  const cls = terminal?.class ?? 'unknown';
+  const signature = terminal ? `${terminal.failing_point || ''}|${terminal.root_cause || ''}` : '';
+
+  // class=environment: count as env_false_positive, do NOT count toward defects
+  if (cls === 'environment') {
+    envFalsePositiveCount++;
+    perCase.push({ case_id: caseId, terminal_verdict: verdict, signature, last_source: terminal?.source ?? 'unknown', class: cls });
+    continue;
+  }
+
+  // Did this case ever have FAIL/PARTIAL/BLOCKED with class=code in ANY round?
+  const everFailed = lines.some(l => VERDICTS_FAIL.has(l.verdict) && l.class === 'code');
+  const finalIsPass = VERDICTS_PASS.has(verdict);
+
+  if (everFailed) {
+    defectsFound++;
+    if (finalIsPass) defectsFixed++;
+  }
+
+  if (finalIsPass) terminalPassed++;
+
+  perCase.push({ case_id: caseId, terminal_verdict: verdict, signature, last_source: terminal?.source ?? 'unknown', class: cls });
+}
+
+// ── Invariant check ──────────────────────────────────────────────────────────
+const defectsRemaining = defectsFound - defectsFixed;
+const invariantHolds = (defectsFound === defectsFixed + defectsRemaining);
+
+// ── Pass rates ───────────────────────────────────────────────────────────────
+// Scored population excludes skipped scenarios; quality additionally excludes
+// environment false positives, so the two rates differ exactly when env noise exists.
+const scoredTotal = deliveredCases.filter(id => !skippedCases.has(id)).length;
+const denominatorQuality = scoredTotal - envFalsePositiveCount;
+const denominatorOperational = scoredTotal;
+
+const passRateQuality = denominatorQuality > 0
+  ? `${Math.round((terminalPassed / denominatorQuality) * 100)}%`
+  : '100%';
+const passRateOperational = denominatorOperational > 0
+  ? `${Math.round((terminalPassed / denominatorOperational) * 100)}%`
+  : '100%';
+
+// ── Build defect row ──────────────────────────────────────────────────────────
+const defectRow = {
+  rounds: roundsNum,
+  terminal_passed: `${terminalPassed}/${scoredTotal}`,
+  defects_found: defectsFound,
+  defects_fixed: defectsFixed,
+  defects_remaining: defectsRemaining,
+  pass_rate_quality: passRateQuality,
+  pass_rate_operational: passRateOperational,
+  stop_reason: stopReason,
+};
+
+const result = {
+  ok: invariantHolds,
+  defect_row: defectRow,
+  per_case: perCase,
+  invariant_holds: invariantHolds,
+  env_false_positive_count: envFalsePositiveCount,
+  total_cases: scoredTotal,
+  skipped_count: skippedCases.size,
+  terminal_passed_count: terminalPassed,
+  defects_found: defectsFound,
+  defects_fixed: defectsFixed,
+  defects_remaining: defectsRemaining,
+  pass_rate_quality: passRateQuality,
+  pass_rate_operational: passRateOperational,
+};
+
+if (outputPath) {
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, JSON.stringify(result, null, 2));
+}
+
+console.log(JSON.stringify(result, null, 2));

package/skills/a2h-spec-implement/scripts/manifest/emit_summary_line.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * emit_summary_line.mjs
+ * Generate the one-line run summary text (used by finalize_run.mjs §2).
+ *
+ * CLI:
+ *   --terminal-passed   integer  (number of cases with terminal PASS)
+ *   --total             integer  (total scored cases)
+ *   --rounds-executed   integer
+ *   --max-rounds        integer
+ *   --stop-reason       string   (all_passed | no_confirmed_defects | no_progress | max_rounds_reached)
+ *
+ * Output (stdout):
+ *   "{terminal_passed}/{total} PASS, {rounds_executed}/{max_rounds} rounds, stop={stop_reason}"
+ *
+ * Example: "5/6 PASS, 3/6 rounds, stop=no_progress"
+ */
+
+const args = {};
+for (let i = 0; i < process.argv.length; i++) {
+  const arg = process.argv[i];
+  if (arg.startsWith('--')) {
+    const key = arg.slice(2);
+    args[key] = process.argv[i + 1];
+    if (args[key]?.startsWith('--')) { args[key] = true; i--; }
+  }
+}
+
+const { 'terminal-passed': terminalPassed, total, 'rounds-executed': roundsExecuted, 'max-rounds': maxRounds, 'stop-reason': stopReason } = args;
+
+if (terminalPassed === undefined || !total || roundsExecuted === undefined || !maxRounds || !stopReason) {
+  console.error(JSON.stringify({ ok: false, error: 'Usage: emit_summary_line --terminal-passed <n> --total <n> --rounds-executed <n> --max-rounds <n> --stop-reason <reason>' }));
+  process.exit(1);
+}
+
+const line = `${terminalPassed}/${total} PASS, ${roundsExecuted}/${maxRounds} rounds, stop=${stopReason}`;
+console.log(JSON.stringify({ ok: true, summary_line: line }));

package/skills/a2h-spec-implement/scripts/manifest/finalize_run.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * finalize_run.mjs
+ * Run finalization — called once after the ROUND loop exits.
+ *
+ * Replaces the former wave/finalize_wave.mjs. Two of that script's four steps
+ * were mirror hops into WAVE_DIR that nothing downstream read: manifest/root_mirror.mjs
+ * re-derives the same artifacts from the round directories itself. With the layout
+ * flattened those hops became pure duplication, so finalization is now aggregate +
+ * summary line, and all mirroring belongs to 阶段3's root_mirror.mjs.
+ *
+ * CLI:
+ *   --output        OUTPUT/
+ *   --ledger        path to convergence.jsonl
+ *   --scenarios     path to logic/scenarios.json
+ *   --rounds        rounds_executed (integer)
+ *   --stop-reason   all_passed | no_confirmed_defects | no_progress | max_rounds_reached
+ *   --max-rounds    integer (MAX_ROUNDS from SKILL.md)
+ *
+ * On invariant_holds=false: writes OUTPUT/finalize-failure.md and exits non-zero.
+ * no_progress and max_rounds_reached are terminal states, NOT errors — they exit 0.
+ *
+ * Output (stdout JSON):
+ * { ok, invariant_holds, defect_row, per_case, summary_line }
+ */
+
+import { execSync } from 'child_process';
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const args = {};
+for (let i = 0; i < process.argv.length; i++) {
+  const arg = process.argv[i];
+  if (arg.startsWith('--')) {
+    const key = arg.slice(2);
+    args[key] = process.argv[i + 1];
+    if (args[key]?.startsWith('--')) { args[key] = true; i--; }
+  }
+}
+
+const {
+  output: outputDir,
+  ledger: ledgerPath,
+  scenarios: scenariosPath,
+  rounds,
+  'stop-reason': stopReason,
+  'max-rounds': maxRounds,
+} = args;
+
+if (!outputDir || !ledgerPath || !scenariosPath || rounds === undefined || !stopReason || maxRounds === undefined) {
+  console.error(JSON.stringify({ ok: false, error: 'Usage: finalize_run --output <dir> --ledger <path> --scenarios <path> --rounds <n> --stop-reason <reason> --max-rounds <n>' }));
+  process.exit(1);
+}
+
+const scriptDir = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+// ── §1: Aggregate the run ────────────────────────────────────────────────────
+const aggregatesDir = join(outputDir, 'aggregates');
+mkdirSync(aggregatesDir, { recursive: true });
+const aggregatePath = join(aggregatesDir, 'run-total.json');
+
+let agg;
+try {
+  const aggOut = execSync(
+    `node "${scriptDir}/ledger/aggregate_run.mjs" --ledger "${ledgerPath}" --scenarios "${scenariosPath}" --rounds "${rounds}" --stop-reason "${stopReason}" --output "${aggregatePath}"`,
+    { encoding: 'utf8' }
+  );
+  agg = JSON.parse(aggOut);
+} catch (e) {
+  try {
+    agg = JSON.parse(e.stdout || e.stderr || '{}');
+  } catch {
+    agg = {};
+  }
+}
+
+// ── §2: Summary line ─────────────────────────────────────────────────────────
+const terminalPassed = agg.terminal_passed_count ?? 0;
+const totalCases = agg.total_cases ?? 0;
+let summaryLine;
+try {
+  const sumOut = execSync(
+    `node "${scriptDir}/manifest/emit_summary_line.mjs" --terminal-passed "${terminalPassed}" --total "${totalCases}" --rounds-executed "${rounds}" --max-rounds "${maxRounds}" --stop-reason "${stopReason}"`,
+    { encoding: 'utf8' }
+  );
+  summaryLine = JSON.parse(sumOut)?.summary_line;
+} catch { /* fall through to the local format below */ }
+if (!summaryLine) {
+  summaryLine = `${terminalPassed}/${totalCases} PASS, ${rounds}/${maxRounds} rounds, stop=${stopReason}`;
+}
+
+// ── Invariant check ──────────────────────────────────────────────────────────
+const invariantHolds = agg.invariant_holds === true;
+const defectRow = agg.defect_row || {};
+const perCase = agg.per_case || [];
+
+if (!invariantHolds) {
+  const failureMsg = `Run finalization: invariant broke.\n` +
+    `defects_found=${agg.defects_found}, defects_fixed=${agg.defects_fixed}, defects_remaining=${agg.defects_remaining}\n` +
+    `Expected: defects_found == defects_fixed + defects_remaining`;
+  writeFileSync(join(outputDir, 'finalize-failure.md'), failureMsg);
+  writeFileSync(join(outputDir, 'finalize-result.json'), JSON.stringify({ aggregate: agg, summary_line: summaryLine }, null, 2));
+  console.error(JSON.stringify({ ok: false, invariant_holds: false, error: failureMsg, defect_row: defectRow }));
+  process.exit(1);
+}
+
+console.log(JSON.stringify({
+  ok: true,
+  invariant_holds: invariantHolds,
+  defect_row: defectRow,
+  per_case: perCase,
+  summary_line: summaryLine,
+  aggregate_file: aggregatePath,
+}, null, 2));

package/skills/a2h-spec-implement/scripts/manifest/render_final_summary.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * render_final_summary.mjs
+ * Phase 3 §4: Generate the final pipeline summary string.
+ *
+ * CLI:
+ *   --stop-reason     all_passed | no_confirmed_defects | no_progress | max_rounds_reached
+ *   --rounds          integer, rounds_executed (optional)
+ *   --max-rounds      integer (optional)
+ *   --skip-test-auto  "true" | "false" (optional)
+ *
+ * Output (stdout JSON):
+ * { ok, summary_text, summary_markdown }
+ */
+
+const args = {};
+for (let i = 0; i < process.argv.length; i++) {
+  const arg = process.argv[i];
+  if (arg.startsWith('--')) {
+    const key = arg.slice(2);
+    let val = process.argv[i + 1];
+    // Parse known booleans
+    if (val === 'true') val = true;
+    if (val === 'false') val = false;
+    args[key] = val;
+    if (String(process.argv[i + 1] || '').startsWith('--')) { args[key] = true; i--; }
+  }
+}
+
+const {
+  'max-rounds': maxRounds,
+  rounds: roundsExecuted,
+} = args;
+
+// stop-reason accepts: ARG_STOP_REASON env, `--stop-reason <value>`, or `--stop-reason=<value>`.
+// (Env stays supported for callers that cannot quote safely.)
+const argvStopReason = (() => {
+  const i = process.argv.findIndex(a => a === '--stop-reason');
+  const next = i >= 0 ? process.argv[i + 1] : undefined;
+  if (next && !next.startsWith('--')) return next;
+  const eq = process.argv.find(a => a.startsWith('--stop-reason='));
+  return eq ? eq.slice('--stop-reason='.length) : undefined;
+})();
+const envSkipTestAuto = process.env.ARG_SKIP_TEST_AUTO;
+const stopReason = process.env.ARG_STOP_REASON ?? argvStopReason ?? args['stop-reason'];
+const skipTestAuto = envSkipTestAuto !== undefined ? envSkipTestAuto === 'true' : (args['skip-test-auto'] ?? false);
+
+if (!stopReason) {
+  console.error(JSON.stringify({ ok: false, error: 'Usage: render_final_summary --stop-reason <reason> [--rounds <n>] [--max-rounds <n>] [--skip-test-auto true|false]' }));
+  process.exit(1);
+}
+
+const overallStatus = stopReason === 'all_passed'
+  ? 'all scenarios passed'
+  : `converged with stop reason: ${stopReason}`;
+
+const skipNote = skipTestAuto
+  ? '\n\n⚠ Integration test (ROUND step ④.7) was skipped because no device was detected; rerun with a device or emulator available, or set --skip-test=false.'
+  : '';
+
+const roundsLabel = roundsExecuted !== undefined ? 'Rounds executed' : 'Max rounds';
+const roundsValue = roundsExecuted !== undefined
+  ? `${roundsExecuted}/${maxRounds || 'N/A'}`
+  : `${maxRounds || 'N/A'}`;
+
+const summaryText = `Overall status: ${overallStatus}
+${roundsLabel}: ${roundsValue}
+Stop reason: ${stopReason}${skipNote}`;
+
+const summaryMarkdown = `## Final Summary
+
+**Overall status:** ${overallStatus}
+
+**${roundsLabel}:** ${roundsValue}
+
+**Stop reason:** ${stopReason}${skipNote}`;
+
+console.log(JSON.stringify({ ok: true, summary_text: summaryText, summary_markdown: summaryMarkdown }));

package/skills/a2h-spec-implement/scripts/manifest/root_mirror.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * root_mirror.mjs
+ * Phase 3 §2: Mirror canonical outputs to OUTPUT/ root for backward compatibility.
+ *
+ * CLI:
+ *   --output     OUTPUT/
+ *
+ * Copies:
+ *   OUTPUT/code-review-report.md         ← newest round that has one
+ *   OUTPUT/self-test-report.md           ← newest round that has one
+ *   OUTPUT/self-test-fix-report.md       ← if it exists
+ *   OUTPUT/package-set/                  ← newest round whose package-set/ is non-empty
+ *                                          (clear-then-copy, skip if source==dest)
+ *                                          If no round ever built: leave untouched
+ *   OUTPUT/entry-default-{signed,unsigned}.hap
+ *                                        ← best-effort copy of entry-*.hap from OUTPUT/package-set/,
+ *                                          named after the artifact's real signing mode
+ *
+ * Output (stdout JSON):
+ * { ok, actions: [{file, action: "copied"|"skipped"|"skipped_not_found"|"error"}, ...] }
+ */
+
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'fs';
+import { dirname, join } from 'path';
+
+const args = {};
+for (let i = 0; i < process.argv.length; i++) {
+  const arg = process.argv[i];
+  if (arg.startsWith('--')) {
+    const key = arg.slice(2);
+    args[key] = process.argv[i + 1];
+    if (args[key]?.startsWith('--')) { args[key] = true; i--; }
+  }
+}
+
+const { output: outputDir } = args;
+
+if (!outputDir) {
+  console.error(JSON.stringify({ ok: false, error: 'Usage: root_mirror --output <path>' }));
+  process.exit(1);
+}
+
+const actions = [];
+
+function copyIfExists(src, dst) {
+  if (!existsSync(src)) {
+    actions.push({ file: dst, action: 'skipped_not_found', src });
+    return;
+  }
+  mkdirSync(dirname(dst), { recursive: true });
+  copyFileSync(src, dst);
+  actions.push({ file: dst, action: 'copied', src });
+}
+
+// ── Round discovery ───────────────────────────────────────────────────────────
+// Rounds live directly under OUTPUT/ as round-{n}/. Scan rather than take a count
+// argument: the directories on disk are the authority on what actually ran.
+function roundDirsNewestFirst() {
+  if (!existsSync(outputDir)) return [];
+  return readdirSync(outputDir)
+    .map(name => ({ name, n: /^round-(\d+)$/.exec(name)?.[1] }))
+    .filter(e => e.n !== undefined)
+    .map(e => ({ dir: join(outputDir, e.name), n: parseInt(e.n, 10) }))
+    .sort((a, b) => b.n - a.n);
+}
+
+const rounds = roundDirsNewestFirst();
+
+// ── Step A: mirror the newest round that has each artifact ────────────────────
+const FILES_TO_MIRROR = ['code-review-report.md', 'self-test-report.md', 'self-test-fix-report.md'];
+
+for (const filename of FILES_TO_MIRROR) {
+  const hit = rounds.find(r => existsSync(join(r.dir, filename)));
+  if (hit) {
+    copyIfExists(join(hit.dir, filename), join(outputDir, filename));
+  } else {
+    actions.push({ file: join(outputDir, filename), action: 'skipped_no_round_has_this_file' });
+  }
+}
+
+// ── Step B: mirror the newest round that built (LAST_GOOD_PACKAGE_SET) ────────
+let lastGoodPackageSet = null;
+for (const r of rounds) {
+  const roundPackageSet = join(r.dir, 'package-set');
+  if (existsSync(roundPackageSet)) {
+    const files = readdirSync(roundPackageSet).filter(f => f.includes('signed') || f.endsWith('.hap') || f.endsWith('.hsp'));
+    if (files.length > 0) {
+      lastGoodPackageSet = roundPackageSet;
+      break;
+    }
+  }
+}
+
+const outputPackageSet = join(outputDir, 'package-set');
+
+if (lastGoodPackageSet) {
+  // Skip if source == dest (already up to date)
+  const srcFiles = readdirSync(lastGoodPackageSet).sort().join(',');
+  const dstFiles = existsSync(outputPackageSet) ? readdirSync(outputPackageSet).sort().join(',') : '';
+  if (srcFiles === dstFiles && srcFiles !== '') {
+    actions.push({ file: 'package-set', action: 'skipped_already_current' });
+  } else {
+    rmSync(outputPackageSet, { recursive: true, force: true });
+    mkdirSync(outputPackageSet, { recursive: true });
+    for (const f of readdirSync(lastGoodPackageSet)) {
+      copyFileSync(join(lastGoodPackageSet, f), join(outputPackageSet, f));
+    }
+    actions.push({ file: 'package-set/', action: 'copied', source: lastGoodPackageSet });
+  }
+} else {
+  actions.push({ file: 'package-set/', action: 'skipped_no_round_built' });
+}
+
+// ── Step C: root entry HAP mirror (best-effort) ────────────────────────────────
+// The mirrored name states the artifact's real signing mode. A project with
+// `app.signingConfigs: []` produces entry-default-unsigned.hap; copying that to
+// entry-default-signed.hap would hand a consumer a file whose name promises an
+// installable package and whose bytes are not one.
+if (existsSync(outputPackageSet)) {
+  const entryHap = readdirSync(outputPackageSet).find(f => f.startsWith('entry-') && f.endsWith('.hap'));
+  if (entryHap) {
+    const unsigned = entryHap.includes('-unsigned.');
+    const mirrorName = unsigned ? 'entry-default-unsigned.hap' : 'entry-default-signed.hap';
+    copyFileSync(join(outputPackageSet, entryHap), join(outputDir, mirrorName));
+    actions.push({ file: mirrorName, action: 'copied', source: entryHap, signing_mode: unsigned ? 'unsigned' : 'signed' });
+    if (unsigned) {
+      actions.push({ file: 'entry-default-signed.hap', action: 'skipped_unsigned_build', note: 'project has no signing config; mirrored as entry-default-unsigned.hap' });
+    }
+  } else {
+    actions.push({ file: 'entry-default-*.hap', action: 'skipped_no_entry_hap_in_package_set' });
+  }
+} else {
+  actions.push({ file: 'entry-default-*.hap', action: 'skipped_package_set_not_found' });
+}
+
+console.log(JSON.stringify({ ok: true, actions }, null, 2));

package/skills/a2h-spec-implement/scripts/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "hometrans-scripts",
+  "private": true,
+  "type": "module",
+  "description": "HomeTrans 流水线 Node 脚本依赖(设备驱动 device_ui/l2_run 经 device_ui_core 懒加载 hypium-driver;其余零依赖)。插件形态下 scripts/ 位于 node_modules 内部,无法在原地 npm install —— device_ui_core.loadDriverPkg 会回退到全局 npm root,缺失时按下面声明的版本自动 npm install -g。该版本号是自动安装的唯一来源,只接受精确 semver(范围写法会被降级为 latest)。",
+  "engines": {
+    "node": ">=20.11.1"
+  },
+  "dependencies": {
+    "hypium-driver": "^6.1.210"
+  }
+}