create-principles-disciple 1.93.0 → 1.95.0

package/console/dist/ui/utils/validators.js

@@ -357,6 +357,15 @@ export function validateAgentBindingUpdate(v) {
         return null;
     return { agent: v.agent, runtimeProfile: v.runtimeProfile, enabled: v.enabled };
 }
+export function validateFeatureFlagUpdate(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'feature') || !isString(v.feature))
+        return null;
+    if (!Object.hasOwn(v, 'enabled') || !isBoolean(v.enabled))
+        return null;
+    return { feature: v.feature, enabled: v.enabled };
+}
 export function validateReadinessCheck(v) {
     if (!isObject(v))
         return null;
@@ -934,6 +943,320 @@ const VALID_EVIDENCE_CHAIN_STATES = new Set([
     'malformed',
     'degraded',
 ]);
+// ── Intent Tension (PRI-469, SPEC §16) ───────────────────────────────────────
+//
+// Frontend mirror of the core IntentTension type. `confidence` is forbidden
+// (SPEC §16.3) — validateIntentTension rejects any object carrying it.
+// This validator is the Console's trust boundary: untrusted JSON from the API
+// is narrowed here before any UI code touches it (ERR-001).
+const VALID_INTENT_TENSION_SOURCES = ['none', 'action_drift', 'intent_suspect', 'healthy_tension'];
+const VALID_EVIDENCE_STRENGTHS = ['weak', 'moderate', 'strong'];
+const VALID_INTENT_RELATED_FIELDS = [
+    'why',
+    'desired_outcome',
+    'non_negotiables',
+    'stop_escalation',
+    'current_strategic_focus',
+];
+const VALID_SUGGESTED_OWNER_ACTIONS = [
+    'confirm_drift',
+    'revise_intent',
+    'observe',
+    'dismiss',
+    'promote_to_principle',
+    'promote_to_rulehost',
+];
+/**
+ * Validate an untrusted `intentTension` object from the EvidenceChain API
+ * response. Returns `null` when malformed; the caller (validateEvidenceChainRecord)
+ * treats a `null` intentTension as "not present" so the record is still usable.
+ *
+ * SPEC §16.3: `confidence` is forbidden — explicitly rejected here.
+ * SPEC §16.4: evidence is capped at 3 items; we accept up to 3 and reject
+ * arrays with non-string elements (ERR-005/007).
+ */
+export function validateIntentTension(v) {
+    if (!isObject(v))
+        return null;
+    // SPEC §16.3: confidence is forbidden on intentTension.
+    if (Object.hasOwn(v, 'confidence'))
+        return null;
+    // Required fields (ERR-009: fail loud when missing or wrong type)
+    if (!Object.hasOwn(v, 'source') || !isString(v.source))
+        return null;
+    if (!VALID_INTENT_TENSION_SOURCES.includes(v.source))
+        return null;
+    if (!Object.hasOwn(v, 'evidenceStrength') || !isString(v.evidenceStrength))
+        return null;
+    if (!VALID_EVIDENCE_STRENGTHS.includes(v.evidenceStrength))
+        return null;
+    if (!Object.hasOwn(v, 'relatedIntentFields') || !Array.isArray(v.relatedIntentFields))
+        return null;
+    const relatedIntentFields = [];
+    for (const f of v.relatedIntentFields) {
+        if (typeof f !== 'string')
+            return null;
+        if (!VALID_INTENT_RELATED_FIELDS.includes(f))
+            return null;
+        relatedIntentFields.push(f);
+    }
+    if (!Object.hasOwn(v, 'evidence') || !Array.isArray(v.evidence))
+        return null;
+    const evidence = [];
+    for (const e of v.evidence) {
+        if (typeof e !== 'string')
+            return null;
+        evidence.push(e);
+    }
+    // SPEC §16.4: cap at 3. Server-side already truncates, but the frontend
+    // must not trust that — enforce the cap here too (defense in depth).
+    const truncatedEvidence = evidence.slice(0, 3);
+    if (!Object.hasOwn(v, 'explanation') || !isString(v.explanation))
+        return null;
+    if (v.explanation.length === 0)
+        return null;
+    if (!Object.hasOwn(v, 'suggestedOwnerAction') || !isString(v.suggestedOwnerAction))
+        return null;
+    if (!VALID_SUGGESTED_OWNER_ACTIONS.includes(v.suggestedOwnerAction))
+        return null;
+    const result = {
+        source: v.source,
+        evidenceStrength: v.evidenceStrength,
+        relatedIntentFields,
+        evidence: truncatedEvidence,
+        explanation: v.explanation,
+        suggestedOwnerAction: v.suggestedOwnerAction,
+    };
+    // Optional: intentDocHash
+    if (Object.hasOwn(v, 'intentDocHash')) {
+        if (!isString(v.intentDocHash))
+            return null;
+        result.intentDocHash = v.intentDocHash;
+    }
+    return result;
+}
+/**
+ * Validate an untrusted IntentDecisionRecord object from the API.
+ * Returns null when malformed (Rule 3: fail loud on missing/wrong-type fields).
+ *
+ * Enum fields (source, evidenceStrength, ownerAction) are validated against
+ * the same sets used by validateIntentTension. relatedIntentFields elements
+ * are validated against VALID_INTENT_RELATED_FIELDS.
+ */
+export function validateIntentDecisionRecord(v) {
+    if (!isObject(v))
+        return null;
+    // Required fields (ERR-009: fail loud when missing or wrong type)
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'source') || !isString(v.source))
+        return null;
+    if (!VALID_INTENT_TENSION_SOURCES.includes(v.source))
+        return null;
+    if (!Object.hasOwn(v, 'evidenceStrength') || !isString(v.evidenceStrength))
+        return null;
+    if (!VALID_EVIDENCE_STRENGTHS.includes(v.evidenceStrength))
+        return null;
+    if (!Object.hasOwn(v, 'relatedIntentFields') || !Array.isArray(v.relatedIntentFields))
+        return null;
+    const relatedIntentFields = [];
+    for (const f of v.relatedIntentFields) {
+        if (typeof f !== 'string')
+            return null;
+        if (!VALID_INTENT_RELATED_FIELDS.includes(f))
+            return null;
+        relatedIntentFields.push(f);
+    }
+    if (!Object.hasOwn(v, 'ownerAction') || !isString(v.ownerAction))
+        return null;
+    if (!VALID_SUGGESTED_OWNER_ACTIONS.includes(v.ownerAction))
+        return null;
+    if (!Object.hasOwn(v, 'evidenceRefs') || !Array.isArray(v.evidenceRefs))
+        return null;
+    const evidenceRefs = [];
+    for (const e of v.evidenceRefs) {
+        if (typeof e !== 'string')
+            return null;
+        evidenceRefs.push(e);
+    }
+    if (!Object.hasOwn(v, 'createdAt') || !isString(v.createdAt))
+        return null;
+    const result = {
+        id: v.id,
+        source: v.source,
+        evidenceStrength: v.evidenceStrength,
+        relatedIntentFields,
+        ownerAction: v.ownerAction,
+        evidenceRefs,
+        createdAt: v.createdAt,
+    };
+    // Optional fields — fail loud when present but wrong type (ERR-009)
+    if (Object.hasOwn(v, 'painId')) {
+        if (!isString(v.painId))
+            return null;
+        result.painId = v.painId;
+    }
+    if (Object.hasOwn(v, 'taskId')) {
+        if (!isString(v.taskId))
+            return null;
+        result.taskId = v.taskId;
+    }
+    if (Object.hasOwn(v, 'runId')) {
+        if (!isString(v.runId))
+            return null;
+        result.runId = v.runId;
+    }
+    if (Object.hasOwn(v, 'intentDocHash')) {
+        if (!isString(v.intentDocHash))
+            return null;
+        result.intentDocHash = v.intentDocHash;
+    }
+    if (Object.hasOwn(v, 'resultingCandidateId')) {
+        if (!isString(v.resultingCandidateId))
+            return null;
+        result.resultingCandidateId = v.resultingCandidateId;
+    }
+    if (Object.hasOwn(v, 'resultingRuleCandidateId')) {
+        if (!isString(v.resultingRuleCandidateId))
+            return null;
+        result.resultingRuleCandidateId = v.resultingRuleCandidateId;
+    }
+    if (Object.hasOwn(v, 'patchProposalId')) {
+        if (!isString(v.patchProposalId))
+            return null;
+        result.patchProposalId = v.patchProposalId;
+    }
+    return result;
+}
+/**
+ * Validate a list of IntentDecisionRecord objects. Returns null if any
+ * element is malformed (ERR-005/007: validate array element types).
+ */
+export function validateIntentDecisionList(v) {
+    return validateArray(v, validateIntentDecisionRecord);
+}
+/**
+ * Validate the POST /api/v1/intent-decisions response envelope.
+ * Shape: { record: IntentDecisionRecord, created: boolean }
+ */
+export function validateIntentDecisionResult(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'record'))
+        return null;
+    const record = validateIntentDecisionRecord(v.record);
+    if (record === null)
+        return null;
+    if (!Object.hasOwn(v, 'created') || !isBoolean(v.created))
+        return null;
+    return { record, created: v.created };
+}
+/**
+ * Validate the GET /api/v1/intent-decisions/summary response.
+ * All 6 count keys must be present with non-negative finite numbers.
+ * lastDecisionAt: null is valid, string is valid, anything else returns null.
+ */
+export function validateIntentDecisionSummary(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'counts') || !isObject(v.counts))
+        return null;
+    const { counts } = v;
+    // Explicit per-key checks so isNumber type guards narrow each property.
+    if (!Object.hasOwn(counts, 'confirm_drift') || !isNumber(counts.confirm_drift) || counts.confirm_drift < 0)
+        return null;
+    if (!Object.hasOwn(counts, 'revise_intent') || !isNumber(counts.revise_intent) || counts.revise_intent < 0)
+        return null;
+    if (!Object.hasOwn(counts, 'observe') || !isNumber(counts.observe) || counts.observe < 0)
+        return null;
+    if (!Object.hasOwn(counts, 'dismiss') || !isNumber(counts.dismiss) || counts.dismiss < 0)
+        return null;
+    if (!Object.hasOwn(counts, 'promote_to_principle') || !isNumber(counts.promote_to_principle) || counts.promote_to_principle < 0)
+        return null;
+    if (!Object.hasOwn(counts, 'promote_to_rulehost') || !isNumber(counts.promote_to_rulehost) || counts.promote_to_rulehost < 0)
+        return null;
+    // lastDecisionAt: null or string
+    if (!Object.hasOwn(v, 'lastDecisionAt'))
+        return null;
+    const { lastDecisionAt } = v;
+    if (lastDecisionAt !== null && !isString(lastDecisionAt))
+        return null;
+    return {
+        counts: {
+            confirm_drift: counts.confirm_drift,
+            revise_intent: counts.revise_intent,
+            observe: counts.observe,
+            dismiss: counts.dismiss,
+            promote_to_principle: counts.promote_to_principle,
+            promote_to_rulehost: counts.promote_to_rulehost,
+        },
+        lastDecisionAt,
+    };
+}
+const FOLLOW_UP_RESPONSE_TYPES = new Set([
+    'link_candidate',
+    'guide_rulehost',
+    'generate_patch_proposal',
+]);
+/**
+ * Validate the POST /api/v1/intent-decisions/:id/follow-up response.
+ *
+ * The response is a discriminated union on the `type` field. Each branch has
+ * its own required fields (Rule 3: fail loud on missing required fields).
+ *
+ * Common required fields: `type`, `decisionId`.
+ * - link_candidate: + `record` (IntentDecisionRecordData), `linkedCandidateId`
+ * - guide_rulehost: + `cliCommand`, `note`
+ * - generate_patch_proposal: + `record`, `patchProposal: { id, markdown }`
+ */
+export function validateFollowUpResponse(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'type') || !isString(v.type))
+        return null;
+    if (!FOLLOW_UP_RESPONSE_TYPES.has(v.type))
+        return null;
+    if (!Object.hasOwn(v, 'decisionId') || !isString(v.decisionId))
+        return null;
+    const typedType = v.type;
+    const { decisionId } = v;
+    if (typedType === 'link_candidate') {
+        if (!Object.hasOwn(v, 'record'))
+            return null;
+        const record = validateIntentDecisionRecord(v.record);
+        if (record === null)
+            return null;
+        if (!Object.hasOwn(v, 'linkedCandidateId') || !isString(v.linkedCandidateId))
+            return null;
+        return { type: 'link_candidate', decisionId, record, linkedCandidateId: v.linkedCandidateId };
+    }
+    if (typedType === 'guide_rulehost') {
+        if (!Object.hasOwn(v, 'cliCommand') || !isString(v.cliCommand))
+            return null;
+        if (!Object.hasOwn(v, 'note') || !isString(v.note))
+            return null;
+        return { type: 'guide_rulehost', decisionId, cliCommand: v.cliCommand, note: v.note };
+    }
+    // generate_patch_proposal
+    if (!Object.hasOwn(v, 'record'))
+        return null;
+    const record = validateIntentDecisionRecord(v.record);
+    if (record === null)
+        return null;
+    if (!Object.hasOwn(v, 'patchProposal') || !isObject(v.patchProposal))
+        return null;
+    const pp = v.patchProposal;
+    if (!Object.hasOwn(pp, 'id') || !isString(pp.id))
+        return null;
+    if (!Object.hasOwn(pp, 'markdown') || !isString(pp.markdown))
+        return null;
+    return {
+        type: 'generate_patch_proposal',
+        decisionId,
+        record,
+        patchProposal: { id: pp.id, markdown: pp.markdown },
+    };
+}
 function validateEvidenceChainRecord(v) {
     if (!isObject(v))
         return null;
@@ -1040,6 +1363,20 @@ function validateEvidenceChainRecord(v) {
             return null;
         result.dreamerTaskStatus = v.dreamerTaskStatus;
     }
+    // PRI-469: intentTension (optional). When present but malformed, we DROP
+    // the intentTension field but keep the rest of the record (the Owner still
+    // sees the pain evidence). This matches the core's graceful-degradation
+    // behavior where a malformed intentTension is omitted rather than failing
+    // the entire record. The degradedReason on the record (if any) explains
+    // what happened.
+    if (Object.hasOwn(v, 'intentTension')) {
+        const tension = validateIntentTension(v.intentTension);
+        if (tension !== null) {
+            result.intentTension = tension;
+        }
+        // If tension === null, we intentionally do NOT return null here — the
+        // record is still valid, just without intentTension.
+    }
     return result;
 }
 export function validateEvidenceChain(v) {
@@ -1193,3 +1530,99 @@ export function validateTrajectoryData(v) {
     }
     return result;
 }
