Actions

artifact_update: Generate or revise a structured artifact (report, memo, summary) built from the project's corpus.

Contract Generation is detached: a dispatch returns the running task to poll, and a dispatch naming an artifactId is refused on the API surface today — omit it to generate a new artifact.

code_context_pack: Return the slice of an ingested repository one coding task needs: the declarations ranked most relevant to the task, each as a signature citing its file and line, packed to a token budget. Complements an exact-string search rather than replacing it — it answers which code to read, not what it says.

Contract The response is signatures, never bodies: each declaration carries its header, file, and line span so you read the source yourself at the cited position.

Contract The pack is ranked for precision, not coverage — it returns the few declarations a task turns on and stops well short of the budget when nothing else scores. A short pack is an answer, not a truncation; re-dispatch with a sharper task rather than a larger budget.

Contract Seeds are subtracted from the answer: anything you name in seedSymbols or seedFiles steers the ranking and is never spent on your budget.

code_references: List the ingested code units whose symbol name matches a typed prefix, each as an addressable reference — a stable symbol id, the symbol name as its label, and its file path as its sublabel. This is the manual override for retrieval: the named way to point at code.

Contract References are a bounded page ordered prefix-matches-first, then substring matches, each alphabetical, so the list stays stable as the user keeps typing.

Contract The symbol id is stable across re-ingests — store that, never the label, when persisting what a user picked.

document_ingest: Pull a document into the project's corpus so its factions, cells, and entities feed the memory graph.

Contract Dispatch only starts the ingestion: the source ingests on a detached task the response names, so poll that task rather than treating the dispatch as a completed ingest.

Contract One source, one page. Following links to the rest of a site is the research pass's job, so a whole site asked for here lands only what the named URL itself says.

document_verification: Extract the checkable claims from an ingested document and return a verdict ledger: per claim, whether the project's authority corpus SUPPORTS it (with the exact span), CONTRADICTS it (with the span), leaves it UNSUPPORTED (the corpus does not cover it — not a finding that it is false), or ABSTAINS when the evidence is too weak to call. Each row carries the exact locus it turned on. Scoped to the project the connection is bound to.

Contract The ledger is three-valued, never two: UNSUPPORTED means the corpus does not cover the claim — a statement about coverage, not a finding that the claim is false — and is distinct from CONTRADICTED, which means the corpus asserts the opposite and carries the contradicting span.

Contract A verdict the evidence cannot support at the confidence threshold is ABSTAIN, never a forced call: a low-confidence resolve returns abstain rather than manufacturing a contradiction.

Contract Every SUPPORTED or CONTRADICTED row carries the exact locus it turned on — the faction and its SourceLocation anchor — so the cited span opens the precise place in the corpus. An UNSUPPORTED or ABSTAIN row cites nothing by design.

Contract The authority corpus is the project the connection is bound to, read as ground truth only — generated content is never cited as authority.

file_upload: Register a file the visitor already content-addressed and pushed to storage as chunks, staging it into the caller's session project so it ingests through the ordinary queue.

Contract The destination resolves server-side: the file always lands in the caller's session project, never in a project_id the visitor names.

Contract One session per caller: the first upload mints the session; later calls reuse it, each advancing its idle watermark.

Contract Upload URLs are minted by relay per chunk — a caller cannot name a source for relay to fetch.

memory_query: Read the project's Runlog memory. With a query, returns the cells, entities, and artifacts ranked relevant to it, each carrying its ids as provenance; without one, lists cells (units of knowledge) or entities as a windowed dump. Scoped to the project the connection is bound to.

Contract List reads are windowed: a dispatch returns one bounded page of items plus a nextCursor; pass the returned cursor to continue and treat an empty nextCursor as the final page — a single dispatch is never the whole memory.

Contract Query reads are budgeted, not paged: the response packs the most relevant cells, entities, and artifacts into the requested token budget and stops — dispatch again with a refined query rather than a cursor.

Contract A schema never replaces the query: the natural-language query is what decides WHICH knowledge is retrieved, and the schema only decides what SHAPE the answer takes over it. A dispatch carrying a schema and no query is refused rather than answered from an unranked corpus.

Contract Tethers constrain, they do not rank: a fileIds or entities tether narrows the answer to what those files and entities back, so a tether naming nothing the project holds returns an empty result rather than a broader one. Leave both absent to retrieve across the whole project.

Contract Every field of a structured answer is grounded in the returned cells — the rows stay on the response beside the structured object precisely so a caller can check each value against what it was derived from.

object_submit: Write one form submission as a typed record of the named-object type the site's owner bound to this action, validated against that type's declared fields.

Contract The type is the owner's binding (the action's form wrapper), never a field of the submission: a payload that does not fit the bound type's declared fields is refused, not stored.

sku_create: Create a unit SKU row the storefront can sell: name, price, deliverable kind, scope, and turnaround. Price, scope and turnaround render from the catalog row at checkout time — never from page copy.

Contract The SKU id is server-generated from the name; a page never names a price it did not read from the catalog.

Contract The price, scope and turnaround render from the catalog row at checkout time, never from page copy.

Contract Intake answers ride the purchase into the delivery run; oversize intake is refused at mint, never truncated.

storefront_create: Create a storefront host record bound to a project, so a published site has an identity tenant for visitor sign-up and a storefront for payments.

Contract The storefront is bound to one project; a project records the storefront it was created under.

Contract The storefront provides an identity tenant for visitor sign-up and a payment surface for unit SKUs.

unit_checkout: Mint one unit SKU's Stripe Checkout Session with the page's intake answers attached, for the visitor to pay on. Price, scope and turnaround come from the catalog row, never from the page.

Contract The SKU id is the only thing the page names about the offer: the session's price, name and turnaround are read off the catalog row at mint, so a tampered id buys nothing.

Contract Intake answers ride the purchase into the delivery run; oversize intake is refused at mint, never truncated.