@paradigma-inc/flywheel 0.1.11 → 0.1.13

package/skills/flywheel-lookahead/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: flywheel-lookahead
+description: Stage a single-path next-step frontier from existing Flywheel graph state with Flywheel MCP using lookahead depth `n` and per-hop option width `k`, without execution or compute acquisition. Use for planning what to do next, not claim validation, source-to-graph authoring, or autonomous execution.
+---
+
+# flywheel-lookahead
+
+## When To Use
+
+Use this skill when the task is to shape information inside Flywheel rather than only discuss it. Use the flywheel-lookahead skill when the user wants Flywheel to plan the next frontier of work from an existing set of nodes without executing it yet. Flywheel MCP is a node-first durable system of record for research work: nodes hold durable state, artifacts hold supporting files, executions record runs, and compute leases provide managed hardware. This skill is planning only: it stages next-step nodes from existing graph state without hidden execution, compute approval, or managed compute acquisition.
+
+If exact tool or field semantics are unclear, load [references/flywheel-mcp-tool-map.md](references/flywheel-mcp-tool-map.md) and [references/INTERFACES.md](references/INTERFACES.md) before mutating nodes.
+
+## Input Contract
+
+Before planning, recover or establish these inputs:
+
+- Required before planning: start nodes, objective, lookahead depth `n`, step option width `k`, and an explicit terminal condition.
+- Optional: budget ceiling and budget unit, but only when the user already supplied them or wants them tracked for later execution.
+- Defaults: `lookahead_depth` defaults to `n=1`; `step_option_width` defaults to `k=1`.
+- Recovery rules:
+  - Ask only when a required planning input cannot be recovered from explicit user instructions, current conversational context, or recent graph state.
+  - If start nodes cannot be recovered from explicit ids/slugs, named current context, or recent graph context, ask once.
+  - If the objective is missing, ask once; if the user refuses, infer it from graph context and persist it before planning.
+  - If the terminal condition is missing, ask once; if it remains unspecified, persist a planning-local terminal condition such as stopping after staging this lookahead pass through the requested `n` hops with at most `k` considered options per hop and one selected continuation per hop.
+
+## Working Terms
+
+- `frontier`: the current unresolved next-step nodes or candidate branches worth planning next.
+- `resolved frontier`: the latest resolved nodes from which the next frontier should be expanded, not the original source corpus again.
+- `control node`: the dedicated `insight` node that stores the canonical planning contract for the current frontier.
+- `terminal condition`: the explicit condition that tells this planning pass when to stop staging additional frontier nodes.
+- `expected_revision`: the node's current revision token used for optimistic-locking writes.
+- `lookahead depth (n)`: the number of sequential hops in one planned path.
+- `step option width (k)`: the number of candidate directions evaluated at each hop before choosing one continuation.
+
+## Width Semantics (Unambiguous)
+
+- Lookahead depth `n`: number of sequential hops in one plan path.
+- Step option width `k`: number of candidate directions to evaluate at each hop.
+- Expansion rule: at hop `i`, generate up to `k` non-redundant options, select exactly 1 winner, and only that winner continues to hop `i+1`.
+- Graph shape for this mode: a single chain of `n` staged nodes (not `k` parallel branches).
+- Each step node must record:
+  - the `k` considered options,
+  - the selection criterion,
+  - the chosen continuation.
+
+## Core Rules
+
+- Treat the main page body as the node readme/body field (`content` on modern Flywheel surfaces).
+- Use artifacts for supporting files and evidence, not as a substitute for the node's main narrative, because the node body should stay readable as the canonical planning record.
+- Only create graph edges for durable semantic relationships, because graphifying every wiki link floods the graph with noise that hides decision-relevant structure.
+- Treat the flywheel-lookahead skill as frontier planning only. It expands the Flywheel graph with staged next-step nodes but does not execute them, because execution or compute acquisition changes the job into `$flywheel-auto` or `$flywheel-reproduce`.
+- Planned nodes that are expected to produce evidence or artifacts should be typed `empirical`; planned nodes that only encode synthesis, decomposition, or decision structure should be typed `insight`.
+- Ask only the minimum clarification questions needed to establish a coherent planning contract, and ask none when the required answers are already recoverable from user instructions, conversational context, or graph state.
+- Do not request compute approval, acquire managed compute, or launch execution in this skill, because planning should leave the frontier staged for later work rather than spend budget now.
+
+## Workflow
+
+1. Resolve the starting context.
+   - Resolve starting nodes in this order: explicit node ids/slugs, explicitly named current context, focused or recently referenced nodes, then ask the user if nothing stable is recoverable.
+2. Resolve the planning contract.
+   - Recover required planning inputs from the current conversation and graph first. Ask only for inputs that remain genuinely missing after that recovery pass.
+   - The flywheel-lookahead skill requires a measurable objective. Ask once if it is missing; if the user refuses to specify one, infer it from the available graph context and state it explicitly before continuing.
+   - Default `n=1` and `k=1` unless the user specified otherwise.
+   - Persist the planning contract in a dedicated `insight` control node for this frontier. Put the canonical contract in node `content`, keep a one-line synopsis in `summary`, and keep brief planning rationale in `insights` so the commit contract stays valid.
+   - The control contract must name: objective, decision criterion, start nodes, lookahead depth `n`, step option width `k`, and an explicit terminal condition. Only persist a budget ceiling and unit when the user already supplied one or wants them tracked for later execution.
+   - Later lookahead passes must read the control node `content` first and continue from that persisted contract rather than from chat memory.
+3. Map each stable page, claim, or concept to a node.
+   - For exact node-mutation shapes, load [references/flywheel-mcp-tool-map.md](references/flywheel-mcp-tool-map.md).
+   - Create a new node with `flywheel_stage_node_create` when needed.
+   - Update an existing node with `flywheel_get_node` + `flywheel_stage_node_update` when continuing work.
+4. Put the primary page markdown or plan rationale in the node body/readme field (`content`).
+   - Keep `summary` concise.
+   - Populate `hypothesis`, `insights`, `outcome`, and similar fields only when the source actually supports them.
+5. Publish supporting files with the artifact upload flow.
+   - For exact artifact contract details, load [references/ARTIFACTS.md](references/ARTIFACTS.md).
+   - Use `flywheel_prepare_artifact_uploads`.
+   - Upload raw file bytes to the returned signed URLs.
+   - Call `flywheel_finalize_artifact_uploads` once all uploads in the batch are staged.
+   - Keep the artifact filename stable enough to reference from markdown when inline rendering matters.
+6. Add graph structure sparingly.
+   - Promote only decision-relevant relationships to edges.
+   - Leave ordinary cross-links inside the markdown body.
+7. Expand the frontier as a single selected path.
+   - Expand from the resolved frontier rather than mirroring the source corpus again.
+   - Depth `n` means plan `n` sequential hops ahead from the currently resolved frontier. Default `n=1`.
+   - Width `k` means evaluate up to `k` distinct non-redundant candidate directions at each hop. Default `k=1`.
+   - At each hop, stage the considered options in the step record, apply the selection criterion, and choose exactly one continuation.
+   - Only the chosen continuation advances to hop `i+1`; do not stage `k` parallel continuation branches for this mode.
+   - The staged graph shape for this mode is a single chain of up to `n` unresolved step nodes (shorter only when the terminal condition is met early).
+   - Each step node must record: the `k` considered options, the selection criterion used, and the chosen continuation.
+8. Commit after the node snapshot is coherent with `flywheel_commit_node`.
+   - Commit resolved insight nodes only when they have non-empty `insights`.
+   - Commit resolved empirical nodes only when outcome and artifact rules are satisfied.
+   - Leave unresolved plan nodes staged.
+
+## Result Contract
+
+When the skill completes a pass, it should leave behind:
+
+- One persisted `insight` control node containing the canonical planning contract.
+- A single staged next-step chain up to the current `n` limit where each hop records up to `k` considered options and one selected continuation.
+- Updated node summaries, rationale, and edges only where the current planning pass justifies them.
+- No hidden execution, no compute approval, and no managed compute acquisition.
+
+## Persisted Control Contract
+
+Use a dedicated `insight` node as the durable planning controller for the current frontier. Do not rely on unstated product fields or fresh chat context.
+
+For the canonical entity model and public contract terminology behind this controller, load [references/INTERFACES.md](references/INTERFACES.md).
+
+Use this storage convention:
+
+1. Reuse an existing control node when one already governs the same frontier; otherwise create one with `flywheel_stage_node_create`.
+2. Put the canonical contract in node `content`.
+3. Put a one-line synopsis in `summary`.
+4. Put the planning rationale or branch-selection logic in `insights` so the `insight` commit contract is satisfied.
+5. Update the control node with `flywheel_stage_node_update`.
+6. Read the control node with `flywheel_get_node` before later replans that need a fresh `expected_revision`.
+7. Commit the control node with `flywheel_commit_node` once the contract is coherent, even if downstream frontier nodes remain staged.
+
+Canonical contract shape:
+
+```md
+## Planning contract
+
+- Objective:
+- Decision criterion:
+- Start nodes:
+- Lookahead depth:
+- Step option width:
+- Terminal condition:
+- Budget ceiling: optional
+- Budget unit: optional
+```
+
+The `Start nodes` line is the recovery anchor for later replans. If multiple frontier nodes are in scope, list the governing node ids or slugs explicitly.
+
+## Guardrails
+
+- Build the graph explicitly with nodes, artifacts, and selected edges.
+- Do not request compute approval, acquire managed compute, or launch execution just to do planning.
+
+See also: invoke `$flywheel-to-graph` to port source material into Flywheel without implicit execution, invoke `$flywheel-reproduce` to graphify claim-bearing sources and run budgeted validation branches, and invoke `$flywheel-auto` to advance a frontier autonomously under an explicit budget and persisted stop condition.

