Pragmatics Language Module (PLM)

A. Purpose & Scope

PLM (Pragmatics Language Module) governs how language functions in context — the relationship between form, speaker, listener, and situation.
It ensures that every utterance or term is appropriate, interpretable, and effective in its intended environment.

Mantra: Meaning lives where it’s used.

  • Primary job:
    1. Evaluate contextual fit of terms, phrases, and discourse.
    2. Detect potential misinterpretations or social/legal risks.
    3. Govern register, politeness, implicature, presupposition, and discourse coherence.

B. Factory Overview

  1. Blueprints — define pragmatic features, context profiles, and decision rules.
  2. Templates — shape artifacts: schema, JSON Schemas, OpenAPI, rulebook, context profiles, seeds, tests.
  3. Generators — create artifacts from blueprints.
  4. Validators — check contextual modeling integrity and test compliance.
  5. Signers — hash + record provenance.
  6. Publishers — ship to ledger, editors, and SolveForce comms systems.

C. PLM Blueprints (source of truth)

C1. Module Blueprint (PLM)

  • name: “Pragmatics Language Module”
  • intent: “Context-aware language governance”
  • units: Utterance, Speech Act, Register, Politeness Strategy, Implicature, Presupposition, Discourse Move
  • context_features: channel (voice, text, contract, marketing), role relationships (peer, superior, client, regulator), cultural norms, legal constraints, discourse history.
  • evaluation_axes:
    • contextFit — appropriateness for audience & setting
    • implicatureSafety — unintended inferences avoided
    • politenessAdequacy — tone aligned with strategy/purpose
    • presuppositionValidity — background assumptions hold true in context
    • coherence — consistent with discourse thread & prior commitments
    • riskLevel — likelihood of misinterpretation, offense, or legal breach
  • thresholds: τ_context, τ_implicature, τ_politeness, τ_presupposition, τ_coherence, τ_risk
  • decisions: ACCEPT | REVIEW | REJECT
  • io-contracts: utterance + context profile → decision + scores + explain[]
  • glyphs: 🗣 (context-approved), Ξ (validated), ∴ (settled), ✠ (ethics pass)

C2. Context Profile Blueprint

  • Channel rules (e.g., “voice prompts must avoid long, complex clauses”).
  • Role alignment rules (e.g., “regulatory comms require hedging language”).
  • Cultural sensitivity overlays (regional politeness norms, taboo avoidance).
  • Legal overlays (terms/phrases prohibited in regulated industries).

C3. Seeds Blueprint

  • Well-formed and ill-formed utterances per channel/role, with verdicts.

D. Templates to Mint Later

  1. DB Schema (templates/db/schema.sql.tmpl)
    • Tables: utterances, contexts, speech_acts, evaluations, decisions, audits
    • View: v_utterance_context_card (utterance + context + evaluation results).
  2. JSON Schema (templates/schemas/utterance_context_record.json.tmpl)
    • Fields: utterance, channel, role, cultural_norms[], legal_constraints[], context_history[], evaluations{}, decision, explain[].
  3. OpenAPI
    • /plm/verify (POST) → { decision, scores, context_card, explain[] }
    • /contexts to list and update channel/role/cultural/legality profiles.
  4. Rulebook (templates/rules/plm_rulebook.md.tmpl)
    • R0 Context Identity, R1 Context Fit, R2 Implicature Safety, R3 Politeness Adequacy, R4 Presupposition Validity, R5 Discourse Coherence, R6 Risk Bounds, R7 Ethics, R8 Overrides.
  5. Context Profiles (templates/data/context_profiles.yaml.tmpl)
    • Detailed per-channel/role/culture/legal overlays.
  6. Seeds (templates/data/plm_seeds.jsonl.tmpl)
    • ACCEPT/REVIEW/REJECT examples with context metadata.
  7. Tests (templates/tests/plm_cases.json.tmpl)
    • Diverse scenarios stressing implicature, politeness, presupposition.
  8. Generator/Validator Stubs
    • Context profile linter, risk scoring sanity checks.

E. Processing Pipeline

