@nexusclawhq/cli 0.2.1

package/dist/nexus-cli/node_modules/@nexusclaw/shared/dist/ai-workforce-learning/index.js

@@ -0,0 +1,1261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_WORKFORCE_LEARNING_STATUS_TRANSITIONS = exports.AI_WORKFORCE_TEMPLATE_KEY_PATTERN = exports.AI_WORKFORCE_STABLE_TOOL_NAME_PATTERN = exports.AI_WORKFORCE_REDACTED_VALUE = exports.AI_WORKFORCE_HIRING_MARKETPLACE_RELEASE_READINESS = exports.AI_WORKFORCE_HIRING_MARKETPLACE_CANDIDATE_TYPES = exports.AI_WORKFORCE_HIRING_MARKETPLACE_SOURCE_TYPES = exports.AI_WORKFORCE_GOAL_TO_AGENT_BLUEPRINT_STATUSES = exports.AI_WORKFORCE_LEARNING_CONTENT_STATUSES = exports.AI_WORKFORCE_TARGET_ARTIFACT_CONTENT_POSTURE = exports.AI_WORKFORCE_LEARNING_CONTENT_POSTURES = exports.AI_WORKFORCE_MODEL_ROUTING_GUARD_REASON_CODES = exports.AI_WORKFORCE_ROLLBACK_REASON_CODES = exports.LEARNING_ELIGIBLE_RISK_LEVELS = exports.AI_WORKFORCE_RISK_LEVELS = exports.AI_WORKFORCE_APPROVAL_STATUSES = exports.AI_WORKFORCE_RELEASE_GATE_STATUSES = exports.AI_WORKFORCE_REDACTION_STATUSES = exports.AI_WORKFORCE_LEARNING_PIPELINE_STATUSES = exports.AI_WORKFORCE_TARGET_ARTIFACT_TYPES = exports.AI_WORKFORCE_ARTIFACT_CANDIDATE_TYPES = exports.AI_WORKFORCE_IMPROVEMENT_RECOMMENDATION_SOURCE_TYPES = exports.AI_WORKFORCE_IMPROVEMENT_RECOMMENDATION_TYPES = exports.AI_WORKFORCE_LEARNING_SIGNAL_TYPES = exports.AI_WORKFORCE_BEHAVIOR_EVENT_TYPES = void 0;
+exports.isLearningEligibleRiskLevel = isLearningEligibleRiskLevel;
+exports.requiresApprovalRiskLevel = requiresApprovalRiskLevel;
+exports.getAiWorkforceLearningContentPosture = getAiWorkforceLearningContentPosture;
+exports.canTransitionAiWorkforceLearningStatus = canTransitionAiWorkforceLearningStatus;
+exports.getAiWorkforceLearningReadinessIssues = getAiWorkforceLearningReadinessIssues;
+exports.isAiWorkforceBehaviorEventLearningReady = isAiWorkforceBehaviorEventLearningReady;
+exports.createRedactedAiWorkforceBehaviorEventSample = createRedactedAiWorkforceBehaviorEventSample;
+exports.validateLearningGuardrailRuleCandidatePatch = validateLearningGuardrailRuleCandidatePatch;
+exports.validateLearningKnowledgeSourceCandidatePatch = validateLearningKnowledgeSourceCandidatePatch;
+exports.validateLearningToolPermissionCandidateConfig = validateLearningToolPermissionCandidateConfig;
+exports.validateLearningApprovalPolicyCandidatePatch = validateLearningApprovalPolicyCandidatePatch;
+exports.validateLearningEmployeeTemplateCandidatePatch = validateLearningEmployeeTemplateCandidatePatch;
+exports.validateLearningSopDocumentCandidatePatch = validateLearningSopDocumentCandidatePatch;
+exports.validateLearningWorkflowDraftDefinition = validateLearningWorkflowDraftDefinition;
+exports.validateLearningPromptPolicyDraftContent = validateLearningPromptPolicyDraftContent;
+exports.validateLearningModelRoutingCandidatePatch = validateLearningModelRoutingCandidatePatch;
+exports.validateLearningPromptTemplateCandidatePatch = validateLearningPromptTemplateCandidatePatch;
+exports.validateLearningAgentCandidatePatch = validateLearningAgentCandidatePatch;
+exports.AI_WORKFORCE_BEHAVIOR_EVENT_TYPES = [
+    'execution_started',
+    'user_input_received',
+    'context_retrieved',
+    'knowledge_retrieved',
+    'agent_output_generated',
+    'tool_call_started',
+    'tool_call_completed',
+    'tool_call_failed',
+    'policy_checked',
+    'guardrail_triggered',
+    'approval_requested',
+    'approval_approved',
+    'approval_rejected',
+    'human_edit_applied',
+    'human_handoff_triggered',
+    'execution_completed',
+    'execution_failed',
+    'outcome_verified',
+    'feedback_received',
+    'learning_signal_generated',
+    'improvement_recommendation_generated',
+];
+exports.AI_WORKFORCE_LEARNING_SIGNAL_TYPES = [
+    'successful_behavior_pattern',
+    'failed_behavior_pattern',
+    'human_correction_pattern',
+    'approval_pattern',
+    'rejection_pattern',
+    'knowledge_gap',
+    'knowledge_conflict',
+    'missing_tool',
+    'tool_failure_pattern',
+    'prompt_policy_gap',
+    'guardrail_gap',
+    'workflow_bottleneck',
+    'sop_drift',
+    'model_routing_issue',
+    'cost_optimization_opportunity',
+    'autonomy_upgrade_candidate',
+    'autonomy_downgrade_candidate',
+    'test_case_candidate',
+    'regression_case_candidate',
+    'template_candidate',
+    'auto_approval_candidate',
+];
+exports.AI_WORKFORCE_IMPROVEMENT_RECOMMENDATION_TYPES = [
+    'hire_new_employee',
+    'improve_existing_employee',
+    'create_workflow',
+    'update_workflow',
+    'add_guardrail',
+    'relax_guardrail',
+    'add_tool',
+    'change_tool_permission',
+    'update_sop',
+    'update_knowledge',
+    'generate_test_suite',
+    'upgrade_autonomy',
+    'downgrade_autonomy',
+    'change_model_routing',
+    'auto_approval_policy',
+    'prompt_policy_update',
+];
+exports.AI_WORKFORCE_IMPROVEMENT_RECOMMENDATION_SOURCE_TYPES = [
+    'learning_signal',
+    'learned_pattern',
+    'behavior_event',
+    'goal_blueprint',
+    'advisor_recommendation',
+];
+exports.AI_WORKFORCE_ARTIFACT_CANDIDATE_TYPES = [
+    'prompt_policy_update',
+    'prompt_template_update',
+    'guardrail_update',
+    'workflow_update',
+    'sop_update',
+    'knowledge_update',
+    'tool_permission_update',
+    'approval_policy_update',
+    'model_routing_update',
+    'employee_template',
+    'test_case',
+    'eval_suite',
+    'skill_recommendation',
+];
+exports.AI_WORKFORCE_TARGET_ARTIFACT_TYPES = [
+    'agent',
+    'agent_version',
+    'prompt_policy',
+    'prompt_template',
+    'guardrail',
+    'workflow',
+    'sop',
+    'knowledge',
+    'tool_permission',
+    'approval_policy',
+    'model_routing',
+    'employee_template',
+    'test_case',
+    'eval_suite',
+];
+exports.AI_WORKFORCE_LEARNING_PIPELINE_STATUSES = [
+    'captured',
+    'redaction_pending',
+    'redacted',
+    'ineligible',
+    'eligible',
+    'signal_extracted',
+    'pattern_generated',
+    'recommendation_generated',
+    'draft_created',
+    'tests_required',
+    'simulation_running',
+    'simulation_failed',
+    'approval_required',
+    'approved',
+    'rejected',
+    'ready_to_publish',
+    'published',
+    'rolled_back',
+];
+exports.AI_WORKFORCE_REDACTION_STATUSES = [
+    'not_required',
+    'pending',
+    'redacted',
+    'failed',
+    'blocked',
+];
+exports.AI_WORKFORCE_RELEASE_GATE_STATUSES = [
+    'not_started',
+    'tests_required',
+    'tests_running',
+    'tests_failed',
+    'simulation_required',
+    'simulation_running',
+    'simulation_failed',
+    'approval_required',
+    'ready_to_publish',
+    'published',
+    'blocked',
+    'rolled_back',
+];
+exports.AI_WORKFORCE_APPROVAL_STATUSES = [
+    'not_required',
+    'required',
+    'pending',
+    'approved',
+    'rejected',
+    'expired',
+];
+exports.AI_WORKFORCE_RISK_LEVELS = ['L0', 'L1', 'L2', 'L3', 'L4'];
+/**
+ * code-quality-audit-remediation-v1 R6 (P1-9) — single source of truth for
+ * "which risk levels are learning-eligible". Before this, three call sites
+ * each independently hand-wrote this same rule with drifted literal
+ * expressions: `behavior-learning-capture.service.ts` used
+ * `['L0','L1','L2'].includes(riskLevel)`, `behavior-learning-pipeline
+ * .service.ts` independently rewrote the identical whitelist for its
+ * `risk_not_allowed` gate, and `behavior-learning-governance-route
+ * .service.ts` used the logically-equivalent-but-differently-written
+ * complement `riskLevel !== 'L0' && riskLevel !== 'L1'` for its
+ * `approvalRequired` gate (see `requiresApprovalRiskLevel` below — a
+ * DIFFERENT rule, not a duplicate of this one; the two happen to be
+ * complements of each other today but govern different decisions and must
+ * stay as two named functions, not be collapsed into one).
+ */
+exports.LEARNING_ELIGIBLE_RISK_LEVELS = ['L0', 'L1', 'L2'];
+function isLearningEligibleRiskLevel(riskLevel) {
+    return exports.LEARNING_ELIGIBLE_RISK_LEVELS.includes(riskLevel);
+}
+/**
+ * code-quality-audit-remediation-v1 R6 (P1-9) — single source of truth for
+ * "which risk levels require approval before publication". Governs
+ * `behavior-learning-governance-route.service.ts`'s `approvalRequired`
+ * decision. See `isLearningEligibleRiskLevel` above for why this is a
+ * separate function rather than reusing/negating that one.
+ */
+function requiresApprovalRiskLevel(riskLevel) {
+    return !(riskLevel === 'L0' || riskLevel === 'L1');
+}
+/**
+ * learning-content-generation-v1 R2.2 (rollback mutation) — closed set of
+ * stable reasonCode values a caller may pass to `rollbackLearningPublication`.
+ *
+ * Prior to this (Phase 0 finding), `rollback_reason_code`
+ * (`behavior-learning-rollback-execution.entity.ts`) and every owner
+ * rollback service only enforced the generic stable-code SHAPE regex
+ * (`^[a-z][a-z0-9_]*$`, see `normalizeRequiredStableCode()` in
+ * `behavior-learning-rollback-execution.service.ts`) — there was no closed
+ * vocabulary. This is a genuinely new contract, not a pre-existing word
+ * list being "discovered". The DB column stays free-form varchar to remain
+ * compatible with any pre-existing rows; this enum is enforced at the
+ * GraphQL/class-validator layer only (see
+ * `RollbackLearningPublicationInput.reasonCode` in
+ * `ai-workforce-learning-rollback.input.ts`).
+ *
+ * `cost_regression` / `safety_regression` added by
+ * model-routing-learning-publication-v1 Phase 5 (requirements.md R6,
+ * design.md §6): the three model_routing monitoring regression triggers
+ * (cost/quality/safety) each produce a rollback RECOMMENDATION carrying one
+ * of these stable codes. `quality_regression` already existed and is reused
+ * verbatim for the quality trigger — it is not a new concept, just a new
+ * (real) producer of an existing code. Per Q4 (signed): every trigger only
+ * ever produces a recommendation; a human must still separately call
+ * `rollbackLearningPublication` with this same reasonCode for the EXISTING
+ * Phase 4 rollback path to actually run — no trigger, including safety,
+ * calls that mutation itself (see
+ * `model-routing-monitoring-regression.service.ts`).
+ */
+exports.AI_WORKFORCE_ROLLBACK_REASON_CODES = [
+    'quality_regression',
+    'cost_regression',
+    'safety_regression',
+    'incident_rollback',
+    'manual_operator_decision',
+    'policy_violation',
+];
+/**
+ * model-routing-learning-publication-v1 R2/R3/R5 — new stable reason codes
+ * the (Phase 4) `ModelRoutingPublicationAdapter` and its R2 safety guard /
+ * R3 budget guard / R5 simulation-evidence gate return via
+ * `BehaviorLearningPublicationAdapterRefusal.reasonCode`
+ * (`behavior-learning-publication-adapter.registry.ts`'s
+ * `reasonCode: string` field). The 4 existing adapters (guardrail/
+ * tool_permission/approval_policy/sop) reuse a shared *generic* rejection
+ * vocabulary (`target_missing` / `content_missing` / `content_invalid` /
+ * `rollback_owner_rejected`) as inline literals scattered per-adapter-file
+ * — there is no dedicated shared-package constant for that generic set
+ * today, and this spec does not introduce one (out of scope). What IS new
+ * here is a set of reason codes specific to a single artifact type's own
+ * guard logic (safety/budget/simulation-evidence gates unique to
+ * `model_routing`, requirements.md R2/R3/R5) — those get a named closed-set
+ * export so Phase 2's guards and Phase 4's adapter both reference the same
+ * stable codes instead of re-typing string literals in multiple files.
+ * Chinese/English copy for these lives only in
+ * `packages/shared/src/locales/{zh-CN,en-US}.ts`
+ * (`aiWorkforceLearningCopy.contentPanel.modelRoutingGuardReasonCode`,
+ * requirements.md R8) — never re-derive display text from the code string
+ * itself.
+ */
+exports.AI_WORKFORCE_MODEL_ROUTING_GUARD_REASON_CODES = [
+    'safety_guard_rejected',
+    'budget_guard_rejected',
+    'simulation_evidence_missing',
+];
+/**
+ * learning-content-generation-v1 R3.6/R4 — content-generation posture per
+ * `AiWorkforceTargetArtifactType`. Drives both the `generateLearningDraftContent`
+ * mutation's structured-rejection branch and the front-end's per-type
+ * rendering (design.md §7):
+ *
+ * - `llm_patch`: the 7 patch-type owners (guardrail/knowledge/tool_permission/
+ *   approval_policy/employee_template/sop/model_routing) — LLM drafts a patch
+ *   payload against the type's content contract, subject to the full
+ *   evidence/validator/generation pipeline. NOTE (Phase 0 finding for the
+ *   first 6, do not re-litigate; model-routing-learning-publication-v1
+ *   Phase 4 for the 7th): 5 of these 7 (guardrail/tool_permission/
+ *   approval_policy/sop/model_routing) have zero real `targetArtifactId` in
+ *   the current pipeline (`BehaviorLearningTargetIdentityService` does not
+ *   resolve `model_routing` — see `model-routing-publication.adapter.ts`'s
+ *   class doc) and will therefore always terminate at a "target missing"
+ *   outcome before an LLM call is ever made — this posture only says "the
+ *   content SHAPE is patch-like", not "a real candidate of this type can
+ *   reach `generated`" via the fully-automated pipeline. Honesty note
+ *   specific to `model_routing` (do not conflate with the publish/rollback
+ *   chain below, which IS fully real): `learning-draft-content-generator
+ *   .service.ts`'s internal `describeSchemaForType()`/`validateForType()`
+ *   switches also have no `model_routing` case yet (both fall to their
+ *   generic default), so even a hand-supplied `targetArtifactId` reaching
+ *   the real `generateLearningDraftContent` mutation would terminate at
+ *   `validation_failed`, not `generated` — wiring that LLM-drafting path is
+ *   a real, separate, still-open gap, not required by
+ *   model-routing-learning-publication-v1 (R1-R7 only cover PUBLISHING an
+ *   already-generated candidate, not drafting one). What IS fully real and
+ *   proven end-to-end: a candidate whose `generatedContent` is set directly
+ *   (bypassing the LLM generator, the same "hand-built content" idiom the
+ *   other four adapters' own e2e coverage already uses) flows through the
+ *   real R1 re-validator, R2/R3/R5 guards, R4 canary overlay, and real
+ *   `setOrgPolicy` publish/rollback — see the real-Postgres full-lifecycle
+ *   integration test in `model-routing-publication-adapter.e2e.integration
+ *   .spec.ts`.
+ * - `reference_no_content`: `test_case`/`eval_suite` — the artifact already
+ *   has real, publishable content (a materialized `AgentTestCase` /
+ *   `AgentTestSuite`); there is nothing for an LLM to draft.
+ * - `reference_draft_pending`: `workflow`/`prompt_policy`/`prompt_template`/
+ *   `agent` — drafting requires materializing a non-active draft entity
+ *   through the owning module's own creation path, not just writing
+ *   `generated_content` on the candidate row. `prompt_template` moved INTO
+ *   this bucket in prompt-template-learning-publication-v1 Phase 2
+ *   (requirements.md R1/R7): `PromptTemplateVersionService`'s snapshot/
+ *   archive path is still not treated as the draft boundary (that judgment
+ *   from learning-content-generation-v2 phase-5 stands unchanged) — the NEW
+ *   `PromptTemplateLearningDraft` table is the real pending→activated→
+ *   rolled_back draft boundary instead. `agent` moved INTO this bucket in
+ *   agent-learning-publication-v1 Phase 2 (requirements.md R1/R3/R7, Q9
+ *   signed): ONLY `improve_existing_employee`-sourced candidates can reach
+ *   `generated` — `upgrade_autonomy`/`downgrade_autonomy` candidates share
+ *   this same `targetArtifactType`/posture but are still honestly deferred
+ *   by the generator's own R3 sub-gate (posture cannot distinguish
+ *   recommendationType; see `learning-draft-content-generator.service.ts`'s
+ *   `checkAgentAutonomySubGate()`) — autonomy-level semantics have no data
+ *   model in this codebase (Phase 0 finding) and remain out of scope for a
+ *   future, independent spec.
+ * - `deferred`: `agent_version` only — v2 product-decision defer, now
+ *   permanent (agent-version-learning-publication-v1 closed by decision,
+ *   2026-07-09: standalone publication is not needed — the existing
+ *   rollback owner already IS "publish a historical AgentVersion" in
+ *   substance). `model_routing` moved OUT of this bucket in model-routing-
+ *   learning-publication-v1 Phase 4 (requirements.md R7) — it is now
+ *   `llm_patch`, real adapter, real owner, real publish/rollback (see
+ *   `ModelRoutingPublicationAdapter`).
+ */
+exports.AI_WORKFORCE_LEARNING_CONTENT_POSTURES = [
+    'llm_patch',
+    'reference_no_content',
+    'reference_draft_pending',
+    'deferred',
+];
+/**
+ * Per-type posture lookup — single source of truth consumed by both the
+ * backend (`generateLearningDraftContent` mutation's non-`llm_patch`
+ * structured rejection) and the front-end (design.md §7 per-posture
+ * rendering). Every one of the 14 `AiWorkforceTargetArtifactType`s must
+ * appear exactly once here.
+ */
+exports.AI_WORKFORCE_TARGET_ARTIFACT_CONTENT_POSTURE = {
+    guardrail: 'llm_patch',
+    knowledge: 'llm_patch',
+    tool_permission: 'llm_patch',
+    approval_policy: 'llm_patch',
+    employee_template: 'llm_patch',
+    sop: 'llm_patch',
+    test_case: 'reference_no_content',
+    eval_suite: 'reference_no_content',
+    workflow: 'reference_draft_pending',
+    prompt_policy: 'reference_draft_pending',
+    // prompt-template-learning-publication-v1 Phase 2 (requirements.md R1/R7,
+    // Phase 0 correction) — flipped from 'deferred' to 'reference_draft_pending'.
+    // This flip only unlocks DRAFT GENERATION (a real `PromptTemplateLearningDraft`
+    // row can now be materialized) — PUBLISH remains blocked independently
+    // until Phase 4 registers `PromptTemplatePublicationAdapter` (dispatch
+    // gates on `registry.get()`, not this posture value; see
+    // `behavior-learning-publication-dispatch.service.ts`).
+    prompt_template: 'reference_draft_pending',
+    // agent-learning-publication-v1 Phase 2 (requirements.md R1/R3/R7) —
+    // flipped from 'deferred' to 'reference_draft_pending'. This flip only
+    // unlocks DRAFT GENERATION for `improve_existing_employee`-sourced
+    // candidates (a real `AgentLearningDraft` row can now be materialized;
+    // `upgrade_autonomy`/`downgrade_autonomy` stay deferred via the
+    // generator's own R3 sub-gate, not via posture) — PUBLISH remains
+    // blocked independently until Phase 4 registers `AgentPublicationAdapter`
+    // (dispatch gates on `registry.get()`, not this posture value).
+    agent: 'reference_draft_pending',
+    // model-routing-learning-publication-v1 Phase 4 (requirements.md R7) —
+    // flipped from 'deferred' to 'llm_patch'. Pre-conditions (R1-R6) all
+    // shipped in Phases 1-3; `ModelRoutingPublicationAdapter` (Phase 4) is
+    // registered and real. See this const's doc comment above for the
+    // targetArtifactId caveat shared with guardrail/tool_permission/
+    // approval_policy/sop.
+    model_routing: 'llm_patch',
+    agent_version: 'deferred',
+};
+function getAiWorkforceLearningContentPosture(targetArtifactType) {
+    return exports.AI_WORKFORCE_TARGET_ARTIFACT_CONTENT_POSTURE[targetArtifactType];
+}
+/**
+ * learning-content-generation-v1 R3/R4 — closed set of terminal
+ * `content_status` values a candidate's generated-content lifecycle can
+ * reach, plus the one non-terminal starting value. Exactly 4 terminal
+ * states per design.md §5.5 — do not add a 5th without updating the
+ * migration/entity/GraphQL object type together.
+ */
+exports.AI_WORKFORCE_LEARNING_CONTENT_STATUSES = [
+    'not_generated',
+    'generated',
+    'insufficient_evidence',
+    'validation_failed',
+    'generation_failed',
+];
+/**
+ * learning-content-generation-v2 Phase 2 — persisted Goal-to-Agent blueprint
+ * lifecycle. These rows are draft planning artifacts only; none of these
+ * statuses may be interpreted as "active employee created" or "published".
+ */
+exports.AI_WORKFORCE_GOAL_TO_AGENT_BLUEPRINT_STATUSES = [
+    'draft',
+    'insufficient_evidence',
+    'validation_failed',
+];
+/**
+ * learning-content-generation-v2 Phase 3 — Hiring Marketplace candidate
+ * read-model contract. This is a query/view contract only: a marketplace
+ * candidate is not an active employee and does not by itself publish any
+ * owner configuration.
+ */
+exports.AI_WORKFORCE_HIRING_MARKETPLACE_SOURCE_TYPES = [
+    'behavior_candidate',
+    'goal_blueprint',
+    'advisor_recommendation',
+];
+exports.AI_WORKFORCE_HIRING_MARKETPLACE_CANDIDATE_TYPES = [
+    'employee_template',
+    'goal_to_agent_blueprint',
+];
+exports.AI_WORKFORCE_HIRING_MARKETPLACE_RELEASE_READINESS = [
+    'needs_tests',
+    'needs_approval',
+    'ready_for_draft',
+    'blocked',
+];
+exports.AI_WORKFORCE_REDACTED_VALUE = '[REDACTED]';
+/** Regex the tool-permission owner service enforces on every entry of
+ * `allowedTools`/`blockedTools` (`STABLE_TOOL_NAME` in
+ * `tool-permission-learning-publication-owner.service.ts`). Exported so the
+ * shared validator and any front-end input validation use the exact same
+ * pattern rather than a hand-copied approximation. */
+exports.AI_WORKFORCE_STABLE_TOOL_NAME_PATTERN = /^[A-Za-z0-9:._/-]+$/;
+/** Regex the employee-template owner service enforces on `templateKey`
+ * (`TEMPLATE_KEY` in `employee-template-learning-publication-owner.service.ts`).
+ * Exported so the generator's slugify step and the shared validator use the
+ * exact same pattern. */
+exports.AI_WORKFORCE_TEMPLATE_KEY_PATTERN = /^[a-z][a-z0-9_-]{2,127}$/;
+exports.AI_WORKFORCE_LEARNING_STATUS_TRANSITIONS = {
+    captured: ['redaction_pending', 'ineligible'],
+    redaction_pending: ['redacted', 'ineligible'],
+    redacted: ['eligible', 'ineligible'],
+    ineligible: [],
+    eligible: ['signal_extracted'],
+    signal_extracted: ['pattern_generated', 'recommendation_generated'],
+    pattern_generated: ['recommendation_generated'],
+    recommendation_generated: ['draft_created', 'rejected'],
+    draft_created: ['tests_required', 'approval_required'],
+    tests_required: ['simulation_running', 'approval_required'],
+    simulation_running: ['simulation_failed', 'approval_required', 'ready_to_publish'],
+    simulation_failed: ['draft_created', 'rejected'],
+    approval_required: ['approved', 'rejected'],
+    approved: ['ready_to_publish'],
+    rejected: [],
+    ready_to_publish: ['published'],
+    published: ['rolled_back'],
+    rolled_back: [],
+};
+function canTransitionAiWorkforceLearningStatus(from, to) {
+    return exports.AI_WORKFORCE_LEARNING_STATUS_TRANSITIONS[from].includes(to);
+}
+function getAiWorkforceLearningReadinessIssues(event) {
+    const issues = [];
+    if (!event.learningEligible) {
+        issues.push('learning_not_eligible');
+    }
+    if (event.redactionStatus !== 'redacted' && event.redactionStatus !== 'not_required') {
+        issues.push('redaction_not_complete');
+    }
+    return issues;
+}
+function isAiWorkforceBehaviorEventLearningReady(event) {
+    return getAiWorkforceLearningReadinessIssues(event).length === 0;
+}
+function createRedactedAiWorkforceBehaviorEventSample(overrides = {}) {
+    return {
+        id: 'bev_001',
+        tenantId: 'tenant_001',
+        employeeId: 'agent_refund_specialist',
+        agentId: 'agent_refund_specialist',
+        workflowId: null,
+        executionId: 'exec_123',
+        spanId: 'span_001',
+        correlationId: 'corr_001',
+        eventType: 'human_edit_applied',
+        eventSource: 'agent_runtime',
+        userId: 'user_reviewer_001',
+        department: 'support',
+        channel: 'web',
+        businessObjectType: 'Case',
+        businessObjectId: 'case_001',
+        riskLevel: 'L1',
+        inputSnapshot: exports.AI_WORKFORCE_REDACTED_VALUE,
+        outputSnapshot: 'Refund approved. Customer should receive funds in 5-7 days.',
+        contextSnapshot: { customerEmail: exports.AI_WORKFORCE_REDACTED_VALUE },
+        toolCalls: [],
+        knowledgeRefs: [],
+        approvals: [],
+        humanEdits: [
+            {
+                before: 'Refund approved. Customer should receive funds in 5-7 days.',
+                after: 'Refund approved under Refund Policy Section 3.2. Customer should receive funds in 5-7 days.',
+                changedFields: ['response.body'],
+                reason: 'policy_citation_added',
+                improvedOutcome: true,
+            },
+        ],
+        finalOutcome: { status: 'completed', outcomeVerified: true },
+        feedback: { rating: 'up', qualityScore: 0.94 },
+        labels: ['corrected_by_human', 'outcome_verified'],
+        redactionStatus: 'redacted',
+        piiDetected: true,
+        learningEligible: true,
+        createdAt: '2026-07-01T00:00:00.000Z',
+        ...overrides,
+    };
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+const STABLE_RISK_LEVELS = new Set(exports.AI_WORKFORCE_RISK_LEVELS);
+// ---------------------------------------------------------------------
+// guardrail — mirrors GuardrailLearningPublicationOwnerService.normalizeCandidateRulePatch()
+// ---------------------------------------------------------------------
+function validateLearningGuardrailRuleCandidatePatch(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidateRulePatch must be an object'] };
+    }
+    const data = {};
+    if (raw.name !== undefined && raw.name !== null) {
+        if (!isNonEmptyString(raw.name)) {
+            errors.push('name must be a non-empty string');
+        }
+        else {
+            data.name = raw.name.trim();
+        }
+    }
+    if (raw.description !== undefined) {
+        if (raw.description === null) {
+            data.description = null;
+        }
+        else if (typeof raw.description !== 'string') {
+            errors.push('description must be a string');
+        }
+        else {
+            data.description = raw.description.trim();
+        }
+    }
+    if (raw.isActive !== undefined && raw.isActive !== null) {
+        if (typeof raw.isActive !== 'boolean') {
+            errors.push('isActive must be a boolean');
+        }
+        else {
+            data.isActive = raw.isActive;
+        }
+    }
+    if (raw.priority !== undefined && raw.priority !== null) {
+        if (!Number.isInteger(raw.priority) || raw.priority <= 0) {
+            errors.push('priority must be a positive integer');
+        }
+        else {
+            data.priority = raw.priority;
+        }
+    }
+    if (raw.conditions !== undefined && raw.conditions !== null) {
+        if (!isPlainObject(raw.conditions)) {
+            errors.push('conditions must be an object');
+        }
+        else {
+            data.conditions = raw.conditions;
+        }
+    }
+    if (raw.riskLevel !== undefined && raw.riskLevel !== null) {
+        if (typeof raw.riskLevel !== 'string' || !STABLE_RISK_LEVELS.has(raw.riskLevel)) {
+            errors.push('riskLevel must be one of L0, L1, L2, L3, L4');
+        }
+        else {
+            data.riskLevel = raw.riskLevel;
+        }
+    }
+    if (raw.action !== undefined && raw.action !== null) {
+        if (!isPlainObject(raw.action)) {
+            errors.push('action must be an object');
+        }
+        else {
+            data.action = raw.action;
+        }
+    }
+    if (errors.length === 0 && Object.keys(data).length === 0) {
+        errors.push('candidateRulePatch must change at least one rule field');
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true, data };
+}
+// ---------------------------------------------------------------------
+// knowledge — mirrors KnowledgeLearningPublicationOwnerService.normalizeCandidateSourcePatch()
+// ---------------------------------------------------------------------
+const KNOWLEDGE_ACCESS_LEVELS = new Set(['public', 'private', 'org_subtree']);
+function validateLearningKnowledgeSourceCandidatePatch(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidateSourcePatch must be an object'] };
+    }
+    if (!isNonEmptyString(raw.content)) {
+        errors.push('content is required and must be a non-empty string');
+    }
+    if (raw.title !== undefined && raw.title !== null && !isNonEmptyString(raw.title)) {
+        errors.push('title must be a non-empty string when provided');
+    }
+    const data = {
+        content: isNonEmptyString(raw.content) ? raw.content.trim() : '',
+    };
+    if (raw.title !== undefined) {
+        data.title = raw.title === null ? null : isNonEmptyString(raw.title) ? raw.title.trim() : null;
+    }
+    if (raw.sourceType !== undefined) {
+        if (raw.sourceType !== null && !isNonEmptyString(raw.sourceType)) {
+            errors.push('sourceType must be a non-empty string when provided');
+        }
+        else {
+            data.sourceType = raw.sourceType === null ? null : raw.sourceType.trim();
+        }
+    }
+    if (raw.sourceObject !== undefined) {
+        if (raw.sourceObject !== null && !isNonEmptyString(raw.sourceObject)) {
+            errors.push('sourceObject must be a non-empty string when provided');
+        }
+        else {
+            data.sourceObject = raw.sourceObject === null ? null : raw.sourceObject.trim();
+        }
+    }
+    if (raw.accessLevel !== undefined) {
+        if (raw.accessLevel !== null && !KNOWLEDGE_ACCESS_LEVELS.has(raw.accessLevel)) {
+            errors.push('accessLevel must be one of public, private, org_subtree');
+        }
+        else {
+            data.accessLevel = raw.accessLevel;
+        }
+    }
+    if (raw.orgNodeId !== undefined) {
+        if (raw.orgNodeId !== null && !isNonEmptyString(raw.orgNodeId)) {
+            errors.push('orgNodeId must be a non-empty string when provided');
+        }
+        else {
+            data.orgNodeId = raw.orgNodeId === null ? null : raw.orgNodeId.trim();
+        }
+    }
+    if (raw.metadata !== undefined) {
+        if (raw.metadata !== null && !isPlainObject(raw.metadata)) {
+            errors.push('metadata must be an object when provided');
+        }
+        else {
+            data.metadata = raw.metadata;
+        }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true, data };
+}
+// ---------------------------------------------------------------------
+// tool_permission — mirrors ToolPermissionLearningPublicationOwnerService.normalizeCandidatePermissionConfig()
+// ---------------------------------------------------------------------
+function normalizeToolNameArray(value, fieldName, errors) {
+    if (!Array.isArray(value)) {
+        errors.push(`${fieldName} must be an array`);
+        return [];
+    }
+    const normalized = [];
+    for (const item of value) {
+        if (typeof item !== 'string') {
+            errors.push(`${fieldName} must contain only tool name strings`);
+            continue;
+        }
+        const toolName = item.trim();
+        if (!exports.AI_WORKFORCE_STABLE_TOOL_NAME_PATTERN.test(toolName)) {
+            errors.push(`${fieldName} contains invalid tool name "${toolName}"`);
+            continue;
+        }
+        if (!normalized.includes(toolName)) {
+            normalized.push(toolName);
+        }
+    }
+    return normalized;
+}
+function normalizeOptionalPositiveInt(value, fieldName, errors) {
+    if (value === undefined || value === null)
+        return null;
+    if (!Number.isInteger(value) || value <= 0) {
+        errors.push(`${fieldName} must be a positive integer`);
+        return null;
+    }
+    return value;
+}
+function validateLearningToolPermissionCandidateConfig(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidatePermissionConfig must be an object'] };
+    }
+    const allowedTools = normalizeToolNameArray(raw.allowedTools, 'allowedTools', errors);
+    const blockedTools = normalizeToolNameArray(raw.blockedTools, 'blockedTools', errors);
+    const blockedSet = new Set(blockedTools);
+    for (const allowedTool of allowedTools) {
+        if (blockedSet.has(allowedTool)) {
+            errors.push(`tool "${allowedTool}" cannot appear in both allowedTools and blockedTools`);
+        }
+    }
+    const maxQueriesPerMinute = normalizeOptionalPositiveInt(raw.maxQueriesPerMinute, 'maxQueriesPerMinute', errors);
+    const maxWritesPerMinute = normalizeOptionalPositiveInt(raw.maxWritesPerMinute, 'maxWritesPerMinute', errors);
+    const maxBatchSize = normalizeOptionalPositiveInt(raw.maxBatchSize, 'maxBatchSize', errors);
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    return {
+        valid: true,
+        data: {
+            allowedTools,
+            blockedTools,
+            maxQueriesPerMinute,
+            maxWritesPerMinute,
+            maxBatchSize,
+        },
+    };
+}
+// ---------------------------------------------------------------------
+// approval_policy — mirrors ApprovalPolicyLearningPublicationOwnerService.normalizeCandidatePolicyPatch()
+// ---------------------------------------------------------------------
+function validateLearningApprovalPolicyCandidatePatch(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidatePolicyPatch must be an object'] };
+    }
+    const data = {};
+    if (raw.name !== undefined && raw.name !== null) {
+        if (!isNonEmptyString(raw.name)) {
+            errors.push('name must be a non-empty string');
+        }
+        else {
+            data.name = raw.name.trim();
+        }
+    }
+    if (raw.description !== undefined) {
+        if (raw.description !== null && typeof raw.description !== 'string') {
+            errors.push('description must be a string');
+        }
+        else {
+            data.description = raw.description;
+        }
+    }
+    if (raw.entryCondition !== undefined) {
+        if (raw.entryCondition !== null && typeof raw.entryCondition !== 'string') {
+            errors.push('entryCondition must be a string');
+        }
+        else {
+            data.entryCondition = raw.entryCondition;
+        }
+    }
+    if (raw.steps !== undefined && raw.steps !== null) {
+        if (!Array.isArray(raw.steps) || raw.steps.length === 0) {
+            errors.push('steps must be a non-empty array when provided');
+        }
+        else {
+            const normalizedSteps = [];
+            raw.steps.forEach((step, index) => {
+                if (!isPlainObject(step)) {
+                    errors.push(`steps[${index}] must be an object`);
+                    return;
+                }
+                if (!isNonEmptyString(step.id))
+                    errors.push(`steps[${index}].id is required`);
+                if (!isNonEmptyString(step.name))
+                    errors.push(`steps[${index}].name is required`);
+                if (!isNonEmptyString(step.approverType)) {
+                    errors.push(`steps[${index}].approverType is required`);
+                }
+                if (!isNonEmptyString(step.approverName)) {
+                    errors.push(`steps[${index}].approverName is required`);
+                }
+                normalizedSteps.push({
+                    ...step,
+                    id: String(step.id ?? '').trim(),
+                    name: String(step.name ?? '').trim(),
+                    approverType: String(step.approverType ?? '').trim(),
+                    approverName: String(step.approverName ?? '').trim(),
+                });
+            });
+            if (errors.length === 0) {
+                data.steps = normalizedSteps;
+            }
+        }
+    }
+    if (raw.riskAssessmentConfig !== undefined) {
+        if (raw.riskAssessmentConfig !== null && !isPlainObject(raw.riskAssessmentConfig)) {
+            errors.push('riskAssessmentConfig must be an object when provided');
+        }
+        else {
+            data.riskAssessmentConfig = raw.riskAssessmentConfig;
+        }
+    }
+    if (raw.finalApprovalAction !== undefined) {
+        if (raw.finalApprovalAction !== null && typeof raw.finalApprovalAction !== 'string') {
+            errors.push('finalApprovalAction must be a string');
+        }
+        else {
+            data.finalApprovalAction = raw.finalApprovalAction;
+        }
+    }
+    if (raw.finalRejectionAction !== undefined) {
+        if (raw.finalRejectionAction !== null && typeof raw.finalRejectionAction !== 'string') {
+            errors.push('finalRejectionAction must be a string');
+        }
+        else {
+            data.finalRejectionAction = raw.finalRejectionAction;
+        }
+    }
+    if (errors.length === 0 && Object.keys(data).length === 0) {
+        errors.push('candidatePolicyPatch must change at least one approval-policy field');
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true, data };
+}
+// ---------------------------------------------------------------------
+// employee_template — mirrors EmployeeTemplateLearningPublicationOwnerService.normalizeCandidateTemplate()
+//
+// NOTE: `templateKey` IS part of the wire contract (the owner service
+// requires it), but the *generator service* (Task 4) is responsible for
+// constructing it from `roleName` rather than accepting it from the LLM —
+// this validator still checks the regex because the adapter re-validates
+// the fully-constructed payload (LLM fields + constructed fields) before
+// dispatch, per requirements.md R4.3 ("adapter 在分发时用同一 validator 二
+// 次校验").
+// ---------------------------------------------------------------------
+function validateLearningEmployeeTemplateCandidatePatch(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidateTemplate must be an object'] };
+    }
+    if (!isNonEmptyString(raw.templateKey)) {
+        errors.push('templateKey is required');
+    }
+    else if (!exports.AI_WORKFORCE_TEMPLATE_KEY_PATTERN.test(raw.templateKey)) {
+        errors.push('templateKey must match /^[a-z][a-z0-9_-]{2,127}$/');
+    }
+    if (!isNonEmptyString(raw.title))
+        errors.push('title is required');
+    if (!isNonEmptyString(raw.roleName))
+        errors.push('roleName is required');
+    if (!isNonEmptyString(raw.mission))
+        errors.push('mission is required');
+    if (!isPlainObject(raw.blueprint))
+        errors.push('blueprint is required and must be an object');
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    return {
+        valid: true,
+        data: {
+            templateKey: raw.templateKey.trim(),
+            title: raw.title.trim(),
+            roleName: raw.roleName.trim(),
+            mission: raw.mission.trim(),
+            blueprint: raw.blueprint,
+        },
+    };
+}
+// ---------------------------------------------------------------------
+// sop — mirrors SopLearningPublicationOwnerService.normalizeCandidateDocumentPatch()
+// ---------------------------------------------------------------------
+function validateLearningSopDocumentCandidatePatch(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidateDocumentPatch must be an object'] };
+    }
+    const data = {};
+    if (raw.title !== undefined && raw.title !== null) {
+        if (!isNonEmptyString(raw.title)) {
+            errors.push('title must be a non-empty string');
+        }
+        else {
+            data.title = raw.title.trim();
+        }
+    }
+    if (raw.category !== undefined) {
+        if (raw.category !== null && typeof raw.category !== 'string') {
+            errors.push('category must be a string');
+        }
+        else {
+            data.category = raw.category;
+        }
+    }
+    if (raw.applicableObjects !== undefined) {
+        if (raw.applicableObjects === null) {
+            data.applicableObjects = [];
+        }
+        else if (!Array.isArray(raw.applicableObjects)) {
+            errors.push('applicableObjects must be an array');
+        }
+        else {
+            const normalized = [];
+            raw.applicableObjects.forEach((value, index) => {
+                if (!isNonEmptyString(value)) {
+                    errors.push(`applicableObjects[${index}] must be a non-empty string`);
+                }
+                else {
+                    normalized.push(value.trim());
+                }
+            });
+            if (errors.length === 0)
+                data.applicableObjects = normalized;
+        }
+    }
+    if (raw.steps !== undefined && raw.steps !== null) {
+        if (!Array.isArray(raw.steps)) {
+            errors.push('steps must be an array');
+        }
+        else if (raw.steps.some((step) => !isPlainObject(step))) {
+            errors.push('steps must contain only objects');
+        }
+        else {
+            data.steps = raw.steps;
+        }
+    }
+    if (errors.length === 0 && Object.keys(data).length === 0) {
+        errors.push('candidateDocumentPatch must change at least one SOP field');
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true, data };
+}
+// ---------------------------------------------------------------------
+// Phase 4 (R5) — reference-type draft content validators.
+//
+// These validate the LLM's FULL drafted definition BEFORE the generator
+// calls the target module's real creation path (`FlowService.createVersion`
+// + `saveVersion`; `PromptStrategyService.create`) — a structural pre-check
+// so an obviously-malformed LLM output never reaches those services at all.
+// `FlowService.saveVersion()`'s own `validateGraph()` remains the
+// authoritative graph-correctness check (START/END reachability, decision
+// branch coverage, etc.) — this validator only mirrors the minimal
+// structural shape `saveVersion()` requires before it will even attempt
+// that deeper validation (a definition missing `nodes`/`edges` arrays, or
+// containing a node without an `id`, would otherwise reach
+// `normalizeFlowVersionDefinition()` and produce confusing downstream
+// errors rather than an honest `validation_failed` here).
+// ---------------------------------------------------------------------
+// mirrors FlowService's own FLOW_NODE_TYPES set (flow.service.ts)
+const KNOWN_FLOW_NODE_TYPES = new Set([
+    'START',
+    'END',
+    'ACTION',
+    'APPROVAL',
+    'DECISION',
+    'LOOP',
+    'WAIT',
+    'SUBFLOW',
+    'SCREEN',
+    'AGENT',
+]);
+function validateLearningWorkflowDraftDefinition(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['workflow draft definition must be an object'] };
+    }
+    if (raw.version !== undefined && typeof raw.version !== 'string') {
+        errors.push('version must be a string when provided');
+    }
+    if (!Array.isArray(raw.nodes) || raw.nodes.length === 0) {
+        errors.push('nodes must be a non-empty array');
+    }
+    if (!Array.isArray(raw.edges)) {
+        errors.push('edges must be an array');
+    }
+    const nodes = [];
+    if (Array.isArray(raw.nodes)) {
+        const seenIds = new Set();
+        raw.nodes.forEach((node, index) => {
+            if (!isPlainObject(node)) {
+                errors.push(`nodes[${index}] must be an object`);
+                return;
+            }
+            if (!isNonEmptyString(node.id)) {
+                errors.push(`nodes[${index}].id is required`);
+                return;
+            }
+            if (seenIds.has(node.id)) {
+                errors.push(`nodes[${index}].id "${node.id}" is duplicated`);
+            }
+            seenIds.add(node.id);
+            if (!isNonEmptyString(node.type)) {
+                errors.push(`nodes[${index}].type is required`);
+            }
+            else if (!KNOWN_FLOW_NODE_TYPES.has(node.type.toUpperCase())) {
+                errors.push(`nodes[${index}].type "${node.type}" is not a known flow node type`);
+            }
+            if (!isNonEmptyString(node.name)) {
+                errors.push(`nodes[${index}].name is required`);
+            }
+            if (node.settings !== undefined && node.settings !== null && !isPlainObject(node.settings)) {
+                errors.push(`nodes[${index}].settings must be an object when provided`);
+            }
+            nodes.push({
+                id: String(node.id),
+                type: String(node.type ?? '').toUpperCase(),
+                name: String(node.name ?? ''),
+                position: isPlainObject(node.position)
+                    ? { x: Number(node.position.x) || 0, y: Number(node.position.y) || 0 }
+                    : null,
+                settings: isPlainObject(node.settings) ? node.settings : {},
+            });
+        });
+        if (nodes.length > 0) {
+            if (!nodes.some((node) => node.type === 'START')) {
+                errors.push('nodes must include exactly one START node');
+            }
+            if (!nodes.some((node) => node.type === 'END')) {
+                errors.push('nodes must include at least one END node');
+            }
+        }
+    }
+    const edges = [];
+    if (Array.isArray(raw.edges)) {
+        const nodeIds = new Set(nodes.map((node) => node.id));
+        raw.edges.forEach((edge, index) => {
+            if (!isPlainObject(edge)) {
+                errors.push(`edges[${index}] must be an object`);
+                return;
+            }
+            if (!isNonEmptyString(edge.id)) {
+                errors.push(`edges[${index}].id is required`);
+            }
+            if (!isNonEmptyString(edge.source)) {
+                errors.push(`edges[${index}].source is required`);
+            }
+            else if (nodeIds.size > 0 && !nodeIds.has(edge.source)) {
+                errors.push(`edges[${index}].source "${edge.source}" does not match any node id`);
+            }
+            if (!isNonEmptyString(edge.target)) {
+                errors.push(`edges[${index}].target is required`);
+            }
+            else if (nodeIds.size > 0 && !nodeIds.has(edge.target)) {
+                errors.push(`edges[${index}].target "${edge.target}" does not match any node id`);
+            }
+            edges.push({
+                id: String(edge.id ?? `edge-${index}`),
+                source: String(edge.source ?? ''),
+                target: String(edge.target ?? ''),
+                sourceHandle: isNonEmptyString(edge.sourceHandle) ? edge.sourceHandle : null,
+                targetHandle: isNonEmptyString(edge.targetHandle) ? edge.targetHandle : null,
+                label: isNonEmptyString(edge.label) ? edge.label : null,
+            });
+        });
+    }
+    if (raw.trigger !== undefined && raw.trigger !== null && !isPlainObject(raw.trigger)) {
+        errors.push('trigger must be an object when provided');
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    return {
+        valid: true,
+        data: {
+            version: typeof raw.version === 'string' ? raw.version : '1',
+            nodes,
+            edges,
+            trigger: isPlainObject(raw.trigger) ? raw.trigger : null,
+        },
+    };
+}
+// ---------------------------------------------------------------------
+// prompt_policy — mirrors CreatePromptStrategyInput
+// (`ai-service/prompt-strategy.service.ts`), minus `workspaceId` (always
+// supplied by the generator from the caller's context, never LLM output).
+// `PromptStrategyService.create()` itself only requires a non-empty,
+// trimmed `name` — this validator enforces nothing stricter than that.
+// ---------------------------------------------------------------------
+function validateLearningPromptPolicyDraftContent(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['prompt policy draft content must be an object'] };
+    }
+    if (!isNonEmptyString(raw.name)) {
+        errors.push('name is required and must be a non-empty string');
+    }
+    if (raw.description !== undefined && raw.description !== null && typeof raw.description !== 'string') {
+        errors.push('description must be a string when provided');
+    }
+    if (raw.industry !== undefined && raw.industry !== null && typeof raw.industry !== 'string') {
+        errors.push('industry must be a string when provided');
+    }
+    if (raw.templateOverrides !== undefined &&
+        raw.templateOverrides !== null &&
+        !isPlainObject(raw.templateOverrides)) {
+        errors.push('templateOverrides must be an object when provided');
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    return {
+        valid: true,
+        data: {
+            name: raw.name.trim(),
+            description: isNonEmptyString(raw.description) ? raw.description.trim() : null,
+            industry: isNonEmptyString(raw.industry) ? raw.industry.trim() : null,
+            templateOverrides: isPlainObject(raw.templateOverrides) ? raw.templateOverrides : null,
+        },
+    };
+}
+const MODEL_ROUTING_MODEL_POLICY_WHITELISTED_KEYS = new Set([
+    'defaultModelByCapability',
+    'defaultModelByScenario',
+]);
+function normalizeModelIdentifierMap(value, fieldName, errors) {
+    if (value === undefined)
+        return undefined;
+    if (value === null || !isPlainObject(value)) {
+        errors.push(`${fieldName} must be an object`);
+        return undefined;
+    }
+    const normalized = {};
+    let sawError = false;
+    for (const [key, entryValue] of Object.entries(value)) {
+        if (!isNonEmptyString(key)) {
+            errors.push(`${fieldName} keys must be non-empty strings`);
+            sawError = true;
+            continue;
+        }
+        if (!isNonEmptyString(entryValue)) {
+            errors.push(`${fieldName}.${key} must be a non-empty string`);
+            sawError = true;
+            continue;
+        }
+        normalized[key.trim()] = entryValue.trim();
+    }
+    return sawError ? undefined : normalized;
+}
+/**
+ * mirrors the v1 whitelist described in the block comment above — takes the
+ * LLM's raw (already `JSON.parse`d) candidate patch and either narrows it
+ * to exactly `{ modelPolicy: { defaultModelByCapability?, defaultModelByScenario? } }`
+ * or reports every whitelist violation / shape error found. Never throws
+ * (same discriminated-union contract as every other validator in this
+ * file).
+ */
+function validateLearningModelRoutingCandidatePatch(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidatePatch must be an object'] };
+    }
+    const unknownTopLevelKeys = Object.keys(raw).filter((key) => key !== 'modelPolicy');
+    if (unknownTopLevelKeys.length > 0) {
+        errors.push(`candidatePatch contains fields outside the v1 whitelist: ${unknownTopLevelKeys.join(', ')}. ` +
+            'Only modelPolicy.defaultModelByCapability/defaultModelByScenario may be set by learning.');
+    }
+    if (raw.modelPolicy === undefined || raw.modelPolicy === null) {
+        errors.push('modelPolicy is required');
+        return { valid: false, errors };
+    }
+    if (!isPlainObject(raw.modelPolicy)) {
+        errors.push('modelPolicy must be an object');
+        return { valid: false, errors };
+    }
+    const unknownModelPolicyKeys = Object.keys(raw.modelPolicy).filter((key) => !MODEL_ROUTING_MODEL_POLICY_WHITELISTED_KEYS.has(key));
+    if (unknownModelPolicyKeys.length > 0) {
+        errors.push(`modelPolicy contains fields outside the v1 whitelist: ${unknownModelPolicyKeys.join(', ')}. ` +
+            'Only defaultModelByCapability/defaultModelByScenario may be set by learning.');
+    }
+    const defaultModelByCapability = normalizeModelIdentifierMap(raw.modelPolicy.defaultModelByCapability, 'modelPolicy.defaultModelByCapability', errors);
+    const defaultModelByScenario = normalizeModelIdentifierMap(raw.modelPolicy.defaultModelByScenario, 'modelPolicy.defaultModelByScenario', errors);
+    if (errors.length === 0 &&
+        (defaultModelByCapability === undefined || Object.keys(defaultModelByCapability).length === 0) &&
+        (defaultModelByScenario === undefined || Object.keys(defaultModelByScenario).length === 0)) {
+        errors.push('modelPolicy must set at least one of defaultModelByCapability or defaultModelByScenario');
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    const modelPolicy = {};
+    if (defaultModelByCapability !== undefined && Object.keys(defaultModelByCapability).length > 0) {
+        modelPolicy.defaultModelByCapability = defaultModelByCapability;
+    }
+    if (defaultModelByScenario !== undefined && Object.keys(defaultModelByScenario).length > 0) {
+        modelPolicy.defaultModelByScenario = defaultModelByScenario;
+    }
+    return { valid: true, data: { modelPolicy } };
+}
+/**
+ * Body-only whitelist validator — narrows the LLM's raw (already
+ * `JSON.parse`d) output to exactly `{ template: string }` or reports every
+ * whitelist violation / shape error found. Never throws (same
+ * discriminated-union contract as every other validator in this file).
+ * The body is intentionally NOT trimmed — leading/trailing whitespace can
+ * be meaningful in a prompt template; only the "effectively empty" check
+ * uses a trimmed view.
+ */
+function validateLearningPromptTemplateCandidatePatch(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidatePatch must be an object'] };
+    }
+    const unknownKeys = Object.keys(raw).filter((key) => key !== 'template');
+    if (unknownKeys.length > 0) {
+        errors.push(`candidatePatch contains fields outside the v1 whitelist: ${unknownKeys.join(', ')}. ` +
+            'Only the template body may be set by learning (Q8 signed: body-level edits only).');
+    }
+    if (typeof raw.template !== 'string' || raw.template.trim().length === 0) {
+        errors.push('template is required and must be a non-empty string');
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    return { valid: true, data: { template: raw.template } };
+}
+const AGENT_CANDIDATE_PATCH_WHITELISTED_KEYS = new Set([
+    'persona',
+    'systemInstructions',
+    'identityPolicy',
+]);
+/**
+ * Three-field whitelist validator — narrows the LLM's raw (already
+ * `JSON.parse`d) output to a subset of `{ persona?, systemInstructions?,
+ * identityPolicy? }` (each, when present, a non-empty string) or reports
+ * every whitelist violation / shape error found. Never throws (same
+ * discriminated-union contract as every other validator in this file).
+ * Bodies are intentionally NOT trimmed for the same reason
+ * `validateLearningPromptTemplateCandidatePatch` does not trim `template` —
+ * leading/trailing whitespace can be meaningful in prompt-adjacent text;
+ * only the "effectively empty" check uses a trimmed view.
+ */
+function validateLearningAgentCandidatePatch(raw) {
+    const errors = [];
+    if (!isPlainObject(raw)) {
+        return { valid: false, errors: ['candidatePatch must be an object'] };
+    }
+    const unknownKeys = Object.keys(raw).filter((key) => !AGENT_CANDIDATE_PATCH_WHITELISTED_KEYS.has(key));
+    if (unknownKeys.length > 0) {
+        errors.push(`candidatePatch contains fields outside the v1 whitelist: ${unknownKeys.join(', ')}. ` +
+            'Only persona/systemInstructions/identityPolicy may be set by learning (Q10 signed: three free-text fields only).');
+    }
+    const data = {};
+    for (const key of ['persona', 'systemInstructions', 'identityPolicy']) {
+        const value = raw[key];
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'string' || value.trim().length === 0) {
+            errors.push(`${key} must be a non-empty string when provided`);
+            continue;
+        }
+        data[key] = value;
+    }
+    if (errors.length === 0 && Object.keys(data).length === 0) {
+        errors.push('candidatePatch must set at least one of persona, systemInstructions, identityPolicy');
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    return { valid: true, data };
+}
+//# sourceMappingURL=index.js.map