jfl 0.1.1 → 0.2.1

package/clawdbot-skill/index.ts

@@ -1,14 +1,20 @@
 /**
  * JFL GTM Clawdbot Skill
  *
- * Provides full JFL CLI access from Telegram/Slack with proper session isolation.
- * Uses `jfl session create` and `jfl session exec` for worktree isolation, auto-commit, and journaling.
- * Session state persisted to ~/.clawd/memory/jfl-sessions.json
+ * Dormant until user engages via /jfl. Then activates sessions, context,
+ * journaling, and coordination via OpenClaw protocol.
+ *
+ * On install: explains what JFL does and how to use it.
+ * On /jfl: lets user pick a GTM workspace, then activates.
+ * While active: auto-injects context, captures decisions, auto-commits.
+ *
+ * @purpose Clawdbot skill using OpenClaw for full JFL integration
+ * @spec specs/OPENCLAW_SPEC.md
  */
 
 import { exec } from "child_process"
 import { promisify } from "util"
-import { existsSync, readFileSync } from "fs"
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs"
 import { join } from "path"
 import { homedir } from "os"
 
@@ -25,462 +31,653 @@ interface GTM {
   path: string
 }
 
-/**
- * Boot sequence - runs when skill first activates
- */
-export async function onBoot(ctx: Context) {
-  // Check if JFL CLI is installed
-  const hasJFL = await checkJFLInstalled()
+interface SessionState {
+  gtmPath: string
+  gtmName: string
+  agentId: string
+  sessionBranch: string | null
+  activated: boolean
+}
 
-  if (!hasJFL) {
-    return {
-      text: "⚠️ JFL CLI not found\n\n" +
-            "Install: npm install -g jfl\n\n" +
-            "Then run /jfl again",
-      buttons: []
-    }
-  }
+// ============================================================================
+// State persistence
+// ============================================================================
 
-  // Find available GTMs
-  const gtms = await findGTMs()
+const STATE_DIR = join(homedir(), ".clawd", "memory")
+const STATE_FILE = join(STATE_DIR, "jfl-openclaw.json")
 
-  if (gtms.length === 0) {
-    return {
-      text: "🚀 JFL - Just Fucking Launch\n\n" +
-            "No GTMs found.\n\n" +
-            "Create one: jfl init\n" +
-            "Then run /jfl again"
+function loadState(): Map<string, SessionState> {
+  try {
+    if (existsSync(STATE_FILE)) {
+      return new Map(Object.entries(JSON.parse(readFileSync(STATE_FILE, "utf-8"))))
     }
-  }
-
-  // Show GTM picker (like screenshot)
-  const buttons = gtms.map(g => ({
-    text: `📂 ${g.name}`,
-    callbackData: `select:${g.path}`
-  }))
-
-  return {
-    text: "🚀 JFL - Just Fucking Launch\n\n" +
-          "Your team's context layer. Any AI. Any task.\n\n" +
-          "Open a project:",
-    buttons
-  }
+  } catch { /* ignore */ }
+  return new Map()
 }
 
-/**
- * Handle button clicks
- */
-export async function onCallback(data: string, ctx: Context) {
-  const [action, value] = data.split(":")
-
-  if (action === "select") {
-    return await handleSelectGTM(value, ctx)
-  }
-
-  if (action === "cmd") {
-    return await handleCommand(value, ctx)
-  }
-
-  return { text: "Unknown action" }
+function saveState(state: Map<string, SessionState>) {
+  mkdirSync(STATE_DIR, { recursive: true })
+  writeFileSync(STATE_FILE, JSON.stringify(Object.fromEntries(state), null, 2))
 }
 
-/**
- * Handle slash commands
- */
-export async function onCommand(cmd: string, args: string[], ctx: Context) {
-  const session = getSession(ctx.threadId)
+const state = loadState()
 
-  if (!session && cmd !== "gtm") {
-    return {
-      text: "⚠️ No GTM selected.\n\nRun /jfl to select a project."
-    }
-  }
-
-  switch (cmd) {
-    case "gtm":
-      return await onBoot(ctx)
+function getState(threadId: string): SessionState | undefined {
+  return state.get(threadId)
+}
 
-    case "hud":
-      return await runJFLCommand(session!, "hud")
+function setState(threadId: string, s: SessionState) {
+  state.set(threadId, s)
+  saveState(state)
+}
 
-    case "crm":
-      if (args.length === 0) {
-        return showCRMMenu()
-      }
-      return await runCRMCommand(session!, args)
+// ============================================================================
+// OpenClaw helpers
+// ============================================================================
+
+async function openclaw(cmd: string, cwd?: string): Promise<string> {
+  const { stdout } = await execAsync(`jfl openclaw ${cmd}`, {
+    timeout: 30000,
+    env: { ...process.env },
+    cwd,
+  })
+  return stdout.trim()
+}
 
-    case "brand":
-      return showBrandMenu()
+async function openclawJSON(cmd: string, cwd?: string): Promise<any> {
+  const raw = await openclaw(`${cmd} --json`, cwd)
+  return JSON.parse(raw)
+}
 
-    case "content":
-      if (args.length === 0) {
-        return showContentMenu()
-      }
-      return await runJFLCommand(session!, `content ${args.join(" ")}`)
+async function ensureContextHub(gtmPath: string): Promise<boolean> {
+  try {
+    // Check if hub is healthy
+    const status = await openclawJSON("status", gtmPath)
+    if (status.context_hub?.healthy) return true
+  } catch { /* hub not running */ }
 
-    default:
-      return { text: `Unknown command: /${cmd}` }
+  // Start hub from within GTM directory
+  try {
+    await execAsync("jfl context-hub start", {
+      cwd: gtmPath,
+      timeout: 15000,
+      env: { ...process.env },
+    })
+    return true
+  } catch {
+    return false
   }
 }
 
-/**
- * Check if JFL CLI is installed
- */
-async function checkJFLInstalled(): Promise<boolean> {
+async function ensureJFL(): Promise<boolean> {
   try {
-    await execAsync("jfl --version")
+    await execAsync("jfl --version", { timeout: 5000 })
     return true
   } catch {
-    return false
+    try {
+      await execAsync("npm install -g jfl", { timeout: 60000 })
+      return true
+    } catch {
+      return false
+    }
   }
 }
 
-/**
- * Find GTMs on this machine
- *
- * A GTM has: .jfl/ + knowledge/ + CLAUDE.md
- * Product repos (jfl-cli, jfl-platform) have .jfl/ but aren't GTMs
- */
-async function findGTMs(): Promise<GTM[]> {
-  const gtms: GTM[] = []
+function agentId(ctx: Context): string {
+  return `clawd-${ctx.platform}-${ctx.userId}`.slice(0, 30)
+}
 
-  // Check common locations
-  const searchPaths = [
-    join(homedir(), "CascadeProjects"),
-    join(homedir(), "Projects"),
-    join(homedir(), "code"),
-  ]
+// ============================================================================
+// Welcome / Intro (shown on first use or install)
+// ============================================================================
 
-  for (const basePath of searchPaths) {
-    if (!existsSync(basePath)) continue
+const WELCOME_MESSAGE = `JFL - Just Fucking Launch
 
-    try {
-      const { stdout } = await execAsync(`find ${basePath} -maxdepth 2 -name .jfl -type d`)
-      const dirs = stdout.trim().split("\n").filter(Boolean)
+Your project context layer. I track decisions, save context, and keep everything synced across sessions.
 
-      for (const dir of dirs) {
-        const gtmPath = dir.replace("/.jfl", "")
+What I do when active:
+- Search project context before responding
+- Capture decisions into the journal automatically
+- Auto-commit your work every 2 minutes
+- Coordinate with other agents on the team
 
-        // Filter: Must have knowledge/ and CLAUDE.md to be a GTM
-        const hasKnowledge = existsSync(join(gtmPath, "knowledge"))
-        const hasClaude = existsSync(join(gtmPath, "CLAUDE.md"))
+Commands:
+/jfl — Activate / select a project
+/context <query> — Search project knowledge
+/journal <type> <title> | <summary> — Log work
+/hud — Project dashboard
 
-        if (!hasKnowledge || !hasClaude) {
-          continue // Skip product repos
-        }
+To get started, use /jfl to pick a project.`
 
-        const name = gtmPath.split("/").pop() || "unknown"
-        gtms.push({ name, path: gtmPath })
-      }
-    } catch {
-      // Skip if find fails
-    }
-  }
+const ACTIVATION_MESSAGE = (gtmName: string) => `JFL activated: ${gtmName}
 
-  return gtms
-}
+I'll now:
+- Search context before each response
+- Capture decisions automatically
+- Auto-commit work periodically
 
-/**
- * Session storage (persisted to disk)
- */
-const SESSIONS_FILE = join(homedir(), ".clawd", "memory", "jfl-sessions.json")
+Commands:
+/context <query> — Search project context
+/journal <type> <title> | <summary> — Log work
+/hud — Project dashboard
+/jfl — Status`
 
-interface SessionData {
-  gtmPath: string
-  gtmName: string
-  sessionId: string
-  platform: string
-}
+// ============================================================================
+// Boot (on /jfl command)
+// ============================================================================
 
-function loadSessions(): Map<string, SessionData> {
-  try {
-    if (existsSync(SESSIONS_FILE)) {
-      const data = JSON.parse(readFileSync(SESSIONS_FILE, "utf-8"))
-      return new Map(Object.entries(data))
+export async function onBoot(ctx: Context) {
+  const hasJFL = await ensureJFL()
+  if (!hasJFL) {
+    return {
+      text: "JFL CLI not found and auto-install failed.\n\nInstall manually:\n  npm install -g jfl\n\nThen run /jfl again.",
     }
-  } catch {
-    // Ignore parse errors
   }
-  return new Map()
-}
 
-function saveSessions(sessions: Map<string, SessionData>) {
-  try {
-    const data = Object.fromEntries(sessions)
-    const fs = require("fs")
-    fs.mkdirSync(join(homedir(), ".clawd", "memory"), { recursive: true })
-    fs.writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2))
-  } catch (error) {
-    console.error("Failed to save sessions:", error)
+  // Check if already activated
+  const existing = getState(ctx.threadId)
+  if (existing?.activated && existing?.sessionBranch) {
+    return await showStatus(existing)
   }
-}
 
-const sessions = loadSessions()
+  // Find available GTMs
+  const gtms = await findGTMs()
+  if (gtms.length === 0) {
+    return {
+      text: "No GTM workspaces found.\n\nCreate one:\n  jfl init -n 'My Project'\n\nThen run /jfl again.",
+    }
+  }
 
-function getSession(threadId: string) {
-  return sessions.get(threadId)
-}
+  // Single GTM → auto-activate
+  if (gtms.length === 1) {
+    return await activateGTM(gtms[0].path, ctx)
+  }
 
-function setSession(threadId: string, data: SessionData) {
-  sessions.set(threadId, data)
-  saveSessions(sessions)
+  // Multiple GTMs → let user pick
+  const buttons = gtms.map((g) => ({
+    text: g.name,
+    callbackData: `select:${g.path}`,
+  }))
+
+  return {
+    text: "Select a project:",
+    buttons,
+  }
 }
 
-/**
- * Handle GTM selection
- */
-async function handleSelectGTM(gtmPath: string, ctx: Context) {
-  const gtmName = gtmPath.split("/").pop() || "unknown"
+// ============================================================================
+// Activation
+// ============================================================================
+
+async function activateGTM(gtmPath: string, ctx: Context) {
+  const agent = agentId(ctx)
 
+  // Read GTM name from config
+  let gtmName = gtmPath.split("/").pop() || "unknown"
   try {
-    // Create or get session with proper worktree isolation
-    const { stdout } = await execAsync(
-      `cd ${gtmPath} && jfl session create --platform ${ctx.platform} --thread ${ctx.threadId}`
-    )
-    const sessionId = stdout.trim()
+    const cfg = JSON.parse(readFileSync(join(gtmPath, ".jfl", "config.json"), "utf-8"))
+    if (cfg.name) gtmName = cfg.name
+  } catch {}
+
+  try {
+    // Register agent with GTM (idempotent)
+    await openclawJSON(`register -g "${gtmPath}" -a ${agent}`, gtmPath)
+
+    // Ensure context hub is running from the GTM directory
+    await ensureContextHub(gtmPath)
+
+    // Start session
+    const session = await openclawJSON(`session-start -a ${agent} -g "${gtmPath}"`, gtmPath)
 
-    // Store session with ID
-    setSession(ctx.threadId, {
+    setState(ctx.threadId, {
       gtmPath,
       gtmName,
-      sessionId,
-      platform: ctx.platform
+      agentId: agent,
+      sessionBranch: session.session_id,
+      activated: true,
     })
 
-    // Show command menu
-    const commands = [
+    return { text: ACTIVATION_MESSAGE(gtmName) }
+  } catch (error: any) {
+    // Session start failed but registration may have worked
+    setState(ctx.threadId, {
+      gtmPath,
+      gtmName,
+      agentId: agent,
+      sessionBranch: null,
+      activated: true,
+    })
+    return { text: `JFL activated: ${gtmName}\n\nSession start failed: ${error.message}\nContext and journaling still work.` }
+  }
+}
+
+// ============================================================================
+// Status (shown when /jfl is called while active)
+// ============================================================================
+
+async function showStatus(s: SessionState) {
+  let hubStatus = "unknown"
+  try {
+    const status = await openclawJSON("status")
+    hubStatus = status.context_hub?.healthy ? "running" : "offline"
+  } catch {
+    hubStatus = "offline"
+  }
+
+  return {
+    text: [
+      `JFL active: ${s.gtmName}`,
+      `Session: ${s.sessionBranch || "none"}`,
+      `Context Hub: ${hubStatus}`,
+      ``,
+      `Commands:`,
+      `/context <query> — Search`,
+      `/journal <type> <title> | <summary> — Log`,
+      `/hud — Dashboard`,
+    ].join("\n"),
+    buttons: [
       [
-        { text: "📊 Dashboard", callbackData: "cmd:hud" },
-        { text: "👥 CRM", callbackData: "cmd:crm" }
+        { text: "Dashboard", callbackData: "cmd:hud" },
+        { text: "Search Context", callbackData: "cmd:context" },
       ],
       [
-        { text: "🎨 Brand", callbackData: "cmd:brand" },
-        { text: "✍️ Content", callbackData: "cmd:content" }
+        { text: "Switch Project", callbackData: "cmd:switch" },
+        { text: "End Session", callbackData: "cmd:end" },
       ],
-      [
-        { text: "🔄 Sync", callbackData: "cmd:sync" },
-        { text: "📝 Status", callbackData: "cmd:status" }
-      ]
-    ]
+    ],
+  }
+}
 
-    return {
-      text: `✓ Session created: ${gtmName}\n\n` +
-            `Session ID: ${sessionId}\n` +
-            `Isolated worktree with auto-commit enabled.\n\n` +
-            `What do you want to do?`,
-      buttons: commands
+// ============================================================================
+// Callbacks
+// ============================================================================
+
+export async function onCallback(data: string, ctx: Context) {
+  const [action, value] = data.split(":")
+
+  if (action === "select") return await activateGTM(value, ctx)
+  if (action === "cmd") return await handleCommand(value, ctx)
+
+  return { text: "Unknown action" }
+}
+
+async function handleCommand(cmd: string, ctx: Context) {
+  const s = getState(ctx.threadId)
+  if (!s?.activated) return { text: "JFL not active. Use /jfl to select a project." }
+
+  switch (cmd) {
+    case "hud":
+      return await runInGTM(s, "jfl hud")
+    case "crm":
+      return showCRMMenu()
+    case "context":
+      return await runContext(s)
+    case "status":
+      return await showStatus(s)
+    case "brand":
+      return showBrandMenu()
+    case "content":
+      return showContentMenu()
+    case "switch": {
+      // Deactivate current
+      setState(ctx.threadId, { ...s, activated: false, sessionBranch: null })
+      try { await openclawJSON("session-end --sync") } catch {}
+      return await onBoot(ctx)
     }
-  } catch (error: any) {
-    return {
-      text: `❌ Failed to create session\n\n${error.message}\n\n` +
-            `Make sure you're in a JFL GTM directory.`
+    case "end": {
+      try { await openclawJSON("session-end --sync") } catch {}
+      setState(ctx.threadId, { ...s, activated: false, sessionBranch: null })
+      return { text: `Session ended for ${s.gtmName}.\n\nUse /jfl to start again.` }
     }
+    default:
+      return { text: "Unknown command" }
   }
 }
 
-/**
- * Handle command button
- */
-async function handleCommand(cmd: string, ctx: Context) {
-  const session = getSession(ctx.threadId)
+// ============================================================================
+// Commands
+// ============================================================================
 
-  if (!session) {
-    return { text: "⚠️ Session expired. Run /jfl to select a GTM." }
-  }
+export async function onCommand(cmd: string, args: string[], ctx: Context) {
+  if (cmd === "jfl" || cmd === "gtm") return await onBoot(ctx)
+
+  const s = getState(ctx.threadId)
+  if (!s?.activated) return { text: "JFL not active. Use /jfl to select a project first." }
 
   switch (cmd) {
     case "hud":
-      return await runJFLCommand(session, "hud")
+      return await runInGTM(s, "jfl hud")
 
     case "crm":
-      return showCRMMenu()
+      if (args.length === 0) return showCRMMenu()
+      return await runInGTM(s, `./crm ${args.join(" ")}`)
+
+    case "context":
+      if (args.length === 0) return await runContext(s)
+      return await runContextQuery(s, args.join(" "))
+
+    case "journal": {
+      const type = args[0] || "discovery"
+      const title = args.slice(1).join(" ") || "Note"
+      await openclaw(`journal --type ${type} --title "${title}" --summary "${title}"`)
+      return { text: `Journal entry written: [${type}] ${title}` }
+    }
 
     case "brand":
       return showBrandMenu()
 
     case "content":
-      return showContentMenu()
-
-    case "sync":
-      return await runGitSync(session)
-
-    case "status":
-      return await runGitStatus(session)
+      if (args.length === 0) return showContentMenu()
+      return await runInGTM(s, `jfl content ${args.join(" ")}`)
 
     default:
-      return { text: "Unknown command" }
+      return { text: `Unknown command: /${cmd}` }
   }
 }
 
-/**
- * Run JFL command (uses session exec for isolation)
- */
-async function runJFLCommand(session: SessionData, command: string) {
-  try {
-    // Use jfl session exec to run command in isolated worktree
-    const { stdout, stderr } = await execAsync(
-      `cd ${session.gtmPath} && jfl session exec "${session.sessionId}" "${command}"`,
-      {
-        env: { ...process.env, JFL_PLATFORM: session.platform }
-      }
-    )
-
-    const output = stdout || stderr
-    const formatted = formatForTelegram(output)
+// ============================================================================
+// Runners
+// ============================================================================
 
-    return {
-      text: formatted,
-      parseMode: "Markdown"
-    }
+async function runInGTM(s: SessionState, command: string): Promise<any> {
+  try {
+    const { stdout } = await execAsync(command, {
+      cwd: s.gtmPath,
+      timeout: 30000,
+      env: { ...process.env },
+    })
+    return { text: stripAnsi(stdout).slice(0, 4000), parseMode: "Markdown" }
   } catch (error: any) {
-    return {
-      text: `❌ Error running jfl ${command}\n\n${error.message}`
-    }
+    return { text: `Command failed: ${error.message}` }
   }
 }
 
-/**
- * Run CRM command (uses session exec for isolation)
- */
-async function runCRMCommand(session: SessionData, args: string[]) {
+async function runContext(s: SessionState) {
   try {
-    // Use session exec to run CRM in isolated worktree
-    const { stdout } = await execAsync(
-      `cd ${session.gtmPath} && jfl session exec "${session.sessionId}" "./crm ${args.join(" ")}"`
+    const items = await openclawJSON("context")
+    if (!Array.isArray(items) || items.length === 0) {
+      return { text: "No context items found. Context Hub may not be running.\n\nStart it: jfl context-hub start" }
+    }
+    const lines = items.slice(0, 8).map((i: any) =>
+      `[${i.source || i.type}] ${i.title}\n  ${(i.content || "").slice(0, 100)}`
     )
-    const formatted = formatForTelegram(stdout)
+    return { text: `Project Context\n\n${lines.join("\n\n")}` }
+  } catch (error: any) {
+    return { text: `Context Hub unreachable: ${error.message}` }
+  }
+}
 
-    return {
-      text: formatted,
-      parseMode: "Markdown"
+async function runContextQuery(s: SessionState, query: string) {
+  try {
+    const items = await openclawJSON(`context -q "${query}"`)
+    if (!Array.isArray(items) || items.length === 0) {
+      return { text: `No results for: ${query}` }
     }
+    const lines = items.slice(0, 5).map((i: any) =>
+      `[${i.source || i.type}] ${i.title}\n  ${(i.content || "").slice(0, 120)}`
+    )
+    return { text: `Results for "${query}"\n\n${lines.join("\n\n")}` }
   } catch (error: any) {
-    return {
-      text: `❌ Error running crm\n\n${error.message}`
-    }
+    return { text: `Search failed: ${error.message}` }
   }
 }
 
-/**
- * Show CRM menu
- */
+// ============================================================================
+// Menus
+// ============================================================================
+
 function showCRMMenu() {
   return {
-    text: "👥 CRM\n\nWhat do you want to do?",
+    text: "CRM\n\nWhat do you want to do?",
     buttons: [
       [
-        { text: "📋 List Pipeline", callbackData: "crm:list" },
-        { text: "⏰ Stale Deals", callbackData: "crm:stale" }
+        { text: "Pipeline", callbackData: "crm:list" },
+        { text: "Stale Deals", callbackData: "crm:stale" },
       ],
       [
-        { text: "📞 Prep Call", callbackData: "crm:prep" },
-        { text: "✏️ Log Touch", callbackData: "crm:touch" }
-      ]
-    ]
+        { text: "Prep Call", callbackData: "crm:prep" },
+        { text: "Log Touch", callbackData: "crm:touch" },
+      ],
+    ],
   }
 }
 
-/**
- * Show brand menu
- */
 function showBrandMenu() {
   return {
-    text: "🎨 Brand Architect\n\nWhat do you want to create?",
+    text: "Brand Architect\n\nWhat do you want to create?",
     buttons: [
       [
         { text: "Logo Marks", callbackData: "brand:marks" },
-        { text: "Color Palette", callbackData: "brand:colors" }
+        { text: "Colors", callbackData: "brand:colors" },
       ],
       [
         { text: "Typography", callbackData: "brand:typography" },
-        { text: "Full System", callbackData: "brand:full" }
-      ]
-    ]
+        { text: "Full System", callbackData: "brand:full" },
+      ],
+    ],
   }
 }
 
-/**
- * Show content menu
- */
 function showContentMenu() {
   return {
-    text: "✍️ Content Creator\n\nWhat do you want to create?",
+    text: "Content Creator\n\nWhat do you want to create?",
     buttons: [
       [
-        { text: "Twitter Thread", callbackData: "content:thread" },
-        { text: "Single Post", callbackData: "content:post" }
+        { text: "Thread", callbackData: "content:thread" },
+        { text: "Post", callbackData: "content:post" },
       ],
       [
         { text: "Article", callbackData: "content:article" },
-        { text: "One-Pager", callbackData: "content:onepager" }
-      ]
-    ]
+        { text: "One-Pager", callbackData: "content:onepager" },
+      ],
+    ],
+  }
+}
+
+// ============================================================================
+// GTM discovery (only returns type:"gtm", never services)
+// ============================================================================
+
+function readJflConfig(dir: string): { type?: string; name?: string } | null {
+  try {
+    return JSON.parse(readFileSync(join(dir, ".jfl", "config.json"), "utf-8"))
+  } catch {
+    return null
+  }
+}
+
+async function findGTMs(): Promise<GTM[]> {
+  // First try OpenClaw registry
+  try {
+    const gtms = await openclawJSON("gtm-list")
+    if (Array.isArray(gtms) && gtms.length > 0) {
+      return gtms.map((g: any) => ({ name: g.name, path: g.path }))
+    }
+  } catch { /* fall through to filesystem scan */ }
+
+  // Fallback: scan filesystem for type:"gtm" directories
+  const gtms: GTM[] = []
+  const searchPaths = [
+    join(homedir(), "CascadeProjects"),
+    join(homedir(), "Projects"),
+    join(homedir(), "code"),
+  ]
+
+  for (const basePath of searchPaths) {
+    if (!existsSync(basePath)) continue
+    try {
+      const entries = readdirSync(basePath, { withFileTypes: true })
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        const candidate = join(basePath, entry.name)
+        const config = readJflConfig(candidate)
+        if (!config) continue
+
+        // Only include GTMs, not services
+        if (config.type === "gtm") {
+          gtms.push({ name: config.name || entry.name, path: candidate })
+        } else if (!config.type && existsSync(join(candidate, "knowledge"))) {
+          // Legacy: no type field but has knowledge/ → probably a GTM
+          gtms.push({ name: config.name || entry.name, path: candidate })
+        }
+        // type:"service" → skip entirely
+      }
+    } catch { /* skip */ }
   }
+
+  return gtms
 }
 
+// ============================================================================
+// LIFECYCLE HOOKS (Clawdbot calls these automatically)
+// All hooks check activation state. When dormant, they're no-ops.
+// ============================================================================
+
 /**
- * Git sync (runs in session worktree)
+ * session_start — fires when Clawdbot session begins.
+ * Does NOT auto-activate. Just checks if JFL is available and notes it.
+ * User must run /jfl to activate.
  */
-async function runGitSync(session: SessionData) {
-  try {
-    // Session exec automatically runs session-sync.sh before command
-    const { stdout } = await execAsync(
-      `cd ${session.gtmPath} && jfl session exec "${session.sessionId}" "git status --short"`
-    )
+export async function onSessionStart(event: { agentId: string; platform: string; threadId: string }) {
+  const existing = getState(event.threadId)
 
-    return {
-      text: `✓ Synced ${session.gtmName}\n\nSession-sync runs automatically before each command.\n\n${stdout || "Working tree clean"}`
+  // If already activated from a previous session, re-inject context
+  if (existing?.activated && existing?.gtmPath) {
+    const agent = existing.agentId || event.agentId || `clawd-${event.platform}`
+
+    try {
+      // Ensure context hub is running from the GTM directory
+      await ensureContextHub(existing.gtmPath)
+
+      // Try to resume or start a new session
+      const session = await openclawJSON(`session-start -a ${agent} -g "${existing.gtmPath}"`, existing.gtmPath)
+      setState(event.threadId, { ...existing, sessionBranch: session.session_id })
+
+      return {
+        prependContext: [
+          `<jfl-session>`,
+          `GTM: ${existing.gtmName} (${existing.gtmPath})`,
+          `Session: ${session.session_id}`,
+          `Use /jfl for status. Use /context <query> to search.`,
+          `</jfl-session>`,
+        ].join("\n"),
+      }
+    } catch {
+      // Session start failed but we're still "activated" for the GTM
+      return {
+        prependContext: `<jfl-session>GTM: ${existing.gtmName} (session start failed, commands still work)</jfl-session>`,
+      }
     }
-  } catch (error: any) {
-    return {
-      text: `❌ Sync failed\n\n${error.message}`
+  }
+
+  // Not activated — stay quiet. Don't inject anything.
+  // Just check if JFL is available for the welcome message later
+  const hasJFL = await ensureJFL()
+  if (hasJFL) {
+    const gtms = await findGTMs()
+    if (gtms.length > 0) {
+      return {
+        prependContext: `<jfl-available>JFL is installed with ${gtms.length} project(s) available. User can activate with /jfl.</jfl-available>`,
+      }
     }
   }
+
+  return { prependContext: "" }
 }
 
 /**
- * Git status (runs in session worktree)
+ * before_turn — fires before each agent response.
+ * Only injects context when JFL is active.
  */
-async function runGitStatus(session: SessionData) {
+export async function onBeforeTurn(event: { agentId: string; threadId: string; message?: string }) {
+  const s = getState(event.threadId)
+  if (!s?.activated || !s?.sessionBranch || !s?.gtmPath) return { prependContext: "" }
+
+  let contextBlock = ""
   try {
-    // Use session exec to check status in isolated worktree
-    const { stdout } = await execAsync(
-      `cd ${session.gtmPath} && jfl session exec "${session.sessionId}" "git status --short && echo '---' && git log --oneline -5"`
-    )
+    const query = event.message?.slice(0, 100) || ""
+    if (query.length > 10) {
+      const items = await openclawJSON(`context -q "${query.replace(/"/g, '\\"')}"`, s.gtmPath)
+      if (Array.isArray(items) && items.length > 0) {
+        const relevant = items.slice(0, 3).map((i: any) =>
+          `- [${i.type}] ${i.title}: ${(i.content || "").slice(0, 150)}`
+        ).join("\n")
+        contextBlock = `<jfl-context>\nRelevant context:\n${relevant}\n</jfl-context>`
+      }
+    }
+  } catch { /* non-fatal */ }
 
-    return {
-      text: `📊 Status: ${session.gtmName}\nSession: ${session.sessionId}\n\n\`\`\`\n${stdout}\n\`\`\``,
-      parseMode: "Markdown"
+  return { prependContext: contextBlock }
+}
+
+/**
+ * after_turn — fires after each agent response.
+ * Only runs heartbeat + capture when JFL is active.
+ */
+export async function onAfterTurn(event: {
+  agentId: string
+  threadId: string
+  response?: string
+  detectedIntent?: string
+}) {
+  const s = getState(event.threadId)
+  if (!s?.activated || !s?.sessionBranch || !s?.gtmPath) return
+
+  // Heartbeat (auto-commit)
+  try {
+    await openclaw("heartbeat --json", s.gtmPath)
+  } catch { /* non-fatal */ }
+
+  // Auto-capture decisions/completions
+  if (event.detectedIntent && event.response) {
+    const intentMap: Record<string, string> = {
+      decision: "decision",
+      completed: "feature",
+      fixed: "fix",
+      learned: "discovery",
     }
-  } catch (error: any) {
-    return {
-      text: `❌ Status failed\n\n${error.message}`
+    const type = intentMap[event.detectedIntent]
+    if (type) {
+      const title = event.response.slice(0, 80).replace(/\n/g, " ")
+      try {
+        await openclaw(`journal --type ${type} --title "${title.replace(/"/g, '\\"')}" --summary "${title.replace(/"/g, '\\"')}"`, s.gtmPath)
+      } catch { /* non-fatal */ }
     }
   }
 }
 
 /**
- * Format CLI output for Telegram
- * Optimized for mobile viewing
+ * session_end — fires when Clawdbot session ends.
+ * Only cleans up if JFL was active.
  */
-function formatForTelegram(output: string): string {
-  return output
-    // Strip ANSI color codes
-    .replace(/\x1b\[[0-9;]*m/g, "")
-    // Convert long separator lines to short ones (mobile-friendly)
-    .replace(/[━─]{20,}/g, "━━━━━━━━━")
-    // Keep single box-drawing characters as-is (they render fine)
-    .replace(/[┌┐└┘├┤┬┴┼]/g, "")
-    // Convert vertical bars
-    .replace(/[│┃]/g, "")
-    // Add spacing around emoji headers for readability
-    .replace(/^(📊|👥|🎨|✍️|🔄|📝)/gm, "\n$1")
-    // Preserve emoji and structure
-    .trim()
+export async function onSessionEnd(event: { agentId: string; threadId: string }) {
+  const s = getState(event.threadId)
+  if (!s?.activated || !s?.sessionBranch || !s?.gtmPath) return
+
+  try {
+    await openclawJSON("session-end --sync", s.gtmPath)
+  } catch { /* never block shutdown */ }
+
+  // Keep activated state but clear session
+  setState(event.threadId, { ...s, sessionBranch: null })
+}
+
+// ============================================================================
+// Util
+// ============================================================================
+
+function stripAnsi(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*m/g, "")
 }
 
 export default {
+  // Interactive (user-triggered)
   onBoot,
   onCallback,
-  onCommand
+  onCommand,
+  // Lifecycle (Clawdbot-triggered, gated by activation)
+  onSessionStart,
+  onBeforeTurn,
+  onAfterTurn,
+  onSessionEnd,
 }