Forge

List the fragments in an organization (name, description, tags, ids, revision, public state, sizes, collectionId) and its collections — the named groups fragments are filed under (id, name, fragmentCount). Scan description and tags to find the one the user means. orgId is only needed when you belong to several.

fragment_list

The organizations the caller belongs to. Only needed when a tool answers org_choice_required.

list_orgs

A skill's history, newest first: revision, name, description, byteSize and author. Restore one with skill_restore.

skill_list_revisions

List a workspace's skills without bodies: every skill, one collection's (collectionId), or the workspace's own (collectionId: null). Read one with skill_get.

skill_list

File a fragment under a collection (collectionId from fragment_list or fragment_collection_create), or pass collectionId: null to return it to the workspace root. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_move

Read a collection (a kit): the collection, its fragments, its skills in full, what you may do (viewer.member, viewer.canRemix) and, per workspace you could remix into, how many fragments it has against the room left there (room). Use it to read a kit from a share link (/share/collection/<id> — the id is the collectionId) as well as your own collections. Read the skills before using the fragments.

fragment_collection_get

When the user wants to see the fragment: answers shellUrl — the workbench page (live preview, controls, agent status) — which is the URL to hand them; `variant` (id or name) opens that variant. Also answers `url`, the raw sandboxed render (valid 12 h, re-renders on every submit) for your own checks such as a screenshot or fetch — never give the user that one — plus the fragment's name and variants. Clients that render MCP Apps (ChatGPT) show the result as a live preview card with a variant switcher, so there you need not repeat the links.

fragment_preview

Publish the current revision at https://<slug>.ui8.dev/ (a pinned snapshot; later edits stay private until the next publish). `slug` claims or changes the public name. `password` gates the page behind one shared password (null removes it; the page is open by default). Asks the user first: without confirm: true it answers confirmation_required. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_publish

Take a fragment into the project you are working in: answers its text files inline (or one tar url + command above the inline cap), a signed url per binary asset (curl them; they expire in an hour), the variant's entryPath and story, package.json dependencies, the skills that govern it (most specific first) and provenance.header to put at the top of the adapted entry file. Adapt the code to the project's conventions — nothing is copied in the cloud and the fragment is not changed. Needs membership of the workspace or a remix-level share link. Follow next.

fragment_pull

One file of the tree. Text files (variants, src/**, index.css, package.json) come back inline as `content`; binary assets answer downloadUrl (authenticated) and deliveryPath (what the preview serves) instead. Read a file before you rewrite it.

fragment_get_file

Read a skill: its fields, `markdown` (the rendered SKILL.md) and `path` (where it goes in a project: .agents/skills/<name>/SKILL.md).

skill_get

Forge Fragments reference, returned as markdown: the reference for cloud-hosted Fragments — using one in a project (fragment_find, the skills to read, fragment_pull, adapting), remixing fragments and collections, skills (SKILL.md documents a workspace or collection carries), the Vite-shaped tree (variants, shared files, assets, package.json, index.css), code sessions (download, edit, upload, submit), limits and path rules, the story body, revisions and restore, publishing, error codes. The server instructions carry the must-know; read this for limits, path rules, revisions and error codes.

fragment_docs

Copy a fragment as a NEW private fragment (every variant, file and asset; fresh ids, no history, unpublished) and answer it with its shellUrl. Works on a fragment in your workspace, or one reached through a share link whose linkAccess is remix. orgId picks the workspace the copy lands in (defaults to the source workspace when you are a member; required for a share-link remix). name defaults to the original plus " remix". variantId copies just that variant into its own fragment (Extract: the variant stays in the original; the copy is named "<fragment> · <variant>" by default). collectionId files the copy under a collection of the target workspace (null: its root). The copy records where it came from (remixedFrom).

fragment_remix

Copy a whole collection into a workspace you belong to: a NEW collection with every fragment (each a remix) and the collection's skills; the source workspace's own skills do not travel. All or nothing against the target's plan cap. Asks the user first: without confirm: true it answers confirmation_required with the fragment count and the room in each workspace — show those numbers, then retry with confirm: true. orgId picks the target (defaults to the source workspace for a member); name defaults to the original plus " (remix)".

fragment_collection_remix

Rename a fragment. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_rename

Answer in a feedback thread as the agent (what you did, what you need, why not). Keep it short; resolve separately once the item is handled.

fragment_feedback_reply

Mark a feedback item resolved once your submit addressed it (or reopen: true to put it back). The shell drops resolved pins from the preview.

fragment_feedback_resolve

Restore every variant and file (or one `path`) to its state at a revision, written as a NEW revision; answers what was restored and warnings for paths whose history does not reach back that far. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_restore_revision

Restore a skill to a past revision, as a new revision (the counter never rewinds). Answers the skill without its body. A workspace skill (no collectionId) needs an admin; a collection skill needs a member. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

skill_restore

Restore an archived fragment and its public page and share link. Consumes a fragment slot; quota_exceeded leaves it archived. No confirmation needed. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_unarchive

Create or update a skill. Without skillId: creates — pass name, description and body, or `markdown` (a whole SKILL.md whose frontmatter supplies name and description); collectionId files it under a collection, omitted files it at the workspace root. With skillId: updates the given fields. Explicit fields win over `markdown`. Answers the skill without its body, plus the new revision. A workspace skill (no collectionId) needs an admin; a collection skill needs a member. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

skill_save

Variant metadata — never code. With variantId: `name` renames, `story` replaces the whole story body, `values` merges top-level props (null deletes). Without variantId: creates a variant (name required) with a starter entry file and answers its entryPath — fill it through a session. Returns story `warnings` to fix. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_save_variant

Password-protect the public page (one shared password visitors type once), or pass null to make it open again. Takes effect on a live page at once — no re-publish — and is remembered for the next publish. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_set_password

Choose which variant the preview and the public page open by default. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_set_default_variant

Call this FIRST for any confirmed create or edit, before research or drafting. Without fragmentId it creates the fragment (name required; pass a one-line description and a few tags too, so the workspace list stays searchable) and its first variant. Answers shellUrl (the fragment's workbench page: live preview, parametric controls and the agent-activity indicator — hand it to the user right away), workdir (a local directory the commands use), the file list (kind, bytes, sha256), download.command (a gzipped tar of the Vite-shaped project, extracted into workdir), upload.command and a deadline (60 minutes). File contents are never inlined: run download.command, read only the files you need, edit under workdir, run upload.command exactly as returned, then fragment_submit with fragmentId and sessionId. For a new fragment the download is optional — write the variant entry file into workdir and upload. Never start a session for questions or read-only work.

fragment_start_session

Args: fragmentId, sessionId, optional deleted (tree paths to remove) and variant (id or name the URLs open). Apply the tree you uploaded to the session (run upload.command first). Diffs the upload against the fragment by content hash and writes only what changed, in one revision; answers at once with the revision, shellUrl (the workbench page — the ONLY URL to give the user), previewUrl (the raw sandboxed render, for your own checks; never hand it to the user), what was written, and ignoredPaths (server-owned and tooling files — never an error). List removals in `deleted`. A rejected submit keeps the session: fix, re-upload, submit again. Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_submit

Take the public page down; the slug is kept so a later publish restores the URL. Asks the user first (confirm: true). Optional ifRevision refuses to overwrite a concurrent edit (revision_conflict carries the current revision).

fragment_unpublish