loopable-cli 0.2.0 → 0.3.0

package/dist/dispatcher.mjs

@@ -55,9 +55,32 @@ var init_define = __esm({
   }
 });
 
+// src/agents/claude/manifest.ts
+var claudeManifest;
+var init_manifest = __esm({
+  "src/agents/claude/manifest.ts"() {
+    "use strict";
+    init_define();
+    claudeManifest = defineAgentManifest({
+      id: "claude",
+      name: "Claude Code",
+      tagline: "Anthropic's coding agent, driven through its print mode.",
+      docsUrl: "https://docs.claude.com/en/docs/claude-code/cli-reference",
+      icon: "ClaudeCode",
+      accent: "bg-[#d97757] text-white",
+      binaries: ["claude"],
+      installHint: "Install with curl -fsSL https://claude.ai/install.sh | bash, then run claude auth login.",
+      permissionModes: ["read_only", "workspace_write"],
+      supportsModel: true,
+      modelPlaceholder: "e.g. sonnet or opus; leave empty for the default",
+      defaults: { permissionMode: "read_only", model: null, timeoutMs: 3e5 }
+    });
+  }
+});
+
 // src/agents/codex/manifest.ts
 var codexManifest;
-var init_manifest = __esm({
+var init_manifest2 = __esm({
   "src/agents/codex/manifest.ts"() {
     "use strict";
     init_define();
@@ -66,7 +89,7 @@ var init_manifest = __esm({
       name: "Codex",
       tagline: "OpenAI's coding agent, driven non-interactively through codex exec.",
       docsUrl: "https://developers.openai.com/codex/cli",
-      icon: "Terminal",
+      icon: "Codex",
       accent: "bg-neutral-900 text-white",
       binaries: ["codex"],
       installHint: "Install with npm i -g @openai/codex, then run codex login.",
@@ -80,7 +103,7 @@ var init_manifest = __esm({
 
 // src/agents/cursor-agent/manifest.ts
 var cursorAgentManifest;
-var init_manifest2 = __esm({
+var init_manifest3 = __esm({
   "src/agents/cursor-agent/manifest.ts"() {
     "use strict";
     init_define();
@@ -89,7 +112,7 @@ var init_manifest2 = __esm({
       name: "Cursor Agent",
       tagline: "Cursor's CLI agent, driven through its print mode.",
       docsUrl: "https://cursor.com/docs/cli",
-      icon: "MousePointerClick",
+      icon: "Cursor",
       accent: "bg-blue-600 text-white",
       binaries: ["cursor-agent"],
       installHint: "Install with curl https://cursor.com/install -fsS | bash, then run cursor-agent login.",
@@ -101,11 +124,148 @@ var init_manifest2 = __esm({
   }
 });
 
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "loopable-cli",
+      version: "0.2.1",
+      description: "CLI to run Loopable: App, Dispatcher, and Runner.",
+      license: "MIT",
+      type: "module",
+      bin: {
+        loopable: "./dist/cli.mjs"
+      },
+      files: [
+        ".output",
+        "dist",
+        "drizzle"
+      ],
+      engines: {
+        node: ">=22"
+      },
+      packageManager: "pnpm@11.22.0",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/imsobear/loopable.git"
+      },
+      bugs: {
+        url: "https://github.com/imsobear/loopable/issues"
+      },
+      homepage: "https://github.com/imsobear/loopable#readme",
+      publishConfig: {
+        access: "public"
+      },
+      imports: {
+        "#/*": "./src/*"
+      },
+      scripts: {
+        dev: "node --experimental-strip-types scripts/dev.ts",
+        start: "node dist/cli.mjs start",
+        dispatcher: "LOOPABLE_DEV=1 node --experimental-strip-types src/cli.ts dispatcher",
+        runner: "LOOPABLE_DEV=1 node --experimental-strip-types src/cli.ts runner",
+        "generate-routes": "tsr generate",
+        build: "vite build && node scripts/build-cli.mjs",
+        preview: "vite preview",
+        test: "vitest run",
+        "test:watch": "vitest",
+        "db:generate": "drizzle-kit generate",
+        "db:studio": "LOOPABLE_DEV=1 drizzle-kit studio",
+        typecheck: "tsc --noEmit",
+        release: "node scripts/release.mjs",
+        deploy: "LOOPABLE_CF=1 vite build && wrangler deploy",
+        "site:dev": "pnpm --filter loopable-site dev",
+        "site:build": "pnpm --filter loopable-site build",
+        "site:deploy": "pnpm --filter loopable-site deploy",
+        prepublishOnly: "pnpm typecheck && pnpm test && pnpm build"
+      },
+      dependencies: {
+        "@libsql/client": "^0.18.0"
+      },
+      devDependencies: {
+        "@base-ui/react": "^1.7.0",
+        "@cloudflare/containers": "^0.3.7",
+        "@cloudflare/vite-plugin": "^1.54.10",
+        "@fontsource-variable/geist": "^5.3.0",
+        "@tailwindcss/vite": "4.1.18",
+        "@tanstack/devtools-vite": "0.8.5",
+        "@tanstack/react-devtools": "0.10.12",
+        "@tanstack/react-router": "1.170.32",
+        "@tanstack/react-router-devtools": "1.167.1",
+        "@tanstack/react-start": "1.168.49",
+        "@tanstack/router-cli": "1.167.33",
+        "@types/node": "^22.10.2",
+        "@types/qrcode": "^1.5.6",
+        "@types/react": "^19.2.0",
+        "@types/react-dom": "^19.2.0",
+        "@vitejs/plugin-react": "^6.0.1",
+        "class-variance-authority": "^0.7.1",
+        clsx: "^2.1.1",
+        "drizzle-kit": "^0.31.10",
+        "drizzle-orm": "^0.45.2",
+        esbuild: "^0.28.2",
+        "lucide-react": "^1.39.0",
+        "next-themes": "^0.4.6",
+        nitro: "3.0.260610-beta",
+        qrcode: "^1.5.4",
+        react: "19.2.0",
+        "react-dom": "19.2.0",
+        shadcn: "^4.19.1",
+        sonner: "^2.0.8",
+        "tailwind-merge": "^3.6.0",
+        tailwindcss: "4.1.18",
+        "tw-animate-css": "^1.4.0",
+        typescript: "^6.0.2",
+        vite: "^8.0.0",
+        vitest: "^4.1.11",
+        wrangler: "^4.132.0"
+      }
+    };
+  }
+});
+
+// src/lib/version.ts
+function olderThan(a, b) {
+  if (!a) return true;
+  const pa = a.split(".").map((part) => Number.parseInt(part, 10));
+  const pb = b.split(".").map((part) => Number.parseInt(part, 10));
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (Number.isNaN(x)) return true;
+    if (x !== y) return x < y;
+  }
+  return false;
+}
+var VERSION, RUNNER_PROTOCOL, LEGACY_RUNNER_PROTOCOL, FOLDER_JOB_PROTOCOL;
+var init_version = __esm({
+  "src/lib/version.ts"() {
+    init_package();
+    VERSION = package_default.version;
+    RUNNER_PROTOCOL = 2;
+    LEGACY_RUNNER_PROTOCOL = 1;
+    FOLDER_JOB_PROTOCOL = 2;
+  }
+});
+
+// src/server/agent-job.ts
+import { isAbsolute, join as join5 } from "node:path";
+function folderIsLegacy(folder) {
+  return isAbsolute(folder.trim());
+}
+var init_agent_job = __esm({
+  "src/server/agent-job.ts"() {
+    "use strict";
+    init_version();
+  }
+});
+
 // src/agents/discover.ts
 import { execFile } from "node:child_process";
 import { accessSync, constants } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { promisify } from "node:util";
 function unique(values) {
   return [...new Set(values.filter(Boolean))];
@@ -114,7 +274,7 @@ function inheritedDirs() {
   const home = homedir2();
   return unique([
     ...(process.env.PATH ?? "").split(":"),
-    ...HOME_DIRS.map((dir) => join5(home, dir)),
+    ...HOME_DIRS.map((dir) => join6(home, dir)),
     ...SYSTEM_DIRS
   ]);
 }
@@ -132,7 +292,7 @@ async function loginShellDirs() {
 function executableIn(dirs, names) {
   for (const dir of dirs) {
     for (const name of names) {
-      const candidate = join5(dir, name);
+      const candidate = join6(dir, name);
       try {
         accessSync(candidate, constants.X_OK);
         return candidate;
@@ -148,9 +308,9 @@ async function resolveBinary(names) {
 function clean(text3) {
   return text3.replace(ANSI, "").trim();
 }
-async function probe(bin, args3, timeoutMs = 1e4) {
+async function probe(bin, args4, timeoutMs = 1e4) {
   try {
-    const { stdout, stderr } = await exec(bin, args3, { timeout: timeoutMs });
+    const { stdout, stderr } = await exec(bin, args4, { timeout: timeoutMs });
     return { ok: true, text: clean(stdout) || clean(stderr) };
   } catch (error) {
     const failure = error;
@@ -298,14 +458,171 @@ var init_process = __esm({
   }
 });
 
+// src/agents/claude/events.ts
+function parse(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function blocks(event) {
+  return event?.type === "assistant" ? event.message?.content ?? [] : [];
+}
+function describeTool(block, cwd) {
+  const verb = (block.name ?? "a tool").toLowerCase();
+  const input = block.input ?? {};
+  const subject = input.file_path ?? input.path ?? input.command ?? input.pattern ?? input.url ?? input.query;
+  if (typeof subject !== "string") return verb;
+  const short = cwd && subject.startsWith(`${cwd}/`) ? subject.slice(cwd.length + 1) : subject;
+  return `${verb} ${short}`;
+}
+function describeEvent(line, cwd) {
+  const event = parse(line);
+  if (!event) return line.trim() === "" ? null : line;
+  switch (event.type) {
+    case "system":
+      if (event.subtype !== "init") return null;
+      return event.model ? `Started with ${event.model}.` : "Started.";
+    case "assistant": {
+      const tools = blocks(event).filter((block) => block.type === "tool_use").map((block) => `Running ${describeTool(block, cwd)}`);
+      return tools.length > 0 ? tools.join("\n") : null;
+    }
+    case "result": {
+      const seconds = event.duration_ms !== void 0 ? (event.duration_ms / 1e3).toFixed(0) : "?";
+      const tokens = event.usage?.output_tokens;
+      const spent = tokens === void 0 ? "" : `, ${tokens} tokens out`;
+      return event.is_error ? `Failed after ${seconds}s${spent}: ${event.result ?? event.subtype ?? "unknown error"}` : `Answered after ${seconds}s${spent}.`;
+    }
+    default:
+      return null;
+  }
+}
+function answerFrom(stdout) {
+  const events = stdout.split("\n").map(parse);
+  const result = events.filter((event) => event?.type === "result").at(-1);
+  const failed = result?.is_error === true;
+  if (typeof result?.result === "string" && result.result.trim() !== "") {
+    return { text: result.result.trim(), failed };
+  }
+  const said = events.flatMap(blocks);
+  const lastTool = said.findLastIndex((block) => block.type === "tool_use");
+  const text3 = said.slice(lastTool + 1).filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n").trim();
+  return { text: text3, failed };
+}
+var init_events = __esm({
+  "src/agents/claude/events.ts"() {
+    "use strict";
+  }
+});
+
+// src/agents/claude/runtime.ts
+async function binary() {
+  const found = await resolveBinary(claudeManifest.binaries);
+  if (!found) throw new Error("The claude binary was not found on this host.");
+  return found;
+}
+function args(input) {
+  const list = [
+    "-p",
+    // A stream of events rather than one block at the end, so a run can be
+    // watched. Print mode refuses stream-json without --verbose.
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    // Session files would outlive a run that is meant to leave nothing behind.
+    "--no-session-persistence"
+  ];
+  if (input.settings.permissionMode === "read_only") {
+    list.push("--permission-mode", "dontAsk", "--tools", "Read,Grep,Glob");
+  } else {
+    list.push("--permission-mode", "acceptEdits", "--allowedTools", "Bash");
+  }
+  if (input.settings.model) list.push("--model", input.settings.model);
+  list.push("--", input.prompt);
+  return list;
+}
+var claudeRuntime;
+var init_runtime = __esm({
+  "src/agents/claude/runtime.ts"() {
+    "use strict";
+    init_define();
+    init_discover();
+    init_process();
+    init_events();
+    init_manifest();
+    claudeRuntime = defineAgentRuntime({
+      async detect() {
+        const found = await resolveBinary(claudeManifest.binaries);
+        if (!found) return { installed: false };
+        const version2 = await probe(found, ["--version"]);
+        return { installed: true, binaryPath: found, version: firstLine(version2.text) };
+      },
+      async authStatus() {
+        const found = await resolveBinary(claudeManifest.binaries);
+        if (!found) return { signedIn: false, detail: "Not installed." };
+        const result = await probe(found, ["auth", "status", "--json"]);
+        try {
+          const status = JSON.parse(result.text);
+          return status.loggedIn ? { signedIn: true, detail: `Signed in (${status.authMethod ?? "unknown method"}).` } : { signedIn: false, detail: "Run claude auth login." };
+        } catch {
+          return {
+            signedIn: result.ok,
+            detail: firstLine(result.text) || (result.ok ? "Signed in." : "Run claude auth login.")
+          };
+        }
+      },
+      invocation(input) {
+        return { bin: claudeManifest.binaries[0], args: args(input) };
+      },
+      async run(input) {
+        const bin = await binary();
+        const argv = args(input);
+        const outcome = await runProcess({
+          bin,
+          args: argv,
+          cwd: input.cwd,
+          timeoutMs: input.settings.timeoutMs,
+          signal: input.signal,
+          logPath: input.logFile,
+          logLine: (line) => describeEvent(line, input.cwd)
+        });
+        const command = `${bin} ${argv.join(" ")}`;
+        const answer = answerFrom(outcome.stdout);
+        if (outcome.aborted) {
+          return { ok: false, aborted: true, output: answer.text, durationMs: outcome.durationMs, command };
+        }
+        if (outcome.timedOut) {
+          return {
+            ok: false,
+            output: answer.text,
+            detail: `Claude Code did not finish within ${Math.round(input.settings.timeoutMs / 1e3)}s.`,
+            durationMs: outcome.durationMs,
+            command
+          };
+        }
+        return {
+          ok: outcome.code === 0 && !answer.failed,
+          output: answer.text,
+          detail: outcome.code === 0 && !answer.failed ? void 0 : answer.failed ? answer.text || "The agent reported an error." : outcome.stderr || `Exited with code ${outcome.code}.`,
+          durationMs: outcome.durationMs,
+          command
+        };
+      }
+    });
+  }
+});
+
 // src/agents/codex/runtime.ts
 import { readFileSync as readFileSync3, rmSync as rmSync2 } from "node:fs";
-async function binary() {
+async function binary2() {
   const found = await resolveBinary(codexManifest.binaries);
   if (!found) throw new Error("The codex binary was not found on this host.");
   return found;
 }
-function args(input) {
+function args2(input) {
   const list = [
     "exec",
     "--sandbox",
@@ -325,13 +642,13 @@ function args(input) {
   return list;
 }
 var codexRuntime;
-var init_runtime = __esm({
+var init_runtime2 = __esm({
   "src/agents/codex/runtime.ts"() {
     "use strict";
     init_define();
     init_discover();
     init_process();
-    init_manifest();
+    init_manifest2();
     codexRuntime = defineAgentRuntime({
       async detect() {
         const found = await resolveBinary(codexManifest.binaries);
@@ -349,11 +666,11 @@ var init_runtime = __esm({
         };
       },
       invocation(input) {
-        return { bin: codexManifest.binaries[0], args: args(input) };
+        return { bin: codexManifest.binaries[0], args: args2(input) };
       },
       async run(input) {
-        const bin = await binary();
-        const argv = args(input);
+        const bin = await binary2();
+        const argv = args2(input);
         const command = `${bin} ${argv.join(" ")}`;
         const outcome = await runProcess({
           bin,
@@ -398,7 +715,7 @@ var init_runtime = __esm({
 });
 
 // src/agents/cursor-agent/events.ts
-function parse(line) {
+function parse2(line) {
   const trimmed = line.trim();
   if (!trimmed.startsWith("{")) return null;
   try {
@@ -407,27 +724,27 @@ function parse(line) {
     return null;
   }
 }
-function textOf2(event) {
+function textOf3(event) {
   return (event.message?.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
 }
-function describeTool(call2, cwd) {
-  const [name, body] = Object.entries(call2 ?? {})[0] ?? [];
+function describeTool2(call3, cwd) {
+  const [name, body] = Object.entries(call3 ?? {})[0] ?? [];
   if (!name) return "a tool";
   const verb = name.replace(/ToolCall$/, "").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
-  const args3 = body?.args ?? {};
-  const subject = args3.path ?? args3.command ?? args3.query ?? args3.pattern;
+  const args4 = body?.args ?? {};
+  const subject = args4.path ?? args4.command ?? args4.query ?? args4.pattern;
   if (typeof subject !== "string") return verb;
   const short = cwd && subject.startsWith(`${cwd}/`) ? subject.slice(cwd.length + 1) : subject;
   return `${verb} ${short}`;
 }
-function describeEvent(line, cwd) {
-  const event = parse(line);
+function describeEvent2(line, cwd) {
+  const event = parse2(line);
   if (!event) return line.trim() === "" ? null : line;
   switch (event.type) {
     case "system":
       return event.model ? `Started with ${event.model}.` : "Started.";
     case "tool_call":
-      return event.subtype === "started" ? `Running ${describeTool(event.tool_call, cwd)}` : null;
+      return event.subtype === "started" ? `Running ${describeTool2(event.tool_call, cwd)}` : null;
     case "assistant":
       return null;
     case "result": {
@@ -440,32 +757,32 @@ function describeEvent(line, cwd) {
       return null;
   }
 }
-function answerFrom(stdout) {
-  const events = stdout.split("\n").map(parse);
+function answerFrom2(stdout) {
+  const events = stdout.split("\n").map(parse2);
   const result = events.filter((event) => event?.type === "result").at(-1);
   const failed = result?.is_error === true;
   const whole = events.findLastIndex(
     (event) => event?.type === "assistant" && event.timestamp_ms === void 0
   );
-  if (whole >= 0) return { text: textOf2(events[whole]).trim(), failed };
+  if (whole >= 0) return { text: textOf3(events[whole]).trim(), failed };
   const lastTool = events.findLastIndex((event) => event?.type === "tool_call");
-  const partial = events.slice(lastTool + 1).filter((event) => event?.type === "assistant").map((event) => textOf2(event));
+  const partial = events.slice(lastTool + 1).filter((event) => event?.type === "assistant").map((event) => textOf3(event));
   if (partial.length > 0) return { text: partial.join("").trim(), failed };
   return { text: (result?.result ?? "").trim(), failed };
 }
-var init_events = __esm({
+var init_events2 = __esm({
   "src/agents/cursor-agent/events.ts"() {
     "use strict";
   }
 });
 
 // src/agents/cursor-agent/runtime.ts
-async function binary2() {
+async function binary3() {
   const found = await resolveBinary(cursorAgentManifest.binaries);
   if (!found) throw new Error("The cursor-agent binary was not found on this host.");
   return found;
 }
-function args2(input) {
+function args3(input) {
   const list = [
     "-p",
     // A stream of events rather than one block at the end: it can be watched
@@ -490,14 +807,14 @@ function args2(input) {
   return list;
 }
 var cursorAgentRuntime;
-var init_runtime2 = __esm({
+var init_runtime3 = __esm({
   "src/agents/cursor-agent/runtime.ts"() {
     "use strict";
     init_define();
     init_discover();
     init_process();
-    init_events();
-    init_manifest2();
+    init_events2();
+    init_manifest3();
     cursorAgentRuntime = defineAgentRuntime({
       async detect() {
         const found = await resolveBinary(cursorAgentManifest.binaries);
@@ -516,11 +833,11 @@ var init_runtime2 = __esm({
         };
       },
       invocation(input) {
-        return { bin: cursorAgentManifest.binaries[0], args: args2(input) };
+        return { bin: cursorAgentManifest.binaries[0], args: args3(input) };
       },
       async run(input) {
-        const bin = await binary2();
-        const argv = args2(input);
+        const bin = await binary3();
+        const argv = args3(input);
         const outcome = await runProcess({
           bin,
           args: argv,
@@ -528,10 +845,10 @@ var init_runtime2 = __esm({
           timeoutMs: input.settings.timeoutMs,
           signal: input.signal,
           logPath: input.logFile,
-          logLine: (line) => describeEvent(line, input.cwd)
+          logLine: (line) => describeEvent2(line, input.cwd)
         });
         const command = `${bin} ${argv.join(" ")}`;
-        const answer = answerFrom(outcome.stdout);
+        const answer = answerFrom2(outcome.stdout);
         if (outcome.aborted) {
           return { ok: false, aborted: true, output: answer.text, durationMs: outcome.durationMs, command };
         }
@@ -567,8 +884,10 @@ var init_runtimes = __esm({
   "src/agents/runtimes.ts"() {
     init_runtime();
     init_runtime2();
+    init_runtime3();
     RUNTIMES2 = {
       codex: codexRuntime,
+      claude: claudeRuntime,
       "cursor-agent": cursorAgentRuntime
     };
   }
@@ -580,7 +899,7 @@ import { createServer } from "node:http";
 // src/server/signals.ts
 import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // node_modules/.pnpm/drizzle-orm@0.45.2_@libsql+client@0.18.0_@types+better-sqlite3@9.6.0_better-sqlite3@13.0.3/node_modules/drizzle-orm/entity.js
 var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
@@ -823,8 +1142,8 @@ var ForeignKey = class {
 };
 
 // node_modules/.pnpm/drizzle-orm@0.45.2_@libsql+client@0.18.0_@types+better-sqlite3@9.6.0_better-sqlite3@13.0.3/node_modules/drizzle-orm/tracing-utils.js
-function iife(fn, ...args3) {
-  return fn(...args3);
+function iife(fn, ...args4) {
+  return fn(...args4);
 }
 
 // node_modules/.pnpm/drizzle-orm@0.45.2_@libsql+client@0.18.0_@types+better-sqlite3@9.6.0_better-sqlite3@13.0.3/node_modules/drizzle-orm/pg-core/unique-constraint.js
@@ -1612,7 +1931,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join8(chunks, separator) {
+  function join9(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -1622,7 +1941,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join8;
+  sql2.join = join9;
   function identifier(value) {
     return new Name(value);
   }
@@ -2490,7 +2809,7 @@ var repositories = {
   key: "repositories",
   kind: "string_list",
   label: "Repositories",
-  help: "owner/name, one per line. Wildcards work: acme/* or */*. Leave empty for every repository you can see.",
+  help: "owner/name, one per line. acme/* works. Empty means all.",
   placeholder: "acme/web"
 };
 var ignoreDrafts = {
@@ -2503,7 +2822,7 @@ var ignoreBots = {
   key: "ignoreBots",
   kind: "boolean",
   label: "Skip pull requests opened by bots",
-  help: "Dependabot and friends open a great many, and each one costs a full run.",
+  help: "Such as Dependabot.",
   default: true
 };
 var sizeLimit = {
@@ -2522,7 +2841,7 @@ var issueTarget = {
   key: "issue",
   kind: "text",
   label: "Issue or pull request",
-  help: "A GitHub URL. Leave empty to write back to whatever triggered the loop.",
+  help: "Empty replies where it was asked. Or a GitHub issue URL.",
   placeholder: "https://github.com/acme/web/issues/12"
 };
 var REVIEW_PROMPT = [
@@ -2540,94 +2859,77 @@ var REVIEW_PROMPT = [
   "Where you cannot see enough of the code to judge something, say so instead of",
   "guessing."
 ].join("\n");
-var PLAN_PROMPT = [
-  "Write a short implementation plan for this issue.",
+var REPLY_PROMPT = [
+  "Answer this issue in a comment, the way a teammate who knows this codebase would.",
   "",
-  "Say what should change, in which files where you can tell, and what to watch",
-  "out for. Stay inside what the issue actually supports: if it is too vague to",
-  "plan, say what is missing rather than inventing the requirements.",
+  "Work out what the issue is asking for. If it is a question, answer it from the",
+  "code rather than from memory. If it reports a bug, find the likely cause and",
+  "point at the files and lines involved. If it asks for a change, say how you",
+  "would make it, where, and what to watch out for.",
   "",
-  "Do not write the implementation."
-].join("\n");
-var IMPLEMENT_PROMPT = [
-  "Implement this issue in the checkout you are in.",
-  "",
-  "Read enough of the surrounding code first that what you write looks like it",
-  "belongs: the same patterns, the same names, the same way of handling errors.",
-  "Where the project has tests for work like this, add one.",
-  "",
-  "Stay inside what the issue asks for. A change that also tidies three other",
-  "things is a change nobody can review. If the issue is too vague to implement,",
-  "or doing it properly needs a decision that is not yours to make, reply with",
-  "exactly NOTHING_TO_DO rather than guessing: an unwanted pull request costs",
-  "more attention than a missing one.",
-  "",
-  "Run the project's tests if you can work out how, and say in your description",
-  "whether you did and what happened."
+  "Read the code; do not change it. If the issue is too vague to answer, say what",
+  "is missing rather than inventing it."
 ].join("\n");
 var githubManifest = defineManifest({
   id: "github",
   name: "GitHub",
-  tagline: "Pick up review requests and assigned issues.",
+  tagline: "Pick up reviews and issues sent to your team's shared GitHub account.",
   docsUrl: "https://docs.github.com/rest",
   icon: "Github",
   accent: "bg-neutral-900 text-white",
   auth: {
     kind: "oauth_redirect",
     scopes: GITHUB_SCOPES,
-    needsAppRegistration: true
+    needsAppRegistration: true,
+    // The Connection is the team's agent on GitHub: whatever it writes appears
+    // under its name, and the work it picks up is whatever the team sends to
+    // it. An account made for this is cleanest, but a teammate's own works too
+    // if they are happy for it to be shared.
+    note: "Connect the account the team will send work to. An account made for this is cleanest, but your own works too if you are happy to share it. Reviews and comments appear under its name, and it sees only the repositories it can access. Sign in to GitHub as that account first; GitHub authorizes whichever account the browser is signed in as."
   },
-  workflows: [
+  triggers: [
     {
       id: "github.review_requested",
-      name: "Review pull requests I am asked to review",
-      summary: "Reads the change and posts a review whenever someone asks for yours.",
+      when: "A GitHub review is requested",
       // Team requests matter more than they sound: in most repositories with a
       // CODEOWNERS file, review arrives addressed to a team rather than a person.
-      trigger: "your review is requested, either directly or through a team you belong to",
+      trigger: "someone requests a review from the connected account, directly or through its team",
       // review-requested covers teams; user-review-requested would not.
       watches: "is:open is:pr review-requested:@me",
-      writes: "a review on the pull request, as a comment rather than an approval",
       settings: [repositories, ignoreDrafts, ignoreBots, sizeLimit],
-      prompt: REVIEW_PROMPT,
-      guidancePlaceholder: "Anything specific to your team. For example: we require a test for every new endpoint.",
-      answer: "review",
       runsIn: "checkout",
+      answer: "review",
       actionId: "github.submit_review"
     },
     {
       id: "github.issue_assigned",
-      name: "Plan issues assigned to me",
-      summary: "Posts a short implementation plan when an issue lands on you.",
-      trigger: "an issue is assigned to you",
-      // is:issue matters: without it this would pick up your own pull requests.
+      when: "A GitHub issue is assigned",
+      trigger: "an issue is assigned to the connected account",
+      // is:issue matters: without it this would pick up pull requests too.
       watches: "is:open is:issue assignee:@me",
-      writes: "a comment on the issue",
       settings: [repositories],
-      prompt: PLAN_PROMPT,
-      guidancePlaceholder: "Anything specific to this codebase worth knowing before planning.",
-      answer: "text",
       runsIn: "checkout",
+      answer: "text",
       actionId: "github.post_issue_comment"
+    }
+  ],
+  workflows: [
+    {
+      id: "github.review_requested",
+      name: "Review pull requests",
+      summary: "Posts a review when someone requests one from the connected account.",
+      triggerId: "github.review_requested",
+      prompt: REVIEW_PROMPT
     },
     {
-      id: "github.issue_implement",
-      name: "Implement issues assigned to me",
-      summary: "Writes the change and opens a draft pull request.",
-      trigger: "an issue is assigned to you",
-      watches: "is:open is:issue assignee:@me",
-      writes: "a draft pull request",
-      // The only workflow that writes code, and so the only one whose agent
-      // gets somewhere to write. Kept apart from "Plan issues assigned to me"
-      // rather than replacing it: asking for a plan and asking for the change
-      // are different jobs, and which one an issue deserves is a judgement
-      // about the issue.
-      runsIn: "checkout",
-      settings: [repositories],
-      prompt: IMPLEMENT_PROMPT,
-      guidancePlaceholder: "How work is done here. For example: every new endpoint needs a test, and we do not add dependencies without asking.",
-      answer: "code",
-      actionId: "github.open_pull_request"
+      // The id is the one "Plan issues assigned to me" had. Planning was one
+      // kind of answer to an issue; replying covers it and the rest, and loops
+      // made for planning keep the prompt they copied.
+      id: "github.issue_assigned",
+      name: "Reply to issues",
+      summary: "Answers an issue in a comment when it is assigned to the connected account.",
+      triggerId: "github.issue_assigned",
+      prompt: REPLY_PROMPT
     }
   ],
   actions: [
@@ -2650,80 +2952,59 @@ var githubManifest = defineManifest({
       // A comment is one body of markdown with nowhere to attach anything, so
       // a review arrives here with its findings written into the prose.
       accepts: ["text"]
-    },
-    {
-      id: "github.open_pull_request",
-      name: "Open a draft pull request",
-      summary: "Open a draft pull request for the branch the agent already pushed.",
-      // The agent cloned and pushed with the machine's git. This action only
-      // names the pull request through the Connection.
-      target: [],
-      accepts: ["code"]
     }
   ],
   // Nothing to configure per account: what the account can see is what GitHub
   // decides, and every narrowing choice belongs to a loop.
   settings: [],
-  // The redirect authorizes whichever account the browser is already signed in
-  // as, so a second account is out of reach without signing out of GitHub
-  // first. Connections are still rows, so this is a product decision only.
+  // One shared account per team. The redirect also authorizes whichever account
+  // the browser is already signed in as, so a second one is out of reach
+  // without signing out of GitHub first. Connections are still rows, so this
+  // is a product decision only.
   allowsMultipleAccounts: false,
   byHand: { kind: "link", placeholder: "https://github.com/acme/web/pull/123" }
 });
 
 // src/connectors/gmail/manifest.ts
-var GMAIL_SCOPES = ["https://www.googleapis.com/auth/gmail.readonly"];
+var GMAIL_SCOPES = [
+  "https://www.googleapis.com/auth/gmail.readonly",
+  "https://www.googleapis.com/auth/gmail.send"
+];
 var extraQuery = {
   key: "extraQuery",
   kind: "text",
-  label: "Narrow it down",
-  help: "Gmail search terms, added to the query above. For example: from:bank.example.com, or subject:invoice, or -from:notifications@github.com.",
-  placeholder: "from:boss@example.com"
+  label: "Only mail matching",
+  help: "Gmail search terms, such as from:billing@vendor.com or subject:invoice.",
+  placeholder: "from:alerts@example.com"
+};
+var needsMeOnly = {
+  key: "needsMeOnly",
+  kind: "boolean",
+  label: "Skip mail that needs nothing",
+  help: "A quick look first decides which mail asks for something. The rest is kept, not run.",
+  default: true
 };
 var perPoll = {
   key: "maxPerPoll",
   kind: "select",
-  label: "At most, per look",
-  help: "Each mail costs a full agent run. A quiet mailbox never reaches this; a busy one should be narrowed above rather than raised here.",
+  label: "At most, per check",
   options: [
-    { value: "3", label: "3 messages" },
-    { value: "10", label: "10 messages" },
-    { value: "25", label: "25 messages" }
+    { value: "3", label: "3 emails" },
+    { value: "10", label: "10 emails" },
+    { value: "25", label: "25 emails" }
   ],
   default: "10"
 };
-var needsMeOnly = {
-  key: "needsMeOnly",
-  kind: "boolean",
-  label: "Only tell me when it needs me",
-  help: "One cheap look at everything that arrived decides which mails are actually asking something of you, from the sender, subject and first line. The rest wait in the backlog with a reason, so you can still run one if this got it wrong.",
-  default: true
-};
 var skipOwn = {
   key: "skipOwn",
   kind: "boolean",
-  label: "Skip mail I sent",
-  help: "Your own messages show up in threads you are part of, and being told about what you just sent is not useful.",
+  label: "Skip mail sent from this account",
   default: true
 };
-var TELL_ME_PROMPT = [
-  "Read the email in EMAIL.md and tell me what it says.",
-  "",
-  "You are writing a phone notification, not a summary document. Two or three",
-  'sentences. No headings, no bullet lists, no preamble like "this email is".',
-  "Lead with who it is from and what they want.",
-  "",
-  "Say plainly if it needs something from me and by when. If there is a",
-  "deadline, an amount of money, a date, or a link I have to act on, include it",
-  "exactly as written rather than describing it.",
-  "",
-  "If it is an automated notification, a newsletter, or otherwise needs nothing",
-  "from me, say so in one line and stop."
-].join("\n");
 var gmailManifest = defineManifest({
   id: "gmail",
   name: "Gmail",
-  tagline: "Read new mail and have an agent tell you what matters.",
+  tagline: "Start a loop when an email arrives, or email an answer to the connected account.",
   docsUrl: "https://developers.google.com/gmail/api/guides",
   icon: "Gmail",
   // Gmail's own red, now that the mark is Gmail's own too. A near miss on a
@@ -2734,45 +3015,40 @@ var gmailManifest = defineManifest({
     scopes: GMAIL_SCOPES,
     needsAppRegistration: true
   },
-  workflows: [
+  triggers: [
     {
       id: "gmail.new_mail",
-      name: "Tell me about new mail",
-      summary: "Reads mail as it arrives and sends you a short account of it somewhere you look.",
-      trigger: "mail arrives in your inbox",
+      when: "An email arrives",
+      trigger: "an email arrives in the connected inbox",
       // A day's window rather than "unread": reading a mail on your phone
       // should not decide whether the loop ever saw it. What stops a mail
-      // being handled twice is its id, not its state, so re-seeing yesterday's
-      // costs nothing and a poller that was off for an hour misses nothing.
+      // being handled twice is its id, not its state.
       watches: "in:inbox newer_than:1d",
-      writes: "a message telling you what arrived",
-      // Nothing to check out: the mail is the whole of the work, and it is
-      // handed over as a file.
+      // The mail is the whole of the work, handed over as a file.
       runsIn: "temp",
       settings: [extraQuery, needsMeOnly, perPoll, skipOwn],
-      prompt: TELL_ME_PROMPT,
-      guidancePlaceholder: "What you care about in your mail. For example: I only need to know about anything involving money or a deadline.",
       answer: "text",
-      // Gmail cannot write, so this answers on WeChat, which is the point of
-      // the workflow rather than an accident of it: mail you are already
-      // reading in Gmail does not need telling about. `source` would mean
-      // nothing here, since no chat started this.
-      actionConnectorId: "wechat",
-      actionId: "wechat.reply",
-      actionTarget: { to: "me" },
-      // Half an hour, because mail turns up one piece at a time and the whole
-      // of deciding what is worth a run is having several to compare. Looking
-      // every two minutes meant almost always finding exactly one, which is
-      // not a batch, so every newsletter got an agent to itself.
-      //
-      // The cost of waiting is being told half an hour late about something
-      // that sat unread for hours before it was sent.
+      // Kept in Inbox until a loop says where it should go.
+      actionConnectorId: "schedule",
+      actionId: "schedule.record",
+      // Mail turns up one piece at a time, and deciding what deserves a run
+      // needs several to compare.
       pollEveryMs: 30 * 6e4
     }
   ],
-  // Read-only, so there is nothing to offer. A loop built on Gmail writes
-  // through whichever connector it picks.
-  actions: [],
+  // No ready-made job: what to do with mail is the team's to say, in a
+  // custom loop.
+  workflows: [],
+  actions: [
+    {
+      id: "gmail.send",
+      name: "Email this account",
+      summary: "Send the answer to the connected account's own inbox, in the same thread when it started from an email there.",
+      target: [],
+      // A review sent here reads as prose, with file and line written in.
+      accepts: ["text"]
+    }
+  ],
   settings: [],
   // The redirect authorizes whichever account the browser is signed in as, so
   // reaching a second one means signing out of Google first.
@@ -2868,24 +3144,17 @@ var at = {
   key: "at",
   kind: "text",
   label: "At",
-  help: "On a 24-hour clock, in this host's own time zone. Only the minutes are used by an hourly loop.",
+  help: "24-hour time, in this host's time zone.",
   placeholder: "09:00"
 };
 var weekday = {
   key: "weekday",
   kind: "select",
   label: "On",
-  help: "Only used by a loop that runs once a week.",
+  help: "For weekly loops.",
   options: WEEKDAY_NAMES.map((name, index2) => ({ value: String(index2), label: name })),
   default: "1"
 };
-var folder = {
-  key: "folder",
-  kind: "text",
-  label: "Folder to work in",
-  help: "An absolute path. Nothing arrives to be looked at on a schedule, so this is the whole of what the agent is given.",
-  placeholder: "/Users/you/code/web"
-};
 var RECURRING_PROMPT = [
   "Nothing has arrived: this is running because the time came round.",
   "",
@@ -2907,42 +3176,203 @@ var scheduleManifest = defineManifest({
   allowsMultipleAccounts: false,
   byHand: { kind: "now" },
   settings: [],
+  triggers: [
+    {
+      id: "schedule.recurring",
+      when: "On a schedule",
+      trigger: "the time you set comes round",
+      // No query to show. A clock is not something one can be written for,
+      // and an invented one shown as if it were real is worse than nothing.
+      runsIn: "folder",
+      settings: [every, at, weekday],
+      answer: "text",
+      actionId: "schedule.record"
+    }
+  ],
+  workflows: [
+    {
+      id: "schedule.recurring",
+      name: "Do something on a schedule",
+      summary: "Runs the agent at the times you set, in a folder you name. The answer stays in Inbox, or goes to Slack, Lark, or GitHub.",
+      triggerId: "schedule.recurring",
+      prompt: RECURRING_PROMPT
+    }
+  ],
+  actions: [
+    {
+      id: "schedule.record",
+      name: "Keep in Inbox",
+      summary: "Keeps the answer in Inbox and sends it nowhere.",
+      target: [],
+      accepts: ["text", "review"]
+    }
+  ]
+});
+
+// src/connectors/slack/manifest.ts
+var channel = {
+  key: "channel",
+  kind: "text",
+  label: "Channel",
+  help: "Empty replies where it was asked. Or a channel ID.",
+  placeholder: "C0123456789"
+};
+var ASK_PROMPT = [
+  "Someone has sent you a message in Slack. Do what it asks, working in this directory,",
+  "and then answer them.",
+  "",
+  "You are answering into Slack. Be brief: a couple of short paragraphs at most,",
+  "no headings, no bullet lists unless you are genuinely listing things. Plain sentences.",
+  "",
+  "If the message asks a question about this code, read enough of it to answer",
+  "properly rather than guessing. If it asks for a change, make the change and",
+  "say in one line what you did. If the message is too vague to act on, say what",
+  "you need to know instead of assuming."
+].join("\n");
+var slackManifest = defineManifest({
+  id: "slack",
+  name: "Slack bot",
+  tagline: "Paste a bot token from a Slack app \u2014 not a Slack login. @mention or DM the bot, and it answers in the thread.",
+  docsUrl: "https://api.slack.com/apps",
+  icon: "Slack",
+  accent: "bg-[#4a154b] text-white",
+  auth: {
+    kind: "token",
+    helpUrl: "https://api.slack.com/apps",
+    note: "This is a Slack app in the workspace, not a Slack account sign-in. Create an app at api.slack.com/apps, add bot scopes (channels:history, channels:read, groups:history, groups:read, im:history, im:read, mpim:history, mpim:read, chat:write), Install to Workspace, then paste the Bot User OAuth Token. Invite the bot to any channel it should watch.",
+    fields: [
+      {
+        key: "botToken",
+        label: "Bot User OAuth Token",
+        placeholder: "xoxb-...",
+        secret: true
+      }
+    ]
+  },
+  triggers: [
+    {
+      id: "slack.ask",
+      when: "The Slack bot is mentioned",
+      trigger: "someone @mentions the Slack bot in a channel it is in, or DMs it",
+      runsIn: "folder",
+      settings: [],
+      answer: "text",
+      actionId: "slack.reply",
+      pollEveryMs: 6e4
+    }
+  ],
   workflows: [
     {
-      id: "schedule.recurring",
-      name: "Do something on a schedule",
-      summary: "Runs an agent in a folder you name, and keeps what it says.",
-      trigger: "the time you set comes round",
-      // No query to show. A clock is not something one can be written for,
-      // and an invented one shown as if it were real is worse than nothing.
-      writes: "a note in the log",
+      id: "slack.ask",
+      name: "Do what I ask the Slack bot",
+      summary: "Runs the agent when someone @mentions the Slack bot or DMs it, and answers in the thread.",
+      triggerId: "slack.ask",
+      prompt: ASK_PROMPT
+    }
+  ],
+  actions: [
+    {
+      id: "slack.reply",
+      name: "Reply in Slack",
+      summary: "Post a message back to the thread that asked, or to a channel you name.",
+      target: [channel],
+      accepts: ["text"]
+    }
+  ],
+  settings: [],
+  allowsMultipleAccounts: false,
+  byHand: { kind: "none" }
+});
+
+// src/connectors/feishu/manifest.ts
+var chat = {
+  key: "chat",
+  kind: "text",
+  label: "Chat ID",
+  help: "Empty replies where it was asked. Or a chat ID (oc_\u2026).",
+  placeholder: "oc_..."
+};
+var ASK_PROMPT2 = [
+  "Someone has sent you a message in Feishu. Do what it asks, working in this directory,",
+  "and then answer them.",
+  "",
+  "You are answering into Feishu. Be brief: a couple of short paragraphs at most,",
+  "no headings, no bullet lists unless you are genuinely listing things. Plain sentences.",
+  "",
+  "If the message asks a question about this code, read enough of it to answer",
+  "properly rather than guessing. If it asks for a change, make the change and",
+  "say in one line what you did. If the message is too vague to act on, say what",
+  "you need to know instead of assuming."
+].join("\n");
+var feishuManifest = defineManifest({
+  id: "feishu",
+  name: "Feishu / Lark bot",
+  tagline: "Paste App ID and App Secret from a Feishu or Lark app \u2014 not a Feishu login. @mention the bot in a group, and it answers in the thread.",
+  docsUrl: "https://open.feishu.cn/app",
+  icon: "Feishu",
+  accent: "bg-[#3370ff] text-white",
+  auth: {
+    kind: "token",
+    helpUrl: "https://open.feishu.cn/app",
+    note: "This is a custom Feishu or Lark app, not a Feishu account sign-in. Create an app, enable Bot, add permissions (im:chat:readonly, im:message, im:message.group_msg, im:message:send_as_bot), create a version and publish it, then paste App ID and App Secret. Invite the bot to any group it should watch. Put lark in Open platform for Lark (international).",
+    fields: [
+      {
+        key: "appId",
+        label: "App ID",
+        placeholder: "cli_...",
+        secret: false
+      },
+      {
+        key: "appSecret",
+        label: "App Secret",
+        placeholder: "App Secret",
+        secret: true
+      },
+      {
+        key: "host",
+        label: "Open platform",
+        placeholder: "feishu or lark",
+        secret: false,
+        optional: true
+      }
+    ]
+  },
+  triggers: [
+    {
+      id: "feishu.ask",
+      when: "The Feishu / Lark bot is mentioned",
+      trigger: "someone @mentions the Feishu / Lark bot in a group it is in",
       runsIn: "folder",
-      settings: [every, at, weekday, folder],
-      prompt: RECURRING_PROMPT,
-      guidancePlaceholder: "Anything that holds every time this runs. For example: this repository releases on Thursdays, so say if anything is unmerged by Wednesday evening.",
+      settings: [],
       answer: "text",
-      actionId: "schedule.record"
+      actionId: "feishu.reply",
+      pollEveryMs: 6e4
+    }
+  ],
+  workflows: [
+    {
+      id: "feishu.ask",
+      name: "Do what I ask the Feishu / Lark bot",
+      summary: "Runs the agent when someone @mentions the Feishu / Lark bot in a group, and answers in the thread.",
+      triggerId: "feishu.ask",
+      prompt: ASK_PROMPT2
     }
   ],
   actions: [
     {
-      id: "schedule.record",
-      name: "Keep it in the log",
-      summary: "Leaves the answer here and sends it nowhere. Every run is recorded anyway, so this is what to use until it is worth pushing somewhere.",
-      target: [],
-      accepts: ["text", "review"]
+      id: "feishu.reply",
+      name: "Reply in Feishu / Lark",
+      summary: "Post a message back to the thread that asked, or to a chat you name.",
+      target: [chat],
+      accepts: ["text"]
     }
-  ]
+  ],
+  settings: [],
+  allowsMultipleAccounts: false,
+  byHand: { kind: "none" }
 });
 
 // src/connectors/wechat/manifest.ts
-var folder2 = {
-  key: "folder",
-  kind: "text",
-  label: "Folder to work in",
-  help: "An absolute path to a checkout on this host. The agent runs here, so it can read the code you are asking about.",
-  placeholder: "/Users/you/code/your-project"
-};
 var askers = {
   key: "askers",
   kind: "select",
@@ -2957,14 +3387,14 @@ var recipient = {
   key: "to",
   kind: "select",
   label: "Who to send it to",
-  help: "WeChat only reliably delivers a reply to a conversation you started. Sending to yourself out of the blue is refused unless you have written to the bot in the last half day or so, which makes this a poor fit for anything that has to arrive overnight.",
+  help: '"Me" only arrives if you messaged the bot in the last half day.',
   options: [
     { value: "source", label: "Whoever asked" },
     { value: "me", label: "Me" }
   ],
   default: "source"
 };
-var ASK_PROMPT = [
+var ASK_PROMPT3 = [
   "Someone has sent you a message. Do what it asks, working in this directory,",
   "and then answer them.",
   "",
@@ -2988,23 +3418,28 @@ var wechatManifest = {
     kind: "qr_scan",
     note: "Scanning binds a bot to your WeChat account. Loopable can then read what people send that bot and answer as it, and nothing else on your account."
   },
-  workflows: [
+  triggers: [
     {
       id: "wechat.ask",
-      name: "Do what I ask the bot",
-      summary: "Runs your agent on a runner when you message the bot, and answers in the chat.",
-      trigger: "you send the bot a message",
+      when: "The WeChat bot gets a message",
+      trigger: "someone sends the WeChat bot a message",
       // No query to show: messages arrive on a stream rather than being found
       // by asking, so there is nothing here that could be checked.
-      writes: "a reply in the chat",
       runsIn: "folder",
-      settings: [folder2, askers],
-      prompt: ASK_PROMPT,
-      guidancePlaceholder: "Anything the agent should know about this project before it starts. For example: run pnpm test before saying a change works.",
+      settings: [askers],
       answer: "text",
       actionId: "wechat.reply"
     }
   ],
+  workflows: [
+    {
+      id: "wechat.ask",
+      name: "Do what I ask the WeChat bot",
+      summary: "Runs the agent when someone messages the WeChat bot, and answers in the chat.",
+      triggerId: "wechat.ask",
+      prompt: ASK_PROMPT3
+    }
+  ],
   actions: [
     {
       id: "wechat.reply",
@@ -3027,6 +3462,8 @@ var wechatManifest = {
 // src/connectors/manifests.ts
 var CONNECTOR_MANIFESTS = [
   githubManifest,
+  slackManifest,
+  feishuManifest,
   gmailManifest,
   wechatManifest,
   scheduleManifest
@@ -3037,8 +3474,36 @@ function connectorManifest(id) {
 function needsAccount(id) {
   return connectorManifest(id)?.auth.kind !== "none";
 }
+function customOn(trigger) {
+  return {
+    ...trigger,
+    triggerId: trigger.id,
+    name: trigger.when,
+    summary: `When ${trigger.trigger}.`,
+    prompt: "",
+    custom: true
+  };
+}
 function connectorWorkflow(connectorId, workflowId) {
-  return connectorManifest(connectorId)?.workflows.find((entry) => entry.id === workflowId);
+  const manifest = connectorManifest(connectorId);
+  if (!manifest) return void 0;
+  const defined = manifest.workflows.find((entry) => entry.id === workflowId);
+  if (defined) {
+    const trigger2 = manifest.triggers.find((entry) => entry.id === defined.triggerId);
+    if (!trigger2) return void 0;
+    return {
+      ...trigger2,
+      ...defined,
+      actionId: defined.actionId ?? trigger2.actionId,
+      actionConnectorId: defined.actionConnectorId ?? trigger2.actionConnectorId,
+      actionTarget: defined.actionTarget ?? trigger2.actionTarget,
+      pollEveryMs: defined.pollEveryMs ?? trigger2.pollEveryMs,
+      triggerId: trigger2.id,
+      custom: false
+    };
+  }
+  const trigger = manifest.triggers.find((entry) => entry.id === workflowId);
+  return trigger ? customOn(trigger) : void 0;
 }
 function connectorAction(connectorId, actionId) {
   return connectorManifest(connectorId)?.actions.find((entry) => entry.id === actionId);
@@ -3445,10 +3910,10 @@ function candidates(items, repositories2) {
     return repo && repoMatches(repo, repositories2) ? [{ repo, item }] : [];
   });
 }
-function query(workflowId) {
-  const workflow = githubManifest.workflows.find((entry) => entry.id === workflowId);
-  if (!workflow?.watches) throw new Error(`GitHub cannot watch for ${workflowId}.`);
-  return workflow.watches;
+function query(triggerId) {
+  const trigger = githubManifest.triggers.find((entry) => entry.id === triggerId);
+  if (!trigger?.watches) throw new Error(`GitHub cannot watch for ${triggerId}.`);
+  return trigger.watches;
 }
 async function pollGithub(input) {
   const repositories2 = stringList(input.settings.repositories);
@@ -3724,11 +4189,17 @@ var githubRuntime = defineRuntime({
 
 // src/connectors/gmail/api.ts
 var BASE = "https://gmail.googleapis.com/gmail/v1/users/me";
-async function request2(accessToken, path) {
+async function request2(accessToken, path, init = {}) {
   let res;
   try {
     res = await fetch(`${BASE}${path}`, {
-      headers: { Authorization: `Bearer ${accessToken}`, Accept: "application/json" }
+      method: init.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+        ...init.body === void 0 ? {} : { "Content-Type": "application/json" }
+      },
+      ...init.body === void 0 ? {} : { body: JSON.stringify(init.body) }
     });
   } catch (error) {
     throw new TransientError(
@@ -3740,6 +4211,9 @@ async function request2(accessToken, path) {
     const message = `Gmail ${res.status} on ${path}: ${detail}`;
     const backoff = res.status === 403 && /rateLimitExceeded|userRateLimitExceeded/i.test(detail);
     if (res.status === 429 || res.status >= 500 || backoff) throw new TransientError(message);
+    if (res.status === 403 && /insufficient.*scope|ACCESS_TOKEN_SCOPE_INSUFFICIENT/i.test(detail)) {
+      throw new Error("This Gmail connection cannot send mail. Reconnect Gmail to allow it.");
+    }
     throw new Error(message);
   }
   return await res.json();
@@ -3759,6 +4233,12 @@ function getMessageHeaders(accessToken, id) {
 function getMessage(accessToken, id) {
   return request2(accessToken, `/messages/${id}?format=full`);
 }
+function sendMessage(accessToken, raw, threadId) {
+  return request2(accessToken, "/messages/send", {
+    method: "POST",
+    body: threadId ? { raw, threadId } : { raw }
+  });
+}
 
 // src/connectors/gmail/mail.ts
 function mailRef(id) {
@@ -3848,12 +4328,31 @@ function mailContext(message) {
     ].join("\n")
   };
 }
+function base64url(text3) {
+  return Buffer.from(text3, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function encodedWord(text3) {
+  return /^[\x20-\x7e]*$/.test(text3) ? text3 : `=?UTF-8?B?${Buffer.from(text3, "utf8").toString("base64")}?=`;
+}
+function composeMail(input) {
+  const lines = [
+    `To: ${input.to}`,
+    `Subject: ${encodedWord(input.subject)}`,
+    ...input.inReplyTo ? [`In-Reply-To: ${input.inReplyTo}`, `References: ${input.inReplyTo}`] : [],
+    "MIME-Version: 1.0",
+    'Content-Type: text/plain; charset="UTF-8"',
+    "Content-Transfer-Encoding: base64",
+    "",
+    Buffer.from(input.body, "utf8").toString("base64").replace(/.{76}/g, "$&\r\n")
+  ];
+  return base64url(lines.join("\r\n"));
+}
 
 // src/connectors/gmail/poll.ts
 function baseQuery(workflowId) {
-  const workflow = gmailManifest.workflows.find((entry) => entry.id === workflowId);
-  if (!workflow?.watches) throw new Error(`Gmail cannot watch for ${workflowId}.`);
-  return workflow.watches;
+  const trigger = gmailManifest.triggers.find((entry) => entry.id === workflowId);
+  if (!trigger?.watches) throw new Error(`Gmail cannot watch for ${workflowId}.`);
+  return trigger.watches;
 }
 function boolean2(value, fallback) {
   return typeof value === "boolean" ? value : fallback;
@@ -4068,8 +4567,33 @@ var gmailRuntime = defineRuntime({
       })
     };
   },
-  // No applyAction: this connector reads. A loop built on it answers through
-  // whichever connector it is pointed at.
+  /**
+   * Answers go to the connected account itself, the way a bot answers
+   * whoever asked it. When the run started from an email in this inbox, the
+   * answer joins that thread.
+   */
+  async applyAction({ actionId, source, body, credential }) {
+    if (actionId !== "gmail.send") throw new Error(`Gmail cannot ${actionId}.`);
+    const { accessToken } = await usableToken2(credential);
+    const profile = await getProfile(accessToken);
+    let subject = source.title || "From Loopable";
+    let threadId;
+    let inReplyTo;
+    const sourceId = source.connectorId === "gmail" ? source.ref.replace(/^mail#/, "") : "";
+    if (sourceId) {
+      const original = await getMessage(accessToken, sourceId);
+      threadId = original.threadId;
+      inReplyTo = headerOf(original, "Message-ID") || void 0;
+      const said = headerOf(original, "Subject");
+      if (said) subject = /^re:/i.test(said) ? said : `Re: ${said}`;
+    }
+    const sent = await sendMessage(
+      accessToken,
+      composeMail({ to: profile.emailAddress, subject, body, inReplyTo }),
+      threadId
+    );
+    return { url: permalink(sent.id) };
+  },
   auth: {
     async startAuthorization({ redirectUri, state }) {
       const registration = requireRegistration2();
@@ -4203,6 +4727,618 @@ var scheduleRuntime = {
   }
 };
 
+// src/connectors/slack/api.ts
+var API = "https://slack.com/api";
+async function slack(path, token, init = {}) {
+  const url = new URL(`${API}/${path}`);
+  for (const [key, value] of Object.entries(init.query ?? {})) {
+    url.searchParams.set(key, value);
+  }
+  let response;
+  try {
+    response = await fetch(url.href, {
+      method: init.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        ...init.body ? { "Content-Type": "application/json" } : {}
+      },
+      body: init.body ? JSON.stringify(init.body) : void 0
+    });
+  } catch (error) {
+    throw new TransientError(`Slack is unreachable: ${error.message}`);
+  }
+  if (response.status >= 500 || response.status === 429) {
+    throw new TransientError(`Slack answered ${response.status}`);
+  }
+  if (!response.ok) throw new Error(`Slack answered ${response.status}`);
+  return await response.json();
+}
+function refuse(error) {
+  if (error === "invalid_auth" || error === "not_authed" || error === "token_revoked" || error === "account_inactive") {
+    throw new Error("Slack did not accept that token.");
+  }
+  throw new Error(error ? `Slack refused: ${error}` : "Slack refused the request.");
+}
+async function authTest(botToken) {
+  const body = await slack("auth.test", botToken);
+  if (!body.ok) refuse(body.error);
+  const teamUrl = typeof body.url === "string" ? body.url : "";
+  const team = typeof body.team === "string" ? body.team : "";
+  const teamId = typeof body.team_id === "string" ? body.team_id : "";
+  const botUserId = typeof body.user_id === "string" ? body.user_id : "";
+  const botId = typeof body.bot_id === "string" ? body.bot_id : "";
+  const botName = typeof body.user === "string" ? body.user : "";
+  if (!teamId || !botUserId) throw new Error("Slack did not return which workspace this bot belongs to.");
+  return { botToken, teamId, team, teamUrl, botUserId, botId, botName };
+}
+async function listConversations(credential) {
+  const body = await slack("conversations.list", credential.botToken, {
+    query: {
+      types: "public_channel,private_channel,im,mpim",
+      exclude_archived: "true",
+      limit: "200"
+    }
+  });
+  if (!body.ok) refuse(body.error);
+  const channels = Array.isArray(body.channels) ? body.channels : [];
+  return channels.map((raw) => {
+    const channel2 = raw;
+    if (!channel2.id) return null;
+    return { id: channel2.id, name: channel2.name ?? "", isIm: channel2.is_im === true };
+  }).filter((channel2) => channel2 !== null);
+}
+async function history(credential, channelId, oldest) {
+  const query2 = {
+    channel: channelId,
+    limit: "100",
+    inclusive: "false"
+  };
+  if (oldest) query2.oldest = oldest;
+  const body = await slack("conversations.history", credential.botToken, { query: query2 });
+  if (!body.ok) {
+    if (body.error === "not_in_channel" || body.error === "channel_not_found") return [];
+    refuse(body.error);
+  }
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  const parsed = [];
+  for (const raw of messages) {
+    const message = raw;
+    if (!message.ts) continue;
+    parsed.push({
+      ts: message.ts,
+      ...message.user ? { user: message.user } : {},
+      ...message.bot_id ? { botId: message.bot_id } : {},
+      text: message.text ?? "",
+      ...message.thread_ts ? { threadTs: message.thread_ts } : {}
+    });
+  }
+  return parsed.sort((a, b) => Number(a.ts) - Number(b.ts));
+}
+async function postMessage(credential, input) {
+  const body = await slack("chat.postMessage", credential.botToken, {
+    method: "POST",
+    body: {
+      channel: input.channel,
+      text: input.text,
+      ...input.threadTs ? { thread_ts: input.threadTs } : {}
+    }
+  });
+  if (!body.ok) refuse(body.error);
+  const ts = typeof body.ts === "string" ? body.ts : "";
+  const channel2 = typeof body.channel === "string" ? body.channel : input.channel;
+  if (!ts) throw new Error("Slack accepted the message but did not say where it landed.");
+  return { ts, channel: channel2 };
+}
+function permalink2(credential, channel2, ts) {
+  const host = credential.teamUrl.replace(/\/$/, "");
+  return `${host}/archives/${channel2}/p${ts.replace(".", "")}`;
+}
+
+// src/connectors/slack/runtime.ts
+function asAsked(value) {
+  const record = value;
+  if (!record || typeof record.channel !== "string" || typeof record.ts !== "string") {
+    throw new Error("This task has lost the message it was about.");
+  }
+  return {
+    channel: record.channel,
+    ts: record.ts,
+    user: typeof record.user === "string" ? record.user : void 0,
+    text: typeof record.text === "string" ? record.text : "",
+    threadTs: typeof record.threadTs === "string" ? record.threadTs : record.ts
+  };
+}
+function asCursor(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") out[key] = entry;
+  }
+  return out;
+}
+function summarise2(text3) {
+  const line = text3.replace(/<@[^>]+>/g, "").replace(/\s+/g, " ").trim();
+  if (!line) return "Slack message";
+  return line.length > 80 ? `${line.slice(0, 79)}\u2026` : line;
+}
+function isAsk(input) {
+  if (input.user === input.botUserId || input.messageBotId && input.messageBotId === input.botId) {
+    return false;
+  }
+  if (input.isIm) return Boolean(input.text.trim());
+  return input.text.includes(`<@${input.botUserId}>`);
+}
+function destination(target, source) {
+  if (typeof target.channel === "string" && target.channel.trim()) {
+    return { channel: target.channel.trim() };
+  }
+  if (source.connectorId !== "slack") {
+    throw new Error("There is no Slack channel behind this task. Choose one on the loop.");
+  }
+  const carry = source.carry ?? {};
+  if (!carry.channel) throw new Error("There is no Slack channel behind this task. Choose one on the loop.");
+  return { channel: carry.channel, threadTs: carry.ts };
+}
+function accountOf2(credential) {
+  return {
+    id: credential.teamId,
+    // The bot, then the workspace it is in: "@loopable · Acme". The workspace
+    // alone read as if it were the bot's name.
+    label: [credential.botName ? `@${credential.botName}` : null, credential.team || credential.teamId].filter(Boolean).join(" \xB7 "),
+    url: credential.teamUrl || void 0
+  };
+}
+var slackRuntime = {
+  async readiness() {
+    return { ready: true };
+  },
+  async poll({ workflowId, credential, cursor }) {
+    if (workflowId !== "slack.ask") {
+      throw new Error(`Slack cannot watch for ${workflowId}.`);
+    }
+    const account2 = credential;
+    const previous = asCursor(cursor);
+    const channels = await listConversations(account2);
+    const next = { ...previous };
+    const signals2 = [];
+    for (const channel2 of channels) {
+      const oldest = previous[channel2.id];
+      const messages = await history(account2, channel2.id, oldest);
+      if (messages.length === 0) {
+        if (!next[channel2.id]) next[channel2.id] = String(Date.now() / 1e3);
+        continue;
+      }
+      next[channel2.id] = messages[messages.length - 1].ts;
+      if (!oldest) continue;
+      for (const message of messages) {
+        if (!isAsk({
+          text: message.text,
+          user: message.user,
+          messageBotId: message.botId,
+          isIm: channel2.isIm,
+          botUserId: account2.botUserId,
+          botId: account2.botId
+        })) {
+          continue;
+        }
+        const asked = {
+          channel: channel2.id,
+          ts: message.ts,
+          user: message.user,
+          text: message.text,
+          threadTs: message.threadTs ?? message.ts
+        };
+        signals2.push({
+          key: `${channel2.id}:${message.ts}`,
+          kind: "message",
+          ref: `${channel2.id}:${message.ts}`,
+          title: summarise2(message.text),
+          url: permalink2(account2, channel2.id, message.ts),
+          payload: asked
+        });
+      }
+    }
+    return { signals: signals2, cursor: next };
+  },
+  async resolveWorkItem({ payload }) {
+    const asked = asAsked(payload);
+    return {
+      kind: "message",
+      ref: `${asked.channel}:${asked.ts}`,
+      title: summarise2(asked.text),
+      url: "",
+      carry: { channel: asked.channel, ts: asked.threadTs },
+      context: [
+        {
+          name: "MESSAGE.md",
+          body: [`# What you were asked`, ``, asked.text, ``].join("\n")
+        }
+      ]
+    };
+  },
+  async applyAction({ actionId, target, source, body, credential }) {
+    if (actionId !== "slack.reply") throw new Error(`Slack cannot ${actionId}.`);
+    const account2 = credential;
+    const to = destination(target, source);
+    const posted = await postMessage(account2, {
+      channel: to.channel,
+      text: body.trim(),
+      threadTs: to.threadTs
+    });
+    return { url: permalink2(account2, posted.channel, posted.ts) };
+  },
+  auth: {
+    async connectWithFields(fields) {
+      const botToken = fields.botToken?.trim() ?? "";
+      if (!botToken.startsWith("xoxb-")) {
+        throw new Error("Paste the Bot User OAuth Token from your Slack app. It starts with xoxb-.");
+      }
+      const credential = await authTest(botToken);
+      return { credential, account: accountOf2(credential) };
+    },
+    async identity(credential) {
+      const stored = credential;
+      const fresh = await authTest(stored.botToken);
+      return { account: accountOf2(fresh) };
+    }
+  }
+};
+
+// src/connectors/feishu/api.ts
+var API2 = {
+  feishu: "https://open.feishu.cn/open-apis",
+  lark: "https://open.larksuite.com/open-apis"
+};
+var APPLINK = {
+  feishu: "https://applink.feishu.cn/client/chat/open",
+  lark: "https://applink.larksuite.com/client/chat/open"
+};
+function parseHost(value) {
+  const raw = (value ?? "feishu").trim().toLowerCase();
+  if (!raw || raw === "feishu" || raw === "feishu.cn" || raw.includes("feishu.cn")) return "feishu";
+  if (raw === "lark" || raw === "larksuite" || raw.includes("larksuite.com") || raw.includes("larkoffice.com")) {
+    return "lark";
+  }
+  throw new Error("Open platform must be feishu (China) or lark (international).");
+}
+function refuse2(code, msg) {
+  if (code === 10003 || code === 10012 || code === 10014) {
+    throw new Error("Feishu did not accept those app credentials.");
+  }
+  throw new Error(msg ? `Feishu refused: ${msg}` : "Feishu refused the request.");
+}
+async function call(host, path, init = {}) {
+  const url = new URL(`${API2[host]}${path}`);
+  for (const [key, value] of Object.entries(init.query ?? {})) {
+    url.searchParams.set(key, value);
+  }
+  let response;
+  try {
+    response = await fetch(url.href, {
+      method: init.method ?? "GET",
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        ...init.token ? { Authorization: `Bearer ${init.token}` } : {}
+      },
+      body: init.body ? JSON.stringify(init.body) : void 0
+    });
+  } catch (error) {
+    throw new TransientError(`Feishu is unreachable: ${error.message}`);
+  }
+  if (response.status >= 500 || response.status === 429) {
+    throw new TransientError(`Feishu answered ${response.status}`);
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new Error(`Feishu answered ${response.status}`);
+  }
+  return body;
+}
+function dataOf(body) {
+  if (body.code && body.code !== 0) refuse2(body.code, body.msg);
+  return body.data ?? {};
+}
+async function tenantAccessToken(host, appId, appSecret) {
+  const body = await call(host, "/auth/v3/tenant_access_token/internal", {
+    method: "POST",
+    body: { app_id: appId, app_secret: appSecret }
+  });
+  if (body.code && body.code !== 0) refuse2(body.code, body.msg);
+  const token = body.tenant_access_token ?? "";
+  const expire = typeof body.expire === "number" ? body.expire : 7200;
+  if (!token) throw new Error("Feishu did not return a tenant token.");
+  return { token, expiresAt: Date.now() + expire * 1e3 - 6e4 };
+}
+async function botInfo(credential) {
+  const body = await call(credential.host, "/bot/v3/info", { token: credential.tenantAccessToken });
+  if (body.code && body.code !== 0) refuse2(body.code, body.msg);
+  const bot = body.bot ?? {};
+  const openId = typeof bot.open_id === "string" ? bot.open_id : "";
+  const name = typeof bot.app_name === "string" ? bot.app_name : "";
+  const avatarUrl = typeof bot.avatar_url === "string" ? bot.avatar_url : void 0;
+  if (!openId) throw new Error("Feishu did not return which bot this app is.");
+  return { openId, name, ...avatarUrl ? { avatarUrl } : {} };
+}
+async function listChats(credential) {
+  const chats = [];
+  let pageToken = "";
+  do {
+    const query2 = { page_size: "100" };
+    if (pageToken) query2.page_token = pageToken;
+    const body = await call(credential.host, "/im/v1/chats", {
+      token: credential.tenantAccessToken,
+      query: query2
+    });
+    const data = dataOf(body);
+    const items = Array.isArray(data.items) ? data.items : [];
+    for (const raw of items) {
+      const chat2 = raw;
+      if (!chat2.chat_id) continue;
+      chats.push({ id: chat2.chat_id, name: chat2.name ?? "" });
+    }
+    pageToken = data.has_more === true && typeof data.page_token === "string" ? data.page_token : "";
+  } while (pageToken);
+  return chats;
+}
+function textOf(content) {
+  if (!content) return "";
+  try {
+    const parsed = JSON.parse(content);
+    return typeof parsed.text === "string" ? parsed.text : content;
+  } catch {
+    return content;
+  }
+}
+function mentionsOf(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((entry) => {
+    const mention = entry;
+    return typeof mention.id === "string" ? mention.id : "";
+  }).filter(Boolean);
+}
+async function history2(credential, chatId, oldestMs) {
+  const parsed = [];
+  let pageToken = "";
+  do {
+    const query2 = {
+      container_id_type: "chat",
+      container_id: chatId,
+      sort_type: oldestMs ? "ByCreateTimeAsc" : "ByCreateTimeDesc",
+      page_size: oldestMs ? "50" : "1"
+    };
+    if (oldestMs) query2.start_time = String(Math.floor(Number(oldestMs) / 1e3));
+    if (pageToken) query2.page_token = pageToken;
+    const body = await call(credential.host, "/im/v1/messages", {
+      token: credential.tenantAccessToken,
+      query: query2
+    });
+    if (body.code && body.code !== 0) {
+      if (body.code === 230002 || body.code === 231203) return parsed;
+      refuse2(body.code, body.msg);
+    }
+    const data = body.data ?? {};
+    const items = Array.isArray(data.items) ? data.items : [];
+    for (const raw of items) {
+      const message = raw;
+      if (!message.message_id || message.deleted) continue;
+      parsed.push({
+        id: message.message_id,
+        chatId: message.chat_id ?? chatId,
+        createTime: message.create_time ?? "",
+        text: textOf(message.body?.content),
+        ...message.sender?.id ? { senderId: message.sender.id } : {},
+        ...message.sender?.sender_type ? { senderType: message.sender.sender_type } : {},
+        mentionIds: mentionsOf(message.mentions)
+      });
+    }
+    pageToken = oldestMs && data.has_more === true && typeof data.page_token === "string" ? data.page_token : "";
+  } while (pageToken);
+  return parsed.sort((a, b) => Number(a.createTime) - Number(b.createTime));
+}
+async function replyMessage(credential, messageId, text3) {
+  const body = await call(credential.host, `/im/v1/messages/${messageId}/reply`, {
+    token: credential.tenantAccessToken,
+    method: "POST",
+    body: { msg_type: "text", content: JSON.stringify({ text: text3 }) }
+  });
+  const data = dataOf(body);
+  const id = typeof data.message_id === "string" ? data.message_id : "";
+  const chatId = typeof data.chat_id === "string" ? data.chat_id : "";
+  if (!id) throw new Error("Feishu accepted the reply but did not say where it landed.");
+  return { id, chatId };
+}
+async function sendMessage2(credential, chatId, text3) {
+  const body = await call(credential.host, "/im/v1/messages", {
+    token: credential.tenantAccessToken,
+    method: "POST",
+    query: { receive_id_type: "chat_id" },
+    body: { receive_id: chatId, msg_type: "text", content: JSON.stringify({ text: text3 }) }
+  });
+  const data = dataOf(body);
+  const id = typeof data.message_id === "string" ? data.message_id : "";
+  const landed = typeof data.chat_id === "string" ? data.chat_id : chatId;
+  if (!id) throw new Error("Feishu accepted the message but did not say where it landed.");
+  return { id, chatId: landed };
+}
+function permalink3(host, chatId) {
+  return `${APPLINK[host]}?openChatId=${chatId}`;
+}
+
+// src/connectors/feishu/runtime.ts
+function asAsked2(value) {
+  const record = value;
+  if (!record || typeof record.chatId !== "string" || typeof record.messageId !== "string") {
+    throw new Error("This task has lost the message it was about.");
+  }
+  return {
+    chatId: record.chatId,
+    messageId: record.messageId,
+    user: typeof record.user === "string" ? record.user : void 0,
+    text: typeof record.text === "string" ? record.text : ""
+  };
+}
+function asCursor2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") out[key] = entry;
+  }
+  return out;
+}
+function summarise3(text3) {
+  const line = text3.replace(/@_user_\d+/g, "").replace(/\s+/g, " ").trim();
+  if (!line) return "Feishu message";
+  return line.length > 80 ? `${line.slice(0, 79)}\u2026` : line;
+}
+function isAsk2(input) {
+  if (input.senderType === "app" || input.senderId === input.botOpenId) return false;
+  return input.mentionIds.includes(input.botOpenId);
+}
+function destination2(target, source) {
+  if (typeof target.chat === "string" && target.chat.trim()) {
+    return { chatId: target.chat.trim() };
+  }
+  if (source.connectorId !== "feishu") {
+    throw new Error("There is no Feishu chat behind this task. Choose one on the loop.");
+  }
+  const carry = source.carry ?? {};
+  if (!carry.chatId && !carry.messageId) {
+    throw new Error("There is no Feishu chat behind this task. Choose one on the loop.");
+  }
+  return { chatId: carry.chatId, messageId: carry.messageId };
+}
+function accountOf3(credential) {
+  return {
+    id: credential.botOpenId,
+    label: credential.botName || credential.appId,
+    ...credential.avatarUrl ? { avatarUrl: credential.avatarUrl } : {}
+  };
+}
+async function usable(credential) {
+  if (Date.now() < credential.expiresAt) return { credential };
+  const minted = await tenantAccessToken(credential.host, credential.appId, credential.appSecret);
+  const refreshed = {
+    ...credential,
+    tenantAccessToken: minted.token,
+    expiresAt: minted.expiresAt
+  };
+  return { credential: refreshed, refreshed };
+}
+var feishuRuntime = {
+  async readiness() {
+    return { ready: true };
+  },
+  async poll({ workflowId, credential, cursor }) {
+    if (workflowId !== "feishu.ask") {
+      throw new Error(`Feishu cannot watch for ${workflowId}.`);
+    }
+    const { credential: account2 } = await usable(credential);
+    const previous = asCursor2(cursor);
+    const chats = await listChats(account2);
+    const next = { ...previous };
+    const signals2 = [];
+    for (const chat2 of chats) {
+      const oldest = previous[chat2.id];
+      const messages = await history2(account2, chat2.id, oldest);
+      if (messages.length === 0) {
+        if (!next[chat2.id]) next[chat2.id] = String(Date.now());
+        continue;
+      }
+      next[chat2.id] = messages[messages.length - 1].createTime;
+      if (!oldest) continue;
+      for (const message of messages) {
+        if (oldest && Number(message.createTime) <= Number(oldest)) continue;
+        if (!isAsk2({
+          senderId: message.senderId,
+          senderType: message.senderType,
+          mentionIds: message.mentionIds,
+          botOpenId: account2.botOpenId
+        })) {
+          continue;
+        }
+        const asked = {
+          chatId: message.chatId,
+          messageId: message.id,
+          user: message.senderId,
+          text: message.text
+        };
+        signals2.push({
+          key: `${message.chatId}:${message.id}`,
+          kind: "message",
+          ref: message.id,
+          title: summarise3(message.text),
+          url: permalink3(account2.host, message.chatId),
+          payload: asked
+        });
+      }
+    }
+    return { signals: signals2, cursor: next };
+  },
+  async resolveWorkItem({ payload }) {
+    const asked = asAsked2(payload);
+    return {
+      kind: "message",
+      ref: asked.messageId,
+      title: summarise3(asked.text),
+      url: "",
+      carry: { chatId: asked.chatId, messageId: asked.messageId },
+      context: [
+        {
+          name: "MESSAGE.md",
+          body: [`# What you were asked`, ``, asked.text, ``].join("\n")
+        }
+      ]
+    };
+  },
+  async applyAction({ actionId, target, source, body, credential }) {
+    if (actionId !== "feishu.reply") throw new Error(`Feishu cannot ${actionId}.`);
+    const { credential: account2 } = await usable(credential);
+    const to = destination2(target, source);
+    const text3 = body.trim();
+    const posted = to.messageId && source.connectorId === "feishu" ? await replyMessage(account2, to.messageId, text3) : await sendMessage2(account2, to.chatId ?? "", text3);
+    return { url: permalink3(account2.host, posted.chatId || to.chatId || "") };
+  },
+  auth: {
+    async connectWithFields(fields) {
+      const appId = fields.appId?.trim() ?? "";
+      const appSecret = fields.appSecret?.trim() ?? "";
+      if (!appId) throw new Error("Paste the App ID from your Feishu or Lark app.");
+      if (!appSecret) throw new Error("Paste the App Secret from your Feishu or Lark app.");
+      const host = parseHost(fields.host);
+      const minted = await tenantAccessToken(host, appId, appSecret);
+      const bot = await botInfo({ host, tenantAccessToken: minted.token });
+      const stored = {
+        appId,
+        appSecret,
+        host,
+        botOpenId: bot.openId,
+        botName: bot.name,
+        ...bot.avatarUrl ? { avatarUrl: bot.avatarUrl } : {},
+        tenantAccessToken: minted.token,
+        expiresAt: minted.expiresAt
+      };
+      return { credential: stored, account: accountOf3(stored) };
+    },
+    async identity(credential) {
+      const stored = credential;
+      const { credential: fresh, refreshed } = await usable(stored);
+      const bot = await botInfo(fresh);
+      const updated = {
+        ...fresh,
+        botOpenId: bot.openId,
+        botName: bot.name,
+        ...bot.avatarUrl ? { avatarUrl: bot.avatarUrl } : {}
+      };
+      return {
+        account: accountOf3(updated),
+        ...refreshed ? { renewedCredential: updated } : {}
+      };
+    }
+  }
+};
+
 // src/connectors/wechat/runtime.ts
 import { randomUUID } from "node:crypto";
 
@@ -4227,7 +5363,7 @@ function postHeaders(token) {
     ...token ? { Authorization: `Bearer ${token}` } : {}
   };
 }
-async function call(url, init) {
+async function call2(url, init) {
   let response;
   try {
     response = await fetch(url, init);
@@ -4241,7 +5377,7 @@ async function call(url, init) {
   return await response.json();
 }
 async function requestQrCode() {
-  const body = await call(
+  const body = await call2(
     `${WECHAT_API}/ilink/bot/get_bot_qrcode?bot_type=3`,
     {
       method: "POST",
@@ -4261,7 +5397,7 @@ function absolute(host) {
 async function qrCodeStatus(qrcode, host) {
   let body;
   try {
-    body = await call(
+    body = await call2(
       `${absolute(host)}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`,
       { headers: APP_HEADERS }
     );
@@ -4314,7 +5450,7 @@ function refusal(body) {
   return body.errmsg || `WeChat refused the request (${bad}).`;
 }
 async function notifyStart(credential) {
-  const body = await call(`${credential.baseUrl}/ilink/bot/msg/notifystart`, {
+  const body = await call2(`${credential.baseUrl}/ilink/bot/msg/notifystart`, {
     method: "POST",
     headers: postHeaders(credential.botToken),
     body: JSON.stringify({ base_info: BASE_INFO })
@@ -4324,7 +5460,7 @@ async function notifyStart(credential) {
 }
 var FROM_USER = 1;
 var TEXT_ITEM = 1;
-function textOf(message) {
+function textOf2(message) {
   return (message.item_list ?? []).filter((item) => item.type === TEXT_ITEM).map((item) => item.text_item?.text?.trim()).filter((text3) => Boolean(text3)).join("\n").trim();
 }
 function isFromPerson(message) {
@@ -4336,7 +5472,7 @@ async function getUpdates(credential, cursor) {
   const timer = setTimeout(() => abort.abort(), WAIT_MS);
   let body;
   try {
-    body = await call(`${credential.baseUrl}/ilink/bot/getupdates`, {
+    body = await call2(`${credential.baseUrl}/ilink/bot/getupdates`, {
       method: "POST",
       headers: postHeaders(credential.botToken),
       body: JSON.stringify({ get_updates_buf: cursor, base_info: BASE_INFO }),
@@ -4352,8 +5488,8 @@ async function getUpdates(credential, cursor) {
   if (refused) throw new Error(refused);
   return { messages: body.msgs ?? [], cursor: body.get_updates_buf || cursor };
 }
-async function sendMessage(credential, input) {
-  const body = await call(`${credential.baseUrl}/ilink/bot/sendmessage`, {
+async function sendMessage3(credential, input) {
+  const body = await call2(`${credential.baseUrl}/ilink/bot/sendmessage`, {
     method: "POST",
     headers: postHeaders(credential.botToken),
     body: JSON.stringify({
@@ -4388,7 +5524,7 @@ function asAttempt(value) {
   }
   return { qrcode: record.qrcode, host: record.host };
 }
-function asAsked(value) {
+function asAsked3(value) {
   const record = value;
   if (!record || typeof record.fromUserId !== "string" || typeof record.text !== "string") {
     throw new Error("This task has lost the message it was about.");
@@ -4400,7 +5536,7 @@ function asAsked(value) {
     text: record.text
   };
 }
-function summarise2(text3) {
+function summarise4(text3) {
   const line = text3.split("\n")[0].trim();
   return line.length > 80 ? `${line.slice(0, 79)}\u2026` : line;
 }
@@ -4427,7 +5563,7 @@ function recipientFor(target, source, account2) {
   if (!carry.toUserId) throw new Error("There is nobody to reply to on this task.");
   return { userId: carry.toUserId, contextToken: carry.contextToken };
 }
-function accountOf2(credential) {
+function accountOf4(credential) {
   return {
     id: credential.botId || credential.userId,
     label: credential.botId ? `WeChat bot ${credential.botId}` : "WeChat bot"
@@ -4455,7 +5591,7 @@ var wechatRuntime = {
     const signals2 = [];
     for (const message of messages) {
       if (!isFromPerson(message)) continue;
-      const text3 = textOf(message);
+      const text3 = textOf2(message);
       if (!text3) continue;
       const fromUserId = message.from_user_id ?? "";
       const asked = {
@@ -4468,7 +5604,7 @@ var wechatRuntime = {
         key: `msg#${asked.messageId}`,
         kind: "message",
         ref: `msg#${asked.messageId}`,
-        title: summarise2(text3),
+        title: summarise4(text3),
         // A message in a chat is not somewhere a browser can be sent.
         url: "",
         // Held rather than dropped, so a message that was sent and never
@@ -4481,11 +5617,11 @@ var wechatRuntime = {
     return { signals: signals2, cursor: next };
   },
   async resolveWorkItem({ payload }) {
-    const asked = asAsked(payload);
+    const asked = asAsked3(payload);
     return {
       kind: "message",
       ref: `msg#${asked.messageId}`,
-      title: summarise2(asked.text),
+      title: summarise4(asked.text),
       url: "",
       carry: { toUserId: asked.fromUserId, contextToken: asked.contextToken },
       context: [
@@ -4501,7 +5637,7 @@ var wechatRuntime = {
     const account2 = credential;
     const to = recipientFor(target, source, account2);
     for (const part of chunked(body)) {
-      await sendMessage(account2, {
+      await sendMessage3(account2, {
         toUserId: to.userId,
         contextToken: to.contextToken,
         // Unique per piece, so a retry cannot post half an answer twice.
@@ -4527,7 +5663,7 @@ var wechatRuntime = {
         case "confirmed":
           return {
             state: "confirmed",
-            result: { credential: status.credential, account: accountOf2(status.credential) }
+            result: { credential: status.credential, account: accountOf4(status.credential) }
           };
         case "expired":
           return { state: "expired", reason: status.reason };
@@ -4542,7 +5678,7 @@ var wechatRuntime = {
     async identity(credential) {
       const stored = credential;
       await notifyStart(stored);
-      return { account: accountOf2(stored) };
+      return { account: accountOf4(stored) };
     }
   }
 };
@@ -4550,6 +5686,8 @@ var wechatRuntime = {
 // src/connectors/runtimes.ts
 var RUNTIMES = {
   github: githubRuntime,
+  slack: slackRuntime,
+  feishu: feishuRuntime,
   gmail: gmailRuntime,
   wechat: wechatRuntime,
   schedule: scheduleRuntime
@@ -6289,7 +7427,7 @@ var SQLiteSelectQueryBuilderBase = class extends TypedQueryBuilder {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table)) this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join8) => join8.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join9) => join9.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -7148,7 +8286,7 @@ var SQLiteUpdateBase = class extends QueryPromise {
   createJoin(joinType) {
     return (table, on2) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join8) => join8.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join9) => join9.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on2 === "function") {
@@ -8607,6 +9745,10 @@ var runners = sqliteTable("runners", {
   status: text2("status").$type().notNull().default("offline"),
   inventory: text2("inventory", { mode: "json" }).$type().notNull().default([]),
   lastSeenAt: integer("last_seen_at", { mode: "timestamp_ms" }),
+  /** The runner's loopable-cli version. Null for runners before 0.3. */
+  version: text2("version"),
+  /** What jobs it understands; see RUNNER_PROTOCOL. Null means the first. */
+  protocol: integer("protocol"),
   createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(sql`(unixepoch() * 1000)`)
 });
 
@@ -8629,13 +9771,13 @@ function migrationsFolder() {
     join3(here, "../../../drizzle"),
     join3(process.cwd(), "drizzle")
   ];
-  return candidates2.find((folder3) => existsSync2(folder3)) ?? join3(process.cwd(), "drizzle");
+  return candidates2.find((folder) => existsSync2(folder)) ?? join3(process.cwd(), "drizzle");
 }
 async function migrateIfNeeded() {
   if (process.env.LOOPABLE_SKIP_MIGRATE === "1") return;
-  const folder3 = migrationsFolder();
-  if (!existsSync2(folder3)) return;
-  await migrate(db(), { migrationsFolder: folder3 });
+  const folder = migrationsFolder();
+  if (!existsSync2(folder)) return;
+  await migrate(db(), { migrationsFolder: folder });
 }
 function rowsChanged(result) {
   return Number(result.rowsAffected ?? result.changes ?? 0);
@@ -8752,14 +9894,14 @@ async function decrypt(blob2) {
   return new TextDecoder().decode(opened);
 }
 function bytesToBase64(bytes) {
-  let binary3 = "";
-  for (const byte of bytes) binary3 += String.fromCharCode(byte);
-  return btoa(binary3);
+  let binary4 = "";
+  for (const byte of bytes) binary4 += String.fromCharCode(byte);
+  return btoa(binary4);
 }
 function base64ToBytes(blob2) {
-  const binary3 = atob(blob2);
-  const bytes = new Uint8Array(binary3.length);
-  for (let i = 0; i < binary3.length; i += 1) bytes[i] = binary3.charCodeAt(i);
+  const binary4 = atob(blob2);
+  const bytes = new Uint8Array(binary4.length);
+  for (let i = 0; i < binary4.length; i += 1) bytes[i] = binary4.charCodeAt(i);
   return bytes;
 }
 var tableStore = {
@@ -8877,12 +10019,13 @@ async function checkConnection(id) {
 // src/server/tasks.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, rmSync as rmSync3, statSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { isAbsolute, join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // src/agents/manifests.ts
 init_manifest();
 init_manifest2();
-var AGENT_MANIFESTS = [codexManifest, cursorAgentManifest];
+init_manifest3();
+var AGENT_MANIFESTS = [codexManifest, claudeManifest, cursorAgentManifest];
 function agentManifest(id) {
   return AGENT_MANIFESTS.find((manifest) => manifest.id === id);
 }
@@ -8909,6 +10052,10 @@ var REVIEW_FORMAT = [
   `- "findings" may be empty when the summary says everything worth saying.`
 ].join("\n");
 
+// src/server/tasks.ts
+init_agent_job();
+init_version();
+
 // src/server/agents.ts
 init_runtimes();
 var DEFAULT_AGENT_KEY = "defaultAgentId";
@@ -8980,7 +10127,11 @@ function branchFor(input) {
 
 // src/server/runners.ts
 import { hostname as osHostname } from "node:os";
+init_version();
 var ONLINE_MS = 45e3;
+function protocolOf(row) {
+  return row.protocol ?? LEGACY_RUNNER_PROTOCOL;
+}
 function isRunnerOnline(row, now = Date.now()) {
   if (row.status !== "online") return false;
   if (!row.lastSeenAt) return false;
@@ -8994,7 +10145,10 @@ function toView2(row, now = Date.now()) {
     hostname: row.hostname,
     status: online ? "online" : "offline",
     inventory: row.inventory,
-    lastSeenAt: row.lastSeenAt?.toISOString() ?? null
+    lastSeenAt: row.lastSeenAt?.toISOString() ?? null,
+    version: row.version,
+    protocol: protocolOf(row),
+    outdated: protocolOf(row) < RUNNER_PROTOCOL || olderThan(row.version, VERSION)
   };
 }
 async function listRunners() {
@@ -9018,11 +10172,13 @@ async function busyRunnerIds() {
     )
   );
 }
-async function availableAgentIds(requiresHost = false) {
+async function availableAgentIds(requiresHost = false, minProtocol = 0) {
   const local = osHostname();
   return [
     ...new Set(
-      (await listRunners()).filter((row) => row.status === "online" && (!requiresHost || row.hostname === local)).flatMap(
+      (await listRunners()).filter(
+        (row) => row.status === "online" && (!requiresHost || row.hostname === local) && row.protocol >= minProtocol
+      ).flatMap(
         (row) => row.inventory.filter((entry) => entry.installed && entry.signedIn).map((entry) => entry.agentId)
       )
     )
@@ -9031,9 +10187,11 @@ async function availableAgentIds(requiresHost = false) {
 async function pickRunner(input) {
   const now = Date.now();
   const local = osHostname();
-  let candidates2 = (await db().select().from(runners).all()).filter(
+  const minProtocol = input.minProtocol ?? 0;
+  const capable = (await db().select().from(runners).all()).filter(
     (row) => isRunnerOnline(row, now) && runnerCanRun(row, input.agentId)
   );
+  let candidates2 = capable.filter((row) => protocolOf(row) >= minProtocol);
   if (input.requiresHost) {
     candidates2 = candidates2.filter((row) => row.hostname === local);
   }
@@ -9044,6 +10202,11 @@ async function pickRunner(input) {
   if (input.requiresHost) {
     throw new Error("This job needs a runner on the same host as Loopable.");
   }
+  if (capable.length > 0) {
+    throw new Error(
+      "Every runner with this agent is too old for this job. Upgrade them with npm install -g loopable-cli."
+    );
+  }
   throw new Error("No runner is online that can run this agent.");
 }
 
@@ -9185,11 +10348,11 @@ async function enqueueSignal(input) {
   });
 }
 function sweepRunDirs(maxAgeMs = 7 * 24 * 60 * 60 * 1e3) {
-  const root = join6(dataDir(), "runs");
+  const root = join7(dataDir(), "runs");
   if (!existsSync4(root)) return 0;
   let removed = 0;
   for (const entry of readdirSync(root)) {
-    const dir = join6(root, entry);
+    const dir = join7(root, entry);
     try {
       if (Date.now() - statSync(dir).mtimeMs < maxAgeMs) continue;
       rmSync3(dir, { recursive: true, force: true });
@@ -9252,7 +10415,7 @@ async function preparePromptTask(id, signal) {
   let logPath = null;
   if (!isHosted()) {
     const workspace = runDir(id);
-    logPath = join6(workspace, "agent.log");
+    logPath = join7(workspace, "agent.log");
     writeFileSync2(logPath, "", { flag: "a" });
   }
   const runnerId = await pickRunner({ agentId: task.agentId, requiresHost: false });
@@ -9276,14 +10439,17 @@ async function prepareTask(id, signal) {
   if (!isHosted()) {
     const workspace = runDir(id);
     for (const file of item.context) {
-      writeFileSync2(join6(workspace, file.name), file.body);
+      writeFileSync2(join7(workspace, file.name), file.body);
     }
-    logPath = join6(workspace, "agent.log");
+    logPath = join7(workspace, "agent.log");
     writeFileSync2(logPath, "", { flag: "a" });
   }
+  const folder = workflow.runsIn === "folder" && typeof loop.settings.folder === "string" ? loop.settings.folder : null;
   const runnerId = await pickRunner({
     agentId,
-    requiresHost: workflow.runsIn === "folder"
+    requiresHost: folder !== null && folderIsLegacy(folder),
+    // A relative folder needs a runner that resolves it under its own home.
+    minProtocol: folder !== null && !folderIsLegacy(folder) ? FOLDER_JOB_PROTOCOL : 0
   });
   await updateTask(id, {
     state: "awaiting_agent",
@@ -9458,7 +10624,7 @@ async function pollLoop(loop, claimed) {
     if (!runtime.poll) throw new Error(`${manifest.name} cannot watch for anything yet.`);
     const { credential } = await credentialForConnector(loop.connectorId);
     const answer = await runtime.poll({
-      workflowId: loop.workflowId,
+      workflowId: workflow.triggerId,
       settings: loop.settings,
       credential,
       cursor: loop.pollCursor ?? null
@@ -9478,7 +10644,7 @@ async function pollLoop(loop, claimed) {
         signals: fresh,
         agentId: await defaultAgentFor(loop.agentId),
         guidance: loop.guidance,
-        cwd: mkdtempSync(join7(tmpdir(), "loopable-triage-"))
+        cwd: mkdtempSync(join8(tmpdir(), "loopable-triage-"))
       });
     }
     for (const signal of found) {