@paradigma-inc/flywheel 0.1.11 → 0.1.13

package/skills/flywheel-to-graph/SKILL.md

@@ -0,0 +1,187 @@
+---
+name: flywheel-to-graph
+description: Port source material into Flywheel nodes, artifacts, and durable edges with Flywheel MCP, without execution or compute spend. Use for source-to-graph authoring, not empirical validation, next-step planning, or autonomous execution.
+---
+
+# flywheel-to-graph
+
+## When To Use
+
+Use this skill when the task is to shape information inside Flywheel rather than only discuss it. Use the flywheel-to-graph skill when the user's main goal is to convert unstructured source material into a Flywheel graph. 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 authoring only: it ports source material into nodes, artifacts, and durable edges 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 authoring, recover or establish these inputs:
+
+- Required before authoring: source material or explicit source nodes, and the intended source-to-graph scope.
+- Optional: preferred root node, subtree shape, node granularity, and whether budget metadata should be tracked for later execution-oriented work.
+- Recovery rules:
+  - Ask only when the source corpus, source nodes, or intended scope cannot be recovered from explicit user instructions, current conversational context, or recent graph state.
+  - If the corpus is already represented in Flywheel, recover the governing source nodes before asking.
+  - If no explicit scope is given, infer the narrowest stable scope that matches the provided source material and state it before authoring.
+
+## Working Terms
+
+- `source corpus`: the input material to port, such as papers, blog posts, READMEs, markdown wikis, or research notes.
+- `normalized Flywheel graph export`: already-structured Flywheel node JSON with DAG-safe edges, suitable for `flywheel_import_subgraph`.
+- `durable edge`: a graph relationship that carries stable semantic meaning, not just a navigational hyperlink.
+- `authoring pass`: one pass that reads source material and stages or commits the corresponding node/artifact updates.
+- `expected_revision`: the node's current revision token used for optimistic-locking writes.
+
+## Core Rules
+
+- Prefer explicit Flywheel node and artifact operations over ad hoc bulk-import stories, because node-first authoring keeps the graph legible and auditable.
+- 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 remain the readable source-of-truth for the imported material.
+- Only create graph edges for durable semantic relationships, because graphifying every wiki link floods the graph with noise that hides decision-relevant structure.
+- Use `flywheel_import_subgraph` only for prebuilt Flywheel graph JSON, not for raw markdown repositories, because raw corpora are usually file-centric and cyclic rather than clean node-centric payloads.
+- Treat the flywheel-to-graph skill as source-to-graph authoring only. It ports material into Flywheel primitives but does not execute branches or spend budget implicitly, because that changes the job into `$flywheel-reproduce` or `$flywheel-auto`.
+
+## Workflow
+
+1. Resolve the starting context.
+   - Start from the provided source material or explicit source nodes.
+   - Resolve governing 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. Classify the input.
+   - If it is already a normalized Flywheel graph export, `flywheel_import_subgraph` may be appropriate.
+   - If it is a markdown/wiki/blog/README corpus, paper, or research note set, port it explicitly with node and artifact tools.
+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 source narrative 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 durable semantic relationships to edges.
+   - Leave ordinary cross-links inside the markdown body.
+7. Commit after the node snapshot is coherent with `flywheel_commit_node`.
+   - Commit once the source narrative, artifact attachments, and selected graph structure agree with each other.
+
+## Result Contract
+
+When the skill completes a pass, it should leave behind:
+
+- A root node or subtree that represents the source material in Flywheel.
+- The primary narrative preserved in node `content`.
+- Supporting files attached as artifacts where appropriate.
+- Only durable graph edges added to the graph.
+- No hidden execution, no compute approval, and no managed compute acquisition.
+
+## Persisted Authoring Contract
+
+When the source-to-graph work spans multiple pages or multiple passes, use a dedicated `insight` node as the durable authoring controller for that corpus. 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 authoring control node when one already governs the same corpus; otherwise create one with `flywheel_stage_node_create`.
+2. Put the canonical authoring contract in node `content`.
+3. Put a one-line synopsis in `summary`.
+4. Put the current mapping rationale or continuation note 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 passes that need a fresh `expected_revision`.
+7. Commit the control node with `flywheel_commit_node` once the contract is coherent, even if downstream source nodes remain staged or in progress.
+
+Canonical contract shape:
+
+```md
+## Authoring contract
+
+- Source corpus:
+- Intended scope:
+- Root node or subtree target:
+- Default node granularity:
+- Edge policy:
+- Execution policy:
+```
+
+The `Source corpus` and `Intended scope` lines are the recovery anchors for later authoring passes.
+
+## Wiki Porting
+
+Use this guide when the source material is a markdown wiki, README corpus, or a Karpathy-style LLM wiki that should become Flywheel nodes.
+
+### Default Mapping
+
+- One wiki page or stable concept -> one Flywheel node.
+- The main page markdown -> the node body/readme field (`content`).
+- A short synopsis of the page -> `summary`.
+- Images, PDFs, datasets, notebooks, code snippets, and other supporting files -> node artifacts.
+- Durable structural relationships -> graph edges.
+- Ordinary wiki hyperlinks -> remain markdown links inside the node body.
+
+Do not try to preserve the source wiki as a file-first mirror inside Flywheel. Flywheel is node-first.
+
+### What The Model Should Do
+
+Assume the model is expected to perform the port directly unless the user explicitly asks to build a dedicated importer.
+
+That means:
+
+1. Read the source pages and supporting files.
+2. Create or update nodes explicitly.
+3. Write the page body into node `content`.
+4. Publish supporting files as artifacts.
+5. Add only the graph edges that materially help reasoning or navigation.
+
+Do not wait for a magical bulk-import surface if the available Flywheel primitives are already enough.
+
+## `flywheel_import_subgraph`
+
+Use `flywheel_import_subgraph` only when the input is already normalized into Flywheel node JSON with DAG-safe edges.
+
+Do not use it for raw markdown repositories because those are usually:
+
+- file-centric rather than node-centric
+- heavily cross-linked
+- cyclic in ways that are natural for a wiki but not a clean Flywheel graph
+
+Treat raw wiki content as authoring input, not as a direct subgraph payload.
+
+## Edge Policy
+
+Promote a relation to a graph edge only when it carries durable meaning such as:
+
+- hierarchy or decomposition
+- prerequisite or dependency
+- derived-from or result-of
+- canonical comparison target
+
+Do not create edges for every incidental mention, backlink, or navigational cross-reference. Keep those inside the markdown body instead.
+
+## Inline Artifact Embeds
+
+When the node body supports inline artifact rendering, keep references on their own lines so the renderer can replace them with the matching artifact preview.
+
+Examples:
+
+```md
+![Loss curve](loss-curve.png)
+
+[Evaluation metrics](metrics.json)
+```
+
+Guidelines:
+
+- Upload the artifact first, then reference it from the body.
+- Keep filenames stable enough for the renderer to match them.
+- Use inline embeds for supporting visuals or data, but keep the main explanation in the node body itself.
+- If a reference does not match an artifact, it should remain valid markdown rather than break the page.
+
+## Guardrails
+
+- Do not hide spend behind the flywheel-to-graph skill.
+- Build the graph explicitly with nodes, artifacts, and selected edges.
+- Keep the source material legible in `content`; do not dump everything into artifacts.
+
+See also: invoke `$flywheel-reproduce` to graphify claim-bearing sources and run budgeted validation branches, invoke `$flywheel-lookahead` to stage next-step frontier nodes from existing graph state without execution, and invoke `$flywheel-auto` to advance a frontier autonomously under an explicit budget and persisted stop condition.

