@sireai/optimus 0.1.35 → 0.1.38

package/embedded-skills/task/bugfix/android-hprof-analyzer/SKILL.md

@@ -0,0 +1,37 @@
+# Android HPROF Analyzer
+
+Use this skill for `bugfix` tasks when any evidence file name contains `hprof`.
+
+## Mandatory use
+- If evidence contains a file whose basename includes `hprof`, run this skill before claiming a memory-leak root cause.
+- Do not rely on screenshots alone when an HPROF file is available.
+- Use the generated `summary.json` and `summary.md` as the primary heap-analysis fact source.
+
+## Input
+- Preferred: an evidence manifest path plus an output directory.
+- Optional: an explicit evidence directory and an obfuscation mapping file.
+- The Shark CLI runtime is downloaded on demand into `~/.optimus/tools/shark/` the first time this skill runs.
+
+## Command
+```bash
+node .agents/skills/android-hprof-analyzer/scripts/analyze-hprof.mjs \
+  --manifest <evidence-manifest-path> \
+  --output <artifactDir>/hprof-analysis
+```
+
+Optional flags:
+```bash
+  --evidence-dir <dir>
+  --mapping <mapping-file>
+```
+
+## Output
+- `summary.json`: structured analysis status and per-file metadata
+- `summary.md`: concise human-readable summary with raw output references
+- `raw/*.txt`: raw Shark CLI stdout/stderr for each analyzed dump
+
+## Rules
+- Analyze every discovered evidence file whose basename contains `hprof`.
+- If analysis fails, report whether the blocker was missing Java, missing embedded runtime, runner failure, or invalid dump.
+- If first-use setup fails, report whether the download, checksum, or extraction step failed.
+- Mention which HPROF file was analyzed in `result.md`.

package/embedded-skills/task/bugfix/android-hprof-analyzer/runtime/README.md

@@ -0,0 +1,11 @@
+This directory documents the runtime source used by the embedded
+`android-hprof-analyzer` bugfix skill.
+
+Source release:
+- square/leakcanary `shark-cli-2.14.zip`
+
+Runtime behavior:
+- Optimus does not vendor the Shark CLI distribution inside the npm package.
+- The skill downloads the pinned release on first use and caches it under
+  `~/.optimus/tools/shark/`.
+- A local Java runtime is still required.

