FalseGreen MCP

Agent Reference

The public workflow and tool contract for coding agents using FalseGreen independent software verification.

This reference is derived from the launch client’s runtime MCPtools/list at core SHA 6f47ea32bbad9443134b1e1efd7394af7b724797. A connected runtime tools/list remains the ultimate authority.

Install FalseGreen See FalseGreen Job Read proof

On this page

Reference

Architecture
Connection and authentication
Public lifecycle
Agent authority
Job entitlements
Result semantics
Public tools

Tool groups

Task
Planning
Acceptance contract
Assignment
Verification
Status
Repair
Lifecycle
Paid Job continuation
Evidence and reports
Terraform authority

Customer architecture

One agent builds. FalseGreen independently decides.

Coding agent
    ↓ MCP
FalseGreen customer tool surface
    ↓
Task + frozen definition of done
    ↓
coding-agent implementation
    ↓
independent FalseGreen verification
    ↓
evidence-backed result + durable report

Coding agent

Proposes and plans work, implements source changes, responds to demonstrated deficiencies, performs authorized repair, and requests FalseGreen state, evidence, and reports.

FalseGreen

Owns the independent acceptance boundary, preserves the frozen definition of done, decides verification and repair authorization, terminalizes the Job, and issues authoritative evidence and reports.

The coding agent does not decide its own FalseGreen acceptance.

Connection and authentication

Use the supported client and installer.

Create or sign in to a FalseGreen Account.
cargo install falsegreen
Run falsegreen login --token YOUR_FALSEGREEN_KEY. The client exchanges the enrollment key for an opaque local session and does not retain the enrollment key.
Run the supported installer for Codex or Claude Code, then fully restart the coding agent.

The installed client runs a local STDIO MCP shim, synchronizes the active workspace when required, and forwards supported tool calls to FalseGreen over authenticated HTTPS. Do not place the Account enrollment key in editor or MCP configuration, and do not bypass the client to reproduce its private session transport.

Full installation guide →

Public lifecycle

Freeze the target before judging the result.

Account / authentication
    ↓
Task → optional plan → frozen plan
    ↓
acceptance contract / definition of done
    ↓ freeze
Assignment
    ↓
coding-agent implementation
    ↓
independent verification
    ↓
Accepted or non-Accepted evidence
    ↓ only when repair_authorized=true
repair → reverify the SAME frozen definition of done

Verification attempt != Job. One paid Job owns one frozen definition of done through verification, authorized repair, and reverification. A repairable attempt does not create another paid Job, permit a replacement Task, or allow the target to move.

A terminal non-Accepted paid Job remains historical with its Task, evidence, report, and consumed entitlement. Exact-DoD continuation uses falsegreen_continue_verification_job and a distinct paid entitlement. A material DoD change is new scope and a new acceptance lineage.

Agent authority

What the coding agent may and may not decide.

May

✓ Propose Task, plan, and contract material where allowed.
✓ Implement source changes.
✓ Request verification and inspect results.
✓ Repair demonstrated deficiencies only when repair_authorized=true.
✓ Reverify the same frozen DoD and retrieve durable evidence.
✓ Use explicit exact-DoD continuation when the public lifecycle permits it.

Must not

× Claim FalseGreen ACCEPT itself or fabricate verdict fields.
× Alter the frozen DoD after seeing evidence.
× Treat infrastructure/controller failure as source-code failure.
× Consume repair budget for invalid infrastructure evidence.
× Abandon a Job-bound Task or create an unlinked replacement.
× Treat each failed attempt as another Job or silently retry terminal Jobs.

Job entitlement semantics

Planning is not paid consumption.

Creating an Account does not buy verification.
Creating a Task, planning, and drafting do not consume a Job entitlement.
Freezing the DoD establishes and binds the Job boundary but does not consume the entitlement.
Buying a Job creates an available entitlement.
The first durable substantive verification atomically consumes that entitlement.
Authorized repair and reverification inside the same Job do not consume another entitlement.
A terminal non-Accepted paid Job keeps its entitlement consumed and its history retained.
Preparing an exact-DoD continuation does not consume it; the continuation’s first durable run requires and consumes a distinct available entitlement.

