SG Ground Truth

Findings — write: creating and updating

How the API behaves in this part of a session. Each rule is the entry's own Teaches, copied whole.

API

011_create_project

A script user can create a Project with nothing but {"name": ...}, at 201, but the response echoes only 6 attributes, so read the project back if you need anything else.

  • {"name": "sandbox_show"} with Content-Type: application/json is a complete create: 201, no project template, no code, no dates.

  • On the probed site, GET /schema/Project/fields returns 42 fields and flags exactly one, name, mandatory: true. That count is site configuration, and a schema flag is not the create contract (probe 012), so it does not establish that name is the server's only requirement. This probe never posted a body without name; that POST, behind --write, would settle it.

  • Trap. The 201 body is not an entity read. It echoes 6 attributes (cached_display_name, created_at, landing_page_url, name, tracking_settings, updated_at); everything else, id apart, needs a GET on the new project.

  • name is flagged both mandatory and unique in the schema, so creating is not idempotent. Probe first (GET /entity/projects?fields=name) and reuse the hit, as this probe does. Custom fields silently become <name>_1 on a duplicate (probe 019); whether a Project name collides or duplicates is <unverified>.

  • A fresh project has no sg_status, so a picker must not filter on it (probe 018).

corpus/findings/011_create_project.md

012_create_version

The schema's mandatory flags are not the create contract: on every project-scoped type measured, project is required and the identity field is optional, server-generated and not unique.

  • Trap. /schema/Version/fields marks only code mandatory, yet a body without project 400s.

  • An entity link is a hash: "entity": {"type": "Shot", "id": N} creates, "entity": <id> 400s. project takes the identical shape, and reads return both under relationships (probe 004).

  • The 201 relationships block lists slots that were never set (cuts, playlists, tags), so its keys are not a record of your input. entity appears only when it was written, the one usable confirmation.

  • Both 400s recorded as null: the probe captured errors[0].detail and these errors have none. The status codes are verified; the message text is <unverified>.

The create contract, every type measured since. Version is not a special case. One row per card, entity_types/<Type>:

type identity field flagged mandatory actually required omitted identity becomes unique
Version code yes no New Version <id> no
Shot code yes no New Shot <id> no
Asset code yes no New Asset <id> no
Sequence code yes no New Sequence <id> no
Task content yes no New Task <id> unmeasured
Playlist code yes no New Playlist <id> no
PublishedFile code yes no New Published File <id> no
Note subject yes no nothing; the row has no title no
TimeLog none only id n/a n/a; description reads New Time Log no
Delivery title yes no New Delivery <id> no

For a project-scoped type, project is the requirement and is flagged mandatory: false; the identity field is flagged mandatory: true and is optional, generated by the server when omitted. {} and the identity field alone both answer 400 API create() missing 'project' attribute: with the body echoed. Nothing is unique on any of them, so keying on code is wrong on every type measured: match on id, and treat a code lookup as a query that can return more than one row.

Omitting the key and sending an empty one are different. {"code": ""} on a create is 400 code 104 Create failed for [Shot]: Cannot set identifier field to empty. (Shot) (entity_types/Shot), and Sequence answers the same message for "" and for null (entity_types/Sequence).

Site-wide types are the boundary, not the rule. Project has no project field at all, and its identity name is the one field flagged both mandatory and unique, so a create there is not idempotent (entity_types/Project).

editable is the same shape of flag and the same shape of wrong. created_at and updated_at are flagged editable: false on Note, Reply, Task and Version, and a create body sets both (probe 070). Neither flag describes the create path; send the body and read the 400.

corpus/findings/012_create_version.md

024_read_after_write

Every write ignores ?fields. A create returns what you sent plus the server defaults, an update returns the whole record, and neither resolves a dotted path, so re-read for those and after an upload.

  • There is no conditional write. If-Match, If-Unmodified-Since and If-None-Match are ignored and the update applies at 200, though a GET returns a weak ETag.

  • Echoing updated_at back is refused with API update() Task.updated_at is editable on create only. So a read-then-write guard narrows the race window and never closes it, and exactness needs serialisation outside the API (recipes/005).

operation the response returns it omits how to get the rest
POST /entity/<type> the fields of the request body, the server-set ones (created_at, updated_at, cached_display_name), and every relationship as {id, name, type} every field left at its default, and every dotted path GET /entity/<type>/{id}?fields=...
PUT /entity/<type>/{id} the whole record, changed fields and untouched ones alike dotted paths only the same follow-up GET
PATCH /entity/<type>/{id} nothing: 404 with a null detail everything use PUT
batch create row the same subset a single create returns as a single create one GET per created id
batch update row the whole record, wrapped with links and status dotted paths only the same follow-up GET
batch delete row did_delete, id, uuid any field value nothing to re-read
_upload complete_upload 201 with a one-byte body the stored path and the final URL poll the field until it stops matching /images/status/transient/
DELETE /entity/<type>/{id} 204, empty body everything the id answers 404 from then on
  • Trap. ?fields on a write is accepted and ignored, plain names and dotted paths alike, with no error, the same quiet drop a bogus ?fields name gets on a read (probe 004).

  • The reported create-versus-update asymmetry is real but inverted: the create response is the thin one. Neither verb resolves project.Project.name or entity.Shot.code, and both return the link's own name under relationships, so a second call is needed only for a linked entity's other fields.

  • On the probed site a Version create answers 9 attributes and 15 relationships and an update answers 52 and 20. The counts are site-specific; the ratio is the rule. A create body of 3 extra fields answered 12 attributes, so the create response is what you sent plus the server defaults, not a fixed list.

  • A batch endpoint does exist, undocumented: POST /entity/_batch, and it takes plain application/json, not the vendor Content-Type _search requires (probe 004).

    {"requests": [{"request_type": "create", "entity": "Version", "data": {...}},
                  {"request_type": "update", "entity": "Version", "record_id": N, "data": {...}},
                  {"request_type": "delete", "entity": "Version", "record_id": N}]}
    

    entity is the singular schema name, not the URL slug; the id key is record_id, and entity_id is read as 0 and 404s. One failing row rolls the whole batch back: a good create paired with an update of id 999999999 left 0 rows behind. The response is data, one row per request, in order.

  • Transcoding is the only write whose result is not readable at all on return (probe 013). On the probed site a 16x16 PNG thumbnail stayed at /images/status/transient/thumbnail_pending.png past t+21s and resolved by t+42s, so poll on the path prefix and never on elapsed time.

  • Unsettled. One team reports a newly created Version's linked-entity field reading back empty at the moment of its own creation event, and built a diagnostic to fail loudly on it.

  • This repo has no event listener, so the claim is untested here and a negative result would prove nothing. Settling it needs a listener reading the entity from inside the event callback and comparing against a read a second later.

corpus/findings/024_read_after_write.md

045_webhooks

The hook contract validates the url and the entity type, and silently accepts a field name, a project id and an entity-type count it will never honour. test_connection answers 204 for any uuid. [partial]

not measured: No entity event reached a hook on the probed site, so the delivery payload, the X-SG-SIGNATURE and x-sg-event-batch-* headers, and batch_deliveries, are all unrecorded.

sent result
a field the type does not have, in update 201, and the hook can never fire
two entity types in one hook 201
a project id that is not there 201
an action name the API does not have 400 entity_types is not valid
an entity type the site does not have 400 entity_types is not valid
  • The url validator resolves the host and ignores the scheme. Every unroutable target is refused with one message naming reserved and internal addresses, https://<name>.example.com included, while ftp://example.com/... answers 201. Passing validation means the host resolved, not that the hook can be delivered to.

  • test_connection answers 204 for a uuid that is not a hook. It confirms nothing: not that the hook exists, not that the endpoint is reachable, not that anything was sent. Do not use it as a health check.

  • POST /webhook/hooks refuses the vendor array content type that _search requires, at 415 naming application/json. The webhook family takes plain JSON only (004_array_vs_hash).

  • The two 404 shapes are the parser, not the lookup: a well-formed uuid that names nothing answers code 104 with detail naming it, and a segment that is not a uuid answers code 103 with detail null.

  • A delivery record is written whether or not anything answers. A hook pointed at a dead host records status: "delivered" with response_code: 0 and an empty body. delivered means dispatched, not received. Never read that status as confirmation a consumer got the payload; read response_code, which is 0 when nothing replied.

  • A hook's own status change is delivered to the hook. Setting status to disabled and back writes one delivery record each. Its event type is not in the guide's list of 39 custom events:

    {"data": {"id": "0", "event_type": "Webhook_Status_Change", "event_log_entry_id": 0,
              "webhook_status": "disabled", "previous_webhook_status": "active",
              "meta": {"type": "webhook_status_change", "source": "client",
                       "old_value": "active", "new_value": "disabled"}},
     "timestamp": "2026-09-04T18:47:18Z"}
    

    id is "0" and event_log_entry_id is 0: this is generated by the webhook service itself and has no row in the event log behind it. A consumer must tolerate it, because no subscription asks for it and every toggled hook is sent one.

  • On the probed site, entity events reach no hook, and this is not a REST problem. A hook created in the web interface and one created over REST behave identically: active, correctly subscribed, and no delivery record for any entity change or for test_connection, while Webhook_Status_Change on the same hook in the same minute records normally.

  • Two public endpoints were tried, a tunnel proven reachable in-process and webhook.site. So the delivery recorder runs and the entity-event feed into it does not. Diagnose a silent hook by toggling its status: a record proves the pipeline is alive and isolates the fault to the event feed.

  • Because no entity event was delivered, X-SG-SIGNATURE, the entity payload, the x-sg-event-batch-* headers, batch_deliveries, and PUT /webhook/deliveries/<record_uuid> and redeliver are all unprobed.

  • Everything here uses entity_types. The second subscription mode the 400 names, event_type, the fourth lifecycle action revive, and the entity families the guide excludes are all measured in 050_webhook_subscriptions.