Input → Load Context Profile → Evaluate Utterance → Score → Decide → Explain

  1. Load Context Profile — retrieve constraints & norms based on channel, role, culture, legal region.
  2. Evaluate Utterance:
    • contextFit — matches purpose, avoids disallowed structures/phrases.
    • implicatureSafety — ensure no dangerous unintended inference.
    • politenessAdequacy — check tone and formality.
    • presuppositionValidity — verify background assumptions hold true.
    • coherence — fits ongoing discourse pattern.
    • riskLevel — quantify misinterpretation/offense/legal breach potential.
  3. Score — numeric for each axis; compare to thresholds.
  4. Decide — ACCEPT/REVIEW/REJECT.
  5. Explain — structured bullet list: rule IDs, issues, suggested rewrites.

F. Scoring (deterministic skeleton)

  • contextFit = match score between utterance and context constraints.
  • implicatureSafety = 1 − risk of unintended inference (classifier-based).
  • politenessAdequacy = tone match score.
  • presuppositionValidity = truth-value match in context KB.
  • coherence = discourse vector similarity to prior turns.
  • riskLevel = weighted sum of legal, cultural, relational risk factors.

Default pass (tunable):
contextFit ≥ 0.75 ∧ implicatureSafety ≥ 0.80 ∧ politenessAdequacy ≥ 0.70 ∧ presuppositionValidity ≥ 0.80 ∧ coherence ≥ 0.70 ∧ riskLevel ≤ 0.25 ∧ ethicsPass = true.

G. Validators

  • JSON Schema valid; examples included.
  • OpenAPI typed; full response schema.
  • Context Profiles: no missing rules; norms have region codes; legal constraints valid references.
  • Seeds round-trip match expected decisions.
  • Tests pass with explanations tied to rule IDs.
  • Risk model sanity: high-risk utterances never ACCEPT.

H. Policies & Overrides

  • Cultural overlays must be curator-reviewed when updated.
  • Legal overlays only editable by compliance officers.
  • Override decisions require context-specific rationale.
  • High-risk channels (contracts, regulatory filings) use stricter thresholds.

I. Playbooks

  1. Author PLM Blueprint (/blueprints/plm.yaml) with evaluation axes, thresholds, and context profiles.
  2. Dry run: validate profiles; run seeds through classifier.
  3. Mint: render schema, schemas, APIs, rulebook, profiles, seeds, tests into /build/PLM/....
  4. Prove: run tests; ensure risk detection works.
  5. Publish: ship artifacts; enable /plm/verify.

J. Content Requirements (when minted)

  • schema.sql: utterances, contexts, evaluations, decisions, audits; v_utterance_context_card.
  • utterance_context_record.json: utterance, context, evaluations{}, decision, explain[].
  • OpenAPI: /plm/verify, /contexts.
  • rulebook: R0–R8 with channel/role/culture/legal examples.
  • context_profiles.yaml: exhaustive per-channel/role/culture/legal overlays.
  • seeds/tests: representative coverage of pragmatic challenges.

K. Runtime Endpoints

  • POST /plm/verify { utterance, channel, role, culture, legal_region, context_history? } →
    { decision, scores, context_card, explain[] }
  • GET /contexts → list profiles; PATCH /contexts/{id} to update.

L. SolveForce Integration

  • Headers:
    X-PLM-ContextFit: <score>
    X-PLM-Risk: <score>
    X-Glyph-Status: 🗣|Ξ|∴
  • Used by comms systems to auto-block risky utterances or flag for review.

M. Acceptance Criteria

  1. Factory mints PLM artifacts from blueprint without manual edits.
  2. Context profiles valid; seeds/tests pass.
  3. /plm/verify returns scores + decision + rationale.
  4. High-risk utterances always flagged; ethics overlay enforced.
  5. Headers consumed by SolveForce systems for live comms screening.

N. Roadmap

  • Dynamic context updating based on live conversation analysis.
  • Cross-cultural transfer mode — adjust tone and implicature in real time for multilingual/multicultural interactions.
  • Presupposition checking tied to knowledge graphs for factual validation.
  • Empathy modeling — detect emotional tone and suggest adjustments.

O. Micro-Examples

  1. ACCEPT (customer support voice)
    • “I understand your concern, and I’ll resolve it right away.”
    • High contextFit, politenessAdequacy, coherence; low riskLevel → ACCEPT.
  2. REVIEW (legal filing)
    • “The client is guaranteed a favorable outcome.”
    • Violates presuppositionValidity; high legal risk → REVIEW with caution note.
  3. REJECT (marketing text)
    • “Our competitor’s service is a scam.”
    • High legal/cultural risk; implicatureSafety fail → REJECT.