@surething/cockpit 1.0.207 → 1.0.209

package/dist/scheduledTasks.mjs

@@ -1,16 +1,1169 @@
 import {
+  AgentError,
+  Config_exports,
+  Context_exports,
+  DBError,
+  Duration_exports,
+  Effect_exports,
+  Fiber_exports,
+  Layer_exports,
+  LogLevel_exports,
+  Logger_exports,
+  ManagedRuntime_exports,
+  Option_exports,
+  Queue_exports,
+  Ref_exports,
+  Schedule_exports,
+  Stream_exports,
+  Tracer_exports,
   getSessionTitle,
   updateGlobalState
-} from "./chunk-HIRLDMCH.mjs";
+} from "./chunk-OWUW2O3D.mjs";
 import {
   CLAUDE2_DIR,
   SCHEDULED_TASKS_FILE,
+  createNeo4jDriver,
   readJsonFile,
+  runCypherWithDriver,
   writeJsonFile
-} from "./chunk-RSHKDWJM.mjs";
+} from "./chunk-TXBVUZVH.mjs";
 
 // packages/feature/agent/src/server/scheduledTasks.ts
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+
+// packages/shared/utils/src/ollamaEnv.ts
+var DEFAULT_BASE = "http://127.0.0.1:11434";
+function getOllamaBaseURL() {
+  const raw = process.env.OLLAMA_BASE_URL || DEFAULT_BASE;
+  return raw.replace(/\/v1\/?$/, "").replace(/\/+$/, "");
+}
+function getOllamaOpenAIBaseURL() {
+  return `${getOllamaBaseURL()}/v1/`;
+}
+
+// packages/shared/effect-core/src/logger.ts
+var parseLevel = (raw) => {
+  switch ((raw ?? "").toLowerCase()) {
+    case "all":
+      return LogLevel_exports.All;
+    case "trace":
+      return LogLevel_exports.Trace;
+    case "debug":
+      return LogLevel_exports.Debug;
+    case "info":
+      return LogLevel_exports.Info;
+    case "warning":
+    case "warn":
+      return LogLevel_exports.Warning;
+    case "error":
+      return LogLevel_exports.Error;
+    case "fatal":
+      return LogLevel_exports.Fatal;
+    case "none":
+      return LogLevel_exports.None;
+    default:
+      return LogLevel_exports.Info;
+  }
+};
+var LoggerLivePretty = Layer_exports.mergeAll(
+  Logger_exports.pretty,
+  Logger_exports.minimumLogLevel(parseLevel(process.env.COCKPIT_LOG_LEVEL))
+);
+var appendLogFile = async (line, filePath) => {
+  const { appendFile, mkdir } = await import("fs/promises");
+  const { dirname } = await import("path");
+  try {
+    await mkdir(dirname(filePath), { recursive: true });
+    await appendFile(filePath, line + "\n", "utf-8");
+  } catch {
+  }
+};
+var normalizeMessage = (m) => {
+  if (Array.isArray(m)) {
+    return m.length === 1 ? m[0] : m;
+  }
+  return m;
+};
+var fileLogger = (filePath) => Logger_exports.make(({ logLevel, message, date, fiberId, spans, annotations }) => {
+  const payload = {
+    time: date.toISOString(),
+    level: logLevel.label,
+    // fiberId is a FiberId object; extract its numeric id
+    fiber: typeof fiberId === "object" && fiberId !== null && "id" in fiberId ? fiberId.id : String(fiberId),
+    msg: normalizeMessage(message),
+    spans: Array.from(spans).map((s) => ({
+      label: s.label,
+      startTime: s.startTime
+    })),
+    annotations: Object.fromEntries(annotations)
+  };
+  void appendLogFile(JSON.stringify(payload), filePath);
+});
+var LoggerLiveProd = (logFile) => Layer_exports.mergeAll(
+  Logger_exports.pretty,
+  // still write to stdout for ops readability
+  Logger_exports.add(fileLogger(logFile)),
+  // also append to the file
+  Logger_exports.minimumLogLevel(parseLevel(process.env.COCKPIT_LOG_LEVEL))
+);
+
+// packages/shared/effect-core/src/spanRecorder.ts
+var MAX_SPANS = 500;
+var g = globalThis;
+var ring = g.__cockpitSpanRing ??= {
+  buffer: [],
+  index: /* @__PURE__ */ new Map()
+};
+function recordSpanStart(span) {
+  ring.buffer.push(span);
+  ring.index.set(span.spanId, ring.buffer.length - 1);
+  if (ring.buffer.length > MAX_SPANS) {
+    const removed = ring.buffer.shift();
+    ring.index.clear();
+    for (let i = 0; i < ring.buffer.length; i++) {
+      ring.index.set(ring.buffer[i].spanId, i);
+    }
+    void removed;
+  }
+}
+function recordSpanEnd(spanId, endTimeNs, exit) {
+  const idx = ring.index.get(spanId);
+  if (idx === void 0) return;
+  const existing = ring.buffer[idx];
+  if (!existing) return;
+  const startNs = BigInt(existing.startTimeNs);
+  const durationMs = Number(endTimeNs - startNs) / 1e6;
+  ring.buffer[idx] = {
+    ...existing,
+    endTimeNs: endTimeNs.toString(),
+    durationMs: Math.round(durationMs * 100) / 100,
+    status: exit._tag === "Success" ? "ok" : "error",
+    errorMessage: exit._tag === "Failure" ? prettyPrintCause(exit.cause) : void 0
+  };
+}
+function recordSpanAttribute(spanId, key, value) {
+  const idx = ring.index.get(spanId);
+  if (idx === void 0) return;
+  const existing = ring.buffer[idx];
+  if (!existing) return;
+  ring.buffer[idx] = {
+    ...existing,
+    attributes: { ...existing.attributes, [key]: value }
+  };
+}
+function recordSpanEvent(spanId, eventName, timeNs, attributes) {
+  const idx = ring.index.get(spanId);
+  if (idx === void 0) return;
+  const existing = ring.buffer[idx];
+  if (!existing) return;
+  ring.buffer[idx] = {
+    ...existing,
+    events: [
+      ...existing.events,
+      { name: eventName, timeNs: timeNs.toString(), attributes }
+    ]
+  };
+}
+function prettyPrintCause(cause) {
+  if (cause instanceof Error) return cause.message;
+  if (typeof cause === "string") return cause;
+  try {
+    return JSON.stringify(cause);
+  } catch {
+    return String(cause);
+  }
+}
+function makeStartedRecord(spanId, traceId, parentSpanId, name, kind, startTimeNs) {
+  return {
+    traceId,
+    spanId,
+    parentSpanId,
+    name,
+    kind,
+    startTimeNs: startTimeNs.toString(),
+    endTimeNs: null,
+    durationMs: null,
+    attributes: {},
+    events: [],
+    status: "started"
+  };
+}
+function getParentSpanId(parent) {
+  return Option_exports.isSome(parent) ? parent.value.spanId : null;
+}
+
+// packages/shared/effect-core/src/tracer.ts
+var randomHexString = (length) => {
+  const chars = "abcdef0123456789";
+  let s = "";
+  for (let i = 0; i < length; i++) {
+    s += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return s;
+};
+var RecordingSpan = class {
+  constructor(name, parent, context, links, startTime, kind) {
+    this.name = name;
+    this.parent = parent;
+    this.context = context;
+    this.startTime = startTime;
+    this.kind = kind;
+    this._tag = "Span";
+    this.sampled = true;
+    this.attributes = /* @__PURE__ */ new Map();
+    this.events = [];
+    this.traceId = Option_exports.isSome(parent) ? parent.value.traceId : randomHexString(32);
+    this.spanId = randomHexString(16);
+    this.status = { _tag: "Started", startTime };
+    this.links = Array.from(links);
+    recordSpanStart(
+      makeStartedRecord(
+        this.spanId,
+        this.traceId,
+        getParentSpanId(parent),
+        name,
+        kind,
+        startTime
+      )
+    );
+  }
+  end(endTime, exit) {
+    this.status = {
+      _tag: "Ended",
+      endTime,
+      exit,
+      startTime: this.status.startTime
+    };
+    recordSpanEnd(
+      this.spanId,
+      endTime,
+      exit._tag === "Success" ? { _tag: "Success" } : { _tag: "Failure", cause: exit.cause }
+    );
+  }
+  attribute(key, value) {
+    this.attributes.set(key, value);
+    recordSpanAttribute(this.spanId, key, value);
+  }
+  event(name, startTime, attributes) {
+    this.events.push([name, startTime, attributes ?? {}]);
+    recordSpanEvent(this.spanId, name, startTime, attributes);
+  }
+  addLinks(links) {
+    this.links.push(...links);
+  }
+};
+var recordingTracer = Tracer_exports.make({
+  span: (name, parent, context, links, startTime, kind) => new RecordingSpan(name, parent, context, links, startTime, kind),
+  context: (f) => f()
+});
+var TracerLivePretty = Layer_exports.succeed(
+  Tracer_exports.Tracer,
+  recordingTracer
+);
+var TracerLiveNoop = Layer_exports.empty;
+
+// packages/shared/effect-core/src/config.ts
+var envConfig = Config_exports.literal("dev", "prod")("COCKPIT_ENV").pipe(
+  Config_exports.withDefault("prod")
+);
+var hostConfig = Config_exports.string("COCKPIT_HOST").pipe(
+  Config_exports.withDefault("127.0.0.1")
+);
+var portConfig = Config_exports.integer("COCKPIT_PORT").pipe(
+  Config_exports.orElse(() => Config_exports.integer("PORT")),
+  Config_exports.withDefault(3457)
+);
+var openProjectConfig = Config_exports.option(
+  Config_exports.string("COCKPIT_OPEN_PROJECT")
+).pipe(
+  Config_exports.map((opt) => opt._tag === "Some" ? opt.value : void 0)
+);
+var noOpenConfig = Config_exports.boolean("COCKPIT_NO_OPEN").pipe(
+  Config_exports.withDefault(false)
+);
+var logLevelConfig = Config_exports.string("COCKPIT_LOG_LEVEL").pipe(
+  Config_exports.withDefault("info")
+);
+var cockpitDirConfigOpt = Config_exports.option(Config_exports.string("COCKPIT_DIR"));
+var CockpitConfig = Effect_exports.gen(
+  function* () {
+    const env = yield* envConfig;
+    const host = yield* hostConfig;
+    const port = yield* portConfig;
+    const openProject = yield* openProjectConfig;
+    const noOpen = yield* noOpenConfig;
+    const logLevel = yield* logLevelConfig;
+    const cockpitDirOpt = yield* cockpitDirConfigOpt;
+    const cockpitDir = yield* Effect_exports.sync(() => {
+      if (cockpitDirOpt._tag === "Some") return cockpitDirOpt.value;
+      const env2 = typeof process !== "undefined" ? process.env : void 0;
+      const home = env2?.HOME || env2?.USERPROFILE || ".";
+      return home + "/.cockpit";
+    });
+    const logFile = cockpitDir + "/logs/cockpit.log";
+    return {
+      env,
+      host,
+      port: port === 3457 && env === "dev" ? 3456 : port,
+      // dev defaults to 3456
+      cockpitDir,
+      openProject,
+      openBrowser: !noOpen,
+      logLevel,
+      logFile
+    };
+  }
+).pipe(Effect_exports.orDie);
+var ConfigLive = Layer_exports.empty;
+
+// packages/shared/effect-core/src/schedule.ts
+var wsReconnect = Schedule_exports.exponential(
+  Duration_exports.seconds(1),
+  1.5
+).pipe(
+  Schedule_exports.either(Schedule_exports.spaced(Duration_exports.seconds(10))),
+  // cap at 10s
+  Schedule_exports.intersect(Schedule_exports.recurs(10))
+  // up to 10 attempts
+);
+var dbRetry = Schedule_exports.exponential(
+  Duration_exports.millis(200),
+  2
+).pipe(
+  Schedule_exports.either(Schedule_exports.spaced(Duration_exports.seconds(5))),
+  Schedule_exports.intersect(Schedule_exports.recurs(5))
+);
+var agentRetry = Schedule_exports.exponential(
+  Duration_exports.seconds(1),
+  2
+).pipe(
+  Schedule_exports.jittered,
+  // jitter to avoid thundering herd
+  Schedule_exports.either(Schedule_exports.spaced(Duration_exports.seconds(30))),
+  Schedule_exports.intersect(Schedule_exports.recurs(8))
+);
+var wsHeartbeat = Schedule_exports.spaced(Duration_exports.seconds(30));
+var shortPoll = Schedule_exports.spaced(Duration_exports.seconds(1));
+var longPoll = Schedule_exports.spaced(Duration_exports.seconds(30));
+var fileChangeDebounce = Duration_exports.millis(50);
+var cron = Schedule_exports.cron;
+
+// packages/feature/console/src/effect/pgLive.ts
+import pg from "pg";
+
+// packages/shared/effect-services/src/db.ts
+var PgService = Context_exports.GenericTag("@cockpit/PgService");
+var MySQLService = Context_exports.GenericTag("@cockpit/MySQLService");
+var RedisService = Context_exports.GenericTag("@cockpit/RedisService");
+var Neo4jService = Context_exports.GenericTag("@cockpit/Neo4jService");
+var MongoService = Context_exports.GenericTag("@cockpit/MongoService");
+
+// packages/shared/effect-services/src/agent.ts
+var AgentService = Context_exports.GenericTag("@cockpit/AgentService");
+
+// packages/shared/effect-services/src/scheduler.ts
+var Scheduler = Context_exports.GenericTag("@cockpit/Scheduler");
+
+// packages/feature/console/src/effect/pgLive.ts
+var { Pool } = pg;
+var handleAsync = (op, f) => Effect_exports.tryPromise({
+  try: f,
+  catch: (cause) => new DBError({ db: "pg", op, cause })
+});
+var acquirePool = (poolsRef, id, connectionString) => Effect_exports.gen(function* () {
+  const pools = yield* Ref_exports.get(poolsRef);
+  const existing = pools.get(id);
+  if (existing && existing.connectionString === connectionString) {
+    return existing.pool;
+  }
+  if (existing) {
+    yield* handleAsync("end", () => existing.pool.end()).pipe(
+      Effect_exports.orElse(() => Effect_exports.void)
+    );
+  }
+  const pool = new Pool({
+    connectionString,
+    max: 5,
+    idleTimeoutMillis: 6e4,
+    connectionTimeoutMillis: 1e4
+  });
+  yield* Ref_exports.update(poolsRef, (m) => {
+    const next = new Map(m);
+    next.set(id, { pool, connectionString, createdAt: Date.now() });
+    return next;
+  });
+  return pool;
+});
+var disconnectPool = (poolsRef, id) => Effect_exports.gen(function* () {
+  const pools = yield* Ref_exports.get(poolsRef);
+  const managed = pools.get(id);
+  if (!managed) return;
+  yield* handleAsync("disconnect", () => managed.pool.end()).pipe(
+    Effect_exports.orElse(() => Effect_exports.void)
+  );
+  yield* Ref_exports.update(poolsRef, (m) => {
+    const next = new Map(m);
+    next.delete(id);
+    return next;
+  });
+});
+var PgServiceLive = Layer_exports.scoped(
+  PgService,
+  Effect_exports.gen(function* () {
+    const poolsRef = yield* Ref_exports.make(/* @__PURE__ */ new Map());
+    yield* Effect_exports.addFinalizer(
+      () => Effect_exports.gen(function* () {
+        const pools = yield* Ref_exports.get(poolsRef);
+        for (const { pool } of pools.values()) {
+          yield* Effect_exports.tryPromise({
+            try: () => pool.end(),
+            catch: (cause) => new DBError({ db: "pg", op: "shutdown end", cause })
+          }).pipe(Effect_exports.orElse(() => Effect_exports.void));
+        }
+        yield* Ref_exports.set(poolsRef, /* @__PURE__ */ new Map());
+        yield* Effect_exports.logInfo(
+          `[PgServiceLive] disposed ${pools.size} pool(s)`
+        );
+      })
+    );
+    return PgService.of({
+      query: (id, connStr, sql, params) => Effect_exports.gen(function* () {
+        const pool = yield* acquirePool(poolsRef, id, connStr);
+        const result = yield* handleAsync(
+          "query",
+          () => pool.query(sql, params)
+        );
+        return result.rows;
+      }).pipe(Effect_exports.withSpan("pg.query", { attributes: { id } })),
+      queryWithMeta: (id, connStr, sql, params) => Effect_exports.gen(function* () {
+        const pool = yield* acquirePool(poolsRef, id, connStr);
+        const start = performance.now();
+        const result = yield* handleAsync(
+          "queryWithMeta",
+          () => pool.query(sql, params)
+        );
+        const duration = Math.round((performance.now() - start) * 100) / 100;
+        const meta = {
+          rows: result.rows ?? [],
+          fields: result.fields ? result.fields.map(
+            (f) => ({
+              name: f.name,
+              dataTypeID: f.dataTypeID
+            })
+          ) : null,
+          rowCount: result.rowCount ?? null,
+          command: result.command ?? null,
+          duration
+        };
+        return meta;
+      }).pipe(
+        Effect_exports.withSpan("pg.queryWithMeta", { attributes: { id } })
+      ),
+      stream: (id, connStr, sql, params) => Stream_exports.unwrap(
+        Effect_exports.gen(function* () {
+          const pool = yield* acquirePool(poolsRef, id, connStr);
+          const result = yield* handleAsync(
+            "query",
+            () => pool.query(sql, params)
+          );
+          return Stream_exports.fromIterable(result.rows);
+        })
+      ),
+      withTx: (id, connStr, f) => Effect_exports.gen(function* () {
+        const pool = yield* acquirePool(poolsRef, id, connStr);
+        const client = yield* handleAsync("connect", () => pool.connect());
+        yield* handleAsync("BEGIN", () => client.query("BEGIN"));
+        const tx = {
+          query: (sql, params) => handleAsync(
+            "tx.query",
+            () => client.query(sql, params).then((r) => r.rows)
+          )
+        };
+        const result = yield* f(tx).pipe(
+          Effect_exports.tapBoth({
+            onSuccess: () => handleAsync("COMMIT", () => client.query("COMMIT")),
+            onFailure: () => handleAsync(
+              "ROLLBACK",
+              () => client.query("ROLLBACK")
+            ).pipe(Effect_exports.orElse(() => Effect_exports.void))
+          }),
+          Effect_exports.ensuring(Effect_exports.sync(() => client.release()))
+        );
+        return result;
+      }).pipe(Effect_exports.withSpan("pg.withTx", { attributes: { id } })),
+      disconnect: (id) => disconnectPool(poolsRef, id)
+    });
+  })
+);
+
+// packages/feature/console/src/effect/mysqlLive.ts
+import mysql from "mysql2/promise";
+var handleAsync2 = (op, f) => Effect_exports.tryPromise({
+  try: f,
+  catch: (cause) => new DBError({ db: "mysql", op, cause })
+});
+var acquirePool2 = (poolsRef, id, connectionString) => Effect_exports.gen(function* () {
+  const pools = yield* Ref_exports.get(poolsRef);
+  const existing = pools.get(id);
+  if (existing && existing.connectionString === connectionString) {
+    return existing.pool;
+  }
+  if (existing) {
+    yield* handleAsync2("end", () => existing.pool.end()).pipe(
+      Effect_exports.orElse(() => Effect_exports.void)
+    );
+  }
+  const pool = mysql.createPool({
+    uri: connectionString,
+    connectionLimit: 5,
+    idleTimeout: 6e4,
+    connectTimeout: 1e4
+  });
+  yield* Ref_exports.update(poolsRef, (m) => {
+    const next = new Map(m);
+    next.set(id, { pool, connectionString, createdAt: Date.now() });
+    return next;
+  });
+  return pool;
+});
+var disconnectPool2 = (poolsRef, id) => Effect_exports.gen(function* () {
+  const pools = yield* Ref_exports.get(poolsRef);
+  const managed = pools.get(id);
+  if (!managed) return;
+  yield* handleAsync2("disconnect", () => managed.pool.end()).pipe(
+    Effect_exports.orElse(() => Effect_exports.void)
+  );
+  yield* Ref_exports.update(poolsRef, (m) => {
+    const next = new Map(m);
+    next.delete(id);
+    return next;
+  });
+});
+var MySQLServiceLive = Layer_exports.scoped(
+  MySQLService,
+  Effect_exports.gen(function* () {
+    const poolsRef = yield* Ref_exports.make(/* @__PURE__ */ new Map());
+    yield* Effect_exports.addFinalizer(
+      () => Effect_exports.gen(function* () {
+        const pools = yield* Ref_exports.get(poolsRef);
+        for (const { pool } of pools.values()) {
+          yield* Effect_exports.tryPromise({
+            try: () => pool.end(),
+            catch: (cause) => new DBError({ db: "mysql", op: "shutdown end", cause })
+          }).pipe(Effect_exports.orElse(() => Effect_exports.void));
+        }
+        yield* Ref_exports.set(poolsRef, /* @__PURE__ */ new Map());
+        yield* Effect_exports.logInfo(
+          `[MySQLServiceLive] disposed ${pools.size} pool(s)`
+        );
+      })
+    );
+    return MySQLService.of({
+      query: (id, connStr, sql, params) => Effect_exports.gen(function* () {
+        const pool = yield* acquirePool2(poolsRef, id, connStr);
+        const [rows] = yield* handleAsync2(
+          "query",
+          () => pool.query(sql, params)
+        );
+        return rows;
+      }).pipe(Effect_exports.withSpan("mysql.query", { attributes: { id } })),
+      queryWithMeta: (id, connStr, sql, params) => Effect_exports.gen(function* () {
+        const pool = yield* acquirePool2(poolsRef, id, connStr);
+        const start = performance.now();
+        const [result, fieldPackets] = yield* handleAsync2(
+          "queryWithMeta",
+          () => pool.query(sql, params)
+        );
+        const duration = Math.round((performance.now() - start) * 100) / 100;
+        if (Array.isArray(result) && Array.isArray(fieldPackets)) {
+          const rows = result;
+          const fields = fieldPackets.map((f) => ({ name: f.name, dataTypeID: f.columnType ?? 0 }));
+          const meta2 = {
+            rows,
+            fields,
+            rowCount: rows.length,
+            command: null,
+            duration
+          };
+          return meta2;
+        }
+        const header = result;
+        const meta = {
+          rows: [],
+          fields: null,
+          rowCount: header.affectedRows ?? 0,
+          command: sql.trim().split(/\s+/)[0]?.toUpperCase() || "QUERY",
+          duration
+        };
+        return meta;
+      }).pipe(
+        Effect_exports.withSpan("mysql.queryWithMeta", { attributes: { id } })
+      ),
+      withTx: (id, connStr, f) => Effect_exports.gen(function* () {
+        const pool = yield* acquirePool2(poolsRef, id, connStr);
+        const conn = yield* handleAsync2(
+          "getConnection",
+          () => pool.getConnection()
+        );
+        yield* handleAsync2("BEGIN", () => conn.beginTransaction());
+        const tx = {
+          query: (sql, params) => handleAsync2(
+            "tx.query",
+            () => conn.query(sql, params).then(([rows]) => rows)
+          )
+        };
+        const result = yield* f(tx).pipe(
+          Effect_exports.tapBoth({
+            onSuccess: () => handleAsync2("COMMIT", () => conn.commit()),
+            onFailure: () => handleAsync2("ROLLBACK", () => conn.rollback()).pipe(
+              Effect_exports.orElse(() => Effect_exports.void)
+            )
+          }),
+          Effect_exports.ensuring(Effect_exports.sync(() => conn.release()))
+        );
+        return result;
+      }).pipe(Effect_exports.withSpan("mysql.withTx", { attributes: { id } })),
+      disconnect: (id) => disconnectPool2(poolsRef, id)
+    });
+  })
+);
+
+// packages/feature/console/src/effect/redisLive.ts
+import Redis from "ioredis";
+var handleAsync3 = (op, f) => Effect_exports.tryPromise({
+  try: f,
+  catch: (cause) => new DBError({ db: "redis", op, cause })
+});
+var acquireClient = (clientsRef, id, connectionString) => Effect_exports.gen(function* () {
+  const clients = yield* Ref_exports.get(clientsRef);
+  const existing = clients.get(id);
+  if (existing && existing.connectionString === connectionString) {
+    if (existing.client.status === "ready") return existing.client;
+    yield* handleAsync3("quit", () => existing.client.quit()).pipe(
+      Effect_exports.orElse(() => Effect_exports.void)
+    );
+  } else if (existing) {
+    yield* handleAsync3("quit", () => existing.client.quit()).pipe(
+      Effect_exports.orElse(() => Effect_exports.void)
+    );
+  }
+  const client = yield* handleAsync3("connect", async () => {
+    const c = new Redis(connectionString, {
+      lazyConnect: true,
+      connectTimeout: 1e4,
+      maxRetriesPerRequest: 1
+    });
+    await c.connect();
+    return c;
+  });
+  yield* Ref_exports.update(clientsRef, (m) => {
+    const next = new Map(m);
+    next.set(id, { client, connectionString, createdAt: Date.now() });
+    return next;
+  });
+  return client;
+});
+var disconnectClient = (clientsRef, id) => Effect_exports.gen(function* () {
+  const clients = yield* Ref_exports.get(clientsRef);
+  const managed = clients.get(id);
+  if (!managed) return;
+  yield* handleAsync3("disconnect", () => managed.client.quit()).pipe(
+    Effect_exports.orElse(() => Effect_exports.void)
+  );
+  yield* Ref_exports.update(clientsRef, (m) => {
+    const next = new Map(m);
+    next.delete(id);
+    return next;
+  });
+});
+var subscribeStream = (connStr, pattern) => Stream_exports.unwrapScoped(
+  Effect_exports.gen(function* () {
+    const queue = yield* Queue_exports.unbounded();
+    const sub = yield* Effect_exports.acquireRelease(
+      handleAsync3("subscribeConnect", async () => {
+        const c = new Redis(connStr, {
+          lazyConnect: true,
+          connectTimeout: 1e4,
+          maxRetriesPerRequest: 1
+        });
+        await c.connect();
+        return c;
+      }),
+      (c) => Effect_exports.tryPromise({
+        try: () => c.quit(),
+        catch: () => new DBError({ db: "redis", op: "subscribeQuit", cause: null })
+      }).pipe(Effect_exports.orElse(() => Effect_exports.void))
+    );
+    const isPattern = pattern.includes("*") || pattern.includes("?");
+    yield* handleAsync3(
+      "psubscribe",
+      () => isPattern ? sub.psubscribe(pattern) : sub.subscribe(pattern)
+    );
+    sub.on(isPattern ? "pmessage" : "message", (...args) => {
+      const channel = isPattern ? args[1] : args[0];
+      const message = isPattern ? args[2] : args[1];
+      Effect_exports.runFork(Queue_exports.offer(queue, { channel, message }));
+    });
+    return Stream_exports.fromQueue(queue);
+  })
+);
+var RedisServiceLive = Layer_exports.scoped(
+  RedisService,
+  Effect_exports.gen(function* () {
+    const clientsRef = yield* Ref_exports.make(/* @__PURE__ */ new Map());
+    yield* Effect_exports.addFinalizer(
+      () => Effect_exports.gen(function* () {
+        const clients = yield* Ref_exports.get(clientsRef);
+        for (const { client } of clients.values()) {
+          yield* Effect_exports.tryPromise({
+            try: () => client.quit(),
+            catch: (cause) => new DBError({ db: "redis", op: "shutdown quit", cause })
+          }).pipe(Effect_exports.orElse(() => Effect_exports.void));
+        }
+        yield* Ref_exports.set(clientsRef, /* @__PURE__ */ new Map());
+        yield* Effect_exports.logInfo(
+          `[RedisServiceLive] disposed ${clients.size} client(s)`
+        );
+      })
+    );
+    return RedisService.of({
+      command: (id, connStr, cmd, args) => Effect_exports.gen(function* () {
+        const client = yield* acquireClient(clientsRef, id, connStr);
+        const result = yield* handleAsync3(
+          "call",
+          () => client.call(cmd, ...args ?? [])
+        );
+        return result;
+      }).pipe(Effect_exports.withSpan("redis.command", { attributes: { id, cmd } })),
+      subscribe: (_id, connStr, pattern) => subscribeStream(connStr, pattern),
+      disconnect: (id) => disconnectClient(clientsRef, id)
+    });
+  })
+);
+
+// packages/feature/console/src/effect/neo4jLive.ts
+var handleAsync4 = (op, f) => Effect_exports.tryPromise({
+  try: f,
+  catch: (cause) => new DBError({ db: "neo4j", op, cause })
+});
+var acquireDriver = (driversRef, id, connectionString) => Effect_exports.gen(function* () {
+  const drivers = yield* Ref_exports.get(driversRef);
+  const existing = drivers.get(id);
+  if (existing && existing.connectionString === connectionString) {
+    return existing.driver;
+  }
+  if (existing) {
+    yield* handleAsync4("close", () => existing.driver.close()).pipe(
+      Effect_exports.orElse(() => Effect_exports.void)
+    );
+  }
+  const driver = yield* handleAsync4(
+    "createDriver",
+    () => createNeo4jDriver(connectionString)
+  );
+  yield* Ref_exports.update(driversRef, (m) => {
+    const next = new Map(m);
+    next.set(id, { driver, connectionString, createdAt: Date.now() });
+    return next;
+  });
+  return driver;
+});
+var disconnectDriver = (driversRef, id) => Effect_exports.gen(function* () {
+  const drivers = yield* Ref_exports.get(driversRef);
+  const managed = drivers.get(id);
+  if (!managed) return;
+  yield* handleAsync4("disconnect", () => managed.driver.close()).pipe(
+    Effect_exports.orElse(() => Effect_exports.void)
+  );
+  yield* Ref_exports.update(driversRef, (m) => {
+    const next = new Map(m);
+    next.delete(id);
+    return next;
+  });
+});
+var Neo4jServiceLive = Layer_exports.scoped(
+  Neo4jService,
+  Effect_exports.gen(function* () {
+    const driversRef = yield* Ref_exports.make(/* @__PURE__ */ new Map());
+    yield* Effect_exports.addFinalizer(
+      () => Effect_exports.gen(function* () {
+        const drivers = yield* Ref_exports.get(driversRef);
+        for (const { driver } of drivers.values()) {
+          yield* Effect_exports.tryPromise({
+            try: () => driver.close(),
+            catch: (cause) => new DBError({ db: "neo4j", op: "shutdown close", cause })
+          }).pipe(Effect_exports.orElse(() => Effect_exports.void));
+        }
+        yield* Ref_exports.set(driversRef, /* @__PURE__ */ new Map());
+        yield* Effect_exports.logInfo(
+          `[Neo4jServiceLive] disposed ${drivers.size} driver(s)`
+        );
+      })
+    );
+    return Neo4jService.of({
+      run: (id, connStr, cypher, params) => Effect_exports.gen(function* () {
+        const driver = yield* acquireDriver(driversRef, id, connStr);
+        const result = yield* handleAsync4(
+          "run",
+          () => runCypherWithDriver(driver, cypher, params)
+        );
+        return result.records;
+      }).pipe(Effect_exports.withSpan("neo4j.run", { attributes: { id } })),
+      runWithMeta: (id, connStr, cypher, params) => Effect_exports.gen(function* () {
+        const driver = yield* acquireDriver(driversRef, id, connStr);
+        const result = yield* handleAsync4(
+          "runWithMeta",
+          () => runCypherWithDriver(driver, cypher, params)
+        );
+        const meta = {
+          records: result.records,
+          keys: result.keys,
+          duration: result.duration,
+          counters: result.counters
+        };
+        return meta;
+      }).pipe(
+        Effect_exports.withSpan("neo4j.runWithMeta", { attributes: { id } })
+      ),
+      disconnect: (id) => disconnectDriver(driversRef, id)
+    });
+  })
+);
+
+// packages/feature/console/src/effect/mongoLive.ts
+var notImpl = (op) => Effect_exports.fail(
+  new DBError({
+    db: "mongo",
+    op,
+    cause: new Error("MongoServiceLive not implemented (mongodb driver not installed)")
+  })
+);
+var MongoServiceLive = Layer_exports.succeed(
+  MongoService,
+  MongoService.of({
+    find: () => notImpl("find"),
+    command: () => notImpl("command"),
+    disconnect: () => Effect_exports.void
+    // No connection, disconnect is a no-op
+  })
+);
+
+// packages/feature/agent/src/effect/schedulerLive.ts
+var SchedulerLive = Layer_exports.scoped(
+  Scheduler,
+  Effect_exports.gen(function* () {
+    const fibersRef = yield* Ref_exports.make(
+      /* @__PURE__ */ new Map()
+    );
+    yield* Effect_exports.addFinalizer(
+      () => Effect_exports.gen(function* () {
+        const fibers = yield* Ref_exports.get(fibersRef);
+        for (const f of fibers.values()) {
+          yield* Fiber_exports.interrupt(f);
+        }
+        yield* Ref_exports.set(fibersRef, /* @__PURE__ */ new Map());
+      })
+    );
+    return Scheduler.of({
+      schedule: (id, task, policy) => Effect_exports.gen(function* () {
+        const existing = yield* Ref_exports.get(fibersRef).pipe(
+          Effect_exports.map((m) => m.get(id))
+        );
+        if (existing) {
+          yield* Fiber_exports.interrupt(existing);
+        }
+        const fiber = yield* Effect_exports.forkScoped(
+          task.pipe(
+            Effect_exports.repeat(policy),
+            Effect_exports.tapError(
+              (e) => Effect_exports.logError(`[scheduler] task '${id}' failed`).pipe(
+                Effect_exports.annotateLogs("error", String(e))
+              )
+            )
+          )
+        );
+        yield* Ref_exports.update(
+          fibersRef,
+          (m) => new Map(m).set(id, fiber)
+        );
+        yield* Effect_exports.logInfo(`[scheduler] task '${id}' started`);
+        return { id, fiber };
+      }),
+      list: Effect_exports.gen(function* () {
+        const fibers = yield* Ref_exports.get(fibersRef);
+        return Array.from(fibers.keys());
+      }),
+      cancel: (id) => Effect_exports.gen(function* () {
+        const fibers = yield* Ref_exports.get(fibersRef);
+        const f = fibers.get(id);
+        if (f) {
+          yield* Fiber_exports.interrupt(f);
+          yield* Ref_exports.update(fibersRef, (m) => {
+            const next = new Map(m);
+            next.delete(id);
+            return next;
+          });
+          yield* Effect_exports.logInfo(`[scheduler] task '${id}' cancelled`);
+        }
+      })
+    });
+  })
+);
+
+// packages/feature/agent/src/effect/claudeSdkAdapter.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
+var providerEnvFor = (provider, apiKeyOverride) => {
+  switch (provider) {
+    case "claude":
+      return apiKeyOverride ? { apiKey: apiKeyOverride } : {};
+    case "codex":
+      return {
+        baseUrl: "https://api.openai.com/v1",
+        apiKey: apiKeyOverride
+      };
+    case "kimi":
+      return {
+        baseUrl: "https://api.moonshot.cn/anthropic",
+        apiKey: apiKeyOverride
+      };
+    case "deepseek":
+      return {
+        baseUrl: "https://api.deepseek.com/anthropic",
+        apiKey: apiKeyOverride
+      };
+    case "ollama":
+      return {};
+  }
+};
+var buildOptions = (req, apiKeyOverride) => {
+  const env = providerEnvFor(req.provider, apiKeyOverride);
+  return {
+    model: req.model,
+    env: {
+      ...process.env,
+      ...env.baseUrl ? { ANTHROPIC_BASE_URL: env.baseUrl } : {},
+      ...env.apiKey ? { ANTHROPIC_API_KEY: env.apiKey } : {}
+    }
+  };
+};
+var messagesToPrompt = (req) => {
+  const last = [...req.messages].reverse().find((m) => m.role === "user");
+  return last?.content ?? "";
+};
+var claudeChat = (req, apiKeyOverride) => Effect_exports.gen(function* () {
+  const chunks = yield* Stream_exports.runCollect(claudeStream(req, apiKeyOverride));
+  let text = "";
+  let usage;
+  for (const c of chunks) {
+    if (c._tag === "text") text += c.delta;
+    else if (c._tag === "done") usage = c.usage;
+  }
+  return {
+    message: { role: "assistant", content: text },
+    usage
+  };
+}).pipe(Effect_exports.withSpan("agent.chat", { attributes: { provider: req.provider, model: req.model } }));
+var claudeStream = (req, apiKeyOverride) => Stream_exports.async((emit) => {
+  const provider = req.provider;
+  const options = buildOptions(req, apiKeyOverride);
+  const prompt = messagesToPrompt(req);
+  let cancelled = false;
+  void (async () => {
+    try {
+      const response = query({ prompt, options });
+      for await (const message of response) {
+        if (cancelled) break;
+        const msg = message;
+        if (msg.type === "assistant" && msg.message?.content) {
+          for (const block of msg.message.content) {
+            if (block.type === "text" && block.text) {
+              void emit.single({ _tag: "text", delta: block.text });
+            }
+          }
+        }
+        if (msg.type === "result") {
+          void emit.single({
+            _tag: "done",
+            usage: msg.usage ? {
+              inputTokens: msg.usage.input_tokens ?? 0,
+              outputTokens: msg.usage.output_tokens ?? 0
+            } : void 0
+          });
+        }
+      }
+      void emit.end();
+    } catch (cause) {
+      void emit.fail(
+        new AgentError({
+          provider,
+          kind: "protocol",
+          cause
+        })
+      );
+    }
+  })();
+  return Effect_exports.sync(() => {
+    cancelled = true;
+  });
+});
+
+// packages/feature/agent/src/effect/ollamaAdapter.ts
+import { streamText } from "ai";
+
+// packages/feature/agent/src/server/api/chat/ollama/model.ts
+import { createOpenAI } from "@ai-sdk/openai";
+var ollamaFetch = async (input, init) => {
+  if (init && typeof init.body === "string") {
+    try {
+      const body = JSON.parse(init.body);
+      if (Array.isArray(body.messages)) {
+        let mutated = false;
+        for (const m of body.messages) {
+          if (m && m.role === "assistant" && m.content == null) {
+            m.content = "";
+            mutated = true;
+          }
+        }
+        if (mutated) init = { ...init, body: JSON.stringify(body) };
+      }
+    } catch {
+    }
+  }
+  return fetch(input, init);
+};
+function createOllamaModel(modelName) {
+  const provider = createOpenAI({
+    // EFFECT.md §0 exemption: third-party plugin API key in the same category as
+    // OPENAI_API_KEY / ANTHROPIC_API_KEY; not pulled into CockpitConfig (would over-couple
+    // cockpit configuration with third-party authentication).
+    apiKey: process.env.OLLAMA_API_KEY || "ollama",
+    baseURL: getOllamaOpenAIBaseURL(),
+    fetch: ollamaFetch
+  });
+  return provider.chat(modelName);
+}
+
+// packages/feature/agent/src/effect/ollamaAdapter.ts
+var toModelMessages = (messages) => messages.map((m) => ({
+  role: m.role,
+  content: m.content
+}));
+var ollamaChat = (req) => Effect_exports.gen(function* () {
+  const chunks = yield* Stream_exports.runCollect(ollamaStream(req));
+  let text = "";
+  let usage;
+  for (const c of chunks) {
+    if (c._tag === "text") text += c.delta;
+    else if (c._tag === "done") usage = c.usage;
+  }
+  return {
+    message: { role: "assistant", content: text },
+    usage
+  };
+}).pipe(Effect_exports.withSpan("agent.chat", { attributes: { provider: "ollama", model: req.model } }));
+var ollamaStream = (req) => Stream_exports.async((emit) => {
+  const abortController = new AbortController();
+  void (async () => {
+    try {
+      const ollamaModel = createOllamaModel(req.model);
+      const result = streamText({
+        model: ollamaModel,
+        messages: toModelMessages(req.messages),
+        temperature: req.temperature ?? 0,
+        abortSignal: abortController.signal
+      });
+      for await (const part of result.fullStream) {
+        if (part.type === "text-delta") {
+          const delta = part.text;
+          if (delta) void emit.single({ _tag: "text", delta });
+        } else if (part.type === "finish") {
+          const u = part.totalUsage;
+          void emit.single({
+            _tag: "done",
+            usage: u ? { inputTokens: u.inputTokens ?? 0, outputTokens: u.outputTokens ?? 0 } : void 0
+          });
+        }
+      }
+      void emit.end();
+    } catch (cause) {
+      void emit.fail(
+        new AgentError({ provider: "ollama", kind: "protocol", cause })
+      );
+    }
+  })();
+  return Effect_exports.sync(() => abortController.abort());
+});
+
+// packages/feature/agent/src/effect/agentLive.ts
+var retryableKinds = /* @__PURE__ */ new Set([
+  "rate-limit",
+  "timeout",
+  "unknown"
+]);
+var isRetryable = (e) => retryableKinds.has(e.kind);
+var withAgentRetry = (effect) => effect.pipe(
+  Effect_exports.retry({
+    schedule: agentRetry,
+    while: (e) => isRetryable(e)
+  })
+);
+var dispatchChat = (req) => {
+  switch (req.provider) {
+    case "ollama":
+      return ollamaChat(req);
+    case "claude":
+    case "codex":
+    case "kimi":
+    case "deepseek":
+      return claudeChat(req);
+  }
+};
+var dispatchStream = (req) => {
+  switch (req.provider) {
+    case "ollama":
+      return ollamaStream(req);
+    case "claude":
+    case "codex":
+    case "kimi":
+    case "deepseek":
+      return claudeStream(req);
+  }
+};
+var AgentServiceLive = Layer_exports.succeed(
+  AgentService,
+  AgentService.of({
+    chat: (req) => withAgentRetry(dispatchChat(req)),
+    stream: (req) => dispatchStream(req)
+    // Streaming is excluded from retry (mid-stream retry would drop already-emitted content)
+  })
+);
+
+// packages/shared/effect-runtime/src/server/runtime.ts
+var isDev = process.env.COCKPIT_ENV === "dev";
+var ServerBaseLayer = Layer_exports.unwrapEffect(
+  Effect_exports.gen(function* () {
+    const cfg = yield* CockpitConfig;
+    const loggerLayer = isDev ? LoggerLivePretty : LoggerLiveProd(cfg.logFile);
+    const tracerLayer = isDev ? TracerLivePretty : TracerLiveNoop;
+    return Layer_exports.mergeAll(loggerLayer, tracerLayer, ConfigLive);
+  })
+);
+var AppLayer = Layer_exports.mergeAll(
+  ServerBaseLayer,
+  // DB services
+  PgServiceLive,
+  MySQLServiceLive,
+  RedisServiceLive,
+  Neo4jServiceLive,
+  MongoServiceLive,
+  // Scheduler
+  SchedulerLive,
+  // Agent
+  AgentServiceLive
+);
+var AppRuntime = ManagedRuntime_exports.make(AppLayer);
+
+// packages/feature/agent/src/server/scheduledTasks.ts
 function parseCronField(field, min, max) {
   const values = [];
   for (const part of field.split(",")) {
@@ -55,61 +1208,82 @@ function getNextCronTime(cronExpr, after = /* @__PURE__ */ new Date()) {
   }
   return after.getTime() + 864e5;
 }
-async function sendChatMessage(task) {
-  try {
-    const options = {
-      resume: task.sessionId,
-      cwd: task.cwd,
-      settingSources: ["user", "project", "local"],
-      allowedTools: [
-        "Read",
-        "Write",
-        "Edit",
-        "Bash",
-        "Glob",
-        "Grep",
-        "WebFetch",
-        "WebSearch",
-        "Task",
-        "TodoWrite",
-        "mcp__*"
-      ],
-      permissionMode: "bypassPermissions",
-      allowDangerouslySkipPermissions: true,
-      // For claude2 engine, override config directory to ~/.claude2
-      ...task.engine === "claude2" && {
-        env: { ...process.env, CLAUDE_CONFIG_DIR: CLAUDE2_DIR }
-      }
-    };
-    await updateGlobalState(task.cwd, task.sessionId, "loading", void 0, task.message).catch(() => {
-    });
-    const MAX_COMPACTION_RETRIES = 1;
-    for (let attempt = 0; attempt <= MAX_COMPACTION_RETRIES; attempt++) {
-      let receivedResult = false;
-      const response = query({
-        // First attempt: send the actual message
-        // Retry after compaction: send 'continue' to resume
-        prompt: attempt === 0 ? task.message : "continue",
-        options
-      });
-      for await (const message of response) {
-        const msg = message;
-        if (msg.type === "result") {
-          receivedResult = true;
-        }
-      }
-      if (receivedResult) break;
-      console.log(`[ScheduledTask] Stream ended without result, resuming (attempt ${attempt + 1}/${MAX_COMPACTION_RETRIES})`);
+var sendChatMessageEff = (task) => {
+  const options = {
+    resume: task.sessionId,
+    cwd: task.cwd,
+    settingSources: ["user", "project", "local"],
+    allowedTools: [
+      "Read",
+      "Write",
+      "Edit",
+      "Bash",
+      "Glob",
+      "Grep",
+      "WebFetch",
+      "WebSearch",
+      "Task",
+      "TodoWrite",
+      "mcp__*"
+    ],
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    // For claude2 engine, override config directory to ~/.claude2
+    ...task.engine === "claude2" && {
+      env: { ...process.env, CLAUDE_CONFIG_DIR: CLAUDE2_DIR }
     }
-    const title = await getSessionTitle(task.cwd, task.sessionId);
-    await updateGlobalState(task.cwd, task.sessionId, "unread", title);
-    return true;
-  } catch (error) {
-    console.error(`[ScheduledTask] Failed to send message for task ${task.id}:`, error);
-    await updateGlobalState(task.cwd, task.sessionId, "unread").catch(() => {
+  };
+  const MAX_COMPACTION_RETRIES = 1;
+  return Effect_exports.gen(function* () {
+    yield* Effect_exports.tryPromise(
+      () => updateGlobalState(task.cwd, task.sessionId, "loading", void 0, task.message)
+    ).pipe(Effect_exports.orElse(() => Effect_exports.void));
+    yield* Effect_exports.tryPromise({
+      try: async () => {
+        for (let attempt = 0; attempt <= MAX_COMPACTION_RETRIES; attempt++) {
+          let receivedResult = false;
+          const response = query2({
+            prompt: attempt === 0 ? task.message : "continue",
+            options
+          });
+          for await (const message of response) {
+            const msg = message;
+            if (msg.type === "result") receivedResult = true;
+          }
+          if (receivedResult) break;
+          console.log(`[ScheduledTask] Stream ended without result, resuming (attempt ${attempt + 1}/${MAX_COMPACTION_RETRIES})`);
+        }
+      },
+      catch: (cause) => (
+        // claude2 is a separate Anthropic credential set; the SDK is still claude. Classify under the 'claude' provider.
+        new AgentError({
+          provider: "claude",
+          kind: "unknown",
+          cause
+        })
+      )
     });
-    return false;
-  }
+    const title = yield* Effect_exports.tryPromise(() => getSessionTitle(task.cwd, task.sessionId)).pipe(
+      Effect_exports.orElseSucceed(() => void 0)
+    );
+    yield* Effect_exports.tryPromise(
+      () => updateGlobalState(task.cwd, task.sessionId, "unread", title)
+    ).pipe(Effect_exports.orElse(() => Effect_exports.void));
+    return true;
+  }).pipe(
+    Effect_exports.catchAll(
+      (err) => Effect_exports.gen(function* () {
+        console.error(`[ScheduledTask] Failed to send message for task ${task.id}:`, err);
+        yield* Effect_exports.tryPromise(
+          () => updateGlobalState(task.cwd, task.sessionId, "unread")
+        ).pipe(Effect_exports.orElse(() => Effect_exports.void));
+        return false;
+      })
+    )
+  );
+};
+async function sendChatMessage(task) {
+  return AppRuntime.runPromise(sendChatMessageEff(task));
 }
 var ScheduledTaskManager = class {
   constructor() {
@@ -123,17 +1297,15 @@ var ScheduledTaskManager = class {
     this.onTaskFired = null;
   }
   /**
-   * Return the current port (from explicit init or environment variables).
+   * Return the current port (from explicit init or CockpitConfig).
+   * CockpitConfig handles `Config.orElse(COCKPIT_PORT, PORT)` plus derived
+   * dev/prod defaults; a single sync runPromise gets the unified typed value,
+   * cached into this.port.
    */
   getPort() {
     if (this.port) return this.port;
-    const envPort = parseInt(process.env.COCKPIT_PORT || "0", 10);
-    if (envPort) {
-      this.port = envPort;
-      return this.port;
-    }
-    const isDev = process.env.COCKPIT_ENV === "dev";
-    this.port = isDev ? 3456 : 3457;
+    const cfg = AppRuntime.runSync(CockpitConfig);
+    this.port = cfg.port;
     return this.port;
   }
   /**
@@ -466,9 +1638,10 @@ var ScheduledTaskManager = class {
     }
   }
 };
-var g = globalThis;
-var scheduledTaskManager = g.__scheduledTaskManager ?? (g.__scheduledTaskManager = new ScheduledTaskManager());
+var g2 = globalThis;
+var scheduledTaskManager = g2.__scheduledTaskManager ?? (g2.__scheduledTaskManager = new ScheduledTaskManager());
 export {
   getNextCronTime,
-  scheduledTaskManager
+  scheduledTaskManager,
+  sendChatMessageEff
 };