package/skills/flywheel-to-graph/agents/openai.yaml

@@ -0,0 +1,12 @@
+interface:
+  display_name: "flywheel-to-graph"
+  short_description: "Turn source material into a Flywheel graph"
+  default_prompt: "Use $flywheel-to-graph to turn this source corpus into Flywheel nodes, artifacts, and edges."
+
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "flywheel"
+      description: "Flywheel MCP server"
+      transport: "streamable_http"
+      url: "https://flywheel.paradigma.inc/mcp-server"

package/skills/flywheel-to-graph/evals/evals.json

@@ -0,0 +1,20 @@
+[
+  {
+    "id": "markdown-wiki-corpus-ports-explicitly",
+    "prompt": "Use $flywheel-to-graph to turn this markdown wiki corpus into a Flywheel graph. Preserve the main narrative in nodes, attach supporting files as artifacts, and do not invent a separate importer surface.",
+    "expected_output": "Port the corpus with explicit node and artifact authoring, keep the main narrative in node `content`, add only durable graph edges, and avoid hidden execution or compute spend.",
+    "files": []
+  },
+  {
+    "id": "normalized-export-uses-import-subgraph",
+    "prompt": "Use $flywheel-to-graph on this input, which is already a normalized Flywheel graph export with DAG-safe edges.",
+    "expected_output": "Recognize that the input is already normalized Flywheel graph JSON and use `flywheel_import_subgraph` rather than rebuilding the graph page by page.",
+    "files": []
+  },
+  {
+    "id": "claim-bearing-paper-without-execution",
+    "prompt": "Use $flywheel-to-graph to structure this claim-bearing paper into Flywheel nodes and artifacts, but do not run any validation branches yet.",
+    "expected_output": "Port the paper into nodes, artifacts, and durable edges without hidden execution or compute acquisition, leaving any later empirical validation to `$flywheel-reproduce`.",
+    "files": []
+  }
+]

package/skills/flywheel-to-graph/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-to-graph/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`