package/skills/flywheel-lookahead/agents/openai.yaml

@@ -0,0 +1,12 @@
+interface:
+  display_name: "flywheel-lookahead"
+  short_description: "Plan the next Flywheel frontier"
+  default_prompt: "Use $flywheel-lookahead to expand this Flywheel frontier into staged next-step nodes."
+
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "flywheel"
+      description: "Flywheel MCP server"
+      transport: "streamable_http"
+      url: "https://flywheel.paradigma.inc/mcp-server"

package/skills/flywheel-lookahead/evals/evals.json

@@ -0,0 +1,20 @@
+[
+  {
+    "id": "continuation-from-existing-planning-contract",
+    "prompt": "Use $flywheel-lookahead to continue planning from an existing Flywheel control node that already contains a coherent planning contract. Expand the next frontier one more hop without execution and do not ask again for the objective or start nodes unless the control node is missing or contradictory.",
+    "expected_output": "Read the persisted planning contract from the control node content before replanning, continue from the stored objective and start nodes, avoid re-asking for those inputs when the contract is coherent, and stage additional next-step frontier nodes without execution or compute acquisition.",
+    "files": []
+  },
+  {
+    "id": "cold-start-with-no-objective",
+    "prompt": "Use $flywheel-lookahead to plan the next Flywheel frontier from the current graph context. If I refuse to specify an objective, infer one from the graph context and make it explicit before you stage any next-step nodes.",
+    "expected_output": "Ask for an objective once, infer one from graph context if the user refuses, write that objective and a decision criterion into the planning contract, and only then stage next-step frontier nodes.",
+    "files": []
+  },
+  {
+    "id": "planning-only-with-explicit-depth-and-width",
+    "prompt": "Use $flywheel-lookahead to stage two sequential hops of next-step work while evaluating up to three non-redundant options at each hop from the current Flywheel frontier. Plan only for later work and do not execute anything.",
+    "expected_output": "Persist `n=2` and `k=3` in the planning contract, evaluate up to three non-redundant options at each hop, record the considered options plus selection criterion plus chosen continuation for each step node, continue only along the single chosen path, and avoid compute approval, managed compute acquisition, or execution launch.",
+    "files": []
+  }
+]

