@siduri-x/api 2.0.13 → 2.0.14

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
-
-> @siduri-x/api@2.0.13 build /home/zagin/Projects/vxnus-studio/projects/siduri-x/apps/api
-> tsc
-
+
+> @siduri-x/api@2.0.14 build /home/zagin/Projects/vxnus-studio/projects/siduri-x/apps/api
+> tsc
+

package/.turbo/turbo-test.log

@@ -1,9 +1,9 @@
 
-> @siduri-x/api@2.0.13 test /home/zagin/Projects/vxnus-studio/projects/siduri-x/apps/api
+> @siduri-x/api@2.0.14 test /home/zagin/Projects/vxnus-studio/projects/siduri-x/apps/api
 > jest --config jest.config.json
 
-PASS src/context-mapper.test.ts (9.967 s)
-PASS src/runtime.test.ts (10.201 s)
+PASS src/context-mapper.test.ts (13.757 s)
+PASS src/runtime.test.ts (13.709 s)
   ● Console
 
     console.error
@@ -24,20 +24,20 @@ PASS src/runtime.test.ts (10.201 s)
       at PerceptionPipeline.execute (../../packages/core/dist/perception-pipeline.js:21:34)
       at Object.<anonymous> (src/runtime.test.ts:74:22)
 
-PASS src/t4-gating.test.ts (11.238 s)
-PASS src/knowledge.test.ts
-PASS src/t5-experience.test.ts (11.834 s)
+PASS src/t5-experience.test.ts (14.225 s)
+PASS src/t7-release.test.ts
+PASS src/boot.test.ts
 PASS src/auth.test.ts
 PASS src/b0-b6.test.ts
 PASS src/smoke.test.ts
-PASS src/teach-mode.test.ts (11.131 s)
-PASS src/boot.test.ts
-PASS src/index.test.ts (11.341 s)
-PASS src/t7-release.test.ts
-PASS src/t6-security.test.ts (11.765 s)
+PASS src/index.test.ts
+PASS src/knowledge.test.ts (16.426 s)
+PASS src/t4-gating.test.ts (17.057 s)
+PASS src/teach-mode.test.ts (17.48 s)
+PASS src/t6-security.test.ts (17.495 s)
 
 Test Suites: 13 passed, 13 total
-Tests:       92 passed, 92 total
+Tests:       94 passed, 94 total
 Snapshots:   0 total
-Time:        15.433 s
+Time:        21.275 s
 Ran all test suites.

package/dist/app.js

@@ -572,6 +572,225 @@ function createApp(runtimes = new Map()) {
             res.status(500).json({ error: e.message });
         }
     });
