Forge exposes its full tool surface to ChatGPT through ChatGPT's Developer Mode. You bring ChatGPT; Forge gives it tasks, forms, artefacts, surveys, a knowledge graph, and per-tenant SQLite, all reachable through MCP. Forge does not run an agent of its own.
https://forge-base.com/mcp
Transport: Streamable HTTP (MCP 2025-03-26 spec). Auth: OAuth 2.0 with PKCE. The OAuth server metadata is published at /.well-known/oauth-authorization-server.
ChatGPT supports direct MCP connections through its Developer Mode. This is the way to connect ChatGPT to Forge.
Note: Developer Mode MCP is still in OpenAI beta. Business and Enterprise accounts need an admin to enable Developer Mode first.
In ChatGPT, go to Settings (gear icon) and open Apps (or Advanced). Find the Developer mode toggle and switch it on. On Business or Enterprise plans, a workspace admin must enable this in the organisation settings before individual users can access it.
Once Developer Mode is on, open the Apps panel and choose Create app.
Fill in the form:
| Field | Value |
|---|---|
| App name | Forge (or any label you prefer) |
| MCP server URL | https://forge-base.com/mcp |
| Authentication | OAuth |
Tick the risk acknowledgement checkbox, then click Create.
ChatGPT will prompt you to Sign in with Forge. Enter your Forge email and password on the consent page (if you already have a Forge session open in the same browser, you go straight to the consent page with no password prompt). Click Approve to grant the app access.
After sign-in the app is connected. You can start using Forge tools immediately in any conversation.
Each mutating action (creating a task, writing a record, publishing an artefact) prompts a one-time confirmation dialog in ChatGPT before the tool call executes. This is an OpenAI safety mechanism for Developer Mode apps, not a Forge restriction.
Developer Mode not visible: You may need to update the ChatGPT app or refresh the web app. On Business/Enterprise, confirm your admin has enabled it for the organisation.
OAuth redirect fails: Try the flow in a private/incognito window. If you have an active Forge admin session in your normal browser, the consent page may authenticate you as that admin instead of the intended user.
A tool call returns 403: The authenticated user does not have access to the workspace you are targeting. Ask your Forge admin to grant you access (see Getting access).
A call returns unknown_argument: The error names the rejected fields and accepted arguments for that operation. Argument-key rejections can also include details.didYouMean, with a suggestedArgument or suggestedOperations (each names an operation and its accepted argument), plus explanatory details.hints. These are suggestions only: Forge does not rename fields, retry, or execute a different operation. Existing operation-specific corrections take priority over generic suggestions.
Generic sibling suggestions stay between read operations. A write does not suggest a different operation unless the rejected argument names that operation, or the sibling is the bulk form of the same write in the same safety bucket. For example, table query with sql points to operation sql with argument query; table insert with rows points to bulk-insert. Task delete takes no reason: record the reason in a task comment first, then delete. supersede is appropriate only when another task replaces this one. Task get uses section and cursor for paging, rather than limit.
Opening large files. When a file is too large to inline, manage_file read returns a viewUrl for the signed-in Forge file page and a downloadUrl for GET requests with the caller's own Forge bearer token. PDF bakes that produce an artefact return a viewUrl for viewing the artefact in Forge.
ChatGPT does OAuth once. The token persists and is sent as a Bearer header on every subsequent MCP call. Identity is preserved in the audit log: every tool call records actor: <user.handle> so workspace activity is attributable per-user. Tokens expire after 1 hour; refresh happens automatically using the refresh_token grant.
All tool calls are scoped to the workspaces the authenticated user has been granted access to. ChatGPT cannot read or write workspaces the user was not explicitly granted.
Pass a workspace address or the returned canonical wsp_* ID in workspace arguments. Use each operation's live help response for its current parameters.
Workspace admins and platform admins can use forge_read with resource manage_workspace, operation list-member-clients and args { "slug": "your-workspace", "userId": "usr_member" }. Omit userId for all current members. Editors and viewers are refused by the existing member-admin gate.
The response contains only clients with successful owner-attributed OAuth request completions whose server-checked authorized_workspace matches that workspace. A shared member's clients used only elsewhere are excluded. Each client has its id, registered name (or id fallback), first/last issuance among retained account token rows, status (active or no-active-token) and last successful activity in this workspace from security_audit_event.occurred_at. All dates are UTC ISO strings; missing issuance dates are null. Token values, hashes and secrets are never returned.
OAuth grants are account-wide. This operation does not treat every token held by a member as evidence of workspace use. Unused clients and trimmed security history are absent. The security log keeps a 30-day window; older events are trimmed only after verified acknowledgement of their archived day-files. This operation reads the retained local log, not the archive. Caller-supplied workspace labels in legacy mcp_audit telemetry and facade fallback attribution do not establish client visibility. Rotation/deletion can remove earlier issuance dates; no-active-token covers revocation, expiry or deletion, which existing records cannot distinguish. Issuance dates are account-wide for the listed client, while visibility and activity are workspace-specific. The response's coverage fields state these limits.
Forge exposes four MCP tools split by effect: forge_read (no changes), forge_create (adds), forge_update (changes in place) and forge_delete (removes). Each takes { resource, operation, args }; the resources below are the values of resource. Pass operation: "help" to any tool for the live list of operations and parameters.
Operations that permanently remove data and cannot be restored require confirm: true, which means the user confirmed this exact action. Existing operation-specific acknowledgements still apply.
| Resource | What it does |
|---|---|
manage_workspace |
Read and update workspace profile, styling, and brand voice |
manage_task |
Full task lifecycle plus atomic reconcile/settle through forge_update. The aliases require taskId + expectedVersion, gate only C1-C5, leave reads/evidence open, retain step owners/dates, and keep legacy fact inference pure on reads. |
manage_template |
Author templates and schema forms; manage table bindings |
manage_artifact |
Create and edit artefacts (HTML, JSON, PDF); manage public share links and survey state. set-share is public-only; use revoke-share to remove access and /a/<id> for authenticated workspace access |
manage_page |
Build and update JSON-layout dynamic pages |
manage_table |
Per-tenant SQLite: schema evolution, CSV import, read-only SQL |
manage_file |
Read, write, edit, list, search, move, and delete workspace files; connector-only binary staging via upload-start / upload-append / upload-finish |
manage_link |
Emit and query knowledge-graph edges between workspace entities |
manage_mermaid |
Render Mermaid diagrams and save to artefacts |
manage_share |
Create, list, and revoke public share links. refresh-binding recomputes an existing link's readable table list without rotating its token |
manage_trash |
List deleted files and entities, including skills, and restore or permanently delete |
manage_pdf |
Render documents to PDF; compose whole PDFs or selected pages from PDF artefacts, and extract text |
manage_email |
Render a branded email template to subject, HTML and plain text. Forge does not send email; send it from your own mail connector |
manage_capabilities |
Introspect the MCP surface: whoami, tool list, workspace access |
Use forge_read with resource: "manage_table", operation: "list-tables" and args: { workspace, compact: true, limit: 50, offset: 0 } to discover tables without their column schemas. Entries contain name, rowCount, createdAt and optional displayName; cross-workspace entries also include workspace. Use describe for an individual table's schema.
Compact pages default to 50 tables and accept a whole-number limit from 1 to 100 and a nonnegative safe-integer offset. Follow nextOffset while truncated is true; total reports the available inventory. Cross-workspace discovery applies one global page. Catalogue changes can shift offsets, and partialFailures means discovery is incomplete: restart from offset 0 after recovery.
Omitting compact or passing false preserves existing detailed responses. Legacy single-workspace listing still ignores limit and offset; query is not a table-name filter. Compact mode reduces response size but still enumerates full metadata internally and does not guarantee a fixed byte budget. The compact argument is only accepted by list-tables.
Verified superadmins can call forge_read with manage_telemetry, operation
diagnostics, and args: { "includeDatabase": true }. The operation is platform-wide.
The opt-in returns gateway SQLite page usage, the largest table and index allocations, and
unbound plans for observed reads. A matching databaseQueryFingerprint on a top-query entry
links it to the plan result for that shape. Plans use NULL placeholders on a separate
connection and can be unavailable when a query needs connection-specific features. Omit
includeDatabase for the runtime snapshot alone.
forge_update with manage_feedback classify accepts an optional type: "bug" or type: "improvement", identified by feedbackNumber or id, plus a required note explaining the correction. It updates the existing report and its type-dependent class fingerprint, and appends the previous type and reason to its activity history in one transaction. The original description, evidence, status and encounters stay intact. Omit type to retain its current value. Machine-generated feedback types cannot be converted. Existing workspace write access is required; platform-queue feedback remains admin-only.
manage_task applies closed argument contracts to create, add-step, update-step, update-step-meta, assign-step, update-status and update-tags, including nested step fields on create. Unknown fields and the conflicting aliases checked by these contracts return a field-specific error before writing. For example, update-step accepts status as an alias of newStepStatus, and wait updates accept waitingParty as an alias of awaitingFrom; callers should use the canonical names shown by operation: "help". Accepted step status, governance, assignees, done reason, tags and description changes are saved and visible on read-back.
update-step, assign-step, add-step and update-step-meta now gate the same normalised task candidate they save. They check the loaded task version within the state-and-event transaction, so a change made after that load returns VersionConflict instead of being overwritten. Callers that need to detect a change since an earlier read should pass the supported expectedVersion. This is the first shared writer group; other task writer routes and step-owned wait migration are tracked as later task-engine work. On add-step, acceptanceCriteria remains a compatibility alias for the step description, not a separate field. To edit an existing step description with update-step-meta, use stepDescription or description.
manage_task get, resume and list-comments keep each response within a fixed byte budget, with or without include: "full" (which returns whole strings instead of previews). Anything a read leaves out is counted under _omitted, each part with a next route: get with section and cursor returns the following items of that part (task, steps, facts, comments, attachments, timeline, links, obligations or lessons), and get with section, itemId and field returns one long value in parts, continued with the returned nextCursor. list-comments returns task and step comments as one stream, each with its stepId, and pages with nextCursor. A continuation whose collection changed in between is refused with errorCode: "cursor_stale" and a restart route; a cursor that does not belong to the read it is passed to is refused with errorCode: "cursor_invalid". A comment continuation keeps the stepId and kind it started with; passing a different one with it is refused. lessons counts every matching lesson and pages through all of them; the briefing's topLessons shows only the task's own lessons, lessons from documents linked to it, and lessons from linked tasks that the ranking already surfaces, so a lesson that matches on a shared tag alone is counted under _omitted rather than shown; lessons-for pages the same ranking with offset and nextOffset. In the attachments section, each item's activeShares is point-in-time metadata, not part of the continuation snapshot. list-comments limit/offset are legacy: a limited page also returns nextCursor, the change-safe continuation, while nextOffset is a bare position.
manage_page validate runs the layout save checks without writing. It accepts explicit context, inherits the declaration from an existing page when a slug is supplied, or uses layout.context. It returns context, token, layout and registry errors together in { ok, errors[] }, without recording write-rejection telemetry.
Access is granted per user by a Forge admin. An admin creates the user record and grants workspace access; the user then completes the ChatGPT sign-in above on first connection to obtain their own token. Each user only sees the workspaces they were granted, and every tool call is attributed to them in the audit log.
Self-serve provisioning is planned but not yet shipped.
Clients that cannot call the multipart REST endpoint can stage a binary through the existing Forge tools:
forge_create → manage_file upload-start with the exact decoded byte size and MIME type. An optional SHA-256 digest adds an integrity check.manage_file upload-append with canonical base64 chunks no larger than the returned limit and use receivedBytes as the next byte offset. Exact retries are safe; gaps or different retry bytes are refused.manage_file upload-finish to receive a normal fileRef, then pass that token to manage_file write or manage_artifact.The absolute 15-minute expiry is not extended by appends. Staging is bound to the authenticated user and connector; the finished fileRef retains its existing single-use bearer-capability behaviour.
If your business keeps its procedures as Forge skills, you can add a line like this to your own agent's standing instructions. Forge never asks an agent to install it.
When I ask for one of my business's procedures for Forge work, search my workspace's active skills in Forge (manage_skill list) and use the one I choose.
This page is sourced from packages/gateway/src/content/remote-mcp.md in the Forge repository. Last updated: 2026-09-28.
Telegram agent sends use the workspace bot and known chats. Agent sends with the same bot, chat, exact text and label within 60 seconds are refused. Automation alerts, outbox deliveries, storage notices and retries have no content duplicate check. The shared receipt path permits 60 logical sends per rolling hour per bot, including automation alerts. Refusals include the capacity reset time; capped automation alerts are recorded as failed. Pending and failed attempts consume capacity. These safeguards do not change tools/list, server instructions or OAuth.
manage_portal prepare-invite is admin only. Supply workspace, portal slug, audience rowId and optional expiresInDays (1–30, default 7). It prepares a single-use, zero-grant link and a plain message for manual delivery; it never emails the invite. The response is the same whether or not the email has a Forge account. Existing accounts can only redeem as their signed-in owner; zero-grant invites preserve their access.
settings.invite.readyWhen uses the same equality/inclusion rule array as audience.where, on the audience table. Unmet rules warn without blocking invite preparation or insert/update bookings linked through declared me/forward paths. Readiness is advisory, not an admission rule.
Redeeming a link to create an account sends the standard inbox-verification email. Until that separate confirmation token is consumed, the login remains unverified and cannot match any portal. Invites carry no workspace membership or access grants; admission continues to use live portal audiences.
Platform superadmins can pass category: "pause" to manage_deployment open-incident for a deliberate pause. The board returns category and a visible [Release pause] summary label. The default category is fault; unmarked historical records stay faults. Both categories hold claims under the same leases and acknowledgement/resolution rules. Scheduler refusal and retry exhaustion for one SHA join one live monitor fault, with distinct exhaustion evidence. Existing global acknowledgement remains effective; unacknowledged live faults still hold every claim.
manage_table adds set-rule on forge_create, get-rules and check-rules on forge_read, and delete-rule on forge_delete. Set with {workspace,table,rule:{kind,columns,params,mode,message,when?},ruleId?,acceptExistingViolations?}. A supplied ruleId replaces that table's rule. No existing operation or response changes for tables without declared rules. query also accepts optional checkRules (true or up to 50 rule ids). The response then carries ruleCheck: each rule's violations among only the rows that query returned, as positions in rows, plus the rules it skipped (link and lock rules, or rules naming a column the query did not return). Rows outside the result are never read, so a scoped reader learns nothing about rows it cannot see; check-rules remains the whole-table report.
Kinds: required (nonblank), unique (one/composite columns; ignoreBlank defaults true), allowed (values), range (min/max with required params.type number|date; ISO dates/today in Europe/London; minLength/maxLength for text), format (email/uk-phone/uk-postcode/url preset or pattern), compare (required params.type number|date and left/op/right, lt/lte/gt/gte/eq/neq). Rules choose numeric or date evaluation explicitly: number requires INTEGER/REAL affinity or an existing declared numeric type; date requires TEXT affinity. Rule setup never writes column type metadata. Date-only bounds compare the first ten characters, so max today includes the entire day. Blank values skip allowed/range/format/compare/link; no-overlap skips a row with a blank endpoint by default. Examples: range {type:"date",min:"today"}; compare {type:"number",left:"quantity",op:"lte",right:"capacity"}. Conditions {column,equals}, {column,in:[...]}, {column,blank:boolean} or ANDed arrays scope a rule.
Warn writes include ruleWarnings; form submit still succeeds. Block returns table_rule_violation with the declared message and rule/row details, and refuses the complete write or batch. Form writes roll back rows/checkpoints/events and return a validation refusal. Blocking activation reports existing violations unless explicitly accepted. check-rules pages source rows with limit (1-1000) and offset and returns nextOffset. Unique block rules use partial indexes where existing rows permit, otherwise the shared write check; existing add-unique indexes remain unchanged. Definition changes respect legal holds, column renames rewrite references, and table rename/drop carries/removes the metadata. Restore brings the rules and their owned indexes back together.
Patterns max 200 characters, at most one variable quantifier, no quantified groups/backreferences/lookarounds. Custom input max 256 characters; preset input max 2048. Storage is lazy tenant metadata with no boot migration/backfill. PR 3b adds links, no-overlap, locks and trigger enforcement.
Three further kinds:
link: columns:["client"], params:{table:"clients",column:"reference",onDelete:"block"}. The target is another table in this workspace. block refuses a referenced key's last deletion/change; clear sets matching child cells to NULL in that same transaction; allow leaves them and check-rules marks dangling values with severity:"warn". Parent actions apply to block-mode links. Warn-mode links report missing values without blocking or clearing. Child writes use an indexed existence probe; child and target lookup indexes belong to the rule.no-overlap: columns:["start","end"], params:{type:"date",groupBy:["engineer"],inclusive:false}, optionally when:{column:"status",in:["Open","Confirmed"]}. Only scoped rows in matching groups count, on both sides. Touching endpoints are allowed by default; inclusive includes them. Date values compare instants. NULL group values match; blank endpoints skip by default; malformed/reversed ranges violate. For date rules, wholeDay:true includes both written calendar days without timezone conversion, uses the start day for a blank end, and cannot be combined with inclusive.lock: omit columns or pass []; params:{columns:["signed_amount"]} locks those columns, or params:{} locks all editable cells. Required when:{column:"status",equals:"Signed"} is tested against the stored row before update/delete. Block only. Deleting a matched row is always refused; writing unchanged values is allowed. A subset lock leaves other cells editable but refuses clearing its condition to escape the lock.Unchanged saves of locked rows are allowed, including re-saving form answers; lock checks ignore retired _deprecated_* columns. Offset-less ISO date-times are interpreted as UTC, matching SQLite date probes.
Block-mode required, allowed, numeric/date range on already-valid values (except today), compare, no-overlap, lock and link use one SQLite trigger builder and the same predicates as engine queries. Unique keeps its owned unique index; accepting existing duplicates uses a nonunique lookup index and duplicate triggers instead. Format presets/patterns, text minLength/maxLength, date-format validity and today-relative bounds stay engine-only. Trigger aborts map to table_rule_violation with the rule identity and message. An accepted-existing-violation row remains stored, but a future invalid write is refused. Triggers are immediate: a multi-row key/range swap that temporarily clashes may refuse even if its proposed final state would be valid.
Column rename rewrites local and incoming link references; changing a rule-referenced column's type refuses; dropping a link target refuses until its incoming rules are removed. Rename, unrelated type rebuild, and drop/restore retain owned indexes and backstops. Restoring historical rows installs triggers after restoring their data. A link whose parent table is missing is skipped on restore, with a warning naming that rule and parent. Tables without local or incoming rules get no rule indexes/triggers. Removing a rule removes all its infrastructure. During rollback, remove declared rules first: SQLite triggers and indexes persist under older code.
Top-level orderBy accepts a column string with optional asc/desc, {column,direction}, or an array of those objects; legacy where text contains/startsWith must use filterQuery instead, while real column names ending in _contains retain equality.
manage_table query accepts optional filterQuery, for example
{filter:{or:[{column:"status",op:"eq",value:"open"},{column:"receipt",op:"blank",value:true}]},orderBy:[{column:"_id",direction:"desc"}],limit:100,offset:0}.
Conditions use {column,op,value}; nonempty and/or arrays can nest. Operators are eq, neq, in, normalisedEq, notIn, lt, lte, gt, gte, contains, startsWith and blank. in takes up to 100 scalar values. normalisedEq requires a string: stored ECMAScript trim plus SQLite ASCII lower equals JavaScript trim().toLowerCase() on the value; NULL never matches and blanks can match. Its fixed trim-set and transformed-value bindings both count against budgets. notIn takes up to 100 strings, compares CAST(column AS TEXT), excludes NULL for nonempty arrays and matches all rows for an empty array. Blank takes a boolean; eq/neq null use IS NULL/IS NOT NULL. Contains/prefix treat wildcards literally and fold ASCII case. Blank includes NULL and trimmed empty text. Filters allow depth 8 and 100 nodes; orderBy allows 20 columns and offset is capped at 100000.
Computed outputs: up to 20 {as,expression}; names are ASCII identifiers starting with a letter, at most 64 characters, and underscore-prefixed names are reserved. Expressions accept column/source, literal, coalesce, case with comparisons and exact null checks, concat and formatDate; computed outputs cannot reference one another. Filter and orderBy use {computed: name}. concat converts booleans to 1/0 and numbers to SQLite text; NULL propagates. formatDate uses the value as written without timezone conversion: iso-date YYYY-MM-DD, uk-date DD/MM/YYYY, uk-date-short DD/MM/YY, uk-date-long D Month YYYY, uk-datetime DD/MM/YYYY HH:MM. Invalid dates and numbers return NULL; uk-datetime requires a time part.
Relative comparisons use {relative:'today',days?,timeZone?} or {relative:'now',seconds?} with required dateMode:'date'|'instant'; now requires instant. Days are integers within +/-36500 and seconds within +/-3153600000. Today uses the workspace timezone by default and resolves on every read; date compares valid written calendar dates and instant compares UTC instants (stored date-times without an offset are read as UTC; numbers are read as Julian day numbers, not epoch times). orderBy entries can specify nulls:'first'|'last'. Both relative comparisons and null placement also apply to computed outputs.
Nested orderBy/limit/offset override top-level values when supplied; omitted values keep existing defaults and the 1000-row cap. The shared queryTable path still applies existing scope and withholding. Withheld columns cannot be filtered or sorted. Passing filterQuery with where or whereExact is refused. Up to four joins follow declared link rules: joins:[{link:"ruleId",as:"contact",type:"left"}], with optional from naming an earlier alias. Conditions and orderBy may qualify columns with source:"contact"; unqualified columns address the root. Aliases must be unique identifiers and cannot shadow the root table or a root field (including MCP _staleness). Joined records are nested under aliases; a left miss is null, inner joins omit misses. Targets require a single-column UNIQUE index (including INTEGER PRIMARY KEY), or an unconditional block unique rule with ignoreBlank:false and its enforcing index; link-column affinities and comparison collation must match. total, limit and offset apply to the joined result. Joins refuse tables with viewer scope or withholding declarations, and refuse view, artifactId task scope and columns projection. Empty joins behave as no joins. Existing inputs and SQL behaviour are unchanged.
Anonymous page shares can run saved structured selectors when the link grants the root and each joined table, plus every filter, ordering, join-key and displayed column. Joined selectors require an explicit readableTables policy including every target; a derived page policy never authorises joins, even when the target is bound elsewhere on the page. Create and refresh-binding return the owner a JoinTargetsNotGranted warning with targets requiring explicit grants. Nonempty selectors use a private snapshot of all rows and granted columns in each participating table and are refused if any table exceeds 1,000 rows; they also refuse tables with viewer me-paths and deprecated columns. Empty selectors keep the ordinary page read. Page links cannot be task-bound. Anonymous shares refuse any computed key, including an empty array.
DbTable (table) and ScheduleBoard (schedule-board) accept optional joinGrants: { alias: { columns?: string[] } } for saved filterQuery joins. Default off preserves the page-binding policy. Grants are binding-local and alias-local: a grant permits that alias for this binding’s read only, without opening other bindings or a standalone table read. Explicit columns plus join keys are allowed; omitted columns infer only saved selector references (displayed fields, filter, ordering and computed inputs) plus join keys, never all columns. Every joined table still requires a narrow viewer row scope (me-path). Withheld columns, deprecated/view/cross-workspace refusals, access checks and row caps remain enforced. Anonymous links still require explicit link grants for every joined table and referenced column; page joinGrants do not widen them.
A schedule-board using workspace and table can supply a saved filterQuery using the same grammar as DbTable. Field mappings accept root columns, joined alias.column fields and computed output names. Start and end fields need raw date or datetime values, not formatted date labels. A saved limit below the board's 2000-row request cap is honoured subject to the door's row cap (member reads 1000; scoped and portal joined reads default to 100 rows when the saved selector sets no limit); a partial-load warning follows the door's truncated result. A declared clashRule belongs to the root table and checks only returned rows. Missing rule columns, unsupported checks and truncated results show an incomplete check. On scoped and portal pages a joined table must also be bound elsewhere on the page unless the reading binding grants its saved join alias through joinGrants. Anonymous shares use the link-granted snapshot policy described above and refuse computed outputs. On scoped and portal pages a saved selector without joins (filter or order only) is refused, as for DbTable.
manage_skill list accepts statusFilter values draft|active|archived|all. With no filter it hides archived skills and keeps existing draft visibility. Merged shared skills remain active-only.
delete preserves a skill, its versions and reference files in trash for 60 days. restore-deleted takes slug and an optional trashId (default: most recent copy), retains the prior status and version, and refuses to overwrite a live slug. Task skill assignments and graph links are not restored. Shared-skill recovery uses the same admin permission as delete; restore remains the separate operation for restoring a version of a live skill.
manage_workspace get-user reads one global account by memberUserId or memberEmail, including verified and nullable verifiedAt. It reuses the existing administrator user read. A platform-admin credential is required; workspace admins, members, service tokens and open mode cannot use it.
The browser-only endpoint POST /api/auth/verification/resend takes its recipient from that user's stored account, with one attempt per minute and five per rolling 24 hours. These limits are per daemon and reset on restart. A new verification token expires the user's previous unused links atomically. Confirmation at /verify works independently of whether public signup is enabled. Portal refusals caused by an unverified address log only the user id during login admission, never during audience counts or account-policy reads. An existing member or platform admin with an office-issued invite binding retains the existing admission exception.
forge_update with resource: "manage_workspace", operation: "set-forge-badge-hidden" and args: { slug: "acme", hidden: true } hides the badge on eligible public document and guest pages; hidden: false restores it. The shared gateway route checks platform super-admin authority, resolves the owner-local workspace address or canonical workspace ID, then checks access to the resolved workspace. Global admins, other platform admins, workspace admins, ordinary members, service tokens and open-mode callers cannot change it. Each change atomically records the verified actor, workspace, previous and new value in the activity log. Repeating the current value returns unchanged: true without another activity entry. Forms, surveys and dead-link pages retain their existing badge policy.
manage_table import-csv defaults to mode: "insert". Optional mode: "upsert" requires matchOn: ["column", ...], backed by a real non-partial unique index on exactly those columns, or matchOn: ["_id"]. Matching rows update only the columns supplied by the CSV; other rows insert. Blank non-key cells leave matched values unchanged and become NULL on inserted rows. _id is a selector and is never patched; unmatched rows receive a generated id. Other system columns, including artifact_id, cannot be supplied. Blank keys are refused per row and reported; duplicate CSV keys refuse the whole import with the duplicate row numbers. Rows with a different cell count from the header refuse the whole upsert before planning, listing up to 20 row numbers.
dry_run: true writes nothing and returns counts: { inserted, updated, unchanged, refused } plus up to 20 sample row diffs showing preserved matched values; unmatched _id selectors display as new row. Every upsert insertion journals a lifecycle marker with its actual generated id, including rows whose user fields are all NULL. More than 10,000 inserts plus updates requires confirm_large_import: true; unchanged and refused rows do not count towards that ceiling. Upsert writes, declared table rules, legal-hold checks, signed-history outbox and mutationId replay recording share one tenant transaction. Block rules refuse the whole import atomically; warn rules return ruleWarnings. Reusing a mutationId with identical CSV content, key and mapping replays the committed result; different content, key or mapping is refused. Bulk and CSV imports retain their no-per-row-automation-events behaviour.
A table-bound form can opt into table_config.repeat through the existing template authoring
operations. This is an optional extension; forms without it keep their current behaviour.
{
"repeat": { "fieldId": "entries", "record": { "field": "job", "table": "jobs" } },
"primary": {
"table": "work_logs",
"fields": { "work_date": "work_date", "hours": "hours" },
"trustedValues": { "job_id": "$record.id", "person_id": "$viewer.person" }
},
"children": [{
"table": "progress_readings", "parentKey": "log_id", "sourceFields": ["progress"],
"fields": { "item_ref": "item_ref", "percent": "percent" },
"parentColumns": { "job_id": "job_id", "person_id": "person_id" }
}]
}
entries must be a top-level repeater containing the job table-select on jobs, plus hours
and progress. work_date is a card-level field. Card and row field ids must be distinct.
The selector stores _id or id; when a table has its own logical id, use _id.
Each row's dynamic sliders can filter source metrics by $record.job_type and baseline history
by $record.id. Declare recordColumns: ["job_type", "id"] on that dynamic-sliders field for
those record references; filter access is limited to door-readable columns plus the field's declared
recordColumns. The server renders separate scoped maps for selectable jobs, and validates touched
metric keys against the same row's server-read record before journalling. Changing a row's job clears
its touched readings. Only touched readings are saved; displayed baselines remain display-only.
Member and portal record doors are supported. Each selected record is re-read under the same member/portal authority as recordPick, including selector and task filters. A forbidden selection refuses the entire card before accepted history or table rows are written. Viewer/person and placement values are card-level server values; record values come from each selected row. The writer re-reads the records inside the transaction and refuses a record changed since validation.
Resolve reuses the viewer's own unsubmitted card; after submission it opens a new ordinary instance.
Accepted cards refuse edits or fresh submits. Exact idempotency retries return the original accepted
submission. Recovery re-authorises live records against the frozen snapshots; a changed record is
permanently refused and the person opens a new card.
The writer returns all primaryIds, retaining the first as primaryId for existing consumers.
Children, all primaries and the projection checkpoint commit together; failures emit no insert events.
There are 1 to 200 submitted rows and at most 200 selectable record snapshots per render, using the
existing lookup row caps. Repeat is incompatible with primary upsertOn, answersPer, routes,
secondaries, recordPick, nested repeaters, tableBinding.repeaterFanout and anonymous record links.
manage_telemetry health returns the public daemon health calculation.
Verified superadmins with read access also receive adminReasons,
attention, and outbox counts. Older reservations waiting on tenant state
appear in attention without degrading daemon health.
manage_telemetry dismiss-outbox is a forge_update operation for platform
and workspace admins. It accepts workspace, an fso_… entry id, and a
non-empty reason of up to 1,000 characters. It removes the entry and its
action receipts, and returns the non-replayable deadLetterId. A running
entry with a live lease is refused.