corpus/findings/045_webhooks.md

050_webhook_subscriptions

entity_types and event_type are mutually exclusive and one 400 covers giving neither and giving both. revive is a fourth action, and every entity the guide calls excluded is accepted at 201.

  • The two modes are exclusive, and one message covers both ways of getting it wrong. entity_types either entity types or event type is required is returned for a body with neither and for a body with both. Read it as "exactly one of these", not as "you are missing one".

  • Every entity the guide calls excluded is accepted at 201. A hook on ApiUser, on EventLogEntry, or on a connection entity such as AssetShotConnection is created, is active, and reads back intact. The documentation says it will never fire. Nothing in the API says so, so the create is not the place you will find out.

  • revive is a fourth lifecycle action alongside create, update and delete, and it is the counterpart to the logical delete in 040_field_revive. retire is not an action: the API spells the same operation delete.

  • A bogus event_type does not enumerate the legal ones. event_type is not valid names nothing, unlike the filter operators, which answer a bogus relation with the full list (017_filter_operators). The 39 custom events are readable from the guide and from nowhere in the API.

  • Type errors on event_type are specific where the value error is not: a list answers must be a string and an empty string answers must be filled.

  • batch_deliveries and validate_ssl_cert round-trip on create and are readable back.

corpus/findings/050_webhook_subscriptions.md

058_local_storage_roots

One create fills every local_path_* the storage row defines, whichever platform's root the path was under. The server picks the deepest matching root, and no conditional-write header is honoured.

  • One create fills every platform the row defines. A Mac artist publishing under mac_path gives a Linux farm a working local_path_linux in the same write, and the join runs the same way for a path given under the Linux or Windows root: the server strips whichever root matched and re-joins the remainder onto all three.

  • local_path_windows comes back with backslashes and the drive letter exactly as the row spells them, even though a backslash in the request is refused (recipes/004_register_published_file).

  • A platform reading null is a root the row leaves unset (probe 021), never a property of the write.

  • A Windows root is matched with forward slashes. Z:/zzprobe_058_a/seq/plate.v001.exr resolved against windows_path Z:\zzprobe_058_a, so a client normalises separators before sending and still reaches a drive-letter root.

  • The deepest matching root wins, not the oldest row. With /zzprobe_058_n and /zzprobe_058_n/sub both defined, a path under sub resolved to the sub row in both creation orders, so id order does not decide it. Two rows on the identical root resolved to the higher id.

  • A client that means one specific storage sends {"relative_path", "local_storage"}, which names it outright, rather than {"local_path"}.

  • Nothing in the response signals the choice beyond the id. path.local_storage and path_cache_storage hold the same row and there is no confidence, no candidate list and no warning, so a client checks by comparing that id against the storage it intended (recipes/004_register_published_file step 5).

  • There is no conditional write. All six headers were accepted and ignored, each at 200 with the write applied. The GET does return a weak Etag, so it looks like a precondition is available and no request built on it is honoured. The read-then-write race on version_number cannot be closed at the API; it stays a client convention.

corpus/findings/058_local_storage_roots.md

069_client_note

client_note cannot be set over REST: true on create is 400 and any PUT is 400 editable on create only. sg_note_type: "Client" is the one marker a caller can write.

Two refusals, one field. The create path answers Client Notes can not be created through the API, and the update path answers Note.client_note is editable on create only. Read together they close every route: the only call allowed to set the flag refuses true, and false is what an omitted key already stores. The schema's editable: false is right here, unlike created_at (probe 070). sudo_as_login changes nothing; the refusal is on the API, not on the identity.

sg_note_type is what a REST caller can write. Both fields are stock (visible.editable false, probe 056). sg_note_type is an ordinary list: a value outside valid_values is 400 with the vocabulary in the error, a PUT is 200, and is filters count it. On the probed site the vocabulary is Internal and Client; read it from the schema, never assume it. Setting it to Client leaves client_note false, so a client written this way is invisible to a filter on client_note.

Filter both when listing client-facing Notes. A Note the web application flagged and a Note the API typed are two disjoint sets: client_note is true finds the first, sg_note_type is "Client" the second. On the probed sandbox, 0 and 108 rows.

corpus/findings/069_client_note.md

070_authored_timestamps

A create body sets created_at and updated_at and they read back exactly, on Note, Task and Version, though the schema flags both editable false; every PUT on either 400s. [partial]

not measured: Whether an EventLogEntry create can date itself is untried: that row cannot be deleted afterwards (probe 025), so the probe did not spend one.

editable: false does not describe the create path. Both timestamps are flagged editable: false on all four types and both are accepted in a create body. This is the same inversion probe 012 found on mandatory, where the one field flagged mandatory on a Note is optional and project, which is not flagged, is required. The server's own error says which half of the flag is real: is editable on create only, not is not editable. Read editable: false as "not editable by a PUT" and test the create.

verb created_at updated_at
POST stored as sent stored as sent, on the types that have it
PUT 400 is editable on create only 400 is editable on create only

An authored date is the real one. It is what the row reads back, what created_at filters and sorts on, and what less_than selects: nothing keeps a separate wall-clock insert time. An import writes history that queries correctly, and a bug writes rows that a "created this week" feed can never see.

null is accepted and leaves the row undated. {"created_at": null} answers 201 and the field reads back None, so every created_at filter and every sort on it drops the row. Omit the key rather than sending null on a create built by dropping empty values.

  • updated_at is not on Reply at all: the create 400s with API create() Reply.updated_at doesn't exist. created_at is there and takes a value like the rest.

  • The value shapes are the date_time write shapes exactly (field_types/date_time): ISO 8601 with or without an offset, a date-only string meaning midnight UTC, an offset normalised to UTC, and "YYYY-MM-DD HH:MM:SS UTC" refused, which is the spelling the create's own 201 echo uses.

  • The 201 echo and the re-read disagree about the format. Three of the four types echo 2019-03-04 05:06:07 UTC, Task echoes ISO 8601, and a GET on any of them returns ISO 8601. Parse the re-read, not the echo.

  • sudo_as_login changes nothing here: a person's create dates itself exactly as the script's does.

  • Nothing measured here reaches the event log. A create still writes an EventLogEntry dated now, and that entry cannot be deleted (probe 025), so a back-dated import leaves a forward-dated audit trail.

corpus/findings/070_authored_timestamps.md

078_page_setting_write

A script cannot create a Page (HumanUser expected), a person can. settings_json writes only as a JSON string, reads back identical. DELETE on a PageSetting is 400: every created row is permanent. [partial]

not measured: What the web interface draws for a person whose override the script wrote: needs a person at a browser. Blocked on the work.

  • A Page needs a person. A script's create is refused by name (HumanUser(#...) expected, got ApiUser). Create as a person with sudo_as_login; page_type is read only and the server fills it (canvas), along with a default tree copied from the type's default page.

  • settings_json is written as a string and read as an object. Send json.dumps(tree). The server validates nothing past "a string": a value with no widget tree is stored at 200, and a second shared row on one page is accepted, so a writer can leave a page the web interface cannot draw.

  • PageSetting rows cannot be deleted. DELETE is 400 doesn't respond to retirement, and deleting the Page leaves its rows behind with page reading null. On the probed site 26372 of 30145 PageSetting rows have a null page (probe 023): that is where they come from.

  • This probe therefore clears settings_json to null on every row it leaves, and runs its row-creating half only with --litter.

  • A person's override written by the script is stored and read back like one the web interface wrote. Whether the web interface then draws it was not measured.

  • On the probed site each run left one PageSetting row, page null and settings_json null; the runs that measured this finding left 7.

