@lsctech/polaris 0.4.9 → 0.5.2

package/dist/qc/severity.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEVERITY_ORDER = exports.DEFAULT_SEVERITY_MAPPING = void 0;
+exports.normalizeSeverity = normalizeSeverity;
+exports.compareSeverity = compareSeverity;
+exports.maxSeverity = maxSeverity;
+/**
+ * Built-in severity label mappings for common QC providers.
+ * Provider-specific configs can override these.
+ */
+exports.DEFAULT_SEVERITY_MAPPING = {
+    // Common explicit labels
+    critical: "critical",
+    severe: "critical",
+    blocker: "critical",
+    high: "high",
+    major: "high",
+    error: "high",
+    medium: "medium",
+    moderate: "medium",
+    warning: "medium",
+    low: "low",
+    minor: "low",
+    info: "info",
+    informational: "info",
+    note: "info",
+    suggestion: "info",
+    // CodeRabbit-style labels
+    "needs-action": "high",
+    "needs-review": "medium",
+    nitpick: "low",
+};
+/**
+ * Normalize a provider severity label into a Polaris severity level.
+ * Unknown or empty labels fall back to "info" so that nothing is silently lost.
+ */
+function normalizeSeverity(label, mapping) {
+    const raw = (label ?? "").toString().trim().toLowerCase();
+    if (!raw) {
+        return "info";
+    }
+    const combined = { ...exports.DEFAULT_SEVERITY_MAPPING, ...mapping };
+    if (Object.hasOwn(combined, raw)) {
+        return combined[raw];
+    }
+    // Substring fallbacks for noisy provider labels
+    if (raw.includes("critical") || raw.includes("severe") || raw.includes("blocker")) {
+        return "critical";
+    }
+    if (raw.includes("high") || raw.includes("major") || raw.includes("error")) {
+        return "high";
+    }
+    if (raw.includes("medium") || raw.includes("moderate") || raw.includes("warning")) {
+        return "medium";
+    }
+    if (raw.includes("low") || raw.includes("minor") || raw.includes("nitpick")) {
+        return "low";
+    }
+    if (raw.includes("info") || raw.includes("note") || raw.includes("suggestion")) {
+        return "info";
+    }
+    return "info";
+}
+/** Ordered severity levels from least to most severe. */
+exports.SEVERITY_ORDER = ["info", "low", "medium", "high", "critical"];
+/**
+ * Compare two severities. Returns negative if a is less severe than b,
+ * positive if more severe, or zero if equal.
+ */
+function compareSeverity(a, b) {
+    return exports.SEVERITY_ORDER.indexOf(a) - exports.SEVERITY_ORDER.indexOf(b);
+}
+/**
+ * Return the more severe of two severity levels.
+ */
+function maxSeverity(a, b) {
+    return compareSeverity(a, b) >= 0 ? a : b;
+}

package/dist/qc/triggers.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * QC trigger selection logic.
+ *
+ * Decides which lifecycle trigger a configured provider participates in, and
+ * whether child-level QC should be selected for a given dispatch.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectiveProviderTrigger = effectiveProviderTrigger;
+exports.activeProvidersForTrigger = activeProvidersForTrigger;
+exports.isHighRiskScope = isHighRiskScope;
+exports.isChildQcSelected = isChildQcSelected;
+exports.selectChildQcTrigger = selectChildQcTrigger;
+/** High-risk scope patterns that make a child eligible for child-level QC. */
+const HIGH_RISK_SCOPE_PATTERNS = [
+    /src\/auth/i,
+    /src\/security/i,
+    /src\/payments/i,
+    /src\/crypto/i,
+    /src\/db/i,
+    /src\/database/i,
+    /src\/api/i,
+];
+/**
+ * Derive the effective trigger for a provider.
+ * Falls back to a sensible default derived from the provider mode, then the
+ * cluster-wide default trigger.
+ */
+function effectiveProviderTrigger(provider, defaultTrigger) {
+    if (provider.trigger)
+        return provider.trigger;
+    switch (provider.mode) {
+        case "pr":
+            return "pr";
+        case "local":
+            return "completed-cluster";
+        case "metrics-import":
+            return "completed-cluster";
+        default:
+            return defaultTrigger;
+    }
+}
+/**
+ * Return configured providers that participate in the given trigger.
+ */
+function activeProvidersForTrigger(config, trigger) {
+    if (!config?.enabled)
+        return [];
+    const defaultTrigger = config.defaultTrigger ?? "completed-cluster";
+    return Object.entries(config.providers ?? {}).filter(([, provider]) => {
+        return effectiveProviderTrigger(provider, defaultTrigger) === trigger;
+    });
+}
+/**
+ * Returns true when a scope touches files generally considered high-risk.
+ */
+function isHighRiskScope(scope) {
+    return scope.some((pattern) => HIGH_RISK_SCOPE_PATTERNS.some((re) => re.test(pattern)));
+}
+/**
+ * Decide whether child-level QC should be selected for a child.
+ *
+ * Child-level QC is intentionally opt-in. It is selected only when:
+ *   - QC is enabled and at least one provider is configured for the child trigger.
+ *   - A route policy explicitly enables child-level QC for this route, OR
+ *   - The child is explicitly tagged with "qc-child", OR
+ *   - The child's scope contains high-risk paths (auth, security, payments, etc.).
+ */
+function isChildQcSelected(config, childId, allowedScope, labels, routeName) {
+    if (!config?.enabled)
+        return false;
+    const childProviders = activeProvidersForTrigger(config, "child");
+    if (childProviders.length === 0)
+        return false;
+    const routePolicy = routeName ? config.routes?.[routeName] : undefined;
+    if (routePolicy?.childLevel)
+        return true;
+    if (labels?.includes("qc-child"))
+        return true;
+    if (isHighRiskScope(allowedScope))
+        return true;
+    return false;
+}
+/**
+ * Select the QC trigger for a child dispatch.
+ * Returns "child" when child-level QC is selected, otherwise null.
+ */
+function selectChildQcTrigger(config, childId, allowedScope, labels, routeName) {
+    return isChildQcSelected(config, childId, allowedScope, labels, routeName)
+        ? "child"
+        : null;
+}

