@useorgx/openclaw-plugin 0.4.8 → 0.7.0

package/dist/http/helpers/mission-control.js

@@ -0,0 +1,1383 @@
+import { pickNumber, pickString, toIsoString } from "./value-utils.js";
+export const SLICE_SCOPE_MAX_TASKS = {
+    task: 6,
+    milestone: 15,
+    workstream: 30,
+};
+export const SLICE_SCOPE_TIMEOUT_MULTIPLIER = {
+    task: 1,
+    milestone: 2.5,
+    workstream: 4,
+};
+export const ORGX_SKILL_BY_DOMAIN = {
+    engineering: "orgx-engineering-agent",
+    product: "orgx-product-agent",
+    marketing: "orgx-marketing-agent",
+    sales: "orgx-sales-agent",
+    operations: "orgx-operations-agent",
+    design: "orgx-design-agent",
+    orchestration: "orgx-orchestrator-agent",
+};
+function safeErrorMessage(err) {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === "string")
+        return err;
+    return "Unexpected error";
+}
+function toNullableBoolean(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            return null;
+        if (value === 1)
+            return true;
+        if (value === 0)
+            return false;
+        return null;
+    }
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (["true", "1", "yes", "y", "on", "required"].includes(normalized))
+        return true;
+    if (["false", "0", "no", "n", "off"].includes(normalized))
+        return false;
+    return null;
+}
+function normalizeBehaviorAutomationLevel(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[\s-]+/g, "_");
+    if (!normalized)
+        return null;
+    if (normalized === "manual" ||
+        normalized === "manual_only" ||
+        normalized === "human" ||
+        normalized === "human_only") {
+        return "manual";
+    }
+    if (normalized === "supervised" ||
+        normalized === "constrained" ||
+        normalized === "reviewed" ||
+        normalized === "human_review") {
+        return "supervised";
+    }
+    if (normalized === "auto" ||
+        normalized === "autonomous" ||
+        normalized === "default") {
+        return "auto";
+    }
+    return null;
+}
+export function readBudgetEnvNumber(name, fallback, bounds = {}) {
+    const raw = process.env[name];
+    if (typeof raw !== "string" || raw.trim().length === 0)
+        return fallback;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    if (typeof bounds.min === "number" && parsed < bounds.min)
+        return fallback;
+    if (typeof bounds.max === "number" && parsed > bounds.max)
+        return fallback;
+    return parsed;
+}
+const DEFAULT_TOKEN_MODEL_PRICING_USD_PER_1M = {
+    // GPT-5.3 Codex API pricing is not published yet; use GPT-5.2 Codex pricing as proxy.
+    gpt53CodexProxy: {
+        input: readBudgetEnvNumber("ORGX_BUDGET_GPT53_CODEX_INPUT_PER_1M", 1.75, { min: 0 }),
+        cachedInput: readBudgetEnvNumber("ORGX_BUDGET_GPT53_CODEX_CACHED_INPUT_PER_1M", 0.175, {
+            min: 0,
+        }),
+        output: readBudgetEnvNumber("ORGX_BUDGET_GPT53_CODEX_OUTPUT_PER_1M", 14, { min: 0 }),
+    },
+    opus46: {
+        input: readBudgetEnvNumber("ORGX_BUDGET_OPUS46_INPUT_PER_1M", 5, { min: 0 }),
+        // Anthropic does not publish a fixed cached-input rate on the model page.
+        cachedInput: readBudgetEnvNumber("ORGX_BUDGET_OPUS46_CACHED_INPUT_PER_1M", 5, { min: 0 }),
+        output: readBudgetEnvNumber("ORGX_BUDGET_OPUS46_OUTPUT_PER_1M", 25, { min: 0 }),
+    },
+};
+export const DEFAULT_TOKEN_BUDGET_ASSUMPTIONS = {
+    tokensPerHour: readBudgetEnvNumber("ORGX_BUDGET_TOKENS_PER_HOUR", 1_200_000, { min: 1 }),
+    inputShare: readBudgetEnvNumber("ORGX_BUDGET_INPUT_TOKEN_SHARE", 0.86, { min: 0, max: 1 }),
+    cachedInputShare: readBudgetEnvNumber("ORGX_BUDGET_CACHED_INPUT_SHARE", 0.15, {
+        min: 0,
+        max: 1,
+    }),
+    contingencyMultiplier: readBudgetEnvNumber("ORGX_BUDGET_CONTINGENCY_MULTIPLIER", 1.3, {
+        min: 0.1,
+    }),
+    roundingStepUsd: readBudgetEnvNumber("ORGX_BUDGET_ROUNDING_STEP_USD", 5, { min: 0.01 }),
+};
+const DEFAULT_TOKEN_MODEL_MIX = {
+    gpt53CodexProxy: 0.7,
+    opus46: 0.3,
+};
+function modelCostPerMillionTokensUsd(pricing) {
+    const inputShare = DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.inputShare;
+    const outputShare = Math.max(0, 1 - inputShare);
+    const cachedShare = DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.cachedInputShare;
+    const uncachedShare = Math.max(0, 1 - cachedShare);
+    const effectiveInputRate = pricing.input * uncachedShare + pricing.cachedInput * cachedShare;
+    return inputShare * effectiveInputRate + outputShare * pricing.output;
+}
+function estimateBudgetUsdFromDurationHours(durationHours) {
+    if (!Number.isFinite(durationHours) || durationHours <= 0)
+        return 0;
+    const blendedPerMillionUsd = DEFAULT_TOKEN_MODEL_MIX.gpt53CodexProxy *
+        modelCostPerMillionTokensUsd(DEFAULT_TOKEN_MODEL_PRICING_USD_PER_1M.gpt53CodexProxy) +
+        DEFAULT_TOKEN_MODEL_MIX.opus46 *
+            modelCostPerMillionTokensUsd(DEFAULT_TOKEN_MODEL_PRICING_USD_PER_1M.opus46);
+    const tokenMillions = (durationHours * DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.tokensPerHour) / 1_000_000;
+    const rawBudgetUsd = tokenMillions *
+        blendedPerMillionUsd *
+        DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.contingencyMultiplier;
+    const roundedBudgetUsd = Math.round(rawBudgetUsd / DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.roundingStepUsd) *
+        DEFAULT_TOKEN_BUDGET_ASSUMPTIONS.roundingStepUsd;
+    return Math.max(0, roundedBudgetUsd);
+}
+function isLegacyHourlyBudget(budgetUsd, durationHours) {
+    if (!Number.isFinite(budgetUsd) || !Number.isFinite(durationHours) || durationHours <= 0) {
+        return false;
+    }
+    const legacyHourlyBudget = durationHours * 40;
+    return Math.abs(budgetUsd - legacyHourlyBudget) <= 0.5;
+}
+const DEFAULT_DURATION_HOURS = {
+    initiative: 40,
+    workstream: 16,
+    milestone: 6,
+    task: 2,
+};
+const DEFAULT_BUDGET_USD = {
+    initiative: estimateBudgetUsdFromDurationHours(DEFAULT_DURATION_HOURS.initiative),
+    workstream: estimateBudgetUsdFromDurationHours(DEFAULT_DURATION_HOURS.workstream),
+    milestone: estimateBudgetUsdFromDurationHours(DEFAULT_DURATION_HOURS.milestone),
+    task: estimateBudgetUsdFromDurationHours(DEFAULT_DURATION_HOURS.task),
+};
+const PRIORITY_LABEL_TO_NUM = {
+    urgent: 10,
+    high: 25,
+    medium: 50,
+    low: 75,
+};
+function clampPriority(value) {
+    if (!Number.isFinite(value))
+        return 60;
+    return Math.max(1, Math.min(100, Math.round(value)));
+}
+function mapPriorityNumToLabel(priorityNum) {
+    if (priorityNum <= 12)
+        return "urgent";
+    if (priorityNum <= 30)
+        return "high";
+    if (priorityNum <= 60)
+        return "medium";
+    return "low";
+}
+function getRecordMetadata(record) {
+    const metadata = record.metadata;
+    if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+        return metadata;
+    }
+    return {};
+}
+function extractBudgetUsdFromText(...texts) {
+    for (const text of texts) {
+        if (typeof text !== "string" || text.trim().length === 0)
+            continue;
+        const moneyMatch = /(?:expected\s+budget|budget)[^0-9$]{0,24}\$?\s*([0-9][0-9,]*(?:\.[0-9]{1,2})?)/i.exec(text);
+        if (!moneyMatch)
+            continue;
+        const numeric = Number(moneyMatch[1].replace(/,/g, ""));
+        if (Number.isFinite(numeric) && numeric >= 0)
+            return numeric;
+    }
+    return null;
+}
+function extractDurationHoursFromText(...texts) {
+    for (const text of texts) {
+        if (typeof text !== "string" || text.trim().length === 0)
+            continue;
+        const durationMatch = /(?:expected\s+duration|duration)[^0-9]{0,24}([0-9]+(?:\.[0-9]+)?)\s*h/i.exec(text);
+        if (!durationMatch)
+            continue;
+        const numeric = Number(durationMatch[1]);
+        if (Number.isFinite(numeric) && numeric >= 0)
+            return numeric;
+    }
+    return null;
+}
+export function pickStringArray(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (Array.isArray(value)) {
+            const items = value
+                .filter((entry) => typeof entry === "string")
+                .map((entry) => entry.trim())
+                .filter(Boolean);
+            if (items.length > 0)
+                return items;
+        }
+        if (typeof value === "string") {
+            const items = value
+                .split(",")
+                .map((entry) => entry.trim())
+                .filter(Boolean);
+            if (items.length > 0)
+                return items;
+        }
+    }
+    return [];
+}
+export function dedupeStrings(items) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        if (!item || seen.has(item))
+            continue;
+        seen.add(item);
+        out.push(item);
+    }
+    return out;
+}
+function normalizePriorityForEntity(record) {
+    const explicitPriorityNum = pickNumber(record, [
+        "priority_num",
+        "priorityNum",
+        "priority_number",
+    ]);
+    const priorityLabelRaw = pickString(record, ["priority", "priority_label"]);
+    if (explicitPriorityNum !== null) {
+        const clamped = clampPriority(explicitPriorityNum);
+        return {
+            priorityNum: clamped,
+            priorityLabel: priorityLabelRaw ?? mapPriorityNumToLabel(clamped),
+        };
+    }
+    if (priorityLabelRaw) {
+        const mapped = PRIORITY_LABEL_TO_NUM[priorityLabelRaw.toLowerCase()] ?? 60;
+        return {
+            priorityNum: mapped,
+            priorityLabel: priorityLabelRaw.toLowerCase(),
+        };
+    }
+    return {
+        priorityNum: 60,
+        priorityLabel: null,
+    };
+}
+function normalizeDependencies(record) {
+    const metadata = getRecordMetadata(record);
+    const direct = pickStringArray(record, [
+        "depends_on",
+        "dependsOn",
+        "dependency_ids",
+        "dependencyIds",
+        "dependencies",
+    ]);
+    const nested = pickStringArray(metadata, [
+        "depends_on",
+        "dependsOn",
+        "dependency_ids",
+        "dependencyIds",
+        "dependencies",
+    ]);
+    return dedupeStrings([...direct, ...nested]);
+}
+function toPositiveInteger(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const normalized = Math.floor(value);
+        return normalized > 0 ? normalized : null;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed))
+            return null;
+        const normalized = Math.floor(parsed);
+        return normalized > 0 ? normalized : null;
+    }
+    return null;
+}
+function normalizeSliceScopePreference(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    if (!normalized)
+        return null;
+    if (normalized === "adaptive" || normalized === "task" || normalized === "milestone" || normalized === "workstream") {
+        return normalized;
+    }
+    return null;
+}
+function normalizeDependencyMode(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    if (!normalized)
+        return null;
+    if (normalized === "strict" || normalized === "relaxed") {
+        return normalized;
+    }
+    return null;
+}
+function normalizeAssignedAgents(record) {
+    const metadata = getRecordMetadata(record);
+    const ids = dedupeStrings([
+        ...pickStringArray(record, ["assigned_agent_ids", "assignedAgentIds"]),
+        ...pickStringArray(metadata, ["assigned_agent_ids", "assignedAgentIds"]),
+    ]);
+    const names = dedupeStrings([
+        ...pickStringArray(record, ["assigned_agent_names", "assignedAgentNames"]),
+        ...pickStringArray(metadata, ["assigned_agent_names", "assignedAgentNames"]),
+    ]);
+    const objectCandidates = [
+        record.assigned_agents,
+        record.assignedAgents,
+        metadata.assigned_agents,
+        metadata.assignedAgents,
+    ];
+    const fromObjects = [];
+    for (const candidate of objectCandidates) {
+        if (!Array.isArray(candidate))
+            continue;
+        for (const entry of candidate) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const item = entry;
+            const id = pickString(item, ["id", "agent_id", "agentId"]) ?? "";
+            const name = pickString(item, ["name", "agent_name", "agentName"]) ?? id;
+            if (!name)
+                continue;
+            fromObjects.push({
+                id: id || `name:${name}`,
+                name,
+                domain: pickString(item, ["domain", "role"]),
+            });
+        }
+    }
+    const merged = [...fromObjects];
+    if (merged.length === 0 && (names.length > 0 || ids.length > 0)) {
+        const maxLen = Math.max(names.length, ids.length);
+        for (let i = 0; i < maxLen; i += 1) {
+            const id = ids[i] ?? `name:${names[i] ?? `agent-${i + 1}`}`;
+            const name = names[i] ?? ids[i] ?? `Agent ${i + 1}`;
+            merged.push({ id, name, domain: null });
+        }
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const item of merged) {
+        const key = `${item.id}:${item.name}`.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(item);
+    }
+    return deduped;
+}
+function toMissionControlNode(type, entity, fallbackInitiativeId) {
+    const record = entity;
+    const metadata = getRecordMetadata(record);
+    const initiativeId = pickString(record, ["initiative_id", "initiativeId"]) ??
+        pickString(metadata, ["initiative_id", "initiativeId"]) ??
+        (type === "initiative" ? String(record.id ?? fallbackInitiativeId) : fallbackInitiativeId);
+    const workstreamId = type === "workstream"
+        ? String(record.id ?? "")
+        : pickString(record, ["workstream_id", "workstreamId"]) ??
+            pickString(metadata, ["workstream_id", "workstreamId"]);
+    const milestoneId = type === "milestone"
+        ? String(record.id ?? "")
+        : pickString(record, ["milestone_id", "milestoneId"]) ??
+            pickString(metadata, ["milestone_id", "milestoneId"]);
+    const parentIdRaw = pickString(record, ["parentId", "parent_id"]) ??
+        pickString(metadata, ["parentId", "parent_id"]);
+    const parentId = parentIdRaw ??
+        (type === "initiative"
+            ? null
+            : type === "workstream"
+                ? initiativeId
+                : type === "milestone"
+                    ? workstreamId ?? initiativeId
+                    : milestoneId ?? workstreamId ?? initiativeId);
+    const status = pickString(record, ["status"]) ??
+        (type === "task" ? "todo" : "planned");
+    const dueDate = toIsoString(pickString(record, ["due_date", "dueDate", "target_date", "targetDate"]));
+    const etaEndAt = toIsoString(pickString(record, ["eta_end_at", "etaEndAt"]));
+    const expectedDuration = pickNumber(record, [
+        "expected_duration_hours",
+        "expectedDurationHours",
+        "duration_hours",
+        "durationHours",
+    ]) ??
+        pickNumber(metadata, [
+            "expected_duration_hours",
+            "expectedDurationHours",
+            "duration_hours",
+            "durationHours",
+        ]) ??
+        extractDurationHoursFromText(pickString(record, ["description", "summary", "context"]), pickString(metadata, ["description", "summary", "context"])) ??
+        DEFAULT_DURATION_HOURS[type];
+    const explicitBudget = pickNumber(record, [
+        "expected_budget_usd",
+        "expectedBudgetUsd",
+        "budget_usd",
+        "budgetUsd",
+    ]) ??
+        pickNumber(metadata, [
+            "expected_budget_usd",
+            "expectedBudgetUsd",
+            "budget_usd",
+            "budgetUsd",
+        ]);
+    const extractedBudget = extractBudgetUsdFromText(pickString(record, ["description", "summary", "context"]), pickString(metadata, ["description", "summary", "context"])) ?? null;
+    const tokenModeledBudget = estimateBudgetUsdFromDurationHours(expectedDuration > 0 ? expectedDuration : DEFAULT_DURATION_HOURS[type]) || DEFAULT_BUDGET_USD[type];
+    const expectedBudget = explicitBudget ??
+        (typeof extractedBudget === "number"
+            ? isLegacyHourlyBudget(extractedBudget, expectedDuration)
+                ? tokenModeledBudget
+                : extractedBudget
+            : DEFAULT_BUDGET_USD[type]);
+    const priority = normalizePriorityForEntity(record);
+    const behaviorConfigId = pickString(record, ["behavior_config_id", "behaviorConfigId"]) ??
+        pickString(metadata, ["behavior_config_id", "behaviorConfigId"]);
+    const behaviorConfigVersion = pickString(record, ["behavior_config_version", "behaviorConfigVersion"]) ??
+        pickString(metadata, ["behavior_config_version", "behaviorConfigVersion"]);
+    const behaviorConfigHash = pickString(record, ["behavior_config_hash", "behaviorConfigHash"]) ??
+        pickString(metadata, ["behavior_config_hash", "behaviorConfigHash"]);
+    const behaviorPolicySource = pickString(record, ["policy_source", "policySource"]) ??
+        pickString(metadata, ["policy_source", "policySource"]);
+    const behaviorContext = pickString(record, ["behavior_context", "behaviorContext", "behavior_prompt", "behaviorPrompt"]) ??
+        pickString(metadata, ["behavior_context", "behaviorContext", "behavior_prompt", "behaviorPrompt"]);
+    const behaviorRequiresApproval = toNullableBoolean(record.behavior_requires_approval ??
+        record.behaviorRequiresApproval ??
+        record.config_requires_approval ??
+        record.configRequiresApproval ??
+        record.requires_approval ??
+        record.requiresApproval) ??
+        toNullableBoolean(metadata.behavior_requires_approval ??
+            metadata.behaviorRequiresApproval ??
+            metadata.config_requires_approval ??
+            metadata.configRequiresApproval ??
+            metadata.requires_approval ??
+            metadata.requiresApproval);
+    const behaviorApprovalStatus = pickString(record, ["behavior_approval_status", "behaviorApprovalStatus", "approval_status", "approvalStatus"]) ??
+        pickString(metadata, [
+            "behavior_approval_status",
+            "behaviorApprovalStatus",
+            "approval_status",
+            "approvalStatus",
+        ]);
+    const behaviorApprovalDecisionId = pickString(record, [
+        "behavior_approval_decision_id",
+        "behaviorApprovalDecisionId",
+        "approval_decision_id",
+        "approvalDecisionId",
+    ]) ??
+        pickString(metadata, [
+            "behavior_approval_decision_id",
+            "behaviorApprovalDecisionId",
+            "approval_decision_id",
+            "approvalDecisionId",
+        ]);
+    const behaviorAutomationLevel = normalizeBehaviorAutomationLevel(pickString(record, ["automation_level", "automationLevel"])) ??
+        normalizeBehaviorAutomationLevel(pickString(metadata, ["automation_level", "automationLevel"]));
+    const sliceScopePreference = normalizeSliceScopePreference(pickString(record, [
+        "slice_scope_preference",
+        "sliceScopePreference",
+        "scope_preference",
+        "scopePreference",
+    ])) ??
+        normalizeSliceScopePreference(pickString(metadata, [
+            "slice_scope_preference",
+            "sliceScopePreference",
+            "scope_preference",
+            "scopePreference",
+        ]));
+    const maxSliceTasks = toPositiveInteger(pickNumber(record, ["max_slice_tasks", "maxSliceTasks", "slice_max_tasks", "sliceMaxTasks"])) ??
+        toPositiveInteger(pickNumber(metadata, ["max_slice_tasks", "maxSliceTasks", "slice_max_tasks", "sliceMaxTasks"]));
+    const maxParallelAgents = toPositiveInteger(pickNumber(record, [
+        "max_parallel_agents",
+        "maxParallelAgents",
+        "parallel_agents_max",
+        "parallelAgentsMax",
+    ])) ??
+        toPositiveInteger(pickNumber(metadata, [
+            "max_parallel_agents",
+            "maxParallelAgents",
+            "parallel_agents_max",
+            "parallelAgentsMax",
+        ]));
+    const dependencyMode = normalizeDependencyMode(pickString(record, ["dependency_mode", "dependencyMode", "slice_dependency_mode", "sliceDependencyMode"])) ??
+        normalizeDependencyMode(pickString(metadata, [
+            "dependency_mode",
+            "dependencyMode",
+            "slice_dependency_mode",
+            "sliceDependencyMode",
+        ]));
+    return {
+        id: String(record.id ?? ""),
+        type,
+        title: pickString(record, ["title", "name"]) ??
+            `${type[0].toUpperCase()}${type.slice(1)} ${String(record.id ?? "")}`,
+        status,
+        parentId: parentId ?? null,
+        initiativeId: initiativeId ?? null,
+        workstreamId: workstreamId ?? null,
+        milestoneId: milestoneId ?? null,
+        priorityNum: priority.priorityNum,
+        priorityLabel: priority.priorityLabel,
+        dependencyIds: normalizeDependencies(record),
+        dueDate,
+        etaEndAt,
+        expectedDurationHours: expectedDuration > 0 ? expectedDuration : DEFAULT_DURATION_HOURS[type],
+        expectedBudgetUsd: expectedBudget >= 0 ? expectedBudget : DEFAULT_BUDGET_USD[type],
+        assignedAgents: normalizeAssignedAgents(record),
+        behaviorConfigId: behaviorConfigId ?? null,
+        behaviorConfigVersion: behaviorConfigVersion ?? null,
+        behaviorConfigHash: behaviorConfigHash ?? null,
+        behaviorPolicySource: behaviorPolicySource ?? null,
+        behaviorContext: behaviorContext ?? null,
+        behaviorRequiresApproval,
+        behaviorApprovalStatus: behaviorApprovalStatus ?? null,
+        behaviorApprovalDecisionId: behaviorApprovalDecisionId ?? null,
+        behaviorAutomationLevel: behaviorAutomationLevel ?? null,
+        sliceScopePreference: sliceScopePreference ?? null,
+        maxSliceTasks: maxSliceTasks ?? null,
+        maxParallelAgents: maxParallelAgents ?? null,
+        dependencyMode: dependencyMode ?? null,
+        updatedAt: toIsoString(pickString(record, [
+            "updated_at",
+            "updatedAt",
+            "created_at",
+            "createdAt",
+        ])),
+    };
+}
+export function isTodoStatus(status) {
+    const normalized = status.toLowerCase();
+    return (normalized === "todo" ||
+        normalized === "not_started" ||
+        normalized === "planned" ||
+        normalized === "backlog" ||
+        normalized === "pending");
+}
+export function isInProgressStatus(status) {
+    const normalized = status.toLowerCase();
+    return (normalized === "in_progress" ||
+        normalized === "active" ||
+        normalized === "running" ||
+        normalized === "queued");
+}
+export function isDispatchableWorkstreamStatus(status) {
+    const normalized = status.toLowerCase();
+    if (!normalized)
+        return true;
+    return !(normalized === "blocked" ||
+        normalized === "done" ||
+        normalized === "completed" ||
+        normalized === "cancelled" ||
+        normalized === "archived" ||
+        normalized === "deleted");
+}
+export function isDoneStatus(status) {
+    const normalized = status.toLowerCase();
+    return (normalized === "done" ||
+        normalized === "completed" ||
+        normalized === "cancelled" ||
+        normalized === "archived" ||
+        normalized === "deleted");
+}
+function detectCycleEdgeKeys(edges) {
+    const adjacency = new Map();
+    for (const edge of edges) {
+        const list = adjacency.get(edge.from) ?? [];
+        list.push(edge.to);
+        adjacency.set(edge.from, list);
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const cycleEdgeKeys = new Set();
+    function dfs(nodeId) {
+        if (visited.has(nodeId))
+            return;
+        visiting.add(nodeId);
+        const next = adjacency.get(nodeId) ?? [];
+        for (const childId of next) {
+            if (visiting.has(childId)) {
+                cycleEdgeKeys.add(`${nodeId}->${childId}`);
+                continue;
+            }
+            dfs(childId);
+        }
+        visiting.delete(nodeId);
+        visited.add(nodeId);
+    }
+    for (const key of adjacency.keys()) {
+        if (!visited.has(key))
+            dfs(key);
+    }
+    return cycleEdgeKeys;
+}
+export async function listEntitiesSafe(client, type, filters) {
+    try {
+        const response = await client.listEntities(type, filters);
+        const items = Array.isArray(response.data) ? response.data : [];
+        return { items, warning: null };
+    }
+    catch (err) {
+        return {
+            items: [],
+            warning: `${type} unavailable (${safeErrorMessage(err)})`,
+        };
+    }
+}
+export async function buildMissionControlGraph(client, initiativeId, options) {
+    const degraded = [];
+    const preloadedInitiative = options?.initiativeEntity ?? null;
+    const [initiativeResult, workstreamResult, milestoneResult, taskResult] = await Promise.all([
+        preloadedInitiative
+            ? Promise.resolve({
+                items: [preloadedInitiative],
+                warning: null,
+            })
+            : listEntitiesSafe(client, "initiative", { limit: 300 }),
+        listEntitiesSafe(client, "workstream", {
+            initiative_id: initiativeId,
+            limit: 500,
+        }),
+        listEntitiesSafe(client, "milestone", {
+            initiative_id: initiativeId,
+            limit: 700,
+        }),
+        listEntitiesSafe(client, "task", {
+            initiative_id: initiativeId,
+            limit: 1200,
+        }),
+    ]);
+    for (const warning of [
+        initiativeResult.warning,
+        workstreamResult.warning,
+        milestoneResult.warning,
+        taskResult.warning,
+    ]) {
+        if (warning)
+            degraded.push(warning);
+    }
+    const initiativeEntity = initiativeResult.items.find((item) => String(item.id ?? "") === initiativeId);
+    const initiativeNode = initiativeEntity
+        ? toMissionControlNode("initiative", initiativeEntity, initiativeId)
+        : {
+            id: initiativeId,
+            type: "initiative",
+            title: `Initiative ${initiativeId.slice(0, 8)}`,
+            status: "active",
+            parentId: null,
+            initiativeId,
+            workstreamId: null,
+            milestoneId: null,
+            priorityNum: 60,
+            priorityLabel: null,
+            dependencyIds: [],
+            dueDate: null,
+            etaEndAt: null,
+            expectedDurationHours: DEFAULT_DURATION_HOURS.initiative,
+            expectedBudgetUsd: DEFAULT_BUDGET_USD.initiative,
+            assignedAgents: [],
+            updatedAt: null,
+        };
+    const workstreamNodes = workstreamResult.items.map((item) => toMissionControlNode("workstream", item, initiativeId));
+    const milestoneNodes = milestoneResult.items.map((item) => toMissionControlNode("milestone", item, initiativeId));
+    const taskNodes = taskResult.items.map((item) => toMissionControlNode("task", item, initiativeId));
+    const nodes = [
+        initiativeNode,
+        ...workstreamNodes,
+        ...milestoneNodes,
+        ...taskNodes,
+    ];
+    const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+    for (const node of nodes) {
+        const validDependencies = dedupeStrings(node.dependencyIds.filter((depId) => depId !== node.id && nodeMap.has(depId)));
+        node.dependencyIds = validDependencies;
+    }
+    let edges = [];
+    for (const node of nodes) {
+        if (node.type === "initiative")
+            continue;
+        for (const depId of node.dependencyIds) {
+            edges.push({
+                from: depId,
+                to: node.id,
+                kind: "depends_on",
+            });
+        }
+    }
+    edges = edges.filter((edge, index, arr) => arr.findIndex((candidate) => candidate.from === edge.from &&
+        candidate.to === edge.to &&
+        candidate.kind === edge.kind) === index);
+    const cyclicEdgeKeys = detectCycleEdgeKeys(edges);
+    const cycleDiagnostics = cyclicEdgeKeys.size > 0
+        ? {
+            detected: true,
+            cycleEdgeCount: cyclicEdgeKeys.size,
+            removedEdges: [],
+            affectedNodes: [],
+        }
+        : null;
+    if (cyclicEdgeKeys.size > 0) {
+        degraded.push(`Detected ${cyclicEdgeKeys.size} cyclic dependency edge(s); excluded from ETA graph.`);
+        if (cycleDiagnostics) {
+            const removedEdges = Array.from(cyclicEdgeKeys.values())
+                .map((key) => {
+                const [from, to] = key.split("->", 2);
+                if (!from || !to)
+                    return null;
+                return { from, to };
+            })
+                .filter((entry) => Boolean(entry));
+            cycleDiagnostics.removedEdges = removedEdges;
+        }
+        edges = edges.filter((edge) => !cyclicEdgeKeys.has(`${edge.from}->${edge.to}`));
+        const affectedNodesById = new Map();
+        for (const node of nodes) {
+            const removed = node.dependencyIds.filter((depId) => cyclicEdgeKeys.has(`${depId}->${node.id}`));
+            if (removed.length > 0) {
+                const existing = affectedNodesById.get(node.id) ?? {
+                    nodeId: node.id,
+                    nodeType: node.type,
+                    removedDependencyIds: new Set(),
+                };
+                for (const depId of removed) {
+                    existing.removedDependencyIds.add(depId);
+                }
+                affectedNodesById.set(node.id, existing);
+            }
+            node.dependencyIds = node.dependencyIds.filter((depId) => !removed.includes(depId));
+        }
+        if (cycleDiagnostics) {
+            cycleDiagnostics.affectedNodes = Array.from(affectedNodesById.values()).map((entry) => {
+                const remaining = nodeMap.get(entry.nodeId)?.dependencyIds ?? [];
+                return {
+                    nodeId: entry.nodeId,
+                    nodeType: entry.nodeType,
+                    removedDependencyIds: Array.from(entry.removedDependencyIds.values()),
+                    remainingDependencyIds: [...remaining],
+                };
+            });
+        }
+    }
+    const etaMemo = new Map();
+    const etaVisiting = new Set();
+    const computeEtaEpoch = (nodeId) => {
+        const node = nodeMap.get(nodeId);
+        if (!node)
+            return Date.now();
+        const cached = etaMemo.get(nodeId);
+        if (cached !== undefined)
+            return cached;
+        const parsedEtaOverride = node.etaEndAt ? Date.parse(node.etaEndAt) : Number.NaN;
+        if (Number.isFinite(parsedEtaOverride)) {
+            etaMemo.set(nodeId, parsedEtaOverride);
+            return parsedEtaOverride;
+        }
+        const parsedDueDate = node.dueDate ? Date.parse(node.dueDate) : Number.NaN;
+        if (Number.isFinite(parsedDueDate)) {
+            etaMemo.set(nodeId, parsedDueDate);
+            return parsedDueDate;
+        }
+        if (etaVisiting.has(nodeId)) {
+            degraded.push(`ETA cycle fallback on node ${nodeId}.`);
+            const fallback = Date.now();
+            etaMemo.set(nodeId, fallback);
+            return fallback;
+        }
+        etaVisiting.add(nodeId);
+        let dependencyMax = 0;
+        for (const depId of node.dependencyIds) {
+            dependencyMax = Math.max(dependencyMax, computeEtaEpoch(depId));
+        }
+        etaVisiting.delete(nodeId);
+        const durationMs = (node.expectedDurationHours > 0
+            ? node.expectedDurationHours
+            : DEFAULT_DURATION_HOURS[node.type]) * 60 * 60 * 1000;
+        const eta = Math.max(Date.now(), dependencyMax) + durationMs;
+        etaMemo.set(nodeId, eta);
+        return eta;
+    };
+    for (const node of nodes) {
+        const eta = computeEtaEpoch(node.id);
+        if (Number.isFinite(eta)) {
+            node.etaEndAt = new Date(eta).toISOString();
+        }
+    }
+    const taskNodesOnly = nodes.filter((node) => node.type === "task");
+    const hasActiveTasks = taskNodesOnly.some((node) => isInProgressStatus(node.status));
+    const hasTodoTasks = taskNodesOnly.some((node) => isTodoStatus(node.status));
+    if (initiativeNode.status.toLowerCase() === "active" &&
+        !hasActiveTasks &&
+        hasTodoTasks) {
+        initiativeNode.status = "paused";
+    }
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    const taskIsReady = (task) => task.dependencyIds.every((depId) => {
+        const dependency = nodeById.get(depId);
+        return dependency ? isDoneStatus(dependency.status) : true;
+    });
+    const taskHasBlockedParent = (task) => {
+        const milestone = task.milestoneId ? nodeById.get(task.milestoneId) ?? null : null;
+        const workstream = task.workstreamId ? nodeById.get(task.workstreamId) ?? null : null;
+        return (milestone?.status?.toLowerCase() === "blocked" ||
+            workstream?.status?.toLowerCase() === "blocked");
+    };
+    const recentTodos = nodes
+        .filter((node) => node.type === "task" && isTodoStatus(node.status))
+        .sort((a, b) => {
+        const aReady = taskIsReady(a);
+        const bReady = taskIsReady(b);
+        if (aReady !== bReady)
+            return aReady ? -1 : 1;
+        const aBlocked = taskHasBlockedParent(a);
+        const bBlocked = taskHasBlockedParent(b);
+        if (aBlocked !== bBlocked)
+            return aBlocked ? 1 : -1;
+        const priorityDelta = a.priorityNum - b.priorityNum;
+        if (priorityDelta !== 0)
+            return priorityDelta;
+        const aDue = a.dueDate ? Date.parse(a.dueDate) : Number.POSITIVE_INFINITY;
+        const bDue = b.dueDate ? Date.parse(b.dueDate) : Number.POSITIVE_INFINITY;
+        if (aDue !== bDue)
+            return aDue - bDue;
+        const aEta = a.etaEndAt ? Date.parse(a.etaEndAt) : Number.POSITIVE_INFINITY;
+        const bEta = b.etaEndAt ? Date.parse(b.etaEndAt) : Number.POSITIVE_INFINITY;
+        if (aEta !== bEta)
+            return aEta - bEta;
+        const aEpoch = a.updatedAt ? Date.parse(a.updatedAt) : 0;
+        const bEpoch = b.updatedAt ? Date.parse(b.updatedAt) : 0;
+        return aEpoch - bEpoch;
+    })
+        .map((node) => node.id);
+    return {
+        initiative: {
+            id: initiativeNode.id,
+            title: initiativeNode.title,
+            status: initiativeNode.status,
+            summary: initiativeEntity
+                ? pickString(initiativeEntity, [
+                    "summary",
+                    "description",
+                    "context",
+                ])
+                : null,
+            assignedAgents: initiativeNode.assignedAgents,
+        },
+        nodes,
+        edges,
+        recentTodos,
+        degraded,
+        ...(cycleDiagnostics ? { cycleDiagnostics } : {}),
+    };
+}
+export function normalizeEntityMutationPayload(payload) {
+    const next = { ...payload };
+    const priorityNumRaw = pickNumber(next, ["priority_num", "priorityNum"]);
+    const priorityLabelRaw = pickString(next, ["priority", "priority_label"]);
+    if (priorityNumRaw !== null) {
+        const clamped = clampPriority(priorityNumRaw);
+        next.priority_num = clamped;
+        if (!priorityLabelRaw) {
+            next.priority = mapPriorityNumToLabel(clamped);
+        }
+    }
+    else if (priorityLabelRaw) {
+        next.priority_num = PRIORITY_LABEL_TO_NUM[priorityLabelRaw.toLowerCase()] ?? 60;
+        next.priority = priorityLabelRaw.toLowerCase();
+    }
+    const dependsOnArray = pickStringArray(next, ["depends_on", "dependsOn", "dependencies"]);
+    if (dependsOnArray.length > 0) {
+        next.depends_on = dedupeStrings(dependsOnArray);
+    }
+    else if ("depends_on" in next) {
+        next.depends_on = [];
+    }
+    const expectedDuration = pickNumber(next, [
+        "expected_duration_hours",
+        "expectedDurationHours",
+    ]);
+    if (expectedDuration !== null) {
+        next.expected_duration_hours = Math.max(0, expectedDuration);
+    }
+    const expectedBudget = pickNumber(next, [
+        "expected_budget_usd",
+        "expectedBudgetUsd",
+        "budget_usd",
+        "budgetUsd",
+    ]);
+    if (expectedBudget !== null) {
+        next.expected_budget_usd = Math.max(0, expectedBudget);
+    }
+    const etaEndAt = pickString(next, ["eta_end_at", "etaEndAt"]);
+    if (etaEndAt !== null) {
+        next.eta_end_at = toIsoString(etaEndAt) ?? null;
+    }
+    const assignedIds = pickStringArray(next, [
+        "assigned_agent_ids",
+        "assignedAgentIds",
+    ]);
+    const assignedNames = pickStringArray(next, [
+        "assigned_agent_names",
+        "assignedAgentNames",
+    ]);
+    if (assignedIds.length > 0) {
+        next.assigned_agent_ids = dedupeStrings(assignedIds);
+    }
+    if (assignedNames.length > 0) {
+        next.assigned_agent_names = dedupeStrings(assignedNames);
+    }
+    return next;
+}
+export async function resolveAutoAssignments(input) {
+    const warnings = [];
+    const assignedById = new Map();
+    const addAgent = (agent) => {
+        const key = agent.id || `name:${agent.name}`;
+        if (!assignedById.has(key))
+            assignedById.set(key, agent);
+    };
+    let liveAgents = [];
+    try {
+        const data = await input.client.getLiveAgents({
+            initiative: input.initiativeId,
+            includeIdle: true,
+        });
+        liveAgents = (Array.isArray(data.agents) ? data.agents : [])
+            .map((raw) => {
+            if (!raw || typeof raw !== "object")
+                return null;
+            const record = raw;
+            const id = pickString(record, ["id", "agentId"]) ?? "";
+            const name = pickString(record, ["name", "agentName"]) ?? (id ? `Agent ${id}` : "");
+            if (!name)
+                return null;
+            return {
+                id: id || `name:${name}`,
+                name,
+                domain: pickString(record, ["domain", "role"]),
+                status: pickString(record, ["status"]),
+            };
+        })
+            .filter((item) => item !== null);
+    }
+    catch (err) {
+        warnings.push(`live agent lookup failed (${safeErrorMessage(err)})`);
+    }
+    const orchestrator = liveAgents.find((agent) => /holt|orchestrator/i.test(agent.name) ||
+        /orchestrator/i.test(agent.domain ?? ""));
+    if (orchestrator)
+        addAgent(orchestrator);
+    let assignmentSource = "fallback";
+    try {
+        const preflight = await input.client.delegationPreflight({
+            intent: `${input.title}${input.summary ? `: ${input.summary}` : ""}`,
+        });
+        const recommendations = preflight.data?.recommended_split ?? [];
+        const recommendedDomains = dedupeStrings(recommendations
+            .map((entry) => String(entry.owner_domain ?? "").trim().toLowerCase())
+            .filter(Boolean));
+        for (const domain of recommendedDomains) {
+            const matched = liveAgents.find((agent) => (agent.domain ?? "").toLowerCase().includes(domain));
+            if (matched)
+                addAgent(matched);
+        }
+        if (recommendedDomains.length > 0) {
+            assignmentSource = "orchestrator";
+        }
+    }
+    catch (err) {
+        warnings.push(`delegation preflight failed (${safeErrorMessage(err)})`);
+    }
+    if (assignedById.size === 0) {
+        const text = `${input.title} ${input.summary ?? ""}`.toLowerCase();
+        const fallbackDomains = [];
+        if (/market|campaign|thread|article|tweet|copy/.test(text)) {
+            fallbackDomains.push("marketing");
+        }
+        else if (/design|ux|ui|a11y|accessibility/.test(text)) {
+            fallbackDomains.push("design");
+        }
+        else if (/ops|incident|runbook|reliability/.test(text)) {
+            fallbackDomains.push("operations");
+        }
+        else if (/sales|deal|pipeline|mrr/.test(text)) {
+            fallbackDomains.push("sales");
+        }
+        else {
+            fallbackDomains.push("engineering", "product");
+        }
+        for (const domain of fallbackDomains) {
+            const matched = liveAgents.find((agent) => (agent.domain ?? "").toLowerCase().includes(domain));
+            if (matched)
+                addAgent(matched);
+        }
+    }
+    if (assignedById.size === 0 && liveAgents.length > 0) {
+        addAgent(liveAgents[0]);
+        warnings.push("using first available live agent as fallback");
+    }
+    const assignedAgents = Array.from(assignedById.values());
+    const updatePayload = normalizeEntityMutationPayload({
+        assigned_agent_ids: assignedAgents.map((agent) => agent.id),
+        assigned_agent_names: assignedAgents.map((agent) => agent.name),
+    });
+    let updatedEntity;
+    try {
+        updatedEntity = await input.client.updateEntity(input.entityType, input.entityId, updatePayload);
+    }
+    catch (err) {
+        warnings.push(`assignment patch failed (${safeErrorMessage(err)})`);
+    }
+    return {
+        ok: true,
+        assignment_source: assignmentSource,
+        assigned_agents: assignedAgents,
+        warnings,
+        ...(updatedEntity ? { updated_entity: updatedEntity } : {}),
+    };
+}
+export function normalizeExecutionDomain(value) {
+    const raw = (value ?? "").trim().toLowerCase();
+    if (!raw)
+        return null;
+    if (raw === "orchestrator")
+        return "orchestration";
+    if (raw === "ops")
+        return "operations";
+    return Object.prototype.hasOwnProperty.call(ORGX_SKILL_BY_DOMAIN, raw)
+        ? raw
+        : null;
+}
+export function inferExecutionDomainFromText(...values) {
+    const text = values
+        .map((value) => (value ?? "").trim().toLowerCase())
+        .filter((value) => value.length > 0)
+        .join(" ");
+    if (!text)
+        return "engineering";
+    if (/\b(marketing|campaign|copy|ad|content)\b/.test(text))
+        return "marketing";
+    if (/\b(sales|meddic|pipeline|deal|outreach)\b/.test(text))
+        return "sales";
+    if (/\b(design|ui|ux|brand|wcag)\b/.test(text))
+        return "design";
+    if (/\b(product|prd|roadmap|prioritization)\b/.test(text))
+        return "product";
+    if (/\b(ops|operations|incident|reliability|oncall|slo)\b/.test(text))
+        return "operations";
+    if (/\b(orchestration|dispatch|handoff)\b/.test(text))
+        return "orchestration";
+    return "engineering";
+}
+// ---------------------------------------------------------------------------
+// Per-scope task selection for autopilot slices
+// ---------------------------------------------------------------------------
+export function selectSliceTasksByScope(input) {
+    const { scope, workstreamId, nodeById, includeVerification } = input;
+    const cap = SLICE_SCOPE_MAX_TASKS[scope];
+    const taskIsReady = (node) => node.dependencyIds.every((depId) => {
+        const dep = nodeById.get(depId);
+        return dep ? isDoneStatus(dep.status) : true;
+    });
+    const taskHasBlockedParent = (node) => {
+        const milestone = node.milestoneId ? nodeById.get(node.milestoneId) ?? null : null;
+        const workstream = node.workstreamId ? nodeById.get(node.workstreamId) ?? null : null;
+        return (milestone?.status?.toLowerCase() === "blocked" ||
+            workstream?.status?.toLowerCase() === "blocked");
+    };
+    const isEligible = (node) => Boolean(node &&
+        node.type === "task" &&
+        isTodoStatus(node.status) &&
+        taskIsReady(node) &&
+        !taskHasBlockedParent(node) &&
+        (includeVerification || !/^verification[ \t]+scenario/i.test(String(node.title ?? ""))));
+    if (scope === "milestone") {
+        // Pick tasks from a specific milestone (or the first milestone with ready tasks)
+        const targetMilestoneId = input.milestoneId ?? null;
+        if (targetMilestoneId) {
+            const tasks = input.recentTodos
+                .map((id) => nodeById.get(id))
+                .filter((node) => Boolean(node) &&
+                node.workstreamId === workstreamId &&
+                node.milestoneId === targetMilestoneId &&
+                isEligible(node))
+                .slice(0, cap);
+            return { tasks, milestoneIds: tasks.length > 0 ? [targetMilestoneId] : [] };
+        }
+        // Find first milestone with ready tasks
+        for (const todoId of input.recentTodos) {
+            const node = nodeById.get(todoId);
+            if (!node || node.workstreamId !== workstreamId || !node.milestoneId || !isEligible(node))
+                continue;
+            const msId = node.milestoneId;
+            const tasks = input.recentTodos
+                .map((id) => nodeById.get(id))
+                .filter((n) => Boolean(n) && n.workstreamId === workstreamId && n.milestoneId === msId && isEligible(n))
+                .slice(0, cap);
+            return { tasks, milestoneIds: [msId] };
+        }
+        return { tasks: [], milestoneIds: [] };
+    }
+    if (scope === "workstream") {
+        const milestoneIdSet = new Set();
+        const tasks = input.recentTodos
+            .map((id) => nodeById.get(id))
+            .filter((node) => Boolean(node) && node.workstreamId === workstreamId && isEligible(node))
+            .slice(0, cap);
+        for (const t of tasks) {
+            if (t.milestoneId)
+                milestoneIdSet.add(t.milestoneId);
+        }
+        return { tasks, milestoneIds: Array.from(milestoneIdSet) };
+    }
+    // Default: task scope — current behavior
+    const tasks = input.recentTodos
+        .map((id) => nodeById.get(id))
+        .filter((node) => Boolean(node) && node.workstreamId === workstreamId && isEligible(node))
+        .slice(0, cap);
+    const milestoneIdSet = new Set();
+    for (const t of tasks) {
+        if (t.milestoneId)
+            milestoneIdSet.add(t.milestoneId);
+    }
+    return { tasks, milestoneIds: Array.from(milestoneIdSet) };
+}
+// ---------------------------------------------------------------------------
+// Scope completion evaluation
+// ---------------------------------------------------------------------------
+export function evaluateScopeCompletion(input) {
+    const { scope, milestoneIds, workstreamId, nodeById } = input;
+    if (scope === "task") {
+        return { scopeComplete: true, remainingTasks: 0 };
+    }
+    let remaining = 0;
+    for (const [, node] of nodeById) {
+        if (node.type !== "task")
+            continue;
+        if (isDoneStatus(node.status))
+            continue;
+        if (scope === "milestone") {
+            if (node.milestoneId && milestoneIds.includes(node.milestoneId)) {
+                remaining += 1;
+            }
+        }
+        else if (scope === "workstream") {
+            if (node.workstreamId === workstreamId) {
+                remaining += 1;
+            }
+        }
+    }
+    return { scopeComplete: remaining === 0, remainingTasks: remaining };
+}
+export function deriveExecutionPolicy(taskNode, workstreamNode) {
+    const domainCandidate = taskNode.assignedAgents
+        .map((agent) => normalizeExecutionDomain(agent.domain))
+        .find((domain) => Boolean(domain)) ??
+        (workstreamNode
+            ? workstreamNode.assignedAgents
+                .map((agent) => normalizeExecutionDomain(agent.domain))
+                .find((domain) => Boolean(domain))
+            : null) ??
+        inferExecutionDomainFromText(taskNode.title, workstreamNode?.title ?? null);
+    const domain = normalizeExecutionDomain(domainCandidate) ?? "engineering";
+    const requiredSkill = ORGX_SKILL_BY_DOMAIN[domain] ?? ORGX_SKILL_BY_DOMAIN.engineering;
+    const profile = taskNode.behaviorConfigId ??
+        workstreamNode?.behaviorConfigId ??
+        null;
+    const sliceScopePreference = taskNode.sliceScopePreference ??
+        workstreamNode?.sliceScopePreference ??
+        null;
+    const maxSliceTasks = taskNode.maxSliceTasks ??
+        workstreamNode?.maxSliceTasks ??
+        null;
+    const maxParallelAgents = taskNode.maxParallelAgents ??
+        workstreamNode?.maxParallelAgents ??
+        null;
+    const dependencyMode = taskNode.dependencyMode ??
+        workstreamNode?.dependencyMode ??
+        null;
+    return {
+        domain,
+        requiredSkills: [requiredSkill],
+        profile,
+        sliceScopePreference,
+        maxSliceTasks,
+        maxParallelAgents,
+        dependencyMode,
+    };
+}
+export function deriveBehaviorConfigContext(taskNode, workstreamNode) {
+    const approvalStatusRaw = taskNode.behaviorApprovalStatus ?? workstreamNode?.behaviorApprovalStatus ?? null;
+    const approvalStatus = approvalStatusRaw
+        ? approvalStatusRaw
+            .trim()
+            .toLowerCase()
+            .replace(/[\s-]+/g, "_")
+        : null;
+    const explicitlyRequiresApproval = taskNode.behaviorRequiresApproval ?? workstreamNode?.behaviorRequiresApproval ?? null;
+    const pendingApprovalStatus = approvalStatus === "pending" ||
+        approvalStatus === "requested" ||
+        approvalStatus === "awaiting_approval" ||
+        approvalStatus === "awaiting_review" ||
+        approvalStatus === "in_review" ||
+        approvalStatus === "review_pending" ||
+        approvalStatus === "needs_approval" ||
+        approvalStatus === "open" ||
+        approvalStatus === "queued";
+    const approvedStatus = approvalStatus === "approved" ||
+        approvalStatus === "accepted" ||
+        approvalStatus === "resolved" ||
+        approvalStatus === "completed" ||
+        approvalStatus === "complete";
+    const requiresApproval = explicitlyRequiresApproval === true ? !approvedStatus : pendingApprovalStatus;
+    return {
+        configId: taskNode.behaviorConfigId ?? workstreamNode?.behaviorConfigId ?? null,
+        version: taskNode.behaviorConfigVersion ?? workstreamNode?.behaviorConfigVersion ?? null,
+        hash: taskNode.behaviorConfigHash ?? workstreamNode?.behaviorConfigHash ?? null,
+        policySource: taskNode.behaviorPolicySource ?? workstreamNode?.behaviorPolicySource ?? null,
+        context: taskNode.behaviorContext ?? workstreamNode?.behaviorContext ?? null,
+        requiresApproval,
+        approvalStatus: approvalStatus ?? null,
+        approvalDecisionId: taskNode.behaviorApprovalDecisionId ?? workstreamNode?.behaviorApprovalDecisionId ?? null,
+    };
+}
+export function deriveBehaviorAutomationLevel(taskNode, workstreamNode) {
+    return taskNode.behaviorAutomationLevel ?? workstreamNode?.behaviorAutomationLevel ?? "auto";
+}
+export function detectBehaviorConfigDrift(input) {
+    const workstream = input.workstreamNode;
+    if (!workstream)
+        return null;
+    const declared = {
+        configId: workstream.behaviorConfigId ?? null,
+        version: workstream.behaviorConfigVersion ?? null,
+        hash: workstream.behaviorConfigHash ?? null,
+        policySource: workstream.behaviorPolicySource ?? null,
+        context: workstream.behaviorContext ?? null,
+        automationLevel: workstream.behaviorAutomationLevel ?? null,
+    };
+    const runtime = {
+        configId: input.behaviorConfig.configId ?? null,
+        version: input.behaviorConfig.version ?? null,
+        hash: input.behaviorConfig.hash ?? null,
+        policySource: input.behaviorConfig.policySource ?? null,
+        context: input.behaviorConfig.context ?? null,
+        automationLevel: input.behaviorAutomationLevel,
+    };
+    const norm = (value) => {
+        if (typeof value !== "string")
+            return null;
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    };
+    const normContext = (value) => {
+        const normalized = norm(value);
+        if (!normalized)
+            return null;
+        return normalized.replace(/\s+/g, " ");
+    };
+    const normPolicySource = (value) => {
+        const normalized = norm(value);
+        if (!normalized)
+            return null;
+        return normalized.toLowerCase().replace(/[\s-]+/g, "_");
+    };
+    const hasDeclaredConfig = norm(declared.configId) !== null ||
+        norm(declared.version) !== null ||
+        norm(declared.hash) !== null ||
+        norm(declared.policySource) !== null ||
+        normContext(declared.context) !== null ||
+        declared.automationLevel !== null;
+    if (!hasDeclaredConfig)
+        return null;
+    const fields = [];
+    if (norm(declared.configId) !== norm(runtime.configId))
+        fields.push("config_id");
+    if (norm(declared.version) !== norm(runtime.version))
+        fields.push("version");
+    if (norm(declared.hash) !== norm(runtime.hash))
+        fields.push("hash");
+    if (normPolicySource(declared.policySource) !== normPolicySource(runtime.policySource)) {
+        fields.push("policy_source");
+    }
+    if (normContext(declared.context) !== normContext(runtime.context))
+        fields.push("context");
+    if ((declared.automationLevel ?? null) !== runtime.automationLevel)
+        fields.push("automation_level");
+    if (fields.length === 0)
+        return null;
+    return { fields, declared, runtime };
+}
+export function spawnGuardIsRateLimited(result) {
+    if (!result || typeof result !== "object")
+        return false;
+    const record = result;
+    const checks = record.checks && typeof record.checks === "object" && !Array.isArray(record.checks)
+        ? record.checks
+        : {};
+    const rateLimitCandidates = [
+        checks.rateLimit,
+        checks.rate_limit,
+        record.rateLimit,
+        record.rate_limit,
+    ].filter((entry) => {
+        return Boolean(entry && typeof entry === "object" && !Array.isArray(entry));
+    });
+    for (const candidate of rateLimitCandidates) {
+        if (candidate.passed === false)
+            return true;
+        if (candidate.rateLimited === true || candidate.rate_limited === true || candidate.limited === true) {
+            return true;
+        }
+        const current = pickNumber(candidate, ["current", "count", "value", "used", "attempts"]) ?? null;
+        const max = pickNumber(candidate, ["max", "limit", "threshold", "allowed"]) ?? null;
+        if (typeof current === "number" &&
+            Number.isFinite(current) &&
+            typeof max === "number" &&
+            Number.isFinite(max) &&
+            max > 0 &&
+            current >= max) {
+            return true;
+        }
+    }
+    if (record.rateLimited === true || record.rate_limited === true)
+        return true;
+    const blockedReason = pickString(record, [
+        "blockedReason",
+        "blocked_reason",
+        "reason",
+        "message",
+        "error",
+    ]);
+    if (blockedReason && /\brate[ -]?limit(?:ed)?\b|\btoo many requests\b/i.test(blockedReason)) {
+        return true;
+    }
+    return false;
+}
+export function summarizeSpawnGuardBlockReason(result) {
+    if (!result || typeof result !== "object")
+        return "Spawn guard denied dispatch.";
+    const record = result;
+    const blockedReason = pickString(record, ["blockedReason", "blocked_reason"]);
+    if (blockedReason)
+        return blockedReason;
+    if (spawnGuardIsRateLimited(result)) {
+        return "Spawn guard rate limit reached.";
+    }
+    return "Spawn guard denied dispatch.";
+}