@sireai/optimus 0.1.34 → 0.1.37

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"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sireai/optimus",
-  "version": "0.1.34",
+  "version": "0.1.37",
   "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

package/task-harnesses/pm/ACCEPT.md

@@ -0,0 +1,94 @@
+# ACCEPT
+
+## Decision target
+Route requirement-to-prototype tasks into the `pm` harness.
+
+Triage must decide:
+1. task type fit
+2. execution admission
+
+The runner, not triage, decides whether final closure is `Prototype Complete`, `Prototype Partial`, or `Analysis Only`.
+
+## Minimum input contract
+Treat the task as execution-ready when the request provides a usable requirement basis plus enough structure to prototype one bounded flow.
+
+Recommended PM input vocabulary:
+- `requirement_document`: the requirement basis, usually carried by manual submit `description`, `description-file`, or explicit `requirement-doc-file`
+- `product_goal`: the product or business objective
+- `target_user`: the primary user or audience
+- `core_flow`: the main interaction path to prototype
+- `prototype_scope`: the bounded slice to cover in one task
+- `constraints`: platform, channel, or prototype limits when they materially affect output
+
+Admission rule:
+- `requirement_document` must be present
+- at least one concrete `core_flow` must be explicit or clearly derivable from the requirement basis
+- `prototype_scope` must already be bounded in the request or easy to bound without inventing product strategy
+- `product_goal` and `target_user` should be present when they affect flow framing, prioritization, or screen meaning
+- `constraints` are required only when platform or delivery limits materially change the prototype
+
+## Task type fit
+Classify as `pm` only when all are true:
+- the request is to turn requirement input into an interactive HTML prototype
+- the expected output is a prototype artifact, not production code
+- the task centers on flow, structure, interaction, or state presentation
+- the prototype can be derived from requirement input without real system implementation
+
+Do not classify as `pm` when any are true:
+- the request is only strategy discussion, prioritization, or product advice
+- the request is for production frontend/backend implementation
+- the request is only visual design refinement with no requirement-to-prototype goal
+- the request is only PRD writing or requirement analysis with no interactive output expectation
+- the request is a bugfix, code-change, or repository task
+
+## Execution admission
+Accept into execution only when all are true:
+- the input provides a usable requirement basis
+- the input provides at least one concrete goal
+- the input provides at least one concrete flow, page path, or interaction path
+- the prototype scope is bounded enough for one task
+- the task does not depend on repository coupling or production-system integration
+
+## Still acceptable with partial information
+Still acceptable when:
+- some states, rules, copy, or edge cases are missing
+- but the main objective and at least one core flow are clear
+- and missing detail can be surfaced as assumptions rather than hidden invention
+
+## Reject for insufficient execution context
+Reject even if the task fits `pm` when any are true:
+- there is no concrete requirement, scenario, or flow to prototype
+- the input only says "make a prototype" or "design a page" with no clear objective or path
+- multiple unrelated areas are mixed with no bounded scope
+- the input is too abstract to determine what users can do in the prototype
+- the task depends on hidden context not present in the current input
+- the request expects product decisions to be invented from scratch
+- the request expects real implementation instead of prototype behavior
+
+## Missing information to mention first when rejecting
+- `requirement_document`
+- `product_goal`
+- `target_user`
+- `core_flow`
+- `prototype_scope`
+- `constraints`
+
+## Missing information mapping guidance
+- use `requirement_document` when there is no usable requirement basis in description, attachment, or referenced input
+- use `product_goal` when the business or user objective is unclear
+- use `target_user` when the intended user is unknown
+- use `core_flow` when no concrete flow or interaction path is described
+- use `prototype_scope` when the request is too broad for one prototype task
+- use `constraints` when platform, channel, or product limits are required but missing
+- prefer the smallest set of fields that explains the rejection
+
+## Event scope
+- `problem.discovered`
+- `task.submitted_manually`
+
+## Triage guidance
+- separate prototype-task fit from execution readiness
+- accept requirement-driven prototype work, not open-ended consulting
+- prefer one clear prototype objective over broad redesign asks
+- incomplete detail is acceptable if the core flow is still prototype-able
+- triage only decides whether the task enters the `pm` pipeline