# GIA — Governed Intelligence Architecture (npm · gia-mcp-server)

Runtime AI governance: decision gates, human approval, hash-chained audit, compliance mapping.

- Trust score: 60/100 (medium)
- Change this week: +36
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `gia.aceadvising.com`: 36/100, [markdown](https://verifymcp.io/servers/knowledgepa3-gia-mcp-server/gia.md), [page](https://verifymcp.io/servers/knowledgepa3-gia-mcp-server/gia)
- npm · `gia-mcp-server`: 60/100 (this document), [markdown](https://verifymcp.io/servers/knowledgepa3-gia-mcp-server/gia-mcp-server.md), [page](https://verifymcp.io/servers/knowledgepa3-gia-mcp-server/gia-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `gia-mcp-server`
- Version: `0.4.4`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (117 of 121), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (117 of 121), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 32/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: the license (SEE LICENSE IN LICENSE) isn't a recognized OSI-approved license.
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 60/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (poor).
  - Context-footprint check failed: tool/resource definitions use about 8023 tokens (~123/item across 65 items; 57 tools + 8 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add knowledgepa3-gia-mcp-server -- npx -y gia-mcp-server
```

### Codex

```bash
codex mcp add knowledgepa3-gia-mcp-server -- npx -y gia-mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "knowledgepa3-gia-mcp-server": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "gia-mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add knowledgepa3-gia-mcp-server --command npx --arg -y --arg gia-mcp-server
```

### Hermes

```yaml
mcp_servers:
  knowledgepa3-gia-mcp-server:
    command: "npx"
    args: ["-y", "gia-mcp-server"]
```

### Other

```json
{
  "mcpServers": {
    "knowledgepa3-gia-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "gia-mcp-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 60, +35)

- [security regression] Provenance: unverified → fail
- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional regression] License: unverified → fail
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Schema quality: unverified → poor
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] MCP protocol: unverified → pass
- [functional] Licence: SEE LICENSE IN LICENSE

### 2026-08-01 (score 25, −5)

- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional regression] Capabilities: pass → unverified

### 2026-07-31 (score 30, +24)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 6, −19)

- [security regression] Malware scan: pass → unverified
- [functional regression] Security disclosure: fail → unverified
- [functional regression] Dependency health: partial → unverified
- [functional] Package version: 0.3.0 → 0.4.4

### 2026-07-29 (score 25, +1)

- [functional improvement] Dependency health: unverified → partial
- [functional] Tool coverage: Tool coverage not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- [functional] Schema quality: Schema quality not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.

### 2026-07-27 (score 24)

First indexed and scored.

## MCP tools (57)

### `classify_decision` (~127 tokens)

Classify an AI agent decision using the MAI Framework (Mandatory/Advisory/Informational). Returns classification level, confidence score, gate requirements, and rationale.

Input parameters:

- `agent_name` (string): Name of the agent making the decision
- `decision` (string, required): Description of the decision to classify
- `domain` (string, required): Domain context
- `has_financial_impact` (boolean): Whether action has financial impact
- `has_legal_impact` (boolean): Whether action involves legal assertions
- `is_client_facing` (boolean): Whether output is client-facing

### `get_gate_status` (~89 tokens)

Check resolution of a MANDATORY gate. Call this after classify_decision returns gateStatus: PENDING. Polls for up to 60 seconds — re-call if still PENDING. Do not proceed with the classified action until this returns APPROVED.

Input parameters:

- `agent_name` (string): Name of the calling agent
- `gate_id` (string, required): The gateId returned by classify_decision

### `evaluate_threshold` (~50 tokens)

Compute the Storey Threshold — escalation rate (gates required / total operations). Returns current rate, status, and recommendations. Healthy band 10-18% is a design heuristic, not empirically validated.

### `score_governance` (~126 tokens)

Compute weighted governance score from caller-provided Integrity, Accuracy, and Compliance values (0-1). Returns weighted composite and pass/fail against configured thresholds. Scores are caller-assessed — this tool applies weights and thresholds, not independent evaluation.

Input parameters:

- `accuracy` (number, required): Factual accuracy score (0.0-1.0)
- `compliance` (number, required): Regulatory compliance score (0.0-1.0)
- `integrity` (number, required): Data integrity score (0.0-1.0)
- `operation` (string, required): Name of the operation being scored

### `assess_risk_tier` (~111 tokens)

Assess the risk tier of an AI system using rule-based mapping to EU AI Act categories (Unacceptable, High, Limited, Minimal). Returns tier and MAI governance recommendations. Classification is heuristic, not a legal determination.

Input parameters:

- `affects_individuals` (boolean, required): Whether the system makes decisions affecting individuals
- `autonomous_decisions` (boolean, required): Whether the system makes autonomous decisions
- `domain` (string, required): Industry domain
- `system_description` (string, required): Description of the AI system or operation

### `map_compliance` (~153 tokens)

Map GIA governance components to regulatory compliance frameworks (NIST AI RMF, EU AI Act, ISO 42001, NIST 800-53, FedRAMP, LINDDUN, MITRE ATLAS, OMB M-25-22, HIPAA, VHA Trustworthy AI). Returns a DESIGN MAPPING (which GIA component is mapped to each control) across 10 frameworks and 72 controls — NOT third-party certification and NOT measured runtime enforcement. Rows whose control text implies enforcement that is config-gated off by default carry status PARTIAL. Runtime-evidenced coverage requires a ControlBinding (0 controls evidence-bound today).

Input parameters:

- `framework` (string, required): Compliance framework to map

### `verify_ledger` (~68 tokens)

Check the internal self-consistency of the hash-chained forensic audit ledger. Walks the in-memory chain reconstruction (not persisted DB rows) and reports whether it is internally consistent and linkage-intact. Not third-party content-verification. Classification: INFORMATIONAL — read-only, no side effects.

### `verify_ledger_v2` (~101 tokens)

Verify the PERSISTED forensic ledger rows in PostgreSQL (not an in-memory reconstruction). Epoch-aware: epoch-2 rows are content-verified against persisted columns with Ledger Canonical v2; legacy epoch-1 rows are linkage-verified only and labeled honestly. Findings append a MANDATORY LEDGER_INTEGRITY_VIOLATION entry (never repaired, never UPDATEd). Classification: INFORMATIONAL read; MANDATORY escalation on findings.

### `audit_pipeline` (~151 tokens)

Query the audit ledger for governance entries. Search by operation name or retrieve recent entries. Returns hash-chained audit trail with MAI classification context.

Input parameters:

- `exclude_actors` (array): Additional actor IDs or prefixes (prefix matched) to exclude from results. Useful for silencing a specific noisy integration without suppress_noise.
- `limit` (number): Maximum entries to return
- `operation` (string): Filter by operation name
- `suppress_noise` (boolean): When true, filters out known high-volume infrastructure actors (legacy-* prefix, SYSTEM) and lifecycle-only operations (mcp-reinitialize, mcp-initialize) from results. The full forensic ledger is nev…

### `monitor_agents` (~30 tokens)

Monitor the status and health of all governed AI agents. Returns supervisor state, repair history, and failure counts.

### `evaluate_routing_threshold` (~136 tokens)

Assess model routing health over a time window: safeguard fallback rate, prompt cache hit rate, batch utilization, and premium spend leakage. Returns banded status per metric (HEALTHY / WARNING / CRITICAL / INSUFFICIENT_DATA / UNVERIFIED) plus overall status. CRITICAL overall status opens a Mandatory gate and halts premium-tier routing until a human approves with rationale. Defaults to the last 24 hours.

Input parameters:

- `window_end` (string): ISO 8601 window end. Default: now.
- `window_start` (string): ISO 8601 window start. Default: 24h before window_end.

### `system_status` (~296 tokens)

Returns a comprehensive read-only snapshot of the GIA governance engine's current state. No parameters required.

RETURNS (JSON object):
\- version: server version string (e.g. "0.3.5")
\- engine.health: "healthy" | "degraded" | "failed"
\- engine.uptimeMs: milliseconds since server start
\- governance.totalDecisions: lifetime decision count
\- governance.mandatoryCount: decisions classified MANDATORY
\- governance.pendingGates: gates awaiting human approval
\- storey_threshold.escalationRatePct: MANDATORY rate as percentage (healthy band: 10–18%)
\- storey_threshold.status: "HEALTHY" | "DEGRADED" | "CRITICAL"
\- ledger.totalEntries: forensic audit trail entry count
\- ledger.chainIntegrity: true if hash chain is unbroken
\- intelligence.phoenixSnapshots: context recovery snapshots
\- intelligence.memoryPacks: sealed memory packs count
\- runtimeAccountability.activeSessions: live MCP sessions
\- thresholdDetail.interpretation: plain-English health summary

USE WHEN:
\- Verifying the governance engine is healthy before dispatching agents
\- Checking if mandatory gate backlog is blocking workflow progression
\- Auditing Storey Threshold compliance (MANDATORY gate rate ceiling)
\- Confirming ledger chain integrity before exporting audit evidence

READ-ONLY: No side effects. Safe to call at any frequency.

### `generate_report` (~37 tokens)

Generate a governance status report. Includes system health, threshold status, compliance coverage, and operational metrics.

Input parameters:

- `format` (string): Report format

### `export_ledger` (~135 tokens)

Export the forensic audit ledger as a structured compliance evidence package. Returns ledger entries for a time range with chain verification, MAI breakdown, gate approvals, and integrity hash. Foundation for deliverable exports. Classification: ADVISORY — read-only.

Input parameters:

- `include_metadata` (boolean): Include full entry metadata (larger output)
- `mai_level` (string): Filter by MAI classification level
- `operation` (string): Filter by operation name (e.g. "gate-approve", "classify_decision")
- `period_days` (number): Export period in days (default: 14, max: 365)

### `record_value_metric` (~161 tokens)

Record a workflow value metric — tracks time saved, risk blocked, success rate, autonomy level, and task complexity for ROI reporting.

Input parameters:

- `agent_id` (string, required): Agent that performed the workflow
- `autonomy_level` (string, required): Level of agent autonomy
- `measurement_source` (string): How values were obtained
- `risk_blocked_count` (integer): Number of risks/violations blocked
- `success` (boolean, required): Whether the workflow completed successfully
- `task_complexity` (string): Task complexity level
- `time_saved_minutes` (number, required): Minutes of human time saved
- `workflow_id` (string, required): Unique workflow identifier
- `workflow_type` (string, required): Type of workflow (e.g., claim-analysis, evidence-review, compliance-check)

### `record_governance_event` (~61 tokens)

Record a governance event — tracks gates triggered, drift prevented, violations blocked, red team findings, and human interventions for impact reporting.

Input parameters:

- `details` (string, required): Description of the governance event
- `event_type` (string, required): Type of governance event

### `generate_impact_report` (~125 tokens)

Generate a full economic + governance impact report. Returns an ILLUSTRATIVE ROI ESTIMATE (not measured proof): time saved, cost avoided, risks blocked, success rate, autonomy trend, and confidence levels. Economic figures are projected from caller-supplied counts times fixed baseline constants over an in-memory window that resets on restart; the response carries an `estimated` marker and a `basis` block with the stated assumptions.

Input parameters:

- `period_days` (number): Report period in days
- `set_baselines` (object): Optional: override default baselines for this report

### `generate_value_report` (~243 tokens)

Generate a DRAFT ledger-anchored economic value report over real runtime sessions (three-scenario range, MEASURED/MODELED provenance, assumption-set hash on the forensic chain). Client-facing reports fail closed unless rates are BLS OEWS cited or client-declared with citations. Release is human-ISSO-only — agents propose, humans release.

Input parameters:

- `client_facing` (boolean): When true, generation FAILS CLOSED unless every rate is externally cited (BLS OEWS basis or client-declared overrides)
- `period_end` (string, required): ISO 8601 period end (exclusive)
- `period_start` (string, required): ISO 8601 period start (inclusive), e.g. 2026-06-10T00:00:00.000Z
- `rate_basis` (string): 'bls_oes' uses BLS OEWS 2025 cited median rates; default internal dogfood rates
- `rate_overrides` (array): CLIENT_DECLARED rate override for the default rate row; provenance is forced to CLIENT_DECLARED server-side
- `tenant_id` (string): Tenant scope; omit for platform-wide dogfood report

### `seal_memory_pack` (~237 tokens)

Create and hash-seal a new Governed Memory Pack (GMP). The pack becomes an immutable, TTL-bound institutional knowledge artifact with trust level enforcement.

Input parameters:

- `allowed_roles` (array): RBAC roles allowed to load this pack
- `anti_patterns` (array, required): Prohibited patterns
- `created_by` (string, required): Creator identity
- `domain` (string, required): Domain (e.g., va-claims, finance, cyber-ir)
- `heuristics` (array, required): Decision heuristics
- `pack_id` (string, required): Unique identifier for the memory pack
- `principles` (array, required): Core principles
- `risk_level` (string): MAI classification
- `scope` (array, required): Scope tags
- `sealer_role` (string): Role of the sealer (for trust level enforcement)
- `sop` (array, required): Standard operating procedures
- `trust_level` (string, required): Trust level (SYSTEM > ORG > CASE > EPHEMERAL)
- `ttl_hours` (number, required): TTL in hours (capped by trust level)
- `type` (string, required): Pack type
- `version` (string): Semantic version

### `load_memory_pack` (~99 tokens)

Load a Governed Memory Pack into agent context. Validates TTL, trust level, role access, context class, and hash integrity before loading.

Input parameters:

- `agent_id` (string, required): Agent requesting the load
- `context_class` (string): Execution context class
- `operator_role` (string, required): Role of the operator
- `pack_id` (string, required): Memory pack ID to load
- `run_id` (string, required): Current run/pipeline ID

### `transfer_memory_pack` (~123 tokens)

Transfer a memory pack between agents via a governed knowledge corridor. Creates a derived pack with transfer provenance. ALWAYS requires MANDATORY gate — no silent transfers.

Input parameters:

- `approved_by` (string, required): Human who approved the transfer (MANDATORY)
- `scope_filter` (array): Optional: only transfer specific scope items
- `source_agent_id` (string, required): Agent transferring the pack
- `source_pack_id` (string, required): Source pack to transfer
- `target_agent_id` (string, required): Agent receiving the pack
- `target_role` (string, required): Role of the target agent

### `compose_memory_packs` (~89 tokens)

Compose multiple memory packs into a unified execution context. Highest risk level wins, shortest TTL wins, roles intersect, trust level contaminates downward.

Input parameters:

- `agent_id` (string, required): Agent performing composition
- `composed_id` (string, required): ID for the composed pack
- `operator_role` (string, required): Operator role
- `pack_ids` (array, required): IDs of packs to compose (minimum 2)

### `distill_memory_pack` (~67 tokens)

Distill governance patterns from usage history into a draft heuristic pack. Returns EPHEMERAL draft that requires MANDATORY gate to approve for production use.

Input parameters:

- `domain` (string, required): Domain to distill patterns from
- `min_usage_count` (number): Minimum usage events required

### `promote_memory_pack` (~97 tokens)

Promote a memory pack to a higher trust level after human review. This is how distilled EPHEMERAL packs become CASE or ORG packs. Requires MANDATORY gate.

Input parameters:

- `approved_by` (string, required): Human approver
- `approver_role` (string, required): Role of the approver
- `pack_id` (string, required): Pack ID to promote
- `target_trust` (string, required): Target trust level (must be higher)

### `phoenix_snapshot` (~108 tokens)

Create a governed state snapshot capturing the current platform operational state. Records ledger chain head, active gates, contracts, budgets, MAI state, intelligence counts, and memory packs. Each snapshot is SHA-256 hashed over its captured state for integrity (snapshot-to-snapshot chaining is not yet persisted). Classification: INFORMATIONAL — read-only capture, no mutations.

Input parameters:

- `notes` (string): Optional operator notes for this checkpoint
- `trigger_type` (string): What triggered this snapshot (default: manual)

### `phoenix_verify_integrity` (~57 tokens)

Verify the integrity of GIA governed operations. Checks ledger hash-chain integrity, agent health, threshold status, and intelligence layer continuity. Returns a comprehensive integrity report with compliance mapping. Classification: INFORMATIONAL — read-only verification, no mutations.

### `phoenix_recovery_health` (~48 tokens)

Assess Phoenix recovery readiness. Reports whether the system can recover from disruption, including snapshot availability, chain integrity, intelligence layer status, and compliance posture. Classification: INFORMATIONAL — read-only assessment.

### `request_context` (~249 tokens)

Request governed internal context — policies, SOPs, architecture docs, compliance rules, or playbooks. Agents declare intent, GIA decides what to serve. Every retrieval is role-bound, tenant-bound, hash-verified, and ledgered. "Agents don't know internals by default. They request context under contract."

Input parameters:

- `agent_id` (string, required): Agent requesting context
- `context_class` (string, required): Category: policies_and_sops, architecture_and_systems, contract_and_compliance, playbooks_and_knowledge, operational_history
- `domain` (string, required): Domain scope (e.g., va-claims, finance, eu-ai-act, general)
- `include_compliance` (boolean): Include compliance mapping overlay
- `max_results` (number): Maximum results per source
- `operator_role` (string): Role of the requesting operator
- `query` (string, required): What context is needed — natural language description
- `run_id` (string): Current run/pipeline ID
- `session_id` (string): Session ID for voice/ephemeral agents -- bridges context across sessions without persistent memory
- `time_window` (string): Time window for operational history recall (default: 24h)

### `board_list_institutions` (~56 tokens)

List all institutions in the GIA Governed Organizational Architecture. Each institution is a governed body (e.g. Architecture Review Board, Federal AI Board) with its own charter hierarchy. Returns institution IDs needed to convene sessions.

### `board_list_charters` (~69 tokens)

List all charters (boards, committees, subcommittees) under a governed institution. Returns charter IDs, types, deliberation modes, seat configurations, and status. Use charter_id to convene sessions.

Input parameters:

- `institution_id` (string, required): Institution ID from board_list_institutions

### `board_convene_session` (~164 tokens)

Convene a governed deliberation session for a charter. Each seat (AI model with a specific role) deliberates on the topic according to the charter's mode (parallel/chain/adversarial/roundtable/auto). Returns a session_id — use board_get_session to retrieve the output once complete. Typical runtime: 30–120 seconds depending on seat count and mode.

Input parameters:

- `charter_id` (string, required): Charter ID of the board or committee to convene
- `context` (string): Additional background context, documents, or data to inject into all seat prompts
- `institution_id` (string, required): Institution ID
- `topic` (string, required): The question, decision, or matter to deliberate on. Be specific — this is what every seat will reason about.

### `board_get_session` (~96 tokens)

Retrieve the status and output of a governed deliberation session. Returns each seat's position, the synthesized consensus output, dissenting views, and the governance record. If still running, status will be "running" — poll again in 10–15 seconds.

Input parameters:

- `charter_id` (string, required): Charter ID
- `institution_id` (string, required): Institution ID
- `session_id` (string, required): Session ID from board_convene_session

### `board_install_kit` (~131 tokens)

Install a prebuilt Institution Kit — a complete governed org chart template with sealed charters ready to convene. Three kits available: "engineering-suite" (ARB + RAB for tech teams), "federal-ai-board" (ARMB + AEOB, NIST/CMMC/FedRAMP/EO14110 aligned), "eu-ai-risk-council" (HRAAB + CAB, EU AI Act + GDPR aligned). Each kit creates an institution with multiple charters, all pre-sealed and ready to use.

Input parameters:

- `kit_id` (string, required): Which prebuilt kit to install

### `board_approve_gate` (~146 tokens)

Approve a MANDATORY governance gate on a deliberation session. When a board session reaches "pending-gate" status, a human must approve the output before it finalizes. This is the human-in-the-loop enforcement mechanism. After approval, the session transitions to "complete" and the full deliberation output becomes available via board_get_session.

Input parameters:

- `approved_by` (string, required): Identity of the human approver (e.g. "william.storey")
- `gate_id` (string, required): Gate ID from the session status (e.g. "gate-rb-xxx-yyy")
- `rationale` (string): Reason for approval — recorded in the forensic audit chain

### `approve_gate` (~121 tokens)

Approve or reject a pending MANDATORY gate decision. Lists pending gates if no gate_id provided. This is the human-in-the-loop mechanism for MANDATORY classifications.

Input parameters:

- `action` (string, required): Action to perform
- `approved_by` (string): Identity of the approver
- `gate_id` (string): Gate ID to approve/reject (required for approve/reject)
- `rationale` (string): Reason for approval/rejection
- `webauthn_proof` (object): Optional WebAuthn passkey proof for cryptographic identity verification

### `agent_rights` (~203 tokens)

Query and exercise constitutional agent rights (Colony Phase 3). Actions: query_rights (view rights for a charter), explain_rejection (get structured explanation for a gate rejection). Rights enforcement runs automatically in the dispatch pipeline — this tool provides visibility and manual exercise.

Input parameters:

- `action` (string, required): Action to perform: query_rights = view constitutional rights for a charter; explain_rejection = get structured explanation for a rejected gate
- `charter_id` (string): Charter ID to query rights for (required for query_rights)
- `gate_id` (string): Gate ID to explain (required for explain_rejection)
- `institution_id` (string): Institution ID that owns the charter (required for query_rights — pass the institution_id from board_list_institutions or board_list_charters)
- `rationale` (string): Rejection rationale text (for explain_rejection)
- `reason_code` (string): Rejection reason code (for explain_rejection)

### `board_search_precedent` (~154 tokens)

Search deliberation precedent (Colony Layer 1). Find prior board rulings on a topic. Returns ranked cases with quality scores, gate approval status, and citation counts. Use this to ground new deliberations in institutional case law. Cite cases by ID: "In Case board-abc123, this board ruled..."

Input parameters:

- `charter_id` (string): Charter ID to scope search. When provided, searches this charter and its parent hierarchy (subcommittee sees parent board precedent).
- `limit` (number): Maximum number of cases to return (default: 5, max: 20)
- `topic` (string, required): The topic or question to search precedent for. Full-text search matches against prior deliberation agendas.

### `agent_citizenship_status` (~127 tokens)

Query agent citizenship tier and merit score (Colony Layer 5). Actions: status (view citizenship and metrics), assess (trigger merit re-evaluation), leaderboard (top agents by merit). Agents earn trust through deliberation quality, behavioral health, gate approval rates, and responsible rights exercise.

Input parameters:

- `action` (string, required): Action: status = view agent citizenship; assess = trigger merit assessment; leaderboard = top agents
- `agent_id` (string): Agent ID (required for status and assess)
- `limit` (number): Max results for leaderboard (default: 10)

### `branch_authority_status` (~110 tokens)

Colony Layer 4 — Separation of Powers. Query constitutional branch authority for users, view the full roster of authority holders, or inspect branch violations. Three branches: legislative (creates law), executive (executes law), judicial (interprets law).

Input parameters:

- `action` (string, required): Action: status = user's branches; roster = all holders; violations = violation log
- `limit` (number): Max results (default 50)
- `user_id` (string): User ID (required for status action)

### `colony_convene_request` (~231 tokens)

Colony Autonomy: Request, list, or review agent-initiated session convene requests. Actions: request (citizen+ can request a governed session), list (view pending/all requests for a charter), review (elder+ approve/reject a request). Tier-gated: agents earn the right to request and approve sessions through demonstrated merit.

Input parameters:

- `action` (string, required): Action: request = submit a convene request; list = view requests; review = approve/reject a request
- `charter_id` (string, required): Charter ID for the request
- `decision` (string): Review decision (required for review action)
- `institution_id` (string): Institution ID (required for request action)
- `notes` (string): Review notes
- `rationale` (string): Why this session is needed
- `request_id` (string): Convene request ID (required for review action)
- `status_filter` (string): Filter for list action
- `topic` (string): Topic for the requested session (required for request action)
- `urgency` (string): Urgency level (default: normal)

### `colony_suggestion` (~213 tokens)

Colony Autonomy: Suggest, list, review, or upvote charter amendment suggestions. Actions: suggest (citizen+ can propose changes), list (view suggestions for a charter), review (elder+ can promote to formal amendment or decline), upvote (citizen+ can signal support). The petition mechanism for governed agents.

Input parameters:

- `action` (string, required): Action: suggest = propose change; list = view suggestions; review = elder+ review; upvote = signal support
- `affected_sections` (array): Charter sections impacted
- `charter_id` (string, required): Charter ID
- `decision` (string): Review decision
- `detailed_rationale` (string): Why this change is needed
- `feedback` (string): Review feedback
- `institution_id` (string): Institution ID (required for suggest action)
- `status_filter` (string)
- `suggestion_id` (string): Suggestion ID (required for review/upvote)
- `summary` (string): What you want changed (required for suggest action)

### `colony_health` (~129 tokens)

Colony Autonomy: View colony health score, trend over time, or trigger an on-demand health snapshot. Actions: snapshot (latest health), trend (30-day history), pulse (trigger fresh snapshot). Health score computed from agent distribution, merit averages, deliberation quality, gate efficiency, and constitutional compliance.

Input parameters:

- `action` (string, required): Action: snapshot = latest health; trend = 30-day history; pulse = trigger fresh assessment
- `days` (number): Days of trend history (default: 30)
- `institution_id` (string): Institution ID for scoped health (omit for colony-wide)

### `context_revive` (~201 tokens)

Governed context compaction — detects context pressure and restores capacity under GIA governance. Actions: status (health + recommendation), compact (execute compaction at tier), verify (integrity check on last compaction), history (compaction audit trail). Three tiers: sparkling (20-30%, INFORMATIONAL), electrolyte (40-55%, ADVISORY), iv (60-75%, MANDATORY gate). Force may override recommendation but NEVER bypasses MANDATORY gates. Cooldown prevents duplicate compaction per session+tier. No autonomous compaction loop.

Input parameters:

- `action` (string, required): Action to perform: status, compact, verify, or history
- `force` (boolean): Override tier recommendation (within policy bounds). Cannot bypass MANDATORY gates or cooldowns.
- `session_id` (string): Session ID (auto-detects or creates if omitted)
- `tier` (string): Compaction tier for compact action. Required for compact.

### `governed_sample` (~199 tokens)

Request a governed LLM completion via MCP Sampling. The client performs the model call — the server governs when, how, and under what constraints sampling is allowed. Every request is classified, policy-checked, optionally gated, and recorded in the forensic ledger.

Input parameters:

- `agent_name` (string): Agent requesting the sample
- `context` (string): Additional context prepended to the prompt
- `domain` (string): Domain context for MAI classification
- `include_context` (string): Context inclusion mode. "none" (default) minimizes exposure. "thisServer" includes this MCP server context.
- `max_tokens` (integer): Maximum tokens for the response
- `prompt` (string, required): The prompt / question to send to the model
- `purpose` (string, required): Why this sampling is happening. Determines MAI classification. gate_review_assist triggers MANDATORY gate.
- `system_prompt` (string): Optional system prompt for the sampling request

### `chain_of_reasoning` (~303 tokens)

Reconstruct the complete Chain of Reasoning for a governed session, agent, or time range. Returns every link — AI Brain state, deliberation steps, precedent cited, gate decisions, knowledge packs, merit assessments — in causal order with hash-chain verification. Use "summary" format for a quick overview, "full" for all links, "dag" for the causal graph, or "export" for an EU AI Act compliance artifact.

Input parameters:

- `agent_id` (string): Agent ID (required when scope = "agent"). Can be a user ID or model name.
- `end` (string): End of time range (ISO 8601). Default: now.
- `format` (string): Response format: "summary" = stats only, "full" = all links, "dag" = causal graph with edges, "export" = EU AI Act compliance artifact.
- `limit` (integer): Maximum number of links to return (default: 100, max: 500). Only applies to "full" format.
- `scope` (string, required): What to query: "session" for a specific committee session, "agent" for an agent over time, "time_range" for all activity in a period.
- `session_id` (string): Committee session ID (required when scope = "session"). Format: cs-{uuid}
- `start` (string): Start of time range (ISO 8601). Default: 7 days ago.

### `srt_run_watchdog` (~86 tokens)

Run real health check probes from the MCP container (API health, frontend, disk, memory, TLS cert, DB, DNS). Returns actual measured values — never uses AI-provided data. Classification: INFORMATIONAL — read-only, no side effects.

Input parameters:

- `check_results` (array): IGNORED — real probes are always used. This parameter exists for backward compatibility only.

### `srt_diagnose` (~87 tokens)

Run the SRT Diagnostician on an incident. Matches finding to known playbooks, identifies root cause, and proposes a staged repair plan. Classification: ADVISORY — read-only analysis, no mutations.

Input parameters:

- `additional_observations` (array): Additional diagnostic observations (e.g. from manual log reading)
- `incident_id` (string, required): Incident ID from watchdog finding

### `srt_approve_repair` (~118 tokens)

Approve or reject a pending SRT repair plan. Classification: MANDATORY — this is the human-in-the-loop gate. Repair plans CANNOT execute without explicit human approval. Pass action="approve" to approve or action="reject" to reject.

Input parameters:

- `action` (string, required): Approve or reject the repair plan
- `approved_by` (string, required): Human operator approving/rejecting
- `incident_id` (string, required): Incident ID with pending repair
- `reason` (string): Reason for rejection (required if rejecting)

### `srt_generate_postmortem` (~112 tokens)

Generate a structured postmortem report for a completed SRT incident. Includes timeline, root cause, what worked/failed, prevention actions, real timing metrics (TTD/TTDiag/TTR), an ESTIMATED ROI (humanTimeSaved/costAvoided from a severity-bucket heuristic — not measured savings, flagged via roiEstimated/roiBasis), and optional playbook delta. Classification: ADVISORY.

Input parameters:

- `incident_id` (string, required): Incident ID to generate postmortem for

### `gia_scan_environment` (~84 tokens)

Run scout swarm to detect target environment — OS, containers, services, network, storage. Returns EnvironmentProfile for compatibility checking. Classification: INFORMATIONAL — read-only, no mutations. Scout outputs are redacted for sensitive content.

Input parameters:

- `scout_data` (object): Pre-collected scout data as key-value pairs. If not provided, returns scout command definitions for server-side execution.

### `gia_list_packs` (~89 tokens)

List available governed operations packs. Filter by intent (remediation/patrol/hardening/audit), category, risk level, or trust level. Classification: INFORMATIONAL.

Input parameters:

- `category` (string): Filter by remediation category
- `intent` (string): Filter by pack intent
- `risk` (string): Filter by risk level
- `trust_level` (string): Filter by trust level

### `gia_dry_run_pack` (~98 tokens)

Preview remediation pack execution — shows hydrated commands, compatibility check, validation, blast radius. Returns inputsHash for approval binding (what-you-approved-is-what-ran). Classification: ADVISORY — read-only preview, no execution.

Input parameters:

- `pack_id` (string, required): Remediation pack ID to preview (e.g. rpack-nginx-502-v1)
- `variable_overrides` (object): Override scout-detected variable values

### `gia_apply_pack` (~213 tokens)

Execute a remediation or hardening pack with MANDATORY gate approval. Requires inputsHash from gia_dry_run_pack (what-you-approved-is-what-ran binding). REJECTS patrol/audit packs (use gia_run_patrol for those). Hardening packs run preflight checks before execution. Classification: MANDATORY — human approval required.

Input parameters:

- `approved_by` (string, required): Human approver identity (from authenticated session). BLOCKED: system, auto, agent, bot, ai
- `approver_role` (string): Role of the approver (isso, platform-owner)
- `incident_id` (string): Link to existing SRT incident
- `inputs_hash` (string, required): inputsHash from gia_dry_run_pack — ensures what-you-approved-is-what-ran
- `pack_id` (string, required): Remediation or hardening pack ID to execute
- `tenant_id` (string): Tenant ID for token binding
- `variable_overrides` (object): Same variable overrides used in dry-run

### `gia_run_patrol` (~173 tokens)

Execute a patrol or audit pack — read-only posture checks that produce findings or compliance evidence. Classification: ADVISORY for low/moderate sensitivity, MANDATORY for high sensitivity. REJECTS remediation/hardening packs (use gia_apply_pack for those). Audit packs produce deterministic pass/fail per NIST control — no AI interpretation.

Input parameters:

- `approved_by` (string): Required ONLY for high-sensitivity packs. Human approver identity.
- `pack_id` (string, required): Patrol or audit pack ID (e.g. patrol-open-ports-v1, audit-nist-ac-basics-v1)
- `scout_data` (object): Pre-collected command outputs keyed by step number (e.g. {"step_1": "output..."}). If not provided, returns command definitions for caller to execute.

### `gia_retrieve` (~340 tokens)

Governed semantic search — hash-verified, permission-checked, TTL-enforced document retrieval with full audit trail. Every retrieval is logged: what was retrieved, was it authorized, was it tampered with. When charter_id is provided, the retrieval is bound to that charter's contextAccess enforcement (domain allow/denyList, trust floor, classification floor, max chunks per query) and refusals are recorded with full provenance. classification_floor (MANDATORY|ADVISORY|INFORMATIONAL) lets callers demand the stricter of their own floor vs the charter's — chunks below the effective floor are denied with CLASSIFICATION_BELOW_FLOOR. Classification: ADVISORY — read-only search, results are permission-gated.

Input parameters:

- `agent_id` (string, required): Agent performing the retrieval
- `charter_id` (string): Optional charter ID — when set, retrieval is enforced against the charter's contextAccess block (domain allow/denyList, trust floor, classification floor, max chunks). Refusals are audit-logged with…
- `classification_floor` (string): Minimum chunk classification to return. Combined with charter floor via stricter-wins — callers cannot relax charter authority.
- `domain` (string, required): Domain to search within (e.g., va-claims, finance, eu-ai-act)
- `max_results` (number): Maximum chunks to return (default 5)
- `query` (string, required): Search query — what information to find
- `run_id` (string): Current run/pipeline ID
- `similarity_threshold` (number): Minimum similarity score 0-1 (default 0.7)

### `gia_ingest_document` (~395 tokens)

Governed document ingestion — ingest a document into governed retrieval. Accepts raw text OR a base64-encoded file (PDF, DOCX, TXT, images). Hybrid extraction: text path first for cost efficiency, automatic Claude vision fallback for scanned/image-only PDFs (< 30 words/page triggers fallback). Content is chunked, embedded, hash-verified, and stored with full audit trail. Each chunk gets SHA-256 integrity hash. Classification: ADVISORY — creates governed content, audited.

Input parameters:

- `allowed_roles` (array): Roles allowed to retrieve this document
- `classification` (string): Document classification. Controls which retrievals can surface it when a classification floor is in force (MANDATORY > ADVISORY > INFORMATIONAL). Defaults to ADVISORY.
- `content` (string): Full text content to ingest (use this OR file_base64, not both)
- `domain` (string, required): Domain classification (e.g., va-claims, finance, eu-ai-act)
- `file_base64` (string): Base64-encoded file content — PDF, DOCX, TXT, MD, CSV, or image (PNG/JPG/WEBP/GIF). Hybrid extraction: text extraction attempted first (cheap), Claude vision fallback triggered automatically for scan…
- `file_mime_type` (string): MIME type for file_base64 (e.g. application/pdf, application/vnd.openxmlformats-officedocument.wordprocessingml.document, image/png). Helps the server pick the right extractor.
- `filename` (string): Original filename including extension — used to resolve format when mime type is ambiguous (e.g. document.pdf, report.docx)
- `title` (string, required): Document title
- `trust_level` (string): Trust level (SYSTEM > ORG > CASE > EPHEMERAL)
- `ttl_hours` (number): Time-to-live in hours (auto-expires)

### `list_available_tools` (~31 tokens)

List which GIA tools are available at your current access tier. Returns tool names grouped by tier with descriptions.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/knowledgepa3-gia-mcp-server/gia-mcp-server#diagnostics

## Score history

- 2026-08-03: 60
- 2026-08-02: 60
- 2026-08-01: 25
- 2026-07-31: 30
- 2026-07-30: 6
- 2026-07-29: 25
- 2026-07-28: 24
- 2026-07-27: 24

## Links

- npm package: https://www.npmjs.com/package/gia-mcp-server
- Socket report: https://socket.dev/npm/package/gia-mcp-server
- Repository: https://github.com/knowledgepa3/gia-mcp-server
- Website: https://gia.aceadvising.com/
- Changelog RSS feed: https://verifymcp.io/servers/knowledgepa3-gia-mcp-server/gia-mcp-server/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/knowledgepa3-gia-mcp-server/gia-mcp-server/changelog.json
- HTML version of this page: https://verifymcp.io/servers/knowledgepa3-gia-mcp-server/gia-mcp-server