✨ feat(claw): add context tools, deny escalation, batch audit, hot-reload config

- claw_set_context/claw_get_context tools for persistent working memory (180 total tools)
- denyEscalation API endpoint (POST /claws/:id/deny-escalation) with reason param
- Batch audit log inserts (single query instead of N serial writes)
- Hot-reload config on PUT /claws/:id (updateClawConfig in manager)
- Auto-fail state after 5 consecutive errors (vs auto-pause)
- Idle cycle tracking and cleanup (90d history,

Author: ersinkoc

packages/core/src/agent/tools/tool-tags.test.ts

@@ -1072,12 +1072,13 @@ describe('TOOL_SEARCH_TAGS — aggregate statistics', () => {
     }
   });
 
-  it('the exact tool count matches the source (159 tools)', () => {
+  it('the exact tool count matches the source (180 tools)', () => {
     // Count from source: email(6) + git(7) + memory(7) + tasks(6) + notes(5) +
     // calendar(5) + contacts(5) + bookmarks(5) + expenses(8) + habits(8) +
     // files(8) + web(4) + code(5) + image(3) + audio(5) + pdf(3) + goals(8) +
     // extraction(2) + custom_data(11) + weather(2) + utility(22) +
-    // dynamic(8) + config(3) + triggers(6) + plans(7) = 159
-    expect(Object.keys(TOOL_SEARCH_TAGS).length).toBe(159);
+    // dynamic(8) + config(3) + triggers(6) + plans(7) + claw(16) + subagent(6) + crew(3) +
+    // fleet(7) + mcp(7) + souls(3) = 180
+    expect(Object.keys(TOOL_SEARCH_TAGS).length).toBe(180);
   });
 });

packages/core/src/agent/tools/tool-tags.ts

