Server definition

Hash: sha256:d0de0fb5d8802d08d8c02be9c9156a3067ce7f7a46ab87e120f086752dbaa6bd
What it is: What a remote MCP server returned when asked what it offers: 11 tools

The blob, as servednamed by its sha256

{
  "instructions": "PlanExe generates strategic project-plan drafts from a natural-language prompt. Output is a self-contained interactive HTML report (~700KB) with 20+ sections including executive summary, interactive Gantt charts, risk analysis, SWOT, governance, investor pitch, team profiles, work breakdown, scenario comparison, expert criticism, and adversarial sections (premortem, self-audit checklist, premise attacks) that stress-test whether the plan holds up. The output is a draft to refine, not final ground truth — but it surfaces hard questions the prompter may not have considered. Use PlanExe for substantial multi-phase projects with constraints, stakeholders, budgets, and timelines. Do not use PlanExe for tiny one-shot outputs (for example: 'give me a 5-point checklist'); use a normal LLM response for that. The planning pipeline is fixed end-to-end; callers cannot select individual internal pipeline steps to run. Required interaction order: call example_plans first (optional, to preview what PlanExe output looks like — curated example reports and zip bundles). Then call example_prompts. Optional before plan_create: call model_profiles to see profile guidance and available models in each profile. Then perform a non-tool step: draft a strong prompt as flowing prose (not structured markdown with headers or bullets), typically ~300-800 words, and get user approval. Good prompt shape: objective, scope, constraints, timeline, stakeholders, budget/resources, and success criteria. Write the prompt as flowing prose — weave specs, constraints, and targets naturally into sentences. Only after approval, call plan_create. Each plan_create call creates a new plan_id; the server does not enforce a global per-client concurrency limit. Then poll plan_status (about every 5 minutes) to check progress; use plan_file_info when complete. plan_status is the primary way to track progress — it returns structured JSON with progress_percentage, steps_completed/steps_total, and current_step. Optionally, run `curl -N <sse_url>` in a background shell as a completion detector — the stream auto-closes when the plan reaches a terminal state (completed/failed/stopped). If plan generation fails before completing all steps, call plan_resume to continue from where it left off without discarding completed work. Use plan_retry instead for a full restart (plan must be in failed state). Both accept a failed plan_id and optional model_profile (defaults to baseline). To stop, call plan_stop with the plan_id from plan_create; stopping is asynchronous and the plan will transition to the stopped state. If model_profiles returns MODEL_PROFILES_UNAVAILABLE, inform the user that no models are currently configured and the server administrator needs to set up model profiles. Tool errors use {error:{code,message}}. plan_file_info returns {ready:false,reason:...} while the artifact is not yet ready; check readiness by testing whether download_url is present in the response. plan_file_info download_url is the absolute URL where the requested artifact can be downloaded. To list recent plans for a user call plan_list; returns plan_id, state, progress_percentage, created_at, and prompt_excerpt for each plan. plan_status state contract: pending/processing => keep polling; completed => download is ready; failed => terminal error; stopped => user called plan_stop (consider plan_resume). Troubleshooting: if plan_status stays in pending for longer than 5 minutes, the plan was likely queued but not picked up by a worker (server issue). If plan_status is in processing and output files do not change for longer than 20 minutes, the plan_create likely failed/stalled. In both cases, report the issue to PlanExe developers on GitHub: https://github.com/PlanExeOrg/PlanExe/issues . Main output: a self-contained interactive HTML report (~700KB) with collapsible sections and interactive Gantt charts — open in a browser. The zip contains the intermediary pipeline files (md, json, csv) that fed the report. Use send_feedback to report issues or share observations about plan quality, workflow friction, or the MCP interface. Feedback is fire-and-forget and never blocks the workflow. New users: create an account and obtain an API key at https://home.planexe.org/ .",
  "tools": [
    {
      "description": "Returns a curated list of example plans with download links for reports and zip bundles. Use this to preview what PlanExe output looks like before creating your own plan. Especially useful when the user asks what the output looks like before committing to a plan. No API key required.",
      "inputSchema": {
        "properties": {},
        "title": "example_plansArguments",
        "type": "object"
      },
      "name": "example_plans",
      "outputSchema": {
        "$defs": {
          "ExamplePlanItem": {
            "properties": {
              "report_url": {
                "description": "URL to the static HTML report for this example plan.",
                "title": "Report Url",
                "type": "string"
              },
              "title": {
                "description": "Short title describing the example plan.",
                "title": "Title",
                "type": "string"
              },
              "zip_url": {
                "description": "URL to the zip bundle for this example plan.",
                "title": "Zip Url",
                "type": "string"
              }
            },
            "required": [
              "title",
              "report_url",
              "zip_url"
            ],
            "title": "ExamplePlanItem",
            "type": "object"
          }
        },
        "properties": {
          "message": {
            "title": "Message",
            "type": "string"
          },
          "plans": {
            "description": "Curated example plans with download links for reports and zip bundles.",
            "items": {
              "$ref": "#/$defs/ExamplePlanItem"
            },
            "title": "Plans",
            "type": "array"
          }
        },
        "required": [
          "plans",
          "message"
        ],
        "title": "ExamplePlansOutput",
        "type": "object"
      }
    },
    {
      "description": "Call this first. Returns example prompts that define what a good prompt looks like. Do NOT call plan_create yet. Optional before plan_create: call model_profiles to choose model_profile. Next is a non-tool step: formulate a detailed prompt (typically ~300-800 words; use examples as a baseline, similar structure) and get user approval. Good prompt shape: objective, scope, constraints, timeline, stakeholders, budget/resources, and success criteria. Write the prompt as flowing prose, not structured markdown with headers or bullet lists. Weave technical specs, constraints, and targets naturally into sentences. Include banned words/approaches and governance preferences inline. The examples demonstrate this prose style — match their tone and density. Then call plan_create. PlanExe is not for tiny one-shot outputs like a 5-point checklist; and it does not support selecting only some internal pipeline steps.",
      "inputSchema": {
        "properties": {},
        "title": "example_promptsArguments",
        "type": "object"
      },
      "name": "example_prompts",
      "outputSchema": {
        "properties": {
          "message": {
            "title": "Message",
            "type": "string"
          },
          "samples": {
            "description": "Example prompts that define the baseline for what a good prompt looks like. Take inspiration from these when writing your own prompt for plan_create (typically ~300-800 words). Good prompt shape: objective, scope, constraints, timeline, stakeholders, budget/resources, and success criteria.",
            "items": {
              "type": "string"
            },
            "title": "Samples",
            "type": "array"
          }
        },
        "required": [
          "samples",
          "message"
        ],
        "title": "ExamplePromptsOutput",
        "type": "object"
      }
    },
    {
      "description": "Optional helper before plan_create. Returns model_profile options with plain-language guidance and currently available models in each profile. If no models are available, returns error code MODEL_PROFILES_UNAVAILABLE.",
      "inputSchema": {
        "properties": {},
        "title": "model_profilesArguments",
        "type": "object"
      },
      "name": "model_profiles",
      "outputSchema": {
        "$defs": {
          "ModelProfileInfo": {
            "properties": {
              "model_count": {
                "description": "Number of models currently available in this profile.",
                "title": "Model Count",
                "type": "integer"
              },
              "models": {
                "description": "Models currently available to this profile.",
                "items": {
                  "$ref": "#/$defs/ModelProfileModelEntry"
                },
                "title": "Models",
                "type": "array"
              },
              "profile": {
                "description": "Model profile value accepted by plan_create.model_profile.",
                "enum": [
                  "baseline",
                  "premium",
                  "frontier",
                  "custom"
                ],
                "title": "Profile",
                "type": "string"
              },
              "summary": {
                "description": "Short profile guidance for callers.",
                "title": "Summary",
                "type": "string"
              },
              "title": {
                "description": "Human-friendly profile label.",
                "title": "Title",
                "type": "string"
              }
            },
            "required": [
              "profile",
              "title",
              "summary",
              "model_count",
              "models"
            ],
            "title": "ModelProfileInfo",
            "type": "object"
          },
          "ModelProfileModelEntry": {
            "properties": {
              "key": {
                "description": "Model key from llm_config/<profile>.json.",
                "title": "Key",
                "type": "string"
              },
              "model": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "null"
                  }
                ],
                "default": null,
                "description": "Provider model identifier when present.",
                "title": "Model"
              },
              "priority": {
                "anyOf": [
                  {
                    "type": "integer"
                  },
                  {
                    "type": "null"
                  }
                ],
                "default": null,
                "description": "Priority from config (lower number means earlier in selection order).",
                "title": "Priority"
              },
              "provider_class": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "null"
                  }
                ],
                "default": null,
                "description": "Provider class (for example OpenRouter, OpenAI, Ollama).",
                "title": "Provider Class"
              }
            },
            "required": [
              "key"
            ],
            "title": "ModelProfileModelEntry",
            "type": "object"
          }
        },
        "properties": {
          "default_profile": {
            "description": "Default model profile used when plan_create.model_profile is omitted/invalid.",
            "enum": [
              "baseline",
              "premium",
              "frontier",
              "custom"
            ],
            "title": "Default Profile",
            "type": "string"
          },
          "message": {
            "description": "Caller guidance for selecting plan_create.model_profile.",
            "title": "Message",
            "type": "string"
          },
          "profiles": {
            "description": "Available profile options and their model inventory.",
            "items": {
              "$ref": "#/$defs/ModelProfileInfo"
            },
            "title": "Profiles",
            "type": "array"
          }
        },
        "required": [
          "default_profile",
          "profiles",
          "message"
        ],
        "title": "ModelProfilesOutput",
        "type": "object"
      }
    },
    {
      "description": "Call only after example_prompts and after you have completed prompt drafting/approval (non-tool step). PlanExe turns the approved prompt into a strategic project-plan draft (20+ sections) in ~10-20 min. Sections include: executive summary, interactive Gantt charts, investor pitch, project plan with SMART criteria, strategic decision analysis, scenario comparison, assumptions with expert review, governance structure, SWOT analysis, team role profiles, simulated expert criticism, work breakdown structure, plan review (critical issues, KPIs, financial strategy, automation opportunities), Q&A, premortem with failure scenarios, self-audit checklist, and adversarial premise attacks that argue against the project. The adversarial sections (premortem, self-audit, premise attacks) surface risks and questions the prompter may not have considered. Returns plan_id (UUID); use it for plan_status, plan_stop, plan_retry, and plan_file_info. To track progress, poll plan_status at reasonable intervals (e.g. every 5 minutes). Optionally, run `curl -N <sse_url>` in a background shell as a completion detector — the stream auto-closes on terminal state (completed/failed/stopped). If you lose a plan_id, call plan_list to recover it. If the same prompt + model_profile is submitted by the same user within a short window, the existing plan is returned (with deduplicated=true) instead of creating a new one. If you are unsure which model_profile to choose, call model_profiles first. If your deployment uses credits, include user_api_key to charge the correct account. Common error codes: INVALID_USER_API_KEY, USER_API_KEY_REQUIRED, INSUFFICIENT_CREDITS.",
      "inputSchema": {
        "properties": {
          "model_profile": {
            "default": "baseline",
            "description": "Model profile: baseline, premium, frontier, custom. Call model_profiles to inspect options.",
            "enum": [
              "baseline",
              "premium",
              "frontier",
              "custom"
            ],
            "title": "Model Profile",
            "type": "string"
          },
          "prompt": {
            "title": "Prompt",
            "type": "string"
          },
          "start_date": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional plan start date in ISO 8601 format with timezone offset (e.g. '2025-06-15T09:00:00+02:00'). When omitted, the plan starts now. Use this to set a past or future start date for the plan.",
            "title": "Start Date"
          }
        },
        "required": [
          "prompt"
        ],
        "title": "plan_createArguments",
        "type": "object"
      },
      "name": "plan_create",
      "outputSchema": {
        "properties": {
          "created_at": {
            "title": "Created At",
            "type": "string"
          },
          "deduplicated": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "True when this response returns an existing plan instead of creating a new one (duplicate prompt + model_profile by the same user within the dedup window). Absent or None for newly created plans.",
            "title": "Deduplicated"
          },
          "plan_id": {
            "description": "Plan UUID returned by plan_create. Stable across plan_status/plan_stop/plan_file_info.",
            "title": "Plan Id",
            "type": "string"
          },
          "sse_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional completion detector. Run `curl -N <sse_url>` in a background shell — the stream auto-closes when the plan reaches a terminal state (completed/failed/stopped). For structured progress data, use plan_status instead.",
            "title": "Sse Url"
          }
        },
        "required": [
          "plan_id",
          "created_at"
        ],
        "title": "PlanCreateOutput",
        "type": "object"
      }
    },
    {
      "description": "Returns file metadata (content_type, download_url, download_size, expires_at) for the report or zip artifact. Use artifact='report' (default) for the interactive HTML report (~700KB, self-contained with embedded JS for collapsible sections and interactive Gantt charts — open in a browser). Use artifact='zip' for the full pipeline output bundle (md, json, csv intermediary files that fed the report). While the task is still pending or processing, returns {ready:false,reason:\"processing\"}. Check readiness by testing whether download_url is present in the response. Once ready, present download_url to the user or fetch and save the file locally. Download URLs expire after 15 minutes (see expires_at); call plan_file_info again to get a fresh URL if needed. Terminal error codes: generation_failed (plan failed), content_unavailable (artifact missing). Unknown plan_id returns error code PLAN_NOT_FOUND.",
      "inputSchema": {
        "properties": {
          "artifact": {
            "default": "report",
            "description": "Download artifact type: report or zip.",
            "enum": [
              "report",
              "zip"
            ],
            "title": "Artifact",
            "type": "string"
          },
          "plan_id": {
            "description": "Plan UUID returned by plan_create. Use it to download the created plan.",
            "title": "Plan Id",
            "type": "string"
          }
        },
        "required": [
          "plan_id"
        ],
        "title": "plan_file_infoArguments",
        "type": "object"
      },
      "name": "plan_file_info",
      "outputSchema": null
    },
    {
      "description": "List the most recent plans for an authenticated user. Returns up to `limit` plans (default 10, max 50) newest-first, each with plan_id, state, progress_percentage, created_at (ISO 8601), and a prompt_excerpt (first 100 chars). Use this to recover a lost plan_id or to review recent activity.",
      "inputSchema": {
        "properties": {
          "limit": {
            "default": 10,
            "description": "Maximum number of plans to return (1–50). Newest plans are returned first.",
            "maximum": 50,
            "minimum": 1,
            "title": "Limit",
            "type": "integer"
          }
        },
        "title": "plan_listArguments",
        "type": "object"
      },
      "name": "plan_list",
      "outputSchema": {
        "$defs": {
          "PlanListItem": {
            "properties": {
              "created_at": {
                "description": "UTC creation timestamp (ISO 8601).",
                "title": "Created At",
                "type": "string"
              },
              "plan_id": {
                "description": "Plan UUID.",
                "title": "Plan Id",
                "type": "string"
              },
              "progress_percentage": {
                "description": "Progress from 0 to 100.",
                "title": "Progress Percentage",
                "type": "number"
              },
              "prompt_excerpt": {
                "description": "First 100 characters of the prompt.",
                "title": "Prompt Excerpt",
                "type": "string"
              },
              "state": {
                "description": "Current plan state.",
                "enum": [
                  "pending",
                  "processing",
                  "completed",
                  "failed",
                  "stopped"
                ],
                "title": "State",
                "type": "string"
              }
            },
            "required": [
              "plan_id",
              "state",
              "progress_percentage",
              "created_at",
              "prompt_excerpt"
            ],
            "title": "PlanListItem",
            "type": "object"
          }
        },
        "properties": {
          "message": {
            "description": "Human-readable summary (e.g. how many plans were returned).",
            "title": "Message",
            "type": "string"
          },
          "plans": {
            "description": "Plans for the authenticated user, newest first.",
            "items": {
              "$ref": "#/$defs/PlanListItem"
            },
            "title": "Plans",
            "type": "array"
          }
        },
        "required": [
          "plans",
          "message"
        ],
        "title": "PlanListOutput",
        "type": "object"
      }
    },
    {
      "description": "Resume a failed or stopped plan without discarding completed intermediary files. Plan generation restarts from the first incomplete step, skipping all steps that already produced output files. Use plan_resume when plan_status shows 'failed' or 'stopped' and plan generation was interrupted before completing all steps (network drop, timeout, plan_stop, worker crash). For a full restart or to change model_profile, use plan_retry instead. Only failed or stopped plans can be resumed. Returns PLAN_NOT_FOUND when plan_id is unknown and PLAN_NOT_RESUMABLE when the plan is not in failed or stopped state. Returns PIPELINE_VERSION_MISMATCH when the snapshot was created by a different pipeline version; use plan_retry instead.",
      "inputSchema": {
        "properties": {
          "model_profile": {
            "default": "baseline",
            "description": "Model profile used for the resumed plan. Defaults to baseline.",
            "enum": [
              "baseline",
              "premium",
              "frontier",
              "custom"
            ],
            "title": "Model Profile",
            "type": "string"
          },
          "plan_id": {
            "description": "UUID of the failed plan to resume.",
            "title": "Plan Id",
            "type": "string"
          }
        },
        "required": [
          "plan_id"
        ],
        "title": "plan_resumeArguments",
        "type": "object"
      },
      "name": "plan_resume",
      "outputSchema": {
        "$defs": {
          "ErrorDetail": {
            "properties": {
              "code": {
                "title": "Code",
                "type": "string"
              },
              "details": {
                "anyOf": [
                  {
                    "additionalProperties": true,
                    "type": "object"
                  },
                  {
                    "type": "null"
                  }
                ],
                "default": null,
                "title": "Details"
              },
              "message": {
                "title": "Message",
                "type": "string"
              }
            },
            "required": [
              "code",
              "message"
            ],
            "title": "ErrorDetail",
            "type": "object"
          }
        },
        "properties": {
          "error": {
            "anyOf": [
              {
                "$ref": "#/$defs/ErrorDetail"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "model_profile": {
            "anyOf": [
              {
                "enum": [
                  "baseline",
                  "premium",
                  "frontier",
                  "custom"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Model profile assigned to the resumed run.",
            "title": "Model Profile"
          },
          "plan_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Plan UUID that was resumed (same ID as the failed or stopped plan).",
            "title": "Plan Id"
          },
          "resume_count": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Number of times this plan has been resumed.",
            "title": "Resume Count"
          },
          "resumed_at": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "UTC timestamp when the resume request was accepted.",
            "title": "Resumed At"
          },
          "sse_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional completion detector. Run `curl -N <sse_url>` in a background shell — the stream auto-closes when the plan reaches a terminal state (completed/failed/stopped). For structured progress data, use plan_status instead.",
            "title": "Sse Url"
          },
          "state": {
            "anyOf": [
              {
                "enum": [
                  "pending",
                  "processing",
                  "completed",
                  "failed",
                  "stopped"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Current plan state after resume request.",
            "title": "State"
          }
        },
        "title": "PlanResumeOutput",
        "type": "object"
      }
    },
    {
      "description": "Retry a plan that is currently in failed or stopped state. Pass the plan_id and optionally model_profile (defaults to baseline). The plan is reset to pending, prior artifacts are cleared, and the same plan_id is requeued for processing. Returns PLAN_NOT_FOUND when plan_id is unknown and PLAN_NOT_FAILED when the plan is not in failed or stopped state.",
      "inputSchema": {
        "properties": {
          "model_profile": {
            "default": "baseline",
            "description": "Model profile used for retry. Defaults to baseline.",
            "enum": [
              "baseline",
              "premium",
              "frontier",
              "custom"
            ],
            "title": "Model Profile",
            "type": "string"
          },
          "plan_id": {
            "description": "UUID of the failed plan to retry.",
            "title": "Plan Id",
            "type": "string"
          }
        },
        "required": [
          "plan_id"
        ],
        "title": "plan_retryArguments",
        "type": "object"
      },
      "name": "plan_retry",
      "outputSchema": {
        "$defs": {
          "ErrorDetail": {
            "properties": {
              "code": {
                "title": "Code",
                "type": "string"
              },
              "details": {
                "anyOf": [
                  {
                    "additionalProperties": true,
                    "type": "object"
                  },
                  {
                    "type": "null"
                  }
                ],
                "default": null,
                "title": "Details"
              },
              "message": {
                "title": "Message",
                "type": "string"
              }
            },
            "required": [
              "code",
              "message"
            ],
            "title": "ErrorDetail",
            "type": "object"
          }
        },
        "properties": {
          "error": {
            "anyOf": [
              {
                "$ref": "#/$defs/ErrorDetail"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "model_profile": {
            "anyOf": [
              {
                "enum": [
                  "baseline",
                  "premium",
                  "frontier",
                  "custom"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Model profile assigned to the retry request.",
            "title": "Model Profile"
          },
          "plan_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Plan UUID that was retried (same ID as the failed or stopped plan).",
            "title": "Plan Id"
          },
          "retried_at": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "UTC timestamp when the retry request was accepted.",
            "title": "Retried At"
          },
          "sse_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional completion detector. Run `curl -N <sse_url>` in a background shell — the stream auto-closes when the plan reaches a terminal state (completed/failed/stopped). For structured progress data, use plan_status instead.",
            "title": "Sse Url"
          },
          "state": {
            "anyOf": [
              {
                "enum": [
                  "pending",
                  "processing",
                  "completed",
                  "failed",
                  "stopped"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Current plan state after retry request.",
            "title": "State"
          }
        },
        "title": "PlanRetryOutput",
        "type": "object"
      }
    },
    {
      "description": "Returns status and progress of the plan currently being created. This is the primary way to check progress — it returns structured JSON with all progress fields. Poll at reasonable intervals (e.g. every 5 minutes): plan generation typically takes 10-20 minutes (baseline profile) and may take longer on higher-quality profiles. State contract: pending/processing => keep polling; completed => download is ready; failed => terminal error; stopped => user called plan_stop (consider plan_resume). progress_percentage is 0-100 (integer-like float); 100 when completed. Note: steps vary in duration — early steps complete quickly while later steps (review, report generation) take longer. Do not use progress_percentage to estimate time remaining. steps_completed and steps_total give the number of plan generation steps completed and expected (both nullable). current_step is the human-readable label of the most recently completed step (e.g. 'SWOT Analysis'). timing.last_progress_at is an ISO 8601 timestamp of the last progress update (null until the first worker update); use it to compute time-since-last-progress and detect stalls — a gap > 10 minutes with no progress change is a strong stall signal. files lists the most recent 10 intermediate outputs produced so far (files_count gives the total); use their updated_at timestamps as a secondary stall signal. When state is 'failed', the response includes an error dict with failure diagnostics: error.failure_reason (category: generation_error, worker_error, inactivity_timeout, internal_error, version_mismatch), error.failed_step (pipeline step active at failure), error.message (human-readable message), and error.recoverable (true => plan_resume may work, false => use plan_retry). The error dict is absent for non-failed states. Unknown plan_id returns error code PLAN_NOT_FOUND. Troubleshooting: pending for >5 minutes likely means queued but not picked up by a worker. processing with timing.last_progress_at unchanged for >10 minutes likely means stalled — call plan_stop then plan_retry. Fall back to file updated_at timestamps if last_progress_at is null. Report these issues to https://github.com/PlanExeOrg/PlanExe/issues .",
      "inputSchema": {
        "properties": {
          "plan_id": {
            "description": "Plan UUID returned by plan_create.",
            "title": "Plan Id",
            "type": "string"
          }
        },
        "required": [
          "plan_id"
        ],
        "title": "plan_statusArguments",
        "type": "object"
      },
      "name": "plan_status",
      "outputSchema": null
    },
    {
      "description": "Request the plan generation to stop. Pass the plan_id (the UUID returned by plan_create). Stopping is asynchronous: the stop flag is set immediately but the plan may continue briefly before halting. A stopped plan will transition to the stopped state. If the plan is already completed or failed, stop_requested returns false (the plan already finished). Unknown plan_id returns error code PLAN_NOT_FOUND.",
      "inputSchema": {
        "properties": {
          "plan_id": {
            "description": "Plan UUID returned by plan_create. Use it to stop the plan creation.",
            "title": "Plan Id",
            "type": "string"
          }
        },
        "required": [
          "plan_id"
        ],
        "title": "plan_stopArguments",
        "type": "object"
      },
      "name": "plan_stop",
      "outputSchema": {
        "$defs": {
          "ErrorDetail": {
            "properties": {
              "code": {
                "title": "Code",
                "type": "string"
              },
              "details": {
                "anyOf": [
                  {
                    "additionalProperties": true,
                    "type": "object"
                  },
                  {
                    "type": "null"
                  }
                ],
                "default": null,
                "title": "Details"
              },
              "message": {
                "title": "Message",
                "type": "string"
              }
            },
            "required": [
              "code",
              "message"
            ],
            "title": "ErrorDetail",
            "type": "object"
          }
        },
        "properties": {
          "error": {
            "anyOf": [
              {
                "$ref": "#/$defs/ErrorDetail"
              },
              {
                "type": "null"
              }
            ],
            "default": null
          },
          "state": {
            "anyOf": [
              {
                "enum": [
                  "pending",
                  "processing",
                  "completed",
                  "failed",
                  "stopped"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Current plan state after stop request.",
            "title": "State"
          },
          "stop_requested": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "True when stop request flag was set for a pending/processing task.",
            "title": "Stop Requested"
          }
        },
        "title": "PlanStopOutput",
        "type": "object"
      }
    },
    {
      "description": "Submit feedback about PlanExe — issues, impressions, or suggestions. Callable at any point in the workflow; fire-and-forget, never blocks. Use category to classify: mcp (MCP tools, SSE, plan_status, workflow), plan (the generated output files), code (PlanExe source), docs (documentation), other. Optionally attach to a plan via plan_id. Use rating (1-5) for sentiment: 1=strong negative, 3=neutral, 5=strong positive. Especially useful for reporting: SSE streams that close before plan completion, plan_status returning stale or inconsistent data, queue delays where workers are slow to pick up plans, and impressions of plan output quality after reviewing reports. Include specific details (plan_id, percentages, timestamps) when reporting issues.",
      "inputSchema": {
        "properties": {
          "category": {
            "description": "Feedback category: mcp, plan, code, docs, or other.",
            "title": "Category",
            "type": "string"
          },
          "message": {
            "description": "Free-text feedback. Include environment context if reporting an issue.",
            "title": "Message",
            "type": "string"
          },
          "plan_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional plan UUID to attach this feedback to.",
            "title": "Plan Id"
          },
          "rating": {
            "anyOf": [
              {
                "maximum": 5,
                "minimum": 1,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Sentiment: 1=strong negative, 2=weak negative, 3=neutral, 4=weak positive, 5=strong positive.",
            "title": "Rating"
          }
        },
        "required": [
          "category",
          "message"
        ],
        "title": "send_feedbackArguments",
        "type": "object"
      },
      "name": "send_feedback",
      "outputSchema": {
        "properties": {
          "feedback_id": {
            "description": "Server-generated UUID for this feedback entry.",
            "title": "Feedback Id",
            "type": "string"
          },
          "message": {
            "description": "Confirmation message.",
            "title": "Message",
            "type": "string"
          },
          "received_at": {
            "description": "UTC timestamp when the feedback was received (ISO 8601).",
            "title": "Received At",
            "type": "string"
          }
        },
        "required": [
          "feedback_id",
          "received_at",
          "message"
        ],
        "title": "SendFeedbackOutput",
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:d0de0fb5d8802d08d8c02be9c9156a3067ce7f7a46ab87e120f086752dbaa6bd | sha256sum