@sireai/optimus 0.1.35 → 0.1.37

package/dist/task-environment/orchestration/task-runtime-policy.d.ts

@@ -0,0 +1,4 @@
+import type { TaskRuntimePolicy } from "../../types.js";
+export declare function getTaskRuntimePolicy(taskType: string): TaskRuntimePolicy;
+export declare function taskRequiresRepository(taskType: string): boolean;
+export declare function taskSupportsPublication(taskType: string): boolean;

package/dist/task-environment/orchestration/task-runtime-policy.js

@@ -0,0 +1,38 @@
+const TASK_RUNTIME_POLICIES = {
+    bugfix: {
+        taskType: "bugfix",
+        executionBinding: "repo_bound",
+        artifactContract: "patch_result",
+        requiresRepository: true,
+        requiresRepoMemory: true,
+        supportsPublication: true,
+        supportsPatchArtifact: true,
+        primaryResultFile: "result.md",
+        expectedPrimaryArtifacts: ["result.md", "patch.diff"]
+    },
+    pm: {
+        taskType: "pm",
+        executionBinding: "artifact_only",
+        artifactContract: "prototype_result",
+        requiresRepository: false,
+        requiresRepoMemory: false,
+        supportsPublication: false,
+        supportsPatchArtifact: false,
+        primaryResultFile: "result.md",
+        expectedPrimaryArtifacts: ["result.md"]
+    }
+};
+export function getTaskRuntimePolicy(taskType) {
+    const policy = TASK_RUNTIME_POLICIES[taskType];
+    if (!policy) {
+        throw new Error(`No runtime policy registered for taskType ${taskType}.`);
+    }
+    return policy;
+}
+export function taskRequiresRepository(taskType) {
+    return getTaskRuntimePolicy(taskType).requiresRepository;
+}
+export function taskSupportsPublication(taskType) {
+    return getTaskRuntimePolicy(taskType).supportsPublication;
+}
+//# sourceMappingURL=task-runtime-policy.js.map

package/dist/task-environment/orchestration/task-runtime-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-runtime-policy.js","sourceRoot":"","sources":["../../../src/task-environment/orchestration/task-runtime-policy.ts"],"names":[],"mappings":"AAEA,MAAM,qBAAqB,GAAsC;IAC/D,MAAM,EAAE;QACN,QAAQ,EAAE,QAAQ;QAClB,gBAAgB,EAAE,YAAY;QAC9B,gBAAgB,EAAE,cAAc;QAChC,kBAAkB,EAAE,IAAI;QACxB,kBAAkB,EAAE,IAAI;QACxB,mBAAmB,EAAE,IAAI;QACzB,qBAAqB,EAAE,IAAI;QAC3B,iBAAiB,EAAE,WAAW;QAC9B,wBAAwB,EAAE,CAAC,WAAW,EAAE,YAAY,CAAC;KACtD;IACD,EAAE,EAAE;QACF,QAAQ,EAAE,IAAI;QACd,gBAAgB,EAAE,eAAe;QACjC,gBAAgB,EAAE,kBAAkB;QACpC,kBAAkB,EAAE,KAAK;QACzB,kBAAkB,EAAE,KAAK;QACzB,mBAAmB,EAAE,KAAK;QAC1B,qBAAqB,EAAE,KAAK;QAC5B,iBAAiB,EAAE,WAAW;QAC9B,wBAAwB,EAAE,CAAC,WAAW,CAAC;KACxC;CACF,CAAC;AAEF,MAAM,UAAU,oBAAoB,CAAC,QAAgB;IACnD,MAAM,MAAM,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAC/C,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,6CAA6C,QAAQ,GAAG,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,QAAgB;IACrD,OAAO,oBAAoB,CAAC,QAAQ,CAAC,CAAC,kBAAkB,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,QAAgB;IACtD,OAAO,oBAAoB,CAAC,QAAQ,CAAC,CAAC,mBAAmB,CAAC;AAC5D,CAAC"}

package/dist/types.d.ts

@@ -106,6 +106,24 @@ export interface RuntimeEventContent {
     branch?: string;
     metadata?: Record<string, unknown>;
 }
+export interface PmTaskInputReferenceMaterial {
+    type: "doc" | "image" | "link" | "note";
+    title: string;
+    content?: string;
+    url?: string;
+}
+export interface PmTaskInput {
+    requirementDocument: string;
+    productGoal?: string;
+    targetUser?: string;
+    coreFlow?: string;
+    prototypeScope?: string;
+    platform?: "web" | "mobile_web" | "ios" | "android" | "desktop" | "responsive";
+    constraints?: string[];
+    referenceMaterials?: PmTaskInputReferenceMaterial[];
+    styleDirection?: string;
+    changeNotes?: string;
+}
 export interface FeishuAssigneeIdentity {
     displayName?: string;
     login?: string;
@@ -123,6 +141,19 @@ export interface PollingCheckpoint {
     skippedCount?: number;
 }
 export type RepositoryExecutionMode = "copy" | "inplace";
+export type TaskExecutionBinding = "repo_bound" | "artifact_only";
+export type TaskArtifactContract = "patch_result" | "prototype_result" | "analysis_result";
+export interface TaskRuntimePolicy {
+    taskType: string;
+    executionBinding: TaskExecutionBinding;
+    artifactContract: TaskArtifactContract;
+    requiresRepository: boolean;
+    requiresRepoMemory: boolean;
+    supportsPublication: boolean;
+    supportsPatchArtifact: boolean;
+    primaryResultFile: string;
+    expectedPrimaryArtifacts: string[];
+}
 export interface RepositoryRoot {
     path: string;
     alias?: string;
@@ -549,6 +580,7 @@ export interface RepositoryGuidanceContext {
 }
 export interface TaskExecutionContext {
     taskRootDir: string;
+    runtimePolicy: TaskRuntimePolicy;
     addresses: import("./task-environment/execution-addresses.js").ExecutionAddresses;
     sandboxMode: CodexSandboxMode;
     approvalPolicy: CodexApprovalPolicy;

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/shark-cli-${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"]
+}