package/skills/flywheel-lookahead/references/ARTIFACTS.md

@@ -0,0 +1,218 @@
+# Flywheel Artifacts
+
+Canonical reference for node artifact publishing in Flywheel MCP 0.9.
+
+Legacy note:
+
+- historical `run_artifacts` rows are retained for backward reads.
+- new artifact writes must use the MCP batch upload workflow:
+  `flywheel_prepare_artifact_uploads` -> raw file upload(s) ->
+  `flywheel_finalize_artifact_uploads`.
+
+## Node MCP Contract
+
+Artifacts are managed through node MCP tools:
+
+- `flywheel_prepare_artifact_uploads` prepares one or more signed raw-file
+  upload requests for a node.
+- The caller executes each returned upload request with raw bytes.
+- `flywheel_finalize_artifact_uploads` appends all staged uploads in that batch
+  to the node and bumps node revision once.
+- `flywheel_list_artifacts` and `flywheel_get_artifact` return artifact
+  metadata.
+- `flywheel_get_artifact_preview` reads persisted preview payload content by
+  artifact id.
+- `flywheel_commit_node` commits/finalizes node state after terminal fields are
+  already staged.
+
+Contract rules:
+
+- `flywheel_prepare_artifact_uploads` requires `expected_revision` and enforces
+  optimistic locking before issuing upload tickets.
+- Upload uses the signed one-time ticket in each returned `upload_url`;
+  client-supplied path/reference fields are not part of this contract.
+- Raw upload only stages payloads. It does not mutate node state or bump node
+  revision.
+- `flywheel_finalize_artifact_uploads` is the single node mutation point for an
+  artifact batch.
+- `flywheel_commit_node` is finalize-only:
+  - request shape is `expected_revision` with optional `summary` override.
+  - node kind/outcome/hypothesis/insights/no_artifacts_reason must already be
+    staged.
+  - commit transitions lifecycle to `committed`.
+- committed node contract rules remain strict:
+  - `kind=empirical` + `outcome=completed` requires artifacts or
+    `no_artifacts_reason`.
+  - `kind=insight` requires non-empty `insights`.
+  - `kind=empirical` requires empty `insights`.
+- MCP mutating calls require idempotency:
+  - tool transport auto-manages idempotency keys for tool calls.
+  - direct HTTP callers must provide `Idempotency-Key` on mutating MCP
+    endpoints.
+
+`artifact_type=banner` is supported for campaign root visuals. It follows the
+same raw image upload validation path as `artifact_type=image` and is intended
+for zoomed-out canvas visibility.
+
+## Prepare Request Shape
+
+`POST /mcp/nodes/{node_id}/artifacts/uploads/prepare`
+
+```json
+{
+  "expected_revision": 7,
+  "items": [
+    {
+      "artifact_type": "image",
+      "title": "Loss curve",
+      "execution_id": "optional-execution-id",
+      "metadata": {
+        "source": "training-run"
+      },
+      "filename": "loss_curve.png",
+      "media_type": "image/png"
+    }
+  ]
+}
+```
+
+Notes:
+
+- `items` must contain at least one structured object item.
+- String or JSON-encoded item payloads are invalid at the tool boundary.
+- `filename` and `media_type` are required for each item.
+- `metadata` is caller-defined JSON.
+
+## Prepare Response Shape
+
+```json
+{
+  "batch": {
+    "batch_token": "uuid",
+    "expires_at": "2026-03-09T16:00:00+00:00",
+    "max_upload_bytes": 10485760,
+    "items": [
+      {
+        "upload_id": "uuid",
+        "upload_url": "https://.../mcp/artifacts/uploads/{upload_id}?ticket=...",
+        "method": "PUT",
+        "headers": {
+          "Content-Type": "image/png",
+          "X-Flywheel-Artifact-Filename": "loss_curve.png"
+        },
+        "curl_command": "curl -sS -X PUT '...' -H 'Content-Type: image/png' -H 'X-Flywheel-Artifact-Filename: loss_curve.png' --data-binary @/absolute/path/to/file"
+      }
+    ]
+  }
+}
+```
+
+## Raw Upload Step
+
+Execute each returned request exactly:
+
+- Method: `PUT`
+- URL: `batch.items[i].upload_url`
+- Body: raw file bytes
+- Headers:
+  - `Content-Type` (media type)
+  - `X-Flywheel-Artifact-Filename` (filename hint)
+
+A successful upload:
+
+- validates the uploaded bytes against the requested artifact type
+- stages canonical payload JSON in blob storage
+- returns `202 Accepted`
+- does not yet append an artifact record to the node
+
+## Finalize Request and Response
+
+`POST /mcp/nodes/{node_id}/artifacts/uploads/finalize`
+
+```json
+{
+  "batch_token": "uuid"
+}
+```
+
+Successful finalize:
+
+- validates the batch is complete and still revision-compatible
+- appends all staged artifacts to the node
+- persists canonical payload JSON to `artifacts/nodes/{node_id}/{artifact_id}.json`
+- bumps node revision once
+- returns `{ "node": ..., "artifacts": [...] }`
+
+## Artifact Preview Behavior
+
+Artifact preview endpoint:
+`GET /mcp/nodes/{node_id}/artifacts/{artifact_id}/preview`.
+MCP tool: `flywheel_get_artifact_preview`.
+
+- Preview reads canonical persisted payload blob (`storage_path`) only.
+- No workspace dependency or local-file fallback is required.
+- `data_url` in preview responses is render output only; never upload JSON
+  metadata wrappers.
+- Preview-normalized types:
+  - `image` -> image payload with `data_url`
+  - `html` / `plotly_html` -> HTML payload
+  - `json` -> JSON payload
+  - `text` / `diff_carousel` and common text/code extensions -> text payload
+
+## WebUI Artifact Payload Reads
+
+When artifacts are projected through node responses, the server returns
+normalized storage references for each artifact payload:
+
+- `storage_path`: canonical blob path (for example
+  `artifacts/nodes/{node_id}/{artifact_id}.json`).
+- `storage_url`: the single client/host read URL for that payload.
+  - All blob backends: `/blobs/{storage_path}` authenticated byte-serving
+    proxy after access checks.
+
+Clients should read artifact bytes from `storage_url` only. `storage_path`
+remains metadata/debug context and must not be reconstructed into fetch URLs by
+clients. Payload loads are coordinated through a shared loader with in-flight
+deduplication, cache reuse, and bounded fetch concurrency to avoid bursty
+request storms and `429` backpressure under artifact-heavy nodes.
+
+The node overview panel additionally avoids eager load spikes by defaulting to
+collapsed mode for artifact-heavy nodes and deferring artifact rendering until
+cards approach the viewport.
+
+## Artifact Load Telemetry
+
+The WebUI emits a batched first-party product analytics event,
+`web_artifact_payload_batch`, through `POST /analytics/events`.
+
+This event is intended for aggregate artifact read-path observability and
+includes fields such as:
+
+- load volume (`loads_started`, `loads_completed`, `loads_failed`)
+- rate-limit incidence (`loads_429`)
+- queue/load latency aggregates
+- source mix (`/blobs/*` authenticated proxy)
+- top per-node load/failure summaries in the batch window
+
+## File Inventory Surfaces
+
+Artifacts and attachments are exposed through two HTTP inventory endpoints:
+
+- `GET /users/me/files` for account-wide browsing in Settings.
+- `GET /nodes/{node_id}/files` for node lineage-scoped browsing in the node
+  details panel.
+
+Inventory entries include source context (`node_id`, `execution_id`) so the UI
+can jump directly to the originating node or execution.
+
+## Common Invalid Payload Causes
+
+- stale `expected_revision` at prepare or finalize time
+- missing/invalid upload ticket
+- expired upload ticket or batch
+- upload body exceeds configured size limit
+- uploaded bytes do not match requested artifact format (for example invalid
+  JSON)
+- finalize called before every prepared upload is staged
+- commit contract violations (for example empirical `completed` without
+  artifacts or `no_artifacts_reason`)