corpus/findings/078_page_setting_write.md

083_task_template_on_create

A create with task_template makes the Tasks inside the same call, by POST and by _batch, copying every field set on the template tasks and their dependency types and offsets.

on the template task on the generated Task
content, step, sg_sort_order, sg_status_list copied
duration, est_in_mins, sg_description, milestone copied
task_assignees copied
start_date, due_date copied as the same calendar dates, not shifted
a TaskDependency with dependency_type and offset_days a new TaskDependency between the new Tasks, same type and offset
the template task itself template_task points at it
task_template null on the generated Task; the Shot holds it
project, entity the Shot's project, the Shot
  • The Tasks exist before the 201 returns: a read straight after the create found all three, and one 5s later found the same three. There is no background job to poll for.

  • The 201 body's tasks relationship is [] although the Tasks exist. Read them with ["entity", "is", <the Shot>] on /entity/tasks/_search, not off the create response.

  • _batch applies the template exactly as POST does. Recipe 002's rule still holds: the batch cannot name the Tasks it generates, so read them back afterwards.

  • entity_type on the template is not checked: an Asset template on a Shot create generated its Task.

  • Dates copy verbatim. A template task dated in March makes a March Task on every entity, whatever day it is created; schedule them afterwards (probe 087 for what a date write then moves).

  • Reapplying to a Shot that already has Tasks is probe 084.

corpus/findings/083_task_template_on_create.md

084_task_template_reapply

Changing task_template to T creates a Task per T task no Task links by template_task, duplicating a same-name hand-made one, and re-syncs the linked Tasks' fields and edges (probe 102).

on the Shot already the new template's task result
nothing any created
a Task whose template_task is this template task the same not re-created; re-synced to it, fields and edges (probe 102)
a Task made from another template, same content and step this one created: a duplicate
a Task made from another template, same content, other step this one created
a hand-made Task, same content and step this one created: a duplicate
a Task from the old template the new one lacks none kept
  • The match key is template_task, not content and step. A template task is not re-created only when a Task on the entity already points at it. Delete that Task and the next apply re-creates it.

  • No Task is ever removed. Switching templates, and clearing the field, leave every Task in place, statuses and all. A replace means the caller deletes the Tasks itself (probe 089 for what that breaks).

  • It does not only add. The Tasks linked to the new template have their fields overwritten and the edges between them reset to the template's (probes 096, 102 correct this entry's first reading).

  • The apply runs only when the value changes. Sending the stored value again added nothing on Shot E although a Task was missing; clear the field first, then set it, as Shot D did.

  • There is no mode. No body key, schema property or documented parameter selects keep, replace or merge. To merge by content and step, point each matching Task's template_task at its template task first, then write task_template (recipe 015_apply_task_template_without_duplicates).

corpus/findings/084_task_template_reapply.md

085_task_dependency_types

TaskDependency takes four dependency_type values, default finish-to-start-next-day; offset_days counts working days and snaps the dependent both ways. shift_ratio moved nothing.

dependency_type the dependent Task (task) is placed so that
finish-to-start-next-day it starts the working day after dependent_task ends
start-to-start it starts the day dependent_task starts
finish-to-finish it ends the day dependent_task ends
start-to-finish-next-day it ends the working day before dependent_task starts
  • The field names read backwards. task is the downstream Task and dependent_task is the one it depends on: the row reads Task <task> dependent on Task <dependent_task>, and task gets dependent_task in its upstream_tasks.

  • offset_days is working days on top of the type and may be negative: finish-to-start-next-day with 2 moved Monday to Wednesday, with -1 it put a start on the upstream's Friday and its end on the next Monday.

  • The dependent snaps to the constraint in both directions. Every D started two weeks early and was moved later; setting offset_days back to null moved a D earlier. It is placement, not a minimum.

  • PUT on a live row reschedules at once, so a type or offset can be corrected in place.

  • shift_ratio 0.5 was accepted with 201 and changed no date in any of the four types. Its effect is unmeasured beyond that.

  • The server rejects a duplicate pair, a self-loop and a two-Task cycle with a 400; a three-Task cycle is the same 400, inside _batch too (probe 107). pinned stayed false throughout (probe 087 for pinned Tasks).

  • offset_days null and 0 place the Task alike but are two stored values: a filter on one misses the other, and a template apply treats them as a difference (probe 105).

corpus/findings/085_task_dependency_types.md

086_batch_tasks_with_dependencies

Tasks and their dependencies take two _batch calls: create the Tasks, then create TaskDependency rows. upstream_tasks on a create links without rescheduling.

route calls dependency type dependents scheduled
one batch with a placeholder id 1 n/a 400, nothing created
Task creates, then TaskDependency creates 2 any, with offset_days yes
Task creates, then upstream_tasks updates 2 finish-to-start-next-day only yes
level by level, upstream_tasks in the create body one per level finish-to-start-next-day only no
  • A link made at create time does not schedule. upstream_tasks in a create body, batched or not, writes the TaskDependency row and leaves the dates as sent, with dependency_violation false. A later write to another field does not fix them. Write the link as a separate update or row.

  • "entity": "TaskDependency" is a valid batch entity, so route 1 is the one that takes a type and an offset: it is how to copy a template's edges (probe 085 for what each type does).

  • A loop in a dependency batch rolls the whole batch back like any other failure (recipe 002).

  • Recipe 016_create_tasks_with_dependencies is route 1 as code.

corpus/findings/086_batch_tasks_with_dependencies.md

087_dependency_cascade

An upstream date write reschedules every unpinned downstream Task, later and earlier alike; a null one moves none (097). A pinned Task stays put and flags dependency_violation while broken.

the downstream Task after an upstream date write
unpinned, any depth moved to satisfy its dependency, later or earlier, duration held
start-to-start follows the upstream start; untouched by a due date write
pinned true dates held; dependency_violation true while broken, false again once satisfied
downstream of a pinned Task follows the pinned Task, not the upstream end of the chain
finish-to-start, when a Task with no upstream has its dates written null unmoved; the next real date write moves it (probe 097)
  • The cascade pulls back as well as pushes. Shortening the upstream moved d1 and d2 earlier. A Task whose dates a person chose and did not pin is overwritten by any upstream write, and by a new edge (probe 092).

  • Writing a dependent's start_date pins it. The date PUT on d1 set pinned true (as entity_types/Task found) and d2 followed d1 to a date before the upstream ends. That PUT wrote start_date; probe 093 found start_date is what pins, null or real, and a due_date write alone does not. A duration write does not (probe 100); a Task with no upstream never pins (probe 097).

  • PUT {"pinned": false} reschedules at once: d1 snapped back behind the upstream and d2 with it.

  • pinned is writable directly, so a sync can protect a Task before it rewrites the upstream end.

corpus/findings/087_dependency_cascade.md

089_task_delete_side_effects

Deleting a Task retires its TaskDependency rows, unlinks both neighbours without bridging them, and nulls Version.sg_task and PublishedFile.task. Revive restores all of it.

linked to the deleted Task after DELETE after revive
its TaskDependency rows retired: 404 on GET, listed under return_only: retired live again
the upstream and downstream neighbours unlinked from it; not linked to each other relinked
the neighbours' dates unchanged the chain rescheduled from the upstream's current dates
Version.sg_task null; the Version stays the Task again
PublishedFile.task null; the file stays the Task again
  • A PublishedFile loses its Task and nothing says so. The file stays live with task null, so a ["task", "is", ...] query stops finding it and the publish reads as an orphan. Read what points at a Task before deleting it; the 204 names nothing.

  • The chain is cut, not bridged. c stopped following a: moving a afterwards left c where it was. A sync that removes a middle Task must write the a -> c dependency itself if it wants one.

  • Revive is a full undo on the links measured here: dependencies, sg_task and task all returned with the same row ids. The revived chain is rescheduled at once, so its dates are not the ones it was deleted with.

  • A delete request inside _batch does the same to the Task, its dependency rows, its neighbours and Version.sg_task, and revive undoes it the same way (probe 103). PublishedFile.task was not measured on that route.

  • Deleting a Task retires only the Task and its dependency rows, unlike deleting a Shot, which retires its Versions (probe 060).

