← WebMCP Directory

Tool tree

decision-workspace.vercel.app

Productivity & BusinessTools verified
Website
A local-first workspace for making transparent decisions.
Explore capabilities

    page: Every page

    get_decision_workspaceAnswer

    Read decision workspace state. Supports compact view (default), interview view, model view, brief view, or full view.

    View tool JSON
    {
      "name": "get_decision_workspace",
      "kind": "answer",
      "impl": "imperative",
      "description": "Read decision workspace state. Supports compact view (default), interview view, model view, brief view, or full view.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "view": {
            "type": "string",
            "enum": [
              "compact",
              "interview",
              "model",
              "brief",
              "full"
            ],
            "description": "Level of detail to retrieve (default: 'compact')"
          }
        },
        "required": [],
        "additionalProperties": true
      },
      "page": "/"
    }
    list_decisionsAnswer

    List and search all saved decisions in the local workspace. Filter by text query or status.

    View tool JSON
    {
      "name": "list_decisions",
      "kind": "answer",
      "impl": "imperative",
      "description": "List and search all saved decisions in the local workspace. Filter by text query or status.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "description": "Optional search query to filter decisions by title or recommendation"
          },
          "status": {
            "type": "string",
            "enum": [
              "draft",
              "interviewing",
              "ready_to_review",
              "not_ready",
              "lean_verify",
              "recommended"
            ],
            "description": "Optional status filter"
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 100,
            "description": "Maximum number of decisions to return (default: 50)"
          }
        },
        "required": [],
        "additionalProperties": true
      },
      "page": "/"
    }
    run_scenarioAction

    Run a non-destructive what-if ranking with hypothetical weights or assessment scores without modifying base state.

    View tool JSON
    {
      "name": "run_scenario",
      "kind": "act",
      "impl": "imperative",
      "description": "Run a non-destructive what-if ranking with hypothetical weights or assessment scores without modifying base state.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "criterionWeights": {
            "type": "object",
            "description": "Hypothetical criterion weight overrides"
          },
          "assessmentScores": {
            "type": "object",
            "description": "Hypothetical assessment score overrides keyed by 'optionId:criterionId'"
          },
          "assessments": {
            "type": "object"
          },
          "assessmentOverrides": {
            "type": "object"
          }
        },
        "required": [],
        "additionalProperties": true
      },
      "page": "/"
    }
    start_decisionAction

    Start or initialize a decision workspace with title, context, goal, and initial options/criteria in one atomic call. Resets all previous decision data.

    View tool JSON
    {
      "name": "start_decision",
      "kind": "act",
      "impl": "imperative",
      "description": "Start or initialize a decision workspace with title, context, goal, and initial options/criteria in one atomic call. Resets all previous decision data.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "Optional workspace ID"
          },
          "title": {
            "type": "string",
            "description": "Decision title or question"
          },
          "context": {
            "type": "string",
            "description": "Background context or constraints"
          },
          "goal": {
            "type": "string",
            "description": "Primary goal or outcome desired"
          },
          "options": {
            "type": "array",
            "description": "Initial decision options",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string",
                  "description": "Unique option ID"
                },
                "name": {
                  "type": "string",
                  "description": "Display name of candidate option"
                },
                "description": {
                  "type": "string",
                  "description": "Optional detail/notes"
                },
                "attributes": {
                  "type": "object",
                  "description": "Structured key-value attributes for hard constraint evaluation"
                }
              },
              "required": [
                "id",
                "name"
              ]
            }
          },
          "criteria": {
            "type": "array",
            "description": "Initial decision criteria",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string",
                  "description": "Unique criterion ID"
                },
                "name": {
                  "type": "string",
                  "description": "Display name of criterion"
                },
                "description": {
                  "type": "string"
                },
                "weight": {
                  "type": "number",
                  "minimum": 1,
                  "maximum": 10,
                  "description": "Importance weight integer from 1 to 10"
                },
                "kind": {
                  "type": "string",
                  "enum": [
                    "objective",
                    "subjective",
                    "hybrid"
                  ]
                }
              },
              "required": [
                "id",
                "name"
              ]
            }
          },
          "confirmReset": {
            "type": "boolean",
            "description": "Must be true if resetting a workspace that already contains existing decision data"
          },
          "expectedRevision": {
            "type": "integer",
            "minimum": 1,
            "description": "Expected current revision for optimistic concurrency control"
          }
        },
        "required": [
          "title"
        ],
        "additionalProperties": true
      },
      "page": "/"
    }
    open_decisionAction

    Open and switch to a saved decision in the active workspace by its unique decision ID.

    View tool JSON
    {
      "name": "open_decision",
      "kind": "act",
      "impl": "imperative",
      "description": "Open and switch to a saved decision in the active workspace by its unique decision ID.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "decisionId": {
            "type": "string",
            "description": "The unique ID of the saved decision to open"
          },
          "expectedRevision": {
            "type": "integer",
            "minimum": 1,
            "description": "Expected current revision for optimistic concurrency control"
          }
        },
        "required": [
          "decisionId"
        ],
        "additionalProperties": true
      },
      "page": "/"
    }
    set_next_interview_questionAction

    Set the single pending interview question. Enforces the invariant that at most one question is awaiting an answer.

    View tool JSON
    {
      "name": "set_next_interview_question",
      "kind": "act",
      "impl": "imperative",
      "description": "Set the single pending interview question. Enforces the invariant that at most one question is awaiting an answer.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "question": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string"
              },
              "prompt": {
                "type": "string"
              },
              "rationale": {
                "type": "string"
              },
              "selectionReason": {
                "type": "string",
                "description": "Mandatory justification explaining why this question is the highest-value step now"
              },
              "answerType": {
                "type": "string",
                "enum": [
                  "text",
                  "single_choice",
                  "multi_choice",
                  "number",
                  "currency",
                  "date",
                  "scale",
                  "boolean"
                ]
              },
              "mappingPolicy": {
                "type": "string",
                "enum": [
                  "deterministic",
                  "agent_required",
                  "evidence_only"
                ],
                "description": "How answers map to criteria, constraints, or evidence"
              },
              "choices": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "label": {
                      "type": "string"
                    },
                    "value": {
                      "description": "Underlying value for this choice"
                    },
                    "description": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "id",
                    "label",
                    "value"
                  ]
                }
              },
              "allowOther": {
                "type": "boolean",
                "description": "Allow user free-text / something else answer"
              },
              "otherLabel": {
                "type": "string"
              },
              "min": {
                "type": "number"
              },
              "max": {
                "type": "number"
              },
              "step": {
                "type": "number"
              },
              "unit": {
                "type": "string"
              },
              "affects": {
                "type": "object",
                "properties": {
                  "criterionIds": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "optionIds": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "constraintIds": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "uncertaintyIds": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "assessmentKeys": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  }
                }
              },
              "mappingRules": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "targetType": {
                      "type": "string",
                      "enum": [
                        "constraint",
                        "criterion_weight",
                        "option_score",
                        "evidence"
                      ]
                    },
                    "targetId": {
                      "type": "string"
                    },
                    "subTargetId": {
                      "type": "string"
                    },
                    "transform": {
                      "type": "string",
                      "enum": [
                        "direct",
                        "scale_10",
                        "boolean_match"
                      ]
                    },
                    "valueMap": {
                      "type": "object"
                    }
                  },
                  "required": [
                    "targetType",
                    "targetId"
                  ]
                }
              },
              "requiredFor": {
                "type": "array",
                "items": {
                  "type": "string",
                  "enum": [
                    "review",
                    "recommend"
                  ]
                }
              }
            },
            "required": [
              "id",
              "prompt",
              "rationale",
              "selectionReason",
              "mappingPolicy"
            ]
          },
          "expectedRevision": {
            "type": "integer",
            "minimum": 1,
            "description": "Expected current revision for optimistic concurrency control"
          }
        },
        "required": [
          "question",
          "expectedRevision"
        ],
        "additionalProperties": true
      },
      "page": "/"
    }
    process_interview_answerAction

    Process an interview answer atomically: record answer, apply interpretation, update model patch (criteria/assessments/constraints/evidence/uncertainties), and optionally chain the next question in a single turn.

    View tool JSON
    {
      "name": "process_interview_answer",
      "kind": "act",
      "impl": "imperative",
      "description": "Process an interview answer atomically: record answer, apply interpretation, update model patch (criteria/assessments/constraints/evidence/uncertainties), and optionally chain the next question in a single turn.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "questionId": {
            "type": "string",
            "description": "ID of the question being answered"
          },
          "answer": {
            "description": "The answer value (primitive, array, or { kind: 'other', text: '...' })"
          },
          "interpretation": {
            "type": "object",
            "description": "Agent interpretation or note resolving the user's answer",
            "properties": {
              "summary": {
                "type": "string",
                "description": "Concise summary of how the answer was interpreted"
              },
              "completeness": {
                "type": "string",
                "enum": [
                  "complete",
                  "partial",
                  "clarification_needed"
                ]
              }
            }
          },
          "modelPatch": {
            "type": "object",
            "description": "Batch updates to criteria, assessments, constraints, evidence, or uncertainties",
            "properties": {
              "options": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string",
                      "description": "Unique option ID"
                    },
                    "name": {
                      "type": "string",
                      "description": "Display name of candidate option"
                    },
                    "description": {
                      "type": "string",
                      "description": "Optional detail/notes"
                    },
                    "attributes": {
                      "type": "object",
                      "description": "Structured key-value attributes for hard constraint evaluation"
                    }
                  },
                  "required": [
                    "id",
                    "name"
                  ]
                }
              },
              "criteria": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string",
                      "description": "Unique criterion ID"
                    },
                    "name": {
                      "type": "string",
                      "description": "Display name of criterion"
                    },
                    "description": {
                      "type": "string"
                    },
                    "weight": {
                      "type": "number",
                      "minimum": 1,
                      "maximum": 10,
                      "description": "Importance weight integer from 1 to 10"
                    },
                    "kind": {
                      "type": "string",
                      "enum": [
                        "objective",
                        "subjective",
                        "hybrid"
                      ]
                    }
                  },
                  "required": [
                    "id",
                    "name"
                  ]
                }
              },
              "assessments": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "optionId": {
                      "type": "string",
                      "description": "Target option ID"
                    },
                    "criterionId": {
                      "type": "string",
                      "description": "Target criterion ID"
                    },
                    "score": {
                      "type": [
                        "number",
                        "null"
                      ],
                      "minimum": 0,
                      "maximum": 10,
                      "description": "Score from 0 to 10 or null if unassessed"
                    },
                    "confidence": {
                      "type": "number",
                      "minimum": 0,
                      "maximum": 10,
                      "description": "Confidence score (0-10)"
                    },
                    "reason": {
                      "type": "string",
                      "description": "Grounding justification"
                    },
                    "evidenceIds": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      },
                      "description": "IDs of supporting evidence"
                    },
                    "sourceType": {
                      "type": "string",
                      "enum": [
                        "user",
                        "research",
                        "agent"
                      ]
                    }
                  },
                  "required": [
                    "optionId",
                    "criterionId",
                    "score"
                  ]
                }
              },
              "constraints": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "name": {
                      "type": "string"
                    },
                    "description": {
                      "type": "string"
                    },
                    "operator": {
                      "type": "string",
                      "enum": [
                        "eq",
                        "neq",
                        "gt",
                        "gte",
                        "lt",
                        "lte",
                        "in",
                        "contains"
                      ]
                    },
                    "expectedValue": {
                      "description": "Threshold or target value"
                    },
                    "required": {
                      "type": "boolean",
                      "description": "Hard constraint if true, soft preference if false"
                    },
                    "sourceQuestionId": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "name",
                    "operator",
                    "expectedValue"
                  ]
                }
              },
              "evidence": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "text": {
                      "type": "string",
                      "description": "Factual verified statement"
                    },
                    "sourceType": {
                      "type": "string",
                      "enum": [
                        "user",
                        "research"
                      ],
                      "description": "Origin provenance"
                    },
                    "sourceUrl": {
                      "type": "string"
                    },
                    "confidence": {
                      "type": "number",
                      "minimum": 0,
                      "maximum": 10
                    },
                    "relatedOptionId": {
                      "type": "string"
                    },
                    "relatedCriterionId": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "text",
                    "sourceType"
                  ]
                }
              },
              "uncertainties": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "question": {
                      "type": "string",
                      "description": "Key unresolved question"
                    },
                    "importance": {
                      "type": "number",
                      "minimum": 0,
                      "maximum": 10
                    },
                    "uncertainty": {
                      "type": "number",
                      "minimum": 0,
                      "maximum": 10
                    },
                    "plausibleImpact": {
                      "type": "number",
                      "minimum": 0,
                      "maximum": 10
                    },
                    "relatedOptionId": {
                      "type": "string"
                    },
                    "relatedCriterionId": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "question"
                  ]
                }
              }
            }
          },
          "nextQuestion": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string"
              },
              "prompt": {
                "type": "string"
              },
              "rationale": {
                "type": "string"
              },
              "selectionReason": {
                "type": "string",
                "description": "Mandatory justification explaining why this question is the highest-value step now"
              },
              "answerType": {
                "type": "string",
                "enum": [
                  "text",
                  "single_choice",
                  "multi_choice",
                  "number",
                  "currency",
                  "date",
                  "scale",
                  "boolean"
                ]
              },
              "mappingPolicy": {
                "type": "string",
                "enum": [
                  "deterministic",
                  "agent_required",
                  "evidence_only"
                ],
                "description": "How answers map to criteria, constraints, or evidence"
              },
              "choices": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "label": {
                      "type": "string"
                    },
                    "value": {
                      "description": "Underlying value for this choice"
                    },
                    "description": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "id",
                    "label",
                    "value"
                  ]
                }
              },
              "allowOther": {
                "type": "boolean",
                "description": "Allow user free-text / something else answer"
              },
              "otherLabel": {
                "type": "string"
              },
              "min": {
                "type": "number"
              },
              "max": {
                "type": "number"
              },
              "step": {
                "type": "number"
              },
              "unit": {
                "type": "string"
              },
              "affects": {
                "type": "object",
                "properties": {
                  "criterionIds": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "optionIds": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "constraintIds": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "uncertaintyIds": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  },
                  "assessmentKeys": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    }
                  }
                }
              },
              "mappingRules": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "targetType": {
                      "type": "string",
                      "enum": [
                        "constraint",
                        "criterion_weight",
                        "option_score",
                        "evidence"
                      ]
                    },
                    "targetId": {
                      "type": "string"
                    },
                    "subTargetId": {
                      "type": "string"
                    },
                    "transform": {
                      "type": "string",
                      "enum": [
                        "direct",
                        "scale_10",
                        "boolean_match"
                      ]
                    },
                    "valueMap": {
                      "type": "object"
                    }
                  },
                  "required": [
                    "targetType",
                    "targetId"
                  ]
                }
              },
              "requiredFor": {
                "type": "array",
                "items": {
                  "type": "string",
                  "enum": [
                    "review",
                    "recommend"
                  ]
                }
              }
            },
            "required": [
              "id",
              "prompt",
              "rationale",
              "selectionReason",
              "mappingPolicy"
            ]
          },
          "expectedRevision": {
            "type": "integer",
            "minimum": 1,
            "description": "Expected current revision for optimistic concurrency control"
          }
        },
        "required": [
          "questionId",
          "answer"
        ],
        "additionalProperties": true
      },
      "page": "/"
    }
    manage_interview_questionAction

    Manage interview question lifecycle: snooze (answer later), skip (with optional reason), or reopen a previously answered/skipped/snoozed question.

    View tool JSON
    {
      "name": "manage_interview_question",
      "kind": "act",
      "impl": "imperative",
      "description": "Manage interview question lifecycle: snooze (answer later), skip (with optional reason), or reopen a previously answered/skipped/snoozed question.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "questionId": {
            "type": "string",
            "description": "ID of the question to manage"
          },
          "action": {
            "type": "string",
            "enum": [
              "snooze",
              "skip",
              "reopen"
            ],
            "description": "Action to perform on the question"
          },
          "reason": {
            "type": "string",
            "description": "Optional explanation when skipping"
          },
          "expectedRevision": {
            "type": "integer",
            "minimum": 1,
            "description": "Expected current revision for optimistic concurrency control"
          }
        },
        "required": [
          "questionId",
          "action"
        ],
        "additionalProperties": true
      },
      "page": "/"
    }
    apply_decision_patchAction

    Apply batch model updates in a single atomic transaction across options, criteria, assessments, constraints, evidence, and uncertainties.

    View tool JSON
    {
      "name": "apply_decision_patch",
      "kind": "act",
      "impl": "imperative",
      "description": "Apply batch model updates in a single atomic transaction across options, criteria, assessments, constraints, evidence, and uncertainties.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "options": {
            "type": "array",
            "description": "Options to upsert",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string",
                  "description": "Unique option ID"
                },
                "name": {
                  "type": "string",
                  "description": "Display name of candidate option"
                },
                "description": {
                  "type": "string",
                  "description": "Optional detail/notes"
                },
                "attributes": {
                  "type": "object",
                  "description": "Structured key-value attributes for hard constraint evaluation"
                }
              },
              "required": [
                "id",
                "name"
              ]
            }
          },
          "criteria": {
            "type": "array",
            "description": "Criteria to upsert",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string",
                  "description": "Unique criterion ID"
                },
                "name": {
                  "type": "string",
                  "description": "Display name of criterion"
                },
                "description": {
                  "type": "string"
                },
                "weight": {
                  "type": "number",
                  "minimum": 1,
                  "maximum": 10,
                  "description": "Importance weight integer from 1 to 10"
                },
                "kind": {
                  "type": "string",
                  "enum": [
                    "objective",
                    "subjective",
                    "hybrid"
                  ]
                }
              },
              "required": [
                "id",
                "name"
              ]
            }
          },
          "assessments": {
            "type": "array",
            "description": "Assessments to upsert",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string"
                },
                "optionId": {
                  "type": "string",
                  "description": "Target option ID"
                },
                "criterionId": {
                  "type": "string",
                  "description": "Target criterion ID"
                },
                "score": {
                  "type": [
                    "number",
                    "null"
                  ],
                  "minimum": 0,
                  "maximum": 10,
                  "description": "Score from 0 to 10 or null if unassessed"
                },
                "confidence": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 10,
                  "description": "Confidence score (0-10)"
                },
                "reason": {
                  "type": "string",
                  "description": "Grounding justification"
                },
                "evidenceIds": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  },
                  "description": "IDs of supporting evidence"
                },
                "sourceType": {
                  "type": "string",
                  "enum": [
                    "user",
                    "research",
                    "agent"
                  ]
                }
              },
              "required": [
                "optionId",
                "criterionId",
                "score"
              ]
            }
          },
          "constraints": {
            "type": "array",
            "description": "Constraints to upsert",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string"
                },
                "name": {
                  "type": "string"
                },
                "description": {
                  "type": "string"
                },
                "operator": {
                  "type": "string",
                  "enum": [
                    "eq",
                    "neq",
                    "gt",
                    "gte",
                    "lt",
                    "lte",
                    "in",
                    "contains"
                  ]
                },
                "expectedValue": {
                  "description": "Threshold or target value"
                },
                "required": {
                  "type": "boolean",
                  "description": "Hard constraint if true, soft preference if false"
                },
                "sourceQuestionId": {
                  "type": "string"
                }
              },
              "required": [
                "name",
                "operator",
                "expectedValue"
              ]
            }
          },
          "evidence": {
            "type": "array",
            "description": "Evidence items to add/upsert",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string"
                },
                "text": {
                  "type": "string",
                  "description": "Factual verified statement"
                },
                "sourceType": {
                  "type": "string",
                  "enum": [
                    "user",
                    "research"
                  ],
                  "description": "Origin provenance"
                },
                "sourceUrl": {
                  "type": "string"
                },
                "confidence": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 10
                },
                "relatedOptionId": {
                  "type": "string"
                },
                "relatedCriterionId": {
                  "type": "string"
                }
              },
              "required": [
                "text",
                "sourceType"
              ]
            }
          },
          "uncertainties": {
            "type": "array",
            "description": "Uncertainties to add/upsert",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string"
                },
                "question": {
                  "type": "string",
                  "description": "Key unresolved question"
                },
                "importance": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 10
                },
                "uncertainty": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 10
                },
                "plausibleImpact": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 10
                },
                "relatedOptionId": {
                  "type": "string"
                },
                "relatedCriterionId": {
                  "type": "string"
                }
              },
              "required": [
                "question"
              ]
            }
          },
          "expectedRevision": {
            "type": "integer",
            "minimum": 1,
            "description": "Expected current revision for optimistic concurrency control"
          }
        },
        "required": [],
        "additionalProperties": true
      },
      "page": "/"
    }
    finalize_decisionAction

    Finalize the decision workspace: save recommendation, store agent summary, validate readiness, and synthesize the Decision Brief in one atomic call.

    View tool JSON
    {
      "name": "finalize_decision",
      "kind": "act",
      "impl": "imperative",
      "description": "Finalize the decision workspace: save recommendation, store agent summary, validate readiness, and synthesize the Decision Brief in one atomic call.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "status": {
            "type": "string",
            "enum": [
              "recommended",
              "lean_verify",
              "not_ready"
            ]
          },
          "optionId": {
            "type": "string",
            "description": "ID of the recommended option (mandatory if recommended or lean_verify)"
          },
          "confidence": {
            "type": "number",
            "minimum": 0,
            "maximum": 10,
            "description": "Confidence score out of 10"
          },
          "reason": {
            "type": "string",
            "description": "Short justification for the recommendation"
          },
          "agentSummary": {
            "type": "string",
            "description": "Agent-authored executive summary synthesized from the decision workspace"
          },
          "remainingUnknownIds": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "nextAction": {
            "type": "string",
            "description": "Concrete next step or verification task"
          },
          "kind": {
            "type": "string",
            "enum": [
              "provisional",
              "final"
            ],
            "description": "Brief kind to generate (default: 'final')"
          },
          "basedOnRevision": {
            "type": "integer",
            "minimum": 1,
            "description": "Revision of the decision state this recommendation is based on (mandatory)"
          },
          "expectedRevision": {
            "type": "integer",
            "minimum": 1,
            "description": "Expected current revision for optimistic concurrency control"
          }
        },
        "required": [
          "status",
          "confidence",
          "reason",
          "agentSummary",
          "basedOnRevision"
        ],
        "additionalProperties": true
      },
      "page": "/"
    }