@tea-agent/loop-agent 0.3.0 → 0.5.0

package/dist/worker/loop-agent/loop-agent-client.js

@@ -0,0 +1,105 @@
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseCommandJson } from "./parse-json.js";
+export const DEFAULT_WORKER_COMMAND_TIMEOUT_MS = 120_000;
+export class LoopAgentClient {
+    loopAgentBin;
+    baseArgs;
+    artifactRoot;
+    defaultTimeoutMs;
+    env;
+    constructor(options) {
+        this.loopAgentBin = options.loopAgentBin;
+        this.baseArgs = options.baseArgs ?? [];
+        this.artifactRoot = options.artifactRoot;
+        this.defaultTimeoutMs =
+            options.defaultTimeoutMs ?? DEFAULT_WORKER_COMMAND_TIMEOUT_MS;
+        this.env = options.env;
+    }
+    async run(args, options) {
+        return this.runCommand(this.loopAgentBin, [...this.baseArgs, ...args], args, options);
+    }
+    async runExternal(command, args, options) {
+        return this.runCommand(command, args, args, options);
+    }
+    async runCommand(command, commandArgs, resultArgs, options) {
+        const startedAt = Date.now();
+        const artifactDir = path.join(this.artifactRoot, sanitizeName(options.artifactName));
+        await mkdir(artifactDir, { recursive: true });
+        const { stdout, stderr, exitCode, timedOut } = await spawnCommand({
+            command,
+            args: commandArgs,
+            cwd: options.cwd,
+            timeoutMs: options.timeoutMs ?? this.defaultTimeoutMs,
+            env: { ...process.env, ...this.env, ...options.env },
+        });
+        const result = {
+            ok: exitCode === 0 && !timedOut,
+            args: resultArgs,
+            command,
+            cwd: options.cwd,
+            durationMs: Date.now() - startedAt,
+            exitCode,
+            stdout,
+            stderr,
+            timedOut,
+            artifacts: {
+                dir: artifactDir,
+                stdoutPath: path.join(artifactDir, "stdout.txt"),
+                stderrPath: path.join(artifactDir, "stderr.txt"),
+                resultPath: path.join(artifactDir, "result.json"),
+            },
+        };
+        if (options.expectJson) {
+            const parsed = parseCommandJson(stdout);
+            if (parsed.ok) {
+                result.json = parsed.value;
+            }
+            else {
+                result.ok = false;
+                result.parseFailure = parsed.failure;
+            }
+        }
+        await writeFile(result.artifacts.stdoutPath, stdout, "utf-8");
+        await writeFile(result.artifacts.stderrPath, stderr, "utf-8");
+        await writeFile(result.artifacts.resultPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
+        return result;
+    }
+}
+function spawnCommand(input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(input.command, input.args, {
+            cwd: input.cwd,
+            env: input.env,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, input.timeoutMs);
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timeout);
+            resolve({ stdout, stderr, exitCode, timedOut });
+        });
+    });
+}
+function sanitizeName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}

package/dist/worker/loop-agent/parse-json.js