Result semantics

Do not collapse evidence failures into one state.

Accepted

Evidence established the frozen criteria for the exact verified source. Acceptance is bounded, not universal certification.

Failed / unsafe

Evidence demonstrated required failure. Repair is permitted only when the completion response explicitly returns repair_authorized=true.

Runtime Incomplete / Report Insufficient Evidence

The available evidence did not establish the complete boundary. Runtime status may be incomplete; the canonical report distinguishes demonstrated failure from insufficient evidence.

Invalid, error, or infrastructure/precondition failure

This is not a source-code verdict. Retrieve the artifact when available and stop or mark unresolved; do not spend repair budget or rewrite source in response.

Terminal non-Accepted

The paid Job and Task history remain preserved. Continue only through the explicit exact-DoD continuation tool when supported and appropriate.

Pre-execution Task closure

falsegreen_close_task exposes only agent closure of a stale unbound Task and returns abandoned. It is not a verification verdict. Historical operator closure is not part of the public customer MCP surface.

Public MCP tools

30 launch-public customer tools.

Input schemas below are the exact runtime tools/listexport from the authority SHA. The catalog does not expose worker, operator, migration, reconciliation, signing, billing-provider, or private infrastructure controls.

Task

falsegreen_create_task

Use when: No FalseGreen task is active and the work needs a new bounded acceptance scope.
Do not use when: A failed, unresolved, terminal, or Job-bound Task already represents the work.
Returns: task_id, draft status, and the next planning-or-contract action.
Mutates state: Yes
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: No public idempotency guarantee; list existing Tasks before retrying after an uncertain response.
Typical next: falsegreen_get_plan_schema, falsegreen_get_contract_schema
Failure behavior: Rejects missing state, unapproved workspaces, malformed repository metadata, or task-capacity violations.

Exact input schema

                              
                                {
  "properties": {
    "branch": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "commit_sha": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "goal": {
      "type": "string"
    },
    "pr_identifier": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "pr_number": {
      "default": null,
      "minimum": 1,
      "type": [
        "integer",
        "null"
      ]
    },
    "pr_url": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "repository": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "title": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "workspace": {
      "type": "string"
    }
  },
  "required": [
    "workspace",
    "goal"
  ],
  "type": "object"
}

falsegreen_list_tasks

List compact Task lifecycle state and closeability.

Use when: The agent needs to discover existing Tasks before creating, closing, or recovering work.
Do not use when: Do not infer acceptance from list state; retrieve status and artifacts for authoritative results.
Returns: Task entries with task_id, status, can_close, goal, and latest_run_id.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_get_status, falsegreen_close_task, falsegreen_get_assignment
Failure behavior: Returns a tool error if protected Task state is unavailable.

Exact input schema

                              
                                {
  "properties": {},
  "type": "object"
}

Planning

falsegreen_get_plan_schema

Return the live structured task-plan input schema.

Use when: A substantial Task needs an explicit outcome-oriented plan before contract drafting.
Do not use when: Do not invent plan fields from examples instead of using this live schema.
Returns: The current task-plan JSON Schema with server-owned fields identified.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_save_plan_draft
Failure behavior: Returns a tool error if the schema cannot be produced.

Exact input schema

                              
                                {
  "properties": {},
  "type": "object"
}

falsegreen_save_plan_draft

Save an outcome-oriented plan revision for a Task.

Use when: The agent has populated the live plan schema with dependencies, acceptance conditions, evidence, and omission risks.
Do not use when: The plan is frozen or contract drafting has made plan mutation invalid.
Returns: task_id, plan_draft status, revision, work-item count, acceptance-condition count, and next action.
Mutates state: Yes
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Saving creates a revision; inspect the current plan before retrying an uncertain write.
Typical next: falsegreen_validate_plan, falsegreen_get_plan
Failure behavior: Rejects invalid plan structure, Task identity, lifecycle state, or dependency relationships.

Exact input schema

                              
                                {
  "properties": {
    "plan": {
      "type": "object"
    },
    "task_id": {
      "type": "string"
    }
  },
  "required": [
    "task_id",
    "plan"
  ],
  "type": "object"
}