corpus/findings/089_task_delete_side_effects.md

092_dependency_edge_reschedule

A new edge reschedules an unpinned downstream Task at once, whether POSTed or copied by a template apply on claim. A pinned one keeps its dates and flags dependency_violation.

  • An edge is a scheduling write. Creating one moves an unpinned downstream Task to satisfy it, the same as the upstream date write of probe 087, duration held. The upstream Task does not move.

  • A template apply reschedules Tasks it did not create. The edge it copies between claimed Tasks (recipe 015) moved b two days although no date was sent. Pin a Task whose dates a person chose before the apply, or restore its dates after.

  • A pinned downstream Task keeps its dates and reads dependency_violation true from the moment the edge exists. Neither route sets or clears pinned.

  • The claim itself (template_task written) moves nothing, and the reschedule is done before the PUT returns: a read 3 s later matched the first. The template's undated tasks copied no dates.

corpus/findings/092_dependency_edge_reschedule.md

093_clear_dates_pin

On a dependent Task a start_date write pins it, null or real; a due_date write never does, null or real. A pinned null Task holds; PUT pinned:false refills both dates.

write on a dependent Task pinned after on the next upstream write
start_date null, alone or with due_date true held; the null stays null, dependency_violation stays false
start_date real true (control) held; dependency_violation true
due_date null alone false follows: both dates rewritten from the upstream and duration
due_date real false (control, twice); duration recomputed follows, new duration kept
PUT {"pinned": false} false rewrites start_date from the upstream, due_date from duration
  • start_date is the pinning write, not "any date". The same Task (due) stayed unpinned after due_date null and after a real due_date, then pinned on a real start_date. A due_date write acts like a duration write (probe 100): it resizes, it does not anchor.

  • Nothing unpins a Task by itself: both and start stayed pinned with a null start across the upstream move. A null start raises no dependency_violation, so it is invisible to a violation check.

  • duration survives every null write (960 throughout); the unpin recompute uses it to refill due_date.

  • A sync that wants the server to reschedule a Task sets pinned: false; nulling the dates either pins it (start_date) or is overwritten at the next upstream write (due_date).

corpus/findings/093_clear_dates_pin.md

094_permission_preflight

Ask with a write that cannot land: a no-op PUT per field (update), a POST with a bad status (create), a _batch of [delete, 404 sentinel] (delete). Permission is checked first, and nothing is written. [partial]

not measured: a launcher session (probe 052) of a lower-level person, and the allowed side of a conditional rule (an Artist assigned to the Task); both need a person, the first at a browser

  • Every refusal is a 400 naming the entity or the field, checked before value validation and before the batch reaches its next request. An allowed caller gets the validation error or the sentinel's 404 instead. Nothing reaches the rows either way: no updated_at bump, no EventLogEntry, no retired row.

  • properties.editable in GET /schema/<Type>/fields?project_id= is per caller. false is a refusal without a write. true can still be refused by a conditional rule (candidate 3), so it means maybe.

  • Candidates 5, 7 and 8 answer the same for both callers and test nothing: an empty PUT passes, and an unknown field or a missing id fails before permission is read.

  • A no-op PUT tests the current value. A rule can depend on field_value, so test the intended value with a _batch of [the real update, sentinel] (candidate 11), which rolls back.

Callers. The refused person and the allowed person are the script acting through sudo_as_login (probe 027), which applies that person's permission set. A person signed in with the App Session Launcher (probe 052, recipe 012) has the same set on a HumanUser bearer; that session was not measured as an Artist, because the launcher needs the person to approve at a browser.

Precondition, declared. The probe provisions its rows. It cannot provision the refused caller: can_impersonate_this_user is not writable over REST (probe 027). Its requires list names an active non-Admin HumanUser with that flag on and in the sandbox project, found by a _search, and the probe exits with the list when there is none. On the probed site two Artists qualify.

A conditional refusal prints its rule. Probe 027 found no rule readable as a row. The 400 for a conditional rule returns the rule id and its condition tree: on the probed site an Artist may set Task.sg_status_list only where task_assignees or task_reviewers (or a Group in either) holds the caller. An unconditional refusal names only the field.

A late bump on a rolled-back create. In exploratory runs of the same _batch [create a Task under a Shot, sentinel] by an allowed caller, the parent Shot's updated_at moved a few seconds after the call in 4 of 15 rolled-back creates, with updated_by unchanged, no EventLogEntry and no Task. The run above saw none; one earlier probe run saw one. No other candidate moved a timestamp in any run. Check create with the invalid-status POST (candidate 6), which left its parent unchanged in all 3 probe runs.

Unmeasured. An Artist assigned to the Task, which is the allowed side of the rule in candidate 3: assigning a real person can notify them. Delete is checked per entity type here; a conditional delete rule would need the same _batch per row. Assets were read in the schema only; the PUT candidates ran on a Shot.

corpus/findings/094_permission_preflight.md

095_dependency_remove_undo

Remove an edge with DELETE on its TaskDependency row: revive restores its type and offset. A remove on upstream_tasks or downstream_tasks erases the row for good.

remove by the TaskDependency row undo
DELETE /entity/task_dependencies/<id> retired: 404 on GET, listed under return_only: retired POST .../<id>?revive=1, same id, type and offset
a delete request on the row inside _batch retired, the same (probe 103) revive, the same
remove on the downstream Task's upstream_tasks erased: not listed as retired re-create; revive is 404
remove on the upstream Task's downstream_tasks erased, the same re-create; revive is 404
the downstream Task after the edge is removed after revive or re-create
unpinned dates held where the edge put them; no longer follows the upstream rescheduled at once from the upstream's current dates
pinned, in violation dates and pinned held; dependency_violation false dates held; dependency_violation true again
  • Delete the row, not the link. An undo stack that removes an edge by a multi_entity remove cannot bring it back: the row is gone, and re-adding through upstream_tasks writes a new row typed finish-to-start-next-day with no offset. Record the row id and delete it, by DELETE or in _batch.

  • A re-created row with the same type and offset places the Task as the revived row would. The difference is the id, and the retired original then cannot be revived: the pair is unique across live rows, so revive after re-create is the 400 above. Undo by revive, or by re-create, not both.

  • Neither route restores the downstream Task's old dates. An unpinned Task snaps to the edge as measured against the upstream now (probe 085); an undo that wants the old dates writes them, and the start_date write pins the Task (probe 093).

  • An edge places an unpinned Task exactly, not at the earliest: l1 and l3, written late, were pulled back to the edge. A pinned Task placed later than that reads dependency_violation false for both types (l2, l4); only one placed earlier (d) reads true.

corpus/findings/095_dependency_remove_undo.md

096_task_template_unmerge

A template write re-syncs every Task linked to it: fields but status reset, edges rewired. Undo: old template_task per Task first, then old task_template, then delete what B made.

write server does
template_task on a Task nothing but that field
task_template changed to T for every Task pointing at a T task: sg_sort_order, sg_description, duration set to the template task's; sg_status_list kept
the same creates the Tasks no Task points at (probe 084), adds T's missing edges, deletes edges between two T-linked Tasks that T lacks, moves an edge to the Task that now holds its template end
task_template null nothing: no field, Task or edge touched
  • The apply overwrites hand edits. It re-syncs every linked Task, not only the new ones: roto, never claimed, lost its description and duration. This corrects probe 084's "skipped" and recipe 015, which says only template_task is written. Status is the one field measured to survive.

  • Order: Tasks first, then the entity. Entity first, A's apply finds its tasks unclaimed, makes a second comp and lay, and moves A's edge onto them. Pointing the originals back afterwards merges nothing.

  • Undo to A needs three kinds of write: old template_task per claimed Task, old task_template, DELETE per Task B made (its edges retire, probe 089). The apply removes B's edges between claimed Tasks.

  • Undo to null gets no server help: delete B's edges between claimed Tasks yourself. Either way, write back the hand-edited fields read before the merge; the merge overwrote them and the undo's apply does too.

corpus/findings/096_task_template_unmerge.md

097_null_dates_unpin

A Task with no upstream never pins, on a null or a real date write; nulling its dates leaves its downstream unmoved, and pinned:false refills nothing.

