clawmatrix 0.4.2 → 0.5.0

package/src/cluster-service.ts

@@ -15,10 +15,15 @@ import { ToolProxy, type GatewayInfo } from "./tool-proxy.ts";
 import { AcpProxy, readAllSessionStoresFromDisk } from "./acp-proxy.ts";
 import { TerminalManager } from "./terminal.ts";
 import { FileTransferManager } from "./file-transfer.ts";
-import { WebHandler } from "./web.ts";
+import { ApiHandler } from "./api.ts";
 import { KnowledgeSync } from "./knowledge-sync.ts";
 import { HealthTracker } from "./health-tracker.ts";
+import { KanbanManager } from "./kanban.ts";
 import { SentinelManager } from "./sentinel-manager.ts";
+import { AutomationManager } from "./automation.ts";
+import { Store } from "./store.ts";
+import { LogReplicator } from "./log-replication.ts";
+import { setAuditStore } from "./audit.ts";
 import type {
   AnyClusterFrame,
   HandoffRequest,
@@ -30,7 +35,6 @@ import type {
   HandoffInputRequired,
   HandoffInput,
   KnowledgeSyncFrame,
-  HealthSyncFrame,
   AvailabilityRequest,
   AvailabilityResponse,
   ModelRequest,
@@ -71,6 +75,9 @@ import type {
   FileTransferChunk,
   FileTransferChunkAck,
   FileTransferComplete,
+  KanbanSyncFrame,
+  KanbanNotifyFrame,
+  LogSyncFrame,
 } from "./types.ts";
 
 function resolveGatewayInfo(openclawConfig: OpenClawConfig): GatewayInfo {
@@ -96,8 +103,15 @@ export class ClusterRuntime {
   readonly terminalManager: TerminalManager;
   readonly fileTransferManager: FileTransferManager | null;
   knowledgeSync: KnowledgeSync | null = null;
+  /** Resolved workspace path (null if not configured). */
+  workspacePath: string | null = null;
   healthTracker: HealthTracker;
-  webHandler: WebHandler | null = null;
+  kanbanManager: KanbanManager | null = null;
+  apiHandler: ApiHandler | null = null;
+  automationManager: AutomationManager | null = null;
+  store: Store | null = null;
+  logReplicator: LogReplicator | null = null;
+  private storeCleanupTimer: ReturnType<typeof setInterval> | null = null;
   private sentinelManager: SentinelManager | null = null;
   private logger: PluginLogger;
   private openclawConfig: OpenClawConfig;
@@ -113,7 +127,7 @@ export class ClusterRuntime {
     this.logger = logger;
     this.openclawConfig = openclawConfig;
     const gatewayInfo = resolveGatewayInfo(openclawConfig);
-    this.peerManager = new PeerManager(config, openclawVersion);
+    this.peerManager = new PeerManager(config, openclawVersion, openclawConfig as Record<string, unknown>);
     this.handoffManager = new HandoffManager(config, this.peerManager, gatewayInfo);
     this.modelProxy = new ModelProxy(config, this.peerManager, gatewayInfo, openclawConfig);
     this.toolProxy = new ToolProxy(config, this.peerManager, gatewayInfo, logger);
@@ -126,7 +140,6 @@ export class ClusterRuntime {
       : null;
     this.healthTracker = new HealthTracker({
       nodeId: config.nodeId,
-      peerManager: this.peerManager,
     });
     // Build agent indexes
     for (const a of config.agents) {
@@ -169,19 +182,48 @@ export class ClusterRuntime {
       this.trackRelayPeerHealth();
     });
 
-    // Web dashboard (must be set before peerManager.start() creates the HTTP server)
-    if (this.config.web?.enabled) {
-      this.webHandler = new WebHandler(this.config, this.peerManager, this.handoffManager);
-      this.peerManager.setHttpHandler((req, res) => this.webHandler!.handle(req, res));
-      // Enable satellite tool routing through WebHandler
-      this.toolProxy.setSatelliteHandler(this.webHandler);
-      this.webHandler.setHealthTracker(this.healthTracker);
-      this.logger.info(`[clawmatrix] Web dashboard enabled on listen port`);
+    // HTTP API (must be set before peerManager.start() creates the HTTP server)
+    if (this.config.listen) {
+      this.apiHandler = new ApiHandler(this.config, this.peerManager, this.handoffManager);
+      this.peerManager.setHttpHandler((req, res) => this.apiHandler!.handle(req, res));
+      // Enable satellite tool routing through ApiHandler
+      this.toolProxy.setSatelliteHandler(this.apiHandler);
+      this.apiHandler.setHealthTracker(this.healthTracker);
+      this.logger.info(`[clawmatrix] HTTP API enabled on listen port`);
     }
 
+    // Automation manager (always enabled — no rules = no overhead)
+    {
+      const workspacePath = this.resolveWorkspacePath();
+      const stateDir = workspacePath
+        ? path.join(workspacePath, ".clawmatrix")
+        : null;
+      if (stateDir) {
+        const automationsPath = path.join(stateDir, "automations.json");
+        this.automationManager = new AutomationManager(
+          automationsPath, this.handoffManager, this.peerManager, this.config.nodeId,
+        );
+        if (this.apiHandler) {
+          this.apiHandler.setAutomationManager(this.automationManager);
+        }
+        this.automationManager.setToolInvoker(this.toolProxy);
+        this.automationManager.start().catch((err) => {
+          this.logger.error(`[clawmatrix] Automation manager failed to start: ${err}`);
+        });
+      }
+    }
+
+    // Resolve workspace path (used by knowledge sync)
+    this.workspacePath = this.resolveWorkspacePath();
+
     // Knowledge sync
     if (this.config.knowledge?.enabled) {
-      const workspacePath = this.resolveWorkspacePath();
+      // Advertise "knowledge" capability so peers can detect it
+      if (!this.config.tags.includes("knowledge")) {
+        this.config.tags.push("knowledge");
+      }
+
+      const workspacePath = this.workspacePath;
       if (workspacePath) {
         const stateDir = path.join(workspacePath, ".clawmatrix");
         this.knowledgeSync = new KnowledgeSync({
@@ -198,6 +240,9 @@ export class ClusterRuntime {
         }).catch((err) => {
           this.logger.error(`[clawmatrix] Knowledge sync failed to start: ${err}`);
         });
+        if (this.apiHandler) {
+          this.apiHandler.setKnowledgeSync(this.knowledgeSync);
+        }
 
         // Sync with peers on connect/disconnect
         this.peerManager.on("peerConnected", (nodeId) => {
@@ -206,6 +251,20 @@ export class ClusterRuntime {
         this.peerManager.on("peerDisconnected", (nodeId) => {
           this.knowledgeSync?.removePeerSync(nodeId);
         });
+
+        // Wire ACP tool write attribution to knowledge-sync
+        if (this.acpProxy) {
+          const ks = this.knowledgeSync;
+          const nodeId = this.config.nodeId;
+          const agentTypeMap: Record<string, string> = { claude: "Claude Code", codex: "Codex", gemini: "Gemini CLI" };
+          this.acpProxy.onToolWrite = (filePath, agentId) => {
+            ks.setPendingAttribution(filePath, {
+              nodeId,
+              agentId,
+              agentType: agentTypeMap[agentId] ?? agentId,
+            });
+          };
+        }
       }
     }
 
@@ -222,11 +281,87 @@ export class ClusterRuntime {
       });
     }
 
+    // SQLite store + log replication
+    {
+      const workspacePath = this.resolveWorkspacePath();
+      const stateDir = workspacePath
+        ? path.join(workspacePath, ".clawmatrix")
+        : path.join(process.env.HOME ?? process.env.USERPROFILE ?? "/tmp", ".openclaw", "clawmatrix");
+      try {
+        this.store = new Store(path.join(stateDir, "clawmatrix.db"));
+        this.logReplicator = new LogReplicator({
+          store: this.store,
+          nodeId: this.config.nodeId,
+          sendTo: (peerId, frame) => this.peerManager.sendTo(peerId, frame),
+        });
+
+        this.peerManager.on("peerConnected", (nodeId) => {
+          this.logReplicator?.initPeerSync(nodeId);
+        });
+        this.peerManager.on("peerDisconnected", (nodeId) => {
+          this.logReplicator?.removePeerSync(nodeId);
+        });
+
+        // Periodic TTL cleanup (every 24h)
+        const retentionMs = (this.config.store?.retentionDays ?? 90) * 86400_000;
+        this.storeCleanupTimer = setInterval(() => {
+          const cutoff = Date.now() - retentionMs;
+          const result = this.store?.cleanup(cutoff);
+          if (result) {
+            const total = result.audit + result.health + result.handoff + result.satellite + result.ingested + result.automation;
+            if (total > 0) this.logger.info(`[clawmatrix] Store cleanup: ${total} old rows removed`);
+          }
+        }, 86400_000);
+
+        // Wire subsystems to store for persistence
+        setAuditStore(this.store, this.config.nodeId, this.logReplicator!);
+        this.handoffManager.store = this.store;
+        this.handoffManager.logReplicator = this.logReplicator;
+        this.healthTracker.setStore(this.store, this.logReplicator!);
+        if (this.acpProxy) this.acpProxy.store = this.store;
+        this.apiHandler?.setStore(this.store);
+        this.automationManager?.setStore(this.store);
+
+        this.logger.info(`[clawmatrix] Store initialized at ${stateDir}/clawmatrix.db`);
+      } catch (err) {
+        this.logger.warn(`[clawmatrix] Store initialization failed (non-fatal): ${err}`);
+      }
+    }
+
     // Health tracker (always enabled, no config gate)
     this.healthTracker.start().catch((err) => {
       this.logger.error(`[clawmatrix] Health tracker failed to start: ${err}`);
     });
 
+    // Kanban board
+    if (this.config.kanban?.enabled) {
+      const workspacePath = this.resolveWorkspacePath();
+      const stateDir = workspacePath
+        ? path.join(workspacePath, ".clawmatrix")
+        : undefined;
+      this.kanbanManager = new KanbanManager({
+        nodeId: this.config.nodeId,
+        peerManager: this.peerManager,
+        prefix: this.config.kanban.prefix,
+        autoAssign: this.config.kanban.autoAssign,
+        archiveAfterMs: this.config.kanban.archiveAfterMs,
+        stateDir,
+      });
+      this.kanbanManager.start().catch((err) => {
+        this.logger.error(`[clawmatrix] Kanban manager failed to start: ${err}`);
+      });
+      if (this.apiHandler) {
+        this.apiHandler.setKanbanManager(this.kanbanManager);
+      }
+
+      this.peerManager.on("peerConnected", (nodeId) => {
+        this.kanbanManager?.initPeerSync(nodeId);
+      });
+      this.peerManager.on("peerDisconnected", (nodeId) => {
+        this.kanbanManager?.removePeerSync(nodeId);
+      });
+    }
+
     // Sentinel: detached subprocess for diagnostics when gateway dies.
     // Default on; starts when not explicitly disabled AND (has outbound peers OR gateway is a listener for port takeover)
     const sentinelEnabled = (this.config.sentinel?.enabled ?? true) && (this.config.peers.length > 0 || this.config.listen);
@@ -299,15 +434,21 @@ export class ClusterRuntime {
   }
 
   private async stopInternal() {
+    this.automationManager?.stop();
     await this.healthTracker.stop();
+    await this.kanbanManager?.stop();
     await this.knowledgeSync?.stop();
     this.syncCleanup();
     await this.peerManager.stop();
+    // Close store after all subsystems are done
+    if (this.storeCleanupTimer) { clearInterval(this.storeCleanupTimer); this.storeCleanupTimer = null; }
+    this.logReplicator?.destroy();
+    this.store?.close();
   }
 
   /** Synchronous cleanup that never blocks. */
   private syncCleanup() {
-    this.webHandler?.destroy();
+    this.apiHandler?.destroy();
     this.handoffManager.destroy();
     this.acpProxy?.destroy();
     this.terminalManager.destroy();
@@ -496,7 +637,8 @@ export class ClusterRuntime {
         });
         break;
       case "health_sync":
-        this.healthTracker.handleSyncMessage(frame as HealthSyncFrame);
+        // Legacy: Automerge health sync frames are ignored.
+        // Health events now sync via log_sync (LogReplicator).
         break;
       case "availability_req": {
         const af = frame as AvailabilityRequest;
@@ -720,6 +862,20 @@ export class ClusterRuntime {
       case "file_transfer_complete":
         this.fileTransferManager?.handleComplete(frame as FileTransferComplete);
         break;
+      case "log_sync":
+        this.logReplicator?.handleSyncMessage(frame as LogSyncFrame);
+        break;
+      case "kanban_sync":
+        this.kanbanManager?.handleSyncMessage(frame as KanbanSyncFrame);
+        break;
+      case "kanban_notify":
+        // Kanban notifications are consumed by mobile/web clients.
+        // Push to satellite events if web handler is active.
+        if (this.apiHandler) {
+          const kf = frame as KanbanNotifyFrame;
+          this.apiHandler.pushKanbanEvent(kf.payload);
+        }
+        break;
     }
   }
 

package/src/compat.ts

@@ -70,6 +70,109 @@ export function spawnProcess(
   };
 }
 
+// ── SQLite support ────────────────────────────────────────────────
+//
+// Normalized interface over bun:sqlite (Bun runtime) and better-sqlite3 (Node.js).
+// Tests run with `bun test` → bun:sqlite; production runs inside OpenClaw Node.js → better-sqlite3.
+
+export interface SqliteDatabase {
+  exec(sql: string): void;
+  prepare(sql: string): SqliteStatement;
+  close(): void;
+  transaction<T extends (...args: unknown[]) => unknown>(fn: T): T;
+}
+
+export interface SqliteStatement {
+  run(...params: unknown[]): SqliteRunResult;
+  all(...params: unknown[]): unknown[];
+  get(...params: unknown[]): unknown;
+}
+
+export interface SqliteRunResult {
+  changes: number;
+  lastInsertRowid: number;
+}
+
+export function openDatabase(dbPath: string): SqliteDatabase {
+  // Bun runtime: use bun:sqlite (built-in, no native addon needed)
+  if (typeof globalThis.Bun !== "undefined") {
+    return openBunSqlite(dbPath);
+  }
+  // Node.js runtime: use better-sqlite3
+  return openBetterSqlite3(dbPath);
+}
+
+function openBunSqlite(dbPath: string): SqliteDatabase {
+  // Dynamic require to avoid bundler issues in Node.js
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { Database } = require("bun:sqlite");
+  const db = new Database(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA synchronous = NORMAL");
+
+  const changesStmt = db.prepare("SELECT changes() AS v");
+  const rowidStmt = db.prepare("SELECT last_insert_rowid() AS v");
+
+  return {
+    exec: (sql: string) => db.exec(sql),
+    prepare: (sql: string) => {
+      const stmt = db.prepare(sql);
+      return {
+        run(...params: unknown[]): SqliteRunResult {
+          stmt.run(...params);
+          const changes: number = Number((changesStmt.get() as Record<string, unknown>).v);
+          const lastInsertRowid: number = Number((rowidStmt.get() as Record<string, unknown>).v);
+          return { changes, lastInsertRowid };
+        },
+        all(...params: unknown[]): unknown[] {
+          return stmt.all(...params);
+        },
+        get(...params: unknown[]): unknown {
+          return stmt.get(...params);
+        },
+      };
+    },
+    close: () => db.close(),
+    transaction: <T extends (...args: unknown[]) => unknown>(fn: T): T => db.transaction(fn),
+  };
+}
+
+function openBetterSqlite3(dbPath: string): SqliteDatabase {
+  const req = createRequire(import.meta.url);
+  let BetterSqlite3: unknown;
+  try {
+    BetterSqlite3 = req("better-sqlite3");
+  } catch {
+    throw new Error("better-sqlite3 is not available — install it with: npm install better-sqlite3");
+  }
+
+  const db = new (BetterSqlite3 as new (path: string) => Record<string, unknown>)(dbPath) as Record<string, (...args: unknown[]) => unknown>;
+  (db.pragma as (s: string) => void)("journal_mode = WAL");
+  (db.pragma as (s: string) => void)("synchronous = NORMAL");
+
+  return {
+    exec: (sql: string) => (db.exec as (s: string) => void)(sql),
+    prepare: (sql: string) => {
+      const stmt = (db.prepare as (s: string) => Record<string, (...args: unknown[]) => unknown>)(sql);
+      return {
+        run(...params: unknown[]): SqliteRunResult {
+          const result = stmt.run(...params) as { changes: number; lastInsertRowid: number | bigint };
+          return { changes: result.changes, lastInsertRowid: Number(result.lastInsertRowid) };
+        },
+        all(...params: unknown[]): unknown[] {
+          return stmt.all(...params) as unknown[];
+        },
+        get(...params: unknown[]): unknown {
+          return stmt.get(...params);
+        },
+      };
+    },
+    close: () => (db.close as () => void)(),
+    transaction: <T extends (...args: unknown[]) => unknown>(fn: T): T =>
+      (db.transaction as (fn: T) => T)(fn),
+  };
+}
+
 // ── PTY support (optional, requires node-pty) ────────────────────
 
 export interface PtyHandle {

package/src/config.ts

@@ -49,12 +49,15 @@ const ModelInfoSchema = z.object({
   ...ModelParamsSchema,
 });
 
-const PeerConfigSchema = z.object({
+const PeerConfigObjectSchema = z.object({
   nodeId: z.string(),
   /** Single URL or array of URLs for multi-channel connections. */
   url: z.union([z.string(), z.array(z.string()).min(1)]),
 });
 
+/** Peer config: full object or URL string shorthand (nodeId derived from handshake). */
+const PeerConfigSchema = z.union([z.string(), PeerConfigObjectSchema]);
+
 const ToolProxyConfigSchema = z.object({
   enabled: z.boolean().default(false),
   allow: z.array(z.string()).default([]),
@@ -92,11 +95,6 @@ const SentinelConfigSchema = z.object({
   listenHost: z.string().optional(),
 }).optional();
 
-const WebConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  token: z.string().min(8, "web token must be at least 8 characters"),
-}).optional();
-
 const AcpAgentInfoSchema = z.object({
   id: z.string(),
   description: z.string().default(""),
@@ -143,6 +141,16 @@ const FileTransferConfigSchema = z.object({
   allowedPaths: z.array(z.string()).default([]), // empty = no restriction
 }).optional();
 
+const KanbanConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  /** Card ID prefix (e.g. "CM" → CM-1, CM-2). */
+  prefix: z.string().default("CM"),
+  /** Allow agents to auto-claim matching cards. */
+  autoAssign: z.boolean().default(true),
+  /** Archive cards older than this (ms). Default: 30 days. */
+  archiveAfterMs: z.number().default(30 * 24 * 60 * 60 * 1000),
+}).optional();
+
 const AcpConfigSchema = z.object({
   enabled: z.boolean().default(false),
   /** ACP agents available on this node. Advertised to peers via capabilities. */
@@ -164,30 +172,38 @@ const RawClawMatrixConfigSchema = z.object({
   listenHost: z.string().default("0.0.0.0"),
   listenPort: z.number().int().min(0).max(65535).default(0),
   peers: z.array(PeerConfigSchema).default([]),
+  /** Agents provided by this node. Auto-discovered from OpenClaw if omitted. */
   agents: z.array(AgentInfoSchema).default([]),
   models: z.array(ModelInfoSchema).default([]),
   proxyModels: z.array(ProxyModelGroupSchema).default([]),
   tags: z.array(z.string()).default([]),
   proxyPort: z.number().int().min(0).max(65535).default(0),
-  toolProxy: ToolProxyConfigSchema.optional(),
+  /** Tool proxy: boolean shorthand (true = enable all, false = disable) or full object. */
+  toolProxy: z.union([z.boolean(), ToolProxyConfigSchema]).optional(),
   handoffTimeout: z.number().positive().default(600_000),
   modelTimeout: z.number().positive().default(120_000),
+  modelConcurrency: z.number().positive().default(5),
   toolTimeout: z.number().positive().default(30_000),
   /** Grace period (ms) before broadcasting peer_leave after disconnect.
    *  Allows brief reconnections (WiFi/cellular handoff) to be invisible to the mesh. */
   disconnectGrace: z.number().nonnegative().default(30_000),
   sentinel: SentinelConfigSchema,
-  web: WebConfigSchema,
   knowledge: KnowledgeConfigSchema,
   terminal: TerminalConfigSchema,
+  kanban: KanbanConfigSchema,
   acp: AcpConfigSchema,
   fileTransfer: FileTransferConfigSchema,
+  store: z.object({
+    /** Retention period in days for replicated and local event data (default: 90). */
+    retentionDays: z.number().default(90),
+  }).optional(),
   peerApproval: z.union([
     z.boolean(),           // true = required mode, false = disabled
+    z.enum(["required", "notify", "none"]),  // string shorthand
     PeerApprovalConfigSchema,
   ]).default(true),
   e2ee: z.boolean().default(true),
-  compression: z.boolean().default(false),
+  compression: z.boolean().default(true),
 });
 
 /** Flat proxy model after group expansion (used internally). */
@@ -214,15 +230,29 @@ export interface PeerApprovalConfig {
   notifyTargets: Array<{ channel: string; to: string; accountId?: string; threadId?: string | number }>;
 }
 
-export type ClawMatrixConfig = Omit<z.infer<typeof RawClawMatrixConfigSchema>, "proxyModels" | "peerApproval"> & {
+export type ClawMatrixConfig = Omit<z.infer<typeof RawClawMatrixConfigSchema>, "proxyModels" | "peerApproval" | "toolProxy" | "peers"> & {
+  peers: PeerConfig[];
   proxyModels: ProxyModel[];
   peerApproval: PeerApprovalConfig;
+  toolProxy?: ToolProxyConfig;
 };
 
 export { RawClawMatrixConfigSchema as ClawMatrixConfigSchema };
-export type PeerConfig = z.infer<typeof PeerConfigSchema>;
+/** Normalized peer config (always object form). */
+export type PeerConfig = z.infer<typeof PeerConfigObjectSchema>;
 export type ToolProxyConfig = z.infer<typeof ToolProxyConfigSchema>;
 
+/** Auto-generate a temporary nodeId from a URL for pre-handshake use.
+ *  After handshake the real nodeId replaces this. */
+function nodeIdFromUrl(url: string): string {
+  try {
+    const u = new URL(url);
+    return `_${u.hostname}:${u.port || (u.protocol === "wss:" ? "443" : "80")}`;
+  } catch {
+    return `_${url}`;
+  }
+}
+
 /** Parse and flatten grouped proxyModels into flat array.
  *  Uses passthrough() to ignore unknown fields and safeParse to avoid crashing. */
 export function parseConfig(raw: unknown): ClawMatrixConfig {
@@ -233,6 +263,14 @@ export function parseConfig(raw: unknown): ClawMatrixConfig {
   }
   const parsed = result.data;
 
+  // Normalize peers: string → { nodeId: derived, url: string }
+  const peers: PeerConfig[] = parsed.peers.map((p) => {
+    if (typeof p === "string") {
+      return { nodeId: nodeIdFromUrl(p), url: p };
+    }
+    return p;
+  });
+
   // Flatten proxy model groups
   const proxyModels: ProxyModel[] = [];
   for (const group of parsed.proxyModels) {
@@ -253,17 +291,34 @@ export function parseConfig(raw: unknown): ClawMatrixConfig {
     }
   }
 
-  // Normalize peerApproval: boolean → object
+  // Normalize toolProxy: boolean → object
+  let toolProxy: ToolProxyConfig | undefined;
+  const rawToolProxy = parsed.toolProxy;
+  if (typeof rawToolProxy === "boolean") {
+    toolProxy = rawToolProxy
+      ? { enabled: true, allow: ["*"], deny: [], maxOutputBytes: 1_048_576 }
+      : { enabled: false, allow: [], deny: [], maxOutputBytes: 1_048_576 };
+  } else {
+    toolProxy = rawToolProxy;
+  }
+
+  // Normalize peerApproval: boolean | string → object
   let peerApproval: PeerApprovalConfig;
   const rawApproval = parsed.peerApproval;
+  const defaultApproval: Omit<PeerApprovalConfig, "enabled" | "mode"> = {
+    timeout: 1_200_000,
+    allowList: [],
+    persistPath: "approved-peers.json",
+    notifyTargets: [],
+  };
   if (typeof rawApproval === "boolean") {
+    peerApproval = { ...defaultApproval, enabled: rawApproval, mode: "required" };
+  } else if (typeof rawApproval === "string") {
+    // "required" | "notify" | "none"
     peerApproval = {
-      enabled: rawApproval,
-      mode: "required",
-      timeout: 1_200_000,
-      allowList: [],
-      persistPath: "approved-peers.json",
-      notifyTargets: [],
+      ...defaultApproval,
+      enabled: rawApproval !== "none",
+      mode: rawApproval === "none" ? "notify" : rawApproval,
     };
   } else if (rawApproval) {
     peerApproval = {
@@ -275,15 +330,8 @@ export function parseConfig(raw: unknown): ClawMatrixConfig {
       notifyTargets: rawApproval.notifyTargets,
     };
   } else {
-    peerApproval = {
-      enabled: false,
-      mode: "notify",
-      timeout: 1_200_000,
-      allowList: [],
-      persistPath: "approved-peers.json",
-      notifyTargets: [],
-    };
+    peerApproval = { ...defaultApproval, enabled: false, mode: "notify" };
   }
 
-  return { ...parsed, proxyModels, peerApproval };
+  return { ...parsed, peers, proxyModels, toolProxy, peerApproval };
 }