+// ── Intent Page (PRI-466) ────────────────────────────────────────────────────
+const VALID_INTENT_REASONS = ['flag_disabled', 'not_found', 'read_error', 'parse_error', 'oversized'];
+const VALID_INTENT_WARNING_CODES = ['missing_section', 'empty_section', 'too_vague', 'oversized', 'parse_failed'];
+const VALID_INTENT_SECTION_KEYS = ['why', 'desiredOutcome', 'nonNegotiables', 'stopEscalation', 'currentStrategicFocus'];
+export function validateIntentWarning(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'code') || !isString(v.code))
+        return null;
+    if (!VALID_INTENT_WARNING_CODES.includes(v.code))
+        return null;
+    if (!Object.hasOwn(v, 'message') || !isString(v.message))
+        return null;
+    const result = { code: v.code, message: v.message };
+    // Runtime Contract Rule #3: fail loud on wrong-type optional fields,
+    // consistent with validateIntentSummary's optional-field handling.
+    if (Object.hasOwn(v, 'section')) {
+        if (!isString(v.section))
+            return null;
+        result.section = v.section;
+    }
+    return result;
+}
+export function validateIntentSections(v) {
+    if (!isObject(v))
+        return null;
+    const result = {};
+    for (const key of VALID_INTENT_SECTION_KEYS) {
+        if (Object.hasOwn(v, key)) {
+            const val = v[key];
+            if (val !== null && !isString(val))
+                return null;
+            if (isString(val)) {
+                result[key] = val;
+            }
+        }
+    }
+    return result;
+}
+export function validateIntentSummary(v) {
+    if (!isObject(v))
+        return null;
+    // Required fields
+    if (!Object.hasOwn(v, 'ok') || !isBoolean(v.ok))
+        return null;
+    if (!Object.hasOwn(v, 'found') || !isBoolean(v.found))
+        return null;
+    if (!Object.hasOwn(v, 'flagEnabled') || !isBoolean(v.flagEnabled))
+        return null;
+    if (!Object.hasOwn(v, 'warnings') || !Array.isArray(v.warnings))
+        return null;
+    const warnings = validateArray(v.warnings, validateIntentWarning);
+    if (warnings === null)
+        return null;
+    const result = {
+        ok: v.ok,
+        found: v.found,
+        flagEnabled: v.flagEnabled,
+        warnings,
+    };
+    // Optional fields — validate type if present, fail loud on wrong type
+    if (Object.hasOwn(v, 'reason')) {
+        if (!isString(v.reason))
+            return null;
+        if (!VALID_INTENT_REASONS.includes(v.reason))
+            return null;
+        result.reason = v.reason;
+    }
+    if (Object.hasOwn(v, 'nextAction')) {
+        if (!isString(v.nextAction))
+            return null;
+        result.nextAction = v.nextAction;
+    }
+    if (Object.hasOwn(v, 'path')) {
+        if (!isString(v.path))
+            return null;
+        result.path = v.path;
+    }
+    if (Object.hasOwn(v, 'contentHash')) {
+        if (!isString(v.contentHash))
+            return null;
+        result.contentHash = v.contentHash;
+    }
+    if (Object.hasOwn(v, 'lastEditedAt')) {
+        if (!isString(v.lastEditedAt))
+            return null;
+        result.lastEditedAt = v.lastEditedAt;
+    }
+    if (Object.hasOwn(v, 'sections')) {
+        const sections = validateIntentSections(v.sections);
+        if (sections === null)
+            return null;
+        result.sections = sections;
+    }
+    return result;
+}