package/embedded-skills/task/bugfix/android-hprof-analyzer/scripts/analyze-hprof.mjs

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+
+import { execFile } from "node:child_process";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const SCRIPT_DIR = resolve(dirname(fileURLToPath(import.meta.url)));
+const RUNNER_PATH = join(SCRIPT_DIR, "run-shark.sh");
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (!options.outputDir) {
+    throw new Error("analyze-hprof requires --output <dir>.");
+  }
+  if (!options.manifestPath && !options.evidenceDir) {
+    throw new Error("analyze-hprof requires --manifest <path> or --evidence-dir <dir>.");
+  }
+
+  const outputDir = resolve(options.outputDir);
+  const rawDir = join(outputDir, "raw");
+  await mkdir(rawDir, { recursive: true });
+
+  const evidenceFiles = await discoverHprofFiles(options);
+  if (evidenceFiles.length === 0) {
+    const emptySummary = {
+      tool: "embedded-shark",
+      status: "failed",
+      files: [],
+      findings: [],
+      warnings: ["No evidence files whose basename contains 'hprof' were found."]
+    };
+    await writeOutputs(outputDir, emptySummary, ["No HPROF evidence files were found."]);
+    process.exitCode = 1;
+    return;
+  }
+
+  const files = [];
+  const warnings = [];
+  for (const [index, filePath] of evidenceFiles.entries()) {
+    const rawPath = join(rawDir, `${String(index + 1).padStart(2, "0")}-${sanitizeName(basename(filePath))}.txt`);
+    const args = [];
+    if (options.mappingPath) {
+      args.push("--obfuscation-mapping", resolve(options.mappingPath));
+    }
+    args.push("--hprof", filePath, "analyze");
+
+    try {
+      const { stdout, stderr } = await execFileAsync(RUNNER_PATH, args, {
+        cwd: process.cwd(),
+        maxBuffer: 20 * 1024 * 1024,
+        env: process.env
+      });
+      const combined = [stdout, stderr].filter(Boolean).join("\n").trim();
+      await writeFile(rawPath, combined || "(no output)\n", "utf8");
+      files.push({
+        path: filePath,
+        analyzed: true,
+        rawOutputPath: rawPath,
+        findings: extractFindingHints(combined)
+      });
+    } catch (error) {
+      const stdout = error?.stdout ? String(error.stdout) : "";
+      const stderr = error?.stderr ? String(error.stderr) : error instanceof Error ? error.message : String(error);
+      const combined = [stdout, stderr].filter(Boolean).join("\n").trim();
+      await writeFile(rawPath, combined || "(no output)\n", "utf8");
+      const reason = classifyRunnerFailure(combined, error);
+      warnings.push(`${basename(filePath)}: ${reason}`);
+      files.push({
+        path: filePath,
+        analyzed: false,
+        rawOutputPath: rawPath,
+        error: reason,
+        findings: []
+      });
+    }
+  }
+
+  const findings = files.flatMap((entry) => entry.findings.map((finding) => ({
+    sourceFile: entry.path,
+    ...finding
+  })));
+  const analyzedCount = files.filter((entry) => entry.analyzed).length;
+  const status = analyzedCount === files.length
+    ? "ok"
+    : analyzedCount > 0
+      ? "partial"
+      : "failed";
+  const summary = {
+    tool: "embedded-shark",
+    status,
+    files,
+    findings,
+    warnings
+  };
+
+  const markdownLines = [
+    "# HPROF Analysis Summary",
+    "",
+    `- Status: ${status}`,
+    `- Files discovered: ${files.length}`,
+    `- Files analyzed: ${analyzedCount}`,
+    "",
+    "## Files"
+  ];
+  for (const entry of files) {
+    markdownLines.push(
+      `- ${relative(outputDir, entry.path) || entry.path}: ${entry.analyzed ? "analyzed" : `failed (${entry.error})`}`,
+      `  - Raw Output: ${relative(outputDir, entry.rawOutputPath) || entry.rawOutputPath}`
+    );
+    for (const finding of entry.findings) {
+      markdownLines.push(`  - Finding: ${finding.target}${finding.retainPath ? ` | Path: ${finding.retainPath}` : ""}`);
+    }
+  }
+  if (warnings.length > 0) {
+    markdownLines.push("", "## Warnings");
+    for (const warning of warnings) {
+      markdownLines.push(`- ${warning}`);
+    }
+  }
+
+  await writeOutputs(outputDir, summary, markdownLines);
+  if (status === "failed") {
+    process.exitCode = 1;
+  }
+}
+
+function parseArgs(argv) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = argv[index + 1];
+    if (!arg.startsWith("--")) {
+      continue;
+    }
+    if (!next || next.startsWith("--")) {
+      throw new Error(`Missing value for ${arg}.`);
+    }
+    if (arg === "--manifest") {
+      options.manifestPath = next;
+      index += 1;
+      continue;
+    }
+    if (arg === "--evidence-dir") {
+      options.evidenceDir = next;
+      index += 1;
+      continue;
+    }
+    if (arg === "--output") {
+      options.outputDir = next;
+      index += 1;
+      continue;
+    }
+    if (arg === "--mapping") {
+      options.mappingPath = next;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  return options;
+}
+
+async function discoverHprofFiles(options) {
+  const discovered = new Set();
+  if (options.manifestPath) {
+    const manifestPath = resolve(options.manifestPath);
+    const manifestDir = dirname(manifestPath);
+    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    for (const value of collectPathValues(manifest)) {
+      await maybeAddFile(resolve(manifestDir, value), discovered);
+    }
+    await walkForHprofFiles(manifestDir, discovered);
+  }
+  if (options.evidenceDir) {
+    await walkForHprofFiles(resolve(options.evidenceDir), discovered);
+  }
+  return [...discovered].sort((left, right) => left.localeCompare(right));
+}
+
+function collectPathValues(node, values = []) {
+  if (!node) {
+    return values;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      collectPathValues(item, values);
+    }
+    return values;
+  }
+  if (typeof node === "object") {
+    for (const [key, value] of Object.entries(node)) {
+      if (typeof value === "string" && key.toLowerCase().endsWith("path")) {
+        values.push(value);
+      } else {
+        collectPathValues(value, values);
+      }
+    }
+  }
+  return values;
+}
+
+async function walkForHprofFiles(rootDir, discovered) {
+  let entries = [];
+  try {
+    entries = await readdir(rootDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const entryPath = join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      await walkForHprofFiles(entryPath, discovered);
+    } else if (entry.isFile()) {
+      await maybeAddFile(entryPath, discovered);
+    }
+  }
+}
+
+async function maybeAddFile(filePath, discovered) {
+  if (!basename(filePath).toLowerCase().includes("hprof")) {
+    return;
+  }
+  try {
+    const info = await stat(filePath);
+    if (info.isFile()) {
+      discovered.add(filePath);
+    }
+  } catch {
+    // Ignore missing paths recorded in manifests.
+  }
+}
+
+function extractFindingHints(output) {
+  if (!output) {
+    return [];
+  }
+  const hints = [];
+  const retainedPattern = /([A-Za-z0-9_$.]+)\s+leaking/giu;
+  const pathPattern = /GC Root(?:.|\n){0,300}/iu;
+  const targets = [...output.matchAll(retainedPattern)].map((match) => match[1]).slice(0, 5);
+  const pathMatch = output.match(pathPattern)?.[0]?.replace(/\s+/gu, " ").trim();
+  for (const target of targets) {
+    hints.push({
+      target,
+      ...(pathMatch ? { retainPath: pathMatch } : {})
+    });
+  }
+  return hints;
+}
+
+function classifyRunnerFailure(output, error) {
+  const text = `${output}\n${error instanceof Error ? error.message : ""}`.toLowerCase();
+  if (text.includes("java runtime is required") || text.includes("no 'java' command could be found")) {
+    return "missing_java";
+  }
+  if (text.includes("embedded shark runner is unavailable")) {
+    return "missing_embedded_runtime";
+  }
+  if (text.includes("file not found") || text.includes("no such file")) {
+    return "missing_hprof_file";
+  }
+  if (text.includes("heap dump") || text.includes("hprof")) {
+    return "runner_failed";
+  }
+  return "runner_failed";
+}
+
+async function writeOutputs(outputDir, summary, markdownLines) {
+  await mkdir(outputDir, { recursive: true });
+  await writeFile(join(outputDir, "summary.json"), JSON.stringify(summary, null, 2), "utf8");
+  await writeFile(join(outputDir, "summary.md"), `${markdownLines.join("\n")}\n`, "utf8");
+}
+
+function sanitizeName(name) {
+  const extension = extname(name);
+  const base = extension ? name.slice(0, -extension.length) : name;
+  return `${base.replace(/[^\w.-]+/gu, "_").slice(0, 120) || "hprof"}${extension || ".txt"}`.replace(/\.txt$/u, "");
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/embedded-skills/task/bugfix/android-hprof-analyzer/scripts/ensure-shark-runtime.mjs

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { access, appendFile, chmod, copyFile, mkdir, mkdtemp, rename, rm, stat } from "node:fs/promises";
+import { get } from "node:https";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const SHARK_VERSION = process.env.OPTIMUS_HPROF_SHARK_VERSION?.trim() || "2.14";
+const ARCHIVE_NAME = `shark-cli-${SHARK_VERSION}.zip`;
+const ARCHIVE_DIR_NAME = `shark-cli-${SHARK_VERSION}`;
+const DEFAULT_ARCHIVE_URL = `https://github.com/square/leakcanary/releases/download/v${SHARK_VERSION}/${ARCHIVE_NAME}`;
+const DEFAULT_ARCHIVE_SHA256 = "4a1022a4610fd6a4a1306b264f95985c4210e169e2bd4b0ad19bbdcc16d6beef";
+const SCRIPT_DIR = resolve(dirname(fileURLToPath(import.meta.url)));
+const LOG_PREFIX = "[optimus][hprof-runtime]";
+let logFilePathPromise;
+
+async function main() {
+  const cacheRoot = resolve(
+    process.env.OPTIMUS_HPROF_CACHE_DIR?.trim()
+      || join(process.env.HOME?.trim() || homedir(), ".optimus", "tools", "shark")
+  );
+  const archiveUrl = process.env.OPTIMUS_HPROF_SHARK_URL?.trim() || DEFAULT_ARCHIVE_URL;
+  const archiveSha256 = process.env.OPTIMUS_HPROF_SHARK_SHA256?.trim() || DEFAULT_ARCHIVE_SHA256;
+  const archivePathOverride = process.env.OPTIMUS_HPROF_SHARK_ARCHIVE?.trim();
+  const installDir = join(cacheRoot, ARCHIVE_DIR_NAME);
+  const runnerPath = join(installDir, "bin", "shark-cli");
+
+  if (await isExecutableFile(runnerPath)) {
+    logInfo(`Using cached Shark runtime at ${installDir}.`);
+    process.stdout.write(runnerPath);
+    return;
+  }
+
+  await mkdir(cacheRoot, { recursive: true });
+  const tempRoot = await mkdtemp(join(tmpdir(), "optimus-shark-install-"));
+  logInfo(`Preparing Shark runtime ${SHARK_VERSION} under ${cacheRoot}.`);
+
+  try {
+    const archivePath = archivePathOverride ? resolve(archivePathOverride) : join(tempRoot, ARCHIVE_NAME);
+    if (!archivePathOverride) {
+      logInfo(`Downloading Shark runtime ${SHARK_VERSION} from ${archiveUrl}.`);
+      await downloadArchive(archiveUrl, archivePath);
+      logInfo(`Downloaded Shark archive to ${archivePath}.`);
+    } else {
+      logInfo(`Using provided Shark archive at ${archivePath}.`);
+    }
+    logInfo(`Verifying Shark archive checksum (${archiveSha256.slice(0, 12)}...).`);
+    await verifyArchiveChecksum(archivePath, archiveSha256);
+    logInfo("Checksum verified.");
+
+    const extractRoot = join(tempRoot, "extract");
+    await mkdir(extractRoot, { recursive: true });
+    logInfo(`Extracting Shark archive into ${extractRoot}.`);
+    await extractArchive(archivePath, extractRoot);
+    logInfo("Archive extracted.");
+
+    const extractedDir = join(extractRoot, ARCHIVE_DIR_NAME);
+    const extractedRunnerPath = join(extractedDir, "bin", "shark-cli");
+    if (!(await isExecutableFile(extractedRunnerPath))) {
+      throw new Error(`Downloaded Shark archive did not contain an executable runner at ${extractedRunnerPath}.`);
+    }
+    await chmod(extractedRunnerPath, 0o755);
+
+    const stagingDir = join(cacheRoot, `.installing-${Date.now()}-${process.pid}`);
+    await rm(stagingDir, { recursive: true, force: true });
+    await rename(extractedDir, stagingDir);
+    try {
+      await rename(stagingDir, installDir);
+      logInfo(`Installed Shark runtime at ${installDir}.`);
+    } catch (error) {
+      if (await isExecutableFile(runnerPath)) {
+        await rm(stagingDir, { recursive: true, force: true });
+        logInfo(`Another process finished installation first; reusing cached runtime at ${installDir}.`);
+      } else {
+        throw error;
+      }
+    }
+
+    process.stdout.write(runnerPath);
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+async function downloadArchive(url, destinationPath) {
+  if (url.startsWith("file://")) {
+    await copyFile(fileURLToPath(url), destinationPath);
+    return;
+  }
+  if (!url.startsWith("https://")) {
+    throw new Error(`Unsupported Shark archive URL: ${url}`);
+  }
+
+  await new Promise((resolvePromise, rejectPromise) => {
+    const request = get(url, (response) => {
+      if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        response.resume();
+        downloadArchive(response.headers.location, destinationPath).then(resolvePromise, rejectPromise);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        rejectPromise(new Error(`download_failed: HTTP ${response.statusCode ?? "unknown"}`));
+        return;
+      }
+
+      const output = createWriteStream(destinationPath);
+      output.on("finish", () => {
+        output.close();
+        resolvePromise(undefined);
+      });
+      output.on("error", rejectPromise);
+      response.on("error", rejectPromise);
+      response.pipe(output);
+    });
+    request.on("error", rejectPromise);
+  });
+}
+
+async function verifyArchiveChecksum(archivePath, expectedSha256) {
+  const actualSha256 = await computeSha256(archivePath);
+  if (actualSha256 !== expectedSha256.toLowerCase()) {
+    throw new Error(`checksum_mismatch: expected ${expectedSha256}, received ${actualSha256}`);
+  }
+}
+
+async function computeSha256(filePath) {
+  const hash = createHash("sha256");
+  await new Promise((resolvePromise, rejectPromise) => {
+    const input = createReadStream(filePath);
+    input.on("data", (chunk) => hash.update(chunk));
+    input.on("end", resolvePromise);
+    input.on("error", rejectPromise);
+  });
+  return hash.digest("hex");
+}
+
+async function extractArchive(archivePath, extractRoot) {
+  try {
+    await execFileAsync("unzip", ["-oq", archivePath, "-d", extractRoot], {
+      cwd: SCRIPT_DIR,
+      maxBuffer: 16 * 1024 * 1024
+    });
+  } catch (error) {
+    throw new Error(`extract_failed: ${formatProcessError(error)}`.trim());
+  }
+}
+
+function formatProcessError(error) {
+  if (!error || typeof error !== "object") {
+    return "";
+  }
+  const stdout = "stdout" in error && error.stdout ? String(error.stdout).trim() : "";
+  const stderr = "stderr" in error && error.stderr ? String(error.stderr).trim() : "";
+  return [stdout, stderr].filter(Boolean).join(" ").slice(0, 500);
+}
+
+async function isExecutableFile(filePath) {
+  try {
+    await access(filePath);
+    const info = await stat(filePath);
+    return info.isFile();
+  } catch {
+    return false;
+  }
+}
+
+function logInfo(message) {
+  void writeLogLine(message);
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  void writeLogLine(`Failed to prepare Shark runtime: ${message}`);
+  process.exitCode = 1;
+});
+
+async function writeLogLine(message) {
+  const line = `${LOG_PREFIX} ${message}`;
+  process.stderr.write(`${line}\n`);
+  try {
+    const logPath = await resolveLogFilePath();
+    await mkdir(dirname(logPath), { recursive: true });
+    await appendFile(logPath, `${new Date().toISOString()} ${line}\n`, "utf8");
+  } catch {
+    // Best-effort logging only; stderr remains the primary fallback.
+  }
+}
+
+function resolveLogFilePath() {
+  if (!logFilePathPromise) {
+    const homeDir = process.env.HOME?.trim() || homedir();
+    const runtimeLogsDir = process.env.OPTIMUS_RUNTIME_LOGS_DIR?.trim()
+      ? resolve(process.env.OPTIMUS_RUNTIME_LOGS_DIR)
+      : join(homeDir, ".optimus", "runtime", "logs");
+    logFilePathPromise = Promise.resolve(join(runtimeLogsDir, `runtime-${currentDatePart()}.log`));
+  }
+  return logFilePathPromise;
+}
+
+function currentDatePart() {
+  const now = new Date();
+  const year = String(now.getFullYear());
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}

package/embedded-skills/task/bugfix/android-hprof-analyzer/scripts/run-shark.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+ENSURE_SCRIPT="${SCRIPT_DIR}/ensure-shark-runtime.mjs"
+
+if [[ -n "${OPTIMUS_HPROF_SHARK_RUNNER:-}" ]]; then
+  RUNNER="${OPTIMUS_HPROF_SHARK_RUNNER}"
+else
+  if ! command -v node >/dev/null 2>&1; then
+    echo "Node.js is required to provision the embedded Shark runtime but was not found in PATH." >&2
+    exit 2
+  fi
+  RUNNER="$(node "${ENSURE_SCRIPT}")"
+fi
+
+if [[ ! -x "${RUNNER}" ]]; then
+  echo "Embedded Shark runner is unavailable: ${RUNNER}" >&2
+  exit 2
+fi
+
+if ! command -v java >/dev/null 2>&1; then
+  echo "Java runtime is required for embedded Shark analysis but was not found in PATH." >&2
+  exit 3
+fi
+
+exec "${RUNNER}" "$@"

package/embedded-skills/task/bugfix/android-hprof-analyzer/skill.json

@@ -0,0 +1,6 @@
+{
+  "id": "android-hprof-analyzer",
+  "level": "task",
+  "version": "1.0.0",
+  "taskTypes": ["bugfix"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sireai/optimus",
-  "version": "0.1.35",
+  "version": "0.1.38",
   "description": "Optimus Codex-native background task runtime and harness scaffolding.",
   "repository": {
     "type": "git",

package/task-harnesses/bugfix/CONSTRAINTS.md

@@ -5,6 +5,8 @@
 - Do not present guesses, plans, recommendations, or unexecuted steps as completed facts.
 - Do not claim a fix without evidence.
 - If you ran checks, tests, builds, runtime validation, or manual verification, report what ran, how, what happened, and what remains unverified.
+- If available evidence contains any file whose basename includes `hprof`, do not skip heap-dump analysis before concluding a memory leak.
+- Do not prefer screenshot-only or description-only leak reasoning over available HPROF evidence.
 
 ## Patch rules
 - Change code only after reasoning through module boundaries, call chains, state flow, and upstream/downstream impact.

package/task-harnesses/bugfix/ROLE.md

@@ -20,6 +20,10 @@ Typical cases:
 - application code, scripts, configuration, build logic, or tests
 - crashes, runtime errors, incorrect behavior, state bugs, and boundary-condition defects
 
+## Evidence priority
+- If available evidence contains any file whose basename includes `hprof`, analyze that heap dump before claiming a memory-leak root cause.
+- Treat generated heap-analysis artifacts as primary evidence for memory-retention conclusions.
+
 ## Non-goals
 You are not:
 - the triage agent deciding whether the task should be accepted

package/task-harnesses/bugfix/STANDARD.md

@@ -93,6 +93,7 @@ Never overstate:
 - If code changed, runtime should also emit `patch.diff`.
 - If `patch.diff` exists, `Closure Level` must not be `Analysis Only`.
 - If `patch.diff` exists, Patch Closure Mode is mandatory.
+- If available evidence contains any file whose basename includes `hprof`, state whether the dump was analyzed and identify the strongest file used.
 - Before writing `result.md`, determine `Closure Level`, then follow exactly one language mode:
   - `Verified Fix` or `Repair Candidate`: Patch Closure Mode; all narrative sections are English
   - `Analysis Only`: Analysis Closure Mode; narrative sections are Chinese