@useorgx/openclaw-plugin 0.4.9 → 0.7.2

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

@@ -1,4 +1,14 @@
 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",
@@ -15,6 +25,57 @@ function safeErrorMessage(err) {
         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)
@@ -232,6 +293,42 @@ function normalizeDependencies(record) {
     ]);
     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([
@@ -350,6 +447,82 @@ function toMissionControlNode(type, entity, fallbackInitiativeId) {
                 : 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,
@@ -368,6 +541,19 @@ function toMissionControlNode(type, entity, fallbackInitiativeId) {
         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",
@@ -538,11 +724,54 @@ export async function buildMissionControlGraph(client, initiativeId, options) {
         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) {
-            node.dependencyIds = node.dependencyIds.filter((depId) => !cyclicEdgeKeys.has(`${depId}->${node.id}`));
+            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();
@@ -653,6 +882,7 @@ export async function buildMissionControlGraph(client, initiativeId, options) {
         edges,
         recentTodos,
         degraded,
+        ...(cycleDiagnostics ? { cycleDiagnostics } : {}),
     };
 }
 export function normalizeEntityMutationPayload(payload) {
@@ -854,6 +1084,106 @@ export function inferExecutionDomainFromText(...values) {
         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))
@@ -866,19 +1196,178 @@ export function deriveExecutionPolicy(taskNode, workstreamNode) {
         inferExecutionDomainFromText(taskNode.title, workstreamNode?.title ?? null);
     const domain = normalizeExecutionDomain(domainCandidate) ?? "engineering";
     const requiredSkill = ORGX_SKILL_BY_DOMAIN[domain] ?? ORGX_SKILL_BY_DOMAIN.engineering;
-    return { domain, requiredSkills: [requiredSkill] };
+    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;
-    if (!checks || typeof checks !== "object")
-        return false;
-    const rateLimit = checks.rateLimit;
-    if (!rateLimit || typeof rateLimit !== "object")
-        return false;
-    return rateLimit.passed === false;
+    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")

package/dist/http/helpers/sentinel-catalog.d.ts

@@ -0,0 +1,23 @@
+export type SentinelDomain = "engineering" | "sales" | "product" | "operations" | "marketing";
+export type BuiltInSentinel = {
+    id: string;
+    domain: SentinelDomain;
+    name: string;
+    summary: string;
+    signal: "error_log" | "ci_failure" | "dependency_scan" | "accessibility_audit" | "deal_stagnation" | "lead_response" | "cost_anomaly" | "sla_breach" | "content_performance" | "budget_monitor";
+    severity: "high" | "medium";
+    schedule: {
+        cadence: "realtime" | "hourly";
+        windowMinutes: number;
+    };
+    trigger: {
+        operator: "gt" | "eq";
+        threshold: number;
+        unit: "events" | "failures" | "findings" | "hours" | "minutes" | "percent";
+    };
+    defaultAction: string;
+};
+export declare function listBuiltInSentinels(input?: {
+    domain?: string | null;
+    signal?: string | null;
+}): BuiltInSentinel[];