@mndrk/agx 2.0.0 → 2.0.2

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/src/util/helpers.cpp

@@ -1,109 +0,0 @@
-inline v8::Local<v8::String> StringFromUtf8(v8::Isolate* isolate, const char* data, int length) {
-	return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kNormal, length).ToLocalChecked();
-}
-
-inline v8::Local<v8::String> InternalizedFromUtf8(v8::Isolate* isolate, const char* data, int length) {
-	return v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kInternalized, length).ToLocalChecked();
-}
-
-inline v8::Local<v8::Value> InternalizedFromUtf8OrNull(v8::Isolate* isolate, const char* data, int length) {
-	if (data == NULL) return v8::Null(isolate);
-	return InternalizedFromUtf8(isolate, data, length);
-}
-
-inline v8::Local<v8::String> InternalizedFromLatin1(v8::Isolate* isolate, const char* str) {
-	return v8::String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(str), v8::NewStringType::kInternalized).ToLocalChecked();
-}
-
-inline void SetFrozen(v8::Isolate* isolate, v8::Local<v8::Context> ctx, v8::Local<v8::Object> obj, v8::Global<v8::String>& key, v8::Local<v8::Value> value) {
-	obj->DefineOwnProperty(ctx, key.Get(isolate), value, static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly)).FromJust();
-}
-
-void ThrowError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::Error(StringFromUtf8(isolate, message, -1))); }
-void ThrowTypeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::TypeError(StringFromUtf8(isolate, message, -1))); }
-void ThrowRangeError(const char* message) { EasyIsolate; isolate->ThrowException(v8::Exception::RangeError(StringFromUtf8(isolate, message, -1))); }
-
-// Determines whether to skip the given character at the start of an SQL string.
-inline bool IS_SKIPPED(char c) {
-	return c == ' ' || c == ';' || (c >= '\t' && c <= '\r');
-}
-
-// Allocates an empty array, without calling constructors/initializers.
-template<class T> inline T* ALLOC_ARRAY(size_t count) {
-	return static_cast<T*>(::operator new[](count * sizeof(T)));
-}
-
-// Deallocates an array, without calling destructors.
-template<class T> inline void FREE_ARRAY(T* array_pointer) {
-	::operator delete[](array_pointer);
-}
-
-v8::Local<v8::FunctionTemplate> NewConstructorTemplate(
-	v8::Isolate* isolate,
-	v8::Local<v8::External> data,
-	v8::FunctionCallback func,
-	const char* name
-) {
-	v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate, func, data);
-	t->InstanceTemplate()->SetInternalFieldCount(1);
-	t->SetClassName(InternalizedFromLatin1(isolate, name));
-	return t;
-}
-
-void SetPrototypeMethod(
-	v8::Isolate* isolate,
-	v8::Local<v8::External> data,
-	v8::Local<v8::FunctionTemplate> recv,
-	const char* name,
-	v8::FunctionCallback func
-) {
-	v8::HandleScope scope(isolate);
-	recv->PrototypeTemplate()->Set(
-		InternalizedFromLatin1(isolate, name),
-		v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
-	);
-}
-
-void SetPrototypeSymbolMethod(
-	v8::Isolate* isolate,
-	v8::Local<v8::External> data,
-	v8::Local<v8::FunctionTemplate> recv,
-	v8::Local<v8::Symbol> symbol,
-	v8::FunctionCallback func
-) {
-	v8::HandleScope scope(isolate);
-	recv->PrototypeTemplate()->Set(
-		symbol,
-		v8::FunctionTemplate::New(isolate, func, data, v8::Signature::New(isolate, recv))
-	);
-}
-
-void SetPrototypeGetter(
-	v8::Isolate* isolate,
-	v8::Local<v8::External> data,
-	v8::Local<v8::FunctionTemplate> recv,
-	const char* name,
-	v8::AccessorNameGetterCallback func
-) {
-	v8::HandleScope scope(isolate);
-	recv->InstanceTemplate()->SetNativeDataProperty(
-		InternalizedFromLatin1(isolate, name),
-		func,
-		0,
-		data
-	);
-}
-
-#if defined(V8_ENABLE_SANDBOX)
-// When V8 Sandbox is enabled (in newer Electron versions), we need to use Buffer::Copy
-// instead of Buffer::New to ensure the ArrayBuffer backing store is allocated inside the sandbox
-static inline v8::MaybeLocal<v8::Object> BufferSandboxNew(v8::Isolate* isolate, char* data, size_t length, void (*finalizeCallback)(char*, void*), void* finalizeHint) {
-    v8::MaybeLocal<v8::Object> buffer = node::Buffer::Copy(isolate, data, length);
-    finalizeCallback(data, finalizeHint);
-    return buffer;
-}
-#define SAFE_NEW_BUFFER(env, data, length, finalizeCallback, finalizeHint) BufferSandboxNew(env, data, length, finalizeCallback, finalizeHint)
-#else
-// When V8 Sandbox is not enabled, we can use the more efficient Buffer::New
-#define SAFE_NEW_BUFFER(env, data, length, finalizeCallback, finalizeHint) node::Buffer::New(env, data, length, finalizeCallback, finalizeHint)
-#endif

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/src/util/macros.cpp

