jowork 0.1.0

package/dist/cli.js

@@ -0,0 +1,1407 @@
+#!/usr/bin/env node
+import {
+  configPath,
+  createJoWorkMcpServer,
+  credentialsDir,
+  dbPath,
+  joworkDir,
+  logError,
+  logInfo,
+  logsDir
+} from "./chunk-S24PDC46.js";
+import {
+  createId
+} from "./chunk-3NMLDZBL.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/db/manager.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+var MIGRATIONS = [
+  // 001 — Base tables
+  `
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS connector_configs (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      name TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'disconnected',
+      config TEXT NOT NULL DEFAULT '{}',
+      last_sync_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS objects (
+      id TEXT PRIMARY KEY,
+      source TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      uri TEXT NOT NULL UNIQUE,
+      title TEXT,
+      summary TEXT,
+      tags TEXT,
+      doc_map TEXT,
+      content_hash TEXT,
+      last_synced_at INTEGER,
+      created_at INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS object_bodies (
+      object_id TEXT PRIMARY KEY REFERENCES objects(id),
+      content TEXT NOT NULL,
+      content_type TEXT,
+      fetched_at INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS object_chunks (
+      id TEXT PRIMARY KEY,
+      object_id TEXT NOT NULL REFERENCES objects(id),
+      idx INTEGER NOT NULL,
+      heading TEXT,
+      content TEXT NOT NULL,
+      tokens INTEGER,
+      UNIQUE(object_id, idx)
+    );
+    CREATE INDEX IF NOT EXISTS idx_chunks_object ON object_chunks(object_id);
+
+    CREATE TABLE IF NOT EXISTS sync_cursors (
+      connector_id TEXT PRIMARY KEY,
+      cursor TEXT,
+      last_synced_at INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      tags TEXT,
+      scope TEXT NOT NULL DEFAULT 'personal',
+      pinned INTEGER DEFAULT 0,
+      source TEXT,
+      access_count INTEGER NOT NULL DEFAULT 0,
+      last_used_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope);
+  `,
+  // 002 — Object links
+  `
+    CREATE TABLE IF NOT EXISTS object_links (
+      id TEXT PRIMARY KEY,
+      source_object_id TEXT NOT NULL,
+      target_object_id TEXT,
+      link_type TEXT NOT NULL,
+      identifier TEXT NOT NULL,
+      metadata TEXT,
+      confidence TEXT DEFAULT 'medium',
+      created_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_object_links_source ON object_links(source_object_id);
+    CREATE INDEX IF NOT EXISTS idx_object_links_target ON object_links(target_object_id);
+    CREATE INDEX IF NOT EXISTS idx_object_links_type ON object_links(link_type);
+  `,
+  // 003 — Goal-Signal-Measure system
+  `
+    CREATE TABLE IF NOT EXISTS goals (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      autonomy_level TEXT NOT NULL DEFAULT 'copilot',
+      parent_id TEXT,
+      evolved_from TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS signals (
+      id TEXT PRIMARY KEY,
+      goal_id TEXT NOT NULL REFERENCES goals(id),
+      title TEXT NOT NULL,
+      source TEXT NOT NULL,
+      metric TEXT NOT NULL,
+      direction TEXT NOT NULL,
+      poll_interval INTEGER DEFAULT 3600,
+      config TEXT,
+      current_value REAL,
+      last_polled_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS measures (
+      id TEXT PRIMARY KEY,
+      signal_id TEXT NOT NULL REFERENCES signals(id),
+      threshold REAL NOT NULL,
+      comparison TEXT NOT NULL,
+      upper_bound REAL,
+      current REAL,
+      met INTEGER DEFAULT 0,
+      last_evaluated_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_goals_status ON goals(status);
+    CREATE INDEX IF NOT EXISTS idx_signals_goal ON signals(goal_id);
+    CREATE INDEX IF NOT EXISTS idx_measures_signal ON measures(signal_id);
+  `
+];
+var DbManager = class {
+  db;
+  sqlite;
+  constructor(dbPath2) {
+    this.sqlite = new Database(dbPath2);
+    this.sqlite.pragma("journal_mode = WAL");
+    this.sqlite.pragma("busy_timeout = 5000");
+    this.sqlite.pragma("foreign_keys = ON");
+    this.db = drizzle(this.sqlite);
+    logInfo("database", "Database opened", { dbPath: dbPath2 });
+  }
+  /** Run all pending migrations, then ensure FTS virtual tables. */
+  migrate() {
+    this.sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS schema_version (
+        version INTEGER PRIMARY KEY
+      );
+    `);
+    const currentRow = this.sqlite.prepare(
+      "SELECT MAX(version) AS v FROM schema_version"
+    ).get();
+    const current = currentRow?.v ?? 0;
+    for (let i = current; i < MIGRATIONS.length; i++) {
+      const version = i + 1;
+      const sql = MIGRATIONS[i];
+      const txn = this.sqlite.transaction(() => {
+        this.sqlite.exec(sql);
+        this.sqlite.prepare("INSERT INTO schema_version (version) VALUES (?)").run(version);
+      });
+      try {
+        txn();
+        logInfo("database", `Migration ${String(version).padStart(3, "0")} applied`);
+      } catch (err) {
+        logError("database", `Migration ${String(version).padStart(3, "0")} failed`, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    }
+    this.ensureFts();
+  }
+  ensureFts() {
+    const ftsCheck = this.sqlite.prepare(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name IN ('objects_fts', 'memories_fts')`
+    ).all();
+    const existing = new Set(ftsCheck.map((r) => r.name));
+    if (!existing.has("objects_fts")) {
+      this.sqlite.exec(`
+        CREATE VIRTUAL TABLE objects_fts USING fts5(
+          title, summary, tags, source, source_type, body_excerpt,
+          content=''
+        );
+      `);
+      logInfo("database", "Created objects_fts virtual table");
+    }
+    if (!existing.has("memories_fts")) {
+      this.sqlite.exec(`
+        CREATE VIRTUAL TABLE memories_fts USING fts5(
+          title, content, tags,
+          content=''
+        );
+      `);
+      const rows = this.sqlite.prepare(
+        `SELECT rowid, title, content, COALESCE(tags, '') AS tags FROM memories`
+      ).all();
+      if (rows.length > 0) {
+        const insert = this.sqlite.prepare(
+          `INSERT INTO memories_fts(rowid, title, content, tags) VALUES (?, ?, ?, ?)`
+        );
+        for (const r of rows) {
+          insert.run(r.rowid, r.title, r.content, r.tags);
+        }
+        logInfo("database", `Backfilled ${rows.length} memories into FTS`);
+      }
+      logInfo("database", "Created memories_fts virtual table");
+    }
+  }
+  /** Convenience: migrate + return self for chaining. */
+  ensureTables() {
+    this.migrate();
+    return this;
+  }
+  getDb() {
+    return this.db;
+  }
+  getSqlite() {
+    return this.sqlite;
+  }
+  close() {
+    try {
+      this.sqlite.close();
+      logInfo("database", "Database closed");
+    } catch {
+    }
+  }
+};
+
+// src/utils/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+var DEFAULT_CONFIG = {
+  version: "0.1.0",
+  initialized: false,
+  connectors: {}
+};
+function readConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return { ...DEFAULT_CONFIG };
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function writeConfig(config) {
+  mkdirSync(joworkDir(), { recursive: true });
+  writeFileSync(configPath(), JSON.stringify(config, null, 2));
+}
+
+// src/commands/init.ts
+function initCommand(program2) {
+  program2.command("init").description("Initialize JoWork \u2014 create local database and config").action(async () => {
+    const config = readConfig();
+    if (config.initialized && existsSync2(dbPath())) {
+      console.log("\u2713 JoWork already initialized at", joworkDir());
+      return;
+    }
+    console.log("Initializing JoWork...");
+    const db = new DbManager(dbPath());
+    db.ensureTables();
+    db.close();
+    writeConfig({ ...config, initialized: true });
+    console.log("\u2713 Database created at", dbPath());
+    console.log("\u2713 Config saved at", joworkDir());
+    console.log("");
+    console.log("Next steps:");
+    console.log("  jowork register claude-code   # Connect to Claude Code");
+    console.log("  jowork connect feishu          # Connect Feishu data source");
+  });
+}
+
+// src/commands/serve.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, appendFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join2 } from "path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Cron } from "croner";
+
+// src/connectors/credential-store.ts
+import {
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  chmodSync,
+  unlinkSync,
+  readdirSync
+} from "fs";
+import { join } from "path";
+function saveCredential(name, credential) {
+  const dir = credentialsDir();
+  mkdirSync2(dir, { recursive: true });
+  const filePath = join(dir, `${name}.json`);
+  writeFileSync2(filePath, JSON.stringify(credential, null, 2));
+  try {
+    chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function loadCredential(name) {
+  const filePath = join(credentialsDir(), `${name}.json`);
+  if (!existsSync3(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listCredentials() {
+  const dir = credentialsDir();
+  if (!existsSync3(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+}
+
+// src/sync/linker.ts
+var PATTERNS = [
+  // GitHub/GitLab PR/Issue references
+  { type: "pr", regex: /(?:PR|pr|Pull Request|pull request)\s*#?(\d+)/g, confidence: "high" },
+  { type: "issue", regex: /(?:issue|Issue|ISSUE)\s*#?(\d+)/g, confidence: "high" },
+  { type: "issue", regex: /#(\d{2,6})\b/g, confidence: "medium" },
+  // bare #123
+  // Linear-style issue keys
+  { type: "issue", regex: /\b([A-Z]{2,10}-\d{1,6})\b/g, confidence: "high" },
+  // Git commit SHA
+  { type: "commit", regex: /\b([0-9a-f]{7,40})\b/g, confidence: "low" },
+  // URLs
+  { type: "url", regex: /https?:\/\/[^\s<>"{}|\\^`\[\]]+/g, confidence: "high" },
+  // @mentions (feishu user_id format)
+  { type: "mention", regex: /@([a-zA-Z0-9_]+)/g, confidence: "medium" }
+];
+function extractLinks(content) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of PATTERNS) {
+    if (pattern.type === "commit" && content.length < 100) continue;
+    const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const identifier = match[1] ?? match[0];
+      const key = `${pattern.type}:${identifier}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      if (identifier.length < 3) continue;
+      if (pattern.type === "commit" && identifier.length < 7) continue;
+      links.push({
+        linkType: pattern.type,
+        identifier,
+        confidence: pattern.confidence
+      });
+    }
+  }
+  return links;
+}
+function processObjectLinks(sqlite, objectId, content) {
+  const links = extractLinks(content);
+  if (links.length === 0) return 0;
+  const insert = sqlite.prepare(`
+    INSERT OR IGNORE INTO object_links (id, source_object_id, target_object_id, link_type, identifier, metadata, confidence, created_at)
+    VALUES (?, ?, NULL, ?, ?, ?, ?, ?)
+  `);
+  const now = Date.now();
+  let count = 0;
+  const batch = sqlite.transaction(() => {
+    for (const link of links) {
+      const id = `${objectId}:${link.linkType}:${link.identifier}`.slice(0, 64);
+      insert.run(
+        id,
+        objectId,
+        link.linkType,
+        link.identifier,
+        link.metadata ? JSON.stringify(link.metadata) : null,
+        link.confidence,
+        now
+      );
+      count++;
+    }
+  });
+  batch();
+  return count;
+}
+function linkAllUnprocessed(sqlite) {
+  const unprocessed = sqlite.prepare(`
+    SELECT o.id, ob.content FROM objects o
+    JOIN object_bodies ob ON ob.object_id = o.id
+    LEFT JOIN object_links ol ON ol.source_object_id = o.id
+    WHERE ol.id IS NULL
+    LIMIT 1000
+  `).all();
+  let linksCreated = 0;
+  for (const obj of unprocessed) {
+    linksCreated += processObjectLinks(sqlite, obj.id, obj.content);
+  }
+  logInfo("linker", `Processed ${unprocessed.length} objects, created ${linksCreated} links`);
+  return { processed: unprocessed.length, linksCreated };
+}
+
+// src/commands/serve.ts
+function serveCommand(program2) {
+  program2.command("serve").description("Start MCP server (stdio mode for agents, or --daemon for background)").option("--daemon", "Run as background daemon with cron sync").action(async (opts) => {
+    const resolvedDbPath = process.env["JOWORK_DB_PATH"] ?? dbPath();
+    if (!existsSync4(resolvedDbPath)) {
+      console.error("Error: JoWork not initialized. Run `jowork init` first.");
+      process.exit(1);
+    }
+    if (opts.daemon) {
+      await startDaemon();
+      return;
+    }
+    const server = createJoWorkMcpServer({ dbPath: resolvedDbPath });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  });
+}
+var SYNC_INTERVAL = "*/15 * * * *";
+function daemonLog(level, msg, ctx) {
+  const logFile = join2(logsDir(), "daemon.log");
+  const entry = JSON.stringify({
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    msg,
+    ...ctx
+  });
+  appendFileSync(logFile, entry + "\n");
+}
+async function startDaemon() {
+  const pidFile = join2(joworkDir(), "daemon.pid");
+  if (existsSync4(pidFile)) {
+    const existingPid = readFileSync3(pidFile, "utf-8").trim();
+    try {
+      process.kill(parseInt(existingPid, 10), 0);
+      console.error(`Daemon already running (PID ${existingPid}). Kill it first or delete ${pidFile}`);
+      process.exit(1);
+    } catch {
+    }
+  }
+  mkdirSync3(joworkDir(), { recursive: true });
+  writeFileSync3(pidFile, process.pid.toString());
+  const cleanup = () => {
+    try {
+      unlinkSync2(pidFile);
+    } catch {
+    }
+    daemonLog("info", "Daemon stopped");
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const envFile = join2(process.cwd(), ".env");
+  if (existsSync4(envFile)) {
+    for (const line of readFileSync3(envFile, "utf-8").split("\n")) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.+)$/);
+      if (match) process.env[match[1]] = match[2];
+    }
+  }
+  daemonLog("info", "Daemon started", { pid: process.pid });
+  await runSync();
+  const _syncJob = new Cron(SYNC_INTERVAL, async () => {
+    await runSync();
+  });
+  console.log(`Daemon started (PID ${process.pid})`);
+  console.log(`  Sync: every 15 minutes`);
+  console.log(`  PID file: ${pidFile}`);
+  console.log(`  Log file: ${join2(logsDir(), "daemon.log")}`);
+  console.log("  Press Ctrl+C to stop");
+  setInterval(() => {
+  }, 6e4);
+}
+async function runSync() {
+  const sources = listCredentials();
+  if (sources.length === 0) {
+    daemonLog("info", "No sources connected, skipping sync");
+    return;
+  }
+  daemonLog("info", "Sync cycle starting", { sources });
+  let db = null;
+  try {
+    db = new DbManager(dbPath());
+    db.ensureTables();
+    const sqlite = db.getSqlite();
+    for (const source of sources) {
+      const cred = loadCredential(source);
+      if (!cred) {
+        daemonLog("warn", `No credentials for ${source}, skipping`);
+        continue;
+      }
+      try {
+        switch (source) {
+          case "feishu":
+            await syncFeishuDaemon(db, cred.data);
+            break;
+          default:
+            daemonLog("info", `Source ${source} sync not implemented yet`);
+        }
+      } catch (err) {
+        daemonLog("error", `Failed to sync ${source}`, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    const { processed, linksCreated } = linkAllUnprocessed(sqlite);
+    if (processed > 0) {
+      daemonLog("info", "Entity extraction complete", { processed, linksCreated });
+    }
+  } catch (err) {
+    daemonLog("error", "Sync cycle failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  } finally {
+    db?.close();
+  }
+  daemonLog("info", "Sync cycle complete");
+}
+async function syncFeishuDaemon(db, data) {
+  const { appId, appSecret } = data;
+  if (!appId || !appSecret) throw new Error("Missing Feishu credentials");
+  const tokenRes = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ app_id: appId, app_secret: appSecret })
+  });
+  const tokenData = await tokenRes.json();
+  if (tokenData.code !== 0) throw new Error(`Auth failed: code ${tokenData.code}`);
+  const token = tokenData.tenant_access_token;
+  const chatsRes = await fetch("https://open.feishu.cn/open-apis/im/v1/chats?page_size=50", {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  const chatsData = await chatsRes.json();
+  if (chatsData.code !== 0) throw new Error(`Failed to list chats: code ${chatsData.code}`);
+  const chats = chatsData.data?.items ?? [];
+  const sqlite = db.getSqlite();
+  let totalMessages = 0;
+  let newMessages = 0;
+  const { createId: createId2 } = await import("./src-WYAQWZZZ.js");
+  for (const chat of chats) {
+    const cursorRow = sqlite.prepare(`SELECT cursor FROM sync_cursors WHERE connector_id = ?`).get(`feishu:${chat.chat_id}`);
+    let pageToken = cursorRow?.cursor ?? void 0;
+    let hasMore = true;
+    while (hasMore) {
+      const url = new URL("https://open.feishu.cn/open-apis/im/v1/messages");
+      url.searchParams.set("container_id_type", "chat");
+      url.searchParams.set("container_id", chat.chat_id);
+      url.searchParams.set("page_size", "50");
+      url.searchParams.set("sort_type", "ByCreateTimeAsc");
+      if (pageToken) url.searchParams.set("page_token", pageToken);
+      const msgRes = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      const msgData = await msgRes.json();
+      if (msgData.code !== 0) {
+        if (msgData.code === 99991400) {
+          daemonLog("warn", `Rate limited on ${chat.name}, waiting 5s`);
+          await new Promise((r) => setTimeout(r, 5e3));
+          continue;
+        }
+        daemonLog("warn", `Failed to get messages from "${chat.name}": code ${msgData.code}`);
+        break;
+      }
+      const messages = msgData.data?.items ?? [];
+      const insertObj = sqlite.prepare(`
+        INSERT OR IGNORE INTO objects (id, source, source_type, uri, title, summary, tags, content_hash, last_synced_at, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      const insertBody = sqlite.prepare(`
+        INSERT OR IGNORE INTO object_bodies (object_id, content, content_type, fetched_at)
+        VALUES (?, ?, ?, ?)
+      `);
+      const batchInsert = sqlite.transaction((msgs) => {
+        for (const msg of msgs) {
+          if (msg.msg_type !== "text" && msg.msg_type !== "post") continue;
+          let content = "";
+          try {
+            const bodyContent = JSON.parse(msg.body?.content ?? "{}");
+            const raw = bodyContent.text ?? bodyContent.content ?? bodyContent;
+            content = typeof raw === "string" ? raw : JSON.stringify(raw);
+          } catch {
+            content = msg.body?.content ?? "";
+          }
+          if (!content || typeof content !== "string") continue;
+          const uri = `feishu://message/${msg.message_id}`;
+          const hash = simpleHash(content);
+          const now = Date.now();
+          const id = createId2("obj");
+          const createTime = msg.create_time ? parseInt(msg.create_time) : now;
+          const summary = content.length > 200 ? content.slice(0, 200) + "..." : content;
+          insertObj.run(id, "feishu", "message", uri, `${chat.name}`, summary, JSON.stringify(["feishu", "message"]), hash, now, createTime);
+          insertBody.run(id, content, "text/plain", now);
+          newMessages++;
+        }
+      });
+      for (let i = 0; i < messages.length; i += 100) {
+        batchInsert(messages.slice(i, i + 100));
+      }
+      totalMessages += messages.length;
+      hasMore = msgData.data.has_more;
+      pageToken = msgData.data.page_token;
+      if (pageToken) {
+        sqlite.prepare(`INSERT OR REPLACE INTO sync_cursors (connector_id, cursor, last_synced_at) VALUES (?, ?, ?)`).run(`feishu:${chat.chat_id}`, pageToken, Date.now());
+      }
+    }
+  }
+  try {
+    sqlite.exec(`INSERT INTO objects_fts(objects_fts) VALUES('rebuild')`);
+  } catch {
+  }
+  daemonLog("info", "Feishu sync complete", { totalMessages, newMessages, chats: chats.length });
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return hash.toString(36);
+}
+
+// src/commands/register.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, copyFileSync, existsSync as existsSync5 } from "fs";
+import { join as join3 } from "path";
+var HOME = process.env["HOME"] ?? "";
+function registerCommand(program2) {
+  program2.command("register").description("Register JoWork MCP server with an AI agent engine").argument("<engine>", "Engine to register with: claude-code, codex").action(async (engine) => {
+    switch (engine) {
+      case "claude-code":
+        registerClaudeCode();
+        break;
+      case "codex":
+        console.log("Codex registration not yet implemented.");
+        break;
+      default:
+        console.error(`Unknown engine: ${engine}. Supported: claude-code, codex`);
+        process.exit(1);
+    }
+  });
+}
+function registerClaudeCode() {
+  const configPath2 = join3(HOME, ".claude.json");
+  if (existsSync5(configPath2)) {
+    const backupPath = configPath2 + ".bak";
+    copyFileSync(configPath2, backupPath);
+    console.log(`\u2713 Backed up existing config to ${backupPath}`);
+  }
+  let config = {};
+  if (existsSync5(configPath2)) {
+    try {
+      config = JSON.parse(readFileSync4(configPath2, "utf-8"));
+    } catch {
+      console.error(`Warning: ${configPath2} contains invalid JSON. Creating fresh config.`);
+      console.error(`  Original backed up to ${configPath2}.bak`);
+      config = {};
+    }
+  }
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers["jowork"] = {
+    command: "jowork",
+    args: ["serve"]
+  };
+  writeFileSync4(configPath2, JSON.stringify(config, null, 2));
+  console.log(`\u2713 Registered JoWork MCP server in ${configPath2}`);
+  console.log("");
+  console.log("Claude Code will now have access to JoWork tools:");
+  console.log("  search_data, read_memory, write_memory, search_memory, ...");
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync6, statSync } from "fs";
+function statusCommand(program2) {
+  program2.command("status").description("Show JoWork system status").action(async () => {
+    if (!existsSync6(dbPath())) {
+      console.log("JoWork is not initialized. Run `jowork init` first.");
+      return;
+    }
+    const db = new DbManager(dbPath());
+    const sqlite = db.getSqlite();
+    console.log("JoWork Status");
+    console.log("\u2500".repeat(40));
+    console.log(`  Data dir:    ${joworkDir()}`);
+    const stats = statSync(dbPath());
+    const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+    console.log(`  Database:    ${sizeMB} MB`);
+    console.log("");
+    console.log("Data:");
+    const tables = ["objects", "memories", "connector_configs", "object_links"];
+    for (const table of tables) {
+      try {
+        const row = sqlite.prepare(`SELECT COUNT(*) as count FROM ${table}`).get();
+        console.log(`  ${table.padEnd(20)} ${row.count} rows`);
+      } catch {
+        console.log(`  ${table.padEnd(20)} (not created)`);
+      }
+    }
+    console.log("");
+    console.log("Connectors:");
+    const creds = listCredentials();
+    if (creds.length === 0) {
+      console.log("  (none connected)");
+    } else {
+      for (const name of creds) {
+        console.log(`  \u2713 ${name}`);
+      }
+    }
+    try {
+      const cursor = sqlite.prepare(`SELECT connector_id, last_synced_at FROM sync_cursors ORDER BY last_synced_at DESC LIMIT 1`).get();
+      if (cursor) {
+        const lastSync = new Date(cursor.last_synced_at).toLocaleString();
+        console.log(`
+Last sync: ${cursor.connector_id} at ${lastSync}`);
+      }
+    } catch {
+    }
+    db.close();
+  });
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+function doctorCommand(program2) {
+  program2.command("doctor").description("Run diagnostic checks").action(async () => {
+    console.log("JoWork Doctor");
+    console.log("\u2500".repeat(40));
+    let ok = true;
+    const nodeVersion = process.versions.node;
+    const major = parseInt(nodeVersion.split(".")[0]);
+    if (major >= 20) {
+      console.log(`  \u2713 Node.js ${nodeVersion}`);
+    } else {
+      console.log(`  \u2717 Node.js ${nodeVersion} (requires >= 20)`);
+      ok = false;
+    }
+    if (existsSync7(joworkDir())) {
+      console.log(`  \u2713 Data directory exists: ${joworkDir()}`);
+    } else {
+      console.log(`  \u2717 Data directory missing: ${joworkDir()}`);
+      ok = false;
+    }
+    if (existsSync7(dbPath())) {
+      try {
+        const Database3 = (await import("better-sqlite3")).default;
+        const db = new Database3(dbPath());
+        db.pragma("integrity_check");
+        const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+        console.log(`  \u2713 Database OK (${tables.length} tables)`);
+        db.close();
+      } catch (err) {
+        console.log(`  \u2717 Database error: ${err}`);
+        ok = false;
+      }
+    } else {
+      console.log(`  \u2717 Database not found. Run \`jowork init\``);
+      ok = false;
+    }
+    if (existsSync7(configPath())) {
+      console.log(`  \u2713 Config file exists`);
+    } else {
+      console.log(`  \u2717 Config file missing`);
+      ok = false;
+    }
+    const claudeConfigPath = join4(process.env["HOME"] ?? "", ".claude.json");
+    if (existsSync7(claudeConfigPath)) {
+      try {
+        const config = JSON.parse(readFileSync5(claudeConfigPath, "utf-8"));
+        if (config.mcpServers?.jowork) {
+          console.log(`  \u2713 Registered with Claude Code`);
+        } else {
+          console.log(`  \u25CB Not registered with Claude Code (run \`jowork register claude-code\`)`);
+        }
+      } catch {
+        console.log(`  \u25CB Cannot read Claude Code config`);
+      }
+    } else {
+      console.log(`  \u25CB Claude Code config not found`);
+    }
+    console.log("");
+    console.log(ok ? "\u2713 All checks passed" : "\u2717 Some checks failed");
+  });
+}
+
+// src/commands/export.ts
+import { existsSync as existsSync8, writeFileSync as writeFileSync5 } from "fs";
+import Database2 from "better-sqlite3";
+function exportCommand(program2) {
+  program2.command("export").description("Export database backup").option("--format <format>", "Export format: sqlite or json", "sqlite").option("--output <path>", "Output file path").action(async (opts) => {
+    if (!existsSync8(dbPath())) {
+      console.error("Error: JoWork not initialized. Run `jowork init` first.");
+      process.exit(1);
+    }
+    const outputPath = opts.output ?? `jowork-backup-${Date.now()}.${opts.format === "json" ? "json" : "db"}`;
+    if (opts.format === "sqlite") {
+      const db = new Database2(dbPath());
+      await db.backup(outputPath);
+      db.close();
+      console.log(`\u2713 Database backed up to ${outputPath}`);
+    } else if (opts.format === "json") {
+      const db = new Database2(dbPath());
+      const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts%' AND name != 'schema_version'").all();
+      const data = {};
+      for (const { name } of tables) {
+        data[name] = db.prepare(`SELECT * FROM "${name}"`).all();
+      }
+      writeFileSync5(outputPath, JSON.stringify(data, null, 2));
+      db.close();
+      console.log(`\u2713 Data exported to ${outputPath} (${tables.length} tables)`);
+    } else {
+      console.error(`Unknown format: ${opts.format}. Use 'sqlite' or 'json'.`);
+    }
+  });
+}
+
+// src/commands/connect.ts
+function connectCommand(program2) {
+  program2.command("connect").description("Connect a data source").argument("<source>", "Data source: feishu, github").option("--app-id <id>", "App ID (for Feishu)").option("--app-secret <secret>", "App Secret (for Feishu)").option("--token <token>", "Access token (for GitHub)").action(async (source, opts) => {
+    switch (source) {
+      case "feishu":
+        await connectFeishu(opts);
+        break;
+      case "github":
+        await connectGitHub(opts);
+        break;
+      default:
+        console.error(`Unknown source: ${source}. Supported: feishu, github`);
+        process.exit(1);
+    }
+  });
+}
+async function connectFeishu(opts) {
+  let appId = opts.appId;
+  let appSecret = opts.appSecret;
+  if (!appId) appId = process.env["FEISHU_APP_ID"];
+  if (!appSecret) appSecret = process.env["FEISHU_APP_SECRET"];
+  if (!appId || !appSecret) {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "appId", message: "Feishu App ID:", when: !appId },
+      { type: "password", name: "appSecret", message: "Feishu App Secret:", when: !appSecret }
+    ]);
+    appId = appId ?? answers.appId;
+    appSecret = appSecret ?? answers.appSecret;
+  }
+  if (!appId || !appSecret) {
+    console.error("Error: App ID and App Secret are required.");
+    process.exit(1);
+  }
+  console.log("Verifying Feishu credentials...");
+  try {
+    const res = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ app_id: appId, app_secret: appSecret })
+    });
+    const data = await res.json();
+    if (data.code !== 0) {
+      console.error(`Feishu auth failed: ${data.msg}`);
+      process.exit(1);
+    }
+    console.log("\u2713 Feishu credentials verified");
+  } catch (err) {
+    console.error(`Network error: ${err}`);
+    process.exit(1);
+  }
+  saveCredential("feishu", {
+    type: "feishu",
+    data: { appId, appSecret },
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  });
+  console.log("\u2713 Feishu connected. Run `jowork sync` to start syncing data.");
+}
+async function connectGitHub(opts) {
+  let token = opts.token;
+  if (!token) token = process.env["GITHUB_PERSONAL_ACCESS_TOKEN"];
+  if (!token) {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "password", name: "token", message: "GitHub Personal Access Token:" }
+    ]);
+    token = answers.token;
+  }
+  if (!token) {
+    console.error("Error: GitHub token is required.");
+    process.exit(1);
+  }
+  saveCredential("github", {
+    type: "github",
+    data: { token },
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  });
+  console.log("\u2713 GitHub connected.");
+}
+
+// src/commands/sync.ts
+import { existsSync as existsSync9 } from "fs";
+function syncCommand(program2) {
+  program2.command("sync").description("Sync data from connected sources").option("--source <source>", "Sync specific source only").action(async (opts) => {
+    if (!existsSync9(dbPath())) {
+      console.error("Error: JoWork not initialized. Run `jowork init` first.");
+      process.exit(1);
+    }
+    const db = new DbManager(dbPath());
+    db.ensureTables();
+    const sources = opts.source ? [opts.source] : listCredentials();
+    if (sources.length === 0) {
+      console.log("No data sources connected. Run `jowork connect <source>` first.");
+      db.close();
+      return;
+    }
+    for (const source of sources) {
+      const cred = loadCredential(source);
+      if (!cred) {
+        console.log(`\u2298 ${source}: no credentials found, skipping`);
+        continue;
+      }
+      console.log(`Syncing ${source}...`);
+      try {
+        switch (source) {
+          case "feishu":
+            await syncFeishu(db, cred.data);
+            break;
+          case "github":
+            console.log(`  GitHub sync not yet implemented (Phase 4)`);
+            break;
+          default:
+            console.log(`  Unknown source: ${source}`);
+        }
+      } catch (err) {
+        logError("sync", `Failed to sync ${source}`, { error: String(err) });
+        console.error(`  \u2717 ${source} sync failed: ${err}`);
+      }
+    }
+    console.log("Running entity extraction...");
+    const { processed, linksCreated } = linkAllUnprocessed(db.getSqlite());
+    console.log(`  \u2713 Extracted ${linksCreated} links from ${processed} objects`);
+    db.close();
+  });
+}
+async function syncFeishu(db, data) {
+  const { appId, appSecret } = data;
+  if (!appId || !appSecret) throw new Error("Missing Feishu credentials");
+  const tokenRes = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ app_id: appId, app_secret: appSecret })
+  });
+  const tokenData = await tokenRes.json();
+  if (tokenData.code !== 0) throw new Error(`Auth failed: code ${tokenData.code}`);
+  const token = tokenData.tenant_access_token;
+  const chatsRes = await fetch("https://open.feishu.cn/open-apis/im/v1/chats?page_size=50", {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  const chatsData = await chatsRes.json();
+  if (chatsData.code !== 0) throw new Error(`Failed to list chats: code ${chatsData.code}`);
+  const chats = chatsData.data?.items ?? [];
+  console.log(`  Found ${chats.length} chats`);
+  const sqlite = db.getSqlite();
+  let totalMessages = 0;
+  let newMessages = 0;
+  for (const chat of chats) {
+    const cursorRow = sqlite.prepare(`SELECT cursor FROM sync_cursors WHERE connector_id = ?`).get(`feishu:${chat.chat_id}`);
+    let pageToken = cursorRow?.cursor ?? void 0;
+    let hasMore = true;
+    while (hasMore) {
+      const url = new URL("https://open.feishu.cn/open-apis/im/v1/messages");
+      url.searchParams.set("container_id_type", "chat");
+      url.searchParams.set("container_id", chat.chat_id);
+      url.searchParams.set("page_size", "50");
+      url.searchParams.set("sort_type", "ByCreateTimeAsc");
+      if (pageToken) url.searchParams.set("page_token", pageToken);
+      const msgRes = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      const msgData = await msgRes.json();
+      if (msgData.code !== 0) {
+        if (msgData.code === 99991400) {
+          console.log(`  Rate limited on ${chat.name}, waiting 5s...`);
+          await new Promise((r) => setTimeout(r, 5e3));
+          continue;
+        }
+        console.log(`  \u26A0 Failed to get messages from "${chat.name}": code ${msgData.code}`);
+        break;
+      }
+      const messages = msgData.data?.items ?? [];
+      const insertObj = sqlite.prepare(`
+        INSERT OR IGNORE INTO objects (id, source, source_type, uri, title, summary, tags, content_hash, last_synced_at, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      const insertBody = sqlite.prepare(`
+        INSERT OR IGNORE INTO object_bodies (object_id, content, content_type, fetched_at)
+        VALUES (?, ?, ?, ?)
+      `);
+      const batchInsert = sqlite.transaction((msgs) => {
+        for (const msg of msgs) {
+          if (msg.msg_type !== "text" && msg.msg_type !== "post") continue;
+          let content = "";
+          try {
+            const bodyContent = JSON.parse(msg.body?.content ?? "{}");
+            const raw = bodyContent.text ?? bodyContent.content ?? bodyContent;
+            content = typeof raw === "string" ? raw : JSON.stringify(raw);
+          } catch {
+            content = msg.body?.content ?? "";
+          }
+          if (!content || typeof content !== "string") continue;
+          const uri = `feishu://message/${msg.message_id}`;
+          const hash = simpleHash2(content);
+          const now = Date.now();
+          const id = createId("obj");
+          const createTime = msg.create_time ? parseInt(msg.create_time) : now;
+          const summary = content.length > 200 ? content.slice(0, 200) + "..." : content;
+          insertObj.run(id, "feishu", "message", uri, `${chat.name}`, summary, JSON.stringify(["feishu", "message"]), hash, now, createTime);
+          insertBody.run(id, content, "text/plain", now);
+          newMessages++;
+        }
+      });
+      for (let i = 0; i < messages.length; i += 100) {
+        batchInsert(messages.slice(i, i + 100));
+      }
+      totalMessages += messages.length;
+      hasMore = msgData.data.has_more;
+      pageToken = msgData.data.page_token;
+      if (pageToken) {
+        sqlite.prepare(`INSERT OR REPLACE INTO sync_cursors (connector_id, cursor, last_synced_at) VALUES (?, ?, ?)`).run(`feishu:${chat.chat_id}`, pageToken, Date.now());
+      }
+    }
+  }
+  try {
+    sqlite.exec(`INSERT INTO objects_fts(objects_fts) VALUES('rebuild')`);
+  } catch {
+  }
+  console.log(`  \u2713 Synced ${totalMessages} messages (${newMessages} new)`);
+  logInfo("sync", "Feishu sync complete", { totalMessages, newMessages, chats: chats.length });
+}
+function simpleHash2(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return hash.toString(36);
+}
+
+// src/commands/search.ts
+import { existsSync as existsSync10 } from "fs";
+function searchCommand(program2) {
+  program2.command("search").description("Search across all synced data").argument("<query>", "Search keywords").option("--source <source>", "Filter by source").option("--limit <n>", "Max results", "20").action(async (query, opts) => {
+    if (!existsSync10(dbPath())) {
+      console.error("Error: JoWork not initialized. Run `jowork init` first.");
+      process.exit(1);
+    }
+    const db = new DbManager(dbPath());
+    const sqlite = db.getSqlite();
+    const limit = parseInt(opts.limit) || 20;
+    const pattern = `%${query.replace(/[%_\\]/g, "\\$&")}%`;
+    let rows;
+    if (opts.source) {
+      rows = sqlite.prepare(`
+          SELECT id, title, summary, source, source_type, uri FROM objects
+          WHERE (title LIKE ? OR summary LIKE ?) AND source = ?
+          ORDER BY last_synced_at DESC LIMIT ?
+        `).all(pattern, pattern, opts.source, limit);
+    } else {
+      rows = sqlite.prepare(`
+          SELECT id, title, summary, source, source_type, uri FROM objects
+          WHERE title LIKE ? OR summary LIKE ?
+          ORDER BY last_synced_at DESC LIMIT ?
+        `).all(pattern, pattern, limit);
+    }
+    if (rows.length === 0) {
+      console.log(`No results for "${query}"`);
+    } else {
+      for (const row of rows) {
+        console.log(`[${row.source}/${row.source_type}] ${row.title}`);
+        if (row.summary) console.log(`  ${row.summary.slice(0, 100)}`);
+        console.log("");
+      }
+      console.log(`${rows.length} results`);
+    }
+    db.close();
+  });
+}
+
+// src/goals/manager.ts
+var GoalManager = class {
+  constructor(sqlite) {
+    this.sqlite = sqlite;
+  }
+  // ── Goals ──
+  createGoal(opts) {
+    const now = Date.now();
+    const id = createId("goal");
+    this.sqlite.prepare(`
+      INSERT INTO goals (id, title, description, status, autonomy_level, parent_id, created_at, updated_at)
+      VALUES (?, ?, ?, 'active', ?, ?, ?, ?)
+    `).run(id, opts.title, opts.description ?? null, opts.autonomyLevel ?? "copilot", opts.parentId ?? null, now, now);
+    logInfo("goals", `Goal created: "${opts.title}"`, { id });
+    return this.getGoal(id);
+  }
+  getGoal(id) {
+    const row = this.sqlite.prepare("SELECT * FROM goals WHERE id = ?").get(id);
+    if (!row) return null;
+    const goal = this.rowToGoal(row);
+    goal.signals = this.getSignalsForGoal(id);
+    return goal;
+  }
+  listGoals(opts = {}) {
+    let query = "SELECT * FROM goals";
+    const args = [];
+    if (opts.status) {
+      query += " WHERE status = ?";
+      args.push(opts.status);
+    }
+    query += " ORDER BY created_at DESC";
+    const rows = this.sqlite.prepare(query).all(...args);
+    return rows.map((r) => {
+      const goal = this.rowToGoal(r);
+      goal.signals = this.getSignalsForGoal(goal.id);
+      return goal;
+    });
+  }
+  updateGoal(id, patch) {
+    const now = Date.now();
+    const sets = ["updated_at = ?"];
+    const args = [now];
+    if (patch.title !== void 0) {
+      sets.push("title = ?");
+      args.push(patch.title);
+    }
+    if (patch.description !== void 0) {
+      sets.push("description = ?");
+      args.push(patch.description);
+    }
+    if (patch.status !== void 0) {
+      sets.push("status = ?");
+      args.push(patch.status);
+    }
+    if (patch.autonomyLevel !== void 0) {
+      sets.push("autonomy_level = ?");
+      args.push(patch.autonomyLevel);
+    }
+    args.push(id);
+    this.sqlite.prepare(`UPDATE goals SET ${sets.join(", ")} WHERE id = ?`).run(...args);
+    return this.getGoal(id);
+  }
+  // ── Signals ──
+  createSignal(opts) {
+    const now = Date.now();
+    const id = createId("sig");
+    this.sqlite.prepare(`
+      INSERT INTO signals (id, goal_id, title, source, metric, direction, poll_interval, config, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, opts.goalId, opts.title, opts.source, opts.metric, opts.direction, opts.pollInterval ?? 3600, opts.config ? JSON.stringify(opts.config) : null, now, now);
+    logInfo("goals", `Signal created: "${opts.title}" for goal ${opts.goalId}`, { id });
+    return this.getSignal(id);
+  }
+  getSignal(id) {
+    const row = this.sqlite.prepare("SELECT * FROM signals WHERE id = ?").get(id);
+    if (!row) return null;
+    const signal = this.rowToSignal(row);
+    signal.measures = this.getMeasuresForSignal(id);
+    return signal;
+  }
+  getSignalsForGoal(goalId) {
+    const rows = this.sqlite.prepare("SELECT * FROM signals WHERE goal_id = ? ORDER BY created_at").all(goalId);
+    return rows.map((r) => {
+      const sig = this.rowToSignal(r);
+      sig.measures = this.getMeasuresForSignal(sig.id);
+      return sig;
+    });
+  }
+  updateSignalValue(id, value) {
+    const now = Date.now();
+    this.sqlite.prepare("UPDATE signals SET current_value = ?, last_polled_at = ?, updated_at = ? WHERE id = ?").run(value, now, now, id);
+    const measures = this.getMeasuresForSignal(id);
+    for (const m of measures) {
+      const met = this.evaluateMeasure(m, value);
+      this.sqlite.prepare("UPDATE measures SET current = ?, met = ?, last_evaluated_at = ?, updated_at = ? WHERE id = ?").run(value, met ? 1 : 0, now, now, m.id);
+    }
+  }
+  // ── Measures ──
+  createMeasure(opts) {
+    const now = Date.now();
+    const id = createId("msr");
+    this.sqlite.prepare(`
+      INSERT INTO measures (id, signal_id, threshold, comparison, upper_bound, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(id, opts.signalId, opts.threshold, opts.comparison, opts.upperBound ?? null, now, now);
+    return this.getMeasure(id);
+  }
+  getMeasure(id) {
+    const row = this.sqlite.prepare("SELECT * FROM measures WHERE id = ?").get(id);
+    return row ? this.rowToMeasure(row) : null;
+  }
+  getMeasuresForSignal(signalId) {
+    const rows = this.sqlite.prepare("SELECT * FROM measures WHERE signal_id = ? ORDER BY created_at").all(signalId);
+    return rows.map((r) => this.rowToMeasure(r));
+  }
+  // ── Helpers ──
+  evaluateMeasure(measure, value) {
+    switch (measure.comparison) {
+      case "gte":
+        return value >= measure.threshold;
+      case "lte":
+        return value <= measure.threshold;
+      case "gt":
+        return value > measure.threshold;
+      case "lt":
+        return value < measure.threshold;
+      case "eq":
+        return value === measure.threshold;
+      case "between":
+        return value >= measure.threshold && value <= (measure.upperBound ?? Infinity);
+      default:
+        return false;
+    }
+  }
+  rowToGoal(row) {
+    return {
+      id: row.id,
+      title: row.title,
+      description: row.description,
+      status: row.status,
+      autonomyLevel: row.autonomy_level,
+      parentId: row.parent_id,
+      evolvedFrom: row.evolved_from,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  rowToSignal(row) {
+    return {
+      id: row.id,
+      goalId: row.goal_id,
+      title: row.title,
+      source: row.source,
+      metric: row.metric,
+      direction: row.direction,
+      pollInterval: row.poll_interval,
+      config: row.config ? JSON.parse(row.config) : null,
+      currentValue: row.current_value,
+      lastPolledAt: row.last_polled_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  rowToMeasure(row) {
+    return {
+      id: row.id,
+      signalId: row.signal_id,
+      threshold: row.threshold,
+      comparison: row.comparison,
+      upperBound: row.upper_bound,
+      current: row.current,
+      met: row.met === 1,
+      lastEvaluatedAt: row.last_evaluated_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+};
+
+// src/commands/goal.ts
+function goalCommand(program2) {
+  const goal = program2.command("goal").description("Manage goals (Goal-Signal-Measure system)");
+  goal.command("add").description("Add a new goal").argument("<title>", "Goal title").option("--description <desc>", "Goal description").option("--parent <id>", "Parent goal ID").action(async (title, opts) => {
+    const db = new DbManager(dbPath());
+    db.ensureTables();
+    const gm = new GoalManager(db.getSqlite());
+    const g = gm.createGoal({ title, description: opts.description, parentId: opts.parent });
+    console.log(`\u2713 Goal created: "${g.title}" (${g.id})`);
+    db.close();
+  });
+  goal.command("list").description("List goals").option("--status <status>", "Filter by status: active, paused, completed").action(async (opts) => {
+    const db = new DbManager(dbPath());
+    db.ensureTables();
+    const gm = new GoalManager(db.getSqlite());
+    const goals = gm.listGoals({ status: opts.status });
+    if (goals.length === 0) {
+      console.log("No goals found.");
+      db.close();
+      return;
+    }
+    for (const g of goals) {
+      const signalCount = g.signals?.length ?? 0;
+      const metCount = g.signals?.reduce((acc, s) => acc + (s.measures?.filter((m) => m.met).length ?? 0), 0) ?? 0;
+      const totalMeasures = g.signals?.reduce((acc, s) => acc + (s.measures?.length ?? 0), 0) ?? 0;
+      const progress = totalMeasures > 0 ? `${metCount}/${totalMeasures} measures met` : "no measures";
+      console.log(`[${g.status}] ${g.title} (${g.id})`);
+      console.log(`  ${signalCount} signals, ${progress}`);
+      if (g.description) console.log(`  ${g.description}`);
+      console.log("");
+    }
+    db.close();
+  });
+  goal.command("status").description("Show detailed goal status").argument("[id]", "Goal ID (shows all if omitted)").action(async (id) => {
+    const db = new DbManager(dbPath());
+    db.ensureTables();
+    const gm = new GoalManager(db.getSqlite());
+    const goals = id ? [gm.getGoal(id)].filter(Boolean) : gm.listGoals({ status: "active" });
+    for (const g of goals) {
+      console.log(`Goal: ${g.title} [${g.status}]`);
+      console.log(`  ID: ${g.id}`);
+      console.log(`  Autonomy: ${g.autonomyLevel}`);
+      if (g.signals && g.signals.length > 0) {
+        for (const s of g.signals) {
+          const arrow = s.direction === "maximize" ? "\u2191" : s.direction === "minimize" ? "\u2193" : "\u2192";
+          console.log(`  Signal: ${s.title} ${arrow} (${s.source}/${s.metric})`);
+          console.log(`    Current: ${s.currentValue ?? "no data"}, Poll: ${s.pollInterval}s`);
+          if (s.measures) {
+            for (const m of s.measures) {
+              const icon = m.met ? "\u2713" : "\u2717";
+              console.log(`    ${icon} ${m.comparison} ${m.threshold}${m.upperBound ? `-${m.upperBound}` : ""} (current: ${m.current ?? "N/A"})`);
+            }
+          }
+        }
+      } else {
+        console.log("  No signals configured");
+      }
+      console.log("");
+    }
+    db.close();
+  });
+  const signal = program2.command("signal").description("Manage signals for goals");
+  signal.command("add").description("Add a signal to a goal").argument("<goal_id>", "Goal ID").requiredOption("--source <source>", "Data source (e.g. posthog, feishu)").requiredOption("--metric <metric>", "Metric name (e.g. dau, crash_rate)").requiredOption("--direction <dir>", "Direction: maximize, minimize, maintain").option("--title <title>", "Signal title (auto-generated if omitted)").option("--interval <seconds>", "Poll interval in seconds", "3600").action(async (goalId, opts) => {
+    const db = new DbManager(dbPath());
+    db.ensureTables();
+    const gm = new GoalManager(db.getSqlite());
+    const goal2 = gm.getGoal(goalId);
+    if (!goal2) {
+      console.error(`Goal not found: ${goalId}`);
+      process.exit(1);
+    }
+    const title = opts.title ?? `${opts.metric} (${opts.source})`;
+    const sig = gm.createSignal({
+      goalId,
+      title,
+      source: opts.source,
+      metric: opts.metric,
+      direction: opts.direction,
+      pollInterval: parseInt(opts.interval)
+    });
+    console.log(`\u2713 Signal added: "${sig.title}" \u2192 ${goal2.title} (${sig.id})`);
+    db.close();
+  });
+  const measure = program2.command("measure").description("Manage measures for signals");
+  measure.command("add").description("Add a measure to a signal").argument("<signal_id>", "Signal ID").requiredOption("--threshold <n>", "Threshold value").requiredOption("--type <type>", "Comparison: gte, lte, gt, lt, eq, between").option("--upper <n>", "Upper bound (for between)").action(async (signalId, opts) => {
+    const db = new DbManager(dbPath());
+    db.ensureTables();
+    const gm = new GoalManager(db.getSqlite());
+    const sig = gm.getSignal(signalId);
+    if (!sig) {
+      console.error(`Signal not found: ${signalId}`);
+      process.exit(1);
+    }
+    const m = gm.createMeasure({
+      signalId,
+      threshold: parseFloat(opts.threshold),
+      comparison: opts.type,
+      upperBound: opts.upper ? parseFloat(opts.upper) : void 0
+    });
+    console.log(`\u2713 Measure added: ${opts.type} ${opts.threshold} (${m.id})`);
+    db.close();
+  });
+}
+
+// src/cli.ts
+process.env["I18NEXT_DISABLE_BANNER"] = "1";
+var program = new Command();
+program.name("jowork").description("AI Agent Infrastructure \u2014 let AI agents truly understand your work").version("0.1.0");
+initCommand(program);
+serveCommand(program);
+registerCommand(program);
+connectCommand(program);
+syncCommand(program);
+statusCommand(program);
+doctorCommand(program);
+exportCommand(program);
+searchCommand(program);
+goalCommand(program);
+program.parse();