the Task after a date write
no edges, dates set null pinned stays false; a null write only pins a Task that has an upstream (093, entity_types/Task)
no edges, real dates pinned stays false
upstream-only (has downstream, no upstream), null or real dates pinned stays false
its finish-to-start downstream unmoved by the null write; moved by the real one (03-11..03-12), as in 087
  • Only a Task with an upstream pins on a date write. Here neither a null nor a real date write set pinned on a Task with no upstream, with or without a downstream. 087 and 093 measured the pin on dependents.

  • PUT {"pinned": false} on a Task that was already false is a no-op: the nulls survive it. No fallback anchor filled them: not duration, not a project date, not today.

  • Sending the nulls and pinned: false in one PUT read back the same as the nulls alone.

  • A null upstream leaves the downstream's stored dates where they were; the next real date write on the same upstream moves it again. The edge still schedules; a null gives it nothing to schedule from.

  • A client that wants a Task to go back to "server picks the date" has no move here: clearing a root Task's dates is a dead end, not a pending state. It stays null/null until something writes a real date onto it.

corpus/findings/097_null_dates_unpin.md

098_template_merge_in_one_batch

Recipe 015's merge fits one _batch: requests run in order, so a task_template write sees claims made earlier in the batch, and null then T on the same Shot re-runs the apply.

  • A batch applies its requests in order and each sees the one before: a claim earlier in the batch stops the apply from duplicating that Task, exactly as when the claim is a call of its own.

  • Two updates of the same field on the same record in one batch are not collapsed. null then T runs the apply, as two PUTs do (probe 084, Shot D); T alone on a Shot that holds T does not.

  • The one-batch merge and recipe 015's split sequence left the same Tasks, statuses and edges; the template's edge was written onto the claimed hand-made Task in both.

  • One call instead of three, and atomic: a failing claim rolls the clear and the set back with it (recipe 002), and a request failing after the set rolls back the apply's Tasks and edges (probe 113). Recipe 020 is this as code.

corpus/findings/098_template_merge_in_one_batch.md

099_template_apply_edge_copy_kept

A template apply copies a missing edge between two Tasks whose template_task already match it, whether either was claimed, kept, or created by that same call.

  • The edge is copied in all three cases: kept+claimed, kept+kept with the edge missing, and kept+created. Probe 092 already showed claimed+claimed, so every pairing of {kept, claimed, created} a merge apply can produce ends up holding the template's edge.

  • The copy comes from the task_template write, not from the claim. In case 1 the _batch claim set y.template_task and left the pair with no edge; the edge appeared only after the PUT.

  • The apply fills edges between linked Tasks, not only the ones it just touched. Case 2 claimed and created nothing: both Tasks already had template_task set, yet the missing edge appeared.

  • Clearing and re-setting task_template over Tasks linked by an earlier apply fills a missing edge (case 2), but the same write re-syncs those Tasks' fields to the template (probe 102). It is not a safe way to repair edges alone.

corpus/findings/099_template_apply_edge_copy_kept.md

100_duration_write_pin

Writing duration on a dependent Task does not pin it; a start_date write in the same run does. It keeps following the upstream, and a duration write upstream moves it.

write effect on the dependent (down)
duration alone on an unlinked Task (solo) pinned stays false; start_date kept, due_date stretches to hold the new duration
duration alone on down the same: pinned stays false, start_date kept (already the day after the upstream ends), due_date stretches
upstream moves later, after that down moves with it, duration held at 1920
duration on the upstream (up) up's due_date moves; down and down2 follow it, same as a date write (087)
start_date on down (control) pinned turns true; duration held, due_date moves; down2 follows
  • duration does not pin. In the same run a start_date write on down did. due_date was not written on the dependent here; that it pins too rests on entity_types/Task, 087 and 093.

  • On the dependent, a duration write keeps start_date and moves due_date, the same as on the unlinked solo. The dependent then keeps following its upstream.

  • down2 moved on every write that moved down, the duration-only write included: a dependent's own duration write cascades downstream. It stayed put on the no-op pinned=false write, where nothing moved.

  • Writing duration on the upstream end reschedules every unpinned downstream Task, so probe 087's date-based finding holds for duration too.

corpus/findings/100_duration_write_pin.md

101_template_edge_conflict

On a claimed pair, a template apply replaces an existing edge of another type, or the reverse edge, with the template's edge: the old row is erased, not retired, and the PUT is a plain 200.

  • The template's edge wins. In both cases the pre-existing edge is gone and the template's b on a finish-to-start-next-day stands in its place. No error, no skip, no duplicate, no loop.

  • The old row is erased, not retired. It reads 404 under options[return_only]=retired, where a TaskDependency the caller DELETEs reads 200. No retired row is left to find; read the edges first.

  • Nothing rolls back: the PUT is 200, task_template is stored, and the unclaimed template task c is generated. The caller learns of the swap only by reading the edges.

  • An edge with a Task outside the template downstream of a claimed one (x on a) is kept. The reverse, a claimed Task depending on an outside Task, is erased (probes 107, 109). An edge between two claimed Tasks that the template does not link either way is deleted (probe 102).

corpus/findings/101_template_edge_conflict.md

102_task_template_resync

Writing task_template T re-syncs every Task linked to T: T's non-empty values overwrite, status kept, dates and assignees kept or filled if empty; edges between linked Tasks reset to T's.

on T's task on the linked Task before after the write
a value in content, step, est_in_mins, sg_description, sg_sort_order, task_reviewers, milestone anything overwritten with T's: a renamed Task gets its old name back
a value in a custom field: on the probed site one list field and one checkbox field, both behaved as above anything overwritten with T's
duration a Task without dates overwritten; a Task with start and due keeps its dates and the duration they give
duration only start_date or only due_date set, duration null kept: stays null, no date filled (probe 108)
a numeric 0: est_in_mins, or duration on a Task without dates a value overwritten with 0 (probe 108)
start_date, due_date set / empty kept / filled, then moved by the dependency cascade (probe 087)
task_assignees set / empty kept / filled
sg_status_list, pinned anything kept
empty: null, a checkbox's false, a text "" (stored as null on the template task) a value kept: an empty template field never clears (probe 108)
edge, T has it missing / other type or offset, offset_days null against 0 included (probe 105) created / erased and re-created as T's (new id)
edge T lacks both ends linked to T erased
edge T lacks downstream end linked to T, upstream end not (unlinked, another template, another entity) erased (probes 107, 109)
edge T lacks upstream end linked to T, downstream end not kept: x1 on a1, u2 on a2 here, w on b in probe 109
  • Every write that changes task_template to T re-syncs all Tasks already linked to T, after a clear or from another template, and Tasks claimed a moment earlier (recipe 015) the same as Tasks T made. Setting milestone collapses the Task to one day at its due date, duration 0.

  • Kept dates are the re-sync's, not a pin's: the unpinned root a1 keeps them. The re-sync leaves pinned as it was. An edge it deletes is erased: 404 under options[return_only]=retired.

  • Writing another template U or null touches no T-linked Task or edge (probe 096 agrees).

  • The edge rows for a Task not linked to T are corrected by probes 107 and 109: this run measured only the outside Task downstream (x1, u2), and first read "one end unlinked → kept" for both directions.

  • Two Tasks linked to one template task: only one is re-synced and wired, picked unpredictably (probe 106).

  • Corrected in probe 084 (it read "only adds", linked Tasks "skipped") and recipe 015 (it read "creates only what is missing" and "Only template_task is written"). Probe 083 holds.

corpus/findings/102_task_template_resync.md

103_batch_delete_revive

A delete inside _batch retires a Task or TaskDependency exactly as DELETE does: same retired read-back, and revive returns the same id, fields, edges and Version.sg_task.

  • A batch delete is a retire, not an erase. Every read-back matched the plain DELETE: the row lists under return_only: retired by _search and by GET options[return_only]=retired, and POST /entity/<type>/<id>?revive=1 answers did_revive: true.

  • The side effects of deleting a Task (probe 089) are the same on both routes: its edges retire with it, the neighbour's link drops, Version.sg_task reads null, and revive restores all of it with the same ids.

  • An undo stack can record the ids a batch delete returns (data[i].id) and revive them one by one; recipe 018 applies to a batch-deleted edge unchanged.

  • Not measured: revive inside _batch (it accepts only create, update, delete, recipe 002), a Task and its edge deleted in the same batch, and a PublishedFile link.

The probe provisions every row it reads; no operator step. It runs each row through the batch delete first and the DELETE control second, on the same row, with a full read-back between steps.

corpus/findings/103_batch_delete_revive.md

104_template_unmerge_in_one_batch