falsegreen_validate_plan

Validate the current plan draft and dependency graph.

Use when: A plan draft is ready to check before freezing.
Do not use when: There is no plan draft for the supplied Task.
Returns: Validation status and actionable plan errors.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry against the same draft.
Typical next: falsegreen_save_plan_draft, falsegreen_freeze_plan
Failure behavior: Returns validation errors or a tool error for a missing or inaccessible draft.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "type": "string"
    }
  },
  "required": [
    "task_id"
  ],
  "type": "object"
}

falsegreen_freeze_plan

Freeze the proposed plan so later mutation is rejected.

Use when: The current plan validates and should become the immutable planning input to contract drafting.
Do not use when: The plan still has validation errors or requires revision.
Returns: task_id, plan_frozen status, revision, canonical digest, and next action.
Mutates state: Yes
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Freeze is a state transition; inspect the frozen plan before retrying an uncertain response.
Typical next: falsegreen_get_contract_schema, falsegreen_save_contract_draft
Failure behavior: Rejects invalid, missing, or already-incompatible plan state.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "type": "string"
    }
  },
  "required": [
    "task_id"
  ],
  "type": "object"
}

falsegreen_get_plan

Return the current draft or frozen plan.

Use when: The agent needs the authoritative plan revision and acceptance/evidence mapping.
Do not use when: Do not treat a draft plan as human-approved acceptance authority.
Returns: The requested structured plan, including its current revision and frozen digest when applicable.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_save_plan_draft, falsegreen_save_contract_draft
Failure behavior: Returns a tool error if the requested draft or frozen plan does not exist.

Exact input schema

                              
                                {
  "properties": {
    "frozen": {
      "default": true,
      "type": "boolean"
    },
    "task_id": {
      "type": "string"
    }
  },
  "required": [
    "task_id"
  ],
  "type": "object"
}

Acceptance contract

falsegreen_save_contract_draft

Save the draft definition of done and executable acceptance criteria.

Use when: The contract follows the live schema and maps required plan acceptance and evidence IDs.
Do not use when: The contract is frozen, or proposed metadata is inferred rather than supplied or observed.
Returns: task_id, contract_draft status, and criterion count.
Mutates state: Yes
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Saving changes the draft; inspect the current contract before retrying an uncertain write.
Typical next: falsegreen_validate_contract, falsegreen_get_contract
Failure behavior: Rejects malformed criteria, invalid commands, plan-mapping gaps, or incompatible Task state.

Exact input schema

                              
                                {
  "properties": {
    "contract": {
      "type": "object"
    },
    "task_id": {
      "type": "string"
    }
  },
  "required": [
    "task_id",
    "contract"
  ],
  "type": "object"
}

falsegreen_validate_contract

Validate the current contract draft against source-independent policy and plan coverage.

Use when: A contract draft is ready to check before freezing.
Do not use when: Do not interpret validation as acceptance or verification of the implementation.
Returns: valid flag plus actionable contract and planning errors.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry against the same draft.
Typical next: falsegreen_save_contract_draft, falsegreen_freeze_contract
Failure behavior: Returns validation errors or a tool error when Task, workspace, or draft state is unavailable.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

falsegreen_freeze_contract

Freeze the definition of done and bind the Verification Job boundary.

Use when: The exact contract validates and the required human approval path has been satisfied.
Do not use when: The definition of done is unsettled; enforced authority requires the documented human CLI approval instead of agent self-approval.
Returns: Frozen status, Verification Job identity, canonical contract/scope digests, criterion count, and next action.
Mutates state: Yes
Job entitlement: May bind or create Job state but does not consume a Job entitlement.
Idempotency / retry: Freeze is immutable; inspect current contract/assignment state before retrying an uncertain response.
Typical next: falsegreen_get_assignment
Failure behavior: Rejects invalid drafts, lifecycle conflicts, missing authority, or agent freeze attempts when signed human approval is required.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

falsegreen_get_contract_schema

Return the live acceptance-contract schema and verifier command policy.

