Skip to content

Shoot Plan MCP server

uk.co.theamateur/shoot-plantheamateur.co.ukstreamable-httpv0.1.1Scanned

Practical filming plans for AI assistants, with tools to draft, check and export shot plans.

34 tools: 1 can delete or cancel things, 1 do something that can't be undone, 20 change things and 12 only read.

Tools: 1 delete, 1 irreversible, 20 write, 12 read.
  • Reads private data · 0
  • Reads text others write · 1
  • Can send data out · 0
  • 7 findings

Tools listed without sign-in. Remote posture

With Anlyon

1 tool here can delete or cancel things and 1 does something that can't be undone. Govern them.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the Shoot Plan MCP server can do

The Shoot Plan MCP server is published by theamateur.co.uk, a domain the MCP Registry verified. It has 34 tools. It can delete or cancel things (1 tool: shoot_plan_revise), do things that cannot be undone, such as sending, paying or publishing (shoot_plan_merge_takes) and create or change data (20 tools: shoot_plan_quote, shoot_plan_create, shoot_plan_timing, shoot_plan_progress_sync and 16 more). 12 tools only read.

1 tool brings in text other people can write (shoot_plan_get).

The fixed checks matched 7 findings (annotation-conflict). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in, and its tools changed once since Anlyon Radar first saw them.

Last scanned Nov 9, 2026, version 0.1.1.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

34 tools

Deletes or cancels 1Claude Code: deny
  • shoot_plan_reviseUse the plan's one included revision.No findings

    Why it is in this group

    • The description says "cannot be undone".
    • The server marks it destructive (destructiveHint: true).
    Description, as the server wrote it
    Use the plan's one included revision. This cannot be undone and uses up that revision, so call shoot_plan_revision_preview first and confirm with the person. For structured plans, change filming time or transfer time (constraintUpdates.availableMinutes, locationTransferMinutes), framing, or structuredChanges. Use the full taskId from shoot_plan_list (not planId). A unique eight-character task prefix or orderReference also works. Connections see only their own live or owner-test plans.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: false
Can't be undone 1Claude Code: ask
  • shoot_plan_merge_takesJoins two take logs for the same film into one, for when two phones, an AI assistant and a script supervisor each kept a log while offline.1 finding

    Why it is in this group

    • The name "shoot_plan_merge_takes" says "merge": a word for a change that another call does not undo.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "shoot_plan_merge_takes" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_merge_takes" says "merge": a word for a change that another call does not undo.

      What this check looks for
    Description, as the server wrote it
    Joins two take logs for the same film into one, for when two phones, an AI assistant and a script supervisor each kept a log while offline. Joining is by op_id, so a take that is in both logs counts once and merging again changes nothing. Where two logs hold different takes under one op_id, only one is kept and the clash is counted, with a fix: give one of them an op_id of its own. The tools take text only, never video or audio, and no AI model runs. Input: a and b, two dpl.takes/1 objects. Output: {takes, merge}: takes is the joined dpl.takes/1 log; merge has added, already_present and conflicts: the counts of entries new to the joined log, entries that were in both, and entries that clashed (a count can be null if the engine did not send it). When conflicts is above 0, merge.conflict_fix says what to do: look before you trust the joined log. We don't keep either take log. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