Recipe 019's undo fits one _batch with the same end state, if the batch skips edges its own task_template write removes: deleting one 404s and rolls back all. Undo to null deletes them.

  • One batch gives the split sequence's end state in both cases measured: no duplicate Task, the old template_task links, the old edges with their ids, the snapshot's fields, status kept.

  • Requests run in order and the task_template A write runs its apply mid-batch (probe 098): it removes B's edge between the two claimed Tasks. A later DELETE of that edge 404s and rolls back the whole batch (recipe 002). Recipe 019's step 3 reads the edges after that write; a batch cannot.

  • So read every id before the batch and leave out edges whose two ends go back to a template task of a non-null old template. Undo to null: the server removes nothing, keep the DELETE. Mixed ends: not measured.

  • A Task DELETE in the batch retires its edges, as a DELETE call does (probe 089): paint on lay went with paint in both. Provisioned by the probe; no operator step. Recipe 022 is this as code.

corpus/findings/104_template_unmerge_in_one_batch.md

105_offset_days_null_vs_zero

TaskDependency offset_days null and 0 are stored and compared as different: a template apply deletes an entity edge with null against a template 0 (or the reverse) and re-creates it with a new id.

  • Null and 0 are two stored values. A create with null or with the key omitted reads back null; a create with 0 reads back 0. offset_days is 0 does not match a null row, and is null does not match a 0.

  • The apply compares them as different. Template 0 against entity null, and template null against entity 0, both end with the entity edge deleted (GET 404) and re-created with the template's value and a new id, the same as a real difference (the e1 control, 2 against 0). The unchanged d1 kept its id.

  • To keep edge ids through a re-apply, write offset_days exactly as the template holds it, null or 0, never one for the other. Anything keyed on a TaskDependency id loses it otherwise (probe 101: the old row is erased, not retired).

  • The POST response omits offset_days when it is null; read it with a GET or a _search.

  • Provisioned by the probe; no operator step. Only finish-to-start-next-day was measured, and the dates of null against 0 are probe 085's, not measured again here.

corpus/findings/105_offset_days_null_vs_zero.md

106_template_task_linked_twice

With two Tasks linked to one template task, an apply re-syncs and wires only one of them, picked unpredictably (not by id, age or edges); the other is left as is. No error, nothing duplicated.

  • One Task per template task is re-synced and wired, the others are skipped. The skipped one keeps its content and fields, still points at X, and gets no edge. No second X is created; w and y are created only when nothing links to them. Every PUT is 200.

  • Which one wins is not predictable from the caller's side. Across 6 runs the pick flipped on identical setups: not the lowest id, not the oldest created_at, not the first by content, and not the Task already holding T's edges (Shot4 run 4).

  • When the other Task wins, the loser's edges, both of T's shape, are handled unevenly: y on xb was deleted, xb on w was kept, and the winner got both. Measured once; the cause is not measured.

  • Before an apply, leave at most one Task per template task linked: unlink or re-point the others (template_task null), or the result depends on the server's pick. Recipe 015's key caveat can produce this state (probe 096 made it by hand).

corpus/findings/106_template_task_linked_twice.md

107_dependency_three_task_loop

A three-Task loop is a 400 on a direct create and inside _batch, which rolls back whole. A template apply deletes a claimed Task's upstream edge from a Task outside the template, loop or not.

  • The loop check follows the whole chain: closing a three-Task cycle is the same 400 as the two-Task case (probe 085). Inside _batch it counts rows the same batch created earlier, and the batch rolls back with no row left (recipe 002).

  • A template apply never closed the loop because it had already deleted a leg. The PUT task_template erased a on x, where a claimed Task depends on a Task outside the template, in the control Shot too, where no loop was possible. No error; the row reads 404 under options[return_only]=retired, as in probe 101.

  • The reverse, x on b (the outside Task downstream of a claimed one), was kept, as probes 101 and 102 found. Probe 102's row "one end unlinked → kept" holds only for that direction. Read a claimed Task's upstream_tasks before the apply and re-create the edges it should keep.

  • Not measured: a claimed Task that has an upstream in the template (here b) depending on an outside Task, and a loop the apply could close without deleting a leg.

corpus/findings/107_dependency_three_task_loop.md

108_task_template_resync_empties

Re-sync to T: a numeric 0 on T's task overwrites (est, duration); milestone false and "" (stored null) keep the Task's value; a Task with only start or only due keeps its null duration.

on T's task on the linked Task after the re-sync
milestone true (control) false overwritten: true
milestone false true kept: true. False is the checkbox's empty
est_in_mins 0 60 overwritten: 0
duration 0 1920, no dates overwritten: 0
duration 480 (control) 1920, no dates overwritten: 480 (102 agrees)
sg_description "" "hand" kept. The server stored "" as null on T's task, so "" and null are one case
sg_description null, est_in_mins null (negative control) a value kept (102 agrees)
duration 960 only start_date set, duration null kept: duration stays null, no date filled
duration 960 only due_date set, duration null kept: duration stays null, no date filled
  • 0 is a value, false is not. A numeric 0 on T's task wipes the Task's number; a false checkbox never clears a true one. A merge that means "leave it" must not store 0 on the template.

  • duration copies only onto a Task with no dates (here and in 102). Either date set, alone or with the other, keeps the Task's duration; with one date only, it stays null.

  • A text field cannot hold "" on a template task: the write is accepted and reads back null.

  • Not measured: "" on the linked Task side; sg_sort_order 0; a custom number or checkbox field; milestone false on T vs a Task with dates; duration 0 on T vs a dated Task.

corpus/findings/108_task_template_resync_empties.md

109_template_apply_outside_edge

A template apply erases an edge where a linked Task depends on a Task not linked to the template (root or not, other template, other Shot); it kept the edge with the outside Task downstream.

  • Measured rule: an edge whose downstream end is a Task linked to T and whose upstream end is not linked to T is erased by the apply. It held for a root (a) and a non-root (b), for an unlinked Task, a Task linked to another template, and a Task on another entity. The claim alone did not touch it; the PUT task_template did.

  • An edge whose upstream end is linked to T and whose downstream end is not (w on b) was kept, as in probes 101, 102 and 107. One case only.

  • Erased, not retired: 404 under options[return_only]=retired, where an edge the caller DELETEs reads 200 (control in this run; probe 101 too). No error, no row to recover. Read each linked Task's upstream_tasks before the apply and re-create the edges to keep.

  • Probe 102's "one end unlinked or linked to another template → kept" holds only for the downstream direction.

  • Not measured: an outside Task upstream of a Task the apply creates (no edge to that Task can exist before the apply makes it); an outside Task downstream of a root; outside edges on a re-apply of the same template.

corpus/findings/109_template_apply_outside_edge.md

110_template_task_after_revive