+    app.get('/knowledge/entities', auth_1.requireAuth, async (req, res) => {
+        const id = req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        const entityType = req.query.type;
+        const domain = req.query.domain;
+        if (!runtime.knowledge || !runtime.knowledge.entities) {
+            return res.json({ entities: [] });
+        }
+        try {
+            const entities = await runtime.knowledge.entities.getEntities(id, entityType, domain);
+            res.json({ entities });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/knowledge/events', auth_1.requireAuth, async (req, res) => {
+        const id = req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        const stream = req.query.stream;
+        const limit = Number(req.query.limit || 50);
+        if (!runtime.knowledge || !runtime.knowledge.events) {
+            return res.json({ events: [] });
+        }
+        try {
+            const events = await runtime.knowledge.events.getEvents(id, stream, limit);
+            res.json({ events });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/knowledge/tasks', auth_1.requireAuth, async (req, res) => {
+        const id = req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        const status = req.query.status;
+        if (!runtime.knowledge || !runtime.knowledge.tasks) {
+            return res.json({ tasks: [] });
+        }
+        try {
+            const tasks = await runtime.knowledge.tasks.getTasks(id, status);
+            res.json({ tasks });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/knowledge/proposals/approve', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        try {
+            if (typeof runtime.approveProposal === 'function') {
+                const result = await runtime.approveProposal(req.body.id, { companionId: id });
+                res.json({ approved: true, target: result?.target || 'knowledge', status: 'approved' });
+            }
+            else {
+                res.status(400).json({ error: 'Runtime does not support proposal approval' });
+            }
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/knowledge/entities', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        if (!runtime.knowledge || !runtime.knowledge.entities) {
+            return res.status(400).json({ error: 'Knowledge organ does not support entities' });
+        }
+        try {
+            const entity = {
+                id: req.body.id || `ent-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                companionId: id,
+                name: req.body.name,
+                entityType: req.body.entityType || req.body.type || 'entity',
+                domain: req.body.domain || 'general',
+                properties: req.body.properties || {},
+            };
+            await runtime.knowledge.entities.saveEntity(entity);
+            res.json({ saved: true, entity });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/knowledge/entities/delete', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        if (!runtime.knowledge || !runtime.knowledge.entities) {
+            return res.status(400).json({ error: 'Knowledge organ does not support entities' });
+        }
+        try {
+            const success = await runtime.knowledge.entities.deleteEntity(req.body.id);
+            res.json({ deleted: success, id: req.body.id });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/knowledge/tasks', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        if (!runtime.knowledge || !runtime.knowledge.tasks) {
+            return res.status(400).json({ error: 'Knowledge organ does not support tasks' });
+        }
+        try {
+            const task = {
+                id: req.body.id || `task-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                companionId: id,
+                title: req.body.title,
+                status: req.body.status || 'todo',
+                priority: req.body.priority !== undefined ? Number(req.body.priority) : 1,
+                targetDate: req.body.targetDate || null,
+                metadata: req.body.metadata || {},
+            };
+            await runtime.knowledge.tasks.saveTask(task);
+            res.json({ saved: true, task });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/knowledge/tasks/delete', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        if (!runtime.knowledge || !runtime.knowledge.tasks) {
+            return res.status(400).json({ error: 'Knowledge organ does not support tasks' });
+        }
+        try {
+            const success = await runtime.knowledge.tasks.deleteTask(req.body.id);
+            res.json({ deleted: success, id: req.body.id });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/knowledge/events', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        if (!runtime.knowledge || !runtime.knowledge.events) {
+            return res.status(400).json({ error: 'Knowledge organ does not support events' });
+        }
+        try {
+            const event = {
+                id: req.body.id || `evt-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                companionId: id,
+                stream: req.body.stream || 'default',
+                timestamp: req.body.timestamp || new Date().toISOString(),
+                metricValue: req.body.metricValue !== undefined && req.body.metricValue !== null ? Number(req.body.metricValue) : undefined,
+                metadata: req.body.metadata || {},
+            };
+            await runtime.knowledge.events.addEvent(event);
+            res.json({ saved: true, event });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/knowledge/schedule', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        if (!runtime.knowledge || !runtime.knowledge.schedule) {
+            return res.status(400).json({ error: 'Knowledge organ does not support schedule' });
+        }
+        try {
+            const item = {
+                id: req.body.id || `sched-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                companionId: id,
+                title: req.body.title,
+                startTime: req.body.startTime,
+                endTime: req.body.endTime || null,
+                isRecurring: Boolean(req.body.isRecurring),
+                status: req.body.status || 'active',
+            };
+            await runtime.knowledge.schedule.saveItem(item);
+            res.json({ saved: true, item });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/knowledge/schedule/delete', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: 'Companion not found' });
+        if (!runtime.knowledge || !runtime.knowledge.schedule) {
+            return res.status(400).json({ error: 'Knowledge organ does not support schedule' });
+        }
+        try {
+            const success = typeof runtime.knowledge.schedule.deleteItem === 'function'
+                ? await runtime.knowledge.schedule.deleteItem(req.body.id)
+                : false;
+            res.json({ deleted: success, id: req.body.id });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
     // MEMORY MUTATIONS - PROPOSALS
     app.post('/memory/proposals/update', auth_1.requireAuth, async (req, res) => {
         const id = req.body.companionId || Array.from(runtimes.keys())[0];
@@ -709,6 +928,42 @@ function createApp(runtimes = new Map()) {
             res.status(500).json({ error: e.message });
         }
     });
+    // SYSTEM LOGS
+    app.get('/system/logs', auth_1.requireAuth, async (req, res) => {
+        const id = req.query.id || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: "Companion not found" });
+        const level = req.query.level;
+        const subsystem = req.query.subsystem;
+        const q = req.query.q;
+        const limit = parseInt(req.query.limit || '100', 10);
+        const offset = parseInt(req.query.offset || '0', 10);
+        try {
+            const logs = typeof runtime.queryLogs === 'function'
+                ? runtime.queryLogs({ companionId: id, level, subsystem, q, limit, offset })
+                : [];
+            res.json({ logs });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message, logs: [] });
+        }
+    });
+    app.post('/system/logs/clear', auth_1.requireAuth, async (req, res) => {
+        const id = req.body.companionId || Array.from(runtimes.keys())[0];
+        const runtime = runtimes.get(id);
+        if (!runtime)
+            return res.status(404).json({ error: "Companion not found" });
+        try {
+            if (typeof runtime.clearLogs === 'function') {
+                runtime.clearLogs(id);
+            }
+            res.json({ cleared: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
     const isDevMode = process.env.NODE_ENV !== 'production' || process.env.SIDURI_DEV_MODE === 'true';
     if (isDevMode) {
         app.post('/dev/memory/reset', auth_1.requireAuth, async (req, res) => {

package/dist/boot.js

@@ -119,7 +119,7 @@ async function bootCompanion(id, config, options) {
     const vision = createVision(organs.vision || config?.vision);
     const behavior = createBehavior(organs.behavior || config?.behavior);
     const body = createBody(organs.body || config?.body);
-    const hands = createHands(organs.hands || config?.hands);
+    const hands = createHands({ ...(organs.hands || config?.hands), knowledge });
     const ear = createEar(organs.ear || config?.ear);
     const mouth = createMouth(organs.mouth || config?.mouth, voice);
     const observation = options?.observationOrgan;

package/dist/knowledge.test.js

@@ -40,10 +40,22 @@ describe('Life Database & UnifiedKnowledgeOrgan API Integration', () => {
                 };
             }),
         };
+        const memory = {
+            initialize: async () => { },
+            proposeClaim: async (claim) => knowledge.lifeDb.db.proposeClaim(claim),
+            getClaims: async (limit) => knowledge.lifeDb.db.getAllClaims(undefined, limit || 500),
+            getPendingClaims: async (limit) => knowledge.lifeDb.db.getAllClaims(undefined, limit || 500).filter((c) => c.status === 'pending'),
+            approveClaim: async (id) => knowledge.lifeDb.db.approveClaim(id),
+            rejectClaim: async (id) => knowledge.lifeDb.db.rejectClaim(id),
+            searchClaims: async () => [],
+            getApprovedClaims: async () => [],
+            getDirectives: async () => [],
+        };
         runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test Companion', organs: { knowledge: { provider: 'unified', dbPath: testDbPath } } }, {
             brain: mockBrain,
             knowledge,
             externalKnowledge: knowledge.eAdapter ?? knowledge,
+            memory,
         });
         await runtime.initialize();
         const runtimes = new Map([['test-comp', runtime]]);
@@ -135,4 +147,90 @@ describe('Life Database & UnifiedKnowledgeOrgan API Integration', () => {
         expect(lifeRes.status).toBe(200);
         expect(lifeRes.body.matchedInventory).toEqual([]);
     });
+    test('seeds and queries generic entities, events, and tasks', async () => {
+        // 1. Entities
+        await knowledge.entities.saveEntity({
+            id: 'ent-1',
+            companionId: 'test-comp',
+            name: 'Coffee Grinder',
+            entityType: 'item',
+            domain: 'kitchen',
+            properties: { burr: 'conical', setting: 14 },
+        });
+        const entRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/entities?id=test-comp&domain=kitchen')
+            .set(mockAuthHeader);
+        expect(entRes.status).toBe(200);
+        expect(entRes.body.entities).toHaveLength(1);
+        expect(entRes.body.entities[0].name).toBe('Coffee Grinder');
+        expect(entRes.body.entities[0].properties.setting).toBe(14);
+        // 2. Events
+        await knowledge.events.addEvent({
+            id: 'evt-1',
+            companionId: 'test-comp',
+            stream: 'health:heartrate',
+            timestamp: new Date().toISOString(),
+            metricValue: 72,
+            metadata: { unit: 'bpm' },
+        });
+        const evtRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/events?id=test-comp&stream=health:heartrate')
+            .set(mockAuthHeader);
+        expect(evtRes.status).toBe(200);
+        expect(evtRes.body.events).toHaveLength(1);
+        expect(evtRes.body.events[0].metricValue).toBe(72);
+        // 3. Tasks
+        await knowledge.tasks.saveTask({
+            id: 'task-1',
+            companionId: 'test-comp',
+            title: 'Order fresh espresso beans',
+            status: 'pending',
+            priority: 2,
+        });
+        const taskRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/tasks?id=test-comp&status=pending')
+            .set(mockAuthHeader);
+        expect(taskRes.status).toBe(200);
+        expect(taskRes.body.tasks).toHaveLength(1);
+        expect(taskRes.body.tasks[0].title).toBe('Order fresh espresso beans');
+    });
+    test('Truth Gate candidate proposal approval commits Life DB mutations', async () => {
+        // Stage a candidate proposal targeting Life DB
+        const proposal = await knowledge.lifeDb.db.proposeClaim({
+            id: 'prop-task-gate',
+            companionId: 'test-comp',
+            subject: 'task:buy-filter',
+            predicate: 'is',
+            value: 'Buy paper filters',
+            status: 'pending',
+            evidence: {
+                type: 'task',
+                title: 'Buy paper filters',
+                status: 'todo',
+                priority: 1,
+            },
+        });
+        expect(proposal.status).toBe('pending');
+        // Confirm it is not yet in tasks
+        const beforeRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/tasks?id=test-comp')
+            .set(mockAuthHeader);
+        expect(beforeRes.body.tasks.some((t) => t.title === 'Buy paper filters')).toBe(false);
+        // Approve via Truth Gate endpoint
+        const approveRes = await (0, supertest_1.default)(app)
+            .post('/knowledge/proposals/approve')
+            .set(mockAuthHeader)
+            .send({ companionId: 'test-comp', id: 'prop-task-gate' });
+        expect(approveRes.status).toBe(200);
+        expect(approveRes.body.approved).toBe(true);
+        expect(approveRes.body.target).toBe('knowledge');
+        // Confirm it is committed to Life DB tasks
+        const afterRes = await (0, supertest_1.default)(app)
+            .get('/knowledge/tasks?id=test-comp')
+            .set(mockAuthHeader);
+        expect(afterRes.status).toBe(200);
+        const approvedTask = afterRes.body.tasks.find((t) => t.title === 'Buy paper filters');
+        expect(approvedTask).toBeDefined();
+        expect(approvedTask.status).toBe('todo');
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siduri-x/api",
-  "version": "2.0.13",
+  "version": "2.0.14",
   "publishConfig": {
     "access": "public"
   },
@@ -13,13 +13,13 @@
     "dotenv": "^17.4.2",
     "express": "^5.2.1",
     "@siduri-x/body": "2.0.1",
-    "@siduri-x/brain": "2.0.6",
-    "@siduri-x/core": "2.0.10",
+    "@siduri-x/core": "2.0.11",
+    "@siduri-x/brain": "2.0.7",
     "@siduri-x/ear": "2.0.3",
     "@siduri-x/eknowledge": "2.0.1",
-    "@siduri-x/hands": "2.0.1",
+    "@siduri-x/hands": "2.0.2",
+    "@siduri-x/knowledge": "2.0.4",
     "@siduri-x/memory": "2.0.5",
-    "@siduri-x/knowledge": "2.0.3",
     "@siduri-x/mouth": "2.0.2",
     "@siduri-x/observation": "2.0.1",
     "@siduri-x/self": "2.0.7",

package/src/app.ts

@@ -611,6 +611,213 @@ export function createApp(runtimes: Map<string, SiduriRuntime> = new Map()): App
     }
   });
 
+  app.get('/knowledge/entities', requireAuth, async (req, res) => {
+    const id = (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    const entityType = req.query.type as string | undefined;
+    const domain = req.query.domain as string | undefined;
+    if (!runtime.knowledge || !(runtime.knowledge as any).entities) {
+      return res.json({ entities: [] });
+    }
+    try {
+      const entities = await (runtime.knowledge as any).entities.getEntities(id, entityType, domain);
+      res.json({ entities });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.get('/knowledge/events', requireAuth, async (req, res) => {
+    const id = (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    const stream = req.query.stream as string | undefined;
+    const limit = Number(req.query.limit || 50);
+    if (!runtime.knowledge || !(runtime.knowledge as any).events) {
+      return res.json({ events: [] });
+    }
+    try {
+      const events = await (runtime.knowledge as any).events.getEvents(id, stream, limit);
+      res.json({ events });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.get('/knowledge/tasks', requireAuth, async (req, res) => {
+    const id = (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    const status = req.query.status as string | undefined;
+    if (!runtime.knowledge || !(runtime.knowledge as any).tasks) {
+      return res.json({ tasks: [] });
+    }
+    try {
+      const tasks = await (runtime.knowledge as any).tasks.getTasks(id, status);
+      res.json({ tasks });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/knowledge/proposals/approve', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    try {
+      if (typeof (runtime as any).approveProposal === 'function') {
+        const result = await (runtime as any).approveProposal(req.body.id, { companionId: id });
+        res.json({ approved: true, target: result?.target || 'knowledge', status: 'approved' });
+      } else {
+        res.status(400).json({ error: 'Runtime does not support proposal approval' });
+      }
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/knowledge/entities', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    if (!runtime.knowledge || !(runtime.knowledge as any).entities) {
+      return res.status(400).json({ error: 'Knowledge organ does not support entities' });
+    }
+    try {
+      const entity = {
+        id: req.body.id || `ent-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        companionId: id,
+        name: req.body.name,
+        entityType: req.body.entityType || req.body.type || 'entity',
+        domain: req.body.domain || 'general',
+        properties: req.body.properties || {},
+      };
+      await (runtime.knowledge as any).entities.saveEntity(entity);
+      res.json({ saved: true, entity });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/knowledge/entities/delete', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    if (!runtime.knowledge || !(runtime.knowledge as any).entities) {
+      return res.status(400).json({ error: 'Knowledge organ does not support entities' });
+    }
+    try {
+      const success = await (runtime.knowledge as any).entities.deleteEntity(req.body.id);
+      res.json({ deleted: success, id: req.body.id });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/knowledge/tasks', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    if (!runtime.knowledge || !(runtime.knowledge as any).tasks) {
+      return res.status(400).json({ error: 'Knowledge organ does not support tasks' });
+    }
+    try {
+      const task = {
+        id: req.body.id || `task-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        companionId: id,
+        title: req.body.title,
+        status: req.body.status || 'todo',
+        priority: req.body.priority !== undefined ? Number(req.body.priority) : 1,
+        targetDate: req.body.targetDate || null,
+        metadata: req.body.metadata || {},
+      };
+      await (runtime.knowledge as any).tasks.saveTask(task);
+      res.json({ saved: true, task });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/knowledge/tasks/delete', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    if (!runtime.knowledge || !(runtime.knowledge as any).tasks) {
+      return res.status(400).json({ error: 'Knowledge organ does not support tasks' });
+    }
+    try {
+      const success = await (runtime.knowledge as any).tasks.deleteTask(req.body.id);
+      res.json({ deleted: success, id: req.body.id });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/knowledge/events', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    if (!runtime.knowledge || !(runtime.knowledge as any).events) {
+      return res.status(400).json({ error: 'Knowledge organ does not support events' });
+    }
+    try {
+      const event = {
+        id: req.body.id || `evt-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        companionId: id,
+        stream: req.body.stream || 'default',
+        timestamp: req.body.timestamp || new Date().toISOString(),
+        metricValue: req.body.metricValue !== undefined && req.body.metricValue !== null ? Number(req.body.metricValue) : undefined,
+        metadata: req.body.metadata || {},
+      };
+      await (runtime.knowledge as any).events.addEvent(event);
+      res.json({ saved: true, event });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/knowledge/schedule', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    if (!runtime.knowledge || !(runtime.knowledge as any).schedule) {
+      return res.status(400).json({ error: 'Knowledge organ does not support schedule' });
+    }
+    try {
+      const item = {
+        id: req.body.id || `sched-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        companionId: id,
+        title: req.body.title,
+        startTime: req.body.startTime,
+        endTime: req.body.endTime || null,
+        isRecurring: Boolean(req.body.isRecurring),
+        status: req.body.status || 'active',
+      };
+      await (runtime.knowledge as any).schedule.saveItem(item);
+      res.json({ saved: true, item });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/knowledge/schedule/delete', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: 'Companion not found' });
+    if (!runtime.knowledge || !(runtime.knowledge as any).schedule) {
+      return res.status(400).json({ error: 'Knowledge organ does not support schedule' });
+    }
+    try {
+      const success = typeof (runtime.knowledge as any).schedule.deleteItem === 'function'
+        ? await (runtime.knowledge as any).schedule.deleteItem(req.body.id)
+        : false;
+      res.json({ deleted: success, id: req.body.id });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
   // MEMORY MUTATIONS - PROPOSALS
   app.post('/memory/proposals/update', requireAuth, async (req, res) => {
     const id = req.body.companionId as string || Array.from(runtimes.keys())[0];
@@ -730,6 +937,40 @@ export function createApp(runtimes: Map<string, SiduriRuntime> = new Map()): App
     }
   });
 
+  // SYSTEM LOGS
+  app.get('/system/logs', requireAuth, async (req, res) => {
+    const id = (req.query.id as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: "Companion not found" });
+    const level = req.query.level as string | undefined;
+    const subsystem = req.query.subsystem as string | undefined;
+    const q = req.query.q as string | undefined;
+    const limit = parseInt((req.query.limit as string) || '100', 10);
+    const offset = parseInt((req.query.offset as string) || '0', 10);
+    try {
+      const logs = typeof runtime.queryLogs === 'function'
+        ? runtime.queryLogs({ companionId: id, level, subsystem, q, limit, offset })
+        : [];
+      res.json({ logs });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message, logs: [] });
+    }
+  });
+
+  app.post('/system/logs/clear', requireAuth, async (req, res) => {
+    const id = (req.body.companionId as string) || Array.from(runtimes.keys())[0];
+    const runtime = runtimes.get(id);
+    if (!runtime) return res.status(404).json({ error: "Companion not found" });
+    try {
+      if (typeof runtime.clearLogs === 'function') {
+        runtime.clearLogs(id);
+      }
+      res.json({ cleared: true });
+    } catch (e: any) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
   const isDevMode = process.env.NODE_ENV !== 'production' || process.env.SIDURI_DEV_MODE === 'true';
   if (isDevMode) {
     app.post('/dev/memory/reset', requireAuth, async (req, res) => {

package/src/boot.ts

@@ -160,7 +160,7 @@ export async function bootCompanion(
   const vision = createVision(organs.vision || config?.vision);
   const behavior = createBehavior(organs.behavior || config?.behavior);
   const body = createBody(organs.body || config?.body);
-  const hands = createHands(organs.hands || config?.hands);
+  const hands = createHands({ ...((organs.hands || config?.hands) as any), knowledge });
   const ear = createEar(organs.ear || config?.ear);
   const mouth = createMouth(organs.mouth || config?.mouth, voice);
   const observation = options?.observationOrgan;

package/src/knowledge.test.ts

@@ -38,6 +38,19 @@ describe('Life Database & UnifiedKnowledgeOrgan API Integration', () => {
       }),
     };
 
+    const memory: any = {
+      initialize: async () => {},
+      proposeClaim: async (claim: any) => (knowledge.lifeDb as any).db.proposeClaim(claim),
+      getClaims: async (limit?: number) => (knowledge.lifeDb as any).db.getAllClaims(undefined, limit || 500),
+      getPendingClaims: async (limit?: number) =>
+        (knowledge.lifeDb as any).db.getAllClaims(undefined, limit || 500).filter((c: any) => c.status === 'pending'),
+      approveClaim: async (id: string) => (knowledge.lifeDb as any).db.approveClaim(id),
+      rejectClaim: async (id: string) => (knowledge.lifeDb as any).db.rejectClaim(id),
+      searchClaims: async () => [],
+      getApprovedClaims: async () => [],
+      getDirectives: async () => [],
+    };
+
     runtime = new SiduriRuntime(
       'test-comp',
       { name: 'Test Companion', organs: { knowledge: { provider: 'unified', dbPath: testDbPath } } } as any,
@@ -45,6 +58,7 @@ describe('Life Database & UnifiedKnowledgeOrgan API Integration', () => {
         brain: mockBrain,
         knowledge,
         externalKnowledge: knowledge.eAdapter ?? knowledge,
+        memory,
       }
     );
     await runtime.initialize();
@@ -153,4 +167,101 @@ describe('Life Database & UnifiedKnowledgeOrgan API Integration', () => {
     expect(lifeRes.status).toBe(200);
     expect(lifeRes.body.matchedInventory).toEqual([]);
   });
+
+  test('seeds and queries generic entities, events, and tasks', async () => {
+    // 1. Entities
+    await knowledge.entities.saveEntity({
+      id: 'ent-1',
+      companionId: 'test-comp',
+      name: 'Coffee Grinder',
+      entityType: 'item',
+      domain: 'kitchen',
+      properties: { burr: 'conical', setting: 14 },
+    });
+
+    const entRes = await request(app)
+      .get('/knowledge/entities?id=test-comp&domain=kitchen')
+      .set(mockAuthHeader);
+    expect(entRes.status).toBe(200);
+    expect(entRes.body.entities).toHaveLength(1);
+    expect(entRes.body.entities[0].name).toBe('Coffee Grinder');
+    expect(entRes.body.entities[0].properties.setting).toBe(14);
+
+    // 2. Events
+    await knowledge.events.addEvent({
+      id: 'evt-1',
+      companionId: 'test-comp',
+      stream: 'health:heartrate',
+      timestamp: new Date().toISOString(),
+      metricValue: 72,
+      metadata: { unit: 'bpm' },
+    });
+
+    const evtRes = await request(app)
+      .get('/knowledge/events?id=test-comp&stream=health:heartrate')
+      .set(mockAuthHeader);
+    expect(evtRes.status).toBe(200);
+    expect(evtRes.body.events).toHaveLength(1);
+    expect(evtRes.body.events[0].metricValue).toBe(72);
+
+    // 3. Tasks
+    await knowledge.tasks.saveTask({
+      id: 'task-1',
+      companionId: 'test-comp',
+      title: 'Order fresh espresso beans',
+      status: 'pending',
+      priority: 2,
+    });
+
+    const taskRes = await request(app)
+      .get('/knowledge/tasks?id=test-comp&status=pending')
+      .set(mockAuthHeader);
+    expect(taskRes.status).toBe(200);
+    expect(taskRes.body.tasks).toHaveLength(1);
+    expect(taskRes.body.tasks[0].title).toBe('Order fresh espresso beans');
+  });
+
+  test('Truth Gate candidate proposal approval commits Life DB mutations', async () => {
+    // Stage a candidate proposal targeting Life DB
+    const proposal = await (knowledge.lifeDb as any).db.proposeClaim({
+      id: 'prop-task-gate',
+      companionId: 'test-comp',
+      subject: 'task:buy-filter',
+      predicate: 'is',
+      value: 'Buy paper filters',
+      status: 'pending',
+      evidence: {
+        type: 'task',
+        title: 'Buy paper filters',
+        status: 'todo',
+        priority: 1,
+      },
+    });
+    expect(proposal.status).toBe('pending');
+
+    // Confirm it is not yet in tasks
+    const beforeRes = await request(app)
+      .get('/knowledge/tasks?id=test-comp')
+      .set(mockAuthHeader);
+    expect(beforeRes.body.tasks.some((t: any) => t.title === 'Buy paper filters')).toBe(false);
+
+    // Approve via Truth Gate endpoint
+    const approveRes = await request(app)
+      .post('/knowledge/proposals/approve')
+      .set(mockAuthHeader)
+      .send({ companionId: 'test-comp', id: 'prop-task-gate' });
+
+    expect(approveRes.status).toBe(200);
+    expect(approveRes.body.approved).toBe(true);
+    expect(approveRes.body.target).toBe('knowledge');
+
+    // Confirm it is committed to Life DB tasks
+    const afterRes = await request(app)
+      .get('/knowledge/tasks?id=test-comp')
+      .set(mockAuthHeader);
+    expect(afterRes.status).toBe(200);
+    const approvedTask = afterRes.body.tasks.find((t: any) => t.title === 'Buy paper filters');
+    expect(approvedTask).toBeDefined();
+    expect(approvedTask.status).toBe('todo');
+  });
 });