Changes things 20Claude Code: ask
  • shoot_plan_allowanceSays what this account has used and has left of its monthly project allowance, the date it starts again, and, when the limit is reached, how to carry on sooner.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Says what this account has used and has left of its monthly project allowance, the date it starts again, and, when the limit is reached, how to carry on sooner. A project is identified by the plan's work id and title: the same id and title is one project, and changing either starts a new one. It counts when a tool that makes a finished document (shot list, generation briefs, call sheet, shoot-day pack, edit guide, edit file) first makes one for it that month. Drafting, checking and fixing never count, and a project that already had a finished document made this month stays open all month, up to the fair-use limit. A fair-use limit also applies: up to 20 finished-document calls for any one project and 60 for the account each month. Call this before starting a project if you want to know whether a finished document will be available. Input: none. Output: shoot-plan.allowance/1 with projects_used, projects_allowed, projects_left, resets_on and a message. The allowance belongs to the account, not the key, so a new key does not reset it. Needs an agent key from a Shoot Plan account. No AI model runs. This tool never counts toward the allowance. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_apply_fixApplies one fix, taken from a shoot_plan_check result, to a plan and checks the revised plan again.1 finding

    Why it is in this group

    • The name "shoot_plan_apply_fix" says "apply": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "shoot_plan_apply_fix" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_apply_fix" says "apply": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Applies one fix, taken from a shoot_plan_check result, to a plan and checks the revised plan again. Some fixes trade one thing for another (each says its trade_off): tell your human before applying one that does. Input: plan; finding_id and fix_id (a finding's id, and the id of one of its suggestions, both from shoot_plan_check); and optionally findings, the check result you already have, which saves recomputing it. Output: {plan, findings}, the revised plan and its new findings. Nothing is stored, here or by us: keep the revised plan yourself. A wrong finding_id or fix_id is refused with the ids that exist. No AI model runs. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_call_sheetMakes the call sheet for a shoot from a plan's schedule: for the whole schedule, or for one shoot day, who is called, where and when, with the set-ups in order.1 finding

    Why it is in this group

    • The name "shoot_plan_call_sheet" says "call": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "shoot_plan_call_sheet" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_call_sheet" says "call": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Makes the call sheet for a shoot from a plan's schedule: for the whole schedule, or for one shoot day, who is called, where and when, with the set-ups in order. A plan with no schedule has no times, and the call sheet says so rather than inventing any. Input: plan, a dpl.plan/1 object that validates; optionally day, the id of one day in the plan's schedule (a day the plan does not have is refused, and the refusal lists the days it has). Output: dpl.call-sheet/1. No AI model runs; we don't keep the plan. Needs an agent key from a Shoot Plan account, and is free up to 3 projects a month. A project is identified by the plan's work id and title; it counts when this tool first makes a finished document for it that month. shoot_plan_allowance says what is left. Over the limit it answers ALLOWANCE_REACHED: do not retry, a new key will not help, tell your human. A fair-use limit also applies: up to 20 finished-document calls for any one project and 60 for the account each month. To count projects we keep, against your account, a one-way fingerprint (hash) of the project's id and title, the month, how many finished documents were made and when, for 13 months after the end of that month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_checkChecks whether a shot plan will cut together before you film or generate it.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Checks whether a shot plan will cut together before you film or generate it. It looks for crossed lines of action, mismatched eyelines, missing reactions, speakers who are never on screen, missing geography, jump cuts, travel direction, and props that change with no cause. It returns evidence from the plan and fixes it has already tested. The check is instant, and no AI model runs. It checks editing craft, not whether the film is good. Scenes without staging, dialogue or coverage detail come back "not assessed": call shoot_plan_missing_details for the questions to ask your human. Input: plan, a dpl.plan/1 object sent inline (call shoot_plan_format first if you have not written one). Optionally dispositions, the decision log that shoot_plan_record_decision gave you: a finding you decided about earlier, whose evidence has not changed, comes back closed with your reason, and one whose evidence has changed comes back open again (the answer then also says dispositions_applied: how many decisions were applied, reopened or matched no finding). Without dispositions the answer is the same as ever. Output: dpl.findings/1 with stable finding ids, plan_hash, rules_version, any not_assessed scenes and, per finding, its tested fixes (apply one with shoot_plan_apply_fix). A plan that does not validate gets dpl.diagnostics/1 instead: each problem with its path and a fix. We don't keep the plan. We log a one-way fingerprint (hash) of it, its size, the tool, the type of client, the result and the time taken. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_createCreate a plan for an authenticated organisation after authoritative payment confirmation.No findings

    Why it is in this group

    • The name "shoot_plan_create" says "create": a word for a change.
    Description, as the server wrote it
    Create a plan for an authenticated organisation after authoritative payment confirmation.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • shoot_plan_draft_gateThe final check on a drafted plan: is it finished and ready to shoot?No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    The final check on a drafted plan: is it finished and ready to shoot? It returns ready or not ready, with a record of what was checked and what was not. A plan that does not pass gets a normal answer, not an error: the reasons are the next actions, each with its plan path and a fix. A pass is the result to show your human. It holds the plan to the format and to editing readiness, not to taste. No AI model runs. Input: plan, a dpl.plan/1 object. Output: dpl.draft-gate/1 with passed (true or false), result (ready_to_shoot or not_ready), the reasons and counts, and next_tool, the tool to call next. The engine's own wording may name its command line: ignore that and follow next_tool, which names the tool to call next and what to send. We don't keep the plan. We log a one-way fingerprint (hash) of it, its size, the tool, the type of client, the result and the time taken. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_draft_nextSays where a draft stands and the one next thing to do, so you can write a plan layer by layer and have each layer checked as you go.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Says where a draft stands and the one next thing to do, so you can write a plan layer by layer and have each layer checked as you go. It reads the plan you send and never changes it. It returns the layer you have reached, what that layer still lacks as exact plan paths, the questions to put to your human (answer "none" in the plan when none is the honest answer; never invent a detail), the open findings of finished layers with tested fixes, and which recipe fits each scene that has no shots yet. It is quick: call it after every layer or scene. No AI model runs. Input: plan, the draft so far (a dpl.plan/1 object); optionally brief, the same brief you gave shoot_plan_draft_start (it can be used to check the runtime). Output: dpl.draft-next/1, and next_tool, the tool to call next (when the next action is to run the gate, it is shoot_plan_draft_gate). Follow next_tool. The engine's own wording may name its command line: ignore that and follow next_tool, which names the tool to call next and what to send. We don't keep the plan. We log a one-way fingerprint (hash) of it, its size, the tool, the type of client, the result and the time taken. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_draft_startStarts a shot plan for you to write: from a short brief it returns a valid skeleton plan (the places to write start with TODO), the layers to write it in, shot-pattern recipes for …1 finding

    Why it is in this group

    • The name "shoot_plan_draft_start" says "start": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "shoot_plan_draft_start" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_draft_start" says "start": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Starts a shot plan for you to write: from a short brief it returns a valid skeleton plan (the places to write start with TODO), the layers to write it in, shot-pattern recipes for common kinds of scene, and the first thing to do. The loop is: you write the plan, we check it. We write none of the film and no AI model runs. The brief is sent to us only to build the skeleton, and we don't keep it. Input: brief, a dpl.brief/1 object: title, target_runtime_ms and profile ("film", or "short" for a phone or small-crew shoot), and optionally logline, thesis, characters, places and, for a short, delivery, kit, people and shoot_window. Output: dpl.draft/1, with a skeleton plan that already validates, and next_tool, the tool to call next. Write the first layer into the plan, then follow next_tool. The engine's own wording may name its command line: ignore that and follow next_tool, which names the tool to call next and what to send. A brief with a mistake is refused with each problem and its fix. We don't keep the brief. We log a one-way fingerprint (hash) of it, its size, the tool, the type of client, the result and the time taken. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_edit_guideWrites the editing guide for a film, scene by scene: what each shot is for, where to cut and why, which cutaway or insert covers which jump or crossed line, the sound to lay, and e…1 finding

    Why it is in this group

    • The name "shoot_plan_edit_guide" says "edit": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "shoot_plan_edit_guide" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_edit_guide" says "edit": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Writes the editing guide for a film, scene by scene: what each shot is for, where to cut and why, which cutaway or insert covers which jump or crossed line, the sound to lay, and each open finding as a note about what to do in the edit. With a take log it also says which take stands for each shot and marks shots that have no usable take; without one it works from the plan alone. The tools take text only, never video or audio, and no AI model runs. Input: plan; optionally takes (a dpl.takes/1 log). Output: dpl.edit-guide/1, as JSON. We don't keep the plan or the take log. Needs an agent key from a Shoot Plan account, and is free up to 3 projects a month. A project is identified by the plan's work id and title; it counts when this tool first makes a finished document for it that month. shoot_plan_allowance says what is left. Over the limit it answers ALLOWANCE_REACHED: do not retry, a new key will not help, tell your human. A fair-use limit also applies: up to 20 finished-document calls for any one project and 60 for the account each month. To count projects we keep, against your account, a one-way fingerprint (hash) of the project's id and title, the month, how many finished documents were made and when, for 13 months after the end of that month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_export_editMakes a first assembly edit from the plan and the take log, as a file your own editing software opens: OpenTimelineIO (otio), FCPXML (fcpxml), a CMX 3600 edit decision list (edl) o…1 finding

    Why it is in this group

    • The name "shoot_plan_export_edit" says "edit": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "shoot_plan_export_edit" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_export_edit" says "edit": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Makes a first assembly edit from the plan and the take log, as a file your own editing software opens: OpenTimelineIO (otio), FCPXML (fcpxml), a CMX 3600 edit decision list (edl) or an ALE log (ale). It puts the chosen takes in story order, each as long as the plan's slot (a shot with no usable take is left as a gap and listed in the report), linked by your human's own file names so they relink to footage on their own drives. No media is uploaded to us and none comes back; no AI model runs. Input: plan; takes (a dpl.takes/1 log); format (otio, fcpxml, edl or ale); optionally fps (24, 25, 23.976 or 29.97, a number or text; 24 if left out), drop_frame (true or false), media_root (the folder the footage is in, for relinking) and sync_sound (true by default). Output: {format, media_type, file_name, content, report, more_files?}. Save content as file_name. report lists the files to relink, the gaps, any warnings and what the chosen format cannot carry; an EDL is one file for each track, so any further files are in more_files, in order. We don't keep the plan or the take log. Needs an agent key from a Shoot Plan account, and is free up to 3 projects a month. A project is identified by the plan's work id and title; it counts when this tool first makes a finished document for it that month. shoot_plan_allowance says what is left. Over the limit it answers ALLOWANCE_REACHED: do not retry, a new key will not help, tell your human. A fair-use limit also applies: up to 20 finished-document calls for any one project and 60 for the account each month. To count projects we keep, against your account, a one-way fingerprint (hash) of the project's id and title, the month, how many finished documents were made and when, for 13 months after the end of that month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_export_for_generationPrepares a plan for generating its pictures with a generator of your own: it returns the editorial intent of the film (eil.intent/1) and one generation brief per shot (eil.generati…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Prepares a plan for generating its pictures with a generator of your own: it returns the editorial intent of the film (eil.intent/1) and one generation brief per shot (eil.generation-briefs/1). We run no generator and receive no media: you give the briefs to your own. Input: plan; optional sequence and sequence_revision (names for the sequence the intent describes), visual_family (a term for the kind of picture the sequence is made of; the default is a_roll) and house_style (an object, for the briefs). Output: {intent, briefs}. A plan with validation errors is refused with its diagnostics. No AI model runs. We don't keep the plan. Needs an agent key from a Shoot Plan account, and is free up to 3 projects a month. A project is identified by the plan's work id and title; it counts when this tool first makes a finished document for it that month. shoot_plan_allowance says what is left. Over the limit it answers ALLOWANCE_REACHED: do not retry, a new key will not help, tell your human. A fair-use limit also applies: up to 20 finished-document calls for any one project and 60 for the account each month. To count projects we keep, against your account, a one-way fingerprint (hash) of the project's id and title, the month, how many finished documents were made and when, for 13 months after the end of that month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_fit_to_budgetCuts a plan down to what the shoot can afford, without dropping a shot marked `must`: it takes out the least necessary shots one at a time, re-checking the plan after each, and tel…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Cuts a plan down to what the shoot can afford, without dropping a shot marked `must`: it takes out the least necessary shots one at a time, re-checking the plan after each, and tells you what each cut costs. Input: plan, and constraints: max_shots (the most shots the cut may need) and/or max_setups (the most camera set-ups; shots sharing a set-up count once). The engine refuses any other limit and says which it takes. Output: dpl.replan/1 with met (true or false; false says which limit failed, by how much and what to relax), the sacrifices, and the revised plan with its findings. Not meeting a limit is an answer, not an error. It can take several seconds on a large plan (up to 30 s here). No AI model runs; nothing is stored. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_progress_syncTick or untick shots and checklist items.No findings

    Why it is in this group

    • The name "shoot_plan_progress_sync" says "sync": a word for a change.
    Description, as the server wrote it
    Tick or untick shots and checklist items. Each op: itemKey "shot:<shotId>" or "check:<itemId>" from shoot_plan_get, basePlanVersion = the plan's version, a new random UUID v4 as opId, state "complete" or "incomplete". Retry-safe: resending the same opId does nothing twice. An op made against an older basePlanVersion still applies when that item is unchanged in the current version; otherwise its result is item_changed_in_current_version and nothing changes. Ticking records that the person checked the shot, not its technical quality. Use the full taskId from shoot_plan_list (not planId). A unique eight-character task prefix or orderReference also works. Connections see only their own live or owner-test plans.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • shoot_plan_quoteCalculate a deterministic public quote from non-private project metadata.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Calculate a deterministic public quote from non-private project metadata. Do not send a script or brief.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_record_decisionRecords a decision about one finding from shoot_plan_check (accepted, overridden or wont_fix), with the reason and who decided, so that you do not raise it again next session.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Records a decision about one finding from shoot_plan_check (accepted, overridden or wont_fix), with the reason and who decided, so that you do not raise it again next session. We keep nothing: the answer is the updated decision log, and you must keep it and send it back to shoot_plan_check as dispositions. A finding with a remembered decision then comes back closed, with the reason, for as long as the evidence behind it is unchanged; if the evidence changes, it comes back open again. Input: plan; finding_id (a finding's id from shoot_plan_check); decision (accepted, overridden or wont_fix); reason (why, in plain words); by (who decided); optionally at (an ISO 8601 time with a zone, such as 2026-10-18T09:30:00Z; the time of the request if left out) and dispositions (the log you were given last time, to extend it: a later decision about the same finding replaces the earlier one, which stays as history). Output: dpl.dispositions/1, the log with this decision added. A finding_id the plan does not have is refused. No AI model runs. We don't keep the plan. We log a one-way fingerprint (hash) of it, its size, the tool, the type of client, the result and the time taken. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_shoot_packMakes the pack to take on the shoot day: the call sheet with, for each scene, its shots, the action, the look and the sound notes.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Makes the pack to take on the shoot day: the call sheet with, for each scene, its shots, the action, the look and the sound notes. Use it when the crew needs one document to work from; use shoot_plan_call_sheet when only the times and people are wanted. Input: plan, a dpl.plan/1 object that validates; optionally day, the id of one day in the plan's schedule (a day the plan does not have is refused, and the refusal lists the days it has). Output: dpl.shoot-pack/1. No AI model runs; we don't keep the plan. Needs an agent key from a Shoot Plan account, and is free up to 3 projects a month. A project is identified by the plan's work id and title; it counts when this tool first makes a finished document for it that month. shoot_plan_allowance says what is left. Over the limit it answers ALLOWANCE_REACHED: do not retry, a new key will not help, tell your human. A fair-use limit also applies: up to 20 finished-document calls for any one project and 60 for the account each month. To count projects we keep, against your account, a one-way fingerprint (hash) of the project's id and title, the month, how many finished documents were made and when, for 13 months after the end of that month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_sliceCuts out part of a plan, so that you can send a smaller plan when your context is short: the scenes, the shots or the sequence you name, with everything they refer to (characters, …No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Cuts out part of a plan, so that you can send a smaller plan when your context is short: the scenes, the shots or the sequence you name, with everything they refer to (characters, places, props, sound and the rest) and their times unchanged. The slice is a valid plan of its own, so you can send it to shoot_plan_check, and it says which whole plan it was cut from (slice_of). It is for reading and editing one part: to change the film, change the whole plan and check that. Input: plan, and exactly one of scenes (scene ids), shots (shot ids) or sequence (one sequence id). Ids may be a name, a comma-separated list, or a list of names. An id the plan does not have is refused, and the refusal says what to change. Output: the sliced dpl.plan/1 with slice_of. A slice of shots that leaves gaps in a scene is judged as if the shots on either side of a gap were neighbours: treat its check as advice. No AI model runs. We don't keep the plan. We log a one-way fingerprint (hash) of it, its size, the tool, the type of client, the result and the time taken. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_summaryGives a short account of a plan, about 300 words, so that you can pick the work up again without being sent the whole plan: the title, the planned runtime against the target, the c…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Gives a short account of a plan, about 300 words, so that you can pick the work up again without being sent the whole plan: the title, the planned runtime against the target, the counts of scenes, shots, characters and places, the thesis and journey, one line for each sequence and scene, the missing-details counts, and, if you pass the check result, the open findings by severity. Fetch it first when you come back to a film. The scene ids it lists are the ones to ask shoot_plan_slice for. Input: plan, a dpl.plan/1 object; optionally findings, the dpl.findings/1 document shoot_plan_check returned for this plan (without it the summary says no findings were given and does not run the checks; if they are for another revision of the plan, it says so). Output: dpl.summary/1. A plan that does not validate is refused with its diagnostics. No AI model runs. We don't keep the plan. We log a one-way fingerprint (hash) of it, its size, the tool, the type of client, the result and the time taken. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_timingStructured plans only (not older free-text plans).No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Structured plans only (not older free-text plans). Compare planned and actual filming time between consecutive ticks in field mode. plannedSeconds is the planned time of those measured tick-to-tick steps, not the whole plan; planPlannedSeconds is the whole plan's planned shot work when present. Read-only. Use the full taskId from shoot_plan_list (not planId). A unique eight-character task prefix or orderReference also works. Connections see only their own live or owner-test plans.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_to_dplConverts one of your organisation's purchased Shoot Plan plans into a dpl.plan/1 plan in the short-form profile, so you can pass it to shoot_plan_check.1 finding

    Why it is in this group

    • The description's first verb is "convert": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "shoot_plan_to_dpl" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"openWorldHint":false}; The description's first verb is "convert": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Converts one of your organisation's purchased Shoot Plan plans into a dpl.plan/1 plan in the short-form profile, so you can pass it to shoot_plan_check. It is the same conversion dpl-eil's reference importer makes, and it is one way only. Input: planId (the plan's planId, spp_..., as shown inside shoot_plan_get) or taskId (the full taskId from shoot_plan_list); optionally dayStart (HH:MM, default 09:00: the clock time of minute 0 of the shoot) and date (YYYY-MM-DD). Output: {plan, report}. The report lists every field of the Shoot Plan plan that has no place in DPL or was approximated, with counts, and anything it had to assume. It also uses the structured details the plan was made from (people's names, access windows, how noisy each place is) when Shoot Plan holds them; where it does not, those come back as gaps. The private context text is never used. Read-only: the Shoot Plan plan is not changed and the DPL plan is not stored, so keep it yourself. The plan must belong to the organisation of your agent key. Needs an agent key from a Shoot Plan account, and a Shoot Plan you have bought. No AI model runs. It never counts toward the monthly allowance. Documents made from a plan you have bought do not use up a project, but they do count towards the fair-use limits. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