Revive restores template_task. A task_template write while the Task is retired re-creates it, so a later revive leaves two Tasks on one template task. Revive first, then write.

  • Revive restores template_task, on both delete routes. The retired row keeps it: a _search with return_only: retired reads template_task A.x before the revive.

  • A retired Task does not count as linked. The apply re-creates its template task (probe 084's match key) and copies the template edge onto the copy. Reviving the original afterwards gives two Tasks on A.x, and Y then depends on both, by two edges.

  • Order: revive, then the template write. Revived first, the Task is linked again and the apply makes nothing. _batch takes no revive (recipe 021), so an undo revives by separate calls before its batch (recipe 022).

  • Measured with null -> A only. The B -> A write of an undo (probes 096, 104) was not measured here, nor a Task retired from a template other than the one written.

The probe provisions every row; no operator step. Y's Task is the negative control: live throughout, never duplicated in any of the four runs.

corpus/findings/110_template_task_after_revive.md

111_template_undo_outside_edge

An undo's write back to template A erases every edge whose downstream Task is A-linked and that A lacks, pre-merge edges included; recipe 022 DELETEs one such edge, 404s and rolls back.

  • The write back to A applies probe 109's rule: every edge whose downstream Task is A-linked and that A lacks is erased, whatever the upstream end: extra (R1, roto on x), merge-made (R2), or A-linked (roto on lay). Pre-merge edges the merge kept (roto on x, roto on lay) are lost by the undo. Edges with only the upstream end on A (paint on lay, y on lay) are kept.

  • Recipe 022 DELETEs every non-snapshot edge unless both ends go back to A, so a re-created outside edge (R1) 404s the batch and nothing lands. Leave out every edge whose downstream end goes back to an A task.

  • A's own roto on comp was re-created with a new id on both Shots; probe 104, where roto had no other upstream edge, kept the id. Recipe 019's step 3 sweep then deleted it, leaving W with no edge at all. Which hand edge causes the re-create: not measured.

  • Re-create the lost pre-merge edges from a snapshot of ends, type and offset (recipe 016). Doing that inside the undo batch: not measured.

corpus/findings/111_template_undo_outside_edge.md

112_template_unmerge_linked_twice

Undo relinking two Tasks to one template task: A wires either one (11 of 14 picked the loser), nothing is made. Relink the loser after the task_template write: then it matches the one-link undo.

  • Recipe 022 on this state does not undo. A's apply re-syncs and wires one of the two Tasks, the server's pick (probe 106): 11 of 14 went to the loser, the Task that held no edge and was unlinked by the merge, and the pick flipped between identical Shots in one run. Nothing is created.

  • When the loser is picked, the winner keeps B's fields and loses its edges: both of A's edges now sit on the loser, with new ids. Writing the snapshot's fields back does not move them. Recipe 022's KEEP lacks content, which A's re-sync renames on the loser: keep it.

  • Relink only one Task per template task before the task_template write, the one that held the edges, and the others after it in the same batch: a template_task write alone changes nothing (probe 096). D3 did so 3 of 3 and ended as the one-link control did.

  • Even the control is not the pre-merge state to the id: B's apply erased xa on w, a claimed Task on a Task outside B (probe 109), and A's apply recreates it with a new id. Every other id is kept.

corpus/findings/112_template_unmerge_linked_twice.md

113_batch_atomic_after_template_write

A _batch holding a task_template apply is atomic: a later or earlier failing request left no Task, no claim, no field write, no edge and no EventLogEntry row.

  • The apply rolls back with the batch. Wherever the failing request sits, a failed batch leaves no claim, no task_template change, no generated Task or edge and no field write, and writes no EventLogEntry row. Recipe 002's rollback holds for server-side work.

  • An EventLogEntry row showing an apply means a request that committed. A failed batch did not write it; look for a second call (recipe 020 is one batch; any after-apply step is another).

  • A TaskDependency create naming a retired Task is 400 Value is not legal. and takes the batch down. Re-read both ends before re-creating an edge.

  • The script key is shared: filter the log on your own rows, as other writers land in the same window.

corpus/findings/113_batch_atomic_after_template_write.md

127_retry_and_client_uuid

A text field created with unique: true refuses a second create with the same value, case and outer spaces ignored, in a batch too. It is the only idempotency key: the API has no header for it. [partial]

not measured: whether unique spans projects, and whether a deleted row's value frees. One project only. Blocked on the work

  • A client read timeout says nothing about the server: the abandoned batch committed all 20 rows, readable under two seconds later (recipe 002 saw the same at 1001 rows). Look up before re-sending.

  • Create one text field with unique: true for the client UUID and send it on every create. The retry of a committed create then fails with code 104 instead of duplicating; treat that 400 as "already there" and read the row by the UUID. unique can only be set at create (probe 116).

  • Uniqueness ignores case and surrounding spaces, so a UUID is safe but a human code is not a fit. The check runs inside _batch as well, and a refusal rolls the whole batch back (recipe 002), including two rows of the same batch that collide with each other.

  • The error title is the field's display name, not its programmatic name, and ends in a literal <br> . Code 104 is the general create failure, so match on it plus the display name in the title.

corpus/findings/127_retry_and_client_uuid.md

136_unique_scope_retired

A deleted row frees its unique value: a new row may take it. Reviving the old row while another holds the value is a 400 code 104 PG transaction error, and the row stays retired. [partial]

not measured: uniqueness across two projects. Probes write only into the sandbox and a project entity refuses a row with no project. Blocked on the site: needs a second writable project

row state holds K for uniqueness
live yes: a create with K is 400 code 104
retired (deleted) no: a create with K is 201, and the retired row still stores K
revived while a live row holds K the revive fails, 400 code 104, row stays retired
revived while nothing holds K 200; the row holds K again and blocks the next create
  • A lookup by key must search live rows only (the default) and treat a retired match as absent. A client that undoes a delete by reviving must expect the revive to fail when the key was reused, and the error names a Postgres transaction, not uniqueness.

  • The duplicate refusal names the field's display name, not its sg_ name, and ends in <br> .

  • Whether two projects can hold the same value is unmeasured. The refusal says "required to be unique" and names no scope; key on a value that is unique across the site (a UUID) and the question does not arise.

corpus/findings/136_unique_scope_retired.md

137_batch_create_coercion

A _batch create on a custom entity takes a numeric string in a float and honours created_at, as a single POST does. It also takes an Integer and "1e3", which a single POST refuses.

  • Send floats as strings in either path: "1.5" is accepted by both and reads back as a string.

  • created_at and updated_at in a batch create are stored as sent, offsets normalised to UTC, as on a single POST (probe 070). Stamp capture time this way.

  • The batch path is wider than the single one: an Integer and an exponent string both store. Code that is tested by batch can fail by single POST, so validate before sending rather than relying on either (report 001).

  • A refused batch value is code 104 Value is not legal. naming the field; the single path's code 103 says which types it takes. Debug a batch refusal by sending that request alone.

corpus/findings/137_batch_create_coercion.md

143_nonadmin_rows

On the probed site an Artist may not create, edit or delete custom-entity rows (status only) and may create but not delete an Attachment, its own included. The group rights call predicts each answer. [partial]

not measured: Manager and Vendor writes; rights read, not exercised. Blocked on the site: impersonation on for one of each in the sandbox, then 143 --write

  • Read the caller's own group with GET /schema/permission_groups then .../entity_types/<Type> before writing: every Artist answer above matched the table, the sg_status_list exception included. A person sees only their own group; an Admin sees all.

  • A refusal is a 400 code 104 naming the type or the field, as on Task and Shot (probe 094).

  • On the probed site a capture app run by an Artist cannot make its own rows on custom entities and cannot remove a photo it uploaded. Either the people get Manager, the site's Artist rules change, or the app writes through a script key.

  • Manager's rights were read, not exercised; a conditional rule can still refuse a write the table lists as allowed (probe 094).

corpus/findings/143_nonadmin_rows.md

145_time_fields

date_time rounds to the second on POST and PUT (.999 goes up, .5 stays) but truncates in a _batch create. A new timecode field has no rate property; it is integer ms rendered at the site's fixed rate.

  • date_time keeps whole seconds and the path decides which second. Round to the second yourself before sending, then every path stores the same value. A .999 capture time sent by _batch is one second earlier than the same value sent by POST.

  • The rounding is not half-up: .5 stayed on its second and .999 went to the next. Where the cut lies between was not measured. A filter value is rounded the same way as a write, so filtering with the value that was sent finds the row.

  • A timecode field has no rate anywhere: the create refuses a rate property, the schema shows none, and the value is milliseconds of wall-clock time. 01:00:00:12 therefore means 3600000 + 12 * 1000 / fps ms, rounded to an integer, and 3600500 and 3600501 both render as frame 12.

  • Milliseconds are fine enough for frames (one frame at 23.976 is 41.7 ms), but the field stores no rate, so a reader cannot tell which rate a value was written at, and the server renders every value at its own fixed rate (field_types/timecode). Store a frame count in a number field and the rate beside it, or the HH:MM:SS:FF string in text, as the stock cut fields do.

  • A new duration field behaves as the stock one: integer minutes, a float or numeric string truncated toward zero, a clock string refused.

corpus/findings/145_time_fields.md

146_note_unique_key

A unique: true text field works on Note as on Version (probe 127), and refuses a duplicate on PUT and under sudo too. A Note.meta key is found by contains, case-sensitive, and enforces nothing. [partial]

not measured: uniqueness across two projects. Probes write only into the sandbox. Blocked on the site: run 146 --write --second-project <name> with a second writable project

  • Note takes a unique field as Version and custom entities do; case, outer spaces and the is lookup behave as probe 127 measured. The refusal is the same code 104 under sudo_as_login and on a PUT, so a person's retry fails the same way: treat it as "already there" and read the Note by the key.

  • meta is a working lookup with no admin step: seed {"onset_uuid": ...} in the create, find it with contains. It does not stop a retry from making a second Note, so look up before every create, and send the key in the case it was minted in.

  • content and the other fields stay editable on a Note found by meta; only meta itself is fixed.

  • Whether two projects can hold the same key is unmeasured (probe 136 stopped at the same place). A UUID key makes the answer moot.

corpus/findings/146_note_unique_key.md

148_note_author_fields

user and created_by are both honoured on a Note or Version create, though the schema flags created_by read only; a PUT to it is 400. Under sudo_as_login all three author fields are the person. [partial]

not measured: a launcher session bearer (auth_type session_token). Needs a person: 052 --login, then 148 --write --session

  • created_by is writable once, on create, like created_at (probe 070) and Note.meta (field_types/jsonb). The schema's editable: false describes the update path only. Any caller can name another person as creator, so created_by is not proof of who wrote a row.

  • Under sudo_as_login the person is created_by, updated_by and user with nothing sent. A script sending user alone still leaves itself in created_by and updated_by.

  • The launcher bearer's claim is user: HumanUser with auth_type: session_token (probe 052), unlike the sudo bearer, whose user stays the ApiUser. What it records here is unmeasured. Run 052 --login, approve in the browser, then 148 --write --session.

corpus/findings/148_note_author_fields.md

154_batch_multi_entity_mode

multi_entity_update_mode in a _batch update's data adds, removes and sets as on a PUT, and several updates of one record in one batch apply in request order, each row echoing the state after it.

  • Write the mode inside data exactly as in a PUT body (recipe 009). A bare list still replaces the set, in a batch as on a PUT.

  • Requests on one record run in order, each on the result of the one before: add then set ends at the set, set then add keeps both. Each result row is the whole record after that request (recipe 002), so the last row for a record is its final state.

  • Several link edits to one row can share a batch with no read in between.

corpus/findings/154_batch_multi_entity_mode.md

156_action_menu_item

An ActionMenuItem creates from {} at 201 and url is not checked; an Artist is refused. Run from the web interface, an http url got a form POST in a new tab, json or not, with no token. [partial]

not measured: a custom-protocol url opening an app, whether permissions_groups hides an item in the web interface, and Manager rights. Each needs a person, steps below. Blocked on the work

  • Send title, url, entity_type and projects yourself: the server takes a row with none of them, and checks only entity_type (field_types/entity_type) and the list fields.

  • Creating one is an administrator's call on the probed site: Admin 201, Artist 400 code 104. Manager was not reachable (probe 132), so do not infer it.

  • permissions_groups is not a read filter: an Artist reads rows restricted to Admin. Whether it hides the item in the web interface is unmeasured.

  • secret_token is write-only through the API; keep the value on the client that checks signatures.

  • Parse the request as a form. With payload_content_type json, the browser posted the same application/x-www-form-urlencoded body to an http url as with form, field for field, in this run.

  • Act on selected_ids, split on commas. ids is every row on the page, selected or not, and title is the string undefined.

  • Check who sent it yourself. The body names a person (user_id, user_login) and holds no token, key or password, so any client that can reach the url can post the same form. Whether secret_token adds a signature was not measured.

  • Accept a cross-site navigation: Origin: null, Sec-Fetch-Site: cross-site, no Referer. A server that refuses cross-origin form posts refuses every run. Its response is the page the new tab shows.

Needs a person

question step
a custom-protocol url opening an app 156 --write --listen 8765 --hold 900 on the machine with the browser; sign in, right-click a Shot in the sandbox project, run zzprobe 156 protocol, which points at sgonset://shot/1
whether permissions_groups hides an item in the web interface the same run, signed in as an Artist: which of zzprobe 156 for admin, ... for artist and ... for everyone a Shot's menu lists
Manager rights turn on can_impersonate_this_user for an active Manager, run 156 --write

corpus/findings/156_action_menu_item.md

158_project_text_size

A custom text field on Project stored 1,000,000 characters of JSON byte for byte, \n, \r\n and tabs kept, with no refusal. Leading and trailing whitespace is stripped.

  • Write JSON.stringify(value) and parse what reads back. A serializer that ends in a newline gets one character fewer back: compare parsed values, not strings or hashes.

  • 1,000,000 characters was a 200 in about a second. Nothing larger was sent, so a limit, if any, is above it.

  • GET /entity/projects/<id> with no fields returns every field, a custom field of 1 MB included, while the listing GET /entity/projects with no fields returns ids only. Name fields on every read of a Project with a large field, or every client on the site pays for it.

corpus/findings/158_project_text_size.md

159_project_field_update_rights

An Admin updates a custom field on a Project, member or not. An Artist in the project reads it and gets 400 code 104 The field is not editable for this user on a PUT; outside it, 404 on the read. [partial]

not measured: Manager and Vendor writes; rights read, not exercised. Blocked on the site: impersonation on for one of each, then 159 --write

  • Settings an Artist must read and an Admin writes fit a Project field: an Artist who is a member reads it with a plain GET. An Artist cannot save them; route that write through an Admin or the script.

  • Per caller editable in GET /schema/Project/fields/<field>?project_id= predicted every answer (probe 094). Read it to grey out a settings screen before the PUT.

  • Project membership gates an Artist's read: outside the project the Project is a 404, so a field on it cannot be read either.

  • The Manager row allows update, but a rights table can still refuse what it lists (probe 094). Treat Manager as unknown until measured.

corpus/findings/159_project_field_update_rights.md

161_link_to_deleted_row

A link to a deleted row is hidden, not removed: it reads null or drops out, and returns on revive, even after a replace. A write naming a deleted row is 400 code 104 Value is not legal.

  • A replace does not drop a hidden link. On Version.playlists, with P1 retired, [P2] answered 200 and read [P2]; reviving P1 brought it back. remove naming P1 is the same 400, so nothing measured removes it. Expect a revive to restore every link to the row. Not measured on an entity field.

  • Before writing a link, drop every target the client holds that may have been deleted elsewhere: one retired id fails the whole update, the live ones with it.

  • Value is not legal. also answers a type the field does not take (field_types/multi_entity). To tell a deleted row from a wrong type, read the target with options[return_only]=retired.

corpus/findings/161_link_to_deleted_row.md

164_vendor_writes

On the probed site a Vendor creates no Bid or Bid Line, by POST or _batch, and updates only sg_status_list, each refusal 400 code 104. Both preflight reads predicted every answer.

  • A Vendor on the probed site cannot enter a bid: no row can be created and no amount written, on a row assigned to their own Group as on any other. _batch is refused like a single POST; it skips validation (probe 137), not permission.

  • The refusal is checked before anything is written and names the type or the field (probe 094). An app reads it in advance from either call above; both listed exactly the one field that took a write.

  • For vendors to enter their own lines, the site gives Vendor create on Bid Line and update on the amount, ideally conditional on the Bid's Group, in the web interface (probe 162). Otherwise the app writes through a script after checking who is asking, and the row's created_by is the script.

corpus/findings/164_vendor_writes.md

166_vendor_award

On the probed site a Group added to Shot.sg_vendor_groups shows the Shot to its people on their next request; removing it hides it. sg_people grants as users does; other projects stay hidden.

  • Award with {"multi_entity_update_mode": "add", "value": [<group>]} and withdraw with remove (recipe 009). A bare list replaces the field, and with it every other vendor's award.

  • The rule is evaluated per request: a bearer minted before the change sees the new answer on its next call, both ways. There is no token to refresh and no delay to wait out.

  • sg_people counts because the rule names it. On another site read the rule first (probe 162): one naming only users ignores sg_people, which is a site field, not a stock one.

  • On the probed site "See entities in assigned Projects only" holds: a Group's Shots in a project the person is not assigned to stay hidden. Here both vendors' HumanUser.projects held the sandbox alone; assign the vendor to the project before an award there can reach them.

  • Vendor reads Groups (probe 162), so each vendor sees which other Groups hold a Shot they see.

corpus/findings/166_vendor_award.md

168_group_create_rights

On the probed site a Manager or Admin person creates, renames, re-members and retires any Group; Artist and Vendor get 400 code 104. The person's own group rights on Group predict each answer. [partial]

not measured: an App Session Launcher bearer (probe 052); it needs the person to approve at a browser. sudo_as_login applies the same permission set (probe 094)

  • Check before showing the control: read the person's own permission_rule_set, its code, then actions.create.access on Group. An Admin lists every group, so the listing alone does not name theirs.

  • A refusal is 400 code 104, not 403, with no source or detail. Probe 094's shape holds for Group.

  • The right is per type, not per creator: a Manager renames, re-members and retires a Group someone else made, a vendor's included. An app that lets production create Groups lets it retire any Group.

  • code is neither required nor unique, whatever the schema says. Search by code before creating, and keep the id: two Groups may share a name. A retired Group drops out of HumanUser.groups.

  • A Group made by a person works in Shot.sg_vendor_groups on the vendor's next request (probe 166).

corpus/findings/168_group_create_rights.md

Every entry on this site is the output of a probe in probes/. The corpus is generated by running those probes against a live Flow Production Tracking site, not written from memory.

Not affiliated with or endorsed by Autodesk. Flow Production Tracking is their product; this is an independent record of how its REST API answers.