package/skills/flywheel-lookahead/references/INTERFACES.md

@@ -0,0 +1,201 @@
+# Interfaces
+
+Canonical reference for Flywheel user-facing interfaces and public contracts.
+
+Last updated: 2026-03-21
+
+## Primary Clients
+
+- `project/flywheel-webui` - canonical web product UI
+- `project/flywheel-api` - canonical programmatic client interface (local + HTTP)
+- MCP hosts (Codex/Claude/ChatGPT) via `/mcp-server`
+
+## Canonical Entity Model
+
+All interfaces operate on the same core entities:
+
+- node
+- node edge (branch/merge graph links)
+- artifact
+- execution
+- compute lease
+- budget grant
+
+Node snapshots are the canonical durable contract for resume, review, and
+cross-client interoperability.
+
+## Core HTTP Surface
+
+### Node lifecycle and graph
+
+- `GET /mcp/nodes`
+- `GET /mcp/nodes/{node_id}`
+- `GET /mcp/nodes/{node_id}/tree`
+- `POST /mcp/nodes/stage/create`
+- `PATCH /mcp/nodes/{node_id}/stage/update`
+- `POST /mcp/nodes/{node_id}/commit`
+- `POST /mcp/nodes/{node_id}/branch`
+- `POST /mcp/nodes/merge`
+- `DELETE /mcp/nodes/{node_id}`
+- `POST /mcp/nodes/bulk-delete`
+
+### Artifact lifecycle
+
+- `POST /mcp/nodes/{node_id}/artifacts/uploads/prepare`
+- `POST /mcp/nodes/{node_id}/artifacts/uploads/finalize`
+- `GET /mcp/nodes/{node_id}/artifacts`
+- `GET /mcp/nodes/{node_id}/artifacts/{artifact_id}`
+- `GET /mcp/nodes/{node_id}/artifacts/{artifact_id}/preview`
+- `DELETE /mcp/nodes/{node_id}/artifacts/{artifact_id}`
+- `PUT /mcp/artifacts/uploads/{upload_id}`
+
+### Execution lifecycle
+
+- `POST /mcp/nodes/{node_id}/executions`
+- `GET /mcp/nodes/{node_id}/executions`
+- `POST /mcp/nodes/{node_id}/executions/{execution_id}/terminate`
+
+### Compute catalog
+
+- `GET /compute/providers`
+- `GET /compute/offers`
+- `GET /compute/offers/{provider}`
+
+### Managed compute and budgets
+
+- `GET /mcp/nodes/{node_id}/compute/options`
+- `POST /mcp/nodes/{node_id}/compute/acquire`
+- `GET /mcp/compute/status`
+- `GET /mcp/compute/connection`
+- `POST /mcp/compute/release`
+- `POST /mcp/compute/release-all`
+- `GET /mcp/nodes/{node_id}/budget/grants`
+- `GET /mcp/nodes/{node_id}/budget/campaign-grants`
+- `POST /mcp/nodes/{node_id}/budget/campaign-grants`
+- `PATCH /mcp/nodes/{node_id}/budget/campaign-grants/{budget_grant_id}`
+- `DELETE /mcp/nodes/{node_id}/budget/campaign-grants/{budget_grant_id}`
+
+### Sharing, tags, and audit
+
+- `GET /mcp/nodes/{node_id}/sharing`
+- `PUT /mcp/nodes/{node_id}/sharing`
+- `POST /mcp/nodes/sharing/bulk`
+- `GET /mcp/nodes/{node_id}/audit`
+- `POST /mcp/nodes/{root_node_id}/tags`
+- `PATCH /mcp/nodes/{root_node_id}/tags/{tag_id}`
+- `DELETE /mcp/nodes/{root_node_id}/tags/{tag_id}`
+- `PUT /mcp/nodes/{node_id}/tags`
+
+### Export and summaries
+
+- `POST /mcp/export`
+- `POST /mcp/import`
+- `POST /mcp/export-summary`
+- `POST /mcp/export-summary-stream`
+- `POST /mcp/export-summary-pdf`
+- `POST /mcp/export-summary-render-pdf`
+
+### Auth and integrations
+
+- `GET /auth/status`
+- `GET /auth/accounts`
+- `POST /auth/accounts/merge/source-proof`
+- `POST /auth/accounts/merge/preview`
+- `POST /auth/accounts/merge`
+- `POST /auth/accounts/detach`
+- `GET /auth/integrations/status`
+- `PUT /auth/integrations/wandb`
+- `PUT /auth/integrations/huggingface`
+- `DELETE /auth/integrations/wandb`
+- `DELETE /auth/integrations/huggingface`
+
+### Analytics
+
+- `POST /analytics/events`
+- `GET /admin/analytics/kpis`
+- `GET /admin/analytics/overview`
+
+## MCP Tool Surface
+
+### Discovery and sharing tools
+
+- `flywheel_auth_status`
+- `flywheel_get_credits_balance`
+- `flywheel_list_nodes`
+- `flywheel_get_node`
+- `flywheel_get_node_tree`
+- `flywheel_get_node_sharing`
+- `flywheel_set_node_sharing`
+- `flywheel_bulk_set_node_sharing`
+- `flywheel_create_node_tag`
+- `flywheel_update_node_tag`
+- `flywheel_delete_node_tag`
+- `flywheel_set_node_tag_assignments`
+
+### Node and graph tools
+
+- `flywheel_stage_node_create`
+- `flywheel_stage_node_update`
+- `flywheel_commit_node`
+- `flywheel_branch_node`
+- `flywheel_merge_nodes`
+- `flywheel_delete_node`
+- `flywheel_bulk_delete_nodes`
+
+### Artifact tools
+
+- `flywheel_prepare_artifact_uploads`
+- `flywheel_finalize_artifact_uploads`
+- `flywheel_list_artifacts`
+- `flywheel_get_artifact`
+- `flywheel_get_artifact_preview`
+- `flywheel_delete_artifact`
+
+### Execution tools
+
+- `flywheel_launch_execution`
+- `flywheel_list_executions`
+- `flywheel_terminate_execution`
+
+### Compute lease and budget tools
+
+- `flywheel_compute_list_options`
+- `flywheel_request_compute_grant_approval`
+- `flywheel_list_compute_grants`
+- `flywheel_compute_acquire`
+- `flywheel_compute_status`
+- `flywheel_compute_connection`
+- `flywheel_compute_release`
+- `flywheel_compute_release_all`
+
+### Campaign budget tools
+
+- `flywheel_list_campaign_budgets`
+- `flywheel_create_campaign_budget`
+- `flywheel_update_campaign_budget`
+- `flywheel_revoke_campaign_budget`
+
+### Contract, audit, and export tools
+
+- `flywheel_get_contract`
+- `flywheel_list_audit`
+- `flywheel_summarize_node_tree`
+- `flywheel_export_subgraph`
+- `flywheel_import_subgraph`
+- `flywheel_export_summary`
+- `flywheel_export_summary_stream`
+- `flywheel_export_summary_pdf`
+- `flywheel_export_summary_render_pdf`
+
+## Legacy Archival Export
+
+Experimental settings keep legacy history export available as an archival
+migration aid. This path is read-only and outside canonical node workflows.
+
+## Related Docs
+
+- `docs/flywheel/CONCEPT.md`
+- `docs/flywheel/FLYWHEEL_MCP.md`
+- `docs/flywheel/PROVISIONING.md`
+- `docs/flywheel/ARTIFACTS.md`
+- `docs/flywheel/GIT_INTEGRATION.md`