Only reads 12Show 12 read-only tools
  • shoot_plan_capabilitiesReturn truthful Shoot Plan scope, availability, privacy and commercial state.No findings

    Why it is in this group

    • The description's first verb is "return": a word for reading.
    Description, as the server wrote it
    Return truthful Shoot Plan scope, availability, privacy and commercial state.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_coverage_statusAnswers "did we get it?" before the crew leaves a location: from the plan and the take log it says which must-have shots have no good take, which reactions or cutaways the edit wil…No findings

    Why it is in this group

    • The name "shoot_plan_coverage_status" says "status": a word for reading.
    Description, as the server wrote it
    Answers "did we get it?" before the crew leaves a location: from the plan and the take log it says which must-have shots have no good take, which reactions or cutaways the edit will need are still missing, what must match on the next set-up, and whether room tone was recorded. A "hold" verdict is not yet a decision, so it does not count as covered and is asked about. The tools take text only, never video or audio, and no AI model runs. Input: plan and takes (a dpl.takes/1 log); optionally location, scene and day to look at one part of the shoot (each a string, comma-separated names allowed, or a list of strings; a name that is not in the plan is refused with a fix), and next_setup, the set-up that follows. Output: dpl.coverage-status/1. We don't keep the plan or the take log. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_diffSays what changed between two versions of a plan, so that you can catch up from a few lines instead of reading both.No findings

    Why it is in this group

    • The name "shoot_plan_diff" says "diff": a word for reading.
    Description, as the server wrote it
    Says what changed between two versions of a plan, so that you can catch up from a few lines instead of reading both. It compares by id, not by position, so reordering changes nothing: it lists what was added, what was removed, what changed (with the old and new values), and an id that has gone while another has appeared with the same content, which may be a rename: only a person can say. With the check results for both versions it also says which findings are new, which are resolved and which are unchanged. Input: old and new, two dpl.plan/1 objects; optionally old_findings and new_findings, the dpl.findings/1 documents shoot_plan_check returned for each: send both or neither. Output: dpl.diff/1. A plan that does not validate is refused with its diagnostics. Both plans are in one request, so the size limit is for the two together. No AI model runs. We don't keep the plan. We log a one-way fingerprint (hash) of it, its size, the tool, the type of client, the result and the time taken. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_exampleReturn a synthetic example plan generated by the real planner, with its provenance.No findings

    Why it is in this group

    • The description's first verb is "return": a word for reading.
    Description, as the server wrote it
    Return a synthetic example plan generated by the real planner, with its provenance.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_formatReturns what you need to write or repair a plan that the checks can read: links to the JSON Schemas, the shortest valid plan, a worked example of a two-person scene that the checks…No findings

    Why it is in this group

    • The description's first verb is "return": a word for reading.
    Description, as the server wrote it
    Returns what you need to write or repair a plan that the checks can read: links to the JSON Schemas, the shortest valid plan, a worked example of a two-person scene that the checks find nothing wrong with, and a summary of the details that switch each check on (which is why a thin plan comes back "not assessed"). Call it first if you are about to write a plan. Input: none. Output: {schemas, smallest_plan, example_plan, details_that_make_checks_work, rules_of_thumb, rules_version}. No AI model runs; it needs no plan and stores nothing. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_getReturn a full plan: shots in filming order (priority must = essential), setup groups per location or visit, checklist, coverage risks, progress (item keys already ticked), progress…Reads text others writeNo findings

    Why it is in this group

    • The name "shoot_plan_get" says "get": a word for reading.

    What it can reach

    • untrusted-inputThe description's first sentence says "return" and "web": it reads web pages, which anyone can write.
    Description, as the server wrote it
    Return a full plan: shots in filming order (priority must = essential), setup groups per location or visit, checklist, coverage risks, progress (item keys already ticked), progressSummary with counts, each tick's time and source (web, field or agent), and timeSummary when the plan has timing. Structured shots have a unique title and whole filming minutes (at least 1); older free-text shots omit both. Use a shot's shotId for progress. Read-only. Use the full taskId from shoot_plan_list (not planId). A unique eight-character task prefix or orderReference also works. Connections see only their own live or owner-test plans.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_listList the authenticated organisation's Shoot Plans, most recently changed first, without returning private intake or full plan content.No findings

    Why it is in this group

    • The name "shoot_plan_list" says "list": a word for reading.
    Description, as the server wrote it
    List the authenticated organisation's Shoot Plans, most recently changed first, without returning private intake or full plan content. Archived plans are left out unless includeArchived is true. Each plan's taskId is the ID every other plan tool takes. Structured result: {plans:[...]}.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_missing_detailsLists the questions to put to the person who knows the film, so that more of the plan can be checked.No findings

    Why it is in this group

    • The description's first verb is "list": a word for reading.
    Description, as the server wrote it
    Lists the questions to put to the person who knows the film, so that more of the plan can be checked. Each question uses the plan's own names, says which paths in the plan the answer fills in and which checks it unlocks, and says whether it blocks the assessment of a scene. Do not invent an answer to silence a question: when the honest answer is none, say so in the plan with a `none` declaration (shoot_plan_format explains). Input: plan, a dpl.plan/1 object sent inline. Output: dpl.missing/1. No AI model runs; nothing is stored. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_revision_previewStructured plans only; older free-text plans cannot be previewed.No findings

    Why it is in this group

    • The name "shoot_plan_revision_preview" says "preview": a word for reading.
    Description, as the server wrote it
    Structured plans only; older free-text plans cannot be previewed. Preview a revision without using it: what would change, which checked shots would be cleared, and whether it still fits. For example constraintUpdates.availableMinutes: 30 answers "what if I only had 30 minutes?". Never uses the included revision. Use the full taskId from shoot_plan_list (not planId). A unique eight-character task prefix or orderReference also works. Connections see only their own live or owner-test plans.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_shot_listTurns a plan into a shot list a crew can work from.No findings

    Why it is in this group

    • The name "shoot_plan_shot_list" says "list": a word for reading.
    Description, as the server wrote it
    Turns a plan into a shot list a crew can work from. Input: plan; format, "json" (default, dpl.shot-list/1) or "markdown"; vocabulary, an optional industry vocabulary for camera terms (for example "movielabs@1.0"). Output: the shot list, or {format:"markdown", markdown}. No AI model runs. We don't keep the plan. Needs an agent key from a Shoot Plan account, and is free up to 3 projects a month. A project is identified by the plan's work id and title; it counts when this tool first makes a finished document for it that month. shoot_plan_allowance says what is left. Over the limit it answers ALLOWANCE_REACHED: do not retry, a new key will not help, tell your human. A fair-use limit also applies: up to 20 finished-document calls for any one project and 60 for the account each month. To count projects we keep, against your account, a one-way fingerprint (hash) of the project's id and title, the month, how many finished documents were made and when, for 13 months after the end of that month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_statusReturn a plan's status, version, whether its included revision is used, its customer-facing order reference, and progress (essential shots ticked, next shot, when the last tick was…No findings

    Why it is in this group

    • The name "shoot_plan_status" says "status": a word for reading.
    Description, as the server wrote it
    Return a plan's status, version, whether its included revision is used, its customer-facing order reference, and progress (essential shots ticked, next shot, when the last tick was made). Read-only. Use the full taskId from shoot_plan_list (not planId). A unique eight-character task prefix or orderReference also works. Connections see only their own live or owner-test plans.

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false
  • shoot_plan_validate_takesChecks a log of takes against the plan it was shot from, before you rely on it.No findings

    Why it is in this group

    • The name "shoot_plan_validate_takes" says "validate": a word for reading.
    Description, as the server wrote it
    Checks a log of takes against the plan it was shot from, before you rely on it. It finds shots that are not in the plan, take numbers used twice, one op_id used for two different takes, file names written as paths, and a log made for another film or another revision of the plan. Each problem has a path into the log and a fix. A log with errors is a normal answer, not an error. The log is text about recordings (shot ids, verdicts, file names, timecodes). The tools take text only, never video or audio, and no AI model runs. Input: plan (a dpl.plan/1 object) and takes (a dpl.takes/1 object). Output: dpl.diagnostics/1 with valid (true or false) and each diagnostic with its fix. We don't keep the plan or the take log. Needs an agent key from a Shoot Plan account. Free, and it does not count toward the account's 3 free projects a month. Plans up to 8 MB and 120 calls a minute (5,000 a day).

    Annotations the server declares

    • readOnlyHint: true
    • openWorldHint: false

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

No private-data, untrusted-input, outbound path in this server alone: no tool is tagged private-data or outbound.

Reads private data0
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write1
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out0
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

Tools listed without sign-in

Looked at Nov 20, 2026, 19:20 UTC, unchanged since Nov 13, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
23
Protocol version
2025-06-18
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
https://theamateur.co.uk/.well-known/oauth-protected-resource
Authorization servers
https://theamateur.co.uk/mcp/youtube
Legacy HTTP+SSE transport
no
Dynamic client registration
yes
Client ID metadata documents
yes
  • HighThe whole server

    The endpoint served tools/list without credentials, and the list has 23 tools that change things (1 destructive, 1 irreversible, 21 write). Whether a call also works without credentials was not tested: tools are never called.

    Matched text

    https://theamateur.co.uk/mcp/shoot-plan: tools/list returned 36 tools to an anonymous client, including shoot_plan_revise (destructive), shoot_plan_merge_takes (irreversible), shoot_plan_quote (write), shoot_plan_create (write), shoot_plan_timing (write) and 18 more

    What this check looks for

Posture changes

  1. Nov 13, 2026
    • Tools that change things, listed without credentials: 22 to 23
  2. Oct 29, 2026
    • Tools that change things, listed without credentials: 5 to 22

Findings

Matches of fixed checks, with the text they matched.

7 warn
  • The server marks "shoot_plan_apply_fix" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_apply_fix" says "apply": a word for a change.

    What this check looks for
  • The server marks "shoot_plan_draft_start" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_draft_start" says "start": a word for a change.

    What this check looks for
  • The server marks "shoot_plan_merge_takes" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_merge_takes" says "merge": a word for a change that another call does not undo.

    What this check looks for
  • The server marks "shoot_plan_edit_guide" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_edit_guide" says "edit": a word for a change.

    What this check looks for
  • The server marks "shoot_plan_export_edit" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_export_edit" says "edit": a word for a change.

    What this check looks for
  • The server marks "shoot_plan_call_sheet" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"openWorldHint":false}; The name "shoot_plan_call_sheet" says "call": a word for a change.

    What this check looks for
