mainsequence-sdk

Use this skill when the task is about operational execution in a Main Sequence project. This skill owns jobs, schedules, batch scheduling files, project images, run inspection, project resources, releases, Streamlit dashboard deployment, and Artifacts as operational inputs. It does not own DataNode producer design, MetaTable schema design, API route contracts, Streamlit dashboard design, or RBAC policy.

Reviews a Main Sequence project for status, blockers, failures, and completion.

Use this skill to bootstrap work in a Main Sequence repository. This skill owns project context verification, docs-first behavior, success-definition discipline, routing between specialized domain skills, and project-state file discipline. It does not own domain implementation semantics.

Use this skill when the task is about selecting, creating, validating, or documenting Command Center connections before workspace widgets consume data. This skill owns connection type discovery, connection instance readiness, query model/output-contract checks, connection-first workspace dataflow, and routing backend adapter gaps. Use this before creating data-consuming widgets. It does not own workspace layout, widget JSON mutation, AppComponent form contracts, or generic FastAPI implementation.

Use this skill when the task is about translating user intent into a Main Sequence Command Center workspace concept. This skill owns workspace design, widget selection, visualization strategy, information architecture, connection-first dataflow planning, and deciding which widgets best express a business idea. It does not mutate workspace JSON, patch mounted widgets, create connections, create FastAPI endpoints, or create project resources/releases.

Use this skill when the task is to discover what `DataNode` or `MetaTable` data already exists on the Main Sequence platform before implementation starts.

Use this skill when the task is about RBAC, resource sharing, or access verification in a Main Sequence project. This skill owns organization and team access concepts, view and edit semantics, choosing the correct shareable resource boundary, and access checks across projects, DataNodeStorage, constants, secrets, buckets, artifacts, and releases. It does not own job scheduling, DataNode producer logic, or API route design.

Canonical guidance for discovering agents and sending session-scoped A2A requests through Main Sequence.

Use when building or changing an API so Command Center can consume it through an Adapter from API connection. This skill defines the provider-side API contract standards required for Command Center connection discovery, health checks, operation selection, config fields, secret injection metadata, canonical `TabularFrameResponse` outputs, and optional response-mapping metadata for frontend/editor context or future explicit transforms. It does not define general API architecture and does not imply the API may only serve these endpoints.

Use this skill when the task is about validating a planned Command Center AppComponent API contract before backend deployment. This skill owns `apiTargetMode: "mock-json"`, synthetic request and response contract authoring, request-side versus response-side UI metadata separation, and testing downstream bindings in a workspace before any FastAPI image build or ResourceRelease, including checking that generic tabular consumers receive `core.tabular_frame@v1`. It does not own FastAPI implementation, workspace layout design beyond the test harness, or release creation.

Use this skill when the task is about Command Center table or pro-table widgets, canonical `core.tabular_frame@v1` responses, table-specific frame visual metadata, table widget column schema, formula columns, conditional formatting, selection outputs, or live merge key mappings. This skill owns the boundary between source-owned tabular frame contracts and persisted table widget props. It does not own workspace layout, connection creation, generic API architecture, AppComponent forms, MetaTable schema design, or DataNode storage design.

Use this skill when the task is about the Command Center `core__tabular-transform` widget, including tabular transform widget props, projection, filter, aggregate, pivot, unpivot, computed columns, latest-row merge behavior, seed/live update bindings, or wiring transformed `core.tabular_frame@v1` datasets into downstream table, chart, statistic, curve, or agent-facing widgets. This skill is grounded in `mainsequence.client.command_center.widgets.tabular_transform` and does not own connection creation, API provider contracts, table widget presentation props, workspace layout design, or generic FastAPI implementation.

Use this skill when the task is about producing, changing, validating, or reviewing Main Sequence DataNode update processes. This skill owns DataNode update configuration, dependencies, update logic, hashing, namespaces, and validation against a PlatformTimeIndexMetaTable storage contract. It does not own generic MetaTable governance, Alembic migration execution, API route contracts, scheduling, sharing policy, or storage registration internals.

Use this skill when the task is about defining, querying, or reviewing Main Sequence MetaTables. This skill owns SQLAlchemy table contracts, backend-managed table authoring, external table registration, governed compiled SQL operations, foreign keys, indexes, naming, cadence, and validation rules. For Alembic migration lifecycle work, use the mainsequence-metatable-migrations skill. It does not own DataNode producers, API route contracts, scheduling, releases, or sharing policy.

Use this skill when the task is about Main Sequence MetaTable schema evolution, Alembic provider setup, migration scaffold generation, revision creation, migration upgrade/current commands, provider-scoped MetaTable reservation/finalization, or debugging migration lifecycle failures. This skill owns the migration-first workflow for platform-managed MetaTables and should be used instead of direct MetaTable.register() guidance.

Use this skill when a Main Sequence project needs financial markets functionality. This skill points agents to the supported ms-markets library and its packaged skills instead of duplicating market-domain instructions in the SDK scaffold.

Use this skill when the task is about analyzing a Main Sequence Command Center workspace snapshot and answering questions about the current state of the workspace. This skill is for interpreting what the workspace was actually showing at capture time. Each widget snapshot contains that widget's current state, and agents should answer questions from those widget dumps instead of from persisted workspace metadata.

Use this skill when the task is about adding agentic capabilities to a Main Sequence project.

Use this skill when the task is about creating, updating, validating, or reviewing Main Sequence Command Center workspaces. This skill owns workspace documents, widget instance payload resolution, layout decisions, shared versus user state, widget-scoped mutation, and grounding those decisions against the richer widget-type registry contract plus the SDK command_center client models. Source order is strict: registry detail first, SDK client models second, local Main Sequence repository docs/models third only when the first two still leave instance payload questions unresolved. Main Sequence is platform-first: if a mounted widget or AppComponent depends on a project API, that API must already exist as a FastAPI project resource and have a corresponding FastAPI ResourceRelease before the workspace flow is considered usable. Resource and release creation belong to the orchestration-and-releases skill. It does not own AppComponent form contracts, API implementation, or Streamlit dashboards.

Use this skill when the task is about building or changing APIs in a Main Sequence repository. In a Main Sequence project, project APIs should be implemented as FastAPI project resources. This skill owns FastAPI structure, request and response contracts, request user binding, APIDataNode and SimpleTable consumption inside APIs, and exact widget-facing API response contracts. It does not own producer-side DataNode or SimpleTable design, workspace payloads, or scheduling and release workflows.