Bragproof

← Reports

@anyforge/mcp-server

Starts with no setup3.18.0npm

Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.

Needs to start: nothing
Returns a result when called with no setup: 0 of 5 tools tried
Contacts while installing and starting: nothing

200tools listed
0hosts contacted
0files written
0.2 sto start
95dependencies

What it contacted

Nothing besides the npm registry it was installed from. Watched from outside its sandbox while it was installed and started with no input. Its tools may still contact things when called.

Starting it

npx -y @anyforge/mcp-server@3.18.0

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

5 tools that take no input and look read-only were called once with nothing. 0 returned a result.

anyforge_list_studio_sessionsNo usable answer tool reported an error: Error: No AnyForge credentials found. Run `npx @anyforge/control init` to authorise this machine, or set ANYFORGE_API_TOKEN (and optiona
anyforge_search_studio_sessionsNo usable answer tool reported an error: Error: No AnyForge credentials found. Run `npx @anyforge/control init` to authorise this machine, or set ANYFORGE_API_TOKEN (and optiona
anyforge_list_studio_decisionsNo usable answer tool reported an error: Error: No AnyForge credentials found. Run `npx @anyforge/control init` to authorise this machine, or set ANYFORGE_API_TOKEN (and optiona
anyforge_list_studio_modelsNo usable answer tool reported an error: Error: No AnyForge credentials found. Run `npx @anyforge/control init` to authorise this machine, or set ANYFORGE_API_TOKEN (and optiona
anyforge_get_studio_quotaNo usable answer tool reported an error: Error: No AnyForge credentials found. Run `npx @anyforge/control init` to authorise this machine, or set ANYFORGE_API_TOKEN (and optiona

During the calls it contacted nothing it had not already contacted.

Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.

What its tools tell an agent

In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.

2 tools with commands in capitals or very long text
  • Very long description in anyforge_update_work_item: 3000 characters or more
  • Gives the agent orders in anyforge_create_initiative: Create an initiative (optionally under a program). MUST be connected to a repository — pass `codebaseId` (preferred) or `defaultGithubRepo` ("owner/name");

Common and usually harmless: it is how many makers stress how a tool should be used.

Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.

Tools

anyforge_branch_studio_session sessionId, idempotencyKey, scope, messageId, title, checkpointId, expectedRevision, checkpoints
Fork a session with explicit conversation/files/both scope. File scope also requires studio:execute and checkpoints; rewind requires exact workspace revisions. Does not undo external GitHub actions. For branch, reuse the same idempotencyKey when retrying; inspect incomplete preparation before retrying.
anyforge_rewind_studio_session sessionId, scope, messageId, title, checkpointId, expectedRevision, checkpoints
Rewind a session with explicit conversation/files/both scope. File scope also requires studio:execute and checkpoints; rewind requires exact workspace revisions. Does not undo external GitHub actions. For branch, reuse the same idempotencyKey when retrying; inspect incomplete preparation before retrying.
anyforge_update_studio_review_finding sessionId, reviewId, findingId, status, rationale, resolutionRevision
Record a finding disposition with rationale and the revision containing a claimed fix. A fixed status does not imply independent verification; request a linked re-review to verify.
anyforge_get_studio_pr_comments sessionId, prNumber, repoFullName, page
Read paged inline PR review comments and reviewed file/line/commit provenance.
anyforge_get_studio_pr_jobs sessionId, prNumber, repoFullName, expectedHeadSha, runId, page
Read CI job identifiers for the exact PR head and a workflow run from its checks. Follow nextPage before claiming complete evidence.
195 more tools
anyforge_get_studio_pr_logs sessionId, prNumber, repoFullName, expectedHeadSha, jobId, offset, limit
Read a bounded CI log page only for a job belonging to this exact PR head. Preserve nextOffset to continue.
anyforge_request_studio_review sessionId, idempotencyKey, maxTotalTokens, repoFullName, branch, base, pr, reviewers, checkpointId, previousReviewId, focusFindingIds, acceptanceContext
Enqueue a durable, budgeted specialist review of an exact checkpoint, branch or PR. Returns a run ID; inspect its events and structured review artifacts. Reviewers cannot publish changes.
anyforge_list_studio_crew_batches sessionId
Read the session crew batches and unexpired proposals, including aggregate progress and limits.
anyforge_get_studio_crew_batch sessionId, batchId
Read one owned Studio crew batch. Active crews remain governed by their own gates.
anyforge_preview_studio_crew_batch sessionId, items, mode, crewType, maxConcurrent, totalTokenBudget
Persist a proposal for existing/new work items, planned or expedited crews, dependencies and aggregate limits. Starts nothing. Also requires studio:publish because orchestration can reach external systems. Open Code Studio to confirm the returned proposal; API/MCP arguments cannot attest human confirmation.
anyforge_cancel_studio_crew_batch sessionId, batchId, confirmed
Cancel queued starts; already active crews require separate stop actions. Also requires studio:publish.
anyforge_retry_studio_crew_batch sessionId, batchId, confirmed
Create a new proposal for failed/cancelled work; open Code Studio to confirm execution. This action never starts crews. Also requires studio:publish.
anyforge_list_studio_sessions limit, includeArchived
List your owned remote Code Studio sessions and their active/latest run IDs.
anyforge_create_studio_session title, repoFullName, branch, additionalRepos, initiativeId, unbound, context, provenance, idempotencyKey
Prepare a direct coding session or attach it to an existing initiative. Does not start execution. Context is a reference; local edits are not uploaded to the remote checkout. To hand over uncommitted local changes as well, run `anyforge studio create --uncommitted` in the checkout instead. additionalRepos needs an explicit repoFullName.
anyforge_get_studio_usage sessionId
Read an owned Studio session recorded billing subtotal from the newest 200 rows, grouped by actual model, product, run and leg. Preserve truncated, coverage and pending: historical coverage may be incomplete or unavailable; this is not a complete session bill. Provider cost and platform fee remain separate recorded fields.
anyforge_get_studio_session sessionId
Read one owned Studio session and its reconnect IDs.
anyforge_update_studio_session sessionId, title, repoFullName, branch, initiativeId, archived, pinned, folder, tokenBudget, additionalRepos
Update a session title, repository, branch, additional repositories or initiative. Does not execute code. additionalRepos replaces the whole list; null or [] clears it.
anyforge_get_studio_context sessionId, targetPath
Inspect effective context provenance, instructions, skills, graph/document snapshots and MCP availability. Does not expose credentials.
anyforge_add_studio_context sessionId, content, provenance, idempotencyKey
Attach a bounded context snapshot to a prepared prompt. No code execution; explicitly identify local versus remote provenance.
anyforge_list_studio_runs sessionId
List durable runs for your session.
anyforge_start_studio_run sessionId, content, idempotencyKey, model, planned, maxRounds, maxTotalTokens, maxLegs, verbosity, images
Start a durable coding run in the remote workspace. Can spend tokens and edit files. External runs are limited to audited coding, reads and reviews; hosted shell, browser, outbound connectors, Oracle and crew/workflow/approval actions require the browser Studio surface. Use planned=true for analysis only. Dedicated Git push and draft PR tools need studio:publish; ready/merge require confirmation in Code Studio.
anyforge_get_studio_run runId
Read run status, usage and any pending user question.
anyforge_get_studio_run_events runId, after, limit
Read ordered durable run events after a sequence cursor. Persist nextCursor to reconnect without replaying earlier events.
anyforge_control_studio_run runId, action, content, questionId
Pause, cancel, resume, steer or answer a pending question. Answer requires its current questionId. Resuming may execute code and spend tokens.
anyforge_get_studio_changes sessionId
Read remote workspace revision, Git state and changes. Does not create a workspace or install dependencies.
anyforge_list_studio_artifacts sessionId
Read checkpoint and structured reviewer artifacts for this session.
anyforge_get_studio_review sessionId, reviewId
Read structured reviewer findings, dispositions and review target provenance.
anyforge_create_studio_checkpoint sessionId, label
Capture remote workspace files, including staged and untracked changes, as a persistent checkpoint.
anyforge_get_studio_checkpoint sessionId, checkpointId
Read checkpoint metadata and exact revision.
anyforge_diff_studio_checkpoint sessionId, checkpointId
Read the remote workspace diff for a saved checkpoint.
anyforge_read_studio_checkpoint_file sessionId, checkpointId, path, offset, limit
Read a bounded file window from a persistent checkpoint.
anyforge_restore_studio_checkpoint sessionId, checkpointId, expectedRevision
Restore a checkpoint into the remote workspace after comparing its current revision. Saves a safety checkpoint first; does not rewind external GitHub actions.
anyforge_stage_studio_files sessionId, paths, expectedRevision
Stage explicitly selected remote files after checking the current revision.
anyforge_commit_studio_files sessionId, paths, message, expectedRevision
Commit reviewed remote changes. Read changes and confirm file scope before committing; does not push.
anyforge_push_studio_branch sessionId, expectedHeadSha
Publish the exact remote Git HEAD to its branch. Rejects changed HEAD and default-branch pushes.
anyforge_get_studio_pull_request sessionId, prNumber, repoFullName
Read a session repository pull request, checks, review decision and merge blockers.
anyforge_create_studio_pull_request sessionId, title, body, base, expectedHeadSha, repoFullName
Create or reuse a draft PR for the persisted session branch after checking its exact pushed HEAD. Uses your connected GitHub identity. Does not mark ready or merge.
anyforge_update_studio_pull_request sessionId, prNumber, action, repoFullName, expectedHeadSha, title, body
Update metadata or mark a session branch PR as draft using its exact expectedHeadSha. Open Code Studio to review and confirm ready/merge; tool arguments cannot authorize those actions.
anyforge_search_studio_sessions q, cursor, conversations, includeArchived
Search your own Studio sessions by title, repository, branch or folder, newest first. Set conversations=true (q of 2+ characters) to also search message text, five sessions per page. Follow nextCursor; conversationsLimited means a session had more messages than were searched.
anyforge_archive_studio_sessions confirmed
Archive all of your own unarchived Studio sessions (CI auto-fix monitors excluded). Transcripts are kept and each session can be unarchived with update_studio_session. Call again while remaining is true.
anyforge_list_studio_decisions
List your Studio runs waiting on you: each owned session whose current run asked a question, with the question and its options. Answer with control_studio_run.
anyforge_list_studio_models refresh
List the models your company and personal credentials can run, grouped by provider, for the model argument of start_studio_run. A provider with ok=false is not configured or not reachable. Cached for 30 minutes unless refresh=true.
anyforge_get_studio_quota
Read the remaining quota of the Anthropic subscription Studio runs on for you. oauth=false means runs use an API key, which has no subscription window.
anyforge_get_studio_conversation sessionId, after, limit, includeTools
Read an owned session's conversation, oldest first: your messages, the agent's replies and, with includeTools=true, each round's tool calls and results. Long text is clipped and flagged truncated. A page can hold fewer than limit messages; follow nextCursor until it is null.
anyforge_list_studio_tasks sessionId
Read the session's task list (the agent's to-do items), newest change first.
anyforge_compact_studio_session sessionId, confirmed
Compact the session's stored history: older messages are replaced by one summary so the next run starts lean. Deletes the summarized messages and cannot be undone. Spends a small model call on your credential. Refused while a run is active.
anyforge_list_studio_verifications sessionId
Read the session's verification reports (newest 20): diagnostics, tests, lint, typecheck, build and acceptance checks with their evidence and the exact source they ran against. Running a new verification requires the browser Studio surface.
anyforge_get_studio_environment sessionId
Inspect the existing remote checkout's environment readiness: detected toolchain, dependencies and setup scripts. Never clones, installs or loads secrets; preparing the environment requires the browser Studio surface.
anyforge_list_studio_outcomes sessionId, runId
Read the accepted, needs-rework and abandoned outcomes recorded for the session's runs, with the verification each was bound to. Pass runId for one run's outcome history. Outcomes are recorded by a person in Code Studio.
anyforge_list_studio_workspace_files sessionId, path
List a directory of the live remote workspace (omit path for the root). Never creates a checkout: a session without one returns workspace_missing.
anyforge_read_studio_workspace_file sessionId, path, offset, limit
Read a line window of a file in the live remote workspace, including unsaved agent edits. offset is the first line (default 1), limit the line count (default 500, maximum 2000). Never creates a checkout.
anyforge_inspect_studio_code sessionId, operation, path, line, column, newName, revision
Run a language-service query on a live workspace file: diagnostics (default), definition, references, hover, completions, or rename (a preview of the edits; apply with rename_studio_symbol). line and column are 1-based. Pass revision to refuse a changed workspace.
anyforge_write_studio_workspace_file sessionId, action, path, content, expectedRevision, expectedRepoFullName, expectedBranch
Create an empty file or save a file's complete content in the live remote workspace, without a model run. Name the repository, branch and revision you read, so a changed workspace is refused. Each write saves a checkpoint first. Does not commit or push.
anyforge_rename_studio_symbol sessionId, path, line, column, newName, expectedRevision, expectedRepoFullName, expectedBranch
Apply a language-service rename of the symbol at a 1-based line and column across the live remote workspace. Preview it first with inspect_studio_code operation=rename. Name the repository, branch and revision you read; a changed workspace is refused. Does not commit.
anyforge_list_pending_approvals limit
List HIL approvals awaiting an operator decision for your company. Returns each approval id, the crew it belongs to, plan summary, and the architecture / security context. Use this to see what needs your sign-off.
anyforge_get_approval_detail approvalId, include
Get the full detail of a single HIL approval by id (plan, ADR, security audit). A ship gate (`qa_approval`) also carries the verdicts its review chips show, and `reviews[]`: for the architect, security and QA specialists, the verdict, a plain-language reason for it (`verdictExplanation`, `blockingFindingIds`; a NEEDS_REVISION whose findings are all advisory says so), the `reviewedHeadSha`, the amend `round`, the written review, and the findings (id, severity, blocking, category, title, details, location, status). `addressedFindingIds` names what the latest amend round resolved. `architectADR` / `securityAuditResult` hold the same reports. The default response stays under ~20 KB; ask for more with `include`. Reviewer verdicts (`architectVerdict`, `securityVerdict`, `qaVerdict`) come with `<field>Label`, the word the Console shows, and `<field>Outcome` (`clean`, `non_blocking` or `blocking`). `NEEDS_REVISION` is non-blocking and the Console labels it "Advisory"; the Console's "Needs revision" means the blocking `FAIL`.
anyforge_submit_approval approvalId, decision, notes
Submit a decision on a HIL approval. APPROVED resumes the crew past the gate; REJECTED sends it back. Requires a key with the `approve` scope.
anyforge_list_work_items includeArchived, programId, initiativeId, team, priority, type, status, itemId, search, label, owner, assignee, reporter, limit, cursor
List work items in the AnyForge backlog with status, priority, and any linked crew state. ONE PAGE per call (50 by default, 200 max), newest first: the result carries `total` (matches for THESE filters across every page), `hasMore`, `nextCursor`, `appliedFilters` (the filters that actually ran — check it when `total` surprises you) and `nextAction`. When `hasMore` is true, pass `nextCursor` back as `cursor` with the SAME filters for the next page. A page with no relevant rows says nothing about the remaining pages — check `hasMore` before concluding there is no match. Narrow with `programId`, `initiativeId`, `team`, `status`, `priority`, `type`, `assignee`, `reporter`, `label` or `search` rather than paging through a whole backlog; `label` matches one exact label, such as a stage of a label group (anyforge_list_label_groups lists the groups and anyforge_list_work_boards the boards that follow them); to scope a question first, resolve the initiative with anyforge_list_initiatives, then list its items with `initiativeId`. `search` matches id, code, title, description, acceptance criteria, design notes, crew id, latest-status text, tags, component ids and the tracker key (`externalRef.key` or `jiraIssueKey`) — not lifecycle status or initiative names. By default archived items are excluded. Each item carries `assigneeName`, `blockerOwnerName` and `createdByName` beside `assigneeUid`, `blockerOwnerUid` and `createdBy`: the member's name (or email), null when the field is empty or names someone who is not an approved member.
anyforge_get_work_item itemId
Get a single work item by id or by code (`CXE-014`; a code the item gave up when it was re-keyed onto a team's code still finds it, returned under its current `code` with the former ones in `codeAliases`), including the test evidence people recorded on it (`testEvidence`, newest first), the names of its people (`assigneeName`, `blockerOwnerName` and `createdByName` beside `assigneeUid`, `blockerOwnerUid` and `createdBy`; null when the field is empty or names someone who is not an approved member) and the team it answers to (`team`: `{ id, name, source }`, where `source` is `item` for a team set on the item and `initiative` for its initiative's team; `null` when neither has one). `nextActions` says what YOU can do to its status now, so you never need the Console to find a transition: `statusMoves` lists each status the Console status menu offers that your key may reach, as `{ to, send }`, where `send` is the exact anyforge_update_work_item arguments (besides itemId) that make the move; `withheld` lists menu moves the write would refuse now with the code it would answer (work_item_deferred, approve_and_route_required, intake_draft_incomplete, test_evidence_required); `restore` is `reopen` or `undrop` for finished or dropped work you may bring back; `unavailable` says why there are no moves (`read_only`, `not_steward`, `crew_carries`, `finished`, `dropped`). `checklist` and `checklistRevision` (absent reads as 0) are what action='checklist' and 'checklist-promote' work from.
anyforge_list_label_groups
List the company label groups: sets of labels where a work item or initiative carries at most one label of the group (for example an "Implementation stage" group with one label per stage). Each group has an `id`, a `name`, its ordered `labels` and `appliesTo` (`work_items`, `initiatives` or `both`). A group's name is not itself a label on any item: to find the items at one stage pass that stage's label to anyforge_list_work_items as `label`.
anyforge_list_work_boards
List the saved Work boards (the Work queue board picker). A board whose columns follow a label group carries `labelColumns.labelGroupId` and `columnLabels`, the stage labels in column order; list the cards of one column with anyforge_list_work_items and `label`. Boards are a view over work items, not work items, so a search of the work items never finds a board or a label group by name.
anyforge_create_work_item title, description, tags, type, priority, allowedWritePaths, acceptanceCriteria, initiativeId, assigneeUid, dueDate, externalRef, externalId, dedupeByExternalId, estimate, estimatePoints, dependsOn, classOfService, branchName, continuesPullRequest, folderScope, targetGithubRepo, targetGithubBranch, sourceGithubRepo, sourceGithubBranch, sourceGithubSha, sourcePath, targetPath, migrationStrategy, codebaseId, incident, reportedBy, unrouted, repoUnconfirmed, suggestedRepoFullName, suggestedInitiativeId, attachments, teamSlug, triageType, reportedMilestoneId, demandFunction, unplanned, estimatedOperatorDays, estimateBasis
Create a new work item in the backlog (status BACKLOG). Requires `write` scope.
anyforge_update_work_item itemId, action, status, inReview, latestStatus, requestReview, checklistOps, ifChecklistRevision, checklistItemId, assigneeUid, title, description, tags, addTags, removeTags, ifClassificationRevision, type, priority, allowedWritePaths, acceptanceCriteria, outOfScope, bumpKind, dependsOn, crewId, crewType, runProfileId, runProfileOverride, sortOrder, closedReason, closedAsFixedByWorkItemId, targetGithubRepo, validationBranch, sourceGithubRepo, sourceGithubBranch, sourceGithubSha, sourcePath, targetPath, folderScope, migrationStrategy, architectPlan, branchName, targetGithubBranch, continuesPullRequest, dueDate, committedCycleNumber, reason, confirmOverCapacity, pullRequestUrl, linkedWorkItemId, linkType, estimate, estimatePoints, triageType, reportedMilestoneId, teamSlug, droppedReason, confirmActiveDrop, incident, confirmedInitiativeId, targetInitiativeId
Mutate one work item. `action` is one of advance, approve_refinement, approve-and-route, move-initiative, dispatch, complete, update, reorder, archive, unarchive, close-as-fixed, reopen, mark-incident, drop, undrop, confirm-repo, assign, begin, dismiss-automation-suggestion, expedite, block, unblock, link-external, verification, add-evidence, remove-evidence, share-evidence, undefer, set-cycle, scope-change, link-pull-request, unlink-pull-request, link-work-item, or unlink-work-item. Each action takes only its own fields: a field the action does not read is refused with 400 unsupported_fields, naming the field and the actions that do read it, and nothing is changed — so a success means every field you passed was applied. To move an item BACK (or between BACKLOG, REFINED and READY), send `status` with NO action: it takes BACKLOG, REFINED or READY, from one of those statuses or from work a person began (IN_PROGRESS with no crew) — the Console status menu's plain move, with the same role and initiative-steward rules, recorded in the item's history. Any other move is refused with 409 raw_status_not_allowed, naming allowedStatuses and the action to use instead (useAction): reopen for DONE, undrop for DROPPED, begin for IN_PROGRESS, complete for DONE, dispatch for a crew, drop; an item a crew carries moves with its crew. anyforge_get_work_item returns `nextActions.statusMoves`, the exact arguments for each move you may make now. Forward moves have their own actions too: advance, approve_refinement, begin, dispatch, complete. Use action='set-review' with inReview (true or false) to put work a person began (IN_PROGRESS, no crew) in or out of review; begin also takes inReview: true to start an item already in review. Use action='assign' with assigneeUid (a member uid or their email; anyforge_list_members lists both) to set the human executor. Use action='block' with blockReason (what the item is waiting on), blockCategory and optionally blockerOwnerUid (who is chasing it, uid or email) to mark an item blocked without changing its status; action='unblock' clears it. Use action='link-pull-request' with pullRequestUrl to show a GitHub pull request on the item, at any status (the Jira development panel). The pull request need not name the item; its state, title and reviewers are read from GitHub and kept current as it changes, and a linked pull request never moves the item. Pull requests that name the item by its code link themselves. action='unlink-pull-request' with the same URL removes one. Use action='link-work-item' with linkedWorkItemId (another work item's id in this workspace, from any initiative) and linkType 'relates_to' or 'duplicates' to connect two items; action='unlink-work-item' with the same two fields removes it. Both work at any status, DONE and DROPPED included, so finished work keeps its history; they change only the link and never move, block or unblock either item. relates_to has no direction. duplicates is directional: this item duplica
anyforge_retry_work_item itemId
Re-run a work item: terminate its current crew and dispatch a fresh one that reuses the same feature branch (lands new commits on the existing open PR) and re-reads the company's current agent config, so updated skills/guardrails take effect. If the prior crew record is missing, retry recovers by using the work item and initiative dispatch defaults. Returns the new crew id. If the item is DONE/DROPPED this fails with `terminal_item` — reopen it first via anyforge_update_work_item action='reopen'. Requires `write` scope.
anyforge_list_work_item_comments itemId, limit, cursor, since
List the discussion comments on a work item. This is separate from the transcript of any linked crew. Every comment carries a boolean `clientVisible`: true when it is shared with the client on shared reports, false when it is internal. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` to get the next page. Pass `since` to read only comments created after a moment (for example the time you last read the thread); keep the same `since` while paging.
anyforge_post_work_item_comment itemId, body, clientVisible, mentions
Post a discussion comment on a work item. The comment is internal unless `clientVisible` is true, which shares it with the client on shared reports as it is written; to change a comment that is already posted use anyforge_share_work_item_comment. Requires `write` scope and an editor-capable key owner.
anyforge_share_work_item_comment itemId, commentId, clientVisible
Change who can read an existing discussion comment on a work item: clientVisible true shares it with the client on shared reports, false takes it back to internal. Taking it back stops it being served from that moment but cannot retrieve what a reader has already seen. A reply can only be shared while the comment it answers is shared (409 parent_not_shared otherwise). Same rule as the Console: requires `write` scope and a key owner who is an editor or above; a key not bound to a user is refused. Find comment ids with anyforge_list_work_item_comments.
anyforge_edit_work_item_comment itemId, commentId, body
Edit the text of one of YOUR OWN discussion comments on a work item (also on a DONE item). The comment keeps its id and visibility, gains `editedAt`, and its attachments are untouched. Same rule as the Console: only the key owner's own comment can be edited; someone else's is 403 not_comment_author, a Linear-mirrored comment or a shared-report reader's comment is 403 comment_not_editable, an unknown id is 404 comment_not_found. Requires `write` scope and a key owner who is an editor or above. Find comment ids with anyforge_list_work_item_comments.
anyforge_delete_work_item_comment itemId, commentId
Permanently delete one of YOUR OWN discussion comments on a work item, with its attached files. Same rule as the Console: only the key owner's own comment can be deleted (403 not_comment_author, or comment_not_editable for Linear-mirrored and shared-report comments; 404 comment_not_found for an unknown id). A top-level comment that still has replies is refused with 409 comment_has_replies: replies are never removed or re-parented, so delete the replies first. Requires `write` scope and a key owner who is an editor or above.
anyforge_resolve_work_item_comment itemId, commentId, resolved
Resolve (`resolved` true) or reopen (false) the discussion thread a comment belongs to; naming a reply acts on its thread and the result carries that thread's `rootId`. Idempotent: setting the state the thread already has succeeds. Needs a key owner who is an editor or above, like every Control API write; anyone else gets 403 insufficient_role. Read the state back with `resolved` / `resolvedAt` on the root comment from anyforge_list_work_item_comments. Requires `write` scope.
anyforge_split_work_item initiativeId, itemId, children, reason
Replace one unstarted work item with at least two child work items. Requires explicit operator confirmation.
anyforge_merge_work_items initiativeId, itemIds, merged, reason
Replace at least two unstarted work items with one merged work item. Requires explicit operator confirmation.
anyforge_list_work_item_files itemId, limit, cursor
List the files attached to a work item (not files in its discussion comments): id, name, mediaType, size, clientVisible, createdAt (upload time), originalCreatedAt (when given at upload) and uploadedByUid. ONE PAGE per call (50 by default, 100 max); when meta.hasMore is true, pass meta.nextCursor back as cursor. Download a file with GET /api/v1/control/work/{itemId}/files/{fileId}.
anyforge_add_work_item_files itemId, files, idempotencyKey, onNameConflict
Attach up to 5 files to a work item, as the Console's Files panel does: images, PDF, text, logs, Markdown, CSV, JSON, XML, HTML pages, zip, Office documents and MP4/WebM/MOV video. SVG and other types are refused. Give each file exactly one of: text (the content as a string), contentBase64 (the bytes, base64-encoded) or path (a local file, stdio server only); name is required with text or contentBase64. Files start internal (not shared with the client). All or nothing: one refused file attaches none. One call carries at most 10 MB of request, which is about 7 MB of files once base64-encoded; for a larger file use anyforge_start_file_upload (up to 1 GB). A file already on the item with the same name and size is not attached again: it comes back with alreadyAttached: true. A same-name file of another size is refused (file_name_exists) unless onNameConflict is "keep_both". Give originalCreatedAt to keep the date a file was created in another tool. Requires the write scope and a key owner who is an editor or above. Returns { files } with each file's id. Pass an idempotencyKey to retry safely: a repeat with the same key and files returns the stored files ({ replayed: true }). Only call when the person asked to attach these files.
anyforge_list_cycles team, past, ahead
List a team's delivery cycles, oldest first: number, label, startDate, endDate, state (ended, active or future), isCurrent, locked and lockReason (started, or signed_off for a cycle whose plan was signed off), openReason (not_signed_off for a started cycle that is open because its team locks only at sign-off), committed (initiatives, workItems, openWorkItems and demandDays, as the Cycles board counts them) and capacity (availableDays over the cycle's own window). currentCycleNumber names the cycle containing today. By default 2 ended cycles, the current one and the next 3.

Cycle numbers count on a team's own cadence, and teams can run different cadences. To plan a work item into a cycle: read the item's team (team.id from anyforge_get_work_item), list that team's cycles, pick a cycle with locked: false, then call anyforge_update_work_item with action='set-cycle' and that number as committedCycleNumber. An item with no team uses the workspace cadence: leave team out. A locked cycle (the current cycle, and any future cycle signed off early) takes or loses work only through a scope change on the Cycles board; an ended cycle takes none. A team whose cycles lock only at sign-off (cadence.lockMode 'sign_off') keeps its current cycle unlocked until its plan is signed off, so set-cycle can add to it. Without a team, teamCadences lists the teams on a cadence of their own, whose numbers are not these.
anyforge_get_timesheet_week date, today
Read your own timesheet for one week (Monday to Sunday), as the Timesheets grid shows it: days; rows you can book (initiatives, then the overhead categories keyed @meetings, @admin, @support, @learning, @hiring), each with days[].bookable and the reason when a day cannot take time; addable initiatives; blocked ones with the reason; and entries, every booked cell with initiativeId (or category key), date, minutes, note and source (manual = typed by a person, here or in the Console; auto = booked from a calendar or measured activity).

Read the week before anyforge_book_time and send only the cells that should change, so you do not overwrite what someone typed or a calendar booked.
anyforge_book_time entries, today
Book, change or clear cells of your own timesheet: up to 100 at once, ALL OR NOTHING. Every cell is checked by the same rules as the Timesheets grid before any is written; if one is refused, none is, and the error names it by index. A cell that already has time is replaced (mode set, the default) or added to (mode add); minutes 0 clears it; cells you do not send are left alone. Minutes are rounded to the workspace step. A day may not pass 24 hours. Refusals: not_bookable with a reason (date_in_future, period_closed, initiative_closed, no_current_quarter_key_result, not_linked, enabling_work, initiative_not_in_program), day_over_limit, initiative_not_found, duplicate_entry (the same initiative and day twice), time_recording_disabled. Use the initiativeId values anyforge_get_timesheet_week lists. An empty list writes nothing and returns written: 0.
anyforge_list_initiatives status, programId, priority, owner, tag, search, sort, includeArchived, limit, cursor
List initiatives with status, progress and token budget/spend. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor`, `appliedFilters` (the filters that actually ran — check it when the page surprises you) and `nextAction`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` with the SAME filters to get the next page. A page with no relevant rows says nothing about the remaining pages — check `meta.hasMore` before concluding there is no match. Narrow with `programId`, `status` (comma-separated), `priority`, `owner`, `tag` or `search` rather than paging through a whole workspace; this is the tool that scopes a question before anyforge_list_work_items reads the items under one initiative. `search` matches code, name, description, repo and tags only. Archived initiatives are hidden unless includeArchived is set. Rows are the list projection (description is excerpted, dollar spend is omitted) — call anyforge_get_initiative for the full record.
anyforge_get_initiative initiativeId, shape
Get an initiative with its crews, work items, lifetime spend, and daily burn-down series. By default (`shape: "summary"`) crews and work items are rows and initiative text longer than 1,000 characters (architect ADR, test plan, BRD) is excerpted and named in `excerptedFields`. Read one crew or work item in full with anyforge_get_crew / anyforge_get_work_item; pass `shape: "full"` only when you need every document, which can be very large. Reviewer verdicts (`architectVerdict`, `securityVerdict`, `qaVerdict`) come with `<field>Label`, the word the Console shows, and `<field>Outcome` (`clean`, `non_blocking` or `blocking`). `NEEDS_REVISION` is non-blocking and the Console labels it "Advisory"; the Console's "Needs revision" means the blocking `FAIL`.
anyforge_get_initiative_spec initiativeId
Read an initiative's active ICE spec (Intent, Context, Expectations) with its readiness score, plus any spec submission still waiting on human review. Call before proposing a spec. `approvalGate` is what backlog approval will decide: it needs `requiredScore` (100), which is stricter than `readiness.meetsBar` (no failing checks), and `gaps` lists every check still holding the score down, warnings included.
anyforge_propose_initiative_spec initiativeId, intent, context, acceptanceCriteria, nonGoals, edgeCases, constraints, affectedRepos, naSections, blastRadius, agentSuitability, note
Submit an ICE spec for an initiative FOR HUMAN REVIEW. This does not change the active spec: a person must review it and publish it (or reject it), in the AnyForge Console section by section, or by asking you to call anyforge_publish_initiative_spec after reading it. Until then the architect and every spec gate still see the current spec, so do not dispatch the architect expecting this spec to apply — tell the user it is awaiting their review and give them the returned reviewUrl, the absolute Console link to the review page (reviewPath is the same page as a path). A newer submission replaces a pending one. Only write what the user and the code support; flag open questions in `note` rather than inventing context or criteria. Requires `write` scope and an initiative-editing role.
anyforge_publish_initiative_spec initiativeId, submissionId
Publish a pending spec submission so it becomes the initiative's active ICE spec, exactly as it was submitted. ONLY call this when the user has read that submission (show it from anyforge_get_initiative_spec `pendingSubmission`) and explicitly asked you to publish it; never publish a spec you proposed on your own judgement. The Architect plans the whole backlog from the active spec. Pass the `submissionId` the user reviewed. Works only for a person connected through OAuth (the hosted MCP) with the `approve` scope and a role that edits initiatives; a Control API key gets 403 spec_publish_requires_person. Refused with 409 spec_version_conflict when the active spec changed after the submission, and spec_publish_needs_console_review when publishing would add the initiative's intake notes to Context (in both cases the person reviews it in the Console instead), and spec_submission_not_pending when a newer submission replaced it or it was rejected. An already published submission answers status "already_published" and changes nothing. To accept or reject single sections, use the returned reviewUrl in the Console.
anyforge_approve_backlog initiativeId, deferItemIds, deferReason
Approve the proposed backlog for an initiative (HIL #1). Promotes its BACKLOG items to READY and moves the initiative to IN_PROGRESS. Pass `deferItemIds` to leave chosen proposed items out of the approval: they stay in the backlog marked deferred, are never promoted or auto-dispatched, and come back through anyforge_update_work_item action='undefer'. Refused with a 400 and nothing written when an id is not one of this plan's proposed items (defer_item_not_proposed), is the integration-validation item (defer_item_not_deferrable), would defer every item (defer_all_items), or is a dependency of an item being approved (defer_breaks_dependency). Requires `approve` scope.
anyforge_approve_task_proposal initiativeId, crewId, messageId
Approve a mid-flight task proposal card, materialising a READY work item. Requires `approve` scope.
anyforge_create_initiative name, description, programId, defaultGithubRepo, additionalGithubRepos, defaultGithubBranch, priority, tokenBudget, contextNotes, brdContent, codebaseId, tags, longLived, operatorPlanned, taskTracker, assignedOperatorId, decompositionStrategy
Create an initiative (optionally under a program). MUST be connected to a repository — pass `codebaseId` (preferred) or `defaultGithubRepo` ("owner/name"); without one the request is rejected (repo_required) because its crews would have no workspace — unless `taskTracker` is set, since people deliver that work and no crew runs under it. De-dupes on name within the same codebase or program+repo, so re-runs return the existing one. Starts in DRAFT; dispatch the architect to decompose it into a backlog — unless `operatorPlanned` or `taskTracker` is set, in which case it starts IN_PROGRESS with no planner. Requires `write` scope.
anyforge_dispatch_architect initiativeId
Run (or re-run) the architect decomposition for an initiative: (re)creates the decomposition crew, clears any prior error, and starts the architect, which proposes a backlog for HIL #1 approval. Use after creating an initiative, or to retry a failed decomposition. Requires `write` scope.
anyforge_update_initiative initiativeId, name, description, status, priority, contextNotes, tags, tokenBudget, defaultGithubRepo, additionalGithubRepos, defaultGithubBranch, targetCompletionDate, brdContent, programId, confirmDeclassify, longLived, operatorPlanned, taskTracker, assignedOperatorId, decompositionStrategy, teamId, estimate, autoMergeOnApproval, autoDispatchOnApproval, prsLeftForHumanReview, defaultCrewType
Update an existing initiative — only the fields you provide change. Use to rename, re-prioritise, retarget, adjust the token budget, move it under a program, set its owning team (teamId), record the team's own estimate (estimate), or set its repositories (defaultGithubRepo, additionalGithubRepos) and branch. An argument this tool does not declare is refused with the valid names and nothing is changed, so a success means every field you passed was applied. Requires `write` scope. (System-managed initiatives are read-only and reject edits.)
anyforge_delete_initiative initiativeId
Delete a DRAFT initiative by id. Only DRAFT initiatives can be deleted — once decomposed / in progress, archive it via anyforge_update_initiative (status ARCHIVED) instead. Requires `write` scope.
anyforge_get_initiative_status initiativeId
Read an initiative's Status description — the one current line a program report (and its shared link) shows beside the initiative. `latestStatus` and `latestStatusAt` are null when none is set. Read-only.
anyforge_set_initiative_status initiativeId, latestStatus
Set or clear an initiative's Status description — the same write as 'Save status' in the console. It replaces the current line (one line, overwritten on every edit; the history is in the audit trail), is CLIENT-VISIBLE on program reports and their shared links, and is allowed at every initiative status. Pass null or an empty string to clear it. Requires `write` scope and a key owner who can edit initiatives (and act on the initiative's owning team); the write is audited as the key owner.
anyforge_list_initiative_comments initiativeId, limit, cursor
List the Discussion comments on an initiative — the same threaded comments the console renders on the initiative. Oldest first; resolved comments are included (each carries its `resolved` flag and `anchor`). Read-only. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` to get the next page.
anyforge_post_initiative_comment initiativeId, body, parentId, mentions, clientVisible, anchor
Post a Discussion comment on an initiative, into the same thread the console shows. By default it anchors to the initiative's overview (General discussion); pass `anchor` to comment on a section instead (description, contextNotes = Intake notes, brdContent, or `spec:<section>` for a Spec quote), or `parentId` to reply to an existing comment. The comment is internal unless `clientVisible` is true, which shares it with the client on shared reports. `mentions` notify members (uids from anyforge_list_members). A reply into a resolved thread is refused with `thread_resolved`: reopen it first with anyforge_resolve_initiative_comment. Requires `write` scope and an editor-capable key owner; the comment is posted as the key owner.
anyforge_resolve_initiative_comment initiativeId, commentId, resolved
Resolve or reopen a thread on an initiative's Discussion — the console's Resolve and Reopen control. Pass `resolved: true` to resolve, `false` to reopen. A comment that belongs to another initiative is refused and nothing changes. Requires `write` scope and an editor-capable key owner.
anyforge_list_programs status, limit, cursor
List programs (the cross-initiative planning grouping) with status and owner. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters` (the filters that actually ran). When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` with the SAME filters to get the next page. Optionally filter by comma-separated status (PLANNING, IN_PROGRESS, COMPLETE, CANCELLED).
anyforge_get_program programId
Get a single program by id.
anyforge_create_program name, description, status, ownerId, programLeadUid, longLived, targetDate, coverageTarget, tags
Create a program (the cross-initiative grouping). Use this to set up a body of work before adding initiatives under it. To have it take incoming requests, call anyforge_set_program_request_intake afterwards. Requires `write` scope.
anyforge_update_program programId, name, description, status, ownerId, programLeadUid, longLived, targetDate, coverageTarget, tags, testEvidenceRequired, changeFreezes
Update an existing program — only the fields you provide change. Edit its name, description, status, owner, lead, whether it is long-lived, target date, coverage goal, tags, or whether its work items need test evidence before they can be marked Done. Incoming requests are switched with anyforge_set_program_request_intake. Requires `write` scope.
anyforge_set_program_status_line programId, latestStatus
Write or clear a program's status line: the one current sentence about where the program stands, shown under its delivery health on a report's program status board. Overwrites the previous line; the history is in the audit trail. Requires `write` scope and a key holder who can edit programs.
anyforge_get_program_access programId
Read who may read a program: its `visibility` (open or private), the people (`memberUids`) and teams (`teamIds`) listed as readers, the access `revision` to send back when you change them, how its time shows to members outside it (`capacityVisibility`), whether you may change them (`canManage`) and whether this workspace may make a program private (`available`). A program you may neither read nor manage answers `not_found`, as a missing one does. Requires `read` scope and a key that acts as a person.
anyforge_set_program_access programId, visibility, memberUids, teamIds, ifRevision, confirmDeclassify
Set who may read a program: its visibility and the WHOLE lists of reader people and teams, replacing the stored ones. Read them first with anyforge_get_program_access and send its `access.revision` as `ifRevision` (the access revision, not the program's); a stale one is refused with `program_access_modified`. Private: only the listed people, members of the listed teams, the program's lead and owner and its roster read it. Only the program's lead or owner, or a company Owner, may change it. Making a program private needs private programs to be available in the workspace. Opening a private program makes everything in it visible to every member, so a first attempt is refused with `declassification_unconfirmed`: show the person that and repeat with `confirmDeclassify: true` only after they confirm. Requires `write` scope and a key that acts as a person.
anyforge_set_program_capacity_visibility programId, capacityVisibility
Set how a program's time shows to members who cannot read it: `restricted` (the default) shows it as private time, `unavailable` shows those days as unavailable (private programs only). Only the program's lead or owner, or a company Owner, may change it. Requires `write` scope and a key that acts as a person.
anyforge_set_program_request_intake programId, enabled
Turn a program's incoming requests on or off. On creates the program's "Incoming Requests" initiative, where requests filed into the program (and requests other programs forward or route to it) wait for its lead to approve and route them. Off stops new filings; the requests already waiting are left alone. Requires `write` scope and a key holder who can edit programs.
anyforge_delete_program programId, deleteChildren
Delete a program by id. By default its child initiatives are detached (kept, unlinked); pass deleteChildren: true to also delete every child initiative and its work items. This is irreversible. Requires `write` scope.
anyforge_set_program_milestones programId, milestones
Set a program's milestones/waves and the initiatives assigned to each — the whole ordered list in one call. This REPLACES the stored list: to add, rename, re-date or delete a single milestone, read the program first (anyforge_get_program), change the array, and pass the union back; an id you omit is deleted. An initiative may sit in at most one milestone — assigning it to one removes it from any other. Moving a milestone's targetDate records the move in its history when you supply targetDateReason. Requires `write` scope and a key holder who can edit programs.
anyforge_get_program_rollup programId
Read a program's rolled-up portfolio view — the same numbers the console program header shows: delivery progress, initiative and work-item counts by status, token budget/spend, and the risks list. Start here for "how is this program doing?". Read-only.
anyforge_architect_program programId, allowBriefBelowBar, acknowledgeCapacity
Run program-level architecture planning: kick the architect decomposition for EVERY still-DRAFT initiative in the program in one step (already-planned and standing-maintenance initiatives are skipped, reported per row). This spends tokens, the same tier as a single anyforge_dispatch_architect. Gated on the program brief clearing 100% ICE — a below-bar brief returns 409 `program_brief_below_bar` with the score and gaps; an OWNER may waive it with allowBriefBelowBar. Requires `write` scope and a key holder who can dispatch crews.
anyforge_approve_program_architecture programId, excludeInitiativeIds, autoDispatch, autoShip, autoRefine, allowBriefBelowBar, allowSpecBelowBar
Approve the program's rolled-up solution architecture: one review approves EVERY BACKLOG_PROPOSED initiative backlog in the program (this is HIL #1 for each), each through the canonical backlog approval. Hold initiatives back with excludeInitiativeIds. Auto-dispatch keeps its default unless you pass autoDispatch: false to approve the plans but hold the crews. Requires `approve` scope and a key holder who can dispatch crews.
anyforge_list_program_comments programId, limit, cursor
List the Discussion comments on a program brief — the same threaded comments the console renders on the program. Oldest first; resolved comments are included (each carries its `resolved` flag and `anchor`). A comment written by a shared-report reader is marked `external: true` and shows the author's display name only (never an email). Read-only. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` to get the next page.
anyforge_post_program_comment programId, body, section, parentId, mentions
Post a Discussion comment on a program brief, into the same thread the console shows. By default it anchors to the brief's `overview` section; pass `section` to target another brief section, or `parentId` to reply to an existing comment. The comment is always stored private to the team — there is no way to make it visible to a client from here. Requires `write` scope and an editor-capable key owner.
anyforge_get_program_brief_context programId
Read a program's active structured Brief (BRD), version history, legacy rendered mirror, and ICE readiness. Use this before preparing a replacement version.
anyforge_save_program_brief_version programId, problemStatement, solutionSummary, mlpScope, userStories, successMetrics, financialModel, technicalScope, context, dependencies, assumptions, nonFunctionalRequirements, complianceRequirements, nonGoals, naSections
Save a complete, structured, versioned Program Brief (BRD). The previous active version is archived, the rendered markdown mirror is updated, and revenue impact is computed server-side. This replaces the retired free-form anyforge_write_program_brief tool. Requires problemStatement and solutionSummary.
anyforge_update_program_initiative programId, initiativeId, repoFullName, appendContext, description, priority
Enrich one existing initiative within a program. Prefer initiativeId; repoFullName is allowed only when that repository has one initiative in the program. Pass appendContext for factual context, or change description/priority. A description change on an ICE-spec initiative is rejected with the revise_program_initiative_scope replacement. The result reports changed fields or a structured no-op.
anyforge_close_program_initiative programId, initiativeId, action, reason, note, proposalToken
Early-close one initiative in a program with completed-elsewhere, wont-do, duplicate, or superseded. Call action=preview first, present the returned impact, then call action=execute with only the proposalToken. The operation yields CLOSED, cancels active crews, and drops outstanding work items.
anyforge_close_program_work_items_as_fixed programId, action, closures, proposalToken
Batch-close unique, non-terminal work items already fixed outside AnyForge. Call action=preview with closures, present the linked impact, then call action=execute with only proposalToken. Each closure needs workItemId and closedReason; closedAsFixedByWorkItemId is optional.
anyforge_get_program_intake_definition programId, version
Read a program's intake definition: the typed form its intake agent interviews against, which checklist actually applies (the program's own, or its skill's), the current version and revision, and the version history with what each version changed. Pass `version` to read one version in full.
anyforge_set_program_intake_definition programId, checklist, checklistName, customInstructions, ifRevision, reason, acknowledgeImpact, dryRun
Edit a program's intake definition. Send only the keys you change; null clears one. Every change is saved as a new version that can be restored. A change that removes or changes items open requests already hold answers for is refused with the impact until you repeat it with acknowledgeImpact; use dryRun to see the impact first. Filed requests are never re-gated.
anyforge_restore_program_intake_version programId, version, ifRevision, reason, acknowledgeImpact, dryRun
Republish an earlier version of a program's intake definition as a NEW version (history is never edited). Same impact rule as editing: dryRun first, acknowledgeImpact to proceed.
anyforge_set_program_intake_routing programId, rules, ifRevision
Replace a program's intake routing rules: where its intake agent sends a completed request on, by the reporter's answers to its choice questions. Send the WHOLE list (read the current one, and the `revision`, from anyforge_get_program's `intakeAgent.routing`); `[]` removes them all. A rule matches when every `when` condition holds, and the first match wins. Each condition must name a choice question and an answer the program's checklist offers (add a new answer with anyforge_set_program_intake_definition first), and each destination must take requests. Only the program's lead or owner may set them. Rules apply to requests completed after the change; a request already filed is not moved.
anyforge_get_intake_request_details initiativeId, workItemId
Read one program intake request's details: the program's intake definition read against the answers the request holds. Every field comes back in the definition's order and groups with its state (answered, suggested, open, does not apply), the answer, who gave it and whether it can be edited. `applicable: false` means the record is not an intake request.
anyforge_edit_intake_request_details initiativeId, workItemId, edits
Change a program intake request's answers by hand: set a value, mark an item as not applying (with a reason), confirm a suggestion, or clear one. Values are checked against the definition (kind, options, secrets); a person is a name and an optional email, and the platform links an AnyForge member from the email itself. Send `expectedAt` (the answer's `at` from the read, or null) so a concurrent change is refused instead of overwritten. The edit is audited; it does not re-open approval or notify followers. Requires `write` scope and a key holder who can edit initiatives.
anyforge_create_opportunity title, description, type, source, themeId, dueDate, rice, evidence
Create an opportunity — a validated problem or possibility worth pursuing. Opportunities are the bridge between raw signals and themed roadmap work. Requires `write` scope.
anyforge_list_opportunities limit, cursor
List opportunities in the Product (product-planning) layer. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` with the SAME filters to get the next page.
anyforge_list_signals limit, cursor
List signals in the Product (product-planning) layer. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` with the SAME filters to get the next page.
anyforge_list_themes limit, cursor
List themes in the Product (product-planning) layer. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` with the SAME filters to get the next page.
anyforge_create_signal title, body, source, requesterName, requesterContact
Capture a signal — a raw data point, customer quote, support ticket, or market observation that may inform product direction. Signals are refined into opportunities. Requires `write` scope.
anyforge_create_theme name, description, objective, status
Create a theme — a.k.a. a CLUSTER, and the same record as the delivery program it drives. Themes give the roadmap structure above individual initiatives and are what the strategy layer ties to. Requires `write` scope.
anyforge_promote_opportunity id, codebaseId, githubRepo, githubBranch, programId
Promote a prioritized opportunity into a Program + Initiative (starts delivery/Genesis). Requires a codebaseId or githubRepo. Requires `write` scope.
anyforge_update_signal id, title, body, source, status, opportunityId, requesterName, requesterContact, archived
Update an existing signal — edit its status, linked opportunity, source, or other fields. At least one field must be provided. Requires `write` scope.
anyforge_update_theme id, name, description, objective, standsToday, fundingSource, stopCondition, waitsFor, dependsOnThemeIds, status, color, ownerId, tags, archived
Update a theme (a.k.a. cluster — the same record as its delivery program): name, status/horizon, colour, and the CHARTER lines (standsToday, fundingSource, stopCondition, waitsFor, dependsOnThemeIds). A theme carries no strategy link: the objectives it serves are derived from the key results its program's initiatives name (anyforge_set_initiative_key_results). fundingSource + stopCondition are what delivery condition 4 checks; dependsOnThemeIds is what condition 5 walks. Changing `status` MOVES the cluster between horizons and is the only place that can be done. At least one field must be provided. Requires `write` scope.
anyforge_update_opportunity id, title, description, stage, themeId, programId, timeCriticality, rice, evidence, archived
Update an existing opportunity — edit its RICE inputs, stage, theme assignment, program link, or other fields. At least one field must be provided. Requires `write` scope.
anyforge_delete_opportunity id
Permanently hard-delete an opportunity by ID. This is irreversible — prefer archiving (anyforge_update_opportunity with archived: true) unless you are certain. Requires `write` scope.
anyforge_delete_signal id
Permanently hard-delete a signal by ID. This is irreversible — prefer archiving (anyforge_update_signal with archived: true) unless you are certain. Requires `write` scope.
anyforge_delete_theme id
Permanently hard-delete a theme by ID. This is irreversible — prefer archiving (anyforge_update_theme with archived: true) unless you are certain. Requires `write` scope.
anyforge_get_strategy
Read the whole strategy in one call: pillars, their objectives, the key results measuring each (baseline → target → current with attainment), the delivery rollup per pillar, every cluster with its horizon and outstanding charter lines, how many open initiatives are linked to no key result, and the five delivery conditions. The same assembler the console renders from. Start here for any OKR question.
anyforge_list_pillars limit, cursor
List the strategy pillars — the standing parts of the strategy, each with one accountable lead. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` with the SAME filters to get the next page.
anyforge_create_pillar name, description, ownerUid, sortOrder
Create a strategy pillar. Requires `write` scope.
anyforge_update_pillar id, name, description, ownerUid, sortOrder, archived
Update a pillar: name, description, lead (ownerUid), order, or archived. Requires `write` scope.
anyforge_delete_pillar id
Permanently delete a pillar. IRREVERSIBLE, and refuses with 409 `pillar_has_objectives` while any objective still sits under it — move or delete those first. Requires `write` scope.
anyforge_list_objectives pillarId, limit, cursor
List the objectives — what each pillar has to reach, written as outcomes. Narrow to one pillar with `pillarId`. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` with the SAME filters to get the next page.
anyforge_create_objective pillarId, statement, description, ownerUid, sortOrder
Create an objective under a pillar. Rejects a pillarId that does not exist. Nothing rolls up to a new objective until a cluster is tagged with it via anyforge_update_theme. Requires `write` scope.
anyforge_update_objective id, statement, description, ownerUid, pillarId, sortOrder, archived
Update an objective: statement, description, owner, parent pillar, order, or archived. Requires `write` scope.
anyforge_delete_objective id
Permanently delete an objective. IRREVERSIBLE. Refuses with 409 `objective_has_key_results` while measures still hang off it; work reaches an objective only through those, so nothing else is affected. Requires `write` scope.
anyforge_list_key_results objectiveId, limit, cursor
List the key results — the measures that say whether the objectives are being reached. Narrow to one objective with `objectiveId`. ONE PAGE per call (50 by default, 100 max): the result carries `meta` with `hasMore`, `nextCursor` and `appliedFilters`. When `meta.hasMore` is true, pass `meta.nextCursor` back as `cursor` with the SAME filters to get the next page.
anyforge_create_key_result objectiveId, label, unit, direction, baseline, target, current, ownerUid, sourceKind, derivedMetric
Create a key result under an objective. Set direction to "down" for measures that must FALL (cost, latency, days-to-live) or attainment reads improvement as failure. Without a baseline AND a target the measure cannot be scored and reports as not-measured rather than 0%. Set derivedMetric to have AnyForge compute it instead of a person entering readings. Requires `write` scope.
anyforge_update_key_result id, label, unit, direction, baseline, target, current, ownerUid, objectiveId, sourceKind, derivedMetric, archived
Update a key result, including recording a new READING — send current as { value, asOf, source }. Always cite a source: a measure with no source fails delivery condition 2, which is what stops one number being quoted two ways. Requires `write` scope.
anyforge_delete_key_result id
Permanently delete a key result. IRREVERSIBLE — the reading history goes with it. Consider archiving instead. Requires `write` scope.
anyforge_get_initiative_key_results initiativeId
Read which key results one initiative moves, whether anyone has decided (`linked`; false = orphan work), the objectives those measure, and every live key result it could name.
anyforge_set_initiative_key_results initiativeId, keyResultIds
Say which key results one initiative moves — the one write that ties delivery work to the strategy. Any number, under any objectives and pillars. REPLACES the list: to add one, read the current list first and pass the union. Pass [] for enabling work that moves none on its own, or null to clear the answer (it then reads as orphan work). A program's key results and objectives are derived from its initiatives. Requires `write` scope and a key holder who can edit initiatives.
anyforge_get_horizons
Read the per-horizon narrative: what the company looks like at each stage and the "we know it is done when" criteria. Keyed by stored status NOW / NEXT / LATER, where LATER is shown as "Beyond".
anyforge_set_horizon_narrative NOW, NEXT, LATER
Write the narrative for one or more horizons. Send a key per stage: { "NOW": { title, narrative, doneWhen } }. This writes the STORY only — which clusters sit in a horizon is set by anyforge_update_theme status, the single place that can change. Requires `write` scope.
anyforge_get_cluster_charter id
Read one cluster's charter by THEME id: the pillar, objective and owner it sits under, its initiatives and their running/resourced/new split, the window, milestones, the measures it moves, funding source, stop condition, dependencies, and which charter lines are still owed. Edit the written lines through anyforge_update_theme — they live on the theme, so there is one writer.
anyforge_list_crews status, activeOnly, limit
List company crews for discovery, newest first. Filter by comma-separated status values or use activeOnly=true to find crews that are still running, paused, or waiting for review.
anyforge_get_crew crewId, messages, shape
Get a crew with its recent chat messages (the crew output) and operator comments. Use this to see what a crew produced and where it stands. The crew leads with `status`, `currentNode`, the halt or error reason (`haltCode`, `errorCode`, `errorMessage`), `pendingPermissionRequest`, its work item, initiative, `prUrl` and timestamps; these are never left out. By default (`shape: "summary"`) text over 1,000 characters is excerpted and named in `excerptedFields`, and any other value over 2,000 characters (the skill, decision-context and execution-memory snapshots) is left out and named with its size in `omittedFields`; chat and comment entries get the same treatment one by one, each naming its own. For status only, pass `messages: 0`: a few KB. Pass `shape: "full"` only when you need a left-out field in full; a full crew can run past 70,000 characters. When the repository uses AWS CodeArtifact the crew also carries `codeArtifactAttempt`: why a registry token was or was not issued (failing AWS call, missing permission, the stored key's identity). The returned crew carries `url` — its Console page; when you show the crew to the user, render its id/name as a link to that url. Reviewer verdicts (`architectVerdict`, `securityVerdict`, `qaVerdict`) come with `<field>Label`, the word the Console shows, and `<field>Outcome` (`clean`, `non_blocking` or `blocking`). `NEEDS_REVISION` is non-blocking and the Console labels it "Advisory"; the Console's "Needs revision" means the blocking `FAIL`.
anyforge_post_crew_comment crewId, body, messageId, mentionedUids
Post an operator comment on a crew (optionally @-mentioning teammates by uid). Comments are for people: the crew does not read them, and a comment does not resume or redirect a crew. To steer a crew that is running, use anyforge_message_crew. To send a crew waiting at its approval gate back to work with instructions, use anyforge_amend_crew. Requires `write` scope.
anyforge_message_crew crewId, body, idempotencyKey
Message a crew's Engineer while it works, e.g. "skip X", "do not touch file Y", "check Z first". The running Engineer reads it before its next step and confirms in the crew chat; one that has not started reads it on its first step, and one stopped inside the Engineer reads it when resumed. The result says which: delivery is next_step, on_start, on_resume, or next_round for a crew working outside its Engineer (an amend on its way in, review), which reads it the next time the crew is sent back to it. A crew where nothing will read it is refused with crew_not_reading_messages, whose nextStep says what to do: at an approval gate use anyforge_amend_crew; stopped outside its Engineer, resume with guidance; finished, retry. A message steers the work, it does not approve, reject or ship anything. Pass an idempotencyKey to retry safely. The body is limited to 4000 characters (max 4000 characters, not bytes), counted after trimming; a longer one is refused with body_too_long, which states the limit. Requires `approve` scope.
anyforge_resume_crew crewId, guidance
Resume a PAUSED or HALTED crew from its last checkpoint: the same action as the Console's Resume button. The crew continues where it stopped, so one whose Engineer declared itself blocked runs the Engineer again, reading the messages queued for it while halted. To send an open pull request to review without an Engineer round, use anyforge_resume_crew_with_pr. Pass `guidance` for "Resume with guidance": the Engineer's first resumed round runs with that text and the queued messages, in this one call. On a crew halted at its ship gate, guidance is that gate's amend (refused like anyforge_amend_crew). A crew the guidance cannot reach is refused with not_resumable and the guidance is not stored: one that is not paused or halted, or one paused at a gate; use anyforge_amend_crew there. Requires `approve` scope.
anyforge_halt_crew crewId
Halt a crew (terminal stop). Idempotent on already-finished crews. Requires `approve` scope.
anyforge_amend_crew crewId, notes, postToPullRequest
Continue & finish: send a crew waiting at its HIL gate back to the engineer with guidance — it resumes work on the SAME PR (capped at the amend limit). This is the "Continue" option alongside submit_approval APPROVE (ship) / REJECT (stop). A crew halted at its ship gate is resumed with the notes; refused with pr_merged or pr_closed when its pull request merged or closed after the halt. A crew already running is not refused: the amend is queued (queued: true) and appliesAt says when: next_step (the Engineer reads it before its next step) or ship_card (held on its next ship card as a pending Resume, sent from there). A finished crew is refused with no_pending_approval and a nextStep. Requires `approve` scope. Only call when the operator explicitly asks to amend/continue — never on your own judgement of the reviews.
anyforge_fix_crew_ci crewId, notes, outOfScope
Fix CI: send a crew whose pull request has failing checks back to the Engineer to fix them on the same PR. Works from PR review (HIL_SHIP) or a HALTED/PAUSED crew that has a PR; refused when GitHub does not report CI as failing. Requires `approve` scope and spends crew tokens. Only call when the operator asks.
anyforge_resume_crew_with_pr crewId, prUrl
Review & approve: take a HALTED or PAUSED crew's already-open pull request through the specialist reviews to the approve & merge gate, without re-running the Engineer. Omit prUrl to use the PR stored on the crew. A merged PR is refused. Requires `approve` scope.
anyforge_decide_crew_permission crewId, decision, comment, approvalId
Approve or deny the permission a crew in PERMISSION_PENDING is waiting on (see pendingPermissionRequest on anyforge_get_crew). A tool permission applies for the rest of the run; an MCP write approval decides that one call. Pass approvalId to refuse a decision on a newer request. Requires `approve` scope. Only call when the operator decides.
anyforge_upload_coverage items, repo, percent, lcov, commitSha, branch, measuredAt
Upload test-coverage measurements for one or many repos (e.g. synced from SonarQube). Requires `write` scope. Each item needs repo ("owner/name") and either percent (0–100) or a raw lcov report. percent is LINE coverage: from SonarQube read the `line_coverage` measure, not `coverage`, which also counts branch conditions and so does not compare with other sources. Optionally send branch and measuredAt (the analysis date) per item: a reading for a non-default branch, or older than the stored figure, is kept as history only. Writes coverage to the matching codebase + the org repo index, so a Program Genesis quality program can scope "repos below X%". Batch up to 200 items per call — chunk larger syncs. Map SonarQube projects to owner/repo via their GitHub binding before calling; ask the operator about any you can't map.
anyforge_list_repo_index activityStatus, language, belowCoverage, limit
List the repositories in this company's org-level repo index, with activity classification (active = pushed recently, stable = no recent pushes, deprecated = archived), whether each repo already has an AnyForge analysis, and its known coverage %. Use this FIRST when scoping a program to discover candidate codebases. Defaults to active repos. To scope a coverage/quality program in one shot, pass belowCoverage (e.g. 90) — returns only repos with known coverage below it, worst-first. The result includes total counts so you know how many were omitted by the cap.
anyforge_get_repo_analysis repoFullName
Get the AnyForge analysis summary for a single repo (coverage %, architecture red/amber/green counts, open gap count, languages) to assess its relevance and distance from the program goal. Returns `analyzed: false` with a note when the repo has no analysis yet — it can still be scoped in. Call this for the handful of repos you are unsure about, NOT for every repo in a large org.
anyforge_check_dispatch_readiness workItemId, repoFullName
Check what would stop a crew starting, without launching one. Pass `workItemId` to run every dispatch gate for that work item (its id or its code) and get ALL the blockers at once in `blockers` (role, item state, who may dispatch it, the initiative's task tracker, approval, program brief, spec and plan, intake, write scope, repository, team, dependencies, analysis, GitHub connection); `ready` is true only when there are none. Pass only `repoFullName` to check just that repository's Phase 1 + Phase 2 analysis gate. GitHub scopes and permissions, the base branch and the budget are still checked when the crew is started.
anyforge_analyze_repos repos
Start Phase-1 codebase analysis for one or more repos. Idempotent — already-analyzed repos return `already_analyzed`, in-flight ones `already_running` (never re-run). Up to 25 repos per call; chunk larger sets or use anyforge_start_coverage_sweep instead. Requires `write` scope.
anyforge_start_coverage_sweep programId, repos, concurrency
Launch a hands-off, paced analysis sweep: runs Phase 1 across every repo, then Phase 2, keeping at most `concurrency` analyses in flight so the operator OAuth token window is never exhausted. Seed from a programId (derives repos from its initiatives) or an explicit repos list. Re-seeding overwrites the current sweep. Requires `write` scope.
anyforge_refresh_repo_index
Refresh the org repo index now instead of waiting for the nightly sweep. Re-lists every repo's metadata AND auto-detects COMMITTED coverage: for repos with no crew/CI coverage, it reads the repo tree for a checked-in coverage report (lcov.info, coverage-summary.json, cobertura, clover) and records the parsed %, so a repo that publishes coverage in git shows a number without a crew run or a manual upload. Runs in the background — re-read the repo index / coverage panel shortly after. Requires `write` scope.
anyforge_request_pr_review repo, prNumber
Request an AnyForge review of an existing pull request: the same review that commenting "@anyforge review" on it produces and posts on the PR. No crew, work item or initiative is needed, and nothing is merged, approved or pushed. Returns as soon as the review is queued (queued: true); the review covers the PR head at the time it runs. If the PR already has a review for its current head, the existing review's status is returned (queued: false) and no second review is posted. Refused with a stated reason when: the caller is not an owner or operator, the caller has not connected GitHub, the workspace setting "Review pull requests opened outside AnyForge" is off, the repository is not connected, the PR is unknown, a draft, closed or opened by AnyForge or one of its crews, or a per-PR or daily review limit is reached. Requires write scope and a key that belongs to a person.
anyforge_list_escrow_deposits codebaseId, repo
List escrow deposit bundles (the tamper-evident deposit ledger). Filter by codebaseId or repo ("owner/name"); omit both for the whole company. Each entry has commitSha, bundleSha256, sizeBytes, downloadUrl, createdAtMs, and voidedAtMs/deliveredAtMs when set.
anyforge_generate_escrow_deposit codebaseId, repo
Generate a source-escrow deposit bundle for a codebase (source @ pinned commit + generated doc set + obligations manifest + dependency register + handover runbook, one zip). Requires `write` scope. Pass codebaseId or repo ("owner/name"). Returns depositId, commitSha, and a downloadUrl. Generation takes up to a few minutes for large repos.
anyforge_list_escrow_scope
List the codebases currently in escrow scope (the "In escrow scope" checkbox / codebase escrow.enabled). Returns entries with codebaseId, repoFullName, and clientTag, plus the company's total codebase count — the set an escrow sweep will cover.
anyforge_set_escrow_scope repos, codebaseIds, enabled, clientTag
Bulk-set the "In escrow scope" checkbox (codebase escrow.enabled) across many codebases in one call — scope a whole fleet into (or out of) the escrow deposit sweep without clicking per-codebase checkboxes. Requires `write` scope. Target by repos ("owner/name") and/or codebaseIds, up to 1000 per call. Repos with no codebase yet (not analyzed) come back in `unmatchedRepos` — run Phase-1 analysis first, then retry those. Optional clientTag tags every matched codebase for one beneficiary; disabling never clears an existing tag.
anyforge_start_escrow_sweep onlyStale, clientTag, concurrency, status, verifyBuilds
Seed a fleet-wide escrow deposit sweep over all escrow-scoped codebases (codebase escrow.enabled). Requires `write` scope. A 10-minute server tick advances it at ≤concurrency deposits in flight. Options: onlyStale (default true — skip fresh deposits), clientTag (one beneficiary only), concurrency (1–5), verifyBuilds (also measure a build+test run per codebase alongside the deposit). Pass {status: true} to just read current sweep progress without seeding.
anyforge_escrow_scoping_report clientTag, store
Generate the Escode/escrow-agent scoping-answers report (markdown) over all escrow-scoped codebases: repo list, languages, MEASURED build times + machine spec, CI/CD tooling, Terraform topology + database counts, deposit status, test-data position. Fields the platform cannot measure are marked OPERATOR INPUT REQUIRED. Optional clientTag filters to one beneficiary; store=true also persists the markdown to Storage (part of the delivery pack sent to the escrow agent) and returns its downloadUrl. store=true requires `write` scope.
anyforge_deliver_escrow_deposit depositId, force
Deliver a stored escrow deposit bundle to the configured escrow agent over SFTP (companies escrowDelivery config + the company's own SFTP key). Requires `write` scope. Stamps the ledger with deliveredAt + a delivery receipt (remotePath, bundleSha256).
anyforge_ask_oracle question, context, maxContinuations
Ask the AnyForge Oracle a question about this workspace: programs, initiatives, codebases, analyzed-codebase docs, releases, recorded decisions — AND live data from the connected integrations (e.g. "top 10 payment errors in production over the last 7 days" via a connected Datadog). The Oracle runs its own multi-step research loop server-side and returns one final, source-cited answer, so ask the FULL question in one call instead of decomposing it yourself. Read-only; answers are company-scoped. A research turn can take a few minutes, so this call waits up to ~40s: if the result has status "done" it carries the answer; if it has status "running", call anyforge_get_oracle_answer with its askId (repeat while it stays "running"). Do NOT call anyforge_ask_oracle again for the same question — that starts a second turn. A turn that runs out of time is continued server-side automatically (up to maxContinuations extra turns, default 2), so long answers such as a full program brief arrive whole: keep polling rather than asking "continue". A "done" answer with investigationTruncated: true used every continuation; ask a narrower follow-up for what it left out.
anyforge_get_oracle_answer askId
Get the answer to a question started with anyforge_ask_oracle that came back with status "running". Waits up to ~40s per call. Status "done" carries the answer; "running" means call this again with the same askId (it never re-runs the question; a "leg" above 1 means the server is continuing a turn that ran out of time). An error means the turn failed or the askId is unknown/expired (asks are kept for a day).
anyforge_investigate_repository question, repos, context
Ask AnyForge to investigate a repository question for another engineering agent. Select one to five repositories exactly as returned by anyforge_list_repo_index. AnyForge runs a bounded, read-only investigator over the selected repositories' indexed code graph, semantic code search, and analyzed-codebase docs, then returns a concise evidence-backed report with index provenance. It does not expose raw graph records, live source, connected systems, or write tools. Use this when the caller needs repository intelligence without making the Oracle the intermediary. An investigation can take a couple of minutes, so this call waits up to ~40s: if the result has status "done" it carries the report; if it has status "running", call anyforge_get_repository_investigation with its jobId (repeat while it stays "running"). Do NOT call anyforge_investigate_repository again for the same question - that starts a second investigation. Requires read scope.
anyforge_get_repository_investigation jobId
Get the report of a repository investigation started with anyforge_investigate_repository that came back with status "running". Waits up to ~40s per call. Status "done" carries the report; "running" means call this again with the same jobId (it never re-runs the investigation). An error means the investigation failed or the jobId is unknown/expired (investigations are kept for a day). Requires read scope.
anyforge_list_workflows
List the company's Operator Workflows — reusable, deterministic multi-step orchestrations (agent / tool / parallel / map / gate steps). Returns each workflow's id, name, description, enabled flag, current version, and declared inputs (in spec.inputs).
anyforge_get_workflow workflowId
Get one Operator Workflow including its full current spec (steps, inputs, budget). Use this before anyforge_run_workflow to see which inputs the workflow requires.
anyforge_run_workflow workflowId, inputs
Dispatch a run of an Operator Workflow. Returns the QUEUED run (id, pinned version, per-step states) — poll anyforge_get_workflow_run for progress. Runs pause at gate steps for an operator decision. Requires `write` scope. Only dispatch when the operator asked for it — a run spends tokens.
anyforge_get_workflow_run runId
Get a workflow run's status and per-step progress (stepStates keyed by step id; pendingGateStepId is set while the run waits at a gate). Gate decisions are made by an operator on the Console run page or via anyforge_resolve_workflow_gate.
anyforge_resolve_workflow_gate runId, decision, comment
Resolve a workflow run that is paused at a gate step (see pendingGateStepId on the run). approve lets the run continue; reject stops it; amend continues with operator guidance (pass it in comment). Requires the `approve` scope — the same gate as crew HIL decisions.
anyforge_retry_workflow_run runId
Retry a FAILED workflow run from the step that failed. Steps that finished are not run again, and a map step keeps the items it had already answered, so only the unfinished work is paid for again; the run keeps its id and accumulated spend. Refused for a run that did not fail on a step, and for a failed crew step (resume its crews instead). Runs on the company key. Requires the `write` scope.
anyforge_triage_ticket text, sessionId, repos, context, externalUserRef, format
Run or continue a Support Triage interview: classify the issue (incident / bug / enhancement / misconfiguration / new_feature), score it against that type's readiness rubric, resolve the likely owning team from the code graph, and return a paste-ready rendering plus the structured draft. Pass the SAME sessionId returned by a prior call to continue the SAME interview — the server owns the conversation, the caller only ever sends the newest message. Never files or writes anything; take `rendered` and file it wherever you actually track issues.
anyforge_run_triage_eval audience, caseIds, contextMode
Evaluate current-mode cases by default, or select historical saved-snapshot mode (at most 20 cases). Eligible cases consume model tokens; neither mode files tickets. A corpus of 10 or fewer cases runs synchronously and this call returns the completed run directly. A larger corpus (this is the path a real 50-case corpus takes) instead returns a QUEUED run immediately — poll it with anyforge_get_triage_eval_run until status is completed or halted_payment_required. Historical missing evidence is unavailable; inspect historicalCoverage and historicalVerdict.
anyforge_save_triage_evidence_snapshot source, sourceId, sourceRevision, validAt, availableAt, audience, text, repoFullName, teamId
Save supplied source text as immutable historical triage evidence. No upstream fetch or model call. Requires integration-management role and write scope. Chronology is author supplied, not independently verified.
anyforge_get_triage_evidence_snapshot snapshotId
Read a saved immutable snapshot from the current company. Requires integration-management role and read scope.
anyforge_get_triage_eval_run runId
Poll a triageEvalRuns run by id — for a large corpus (more than 10 cases) anyforge_run_triage_eval returns a QUEUED run immediately rather than waiting for it to finish; call this to check progress and read the completed result once status is completed or halted_payment_required. Safe to call repeatedly.
anyforge_list_triage_eval_cases
List current triage evaluation cases for this company; historical cases require an integration-management role.
anyforge_upsert_triage_eval_cases cases
Create or update triageEvalCases in bulk — pass every case in ONE call, including a full corpus. Each case needs `input` (the ticket text) and `expectedType` (incident / bug / enhancement / misconfiguration / new_feature); `expectedTeamId` is optional and, when set, ALSO scores routing accuracy. Pass an existing case's `id` to update it in place — re-uploading the same corpus updates rather than duplicates. Returns `created` (the cases that saved) and `errors` (per-index validation failures) — a bad row does not fail the whole batch.
anyforge_update_triage_eval_case caseId, input, expectedType, expectedTeamId, repoFullName, audience, notes, historical, expectedAction, expectedRepoFullName
Edit one triageEvalCases entry in place — only the fields you provide change. Use to fix a case's ticket text, expected classification, expected owning team, or metadata. To update many cases at once, prefer anyforge_upsert_triage_eval_cases (pass each case's id). Requires `write` scope.
anyforge_delete_triage_eval_case caseId
Delete one triageEvalCases entry by id.
anyforge_list_observability_signals status, limit
List production-error triage signals for your company (grouped, deduped alerts from connected observability providers). Optionally filter by status.
anyforge_accept_observability_signal signalId, codebaseId, repo, severity, impact
Accept a production-error signal — the operator approval that turns it into a governed INCIDENT under the company's KTLO program. The target codebase resolves from codebaseId → repo → the signal's service; if none resolves the call returns codebase_required. Requires `write` scope.
anyforge_dismiss_observability_signal signalId, reason
Dismiss a production-error signal as noise — it won't be resurfaced by later occurrences. A signal already filed as an incident cannot be dismissed (returns already_filed). Requires `write` scope.
anyforge_list_audit_events eventType, actor, from, to, limit, cursor
Read one page of the company's hash-chained audit trail, oldest first. Requires an API key with the `audit:read` scope, held by an owner (an ordinary read key gets insufficient_scope). Filters: eventType (one or several, e.g. ["HIL_APPROVED","CREW_HALTED"]), actor (a uid), from / to (ISO 8601 or epoch ms). limit 1–500 (default 100). Pass the previous page's nextCursor as cursor to continue. Each entry carries sequence, hash, prevHash and sealVersion; a page read without eventType/actor is a contiguous run of the chain (chainContiguous: true) that can be verified.
anyforge_whoami
Who this connection acts as: the key owner's `userId` (uid), `userName` and current `role` in the workspace (the role the console would apply to the same action), the `scopes` the credential carries, the workspace (`companyId`, `companyName`) and its entity vocabulary. Use `userId` as the "me" in assigneeUid, mentions and similar fields; to find a teammate's uid use anyforge_list_members. `userId`, `userName` and `role` are null for a key with no owner. Read-only; any valid credential may call it.

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Install facts

LicenseUNLICENSED
Needsnode >=22
Sourcenot stated
Install scriptsNone declared by it or anything installed with it.
Tarballsha512-cEDfMJ1ONamHU7t123HQ+WE2bJvGj/EJV1WJMEnlvzgo/sPk9tWSeQbPaM1+3FTQYzNBcnHVp4E11A7uDEEZ5w==

Check this report yourself

This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/@anyforge/mcp-server.svg)](https://bragproof.smaverk.com/r/%40anyforge/mcp-server)

New version out? Ask for a fresh report.