Show 1 more finding
  • The server marks "shoot_plan_to_dpl" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"openWorldHint":false}; The description's first verb is "convert": a word for a change.

    What this check looks for

History

Changes to its tool definitions and to its remote endpoint, newest first.

  1. PostureRemote posture changed. Tools that change things, listed without credentials: 22 -> 23.View diff
    • Tools that change things, listed without credentials: 22 to 23
  2. PostureRemote posture changed. Tools that change things, listed without credentials: 5 -> 22.View diff
    • Tools that change things, listed without credentials: 5 to 22
  3. Tools23 added, 1 changed.+23 added~1 changedView diff

Install

Pinned to version 0.1.1. Values in angle brackets are yours to fill in.

claude mcp add --transport http shoot-plan https://theamateur.co.uk/mcp/shoot-plan
claude mcp add --transport http shoot-plan https://theamateur.co.uk/mcp/shoot-plan

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__shoot-plan__shoot_plan_capabilities",
      "mcp__shoot-plan__shoot_plan_example",
      "mcp__shoot-plan__shoot_plan_list",
      "mcp__shoot-plan__shoot_plan_status",
      "mcp__shoot-plan__shoot_plan_get",
      "mcp__shoot-plan__shoot_plan_revision_preview",
      "mcp__shoot-plan__shoot_plan_missing_details",
      "mcp__shoot-plan__shoot_plan_format",
      "mcp__shoot-plan__shoot_plan_shot_list",
      "mcp__shoot-plan__shoot_plan_validate_takes",
      "mcp__shoot-plan__shoot_plan_coverage_status",
      "mcp__shoot-plan__shoot_plan_diff"
    ],
    "ask": [
      "mcp__shoot-plan__shoot_plan_quote",
      "mcp__shoot-plan__shoot_plan_create",
      "mcp__shoot-plan__shoot_plan_timing",
      "mcp__shoot-plan__shoot_plan_progress_sync",
      "mcp__shoot-plan__shoot_plan_check",
      "mcp__shoot-plan__shoot_plan_apply_fix",
      "mcp__shoot-plan__shoot_plan_fit_to_budget",
      "mcp__shoot-plan__shoot_plan_export_for_generation",
      "mcp__shoot-plan__shoot_plan_draft_start",
      "mcp__shoot-plan__shoot_plan_draft_next",
      "mcp__shoot-plan__shoot_plan_draft_gate",
      "mcp__shoot-plan__shoot_plan_merge_takes",
      "mcp__shoot-plan__shoot_plan_edit_guide",
      "mcp__shoot-plan__shoot_plan_export_edit",
      "mcp__shoot-plan__shoot_plan_call_sheet",
      "mcp__shoot-plan__shoot_plan_shoot_pack",
      "mcp__shoot-plan__shoot_plan_summary",
      "mcp__shoot-plan__shoot_plan_slice",
      "mcp__shoot-plan__shoot_plan_record_decision",
      "mcp__shoot-plan__shoot_plan_to_dpl",
      "mcp__shoot-plan__shoot_plan_allowance"
    ],
    "deny": [
      "mcp__shoot-plan__shoot_plan_revise"
    ]
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as shoot-plan. Review it before you use it.