package/dist/qc/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Provider-neutral Quality Control types.
+ *
+ * These types mirror the normalized finding schema defined in the QC architecture
+ * spec. They intentionally do not reference tracker-specific or provider-specific
+ * shapes so that Polaris can support multiple QC backends without vendor lock-in.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/scheduling/child-selector.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.selectNextChild = selectNextChild;
+exports.selectChildSlotClaims = selectChildSlotClaims;
 /**
  * Select the next child to execute.
  *
@@ -14,3 +15,83 @@ function selectNextChild(state) {
         return null;
     return [...state.open_children].sort()[0] ?? null;
 }
+function countActiveSlotsByProvider(claims) {
+    const activeSlotsByProvider = {};
+    for (const claim of claims) {
+        if (!claim.provider)
+            continue;
+        activeSlotsByProvider[claim.provider] = (activeSlotsByProvider[claim.provider] ?? 0) + 1;
+    }
+    return activeSlotsByProvider;
+}
+function selectChildSlotClaims(args) {
+    const now = args.now ?? new Date();
+    const nowMs = now.getTime();
+    const openSet = new Set(args.open_children);
+    const completedSet = new Set(args.completed_children);
+    const expired_claims = [];
+    const retainedClaims = args.existing_claims.filter((claim) => {
+        const expiresAt = new Date(claim.expires_at).getTime();
+        const notExpired = Number.isFinite(expiresAt) && expiresAt > nowMs;
+        const stillOpen = openSet.has(claim.child_id);
+        if (!notExpired || !stillOpen) {
+            expired_claims.push(claim.child_id);
+            return false;
+        }
+        return true;
+    });
+    const rejected_children = {};
+    const claimedChildren = new Set(retainedClaims.map((claim) => claim.child_id));
+    const availableSlots = Math.max(0, args.max_concurrent - retainedClaims.length);
+    const newClaims = [];
+    if (availableSlots > 0) {
+        for (const childId of args.open_children) {
+            if (newClaims.length >= availableSlots)
+                break;
+            if (childId === args.active_child)
+                continue;
+            if (claimedChildren.has(childId))
+                continue;
+            const dependencies = args.get_dependencies(childId);
+            const unmetDependencies = dependencies.filter((dependency) => openSet.has(dependency) && !completedSet.has(dependency));
+            if (unmetDependencies.length > 0) {
+                rejected_children[childId] = "blocked-dependency";
+                continue;
+            }
+            const decision = args.decide_route({
+                childId,
+                activeSlotsByProvider: countActiveSlotsByProvider([...retainedClaims, ...newClaims]),
+            });
+            const hardIneligibleReasons = new Set([
+                "role-disabled",
+                "not-in-policy",
+                "quota-exhausted",
+                "trust-too-low",
+                "capability-mismatch",
+                "cost-policy",
+                "no-slot",
+            ]);
+            const routingExhausted = decision.exhaustedReason !== undefined &&
+                (hardIneligibleReasons.has(decision.exhaustedReason) || decision.mode !== "delegated");
+            const canClaim = decision.selectedProvider !== undefined || decision.mode === "delegated";
+            if (routingExhausted || !canClaim) {
+                rejected_children[childId] = "router-ineligible";
+                continue;
+            }
+            newClaims.push({
+                child_id: childId,
+                provider: decision.selectedProvider ?? null,
+                claimed_at: now.toISOString(),
+                expires_at: new Date(nowMs + args.claim_ttl_ms).toISOString(),
+                selection_reason: decision.selectionReason,
+            });
+        }
+    }
+    const slot_claims = [...retainedClaims, ...newClaims];
+    return {
+        selected_child: slot_claims[0]?.child_id ?? null,
+        slot_claims,
+        rejected_children,
+        expired_claims,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsctech/polaris",
-  "version": "0.4.9",
+  "version": "0.5.2",
   "description": "Polaris — standalone taskchain orchestration framework for governed AI agent workflows",
   "bin": {
     "polaris": "dist/cli/index.js",