@@ -351,6 +351,8 @@ export const TOOL_SEARCH_TAGS: Record<string, readonly string[]> = {
   claw_update_config: ['claw', 'config', 'update', 'self', 'adapt', 'modify', 'settings'],
   claw_send_agent_message: ['claw', 'message', 'send', 'agent', 'communicate', 'inbox'],
   claw_reflect: ['claw', 'reflect', 'evaluate', 'introspect', 'performance', 'progress'],
+  claw_set_context: ['claw', 'context', 'set', 'memory', 'persistent', 'working memory', 'state'],
+  claw_get_context: ['claw', 'context', 'get', 'memory', 'retrieve', 'working memory', 'state'],
   create_claw: ['claw', 'create', 'agent', 'autonomous', 'spawn', 'new'],
   list_claws: ['claw', 'list', 'status', 'agents', 'running'],
   start_claw: ['claw', 'start', 'run', 'begin', 'launch'],

packages/core/src/services/claw-types.ts

@@ -255,6 +255,7 @@ export interface IClawService {
 
   // ---- Escalation ----
   approveEscalation(clawId: string, userId: string): Promise<boolean>;
+  denyEscalation(clawId: string, userId: string, reason?: string): Promise<boolean>;
 
   // ---- Service Lifecycle ----
   start(): Promise<void>;

packages/gateway/src/db/migrations/postgres/001_initial_schema.sql

@@ -1131,7 +1131,7 @@ CREATE TABLE IF NOT EXISTS claws (
   user_id TEXT NOT NULL DEFAULT 'default',
   name TEXT NOT NULL,
   mission TEXT NOT NULL,
-  mode TEXT NOT NULL DEFAULT 'cyclic',
+  mode TEXT NOT NULL DEFAULT 'continuous',
   allowed_tools JSONB DEFAULT '[]',
   limits JSONB NOT NULL DEFAULT '{}',
   interval_ms INTEGER,

packages/gateway/src/db/migrations/postgres/022_claws.sql

@@ -7,7 +7,7 @@ CREATE TABLE IF NOT EXISTS claws (
   user_id TEXT NOT NULL DEFAULT 'default',
   name TEXT NOT NULL,
   mission TEXT NOT NULL,
-  mode TEXT NOT NULL DEFAULT 'cyclic',
+  mode TEXT NOT NULL DEFAULT 'continuous',
   allowed_tools JSONB DEFAULT '[]',
   limits JSONB NOT NULL DEFAULT '{}',
   interval_ms INTEGER,

packages/gateway/src/db/migrations/postgres/023_claw_fixes.sql

@@ -0,0 +1,7 @@
+-- Claw fixes migration
+-- 1. Fix mode column default: 'cyclic' is not a valid ClawMode, correct to 'continuous'
+-- 2. Fix any existing rows stuck with mode='cyclic'
+
+ALTER TABLE claws ALTER COLUMN mode SET DEFAULT 'continuous';
+
+UPDATE claws SET mode = 'continuous' WHERE mode = 'cyclic';

packages/gateway/src/db/repositories/claws.ts

@@ -592,9 +592,33 @@ export class ClawsRepository extends BaseRepository {
     durationMs: number;
     category?: string;
   }>): Promise<void> {
+    if (entries.length === 0) return;
+
+    // Single batch INSERT instead of N serial queries
+    const valuePlaceholders: string[] = [];
+    const params: unknown[] = [];
+    let idx = 1;
+
     for (const entry of entries) {
-      await this.saveAuditEntry(entry);
+      valuePlaceholders.push(`($${idx++}, $${idx++}, $${idx++}, $${idx++}, $${idx++}, $${idx++}, $${idx++}, $${idx++}, $${idx++})`);
+      params.push(
+        generateId('aud'),
+        entry.clawId,
+        entry.cycleNumber,
+        entry.toolName,
+        JSON.stringify(entry.toolArgs),
+        (entry.toolResult ?? '').slice(0, 10_000),
+        entry.success,
+        entry.durationMs,
+        entry.category ?? this.categorizeToolCall(entry.toolName)
+      );
     }
+
+    await this.execute(
+      `INSERT INTO claw_audit_log (id, claw_id, cycle_number, tool_name, tool_args, tool_result, success, duration_ms, category)
+       VALUES ${valuePlaceholders.join(', ')}`,
+      params
+    );
   }
 
   async getAuditLog(

packages/gateway/src/routes/channels-groups.test.ts

@@ -14,13 +14,16 @@ import { requestId } from '../middleware/request-id.js';
 import { errorHandler } from '../middleware/error-handler.js';
 
 // Mock Channel Service
-const mockGetChannel = vi.fn();
-const mockGetStatus = vi.fn();
-const mockListGroups = vi.fn();
-const mockGetGroup = vi.fn();
-const mockFetchGroupHistory = vi.fn();
+const { mockGetChannel, mockGetStatus, mockListGroups, mockGetGroup, mockFetchGroupHistory } = vi.hoisted(() => ({
+  mockGetChannel: vi.fn(),
+  mockGetStatus: vi.fn(),
+  mockListGroups: vi.fn(),
+  mockGetGroup: vi.fn(),
+  mockFetchGroupHistory: vi.fn(),
+}));
 
-vi.mock('@ownpilot/core', () => ({
+vi.mock('@ownpilot/core', async (importOriginal) => ({
+  ...await importOriginal<Record<string, unknown>>(),
   getChannelService: vi.fn().mockReturnValue({
     getChannel: mockGetChannel,
   }),

packages/gateway/src/routes/claws.test.ts

@@ -17,6 +17,13 @@ vi.mock('../services/claw-service.js', () => ({
   getClawService: mockGetClawService,
 }));
 
+const mockGetClawManager = vi.fn().mockReturnValue({
+  updateClawConfig: vi.fn(),
+});
+vi.mock('../services/claw-manager.js', () => ({
+  getClawManager: mockGetClawManager,
+}));
+
 vi.mock('./helpers.js', async (importOriginal) => {
   const actual = await importOriginal<Record<string, unknown>>();
   return {
@@ -58,6 +65,7 @@ function createMockService() {
     getHistory: vi.fn(),
     sendMessage: vi.fn(),
     approveEscalation: vi.fn(),
+    denyEscalation: vi.fn(),
   };
 }
 
@@ -351,4 +359,35 @@ describe('Claws Routes', () => {
       expect(res.status).toBe(404);
     });
   });
+
+  describe('POST /claws/:id/deny-escalation', () => {
+    it('should deny escalation', async () => {
+      service.denyEscalation.mockResolvedValue(true);
+
+      const res = await app.request('/claws/claw-1/deny-escalation', { method: 'POST' });
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.data.denied).toBe(true);
+    });
+
+    it('should pass reason to service', async () => {
+      service.denyEscalation.mockResolvedValue(true);
+
+      const res = await app.request('/claws/claw-1/deny-escalation', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ reason: 'Not needed' }),
+      });
+      expect(res.status).toBe(200);
+      expect(service.denyEscalation).toHaveBeenCalledWith('claw-1', 'user-1', 'Not needed');
+    });
+
+    it('should return 404 if no pending escalation', async () => {
+      service.denyEscalation.mockResolvedValue(false);
+
+      const res = await app.request('/claws/claw-1/deny-escalation', { method: 'POST' });
+      expect(res.status).toBe(404);
+    });
+  });
 });

packages/gateway/src/routes/claws.ts

@@ -304,6 +304,28 @@ clawRoutes.post('/:id/approve-escalation', async (c) => {
   }
 });
 
+// POST /:id/deny-escalation
+clawRoutes.post('/:id/deny-escalation', async (c) => {
+  try {
+    const userId = getUserId(c);
+    const { id } = c.req.param();
+    const body = await c.req.json().catch(() => ({}));
+    const reason = typeof body.reason === 'string' ? body.reason : undefined;
+    const service = getClawService();
+
+    const denied = await service.denyEscalation(id, userId, reason);
+    if (!denied) {
+      return apiError(c, {
+        code: ERROR_CODES.NOT_FOUND,
+        message: 'No pending escalation or claw not found',
+      }, 404);
+    }
+    return apiResponse(c, { denied: true });
+  } catch (err) {
+    return apiError(c, { code: ERROR_CODES.INTERNAL_ERROR, message: getErrorMessage(err) }, 500);
+  }
+});
+
 // =============================================================================
 // 3. GENERIC DYNAMIC ROUTE (must be last)
 // =============================================================================
@@ -357,6 +379,11 @@ clawRoutes.put('/:id', async (c) => {
     if (!updated) {
       return apiError(c, { code: ERROR_CODES.NOT_FOUND, message: 'Claw not found' }, 404);
     }
+
+    // Hot-reload in-memory config so changes take effect without restart
+    const { getClawManager } = await import('../services/claw-manager.js');
+    getClawManager().updateClawConfig(id, updated);
+
     return apiResponse(c, updated);
   } catch (err) {
     return apiError(c, { code: ERROR_CODES.INTERNAL_ERROR, message: getErrorMessage(err) }, 500);