Use when: The agent is preparing executable acceptance criteria for a Task.
Do not use when: Do not hardcode a stale contract schema or infer verifier authority from the repository.
Returns: The current contract JSON Schema plus public command-policy constraints.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_save_contract_draft
Failure behavior: Returns a tool error if the live schema cannot be produced.

Exact input schema

                              
                                {
  "properties": {},
  "type": "object"
}

falsegreen_get_contract

Return the full draft or frozen contract for debugging.

Use when: A developer or agent needs full contract details not present in the compact assignment.
Do not use when: Prefer falsegreen_get_assignment for normal implementation work; do not mutate frozen material.
Returns: The requested contract document and its criteria.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_get_assignment, falsegreen_validate_contract
Failure behavior: Returns a tool error if the requested contract state is missing or inaccessible.

Exact input schema

                              
                                {
  "properties": {
    "frozen": {
      "default": true,
      "type": "boolean"
    },
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

Assignment

falsegreen_get_assignment

Return compact immutable requirements for the active frozen Task.

Use when: The coding agent is ready to implement against the frozen definition of done.
Do not use when: No contract is frozen, or the agent intends to reinterpret or replace the acceptance target.
Returns: Goal, constraints, criteria, repair limit, optional frozen plan, assigned status, and session binding.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_check_completion, falsegreen_begin_implementation
Failure behavior: Rejects missing/ambiguous active Tasks or Tasks without a frozen contract.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

Verification

falsegreen_check_completion

Run the compact independent completion workflow and return the controller decision.

Use when: Implementation or authorized repair is ready for full independent verification.
Do not use when: Do not call after an unrepairable infrastructure error, without an available paid Job, or to change the frozen target.
Returns: Task status, run identity, repair authorization/budget, failures, authoritative report fields when ready, and next action.
Mutates state: Yes
Job entitlement: The first durable substantive verification may consume the bound Job entitlement; same-Job authorized repair and reverification never consume a second entitlement.
Idempotency / retry: No explicit idempotency key; inspect status and artifacts before retrying after an uncertain response.
Typical next: falsegreen_get_verification_artifacts, falsegreen_get_repair_feedback, falsegreen_check_completion
Failure behavior: May return job_required, queue/report infrastructure states, accepted, incomplete, unsafe, invalid, or error. Only repair when repair_authorized is true.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

falsegreen_verify

Durably start full verification or a focused diagnostic criterion run and return immediately.

Use when: A lower-level integration needs a durable run_id and explicit polling; criterion_ids are diagnostic only.
Do not use when: Do not treat a focused run as acceptance or retry an invalid/error run as source repair.
Returns: Durable run identity, queued/running state, next polling action, and may_claim_complete=false.
Mutates state: Yes
Job entitlement: The first durable substantive full verification may consume the bound Job entitlement; focused diagnostics cannot accept, and same-Job reverification never consumes a second entitlement.
Idempotency / retry: Reuse the same idempotency_key when retrying a start whose response may have been lost; the durable run is reused.
Typical next: falsegreen_get_status, falsegreen_get_verification_artifacts
Failure behavior: May fail closed with job_required/job_refused, queue capacity, report delivery, authority mismatch, or invalid lifecycle/source state before substantive verification.

Exact input schema

                              
                                {
  "properties": {
    "criterion_ids": {
      "default": null,
      "items": {
        "type": "string"
      },
      "type": [
        "array",
        "null"
      ]
    },
    "idempotency_key": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

Status

falsegreen_get_status

Poll one durable run or return compact Task status.

Use when: A started run is queued/running, or the agent needs current Task and repair state.
Do not use when: Do not infer a final report from status alone when artifacts are available.
Returns: Run state when run_id is supplied; otherwise Task status, latest run, authority readiness, and repair budget.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to poll; use the exact durable run_id.
Typical next: falsegreen_get_status, falsegreen_get_verification_artifacts, falsegreen_get_repair_feedback
Failure behavior: Rejects unknown or mismatched Task/run identities; queued/running is not a terminal verdict.

Exact input schema

                              
                                {
  "properties": {
    "run_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

Repair

falsegreen_get_repair_feedback

Return compact demonstrated failures from the latest verification run.

Use when: falsegreen_check_completion returned repair_authorized=true and more detail is needed.
Do not use when: Infrastructure/controller errors are not source repair targets; this tool does not grant repair authority.
Returns: Task/run status, bounded failure summaries, and repair instructions.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_check_completion
Failure behavior: Returns a tool error if there is no applicable retained verification feedback.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

falsegreen_consume_repair_cycle

Consume one low-level repair-cycle authorization boundary.

Use when: A specialized integration is explicitly instructed to consume a cycle outside the compact completion workflow.
Do not use when: falsegreen_check_completion already handled authorization, or the failure is invalid, infrastructure-related, or not repair-authorized.
Returns: The remaining repair-cycle count.
Mutates state: Yes
Job entitlement: Consumes repair budget only; it never consumes a second Job entitlement during same-Job repair.
Idempotency / retry: Not idempotent; never retry blindly because each successful call consumes a cycle.
Typical next: falsegreen_get_repair_feedback, falsegreen_check_completion
Failure behavior: Rejects exhausted budgets, invalid lifecycle state, or a failure that is not eligible for repair.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

Lifecycle

falsegreen_begin_implementation

Explicitly transition a frozen Task into implementation state.

Use when: A lower-level integration needs the lifecycle transition before implementation.
Do not use when: Normal agents should prefer falsegreen_check_completion, which begins when needed.
Returns: task_id and implementing status.
Mutates state: Yes
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: State transition; inspect current status before retrying.
Typical next: falsegreen_check_completion, falsegreen_verify
Failure behavior: Rejects Tasks whose lifecycle state cannot enter implementation.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

falsegreen_mark_unresolved

Record that the Task cannot currently be resolved, with an explicit reason.

Use when: Required evidence, access, or environment prevents completion and source repair is not justified.
Do not use when: Do not use it to disguise a demonstrated failure, claim acceptance, or escape Job history.
Returns: task_id and unresolved status.
Mutates state: Yes
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: State mutation; inspect status before retrying.
Typical next: falsegreen_get_status, falsegreen_get_verification_artifacts
Failure behavior: Rejects empty/oversized reasons or incompatible Task state.

Exact input schema

                              
                                {
  "properties": {
    "reason": {
      "type": "string"
    },
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "reason"
  ],
  "type": "object"
}

falsegreen_close_task

Close only a stale non-Accepted Task that never entered Verification Job authority.

Use when: falsegreen_list_tasks reports can_close=true for an obsolete unbound Task.
Do not use when: A Task is Job-bound, verifying, accepted, or being replaced to escape paid Job or acceptance history.
Returns: task_id, previous status, abandoned status, and create_task as the next action.
Mutates state: Yes
Job entitlement: Does not consume or restore a Job entitlement; Job-bound Tasks cannot be closed by the agent.
Idempotency / retry: State transition; list Tasks before retrying.
Typical next: falsegreen_list_tasks, falsegreen_create_task
Failure behavior: Rejects Job-bound, active-verification, accepted, unknown, or otherwise non-closeable Tasks.

Exact input schema

                              
                                {
  "properties": {
    "reason": {
      "type": "string"
    },
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "reason"
  ],
  "type": "object"
}

Paid Job continuation

falsegreen_continue_verification_job

Prepare an exact-DoD successor Job after a terminal non-Accepted paid Job.

Use when: The predecessor is terminal non-Accepted and work must continue against its exact unchanged frozen definition of done.
Do not use when: The predecessor remains repairable, the DoD changed materially, or the agent is trying to create an unlinked replacement Task.
Returns: continuation_ready status, successor Job/lineage identities, predecessor link, frozen digests, available Job count, entitlement_consumed=false, and next action.
Mutates state: Yes
Job entitlement: Prepares a successor without consuming it; the first durable verification requires and consumes a distinct available paid entitlement.
Idempotency / retry: Do not retry blindly; inspect the lineage/status after an uncertain response.
Typical next: falsegreen_verify, falsegreen_check_completion
Failure behavior: Rejects non-terminal predecessors, changed DoD, conflicting lineage identity, invalid ownership, missing retained history, or malformed predecessor identity.

Exact input schema

                              
                                {
  "properties": {
    "predecessor_job_id": {
      "type": "string"
    }
  },
  "required": [
    "predecessor_job_id"
  ],
  "type": "object"
}

Evidence and reports

falsegreen_get_verification_artifacts

Retrieve the source-bound attestation and immutable canonical report for a completed run.

Use when: Every verification run with a run_id has completed, regardless of whether it was accepted.
Do not use when: Do not fabricate, rewrite, or summarize a FalseGreen verdict in place of server-issued fields.
Returns: report_id, report_url, verified_source_identity, attestation/evidence, and server_generated_pr_summary to relay verbatim.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry for the same completed run.
Typical next: falsegreen_get_repair_feedback, falsegreen_check_completion, falsegreen_continue_verification_job
Failure behavior: Returns a tool error while the result/report is unavailable or when Task/run identity conflicts.

Exact input schema

                              
                                {
  "properties": {
    "run_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    },
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

falsegreen_get_attestation_verification_key

Return public verification material for independently checking issued attestations.

Use when: A customer or reviewer needs to validate a retained FalseGreen artifact.
Do not use when: Do not expect private signing material or use the public key to manufacture attestations.
Returns: Public Ed25519 verification material and its public identity metadata.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_get_verification_artifacts
Failure behavior: Returns a tool error if public verification material is unavailable.

Exact input schema

                              
                                {
  "properties": {},
  "type": "object"
}

falsegreen_get_audit_summary

Return the Task audit-chain validity and public event summary.

Use when: A developer is debugging lifecycle history or checking retained event-chain integrity.
Do not use when: Do not use audit events as a substitute for the canonical verification report.
Returns: task_id, audit validity, and ordered event sequence/type/hash entries.
Mutates state: No
Job entitlement: Does not consume a Job entitlement.
Idempotency / retry: Read-only and safe to retry.
Typical next: falsegreen_get_status, falsegreen_get_verification_artifacts
Failure behavior: Returns a tool error for an unavailable Task or protected audit state.

Exact input schema

                              
                                {
  "properties": {
    "task_id": {
      "default": null,
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}

Terraform authority

falsegreen_get_terraform_result

Read the retained Terraform plan, provenance, apply authority, and deployed-outcome state.

Use when: An opt-in Terraform criterion has completed and the agent needs to distinguish plan acceptance, apply authorization, and deployed outcome.
Do not use when: Do not treat an accepted plan as authority to apply or as proof of deployed behavior.
Returns: Bounded Terraform plan evidence, provenance, authorization state, and deployment evidence for the selected command.
Mutates state: No
Job entitlement: Does not consume another Job entitlement.
Idempotency / retry: Read-only and safe to retry for the same run.
Typical next: falsegreen_get_terraform_apply_authorization_payload, falsegreen_get_verification_artifacts
Failure behavior: Rejects runs without retained Terraform evidence or mismatched Task/run/command identity.

Exact input schema

                              
                                {
  "properties": {
    "command_index": {
      "default": null,
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "run_id": {
      "type": "string"
    },
    "task_id": {
      "type": "string"
    }
  },
  "required": [
    "task_id",
    "run_id"
  ],
  "type": "object"
}

falsegreen_get_terraform_apply_authorization_payload

Return the exact bounded Terraform apply payload a human must approve in enforced mode.

Use when: An accepted retained plan needs separate human apply authorization.
Do not use when: The plan is not accepted, evidence is incomplete, or the agent intends to self-authorize apply.
Returns: The exact bounded approval payload and validity information; it does not authorize or start apply.
Mutates state: No
Job entitlement: Does not consume another Job entitlement.
Idempotency / retry: Read-only; regenerate only when a fresh validity window is intentionally needed.
Typical next: falsegreen_authorize_terraform_apply
Failure behavior: Rejects non-accepted/mismatched plan evidence or invalid command/validity parameters.

Exact input schema

                              
                                {
  "properties": {
    "command_index": {
      "default": null,
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "run_id": {
      "type": "string"
    },
    "task_id": {
      "type": "string"
    },
    "valid_for_seconds": {
      "default": null,
      "maximum": 3600,
      "minimum": 60,
      "type": [
        "integer",
        "null"
      ]
    }
  },
  "required": [
    "task_id",
    "run_id"
  ],
  "type": "object"
}

falsegreen_authorize_terraform_apply

Record one human authorization for the exact retained accepted Terraform plan.

Use when: A human has explicitly confirmed the exact bounded plan and supplied required approval material.
Do not use when: A coding agent must not impersonate the human actor or infer approval from plan acceptance.
Returns: Terraform status including the recorded authorization and next apply action.
Mutates state: Yes
Job entitlement: Does not consume another Job entitlement.
Idempotency / retry: Authorization is bounded and stateful; inspect Terraform status before retrying.
Typical next: falsegreen_apply_authorized_terraform_plan
Failure behavior: Rejects actor other than human, missing confirmation, invalid approval, expired/mismatched plan, or duplicate authority use.

Exact input schema

                              
                                {
  "properties": {
    "actor": {
      "const": "human",
      "type": "string"
    },
    "approval": {
      "default": null,
      "type": [
        "object",
        "null"
      ]
    },
    "command_index": {
      "default": null,
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "confirmed": {
      "const": true,
      "type": "boolean"
    },
    "run_id": {
      "type": "string"
    },
    "task_id": {
      "type": "string"
    },
    "valid_for_seconds": {
      "default": null,
      "maximum": 3600,
      "minimum": 60,
      "type": [
        "integer",
        "null"
      ]
    }
  },
  "required": [
    "task_id",
    "run_id",
    "actor",
    "confirmed"
  ],
  "type": "object"
}

falsegreen_apply_authorized_terraform_plan

Consume one authorization and apply only its exact retained Terraform plan.

Use when: A valid one-use authorization exists for the retained plan identity.
Do not use when: No authorization exists, it was already consumed, or arbitrary apply arguments/source changes are desired.
Returns: Updated Terraform state and verify_terraform_deployment as the next action.
Mutates state: Yes
Job entitlement: Does not consume another Job entitlement; it consumes the separate one-use apply authorization.
Idempotency / retry: Not safe to retry blindly; inspect Terraform result because authorization is one-use.
Typical next: falsegreen_verify_terraform_deployment, falsegreen_get_terraform_result
Failure behavior: Rejects missing, expired, consumed, or identity-mismatched authorization and any plan/source drift.

Exact input schema

                              
                                {
  "properties": {
    "authorization_id": {
      "pattern": "^tfapply_[0-9a-f]{32}$",
      "type": "string"
    },
    "command_index": {
      "default": null,
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "run_id": {
      "type": "string"
    },
    "task_id": {
      "type": "string"
    }
  },
  "required": [
    "task_id",
    "run_id",
    "authorization_id"
  ],
  "type": "object"
}

falsegreen_verify_terraform_deployment

Independently observe the outcome of an already applied Terraform plan.

Use when: The authorized apply completed and deployed behavior needs independent evidence.
Do not use when: Apply did not occur, plan evidence is incomplete, or deployment identity differs.
Returns: Updated deployed-outcome evidence and get_verification_artifacts as the next action.
Mutates state: Yes
Job entitlement: Does not consume another Job entitlement.
Idempotency / retry: Observation is stateful; inspect current Terraform result before retrying.
Typical next: falsegreen_get_terraform_result, falsegreen_get_verification_artifacts
Failure behavior: Returns incomplete/error evidence when provider observation, provenance, or deployment preconditions cannot be established.

Exact input schema

                              
                                {
  "properties": {
    "command_index": {
      "default": null,
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "run_id": {
      "type": "string"
    },
    "task_id": {
      "type": "string"
    }
  },
  "required": [
    "task_id",
    "run_id"
  ],
  "type": "object"
}

Machine-readable catalog

Use the catalog for discovery. Use runtime tools/list for execution.

The versioned FalseGreen-owned catalog is available at /.well-known/falsegreen-mcp.json. It is descriptive, not an industry standard.