> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tckg.factagora.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Changelog

> What changed on tckg.factagora.com, newest first. Schema version from GET /v1/version.

Each entry names the schema version served after the deploy, the date, and what a caller can see. Reads and writes that are not listed did not change.

## 0.3.26 (pending deploy)

* `POST /v1/forget` takes `space`: `{"tenant", "space"}` deletes the blocks of one space of your tenant, the edges, verdicts and anchors that would otherwise point at an id with no block left, in one transaction. Fact declarations, backfill batches and blocks written without a space stay. A read of that space or of the whole tenant carries `forgotten_spaces: [{space, at, rows}]` in its certificate; a certificate with no forgotten space is unchanged. Without `space` the request forgets the whole tenant as before. See [forget a tenant or a space](https://docs.tckg.factagora.com/api-reference/forget-tenant.md#forget-one-space).

## 0.3.25 (2026-11-20)

* `POST /v1/facts` takes a key shape, `*/<rest>`: one declaration such as `{"fact_key": "*/language", "key_fields": ["subject"]}` applies to every key shaped `<subject>/language`, so you no longer declare each subject's key. An exact declaration of a key, in force at the instant asked, wins over the shape whenever it was declared. Any other `*` is refused with `TCKG_BAD_FACT_PATTERN`. `resolve`, the `undeclared_fact` write warning and measured strength all apply the shape. Export writes the shape out under each concrete key the bundle uses and carries no `*` key, so `factblock validate` accepts it. Keys declared exactly answer as before. See [declare facts](https://docs.tckg.factagora.com/api-reference/facts.md#key-shapes).

## 0.3.24 (2026-11-20)

* Every read row carries `fact_key` and `fact_value`, the fact the block states a value for and the value as written, null for a block bound to no fact: `GET /v1/memories`, `GET /v1/memories/{id}`, search hits and why. You no longer need to copy them into `payload` to know what a row is the value of.
* `GET /v1/memories?fact_key_prefix=` (and `fact_key_prefix` on the MCP tool `read_memories`) keeps the blocks whose `fact_key` starts with the string. With keys shaped `<subject>/<attr>`, `fact_key_prefix=s_123/` reads one subject's attributes at `as_of` and `valid_at` in one request. `_` and `%` are plain characters. See [list memories](https://docs.tckg.factagora.com/api-reference/list-memories.md).
* Rows of `GET /v1/memories` (including `?id=` reads) and the item of `GET /v1/memories/{id}` carry `superseded_by` and `superseded_since`, decided exactly as on search hits at the same `as_of`, `valid_at` and `facts`. To learn whether a block you cited was later replaced, read it by id at a later `as_of`. Which rows a read returns and in what order is the same as before.

## 0.3.23 (2026-11-20)

* Reading a few blocks by id (`GET /v1/memories?id=`, `GET /v1/memories/{id}`) and paging (`limit`, `after`) no longer read the whole space or tenant first. On a test space of 30,000 blocks an id read went from about 70 ms to under 1 ms, and a page of 100 from about 55 ms to about 14 ms. The rows, their order and the certificate are the same as before; nothing to change on your side.

## 0.3.22 (2026-11-19)

* MCP `track_record`, `timeline` and `graph` run factblock 1.0.0a16 (was 1.0.0a14). `track_record` reads excess over any benchmark named in a verdict value (`{"excess": ..., "benchmark": "069500"}`), not only over SPY; existing keys are unchanged.

* Nodes take `asserted_at_precision`, how precisely the time a statement was made is known: `year`, `month`, `day`, `hour` or `minute`, absent when exact. You can send it, or let the form of `asserted_at` say it: a bare date (`"2026-11-19"`) is day precision and a time without seconds is minute precision. A value outside the list refuses that row with `bad_precision`. Every read that returns nodes (`GET /v1/memories`, `GET /v1/memories/{id}`, search hits, why) carries the field, null for an exact time, and export carries it on the nodes that have one. Nothing else changes: which rows a read returns and in what order is the same as before, and rows written earlier read as exact. See [write memories](https://docs.tckg.factagora.com/api-reference/write-memories.md).

## 0.3.21 (2026-11-19)

* Reads take the case you are asking about: `GET /v1/memories?facts=` (a JSON object), `POST /v1/search {"facts"}` and `POST /v1/resolve {"facts"}`, and the same argument on the MCP tools `read_memories`, `search` and `resolve`. A block whose `applies_if` does not hold for the case is left out of the list, is neither a search candidate nor a hop, does not flag the block it supersedes, and is not a resolve candidate, so a `SUPERSEDES` edge from it is ignored too. Under `most_specific` a conditional finalist now answers for the case instead of `needs_facts`, which remains the answer when no `facts` are given. Every condition must hold; a condition on a key you did not give fails. Without `facts` every read answers exactly as before. The certificate carries `not_applicable`, the number of blocks set aside, whenever `facts` was given. See [list memories](https://docs.tckg.factagora.com/api-reference/list-memories.md), [search](https://docs.tckg.factagora.com/api-reference/search.md) and [resolve](https://docs.tckg.factagora.com/api-reference/resolve.md).

## 0.3.20 (2026-11-17)

* `POST /v1/facts` takes a fifth policy, `most_specific`: a candidate that a `SUPERSEDES` edge known by `as_of` and in force at `valid_at` points to is dropped, then the candidates with the most `applies_if` conditions are the finalists. Unconditional finalists answer when they all carry the same value and are `unresolved_conflict` otherwise. A conditional finalist is a new `no_answer` reason, `needs_facts`, because a read cannot pass facts yet. The four existing policies answer exactly as before. See [declare facts](https://docs.tckg.factagora.com/api-reference/facts.md) and [resolve](https://docs.tckg.factagora.com/api-reference/resolve.md).
* `POST /v1/search` hits flag `superseded_by` only once the `SUPERSEDES` edge is in force at `valid_at`, not as soon as it is known, and carry a new field, `superseded_since`, the instant it took effect. A supersession announced ahead of its effective date no longer flags the block early. See [search](https://docs.tckg.factagora.com/api-reference/search.md).

## 0.3.19 (2026-11-17)

* Nodes take `applies_if`, the cases a block applies to as `[{key, op, value}]` with `op` one of `eq`, `after`, `before`. A malformed one refuses that row with `bad_applies_if`; the rest of the batch is written. The server stores and exports the conditions; it does not evaluate them yet. See [write memories](https://docs.tckg.factagora.com/api-reference/write-memories.md).
* `GET /v1/memories?fact_key=` and `POST /v1/search {"fact_key"}` narrow a read to the blocks that state a value for one fact. Search narrows the candidates only, as `category` does. See [list memories](https://docs.tckg.factagora.com/api-reference/list-memories.md) and [search](https://docs.tckg.factagora.com/api-reference/search.md).
* `GET /v1/export` carries `applies_if` on the node lines that have one (a bundle without it is byte-for-byte the same) and names its scope in two response headers, `X-Tckg-Tenant` and `X-Tckg-Space`. See [export](https://docs.tckg.factagora.com/api-reference/export.md).

## 0.3.18 (2026-11-17)

* `GET /v1/edges` and `GET /v1/export` take `edges=touching` with `space`: edges with exactly one end in the space are returned too, each with `other_end: {side, id, space}` (null when both ends are inside). Without the parameter the response is byte-for-byte the same as before. `edges=touching` without `space` is 400 `TCKG_TOUCHING_NEEDS_SPACE`; combined with `with=strength` it is 400 `TCKG_TOUCHING_WITH_STRENGTH`. The certificate counts touching edges in `masked.edge`. See [edges](https://docs.tckg.factagora.com/api-reference/edges.md) and [export](https://docs.tckg.factagora.com/api-reference/export.md).
* A touching export is not a self-contained bundle: edges may point at nodes that are not in the file, so `factblock validate` reports dangling references. Use the default export for a bundle that stands alone.

## 0.3.17 (2026-11-05, API 2026-11-16)

* `GET /v1/verdicts`: a target's verdicts as of an instant, the latest chosen by the server, ties refused as `unresolved_conflict`. No more `/v1/export` round trip to read one verdict. See [verdicts](https://docs.tckg.factagora.com/api-reference/verdicts.md).
* `GET /v1/edges?with=strength` on a space reads in about a second instead of 8 to 9 seconds (the edge read now filters by space before looking up nodes). Answers unchanged.
* Reader queries are limited to 60 seconds; a read that exceeds it returns 503 `TCKG_QUERY_TIMEOUT`. Writes are not limited.

## 0.3.16 (2026-11-05)

* `POST /v1/forget {"tenant"}`: an app deletes its own tenant's rows in one transaction, with a record left behind; the certificate of a forgotten tenant carries `forgotten: {at, rows}`. See [forget tenant](https://docs.tckg.factagora.com/api-reference/forget-tenant.md).

## 0.3.15 (2026-11-05)

* `POST /v1/facts` takes `{"facts": [...]}` to declare several facts in one request, each item reported as declared, unchanged or refused. See [facts](https://docs.tckg.factagora.com/api-reference/facts.md).
* `tckg.certificate` with `space` reads the space's node ids once; the API keeps one connection pool per role. Answers unchanged, large spaces read faster.

## 0.3.14 (2026-10-23)

* New edge types `SUPPLIES`, `COMPETES_WITH`, `OWNS`, `PART_OF` (general family). Export declares non-core types in the manifest `edge_types`.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.