Capability tags behind 1 rule
  • mcp__shoot-plan__shoot_plan_get untrusted-input

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/uk.co.theamateur/shoot-plan/verify?hash=68259df9a165dcc5aa7ed39de1c1629090ca01252e18d4b02fe0a58594e7e068" | jq -e '.changed == false'

Pinned hash 68259df9a165, from Nov 9, 2026, 13:18 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/uk.co.theamateur/shoot-plan/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for uk.co.theamateur/shoot-plan
[![Anlyon Radar](https://radar.anlyon.com/badge/uk.co.theamateur/shoot-plan.svg)](https://radar.anlyon.com/servers/uk.co.theamateur/shoot-plan)

Source: MCP Registry. Synced Oct 26, 2026, 23:18 UTC.

Shoot Plan MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the Shoot Plan MCP server safe?

No scan can promise that. What its definitions show: 34 tools, 22 of which can change, send or delete something, and 7 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.

Can the Shoot Plan MCP server delete data?

Yes. 1 tool can delete, cancel or revoke something: shoot_plan_revise.

Can the Shoot Plan MCP server do things that cannot be undone?

Yes. 1 tool can send, pay, publish or merge: shoot_plan_merge_takes.

What tools does the Shoot Plan MCP server have?

34 tools: 1 destructive, 1 irreversible, 20 write, 12 read. shoot_plan_revise, shoot_plan_merge_takes, shoot_plan_quote, shoot_plan_create, shoot_plan_timing, shoot_plan_progress_sync, shoot_plan_check, shoot_plan_apply_fix and 26 more.

Does the Shoot Plan MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the Shoot Plan MCP server send data to outside services?

None of its tools sends, posts or publishes, or takes a recipient, channel or URL.

Has the Shoot Plan MCP server changed its tools?

Yes, once since Anlyon Radar started tracking it, most recently on Oct 26, 2026. Every change is on this page and in its Atom feed.