@@ -1,70 +0,0 @@
-#define NODE_ARGUMENTS const v8::FunctionCallbackInfo<v8::Value>&
-#define NODE_ARGUMENTS_POINTER const v8::FunctionCallbackInfo<v8::Value>*
-#define NODE_METHOD(name) void name(NODE_ARGUMENTS info)
-#define NODE_GETTER(name) void name(v8::Local<v8::Name> _, const v8::PropertyCallbackInfo<v8::Value>& info)
-#define INIT(name) v8::Local<v8::Function> name(v8::Isolate* isolate, v8::Local<v8::External> data)
-
-#if defined(V8_MAJOR_VERSION) && V8_MAJOR_VERSION >= 13
-// v8::Object::GetPrototype has been deprecated. See http://crbug.com/333672197
-#define GET_PROTOTYPE(obj) ((obj)->GetPrototypeV2())
-#else
-#define GET_PROTOTYPE(obj) ((obj)->GetPrototype())
-#endif
-
-#define EasyIsolate v8::Isolate* isolate = v8::Isolate::GetCurrent()
-#define OnlyIsolate info.GetIsolate()
-#define OnlyContext isolate->GetCurrentContext()
-#define OnlyAddon static_cast<Addon*>(info.Data().As<v8::External>()->Value())
-#define UseIsolate v8::Isolate* isolate = OnlyIsolate
-#define UseContext v8::Local<v8::Context> ctx = OnlyContext
-#define UseAddon Addon* addon = OnlyAddon
-#define Unwrap node::ObjectWrap::Unwrap
-
-#define REQUIRE_ARGUMENT_ANY(at, var)                                          \
-	if (info.Length() <= (at()))                                               \
-		return ThrowTypeError("Expected a "#at" argument");                    \
-	var = info[at()]
-
-#define _REQUIRE_ARGUMENT(at, var, Type, message, ...)                         \
-	if (info.Length() <= (at()) || !info[at()]->Is##Type())                    \
-		return ThrowTypeError("Expected "#at" argument to be "#message);       \
-	var = (info[at()].As<v8::Type>())__VA_ARGS__
-
-#define REQUIRE_ARGUMENT_INT32(at, var)                                        \
-	_REQUIRE_ARGUMENT(at, var, Int32, a 32-bit signed integer, ->Value())
-#define REQUIRE_ARGUMENT_BOOLEAN(at, var)                                      \
-	_REQUIRE_ARGUMENT(at, var, Boolean, a boolean, ->Value())
-#define REQUIRE_ARGUMENT_STRING(at, var)                                       \
-	_REQUIRE_ARGUMENT(at, var, String, a string)
-#define REQUIRE_ARGUMENT_OBJECT(at, var)                                       \
-	_REQUIRE_ARGUMENT(at, var, Object, an object)
-#define REQUIRE_ARGUMENT_FUNCTION(at, var)                                     \
-	_REQUIRE_ARGUMENT(at, var, Function, a function)
-
-#define REQUIRE_DATABASE_OPEN(db)                                              \
-	if (!db->open)                                                             \
-		return ThrowTypeError("The database connection is not open")
-#define REQUIRE_DATABASE_NOT_BUSY(db)                                          \
-	if (db->busy)                                                              \
-		return ThrowTypeError("This database connection is busy executing a query")
-#define REQUIRE_DATABASE_NO_ITERATORS(db)                                      \
-	if (db->iterators)                                                         \
-		return ThrowTypeError("This database connection is busy executing a query")
-#define REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db)                        \
-	if (!db->unsafe_mode) {                                                    \
-		REQUIRE_DATABASE_NO_ITERATORS(db);                                     \
-	} ((void)0)
-#define REQUIRE_STATEMENT_NOT_LOCKED(stmt)                                     \
-	if (stmt->locked)                                                          \
-		return ThrowTypeError("This statement is busy executing a query")
-
-#define first() 0
-#define second() 1
-#define third() 2
-#define fourth() 3
-#define fifth() 4
-#define sixth() 5
-#define seventh() 6
-#define eighth() 7
-#define ninth() 8
-#define tenth() 9

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/src/util/query-macros.cpp

@@ -1,71 +0,0 @@
-#define STATEMENT_BIND(handle)                                                 \
-	Binder binder(handle);                                                     \
-	if (!binder.Bind(info, info.Length(), stmt)) {                             \
-		sqlite3_clear_bindings(handle);                                        \
-		return;                                                                \
-	} ((void)0)
-
-#define STATEMENT_THROW_LOGIC()                                                \
-	db->ThrowDatabaseError();                                                  \
-	if (!bound) { sqlite3_clear_bindings(handle); }                            \
-	return
-
-#define STATEMENT_RETURN_LOGIC(return_value)                                   \
-	info.GetReturnValue().Set(return_value);                                   \
-	if (!bound) { sqlite3_clear_bindings(handle); }                            \
-	return
-
-#define STATEMENT_START_LOGIC(RETURNS_DATA_CHECK, MUTATE_CHECK)                \
-	Statement* stmt = Unwrap<Statement>(info.This());                          \
-	RETURNS_DATA_CHECK();                                                      \
-	sqlite3_stmt* handle = stmt->handle;                                       \
-	Database* db = stmt->db;                                                   \
-	REQUIRE_DATABASE_OPEN(db->GetState());                                     \
-	REQUIRE_DATABASE_NOT_BUSY(db->GetState());                                 \
-	MUTATE_CHECK();                                                            \
-	const bool bound = stmt->bound;                                            \
-	if (!bound) {                                                              \
-		STATEMENT_BIND(handle);                                                \
-	} else if (info.Length() > 0) {                                            \
-		return ThrowTypeError("This statement already has bound parameters");  \
-	} ((void)0)
-
-
-#define STATEMENT_THROW() db->GetState()->busy = false; STATEMENT_THROW_LOGIC()
-#define STATEMENT_RETURN(x) db->GetState()->busy = false; STATEMENT_RETURN_LOGIC(x)
-#define STATEMENT_START(x, y)                                                  \
-	STATEMENT_START_LOGIC(x, y);                                               \
-	db->GetState()->busy = true;                                               \
-	UseIsolate;                                                                \
-	if (db->Log(isolate, handle)) {                                            \
-		STATEMENT_THROW();                                                     \
-	} ((void)0)
-
-
-#define DOES_NOT_MUTATE() REQUIRE_STATEMENT_NOT_LOCKED(stmt)
-#define DOES_MUTATE()                                                          \
-	REQUIRE_STATEMENT_NOT_LOCKED(stmt);                                        \
-	REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db->GetState())
-#define DOES_ADD_ITERATOR()                                                    \
-	DOES_NOT_MUTATE();                                                         \
-	if (db->GetState()->iterators == USHRT_MAX)                                \
-		return ThrowRangeError("Too many active database iterators")
-#define REQUIRE_STATEMENT_RETURNS_DATA()                                       \
-	if (!stmt->returns_data)                                                   \
-		return ThrowTypeError("This statement does not return data. Use run() instead")
-#define ALLOW_ANY_STATEMENT()                                                  \
-	((void)0)
-
-
-#define _FUNCTION_START(type)                                                  \
-	type* self = static_cast<type*>(sqlite3_user_data(invocation));            \
-	v8::Isolate* isolate = self->isolate;                                      \
-	v8::HandleScope scope(isolate)
-
-#define FUNCTION_START()                                                       \
-	_FUNCTION_START(CustomFunction)
-
-#define AGGREGATE_START()                                                      \
-	_FUNCTION_START(CustomAggregate);                                          \
-	Accumulator* acc = self->GetAccumulator(invocation);                       \
-	if (acc->value.IsEmpty()) return

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/src/util/row-builder.cpp

@@ -1,49 +0,0 @@
-class RowBuilder {
-public:
-
-	explicit RowBuilder(
-		v8::Isolate* isolate,
-		sqlite3_stmt* handle,
-		bool safe_ints
-	) :
-		isolate(isolate),
-		handle(handle),
-		column_count(-1),
-		safe_ints(safe_ints),
-		keys(isolate) {}
-
-	v8::Local<v8::Value> GetRowJS() {
-		if (column_count < 0) {
-			column_count = sqlite3_column_count(handle);
-			keys.reserve(column_count);
-			for (int i = 0; i < column_count; ++i) {
-				keys.emplace_back(
-					InternalizedFromUtf8(isolate, sqlite3_column_name(handle, i), -1)
-						.As<v8::Name>()
-				);
-			}
-		}
-
-		v8::LocalVector<v8::Value> values(isolate);
-		values.reserve(column_count);
-		for (int i = 0; i < column_count; ++i) {
-			values.emplace_back(
-				Data::GetValueJS(isolate, handle, i, safe_ints)
-			);
-		}
-
-		return v8::Object::New(isolate,
-			GET_PROTOTYPE(v8::Object::New(isolate)),
-			keys.data(),
-			values.data(),
-			column_count
-		);
-	}
-
-private:
-	v8::Isolate* isolate;
-	sqlite3_stmt* handle;
-	int column_count;
-	const bool safe_ints;
-	v8::LocalVector<v8::Name> keys;
-};

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/script.txt

@@ -1,111 +0,0 @@
-AGX — THINK FIRST, BUILD FAST
-==============================
-
-PART 1: THE PROBLEM
--------------------
-
-When I want to build something, I usually start by brainstorming ideas, then come up with a plan, before writing any code.
-
-To refine the idea into plan before execution I used to jump between:
- - different models Claude, GPT
- - and tools: claude code, codex, cursor, antigravity
-
-Now, all of that happens in one place.
-
-PART 2: WHAT CHANGED
----------------------
-
-Let's say I want to add a notification system to AGX.
-
-Let's start with something vague:
-
-  "Add a notification system to AGX."
-
-
-
-
-PART 3: HOW IT WORKS — A LIVE EXAMPLE
---------------------------------------
-
-Let me show you what this looks like in practice.
-
-Say I want to add a notification system to AGX. I'll start with something
-intentionally vague:
-
-  "Add a notification system to AGX."
-
-I keep it vague on purpose. I don't want to jump to implementation. I want
-my agents to help me figure out what I actually want.
-
-[DEMO: Type the vague prompt into AGX chat]
-
-The agents don't just start coding. They start asking questions:
-
-  — What types of notifications? Errors? Status updates? Mentions?
-  — In-app? Email? Both?
-  — Real-time push, or periodic digests?
-  — Per-user preferences, or system-wide defaults?
-  — Event-driven, or polling?
-
-This is the diverge phase. We're expanding the problem space, not narrowing
-it. I'm not answering a spec — I'm discovering what I care about.
-
-[DEMO: Show the back-and-forth conversation in AGX]
-
-And here's the key: some of the best questions are ones I wouldn't have
-thought to ask myself. The agents surface tradeoffs I hadn't considered.
-They make me think harder.
-
-Through this conversation, I start to see the shape of what I actually want:
-
-  — Event-driven architecture
-  — Multiple notification channels
-  — Users control their own frequency and preferences
-  — Start with in-app, design for email later
-
-We diverged first. Explored. Now we converge on a clear direction.
-
-[DEMO: Show the refined plan that emerges from the conversation]
-
-
-PART 4: FROM PLAN TO EXECUTION
--------------------------------
-
-Now — and only now — do we start building.
-
-But the transition is seamless. The agents already have full context from
-the thinking phase. There's no handoff. No "let me re-explain what I want
-to a different tool." The same environment that helped me think now helps
-me build.
-
-[DEMO: Show AGX generating tasks from the plan]
-
-The plan becomes tasks. The tasks become code. The code gets tested. All
-in the same place, with the same context, by the same agents who helped me
-think through the design.
-
-[DEMO: Show code being generated and tested]
-
-
-PART 5: WHY THIS MATTERS
---------------------------
-
-The old way:
-
-  Idea → Tool A → Tool B → Tool C → Tool D → Maybe the right thing
-
-The AGX way:
-
-  Vague idea → Thinking → Clear plan → Execution → The right thing
-
-The difference isn't speed. It's accuracy. When you think clearly first,
-you build the right thing the first time. You don't waste cycles building
-something, realizing it's wrong, and starting over.
-
-AGX doesn't just make me faster. It makes me more intentional.
-
-I don't start by coding. I start by thinking.
-And AGX makes sure the thinking is as rigorous as the code.
-
-
-=== END ===

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/tests/projector/_helpers.js

@@ -1,68 +0,0 @@
-/**
- * Shared test helpers for projector tests.
- * @jest-environment node
- */
-
-'use strict';
-
-const Database = require('better-sqlite3');
-const os = require('os');
-const path = require('path');
-const fs = require('fs');
-
-const SCHEMA_SQL = fs.readFileSync(
-  path.join(__dirname, '../../migrations/sqlite_schema.sql'),
-  'utf8'
-);
-
-function tmpDbPath() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agx-proj-test-'));
-  return path.join(dir, 'test.db');
-}
-
-function makeDb(dbPath) {
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-  db.pragma('foreign_keys = ON');
-  db.exec(SCHEMA_SQL);
-  return db;
-}
-
-function insertTask(db, { userId, title = 'Test Task' } = {}) {
-  const id = `task-${Math.random().toString(36).slice(2)}`;
-  db.prepare(`
-    INSERT INTO tasks (id, user_id, content, title, status)
-    VALUES (?, ?, ?, ?, 'queued')
-  `).run(id, userId, 'content', title);
-  return id;
-}
-
-function insertAuditEvent(db, { taskId, userId, action, payload = {} } = {}) {
-  const id = `evt-${Math.random().toString(36).slice(2)}`;
-  db.prepare(`
-    INSERT INTO task_audit_log (id, task_id, user_id, action, payload, signature)
-    VALUES (?, ?, ?, ?, ?, 'sig')
-  `).run(id, taskId, userId, action, JSON.stringify(payload));
-  return id;
-}
-
-/**
- * Load projector module bound to a specific db instance (isolated module cache).
- */
-function loadProjectorWithDb(db) {
-  jest.resetModules();
-  jest.mock('@/lib/sqlite-query-adapter', () => ({
-    getSQLiteDb: () => db,
-    SqlExpression: class SqlExpression { constructor(e) { this.expr = e; } },
-    sqlExpr: (e) => ({ expr: e }),
-  }));
-  const cursors = require('@/lib/db/cursors');
-  const projector = require('@/lib/projectors/notificationProjector');
-  return { projector, cursors };
-}
-
-function countRows(db, table) {
-  return db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n;
-}
-
-module.exports = { tmpDbPath, makeDb, insertTask, insertAuditEvent, loadProjectorWithDb, countRows };

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/tests/projector/crash.test.js

@@ -1,139 +0,0 @@
-/**
- * @jest-environment node
- *
- * Crash/restart test: simulate mid-transaction kill by reloading the module
- * mid-stream and verify cursor durability + DB consistency.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { tmpDbPath, makeDb, insertTask, insertAuditEvent, loadProjectorWithDb, countRows } = require('./_helpers');
-
-describe('projector crash/restart test', () => {
-  let dbPath, db;
-
-  beforeEach(() => {
-    dbPath = tmpDbPath();
-    db = makeDb(dbPath);
-    jest.resetModules();
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(path.dirname(dbPath), { recursive: true });
-  });
-
-  test('cursor is durable across simulated restart', () => {
-    const { projector, cursors } = loadProjectorWithDb(db);
-    const userId = 'user-crash';
-    const taskId = insertTask(db, { userId });
-
-    // Insert 5 events
-    for (let i = 0; i < 5; i++) {
-      insertAuditEvent(db, { taskId, userId, action: 'complete' });
-    }
-
-    projector.runOnce();
-    const cursorAfterFirst = cursors.readCursor('notification_projector');
-    expect(cursorAfterFirst).toBeGreaterThan(0);
-    expect(countRows(db, 'notifications')).toBe(5);
-
-    // Simulate crash: reload module (in-memory debounce state is lost, cursor is from DB)
-    jest.resetModules();
-    jest.mock('@/lib/sqlite-query-adapter', () => ({
-      getSQLiteDb: () => db,
-      SqlExpression: class SqlExpression { constructor(e) { this.expr = e; } },
-      sqlExpr: (e) => ({ expr: e }),
-    }));
-    const projector2 = require('@/lib/projectors/notificationProjector');
-    const cursors2 = require('@/lib/db/cursors');
-
-    // Cursor must be persisted from previous run
-    expect(cursors2.readCursor('notification_projector')).toBe(cursorAfterFirst);
-
-    // Insert 3 more events
-    for (let i = 0; i < 3; i++) {
-      insertAuditEvent(db, { taskId, userId, action: 'fail' });
-    }
-
-    projector2.runOnce();
-    // Only the 3 new events are processed; the 5 old ones are not re-delivered
-    expect(countRows(db, 'notifications')).toBe(8);
-  });
-
-  test('DB is consistent after simulated crash at cursor boundary', () => {
-    const { projector, cursors } = loadProjectorWithDb(db);
-    const userId = 'user-boundary';
-    const taskIds = [
-      insertTask(db, { userId }),
-      insertTask(db, { userId }),
-    ];
-
-    // Insert exactly BATCH_SIZE (100) events across two tasks
-    for (let i = 0; i < 100; i++) {
-      insertAuditEvent(db, { taskId: taskIds[i % 2], userId, action: 'complete' });
-    }
-
-    projector.runOnce(); // processes 100
-    const cursor1 = cursors.readCursor('notification_projector');
-    const notifCount1 = countRows(db, 'notifications');
-    expect(notifCount1).toBe(100);
-
-    // Insert 50 more, then "crash" before processing
-    for (let i = 0; i < 50; i++) {
-      insertAuditEvent(db, { taskId: taskIds[i % 2], userId, action: 'fail' });
-    }
-
-    // Simulate crash: reload module without running
-    jest.resetModules();
-    jest.mock('@/lib/sqlite-query-adapter', () => ({
-      getSQLiteDb: () => db,
-      SqlExpression: class SqlExpression { constructor(e) { this.expr = e; } },
-      sqlExpr: (e) => ({ expr: e }),
-    }));
-    const projector3 = require('@/lib/projectors/notificationProjector');
-    const cursors3 = require('@/lib/db/cursors');
-
-    // Cursor still at 100-event boundary
-    expect(cursors3.readCursor('notification_projector')).toBe(cursor1);
-
-    // Process the 50 new events
-    projector3.runOnce();
-    expect(countRows(db, 'notifications')).toBe(150);
-  });
-
-  test('outbox and notifications stay in sync after restart', () => {
-    const { projector } = loadProjectorWithDb(db);
-    const userId = 'user-sync';
-    const taskId = insertTask(db, { userId });
-
-    for (let i = 0; i < 20; i++) {
-      insertAuditEvent(db, { taskId, userId, action: i % 2 === 0 ? 'complete' : 'fail' });
-    }
-
-    projector.runOnce();
-
-    const notifCount = countRows(db, 'notifications');
-    const outboxCount = countRows(db, 'notification_outbox');
-
-    // Every notification must have exactly one outbox entry
-    expect(notifCount).toBe(outboxCount);
-    expect(notifCount).toBe(20);
-
-    // Simulate restart
-    jest.resetModules();
-    jest.mock('@/lib/sqlite-query-adapter', () => ({
-      getSQLiteDb: () => db,
-      SqlExpression: class SqlExpression { constructor(e) { this.expr = e; } },
-      sqlExpr: (e) => ({ expr: e }),
-    }));
-    const projector2 = require('@/lib/projectors/notificationProjector');
-    projector2.runOnce(); // no-op — no new events
-
-    // Counts unchanged after restart + no-op run
-    expect(countRows(db, 'notifications')).toBe(notifCount);
-    expect(countRows(db, 'notification_outbox')).toBe(outboxCount);
-  });
-});