@@ -0,0 +1,14 @@
+export function parseCommandJson(stdout) {
+    try {
+        return { ok: true, value: JSON.parse(stdout) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            failure: {
+                code: "json-parse-failed",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}

package/dist/worker/materialize/harness-task-materializer.js

@@ -0,0 +1,157 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { writeTaskConfig, writeTaskArtifactFile } from "../../infrastructure/harness/task-store.js";
+import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
+import { resolveLoopAgentProfile } from "../profile-mapping.js";
+import { mapRiskLevelToComplexity } from "../task-spec/complexity-mapping.js";
+import { validateTaskSpec } from "../task-spec/validate.js";
+export async function materializeTaskSpec(options) {
+    const now = options.now ?? new Date();
+    const validation = await validateTaskSpec(options.taskSpec, {
+        taskSpecPath: options.taskSpecPath,
+    });
+    if (!validation.ok) {
+        const codes = validation.errors.map((error) => error.code).join(", ");
+        throw new Error(`TaskSpec validation failed: ${codes}`);
+    }
+    const harnessTaskId = buildHarnessTaskId(options.taskSpec, now);
+    const existingConfig = await loadExistingTaskConfig(options.repoRoot, harnessTaskId);
+    if (!existingConfig) {
+        const newTaskResult = await options.client.run(["new-task", harnessTaskId, options.taskSpec.title], {
+            cwd: options.repoRoot,
+            artifactName: `new-task-${harnessTaskId}`,
+        });
+        if (!newTaskResult.ok) {
+            const racedConfig = await loadExistingTaskConfig(options.repoRoot, harnessTaskId);
+            if (!racedConfig) {
+                throw new Error(`loop-agent new-task failed with exit ${newTaskResult.exitCode}: ${newTaskResult.stderr}`);
+            }
+        }
+    }
+    const paths = getTaskPaths(options.repoRoot, harnessTaskId);
+    const baseConfig = await loadTaskConfig(options.repoRoot, harnessTaskId);
+    const taskConfig = {
+        ...baseConfig,
+        taskId: harnessTaskId,
+        title: options.taskSpec.title,
+        allowedPaths: options.taskSpec.constraints.allowed_paths,
+        forbiddenPaths: options.taskSpec.constraints.forbidden_paths,
+        hardConstraints: options.taskSpec.constraints.hard_constraints,
+        complexity: mapRiskLevelToComplexity(options.taskSpec.risk_level),
+        verifyMode: options.taskSpec.verify.mode,
+        verifyPreset: options.taskSpec.verify.preset,
+        verifyQuota: options.taskSpec.verify.quota,
+        autoCommitAfterVerify: false,
+    };
+    await writeTaskConfig(options.repoRoot, harnessTaskId, taskConfig);
+    const sourcePaths = {
+        requirementPath: path.join(paths.sourceDir, "需求.md"),
+        constraintsPath: path.join(paths.sourceDir, "执行约束.md"),
+        taskYamlPath: path.join(paths.sourceDir, "task.yaml"),
+    };
+    await mkdir(paths.sourceDir, { recursive: true });
+    await writeFile(sourcePaths.requirementPath, renderRequirementMarkdown(options.taskSpec), "utf-8");
+    await writeFile(sourcePaths.constraintsPath, renderConstraintsMarkdown(options.taskSpec), "utf-8");
+    await writeFile(sourcePaths.taskYamlPath, YAML.stringify(options.taskSpec), "utf-8");
+    const profileMapping = resolveLoopAgentProfile(options.taskSpec);
+    const manifest = {
+        schemaVersion: 1,
+        businessId: options.taskSpec.id,
+        harnessTaskId,
+        featureId: options.taskSpec.feature_id,
+        loopAgentProfile: profileMapping.loopAgentProfile,
+        taskConfigPath: paths.taskConfigPath,
+        source: sourcePaths,
+    };
+    await writeTaskArtifactFile(options.repoRoot, harnessTaskId, "materialize-manifest.json", `${JSON.stringify(manifest, null, 2)}\n`);
+    return manifest;
+}
+export function buildHarnessTaskId(taskSpec, now) {
+    const date = now.toISOString().slice(0, 10);
+    const slug = slugify(`${taskSpec.id}-${taskSpec.title}`);
+    return `${date}-${slug}`;
+}
+function slugify(value) {
+    return value
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+function renderRequirementMarkdown(taskSpec) {
+    const lines = [
+        `# ${taskSpec.title}`,
+        "",
+        `TaskSpec business id: ${taskSpec.id}`,
+        `Feature id: ${taskSpec.feature_id}`,
+        `Task type: ${taskSpec.type}`,
+        `Risk level: ${taskSpec.risk_level}`,
+        "",
+    ];
+    if (taskSpec.description) {
+        lines.push("## Description", "", taskSpec.description, "");
+    }
+    lines.push("## Goals", "", ...bulletLines(taskSpec.scope.goals), "");
+    if (taskSpec.scope.non_goals.length > 0) {
+        lines.push("## Non Goals", "", ...bulletLines(taskSpec.scope.non_goals), "");
+    }
+    if (taskSpec.scope.assumptions.length > 0) {
+        lines.push("## Assumptions", "", ...bulletLines(taskSpec.scope.assumptions), "");
+    }
+    if (taskSpec.scope.open_questions.length > 0) {
+        lines.push("## Open Questions", "", ...bulletLines(taskSpec.scope.open_questions), "");
+    }
+    lines.push("## Acceptance References", "", ...bulletLines(taskSpec.acceptance_refs), "");
+    lines.push("## Required Outputs", "", ...bulletLines(taskSpec.outputs.required), "");
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function renderConstraintsMarkdown(taskSpec) {
+    const lines = [
+        `# Execution Constraints for ${taskSpec.id}`,
+        "",
+        "## Allowed Paths",
+        "",
+        ...bulletLines(taskSpec.constraints.allowed_paths),
+        "",
+        "## Forbidden Paths",
+        "",
+        ...bulletLines(taskSpec.constraints.forbidden_paths),
+        "",
+        "## Hard Constraints",
+        "",
+        ...bulletLines(taskSpec.constraints.hard_constraints),
+        "",
+        "## Verification Commands",
+        "",
+        ...bulletLines(taskSpec.verify.commands.map((command) => command.command)),
+        "",
+        "## Source Docs",
+        "",
+        ...bulletLines(Object.entries(taskSpec.source_docs).map(([key, value]) => `${key}: ${value}`)),
+    ];
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function bulletLines(values) {
+    if (values.length === 0)
+        return ["- None"];
+    return values.map((value) => `- ${value}`);
+}
+async function loadExistingTaskConfig(repoRoot, taskId) {
+    try {
+        return await loadTaskConfig(repoRoot, taskId);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return undefined;
+        throw error;
+    }
+}
+function isNotFound(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/worker/pool/failure-routing.js

@@ -0,0 +1,98 @@
+const PRODUCT_CATEGORIES = new Set([
+    "SpecUnclear",
+    "ContractMismatch",
+    "ProductBug",
+    "TestBug",
+    "EnvFailure",
+    "FlakyTest",
+    "RiskyChange",
+    "DependencyFailure",
+    "NeedsHuman",
+    "Unknown",
+]);
+const FOLLOW_UP_BY_CATEGORY = {
+    SpecUnclear: "spec-clarification",
+    ContractMismatch: "architecture-contract-fix",
+    ProductBug: "dev-fix",
+    TestBug: "qa-fix-test",
+    EnvFailure: "env-fix",
+    FlakyTest: "flaky-test-analysis",
+    RiskyChange: "human-review",
+    DependencyFailure: "unblock-dependency",
+    NeedsHuman: "human-review",
+    Unknown: "human-triage",
+};
+const FOLLOW_UP_PREFIX_BY_CATEGORY = {
+    SpecUnclear: "SPEC",
+    ContractMismatch: "CONTRACT",
+    ProductBug: "FIX",
+    TestBug: "QA-FIX",
+    EnvFailure: "ENV",
+    FlakyTest: "FLAKY",
+    RiskyChange: "REVIEW",
+    DependencyFailure: "UNBLOCK",
+    NeedsHuman: "REVIEW",
+    Unknown: "TRIAGE",
+};
+const DAG_TO_PRODUCT_CATEGORY = {
+    validation: "SpecUnclear",
+    executor: "EnvFailure",
+    "write-guard": "RiskyChange",
+    timeout: "EnvFailure",
+    auth: "EnvFailure",
+    "human-required": "NeedsHuman",
+    "human-rejected": "NeedsHuman",
+    "shell-command": "ProductBug",
+    "static-error": "SpecUnclear",
+    "decision-envelope": "NeedsHuman",
+    skipped: "DependencyFailure",
+    unknown: "Unknown",
+};
+export function deriveFailureRoute(result) {
+    if (result.status === "succeeded")
+        return undefined;
+    const primaryFailure = readObject(result.reportDecision.primaryFailure);
+    const category = readProductCategory(primaryFailure, "productLineFailureCategory") ??
+        readProductCategory(primaryFailure, "productLineCategory") ??
+        readProductCategory(primaryFailure, "product_line_failure_category") ??
+        mapDagCategory(readString(primaryFailure, "failureCategory")) ??
+        mapDagCategory(readString(primaryFailure, "normalizedFailureCategory")) ??
+        categoryFromDecisionReason(result.reportDecision.reason);
+    const recommendedFollowUpKind = readString(primaryFailure, "recommendedFollowUpKind") ??
+        readString(primaryFailure, "recommendedFollowUp") ??
+        FOLLOW_UP_BY_CATEGORY[category];
+    return {
+        category,
+        recommendedFollowUpKind,
+        derivedFollowUpTaskId: `${FOLLOW_UP_PREFIX_BY_CATEGORY[category]}-${result.businessId}`,
+        source: primaryFailure ? "report-primary-failure" : "fallback",
+    };
+}
+function readProductCategory(value, key) {
+    const candidate = readString(value, key);
+    return candidate && PRODUCT_CATEGORIES.has(candidate)
+        ? candidate
+        : undefined;
+}
+function mapDagCategory(value) {
+    if (!value || value === "success")
+        return undefined;
+    return DAG_TO_PRODUCT_CATEGORY[value] ?? "Unknown";
+}
+function categoryFromDecisionReason(reason) {
+    if (reason === "report-json-unavailable" || reason === "report-run-missing") {
+        return "Unknown";
+    }
+    return "Unknown";
+}
+function readObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function readString(value, key) {
+    if (!value)
+        return undefined;
+    const child = value[key];
+    return typeof child === "string" ? child : undefined;
+}

package/dist/worker/pool/run-store.js

@@ -0,0 +1,125 @@
+import { appendFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+export function getTaskPoolRoot(repoRoot) {
+    return path.join(repoRoot, ".task-pool");
+}
+export function getRunsJsonlPath(repoRoot) {
+    return path.join(getTaskPoolRoot(repoRoot), "runs", "runs.jsonl");
+}
+export function getEventsJsonlPath(repoRoot) {
+    return path.join(getTaskPoolRoot(repoRoot), "events", "events.jsonl");
+}
+export function getTaskStatePath(repoRoot, taskId) {
+    return path.join(getTaskPoolRoot(repoRoot), "state", `${taskId}.json`);
+}
+export async function recordTaskPoolRun(input) {
+    await ensurePoolDirs(input.repoRoot);
+    await appendJsonlFile(getRunsJsonlPath(input.repoRoot), input.run);
+    await writeTaskPoolState(input.repoRoot, stateFromRun(input.run));
+    await appendJsonlFile(getEventsJsonlPath(input.repoRoot), eventFromRun(input.run));
+}
+export async function findRunByWorkerRunId(repoRoot, workerRunId) {
+    const runs = await readJsonlFile(getRunsJsonlPath(repoRoot));
+    return runs.find((run) => run.workerRunId === workerRunId);
+}
+export async function readTaskPoolState(repoRoot, taskId) {
+    const statePath = getTaskStatePath(repoRoot, taskId);
+    try {
+        return JSON.parse(await readFile(statePath, "utf-8"));
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return undefined;
+        throw error;
+    }
+}
+export async function readAllTaskPoolStates(repoRoot) {
+    const stateDir = path.join(getTaskPoolRoot(repoRoot), "state");
+    try {
+        const entries = await readdir(stateDir);
+        const states = {};
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            const raw = await readFile(path.join(stateDir, entry), "utf-8");
+            const state = JSON.parse(raw);
+            states[state.taskId] = state;
+        }
+        return states;
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return {};
+        throw error;
+    }
+}
+export async function writeTaskPoolState(repoRoot, state) {
+    const statePath = getTaskStatePath(repoRoot, state.taskId);
+    await mkdir(path.dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify({ schemaVersion: 1, ...state }, null, 2)}\n`, "utf-8");
+}
+export async function readJsonlFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        return raw
+            .split(/\r?\n/)
+            .filter((line) => line.trim().length > 0)
+            .map((line) => JSON.parse(line));
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return [];
+        throw error;
+    }
+}
+async function appendJsonlFile(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    try {
+        await appendFile(filePath, `${JSON.stringify(value)}\n`, "utf-8");
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        // Include path so callers/tests can identify which JSONL file failed
+        // (Node EISDIR messages on Windows often omit the path).
+        throw new Error(`failed to append ${filePath}: ${detail}`, { cause: error });
+    }
+}
+async function ensurePoolDirs(repoRoot) {
+    await mkdir(path.join(getTaskPoolRoot(repoRoot), "runs"), { recursive: true });
+    await mkdir(path.join(getTaskPoolRoot(repoRoot), "events"), { recursive: true });
+    await mkdir(path.join(getTaskPoolRoot(repoRoot), "state"), { recursive: true });
+}
+function stateFromRun(run) {
+    return {
+        taskId: run.taskId,
+        status: stateStatusFromRun(run),
+        updatedAt: run.recordedAt,
+        workerRunId: run.workerRunId,
+        ...(run.runRecordPath ? { lastRunRecordPath: run.runRecordPath } : {}),
+        ...(run.failure ? { failure: run.failure } : {}),
+    };
+}
+function stateStatusFromRun(run) {
+    if (run.status === "succeeded")
+        return "Done";
+    if (run.status === "run-error")
+        return "Blocked";
+    return "Failed";
+}
+function eventFromRun(run) {
+    return {
+        schemaVersion: 1,
+        at: run.recordedAt,
+        type: "task-run-recorded",
+        batchRunId: run.batchRunId,
+        workerRunId: run.workerRunId,
+        taskId: run.taskId,
+        status: run.status,
+    };
+}
+function isNotFound(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/worker/pool/types.js

@@ -0,0 +1 @@
+export {};

package/dist/worker/preflight.js

@@ -0,0 +1,108 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+export const DEFAULT_CHECK_REPO_TIMEOUT_MS = 300_000;
+export async function preflightTargetRepo(input) {
+    const commands = [];
+    if (!(await exists(path.join(input.repoRoot, "harness.json")))) {
+        return {
+            ok: false,
+            code: "target-not-initialized",
+            message: "target repo is missing harness.json",
+            commands,
+        };
+    }
+    if (!(await exists(path.join(input.repoRoot, ".harness")))) {
+        return {
+            ok: false,
+            code: "target-not-initialized",
+            message: "target repo is missing .harness",
+            commands,
+        };
+    }
+    const version = await input.client.run(["--version"], {
+        cwd: input.repoRoot,
+        artifactName: "loop-agent-version",
+    });
+    commands.push({ artifactName: "loop-agent-version", result: version });
+    if (!version.ok) {
+        return {
+            ok: false,
+            code: "version-failed",
+            message: "loop-agent --version failed",
+            commands,
+        };
+    }
+    const inspect = await input.client.run(["inspect"], {
+        cwd: input.repoRoot,
+        artifactName: "inspect",
+        expectJson: true,
+    });
+    commands.push({ artifactName: "inspect", result: inspect });
+    if (!inspect.ok || !inspect.json || typeof inspect.json !== "object") {
+        return {
+            ok: false,
+            code: "inspect-failed",
+            message: "loop-agent inspect failed or did not return JSON",
+            commands,
+        };
+    }
+    const docsAudit = await input.client.run(["docs", "audit"], {
+        cwd: input.repoRoot,
+        artifactName: "docs-audit",
+    });
+    commands.push({ artifactName: "docs-audit", result: docsAudit });
+    if (!docsAudit.ok) {
+        return {
+            ok: false,
+            code: "docs-audit-failed",
+            message: "loop-agent docs audit failed",
+            commands,
+        };
+    }
+    const gitStatus = await input.client.runExternal("git", ["status", "--short", "--branch"], {
+        cwd: input.repoRoot,
+        artifactName: "git-status",
+    });
+    commands.push({ artifactName: "git-status", result: gitStatus });
+    if (!gitStatus.ok) {
+        return {
+            ok: false,
+            code: "git-status-failed",
+            message: "git status --short --branch failed",
+            commands,
+        };
+    }
+    if (input.runCheckRepo) {
+        const [command, ...args] = input.checkRepoCommand ?? ["bash", "scripts/check-repo.sh"];
+        const checkRepo = await input.client.runExternal(command, args, {
+            cwd: input.repoRoot,
+            artifactName: "check-repo",
+            timeoutMs: DEFAULT_CHECK_REPO_TIMEOUT_MS,
+        });
+        commands.push({ artifactName: "check-repo", result: checkRepo });
+        if (!checkRepo.ok) {
+            return {
+                ok: false,
+                code: "check-repo-failed",
+                message: `${[command, ...args].join(" ")} failed`,
+                commands,
+            };
+        }
+    }
+    return {
+        ok: true,
+        version: version.stdout.trim(),
+        inspect: inspect.json,
+        gitStatus: gitStatus.stdout,
+        commands,
+    };
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/worker/profile-mapping.js

@@ -0,0 +1,76 @@
+const MINIMAL_TYPES = new Set([
+    "doc-update",
+    "qa-analysis",
+    "qa-casegen",
+    "qa-execute",
+]);
+const SENSITIVE_PATH_MARKERS = [
+    "auth",
+    "payment",
+    "database",
+    "migration",
+    "migrations",
+    "infra",
+    "secret",
+    "public-contract",
+    "public_contract",
+];
+export function resolveLoopAgentProfile(taskSpec) {
+    if (taskSpec.risk_level === "high") {
+        return mapping(taskSpec, "supervised", "risk-high", [
+            "risk_level=high requires supervised governance",
+        ]);
+    }
+    if (MINIMAL_TYPES.has(taskSpec.type)) {
+        return mapping(taskSpec, "minimal", `${taskSpec.type}-minimal`, [
+            `type=${taskSpec.type}`,
+        ]);
+    }
+    const sensitiveMarkers = collectSensitiveMarkers(taskSpec);
+    if (sensitiveMarkers.length > 0) {
+        return mapping(taskSpec, "reviewed", "sensitive-path", [
+            `sensitive path markers: ${sensitiveMarkers.join(", ")}`,
+        ]);
+    }
+    if (taskSpec.type === "backend-feature" ||
+        taskSpec.type === "frontend-feature") {
+        if (taskSpec.risk_level === "medium") {
+            return mapping(taskSpec, "reviewed", `${taskSpec.type}-medium`, [
+                `type=${taskSpec.type}`,
+                "risk_level=medium",
+            ]);
+        }
+        return mapping(taskSpec, "standard", `${taskSpec.type}-low`, [
+            `type=${taskSpec.type}`,
+            "risk_level=low",
+        ]);
+    }
+    if (taskSpec.type === "qa-testcode") {
+        return mapping(taskSpec, "standard", "qa-testcode-standard", [
+            "type=qa-testcode",
+        ]);
+    }
+    if (taskSpec.type === "ci-fix" || taskSpec.type === "reviewer-gate") {
+        return mapping(taskSpec, "reviewed", `${taskSpec.type}-reviewed`, [
+            `type=${taskSpec.type}`,
+        ]);
+    }
+    return mapping(taskSpec, "reviewed", "default-reviewed", [
+        `type=${taskSpec.type}`,
+        "default governance profile",
+    ]);
+}
+function mapping(taskSpec, loopAgentProfile, ruleId, reasons) {
+    return {
+        taskId: taskSpec.id,
+        businessProfile: taskSpec.type,
+        riskLevel: taskSpec.risk_level,
+        loopAgentProfile,
+        ruleId,
+        reasons,
+    };
+}
+function collectSensitiveMarkers(taskSpec) {
+    const haystack = taskSpec.constraints.allowed_paths.map((value) => value.toLowerCase());
+    return SENSITIVE_PATH_MARKERS.filter((marker) => haystack.some((value) => value.includes(marker)));
+}