Repository navigation
Description
This is a design proposal for discussion. Nothing in it is built yet, apart from the throwaway spike code in §6.1.
Revision 2 (2026-09-25): folds in Michiel's decisions on questions 1–3 and 12 (§8) and the results of spikes S1–S3 (§6.1). What changed: views match by exact class only, with Devonian lenses for other shapes (§3.1); install and connect create fresh tables, and syncing an existing table starts from the plugin's view (§3.0, H5); the built-in views stay as they are (H7 withdrawn); H1 narrows to robustness, H2 becomes nice-to-have, and S3 adds a picker-search item (H10); the shared vocabulary moves to a top-level ontology/ folder (§2.0).
Revision 3 (2026-09-25): folds in Michiel's decisions on questions 4–7 (§8). What changed:
- Sync, "Sync this table to …", provider setup, "Changes to send", review and conflict handling are plugin logic, not host vocabulary (§3.0, §4).
- H5's separate host "sync grant" gesture is withdrawn. The host only gates background runs, grants beyond "Allow editing", and proxy permissions (§4.6, §7).
- H4 is decided: "Allow editing" is extended to cover the plugin's provider extras on rows.
- Sync bookkeeping (provider id, ETag, baseline) lives on the row as provider extras (§4.1).
- Update events come from a JS class hook,
afterCommit, which atomic-server builds; it replaces a separate "changed" query trigger. Until it and a per-table change list with tombstones exist, plugins compare on open and review in their view (§4.2, H6). - Plugins review every send while testing; the expected future default is sending automatically, with only real conflicts asking (§4.3).
- Conflicts, Q6 and Q7 are each plugin's call (§4.4, §4.6).
Evidence levels used below:
- (pin): read at the atomic-server commit that
.atomic-server-refpins onmain,bc39dac4b. - (spike): observed by running the Playwright spikes S1–S3 against atomic-server
2567fc30b, the pin PR Pin atomic-server to 2567fc30b (#1818 catalog-install fix: WS continuation frames, agent-after-folder) #173 proposes (the publishedatomic-server-e2eimage and its embedded frontend). The spike code is throwaway and not pushed. Code references in spike findings are to that commit. - (main): read on
ontola/atomic-pluginsmainat096cd86. - (unverified): nobody has run or observed it yet.
Nothing marked (pin) was re-checked at 2567fc30b, and nothing marked (spike) was re-run at bc39dac4b.
A shared class or a plugin capability counts as declared until it has current live evidence, as defined by the certification command in integrations/README.md. Every class and property below is declared only.
0. Summary
Decided by Michiel:
- Plugins sync. A plugin connects a provider and writes rows into ordinary Atomic tables. The data browser can always show those rows with its own views.
- Plugins also provide views. A view works on any table whose row class is the one it applies to. That includes tables the plugin never synced and rows made by hand.
- The shared classes and properties are published on atomic-plugins' GitHub Pages, at
https://ontola.github.io/atomic-plugins/ontology/.... They use the same flow as Install drive apps from the catalog: versioned modules on GitHub Pages, integrity-pinned; Pets e2e (#94) #111'sapps/<id>/<version>/ui.js: committed files, CI checks and immutable versions. - Those URLs are temporary. A better domain for the Pages site is coming. Until it is in place, any plugin that uses these URLs stays disabled: it can't be installed from the catalog UI and isn't listed as available. Tests and e2e runs can still install such a plugin test-side.
- View matching is strict (Q1). A plugin view is offered only on tables whose class is exactly its shared class. Data of another shape is mapped onto the shared class with a Devonian lens, not by guessing columns. Views read shared-class properties only. Matching by column names and types ("duck typing") may be tried later as an experiment; it is not part of this proposal.
- Fresh tables on install; existing tables sync from the view (Q2, revised by Q4–Q7). Installing a plugin and connecting a provider creates fresh tables. To sync a table you already have, you open the plugin's view on it and press "Sync this table to Google / GitHub / Clockify / …". That button is the plugin's own UI, not a host gesture: what it may write is bounded by the view's "Allow editing" grant (#1788), extended by H4 to the plugin's provider extras.
- Built-in views stay as they are (Q3). The data browser's Calendar, Issues and Timer views are unchanged. Plugin views are optional, enhanced views. The built-in views are more thoroughly vetted code, which is why they may run in the host page without an iframe. How that evolves is decided later, once more plugins with better views are published.
- One shared, top-level
ontology/folder (Q12). The vocabulary lives inontology/at the repo's top level, not underintegrations/, and is published at the Pages path/ontology/:https://ontola.github.io/atomic-plugins/ontology/now,https://<domain>/ontology/once the site has its own domain. The base URL is kept in one place. The shared code (the strict class check, subject constants and lenses) goes there too, or next to it at the top level; §2.0 recommends next to it. - Edits made anywhere reach the provider (Q5). An edit to a synced row, whether made in a plain table, the built-in Calendar, another view or on another device, should reach Google, GitHub or Clockify.
- Sync is plugin logic (Q4–Q7). "Sync this table to …", provider setup, "Changes to send", review and conflict handling belong to the plugin. The host can't enforce anything while a view is open, because a plugin with both a sync part and a view wires them together itself. The host owns only what it really gates: background runs, grants beyond "Allow editing", and proxy permissions. There is no separate host "sync grant" (H5 withdrawn).
- Bookkeeping on the row (Q4). The provider id, ETag and baseline are provider extras on the row, not plugin-owned side storage. "Allow editing" is extended to cover them (H4).
- Update events: an
afterCommithook, plus a change list (Q4). atomic-server builds a JS class hook,afterCommit, that user-installed plugins may use, scoped to tables where the plugin's view is installed; it replaces a separate "changed" query trigger. Writes from a hook follow the view grant. Alongside it, the host builds a per-table change list with tombstones: "hook for speed, change list for correctness". Michiel calls the hook an interesting direction to work out, not a finished spec. For now, plugins compare on open and review in their view. - Review while testing; automatic later (Q4). Plugins review every send by default for now. The expected future default is sending automatically, with only real merge conflicts asking.
- Left to each plugin (Q6, Q7, conflicts). What counts as a real conflict and how it's resolved (including "provider wins" for Clockify), whether hand-added rows upload only through "Publish to …", and whether a row deleted at the provider is marked or deleted.
What this proposal adds:
- Four shared row classes: event, issue, time entry and bank transaction. Each has typed shared properties, and each reuses what the host's built-in views already read:
calendarFields,task/v1and thework-*time-tracking shortnames. - Provider-specific data stays outside the shared class, as optional extras: provider ids, ETags, links, baselines and sync state.
- Each plugin splits into a sync part and a view part:
- The sync part writes shared fields plus extras.
- The view part reads only shared fields, shows extras when they are present, and still works on a hand-made row.
- An edit made in any view on a synced row is found by the sync part by comparing the row with its baseline, which is a provider extra on that row. It becomes a Design: two-way sync as an observation log + Devonian lens (CRDT-like), starting with Clockify #97-style intent and goes through the plugin's own review-before-send flow, which the calendar and issue tracker already have.
The atomic-server side is still under discussion. This plan does not assume any new host work. §6 separates the work that needs no host changes from the work that does, and §7 lists every host requirement. After the spikes, the first release needs no host change to work while Pages is reachable, with edits picked up when the plugin opens. H1 is about robustness; H4 is needed only for "Sync this table"; H6 (afterCommit and the change list) is needed for edits to be noticed while the plugin is closed, and for local deletions to be noticed at all.
Still open: Q8–Q11, Q13, Q14 and Q15 (Q15 reframed now that there is no host sync gesture).
1. What exists today
1.1 Host (pin)
| Mechanism | Where | What it does today | Consequence for option 4 |
|---|---|---|---|
App renders |
browser/lib/src/plugin-log.ts (renders, ResourceArray), set in plugin-app.ts createApp |
"The row classes this app knows how to show." createApp sets it to exactly the app's own row class. |
A class list already exists. Nothing fills it with a shared class at install, but an app can add one itself (spike, S2b). |
| "+ Add view" offering | data-browser/.../AppPage/useDriveApps.ts appsForClass; TablePage/TableViewTabs.tsx |
Offers every app on the drive whose renders contains the table's classtype, matched by exact subject. |
This is exactly the strict matching decided in Q1: a view is offered on a hand-made table only if that table's class is the shared class. |
| Catalog install | browser/lib/src/catalog-app.ts installCatalogApp |
Calls createApp without rowClass, so every install mints a fresh class in the app's own ontology. CatalogApp has no rowClass field. |
A catalog entry can't declare a shared class today. The installed app can retarget its own table and renders on first open (spike, S2), so this isn't blocking; H2 would make it declarative. |
store.getData() |
AppPage/hostStore.ts op data |
Returns { table, rowClass, tables? }: the table the app is a view of, or its own table otherwise. rowClass is read from the table. tables holds the destination siblings (#1768). |
A view learns its table's class at runtime and can check that it is a class it renders. |
| Row grant (#1740, PR #1788) | AppPage/rowGrant.ts; server server/src/plugins/app_row_grant.rs |
After "Allow editing", an app may save/remove only the properties the row class requires or recommends, and create rows of exactly that class. It may never destroy rows, or change parent, isA, rights, the table or its views. The grant is tied to a View of that table. |
A view can edit shared fields on any table. It can't write provider extras that the class doesn't list (H4 extends it to the plugin's extras), and it can't delete rows. Confirmed on a Pages-hosted class (spike, S1). |
| Writes outside the grant | hostStore.ts refuseOutsideApp |
An app may otherwise write only inside its own subtree. | A sync part can write freely into tables it created under itself, and nowhere else. Inside its subtree nothing special-cases isA, classtype or renders (spike, S2). |
destination.tables (#1768), store.importer.run (#1774) |
browser/lib/src/plugin-destination.ts; view op runImporter |
Sandbox Set up creates several tables beneath the plugin and binds the schema into the drive's default ontology with ensureSchema. |
Money already gets per-drive shared terms this way. PropertySpec.subject and ClassSpec.subject can already reuse an external term "without editing or copying it". Binding to an external subject is (unverified). |
calendarFields |
browser/lib/src/calendar-date.ts |
Matches shortnames, not subjects: atomic-calendar-day (date), -all-day (boolean), -end-day (date, exclusive, per #172's correction), -notes, and atomic-calendar-recurrence (JSON, in calendar-recurrence.ts). Each may carry the lt-google-calendar-property- prefix. |
Event properties must use these shortnames, or the built-in Calendar view shows them as single-day items. |
Built-in calendar view |
chunks/TablePage/Calendar/ |
Places rows by the configured date or timestamp property, otherwise the first one on the class, otherwise it creates a "Date" column (only for writers). Multi-day and all-day handling applies only when the date column matches atomic-calendar-day. |
Works on any table. Shows no time of day for timed events. Unchanged by this proposal (decision 7). |
Built-in issues view |
chunks/TablePage/Issues/ |
Reads open/closed from a select column (task/v1 Done is closed by subject, other tags by title such as done or closed) or from a boolean column. Takes the issue number from the first integer column whose shortname matches /number/. |
github-issue-number already matches. |
Built-in timer view |
chunks/TablePage/Timer/useTimerProps.ts |
Uses two TIMESTAMP properties: the configured ones, otherwise shortnames matching ^start and ^(end|stop|finish). |
work-start does not match ^start. The Time tracker template sets the view's columns explicitly instead. |
| Shared vocabularies | browser/lib/src/task-schema.ts plus lib/defaults/tasks.json; browser/lib/src/time-tracking-schema.ts |
task/v1: global atomicdata.dev subjects (status, body, assignee, due-date, tags todo/doing/blocked/done), embedded in every host (store.ts isEmbeddedVocabulary), with no class. timeTrackingSchema(): work-start/work-end (TIMESTAMP ms), work-project/work-person (AtomicURL), work-billable, work-source-id, minted per drive ("until frozen schema package distribution lands"). |
These are precedents to reuse, not to duplicate. |
| Table templates | chunks/TablePage/tableTemplates.ts; createTableFromSpec.ts createRowClass |
The "Issue Tracker" and "Project tasks" templates use task/v1 properties, and "Time tracker" uses timeTrackingSchema. Every template table still gets its own new row class. The New Table dialog can instead "use an existing class". |
Hand-made tables share properties with plugins today, but not classes, so under strict matching a plugin view is not offered on them (§3.1). The picker's search doesn't find a Pages class, but pasting its URL works (spike, S3). |
| Catalog gating | data-browser/.../PluginRuns/CatalogApps.tsx (entry.enabled); browser/lib/src/plugin-manifest-http.ts requiresGate |
An entry with enabled: false is not listed. requires gates only on plugin-routes:*, operator-listener:* and operator-sidecar:*, and ignores any other token. |
See §2.0 for which gate to use. |
Upstream state: the atomic-server PRs #1768, #1774 and #1788 are still open upstream, but their code is present at the pin (destinationTablesFor, runImporter and requestRowAccess all exist at bc39dac4b).
1.2 What each plugin writes today (main)
| Plugin | Version | Row class and table | Shared-ish fields | Provider fields | Write-back |
|---|---|---|---|---|---|
Calendar (integrations/calendar/app/sync.ts) |
0.1.0 on #145. The local branch claude/issue-172-calendar-fields has 0.1.1; that branch isn't on origin, and its catalog entry is in #171/#172. |
The app's own table; the class is renamed "Event". | name; core description; location; start/end (STRING, exactly as Google sent them); all-day; day (DATE). #172 renames these to atomic-calendar-* and adds -end-day and -notes. |
google-event-id, google-etag, google-link, sync-baseline (JSON); on the table, google-calendar-id and google-calendar-meta |
Yes. The review list is built by planEdit, and applyEdit sends PATCH with If-Match (a 412 marks the edit stale). The baseline advances only after Google confirms. |
Issue tracker (app/tracker.ts, app/sync.ts) |
0.1.0 (app/package.json); no catalog entry on main |
The app's own table; the class is renamed "Issue". | name; issue-status (the app's own tags todo/doing/done); core description as body |
github-issue-number (INTEGER); github-source (JSON: url, author, labels, assignees, dates); github-sync-state and github-repository on a sync resource; comments as Messages |
Yes. reviewGate holds creates and updates until approved (proposalKey), and reconcileRecord compares baseline, local and remote. The sandbox plugin path (devonian/github-issues/atomic.ts) already uses task/v1 status and body. |
Timesheets (app/ontology.ts) |
No version on the main catalog entry | The app's own table. Rows are a read-only projection of the M1 observation log. | name (description); start/end (TIMESTAMP ms); billable; project/member (name strings) |
clockify-entry-id, clockify-project-id, clockify-user-id; the log lives in clockify-observation-log, -log-head, -observation and -snapshot |
No. The only transport method is GET. M3 (intents and outbox) is next in #123. |
Money (schema.ts, plugin.ts, app/) |
0.2.0, disabled | Sandbox Set up creates the drive-ontology classes bank-transaction and bank-statement-record and two tables, "Bank transactions" and "Imported statements" (destination.tables). |
bank-account, -currency, -amount (an exact decimal STRING), -value-date/-booking-date (DATE), -description, -reference; the user annotations money-category/money-note |
bank-source-id, bank-fingerprint, bank-statement, bank-transaction-code; statement fields |
Import only, append-only. The view writes only money-category/money-note, through the row grant. |
Notion (app/sync.ts, devonian/notion/lens/) |
0.1.0, disabled | One merged table for all shared databases. Columns are notion-<hex property id>. |
select/status are stored as option-id strings and multi-select as a JSON array of ids. Dates, people, relations, formulas, rollups and files are not synced. | notion-page-id, notion-data-source, notion-url, notion-last-edited; notion-sync-record (JSON) on the table |
The drive app never writes back. The older sandbox pilot (plugin.ts) syncs two-way with preview-then-step and real Tag resources. |
Every catalog entry except pets is enabled: false on main (#175). Existing installs of these five plugins are therefore test, e2e or developer installs only. #172 says the same for calendar.
2. Shared row classes
2.0 Where they live (decided), and how they're published, moved and gated
Layout (decided, Q12). The vocabulary goes in a top-level folder, ontology/, next to integrations/, devonian/, reflector/ and syncables/. It isn't specific to one plugin, so it doesn't break the plugin-folder containment rule. It is published at the Pages path /ontology/, so the base is https://ontola.github.io/atomic-plugins/ontology now and https://<domain>/ontology once the Pages site has its own domain.
Where the code goes (recommended): next to it, in a sibling top-level folder, not inside ontology/. Proposed name ontology-kit/ (the name is open):
ontology/holds only what Pages serves under/ontology/: the term files (properties/,classes/,v<N>). Every file in it is immutable once published, so the CI check is simply "no published file underontology/changes", with no exclude list. Nothing under the vocabulary's URL space can ever be a script or a config file instead of a term.ontology-kit/holds what changes:base.json, the build and the CI check, the subject constants, the strict class check views use (§3), and the Devonian lenses (§3.1). It is not published to Pages; plugins inline what they need at build time.- The alternative, code in
ontology/src/with the Pages build excluding it, works too, but then every rule aboutontology/needs an exception forsrc/.
A build step, ontology-kit/'s, writes the term files with absolute subjects from base.json. The subject scheme, relative to that single base:
| Term | Subject | Changes after publishing? |
|---|---|---|
| Property | <BASE>/properties/<shortname> |
Never. A change of meaning gets a new shortname (…-v2). Unchanged properties keep their subject across class versions, as planning/schema-catalog.md also asks. |
| Class | <BASE>/classes/<name>-v<N> |
Never. Adding a required or recommended property creates -v<N+1>, and a view lists every class version it renders. |
| Ontology (index) | <BASE>/v<N> |
Never. One file lists the classes and properties of release N. |
Subjects are extensionless; no .json suffix is needed (spike, S1, below).
The base URL lives in one place. A single file, ontology-kit/base.json ({ "base": "https://ontola.github.io/atomic-plugins/ontology" }), is read by:
- the ontology build, which writes subjects;
- each plugin's
build.mjs, which injects it as a compile-time constant (the same way the bundles already inline other build inputs; unverified per plugin); - the unit tests and e2e.
Reading it from outside integrations/ works in this repo's CI, which builds in the atomic-plugins checkout with browser symlinked in (.github/workflows/ci.yml). It does not work in a copy of integrations/ alone, such as the local reproduction in AGENTS.md or an integrations/ folder carried into atomic-server. Since bundles inline the base, only the build needs the file; that copy step needs to include ontology-kit/ (unverified per plugin).
A proposed CI check (node ontology-kit/check.mjs, which doesn't exist yet) would do the following:
- Refuse any literal
ontola.github.io/atomic-plugins/ontology(and later the new domain's/ontology) outsideontology-kit/base.jsonand the generated files underontology/. - Refuse edits to any published file under
ontology/, the same immutability rule Install drive apps from the catalog: versioned modules on GitHub Pages, integrity-pinned; Pets e2e (#94) #111 applies toapps/<id>/<version>/. This matters more than it first seems: the server fetches each external term once and never revalidates it (spike, S1), so a term published by mistake and then fixed is never re-read by a server that already stored it. - Check that every property has a datatype and that every class lists only properties that exist.
Resolvability: works while Pages is reachable or the term is cached (spike, S1). For a class to be a table's classtype, three things must be able to read it: the data browser's store, the server (the row grant calls get_class(row_class)), and createApp, which checks that a reused rowClass is an Atomic Class. At 2567fc30b, with a Pages-shaped host that copies Pages' measured headers:
- GitHub Pages' headers (probed live 2026-09-25): a
GETreturnsaccess-control-allow-origin: *,cache-control: max-age=600, anetag,last-modifiedandexpires. Extensionless files are served asapplication/octet-stream. A CORS preflight gets405with no CORS headers, so Pages can't pass a preflight. - Server: fetches an unknown external subject on first use, unsigned, with a 10 s timeout and no content-type check, and stores it for ever (
lib/src/db.rs:4851-4903,lib/src/client/helpers.rs:205-231, 479-527).max-ageand the ETag are ignored.get_classfor the row grant works on it. - Browser: the store's direct request is signed (only
https://atomicdata.dev…is exempt,lib/src/client.ts:262-282), so its preflight fails. The store then falls back to the local-database worker, the WASM build ofatomic_lib::Db, which does an unsigned simple GET, passes Pages' CORS, and caches the term in OPFS. It works, but costs one failed signed request and one console CORS error per term per signed-in session, and depends on the local DB worker being on. - Works: a hand-made table with the Pages class as
classtypeshows its columns; "Allow editing" saves the class'srecommendsand creates rows of the class, and refusesdescriptionandisA; the table still renders with Pages down, and also with the browser disconnected from the server. - Fails:
- a browser that has never seen the class (fresh profile) while Pages is down: the table shows only
#, because the browser never asks its own server for an external subject; - a term the server has never fetched, first used while Pages is down: refused server-side ("is not a property");
- a build with the local DB off has no fallback, so signed-in users get no class at all (inferred from the code, not run).
- a browser that has never seen the class (fresh profile) while Pages is down: the table shows only
- Not run:
createApp({ rowClass })with the Pages class (it uses the samestore.getResourceread, so it's expected to pass while reachable or cached);ensureSchemabinding to an external subject; a realhttps://ontola.github.ioURL end to end (only its headers were probed); a server restart (stored terms live in its redb, so they're expected to survive).
H1 in §7 is now the list of robustness fixes for the failure cases.
Moving to the new domain: recommend rewriting stored data, with no alias layer.
| Option | Cost | Verdict |
|---|---|---|
| HTTP redirects from github.io | GitHub Pages can't send HTTP redirects, only HTML meta-refresh, which a JSON-AD client won't follow. | Not possible |
owl:sameAs-like mapping property on the new terms |
Every exact-subject comparison in the host would have to learn aliases: appsForClass, the server's row-grant class check, classtype checks, and ensureSchema binding. That's host work across the board, permanently. |
Not recommended |
| Rewrite stored data on migration | A one-shot pass per drive: table classtype, row isA, and property keys on rows. |
Recommended |
The gating below means no production drive ever stores a github.io subject, so the rewrite touches only test, e2e and developer drives. Throwing those away is also acceptable. The old github.io files stay published, since they're immutable, but nothing new points at them. (Unverified: if the new domain is set as this repository's Pages custom domain, GitHub redirects the github.io URLs to it, so the old subjects would answer with the new-base files rather than the old ones. The gate keeps that from mattering for production drives; for test drives it is one more reason to re-create rather than keep them.) The switch is then one commit that changes ontology-kit/base.json, republishes the ontology under the new base, bumps every plugin that uses it, and turns the gate off. An app can do the rewrite on its own tables without host work (spike, S2); tables the person made need the view's row grant, which allows neither isA nor removing properties the new class doesn't list, so for those the rewrite is (unverified) and may need the person to re-create the table.
Gating: recommend enabled: false plus a repo-side CI rule. Don't use requires.
- At the pin,
requiresGatecounts onlyplugin-routes:,operator-listener:andoperator-sidecar:tokens. A made-up token such asstable-ontology-domainis silently ignored, so the entry would not be gated.integrations/tooling/catalog-requires.mjs checkwould also reject it, because an entry'srequiresmust equal the list derived from its manifest. enabled: falseis already how catalog: only Pets enabled in production until launch #175 hides entries, andCatalogApps.tsxdoesn't list them.- Proposed rule, added to the check above: while
ontology-kit/base.json's host isontola.github.io, any catalog entry whose package bundle contains the base must haveenabled: false. The card'slimitationcopy says "Waits for the stable ontology domain." Test-side installs viainstallCatalogAppin e2e keep working. - If the host later wants to know about vocabulary domains itself, that is optional item H9.
2.1 Shared fields and the conventions every class follows
- Every row keeps
https://atomicdata.dev/properties/nameas its title. - Amounts, instants given by providers, and similar values are exact strings unless the host's own views need a native datatype. Where a native datatype is used, the table says why.
- Where a host view already reads a term, the class reuses it:
- task/v1 by subject, because it's embedded in every host;
calendarFieldsandwork-*by shortname, because the host matches those by shortname or because they're minted per drive.
- New Pages properties get the same shortnames, so the unchanged built-in views keep matching.
- Provider extras are never listed in the shared class. Each sync part defines them in its own ontology. They are stored on the row (decided, Q4). This has a cost at the pin: through a row grant, a view can't write them. H4 (decided) extends "Allow editing" to cover them (§4.6).
2.2 Event (event-v1)
| Property (shortname) | Subject | Datatype | Req. | Meaning | Today (calendar 0.1.0 → 0.1.1 on the #172 branch) |
|---|---|---|---|---|---|
name |
core | STRING | yes | Title | name |
atomic-calendar-day |
Pages | DATE | yes | First civil day (YYYY-MM-DD), in the event's own zone as the provider gives it |
day → atomic-calendar-day |
atomic-calendar-end-day |
Pages | DATE | no | Exclusive end day for multi-day and all-day events. Absent means a single day. | added in 0.1.1 |
atomic-calendar-all-day |
Pages | BOOLEAN | no | All-day. Absent means false. | all-day → atomic-calendar-all-day |
atomic-calendar-start |
Pages | STRING | no | Exact start instant, RFC 3339 with its offset, for timed events | start (a date-time string); new shortname |
atomic-calendar-end |
Pages | STRING | no | Exact exclusive end instant | end; new shortname |
atomic-calendar-location |
Pages | STRING | no | Location | location; new shortname |
atomic-calendar-notes |
Pages | STRING | no | Description as plain text | core description → atomic-calendar-notes in 0.1.1 |
atomic-calendar-recurrence |
Pages | JSON | no | The host's recurrence payload (calendar-recurrence.ts) |
not written; the app skips recurring events |
- Why start and end are strings, not TIMESTAMP: a TIMESTAMP is milliseconds since the epoch and loses the provider's offset. The built-in Calendar view places rows by
atomic-calendar-dayanyway. The cost: the built-in month view shows timed events without a time. That is a declared limitation, and it stays, since the built-in views are unchanged (decision 7). The plugin's own calendar view shows the time. - Relation to built-in views: a synced event table renders correctly in the built-in Calendar view, including all-day and multi-day events, once calendar: use the host's calendar field names so all-day and multi-day events render in the Calendar view #172's shortnames are in. The Timer view doesn't apply.
- Provider extras (calendar sync part):
google-event-id,google-etag,google-link,sync-baseline. On the table:google-calendar-idandgoogle-calendar-meta.
2.3 Issue (issue-v1)
| Property | Subject | Datatype | Req. | Meaning | Today (issue tracker 0.1.0) |
|---|---|---|---|---|---|
name |
core | STRING | yes | Title | name |
status |
https://atomicdata.dev/task/v1/status |
RESOURCEARRAY of task/v1 tags todo, doing, blocked, done |
no | Open or closed state. done is closed. |
the app's own issue-status with its own tags (the sandbox path already uses task/v1) |
body |
…/task/v1/body |
MARKDOWN | no | Description | core description |
assignee |
…/task/v1/assignee |
STRING | no | Assignee, as a display name or login | only inside the github-source JSON |
due-date |
…/task/v1/due-date |
DATE | no | Due date | not written |
- Relation to built-in views:
- The built-in Issues and Kanban views already treat a task/v1
statusselect as the issue state, anddoneas closed by subject. - The Issue Tracker and Project tasks templates use the same four task/v1 subjects. A template-made table therefore has the fields, but not the class, so the plugin's view is not offered on it. A lens (§3.1) or H3 closes that gap.
- The built-in Issues and Kanban views already treat a task/v1
- Provider extras (GitHub sync part):
github-issue-number(INTEGER), which the built-in Issues view already picks up as#n;github-source(JSON: url, author, labels, assignees, timestamps);- on the sync resource:
github-repositoryandgithub-sync-state; - comments as Messages.
- Labels are a common candidate for a later
issue-v2(Jira and Todoist have them). They're left out of v1. - Blocked: the app has no tag for it, and
AtomicPort.rowthrows "Blocked is unmapped". See Q8.
2.4 Time entry (time-entry-v1)
| Property | Subject | Datatype | Req. | Meaning | Today (timesheets) |
|---|---|---|---|---|---|
name |
core | STRING | no | Description | name |
work-start |
Pages | TIMESTAMP (ms) | yes | Start instant | start (TIMESTAMP) |
work-end |
Pages | TIMESTAMP (ms) | no | End instant. Absent means a running timer. | end (TIMESTAMP) |
work-project |
Pages | ATOMIC_URL → work-project resource |
no | Project | project (a name string) plus clockify-project-id |
work-person |
Pages | ATOMIC_URL → work-person resource |
no | Who worked | member (a name string) plus clockify-user-id |
work-billable |
Pages | BOOLEAN | no | Billable flag. It says nothing about invoicing. | billable |
The companion classes work-project-v1 and work-person-v1 each have only a name.
- Why TIMESTAMP here, unlike events: TIMESTAMP is what the built-in Timer view and the Time tracker template use. Clockify truncates to whole seconds (live check on Timesheets (Clockify): two-way interval sync through an observation log and conflict timeline #123), so an integer millisecond value is exact. The exact ISO strings stay in the observation log.
- Relation to built-in views:
- The Time tracker template writes per-drive
work-*properties with the same shortnames, but on its own class. Under strict matching the timesheets view is not offered on such a table; a lens maps it ontotime-entry-v1(§3.1), and it is the first lens proposed. - The built-in Timer view doesn't guess
work-start(its regex is^start), and that stays so (decision 7). The sync part sets the view's start and end columns explicitly on its own table, as the template does, without host work. On a table the person synced with "Sync this table", the person configures that view themselves.
- The Time tracker template writes per-drive
- Provider extras:
work-source-id, which the host's owntimeTrackingSchemaalready defines as a "provider-qualified record identity". Value:clockify:<workspace>:<entry id>, replacingclockify-entry-id.clockify-project-idon the project resource, andclockify-user-idon the person resource.- The observation-log resources on the App.
2.5 Bank transaction (bank-transaction-v1)
| Property | Datatype | Req. | Meaning | Today (money 0.2.0) |
|---|---|---|---|---|
name |
STRING | no | Display line: the description, otherwise the reference | same |
bank-account |
STRING | yes | Account id: an IBAN when the bank gives one, otherwise the bank's own id | same |
bank-currency |
STRING | yes | ISO 4217 code | same |
bank-amount |
STRING | yes | An exact signed decimal. Negative means money out. At most 5 fraction digits. | same |
bank-value-date |
DATE | yes | Value date | same |
bank-booking-date |
DATE | no | Booking date | same |
bank-description |
STRING | no | Original narrative, verbatim | same |
bank-reference |
STRING | no | Bank or customer reference | same |
money-category |
STRING | no | User annotation. No importer writes it. | same |
money-note |
STRING | no | User annotation | same |
- All shortnames are unchanged from money 0.2.0, so the migration only changes subjects (§5).
- Counterparty (name and account) is left out of v1: no importer extracts it yet (README, "out of scope"). The Moneybird work in money: read-only Moneybird contacts drive app on a synthetic fixture (#102) #118 may add it, in
-v2. - Built-in views: the host has no bank view. The Expenses template uses different, locally minted
Amount/Datecolumns on its own class, so it isn't a bank-transaction table. A lens could map it later; that isn't proposed for v1. - Provider extras (importer):
bank-source-id,bank-fingerprint,bank-statement,bank-transaction-code. - The
bank-statement-recordclass and its table stay money-specific in v1. They are import bookkeeping, not a shared domain.
3. Per plugin: sync part and view part
How a view finds its fields (decided, Q1). A plugin view is offered only on a table whose classtype is exactly one of the shared class versions it lists in renders (this is appsForClass' existing exact-subject match). Inside the view, every field is read by subject, from the shared class's properties only. There is no fallback to shortname matching and no column guessing, so a view never has to tell the person which column it picked, and it never writes to a column it guessed. A row that lacks a required shared field is shown as incomplete, not skipped silently.
3.0 Where synced rows go (decided, Q2; revised by Q4–Q7)
- Install and connect → fresh tables. Connecting a provider in the plugin creates a new table of the shared class under the plugin (in its own subtree, so no grant is needed), and the sync part fills it. This is the only path in the first release that needs no host change.
- An existing table → "Sync this table to ". The person opens the plugin's view on a table of the shared class they already have (via "+ Add view", which offers it by exact class), and the view offers "Sync this table to Google Calendar / GitHub / Clockify / …". This button, the provider-source choice (a calendar, a repository, a Clockify workspace) and everything after it are the plugin's own UI and logic, not a host gesture (decided, Q4–Q7). The host is involved only through grants it already owns:
- Writing to the table is bounded by the view's "Allow editing" grant (#1788), given on that table in the usual way. H4 (decided) extends that grant to the plugin's provider extras on rows, which is what lets the sync part store provider ids, ETags and baselines on rows it didn't create. Never
destroy; neverparent,isA, rights, the table or its views. - Reaching the provider goes through the integration-proxy: a provider connection delegated to the plugin's app agent. That is separate from any table grant.
- Running while the view is closed is a background run, which the host gates (H11).
- Writing to the table is bounded by the view's "Allow editing" grant (#1788), given on that table in the usual way. H4 (decided) extends that grant to the plugin's provider extras on rows, which is what lets the sync part store provider ids, ETags and baselines on rows it didn't create. Never
- Where the source binding lives (unverified design): "Allow editing" never allows writing the table resource, and bookkeeping lives on the row (Q4). Proposed: the provider source id is a provider extra on each synced row, next to the provider's record id (for example
google-calendar-idbesidegoogle-event-id); table-level provider metadata, such asgoogle-calendar-meta, stays in the plugin's own subtree, keyed by table subject. - Before H4 exists, the sync part can't write its extras into a table it didn't create, so "Sync this table" can't work. The view shows the button disabled, with the reason ("Needs host support for syncing into an existing table"), or leaves it out. Which of the two is a copy decision, not a design one.
- Rows already in the table when "Sync this table" is pressed: whether they are uploaded, and whether the first pass matches them against provider records, is each plugin's call (Q6, decided as plugin-owned). This proposal's per-plugin default is in §3.2: they stay local-only until an explicit "Publish to …", and provider records are added as new rows with no matching.
- "Fill an existing table" no longer starts from Set up. Set up and connect only ever create fresh tables.
3.1 Other shapes: Devonian lenses (decided in principle, Q1; design open, Q14)
A table of another class, such as a Time tracker template table (its own class, per-drive work-* terms) or an Issue Tracker template table (its own class, task/v1 terms), is not offered the plugin view. It is mapped onto the shared class with a Devonian lens: a pair of functions between the source class and the shared class plus an identity map, as in devonian's AtomicLens and AtomicIdentityMap (devonian/docs/atomic-data.md).
What is proposed:
- A lens is written per source shape, in code, not inferred from column names. Lenses live in
ontology-kit/(§2.0). - The first lens is Time tracker template →
time-entry-v1, since the shortnames already match and the mapping is one-to-one. Issue Tracker template →issue-v1is the second. - The plugin view then runs on the lensed side, which is of the shared class, so the strict match holds.
What is not yet decided or verified (Q14):
- Whether the lensed side is a materialized table of the shared class (under the lens's owner, kept in sync both ways) or computed on read.
- Where the lens runs, and with which grant it writes back to the source table. The source table's row grant allows only that source class's
requires/recommends, which covers the mapped fields when they are on the source class (unverified). devonian'sAtomicLensworks against its in-memoryAtomicStore; its README lists "live Atomic Server transport" as follow-up work, so running a lens against a live drive needs that first.
Duck typing (matching by column names and types) is noted as a possible later experiment, not part of this proposal.
3.2 Per plugin
| Plugin | Sync part | View part | On a table of the shared class the plugin didn't create |
|---|---|---|---|
| Calendar | Connect Google through the proxy, choose a calendar, and create a fresh event-v1 table filled with events plus Google extras. Keep the existing planEdit/applyEdit/If-Match flow. "Sync this table to Google Calendar" targets an existing event-v1 table (needs H4). |
Week, agenda and drawer read shared fields only. Pending and conflict badges, "Open in Google" and the calendar colour appear only when the extras are present. | The view works on it read-and-edit (with "Allow editing"). Today's bug: a row with only a day and no start/end strings "silently doesn't appear" in week and agenda (bounds() in app/events.ts). Fix: place it by atomic-calendar-day/-end-day as an all-day event. Rows without google-event-id are "local only" and aren't sent without an explicit "Publish to Google Calendar" (this plugin's choice under Q6). The view offers "Sync this table to Google Calendar". |
| Issue tracker | Connect GitHub, choose a repository, and create a fresh issue-v1 table with task/v1 status and body, plus GitHub extras. Keep reviewGate and reconcileRecord. "Sync this table to GitHub" targets an existing issue-v1 table (needs H4). |
The list, detail and board read shared fields. #n, labels, author, comments and "Open on GitHub" appear when the extras are there. |
Today: a row with no number becomes a held "Create issue" on the next pass (app/sync.ts runPass). Change: it becomes local only, and a create is offered only through an explicit "Publish to GitHub" action. That is this plugin's choice under Q6, which is left to each plugin. A status outside the four task/v1 tags, or several tags, is shown as it is instead of failing the whole pass (today AtomicPort.row throws). The view offers "Sync this table to GitHub". |
| Timesheets | Keep the M1 observation log and the M2 lens. Connecting creates a fresh time-entry-v1 table, projected from the log, with work-* fields and project and person resources. The #123 M3 intents and outbox add write-back later. "Sync this table to Clockify" targets an existing time-entry-v1 table (needs H4); the per-row bookkeeping (work-source-id and the base observation ids) goes on the rows, and the observation log itself stays under the app, keyed by that table (unverified design; whether the log counts as bookkeeping under the Q4 decision is not settled). |
Change from #146: the views read rows for the shared layer (week, entries, projects) and overlay the log's segments (unknown, conflict, pending) when a log exists for that table. Range edits such as "did not work over [a, b)" stay intents in the log (§4.5). |
On a table with no log, only shared rows are shown, with no unknown or conflict states. Range edits become plain row edits: trimming and creating rows. The view can't delete, because the grant never allows destroy. A Time tracker template table reaches the view through a lens (§3.1). |
| Money | The sandbox importer is unchanged apart from binding to the Pages subjects via ClassSpec.subject/PropertySpec.subject (an existing ensureSchema feature; binding to an external subject is not tested, S4). Set up creates fresh tables, as today. Importing into an existing bank-transaction-v1 table is not proposed for v1. |
The ledger, detail, check and imports screens already resolve fields through the row class (resolveFields) and keep only rows with account, currency, amount and value date. Under strict matching, resolveFields reads by subject only. The statements and closing balance appear when getData().tables.statements exists. |
Already mostly works: a hand-made row loads, with booking date = value date, no format, and statement ''. A non-decimal bank-amount probably breaks amounts.ts (not checked). Add: show it as "Not a valid amount" instead. |
| Notion | Mostly sync: one fresh table per shared Notion database, under the app, with one class per database in the app's ontology (no shared class). select, status and multi-select become SelectProperty values with real Tags named after their options, as the sandbox pilot already did. date becomes DATE, or TIMESTAMP when Notion gives a time, plus an optional <column> end for ranges. people become STRING names. relation becomes a link to the row when its database is synced too, otherwise the Notion URL as a string. formula, rollup and files are skipped and listed in the sync record. Extras: notion-page-id, notion-url, notion-last-edited, and notion-sync-record on each table. Extra tables under the app work without host changes (spike, S2c). |
Most of today's custom view exists because the rows hold option ids. With real tags, the built-in Table, Kanban and Calendar views cover browsing. Keep: a small "Notion sync" view with the sync status, warnings, reconnect and rate-limit banners, and "Open in Notion". A later option is a lens from a Notion database onto a shared class (for example task/v1 status), which isn't in this proposal. | Not applicable: with no shared class, the Notion view isn't offered on other tables, and "Sync this table to Notion" isn't proposed. A hand-made row in a synced Notion table is local only. Write-back stays off in the drive app, as today. The sandbox pilot keeps the only two-way path until #8's bridge. |
4. Edits made anywhere on a synced row
Goal (decided, Q5): an edit to a synced row reaches the provider, wherever it was made: a plain table, the built-in Calendar, another plugin's view, the AI tools, or another device. A view edits the row and doesn't care where the row came from.
Who owns what (decided, Q4–Q7). Finding edits, the "Changes to send" list, review, sending, and conflict handling are plugin logic, not host vocabulary. The host can't enforce any of it while a view is open, because a plugin with both a sync part and a view wires them together itself. The host gates only:
- "Allow editing" and any grant beyond it (H4 extends "Allow editing"; §4.6);
- background runs (H11);
- and, outside atomic-server, the integration-proxy's permissions to reach a provider (§4.6).
The host also supplies update events (§4.2, H6), but doesn't decide what a plugin does with them.
4.1 The model
- Bookkeeping lives on the row (decided, Q4). Each synced row carries provider extras: the provider's record id, the provider's version (an ETag for Google,
updated_atfor GitHub,last_edited_timefor Notion, the base observation ids for Clockify), and a baseline, the shared-field values the sync part last agreed with the provider. None of it goes into plugin-owned side storage.- Calendar (
sync-baseline,google-etag,google-event-id) already works this way. - The issue tracker keeps its baseline in
github-sync-stateon a sync resource today; it moves onto the row (§6.2 item 6). - Timesheets: the per-row ids go on the row; where the observation log stays is noted in §3.2.
- Calendar (
- Finding edits = diffing the row against its baseline.
- Each shared field whose row value ≠ baseline value is a local change.
- This works whether the edit came from:
- the plugin's own view;
- another plugin's view (through its row grant);
- a built-in Table, Calendar, Issues or Timer view (unchanged, decision 7);
- the AI tools;
- another device.
- Calendar already computes "pending" this way (row ≠ baseline).
- Local change → intent, in Design: two-way sync as an observation log + Devonian lens (CRDT-like), starting with Clockify #97's sense. The intent records:
- the row and the fields;
from(the baseline) andto(the row);- the base (the provider version it was made against).
- For Clockify it is stored in the log's intent set. For the other plugins it can be recomputed from row and baseline, so storing it is optional.
- What a diff can't see: local deletions. A synced row deleted locally takes its baseline with it, so there is nothing left to compare. Comparing provider records against rows doesn't help either: a provider record with no row could be "deleted here" or "new there". Until the change list with tombstones (H6b) exists, a local deletion of a synced row is not noticed, and the provider record stays. This is a declared limitation of the first release.
4.2 When the sync part notices (decided, Q4)
For now, with no host work: only while the plugin's frame is open. The sync part compares every synced row with its baseline:
- on open;
- on
subscribeevents for the table (an existing view op); - on the existing manual "Refresh".
Edits made while the plugin is closed are found the next time it opens, and reviewed in its view (§4.3).
Target, with host work (H6): "hook for speed, change list for correctness".
- (a)
afterCommit, a JS class hook that atomic-server builds. A user-installed plugin may use it, scoped to the tables where the plugin's view is installed. It is called after a commit to such a table, so the sync part can react soon after an edit, including edits from other views and devices. It replaces a separate "changed" query trigger; this proposal no longer asks for one. Michiel describes the hook as an interesting direction to work out, not a finished spec: its signature, where it runs, and what "durable" guarantees (proposed meaning: a commit made while nothing is listening is still delivered later) are not designed here. - (b) A per-table change list with tombstones: "what changed on this table since commit X", including deleted rows. The sync part reads it on open or on a run, so correctness never depends on having seen every hook call, and it closes §4.1's local-deletion gap.
Writes from a hook follow the existing view grant (decided, #1788):
- the hook of a view without "Allow editing" on that table only reads; any writes it proposes wait for approval in the view;
- approving one offers "Allow all edits by this view on this table", which is the existing "Allow editing" grant, not a new one;
- with "Allow editing", the hook writes within that grant: shared fields and, with H4, the plugin's provider extras on rows.
A hook that sends to the provider also needs the integration-proxy's permissions (§4.6). Whether an afterCommit call made while no view is open counts as a background run under H11 is (unverified); it is part of working out the hook.
4.3 Review before send
Every intent lands in one "Changes to send" list in the plugin's view. It unifies:
- the issue tracker's
heldanddescribeHeld; - the calendar's
summary.review: PendingEdit[]; - the Notion pilot's preview-then-step.
The list, and the choice of default, belong to the plugin (decided, Q4–Q7):
- Default while testing (decided): every send is reviewed. Nothing is sent without approval. The approval is tied to the content (
proposalKey), so it lapses if the row changes again. - Expected future default (decided direction): sends go out automatically ("just works"), and only real merge conflicts ask the person (§4.4). Recommendation: a plugin switches a provider to automatic only once its write-back for that provider has current live evidence under
integrations/README.md's certification command, not while it is declared only. - Automatic sending while the view is closed additionally needs a background run (H11) and a registered runtime at the integration-proxy (§4.6). With the view open, it needs neither.
4.4 Send, settle, conflict
What counts as a real conflict, and how it's resolved, is each plugin's call (decided, Q4–Q7). The table below is this proposal's per-plugin plan, not a host rule.
| Provider | Conditional write | Settled when | Conflict |
|---|---|---|---|
| Google Calendar | PATCH with If-Match: <etag>. A 412 → stale. |
The write response carries the new ETag. That's how it works today; stricter "read confirms" settlement per #97 is optional here. | The row changed locally and the ETag changed at Google → offer keep mine, keep theirs, or keep as local (resolveConflict, keepAsLocal) |
| GitHub | No ETag is stored. Re-read, then reconcileRecord(baseline, local, remote) before PATCH. |
The next read shows the target values. | Both sides changed since the baseline → describeConflict/resolveConflict |
| Clockify | No version check: PUT replaces the whole entry. Hydrate by GET first, and use the advisory lease (#97 Q5). |
Only a later read observation shows the target (#97, #123). | Per #123 §2.2. "Provider wins" is an acceptable resolution here (Michiel), so the plugin may settle a conflict without asking. |
| Notion | Compare last_edited_time in the preview, and recheck at the step (pilot plugin.ts) |
The next read shows it | "changed after preview" |
A conflict is visible only in the plugin's own view, as extras. Other views, including the unchanged built-in ones, show the row's current, local value, which is a declared limitation. This proposal adds no conflict badge to built-in views.
4.5 Edits that aren't field edits
Timesheets range edits ("worked on P over [a, b)", "did not work") produce several provider calls (#123 §3). They stay view-level intents in the log, created only by the timesheets view.
A built-in Timer or Table edit to work-start/work-end on a synced row is an ordinary field change under §4.1. The planner turns it into a PUT of that one entry, subject to #123's rules: minute snapping, and nothing locked or running.
4.6 What the grants allow
There is no separate host "sync grant" (H5 withdrawn, Q4–Q7): "Sync this table" is plugin UI. The host gates three things, and a plugin's sync logic works inside them:
| Gate | Covers | Given by | Status |
|---|---|---|---|
| "Allow editing" on a table, per view (#1788) | save/remove of the class's required and recommended properties, and create of rows of the class. With H4: also the plugin's own provider extras on rows. Never destroy, parent, isA, rights, the table or its views. Writes from afterCommit follow it (§4.2). |
A person, in the view, on that table; also offered as "Allow all edits by this view on this table" when approving a hook's proposed write | At the pin: shared fields only (spike, S1). H4 is decided, not built. |
| Background runs | A sync part, or a hook, doing work while no view of the plugin is open | The host (H11) | Not designed here |
| Integration-proxy permissions | Reaching the provider at all: a provider connection delegated to the plugin's app agent, plus a registered runtime for unattended runs | The person, when connecting the provider in the plugin, and when registering a runtime | Lives in the integration-proxy, not atomic-server, and is separate from table grants. Its current state was not checked for this proposal (unverified). |
This works with no host changes:
- the view edits shared fields on any table of its class;
- the sync part edits the fresh tables it created (they're in its own subtree), including extras;
- the app retargets its own table's
classtype, its rows'isA, and its ownrenders(spike, S2); - finding edits on open and reviewing them in the view (§4.2, §4.3).
This needs H4: a sync part writing its extras (provider ids, ETags, baselines) into a table it didn't create, which is all of "Sync this table".
This needs H6 or H11: noticing edits while the plugin is closed (H6a, H11), noticing local deletions (H6b), and sending while the plugin is closed (H11, plus a registered runtime at the proxy).
Rows deleted at the provider (Q7): each plugin's call whether to mark or delete. No grant in this proposal allows destroy on a table the plugin didn't create, so on such a table "delete" can only mean asking the person to delete the row. Inside its own subtree, whether a plugin may destroy rows was not checked (unverified). This proposal's per-plugin default: set a …-removed-at extra and let the person delete the row.
4.7 Relation to #97's decision 2
#97 decided that edits made directly in the timesheets table are ignored and overwritten, and that only the timeline view creates intents.
Option 4 reverses that for shared fields (decided, Q5): a table edit becomes an intent, reviewed while testing (§4.3), never silently lost. Until Clockify write-back ships (#123 M3), the sync part should show such edits as "local changes, not sent" instead of overwriting them.
5. Migration
Scope: existing installs are test, e2e and developer installs only (§1.2). They all sync into the plugin's own tables, so every pass below touches only the app's own subtree.
Recommendation: re-sync into fresh tables, plus a small in-app migration only where unsent local work could be lost. A plugin refuses to migrate while it has unsent edits, and asks the person to send or discard them first.
| Plugin | Renamed or moved | Old per-app ontology | 0.1.x tables |
|---|---|---|---|
| Calendar | day→atomic-calendar-day, all-day→-all-day, start/end/location→atomic-calendar-start/-end/-location, core description→-notes. sync-baseline is keyed by field, not column, so it's unchanged (#172). |
Left in place, never deleted. Old properties are removed from the old class's recommends. |
In place: the table's classtype → event-v1. Each row gets isA = [event-v1] and its values copied to the new properties, and the old values are removed. It's all in the app's subtree, and a frame may rewrite classtype and isA there (spike, S2a). Rows the pass skips keep the old class and stay in the table, so the pass must cover every row. |
| Issue tracker | issue-status plus its own tags → task/v1 status and tags, mapped by tag shortname. core description → task/v1 body. |
Left in place | The same in-place pass, gated on an empty held and journal |
| Timesheets | start/end/billable → work-*. The project/member strings → work-project/work-person resources. clockify-entry-id → work-source-id. |
Left in place | Re-project from the log (the rows are a projection). The log is unchanged. |
| Money | Shortnames unchanged. The subjects move from the drive-minted bank-* terms to the Pages ones. |
The drive-ontology terms stay | Re-run Set up, then re-import. The importer is append-only and matches by bank-source-id/legacy. Whether an import can bind to the new subjects while old rows keep the old ones is unverified. Recommendation: fresh tables. |
| Notion | The merged table becomes one table per database. Option ids become Tags. | Left in place | The old merged table is kept as plain data, with a note in its description. The new tables are filled by a fresh sync. |
Each app also adds its shared class versions to its own App resource's renders on first open, which S2b showed it can do, so that it is offered on other tables of the class (until H2 makes this declarative).
The later domain move (§2.0) is a second pass of the same kind. It rewrites classtype, isA and property keys from github.io subjects to the new ones. Only test data is affected, because of the gate.
6. Order of work
6.1 Spikes
S1–S3: done at atomic-server 2567fc30b, with a Pages-shaped host that copies Pages' measured headers. The code is throwaway and stays local (not pushed); all four Playwright tests pass.
-
S1, a Pages-hosted class: partially. Works while Pages is reachable or the term is cached; fails for a cold browser during a Pages outage and for a term the server first uses during an outage. Details in §2.0; the fixes are H1.
-
S2, an app retargets itself: yes, all of it, with no host change. Through the frame store API, an app can:
- (a) set its own table's
classtypeto the Pages class, and rewrite its rows'isAand write Pages properties on them; - (b) add the Pages class to its own App resource's
renders, after which "+ Add view" offers it on a hand-made table of that class, and "Allow editing" there works; - (c) create extra tables under itself with the Pages class.
Only location and rights are checked (
hostStore.ts:472-507refuseOutsideApp;server/src/handlers/app_write.rs:59-147;server/src/plugins/store_host.rs). Caveats: the old per-app class stays in the app's ontology, and rows the app doesn't rewrite keep the old class. - (a) set its own table's
-
S3, New Table's "existing class" picker: partially. Search doesn't find the Pages class, because it is scoped to the drive and
atomicdata.dev(SearchBoxWindow.tsx:384-398). Typing or pasting the class URL and pressing Enter selects it, and the new table works with the right columns. That is a workable fallback, but not discoverable (H10).
Still to spike (no host changes):
- S4.
createApp({ rowClass: <Pages class> })(inferred to work from S1) and money'sensureSchemabinding to external subjects. - S5. One Devonian lens, Time tracker template →
time-entry-v1, against a live drive, to answer Q14's materialize-or-compute and write-back questions. Needsdevonian's live Atomic Server transport or a stand-in.
6.2 Work items that need no host changes
- Ontology source and build: top-level
ontology/(published term files only) andontology-kit/(base.json, build, check, shared code), per §2.0. The four classes in §2 pluswork-project-v1/work-person-v1, a build to extensionless JSON-AD files, the CI check in §2.0 (including immutability, which matters more now that servers never revalidate), and Pages publishing at/ontology/, next toapps/. Addontology/**andontology-kit/**to the CI path filters that decide which lanes run, and includeontology-kit/whereverintegrations/alone is copied for a build (§2.0). - Catalog gate: the CI rule "an entry uses the base →
enabled: falsewhile the base is github.io", plus thelimitationcopy. - Class retargeting on first open (verified possible, S2): each app sets its own table's
classtypeto the shared class, rewrites its rows'isA, and adds its shared class versions to itsrenders. This replaces H2 as the way catalog installs get the shared class. - Strict shared-field reading: each view checks that its table's class is one it renders, and reads fields by subject only (no resolver fallback). The code lives in
ontology-kit/(Q12, §2.0). - Calendar: land calendar: use the host's calendar field names so all-day and multi-day events render in the Calendar view #172 (0.1.1), then the
event-v1fields, the fix for rows with only a day, and the view reading shared fields only. - Issue tracker: task/v1
status/body, the Blocked mapping (Q8), local-only rows instead of automatic creates, a tolerantAtomicPort.row, and the per-row baseline moved out ofgithub-sync-stateonto the row as an extra (Q4). - Timesheets: project into
time-entry-v1with project and person resources, have the views read rows with the log overlay, and configure the Timer view's columns explicitly on its own table. - Money: bind to the Pages subjects (after S4), have
resolveFieldsread by subject only, and show an invalid amount as a message, not a crash. - Notion: one table per database, real Tags, dates, relations where possible, and a slimmed-down sync view.
- Compare on open, and one "Changes to send" list (Q4, the "for now" path):
- Each sync part diffs every synced row against its on-row baseline on open, on
subscribeevents and on "Refresh" (§4.2). - Every send is reviewed by default while testing (§4.3).
- Calendar and issue tracker adapt their existing flows. Timesheets follows Timesheets (Clockify): two-way interval sync through an observation log and conflict timeline #123 M3. Notion follows Notion #8's bridge.
- Each plugin's README states the declared limitation that local deletions of synced rows are not noticed until H6b.
- Each sync part diffs every synced row against its on-row baseline on open, on
- Per-plugin policies, written down (Q6, Q7, conflicts): each plugin's README and view copy state what it treats as a real conflict and how it resolves it (for example "provider wins" for Clockify), whether hand-added rows upload only through "Publish to …", and whether rows deleted at the provider are marked or deleted. This proposal's defaults are in §3.2 and §4.6.
- Migration passes per §5, each with an "unsent edits" guard. In-place retargeting is possible now (S2a).
- A hand-made table under the plugin's view (unblocked by S2b): make the table with New Table → "Use existing class" → paste the class URL (S3), then "+ Add view" → the plugin → "Allow editing". Document the paste step in each plugin's README until H10 or H3 lands.
- "Sync this table to " UI, as plugin UI: the button, the provider-source choice, and the disabled state with its reason until H4 exists. With "Allow editing" but no H4, it can't store extras on the rows, so it can't be exercised end to end.
- The first Devonian lens (Time tracker template →
time-entry-v1), after S5 and Q14. - E2E per plugin:
- Install test-side (allowed despite the gate).
- Connect, and check that a fresh table of the shared class is created and filled, with provider id, version and baseline as extras on each row.
- Close the plugin. Open the table in the built-in Calendar, Issues or Timer view.
- Edit a shared field there.
- Reopen the plugin, and check that it lists the edit in "Changes to send".
- Approve it against the mock provider, and check that the row's baseline advances only after the provider confirms.
- Make a table by pasting the class URL, add the plugin view, "Allow editing", and edit a row there.
6.3 Work that needs host changes
In order of need:
- H4, the wider "Allow editing" scope (decided), for "Sync this table".
- H6, update events (decided direction): the per-table change list with tombstones (H6b) for correctness, and the durable
afterCommithook (H6a) for speed. Until then, plugins compare on open (§6.2 item 10). - H1, robustness.
- H8, landing the open upstream PRs.
- H11, background runs, once a plugin needs to send while closed. The proxy side (delegated connection, registered runtime) is integration-proxy work, not atomic-server's.
Then the smaller or optional ones: H10, H3, H2, H9. H5 and H7 are withdrawn.
7. Host requirements (atomic-server)
Nothing here is assumed to happen. Each item says what depends on it. Numbers are kept from revision 1 so earlier comments still line up; H5 and H7 are withdrawn, and H11 is new in revision 3.
Under Q4–Q7, the host owns only what it really gates: background runs (H11), grants beyond "Allow editing" (H4 widens "Allow editing" itself), and proxy permissions (which live in the integration-proxy, not here). Sync, review and conflict handling are plugin logic and need no host item.
-
H1: make vocabulary resolution robust. S1 shows the published vocabulary already resolves at
2567fc30bfor tableclasstype, the columns, and the row grant'sget_class, while Pages is reachable or the term is cached. H1 is now three robustness items:- (a) (small, lib) Don't sign GETs to a foreign origin that isn't a known Atomic server, or at least not for vocabulary. The
atomicdata.devexemption atlib/src/client.ts:262does this for one host. It removes the failed preflight, the console CORS error per term per session, and the dependency on the local DB worker. - (b) (small, lib) Fix the
/pathproxy signature: sign the final/pathURL, not the subject URL (client.ts:248-289). Today a signed-in/pathread of any non-atomicdata.dev subject fails with "Incorrect signature for auth headers". Then let the browser fall back to its own server for external subjects it can't reach, so a cold device works during a Pages outage. - (c) (optional) Warm or pin a release: fetch every term listed in a release index
<BASE>/v<N>on install instead of lazily, or embed the release the waytask/v1is embedded (store.ts:426-445,lib/defaults/*.json).
Without these, it works except for: a cold device during a Pages outage; a hosted build with the local DB off (inferred); and a term first used server-side while Pages is down.
- (a) (small, lib) Don't sign GETs to a foreign origin that isn't a known Atomic server, or at least not for vocabulary. The
-
H2 (nice-to-have): catalog apps declare their row classes.
CatalogAppgainsrowClass(passed tocreateApp, which already supports it) and arenderslist, so an install creates its table with the shared class and is offered on other tables of it. Not required: an app can do both itself on first open (S2, §6.2 item 3). H2 would remove that first-open patch and the leftover per-app class. -
H3: templates use the shared classes. The Issue Tracker and Time tracker templates, and a new Events template, use
issue-v1,time-entry-v1andevent-v1instead ofcreateRowClass. This changes templates, not the built-in views. Useful for discoverability: without it, a person gets a plugin view on a template-made table only through a lens (§3.1) or by making the table with a pasted class URL (S3). -
H4 (decided): extend "Allow editing" to the plugin's provider extras on rows. On a table where a person gave a view "Allow editing" (#1788), that view's plugin, including its sync part and its
afterCommithook (H6a), may alsosave/removeits own provider extras on rows: provider ids, versions such as ETags, baselines and sync state (Q4, "bookkeeping on the row"). Today's row grant allows only the class'srequires/recommends. Keep "neverdestroy", and neverparent,isA, rights, the table or its views. Not yet specified: how the host knows which properties are "the plugin's provider extras" (for example, properties in the app's own ontology, or a list in its manifest), and whether the "Allow editing" dialog copy should say that the plugin may copy the table's rows to a connected provider (Q15). Needed for "Sync this table"; the fresh-table path doesn't need it. -
H5: withdrawn (Q4–Q7). It proposed a separate, recorded host grant from the "Sync this table to " gesture. "Sync this table" is now plugin UI; writing to the table is bounded by "Allow editing" plus H4, reaching the provider by the integration-proxy's permissions, and running while closed by H11. The no-host alternative listed with it (keeping a row's extras in the app's own subtree, keyed by row subject) is also ruled out, since bookkeeping lives on the row (Q4).
-
H6 (decided direction): update events, "hook for speed, change list for correctness". Michiel calls the hook an interesting direction to work out, not a finished spec.
- (a) A durable JS class hook,
afterCommit, that user-installed plugins may use, scoped to tables where the plugin's view is installed. It replaces a separate "changed" query trigger. Writes from it follow the view grant: without "Allow editing", it only reads, and its proposed writes wait for approval in the view; approving one offers "Allow all edits by this view on this table", which is "Allow editing" itself. Open design points, not decided here: its signature, where it runs, what "durable" guarantees (proposed: a commit made while nothing listens is delivered later), and whether a call made while no view is open is a background run under H11. - (b) A per-table change list with tombstones: "what changed on this table since commit X", including deleted rows.
Without it: edits are found only when the plugin opens (compare on open, §4.2), and local deletions of synced rows are not found at all (§4.1).
- (a) A durable JS class hook,
-
H7: withdrawn (decision 7). It proposed that the built-in Calendar view show the time from
atomic-calendar-start/-endand that the Timer view guesswork-start/work-end. The built-in views stay as they are. -
H8: land the open upstream PRs this relies on: #1768 (
destination.tables), #1774 (importer.run) and #1788 (row grants). They are at the pin but still open upstream. -
H9 (optional): make the host aware of vocabulary gating, for example a recognised
requirestoken. Not needed if theenabled: falserule in §2.0 is used. -
H10 (small): New Table's class picker finds external classes by search. Today its search is scoped to
parents: [drive, 'https://atomicdata.dev'](SearchBoxWindow.tsx:384-398), so a Pages class is found only by pasting its URL (S3). Options: add the ontology base (https://ontola.github.io/atomic-plugins/ontology, laterhttps://<domain>/ontology) to that scope, or list the classes of the ontologies the drive's apps render. Nice-to-have; pasting works. -
H11: background runs. The host runs a plugin's sync part, or delivers its
afterCommitcalls, while no view of the plugin is open, and gates that per plugin (integration-proxy: auth re-design (connections, signing vs capabilities, lifetimes, revocation, multi-node identity) #54 flow b, or the sandboxtrigger, are candidate mechanisms; neither is chosen). This is one of the three things the host owns under Q4–Q7, next to "Allow editing" (with H4) and the proxy's permissions. Sending to a provider from such a run also needs, at the integration-proxy and outside atomic-server, a connection delegated to the plugin's app agent and a registered runtime for unattended runs; whether the proxy supports that today was not checked (unverified). Needed for automatic sending while the plugin is closed (§4.3); not needed while testing, when every send is reviewed in the open view.
8. Questions for Michiel
Decided (2026-09-25):
-
How strictly should a plugin's view match a table? Decided: strict, by exact shared class. A plugin view is offered only on tables of exactly its shared class, and reads shared-class properties only. The resolver's column guessing is removed; matching by name and type is replaced by Devonian lenses that map other shapes onto the shared class (§3.1). Duck typing may be tried later as an experiment.
-
Should a sync be able to fill a table I already have? Decided: yes, but from the view, not from Set up. Install and connect create fresh tables. On a table of the shared class, the plugin's view offers "Sync this table to ". Revised by Q4–Q7: that button is plugin UI, not a recorded host grant (H5 withdrawn); writing is bounded by "Allow editing", extended by H4 (§3.0).
-
How do plugin views relate to the built-in Calendar, Issues and Timer views? Decided: the built-in views stay as they are. Plugin views are optional, enhanced views. The built-in views are more thoroughly vetted, which is why they may run in the host page without an iframe. How that evolves is decided later, once more plugins with better views are published.
-
Change feeds: what happens to edits made while the plugin is closed? Decided:
- Sync, "Changes to send", review and conflicts are plugin logic. The host owns only background runs, grants beyond "Allow editing", and proxy permissions; there is no host sync-grant gesture (H5 withdrawn).
- Bookkeeping (provider id, ETag, baseline) lives on the row as provider extras, and "Allow editing" is extended to cover them (H4: yes).
- Update events come from a JS class hook,
afterCommit, built by atomic-server, usable by user-installed plugins and scoped to tables where the plugin's view is installed. It replaces a separate "changed" query trigger. Writes from it follow the view grant (§4.2). This is a direction to work out, not a finished spec. - For now: plugins compare on open and review in their view. Meanwhile atomic-server builds a per-table change list with tombstones, a durable
afterCommit, and the wider "Allow editing" scope: "hook for speed, change list for correctness" (H6, H4). - Plugins review every send while testing; the expected future default is sending automatically, with only real merge conflicts asking (§4.3).
- Sending to the provider goes through the integration-proxy's permissions (a connection delegated to the plugin's app agent, plus a registered runtime for unattended runs), separate from table grants.
-
Should an edit to a synced row made anywhere go back to the provider? Decided: yes. An edit made in a plain table, the built-in Calendar, another view or on another device should reach Google, GitHub or Clockify. This reverses Design: two-way sync as an observation log + Devonian lens (CRDT-like), starting with Clockify #97's decision that timesheets table edits are overwritten (§4.7).
-
A row I add by hand to a synced table: should it be offered for upload? Decided: each plugin's call. This proposal's per-plugin default: only through an explicit "Publish to …" action; otherwise it stays local. The same applies to rows already in a table when "Sync this table" is pressed.
-
Something deleted at the provider: delete the row or mark it? Decided: each plugin's call. This proposal's per-plugin default: mark it (a
…-removed-atextra) and let the person delete it. No grant here allowsdestroyon a table the plugin didn't create (§4.6).Also each plugin's call, under Q4–Q7: what counts as a real conflict and how it's resolved, including "provider wins" for Clockify (§4.4).
-
Where should the shared vocabulary and code live? Decided: one shared folder at the repo's top level,
ontology/, published at the Pages path/ontology/(https://ontola.github.io/atomic-plugins/ontology/now,https://<domain>/ontology/later), with the base URL in one place. Recommendation for the code (the strict class check, subject constants, lenses): a sibling top-levelontology-kit/, so thatontology/holds only immutable published terms (§2.0). The nameontology-kitis open.
Still open:
- GitHub has no "Blocked" state. How should it be stored there? Recommendation: a label
atomic:blocked, like the existingatomic:doing. - Notion: keep a custom browsing view? Recommendation: no. With real tags and dates, the built-in views are enough. Keep only a small sync-status view.
- Existing test installs: migrate or reinstall? Recommendation: reinstall and re-sync, with an in-app migration only where unsent edits could be lost (§5). In-place migration is possible without host work (S2).
- Time entries: projects and people as linked records or as plain text? Recommendation: linked records (
work-project,work-person), as the host's own Time tracker template does. (Not listed as still open in the Q4–Q7 decisions, but not decided either; kept here until confirmed.) - The domain move: rewrite stored data or keep aliases? Recommendation: rewrite (§2.0). The gate keeps github.io subjects out of real drives, so there is nothing worth an alias layer.
New in revision 2 (open):
-
Lenses: materialize or compute, and who runs them? Is the lensed side a real table of the shared class kept in sync both ways, or computed when the view opens? Does the lens run in the plugin's frame, in a separate lens app, or in the sandbox? Recommendation: decide after S5. A materialized table under the lens's owner fits strict matching and the existing row grant most directly, but duplicates rows.
-
With no host sync gesture, is "Allow editing" plus a provider connection enough consent to copy a table to a provider? Reframed in revision 3. Revision 2 asked what a host "Sync this table" grant would cover; that grant is withdrawn. What's left for the host is H4's exact shape:
- which properties count as "the plugin's provider extras" (properties in the app's own ontology, or a list in its manifest);
- whether the "Allow editing" dialog should say that this plugin may copy the table's rows to a provider it is connected to, since that dialog is now the only host consent on the table side;
- whether granting "Allow editing" through a hook's "Allow all edits by this view on this table" prompt needs different copy from the view's own button.
Who may press "Sync this table", and whether its first pass matches existing rows to provider records, are now plugin questions (Q6's plugin-owned answer covers the second). Recommendation: the host derives "provider extras" from the app's own ontology, so no manifest change is needed, and the "Allow editing" dialog names the plugin's connected providers when it has any. Neither is verified against the host's model.
Not verified anywhere in this proposal:
- a real
https://ontola.github.ioURL end to end (S1 used a host that copies Pages' probed headers); - a hosted build with the local DB off (inferred to fail for signed-in users, S1);
createAppwith an externalrowClass, andensureSchemabinding to external subjects (S4);- any Devonian lens against a live drive (S5);
- the wider "Allow editing" scope (H4), the
afterCommithook and the per-table change list (H6), and background runs (H11), none of which exist; - the integration-proxy's delegated connections and registered runtimes, whose current state was not checked for this proposal;
- whether
destroyis allowed inside an app's own subtree; - the Notion date and people mapping against the live API;
- whether the timesheets view performs well reading rows instead of the log;
- every capability marked declared.
Related: #97, #123, #124, #8, #89, #111, #169, #171, #172, #173, #175; atomic-server #1740, #1768, #1774, #1788.
Activity
michielbdejong commentedon Sep 25, 2026
Picked up by the atomic-plugins worker session (
e6ce43). It's running spikes S1–S3 now (Pages-hosted classes and the "Allow editing" check; an app retargeting its own class; New Table's picker finding external classes). The results will be posted here and will decide which items move to §7's host list.michielbdejong commentedon Sep 25, 2026
Spike results for S1–S3, at the pin
2567fc30b(the published e2e image). The draft class and its two properties were served at a Pages-shaped path, with the headers GitHub Pages actually sends. I probed those live:access-control-allow-origin: *andmax-age=600on GET,application/octet-streamfor extensionless files, and 405 with no CORS headers on a preflight. The test code is throwaway and stays local (branchclaude/option4-spikes).S1 (Pages-hosted class): partially.
lib/src/db.rs:4851-4903). The content type is ignored.classtypeshows its columns.recommendsand create rows of the class. It is refused ondescriptionandisA.get_classon the external subject is fine (app_row_grant.rs:389-462)..jsonsuffix is needed.client.ts:262-282), so Pages' failing preflight blocks it. The local-database worker (the WASMatomic_lib::Db) then fetches the class unsigned and caches it in OPFS (wasm/src/lib.rs:207-222). So it works, but each session costs one failed request per term, plus a console CORS error.#, because the browser never asks its own server for an external subject./pathproxy is broken for signed-in users on any non-atomicdata.dev subject: it signs the subject URL, not the/pathURL (client.ts:248-289)./pathsignature and use it as a fallback for a cold browser;S2 (an app retargets itself): yes. Through the frame store API, an app can:
classtypeto the Pages class;isA;renders, after which "+ Add view" offers it on a hand-made table of that class;Only rights are checked (
hostStore.ts:472-507,app_write.rs,store_host.rs). So §5's in-place migration and §6.2 item 12 need no host work. H2 stays nice-to-have, not required.S3 (New Table's "existing class" picker): partially. Search doesn't find the Pages class: it is scoped to the drive and atomicdata.dev (
SearchBoxWindow.tsx:384-398). Pasting or typing its URL and pressing Enter selects it, and the table works. If search should find it, that's a small host item (search scope or listing), or H3 templates.Not tested:
createAppwith an externalrowClass(inferred to work),ensureSchemabinding to external subjects, and a real https Pages URL end to end (only its headers were probed).michielbdejong commentedon Sep 25, 2026
Decisions from Michiel (2026-09-25), open questions 1–3
Still open:
michielbdejong commentedon Sep 25, 2026
Decided (Michiel, 2026-09-25), open question 12: yes to one shared folder, at the repo's top level:
ontology/, notintegrations/ontology/./ontology/. The live base ishttps://ontola.github.io/atomic-plugins/ontology/, and later, with a custom Pages domain,https://<domain>/ontology/.§2.0 and §7 of the issue body are being updated to match. Questions 4–11 and 13 are still open; question 4 is being discussed separately.
michielbdejong commentedon Sep 25, 2026
Groundwork is up as #178:
ontology/holds the generated, immutable terms (the event, issue, time-entry, project, person and bank-transaction classes, with 22 properties), andontology-kit/holds the base URL (one place), the build and check, the resolver (exact class and exact property, lens hooks) and the gating rule (catalog entries using the github.io base must stay disabled). No plugin uses it yet.Merge pull request #178 from ontola/claude/ontology-scaffold
michielbdejong commentedon Sep 25, 2026
Decisions from Michiel (2026-09-25), open questions 4–7: change feeds and edits made outside the plugin
Edits made anywhere reach the provider. An edit to a synced row, whether made in a plain table, the built-in calendar, another view or on another device, should reach Google, GitHub or Clockify. (Q5)
Sync is plugin logic, not host vocabulary. "Sync this table to …", provider setup, "Changes to send", review and conflict handling are the plugin's own UI and logic. The host can't enforce anything while a view is open, because a plugin with both a sync part and a view wires them together itself. The host only owns what it really gates: background runs, grants beyond "Allow editing", and proxy permissions. So H5 needs no separate host "sync grant" gesture.
Human in the loop while testing. For now, plugins review every send by default. The expected future default is sending automatically ("just works"), with only real merge conflicts asking the user.
Conflicts are the plugin's call: what counts as a real conflict and how it's resolved, including "provider wins" for Clockify.
Update events come from a JS class hook,
afterCommit. User-installed plugins can use it, scoped to tables where the plugin's view is installed, and atomic-server builds it. It replaces a separate "changed" query trigger. Michiel calls this an interesting direction to work out, not a finished spec.Writes from a hook follow the existing view grant (#1788):
Sync bookkeeping lives on the row. The provider id, ETag and baseline are stored on the row as provider extras, not in plugin-owned side storage.
Sending to the provider goes through the integration-proxy's permissions: a connection delegated to the plugin's app agent, plus a registered runtime for unattended runs. These are separate from table grants.
For now:
afterCommit, and the wider "Allow editing" scope.The pattern is "hook for speed, change list for correctness".
Q6 and Q7 are left to each plugin: Q6 is whether hand-added rows are only uploaded through "Publish to …"; Q7 is whether a row deleted at the provider is marked or deleted.
Questions 8–10 and 13 are still open.
michielbdejong commentedon Sep 29, 2026
Decisions from Michiel (answered 2026-09-25): the remaining open questions
atomic:blocked, likeatomic:doing.work-project,work-person).That closes all of this issue's open questions. Q14 and Q15, added during revision, follow from these: Q15 is answered by the Q4–Q7 decisions (no host sync gesture), and Q14 (lens placement) is decided per plugin during implementation.
michielbdejong commentedon Oct 1, 2026
Picking this up: atomic-plugins oversight
34aa23on the build VPS, through a worker subagent.Generated by Claude Code
michielbdejong commentedon Oct 1, 2026
Implementation progress (atomic-plugins oversight
34aa23). The first plugins now sync into the shared classes, mock-tested only:bank-transaction-v1: draft money 0.4.0: sync into the shared bank-transaction-v1 class (#177 item 8) #252. Blocked on the host: both plugin-manifest validators refusesubjecton sandbox importer destinations. The patch is on Agent coordination board (Claude sessions: rules, status, hand-offs) #227 for the atomic-server worker. With it, the money lane passes. Spike S4 (ensureSchemabinding to external subjects) works.event-v1: calendar 0.2.0: rows are the shared event-v1 class (#177 item 5) #253. Rows move in place on first open, Google extras arerow-extras, and day-only rows show as all-day.issue-v1: issue-tracker 0.2.0: rows of the shared issue-v1 class (#177 item 6) #254 (stacked on issue-tracker 0.1.3: sync after connecting through an existing connection #249). Blocked isatomic:blocked(Q8), local rows wait for "Publish to GitHub" (Q6), and baselines live on the rows (decision 7).ontology-kit/served.mjs. An ontology change must therefore land on main and be served before an e2e can use it./changes(#1850) andafterCommit(#1851) are in the pin, but no frame-store operation reaches them, so drive apps keep comparing on open.ensureSchemahits "ambiguous schema shortname".time-entry-v1) after timesheets 0.4.0: two open copies, send lease, concurrent compaction (#123 M5) #246 lands. Item 14 ("Sync this table to …") isn't started.Generated by Claude Code
Merge pull request #253 from ontola/claude/calendar-event-v1
Merge pull request #272 from ontola/claude/calendar-sync-existing-table
michielbdejong commentedon Oct 2, 2026
Item 14, "Sync this table to …", is done for calendar (#272, merged, calendar 0.3.0), with no host change. The app asks for "Allow editing" covering its
row-extras, and keeps the binding on a resource under the App (never on the table). It then syncs the table with the same review, compare-on-open and conflict rules as its own table. The pattern is documented inintegrations/README.md("Syncing a table the app didn't make"). Issue-tracker and timesheets are in progress. Also merged: #253 (calendar →event-v1), #265 (issue-tracker →issue-v1, timesheets →time-entry-v1). #273 (Todoist app onissue-v1) is in CI.Generated by Claude Code
Merge pull request #275 from ontola/claude/timesheets-sync-existing-t…
Merge pull request #276 from ontola/claude/issue-tracker-sync-existin…
Merge pull request #281 from ontola/claude/notion-q9-status-view
Merge pull request #287 from ontola/claude/money-bank-transaction-app
michielbdejong commentedon Oct 2, 2026
Item 8 is done: #287 merged (money 0.4.0). The Money drive app writes
bank-transaction-v1rows itself through app writes, so no host change was needed and #252 is closed as superseded. A catalog install now gives a working Money app (the #94 gap), and the importer's own table still works through a lens.All four shared classes now have a syncing app on main:
event-v1(calendar),issue-v1(issue-tracker, Todoist),time-entry-v1(timesheets) andbank-transaction-v1(money). Item 14 ("Sync this table to …") is done for calendar, issue-tracker and timesheets. Still open: showing a row that's missing a required field as incomplete instead of hiding it (in progress), and the remaining open questions on #227.Generated by Claude Code
Merge pull request #293 from ontola/claude/shared-class-incomplete-rows
michielbdejong commentedon Oct 2, 2026
The "show an incomplete row instead of skipping it" rule is now in the apps: #293 merged for calendar 0.3.1, issue-tracker 0.3.1, Todoist 0.1.1 and timesheets 0.6.2, and #295 (money 0.4.1) is in CI.
Finding: the pinned host refuses any commit that lacks a required property, so on a real host an incomplete row can only come from an empty string or a lens. The rule therefore matters less for required dates and timestamps than the design assumed.
Two related fixes from the same work: calendar and timesheets had been reading a table's View resources as rows, and now filter by
isA.Generated by Claude Code
Merge pull request #295 from ontola/claude/money-incomplete-rows