@ainyc/canonry 1.46.1 → 1.48.2

package/dist/cli.js

@@ -1,127 +1,75 @@
 #!/usr/bin/env node --import tsx
 import {
+  AGENT_WEBHOOK_EVENTS,
+  AgentManager,
+  CliError,
+  EXIT_SYSTEM_ERROR,
+  EXIT_USER_ERROR,
   ProviderNames,
   RunKinds,
+  attachAgentWebhookDirect,
+  buildAgentWebhookUrl,
   computeCompetitorOverlap,
   configExists,
+  configureOpenClawGateway,
   createServer,
+  detectOpenClaw,
   determineAnswerMentioned,
   determineCitationState,
   effectiveDomains,
   extractRecommendedCompetitors,
   formatAuditFactorScore,
+  getAeroStateDir,
   getConfigDir,
   getConfigPath,
   getOrCreateAnonymousId,
+  initializeOpenClawProfile,
+  installOpenClaw,
   isFirstRun,
   isTelemetryEnabled,
   loadConfig,
   notificationEventSchema,
+  printCliError,
+  providerEnvVar,
   providerQuotaPolicySchema,
   reparseStoredResult,
   reparseStoredResult2,
   reparseStoredResult3,
   reparseStoredResult4,
+  resolveAgentCredentials,
   resolveProviderInput,
   saveConfig,
   saveConfigPatch,
+  seedWorkspace,
   setGoogleAuthConfig,
+  setOpenClawModel,
   showFirstRunNotice,
-  trackEvent
-} from "./chunk-RMLIF47M.js";
+  trackEvent,
+  usageError,
+  writeAgentEnv
+} from "./chunk-YPTVJRJY.js";
 import {
   apiKeys,
   competitors,
   createClient,
-  createLogger,
   migrate,
   parseJsonColumn,
   projects,
   querySnapshots,
   runs
-} from "./chunk-HO22LHTY.js";
+} from "./chunk-JTKHPNGL.js";
 
 // src/cli.ts
 import { pathToFileURL } from "url";
 
-// src/cli-error.ts
-var EXIT_USER_ERROR = 1;
-var EXIT_SYSTEM_ERROR = 2;
-var CliError = class extends Error {
-  code;
-  displayMessage;
-  details;
-  exitCode;
-  constructor(options) {
-    super(options.message);
-    this.name = "CliError";
-    this.code = options.code;
-    this.displayMessage = options.displayMessage;
-    this.details = options.details;
-    this.exitCode = options.exitCode ?? EXIT_USER_ERROR;
-  }
-};
-function usageError(displayMessage, options) {
-  const firstLine = displayMessage.split("\n", 1)[0] ?? "Error: invalid command usage";
-  return new CliError({
-    code: "CLI_USAGE_ERROR",
-    message: options?.message ?? firstLine.replace(/^Error:\s*/, ""),
-    displayMessage,
-    details: options?.details
-  });
-}
-function printCliError(err, format) {
-  if (format === "json") {
-    if (err instanceof CliError) {
-      console.error(
-        JSON.stringify(
-          {
-            error: {
-              code: err.code,
-              message: err.message,
-              ...err.details ? { details: err.details } : {}
-            }
-          },
-          null,
-          2
-        )
-      );
-      return;
-    }
-    const message = err instanceof Error ? err.message : "An unexpected error occurred";
-    console.error(
-      JSON.stringify(
-        {
-          error: {
-            code: "CLI_ERROR",
-            message
-          }
-        },
-        null,
-        2
-      )
-    );
-    return;
-  }
-  if (err instanceof CliError && err.displayMessage) {
-    console.error(err.displayMessage);
-    return;
-  }
-  if (err instanceof Error) {
-    console.error(`Error: ${err.message}`);
-    return;
-  }
-  console.error("An unexpected error occurred");
-}
-
 // src/cli-dispatch.ts
 import { parseArgs } from "util";
 function commandId(spec) {
   return spec.path.join(".");
 }
-function matchesPath(args, path9) {
-  if (args.length < path9.length) return false;
-  return path9.every((segment, index) => args[index] === segment);
+function matchesPath(args, path7) {
+  if (args.length < path7.length) return false;
+  return path7.every((segment, index) => args[index] === segment);
 }
 function withFormatOption(options) {
   if (!options) {
@@ -356,7 +304,7 @@ async function backfillAnswerVisibilityCommand(opts) {
   console.log(`  Errors:   ${providerErrors}`);
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService } = await import("./intelligence-service-ZISLIU4S.js");
+  const { IntelligenceService } = await import("./intelligence-service-Q4WX46MJ.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -614,9 +562,9 @@ var ApiClient = class {
     }
     return this.probePromise;
   }
-  async request(method, path9, body) {
+  async request(method, path7, body) {
     await this.probeBasePath();
-    const url = `${this.baseUrl}${path9}`;
+    const url = `${this.baseUrl}${path7}`;
     const serializedBody = body != null ? JSON.stringify(body) : void 0;
     const headers = {
       "Authorization": `Bearer ${this.apiKey}`,
@@ -1695,9 +1643,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs10 = await import("fs");
+    const fs8 = await import("fs");
     try {
-      const content = fs10.readFileSync(opts.keyFile, "utf-8");
+      const content = fs8.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -2455,10 +2403,10 @@ Open this URL in your browser to authorize Google ${opts.type.toUpperCase()} acc
     console.log("(Ensure this URI is listed in your Google Cloud Console OAuth client's authorized redirect URIs)\n");
   }
   try {
-    const { spawn: spawn3 } = await import("child_process");
+    const { spawn: spawn2 } = await import("child_process");
     const platform = process.platform;
     const [cmd, ...extraArgs] = platform === "darwin" ? ["open", authUrl] : platform === "win32" ? ["cmd", "/c", "start", "", authUrl] : ["xdg-open", authUrl];
-    spawn3(cmd, [...extraArgs], { detached: true, stdio: "ignore" }).unref();
+    spawn2(cmd, [...extraArgs], { detached: true, stdio: "ignore" }).unref();
     console.log("(Browser opened automatically)");
   } catch {
     console.log("(Could not open browser automatically \u2014 please copy the URL above)");
@@ -3524,7 +3472,9 @@ var EVENT_DESCRIPTIONS = {
   "citation.lost": "A keyword lost its citation status",
   "citation.gained": "A keyword gained citation status",
   "run.completed": "A visibility run completed successfully",
-  "run.failed": "A visibility run failed"
+  "run.failed": "A visibility run failed",
+  "insight.critical": "A critical-severity insight was generated",
+  "insight.high": "A high-severity insight was generated"
 };
 function listEvents(format) {
   const events = notificationEventSchema.options;
@@ -6917,12 +6867,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs10 = await import("fs/promises");
-  const path9 = await import("path");
-  const filePath = path9.resolve(opts.from);
+  const fs8 = await import("fs/promises");
+  const path7 = await import("path");
+  const filePath = path7.resolve(opts.from);
   let raw;
   try {
-    raw = await fs10.readFile(filePath, "utf8");
+    raw = await fs8.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -7019,13 +6969,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs10 = await import("fs/promises");
-  const path9 = await import("path");
+  const fs8 = await import("fs/promises");
+  const path7 = await import("path");
   const yaml = await import("yaml").catch(() => null);
-  const filePath = path9.resolve(opts.profile);
+  const filePath = path7.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs10.readFile(filePath, "utf8");
+    raw = await fs8.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -7130,13 +7080,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs10 = await import("fs/promises");
-    const path9 = await import("path");
+    const fs8 = await import("fs/promises");
+    const path7 = await import("path");
     const yaml = await import("yaml").catch(() => null);
-    const filePath = path9.resolve(opts.profile);
+    const filePath = path7.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs10.readFile(filePath, "utf8");
+      raw = await fs8.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -7718,445 +7668,7 @@ var WORDPRESS_CLI_COMMANDS = [
 ];
 
 // src/commands/agent.ts
-import path8 from "path";
-
-// src/agent-manager.ts
-import { execFileSync, spawn as spawn2 } from "child_process";
-import fs8 from "fs";
 import path6 from "path";
-var log = createLogger("AgentManager");
-var PROCESS_MARKER = "canonry-openclaw-gateway";
-var AgentManager = class {
-  constructor(config, stateDir) {
-    this.config = config;
-    this.stateDir = stateDir;
-    this.processJsonPath = path6.join(stateDir, "process.json");
-  }
-  processJsonPath;
-  /**
-   * Check if the gateway process is running.
-   * Cleans up stale process.json if the process is dead or belongs to a
-   * different process (PID reuse).
-   */
-  status() {
-    const info = this.readProcessInfo();
-    if (!info) {
-      return { state: "stopped" };
-    }
-    if (info.marker !== PROCESS_MARKER) {
-      this.removeProcessJson();
-      return { state: "stopped" };
-    }
-    if (isProcessAlive2(info.pid) && this.verifyProcessIdentity(info.pid)) {
-      return {
-        state: "running",
-        pid: info.pid,
-        port: info.gatewayPort,
-        startedAt: info.startedAt
-      };
-    }
-    this.removeProcessJson();
-    return { state: "stopped" };
-  }
-  /**
-   * Start the OpenClaw gateway as a detached background process.
-   * Idempotent — no-op if already running.
-   * Waits briefly for the process to confirm it hasn't crashed on startup.
-   */
-  async start() {
-    const currentStatus = this.status();
-    if (currentStatus.state === "running") {
-      log.info("already.running", { pid: currentStatus.pid });
-      return;
-    }
-    const binary = this.config.binary ?? "openclaw";
-    const profile = this.config.profile ?? "aero";
-    const port = this.config.gatewayPort ?? 3579;
-    if (!fs8.existsSync(this.stateDir)) {
-      fs8.mkdirSync(this.stateDir, { recursive: true });
-    }
-    const logFile = path6.join(this.stateDir, "gateway.log");
-    const logFd = fs8.openSync(logFile, "a");
-    const dotEnv = this.loadDotEnv();
-    const child = spawn2(binary, ["--profile", profile, "gateway"], {
-      detached: true,
-      stdio: ["ignore", logFd, logFd],
-      env: {
-        ...process.env,
-        ...dotEnv,
-        OPENCLAW_PROFILE: profile,
-        OPENCLAW_GATEWAY_PORT: String(port),
-        OPENCLAW_STATE_DIR: this.stateDir
-      }
-    });
-    const startupResult = await new Promise((resolve) => {
-      let settled = false;
-      const settle = (r) => {
-        if (settled) return;
-        settled = true;
-        resolve(r);
-      };
-      child.on("error", (err) => settle({ error: err }));
-      child.on("exit", (code) => settle({ exitCode: code }));
-      setTimeout(() => settle({}), 500);
-    });
-    child.unref();
-    fs8.closeSync(logFd);
-    if (startupResult.error) {
-      throw new Error(`Failed to start OpenClaw gateway: ${startupResult.error.message}`);
-    }
-    if (startupResult.exitCode != null) {
-      throw new Error(`OpenClaw gateway exited immediately (code ${startupResult.exitCode}). Check ${path6.join(this.stateDir, "gateway.log")} for details.`);
-    }
-    if (child.pid == null) {
-      throw new Error("Failed to start OpenClaw gateway: no PID returned by spawn");
-    }
-    if (!isProcessAlive2(child.pid)) {
-      throw new Error(`OpenClaw gateway exited immediately after spawn. Check ${path6.join(this.stateDir, "gateway.log")} for details.`);
-    }
-    const processInfo = {
-      pid: child.pid,
-      gatewayPort: port,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      marker: PROCESS_MARKER
-    };
-    fs8.writeFileSync(this.processJsonPath, JSON.stringify(processInfo, null, 2), "utf-8");
-    log.info("started", { pid: child.pid, port });
-  }
-  /**
-   * Stop the gateway process.
-   * Uses DenchClaw escalation: SIGTERM → 800ms poll → SIGKILL.
-   * Idempotent — no-op if already stopped.
-   */
-  async stop() {
-    const info = this.readProcessInfo();
-    if (!info) return;
-    if (isProcessAlive2(info.pid) && info.marker === PROCESS_MARKER && this.verifyProcessIdentity(info.pid)) {
-      await terminateWithEscalation(info.pid);
-    }
-    this.removeProcessJson();
-    log.info("stopped", { pid: info.pid });
-  }
-  /**
-   * Stop the gateway, wipe the workspace directory, and prepare for re-seeding.
-   */
-  async reset() {
-    await this.stop();
-    const workspaceDir = path6.join(this.stateDir, "workspace");
-    if (fs8.existsSync(workspaceDir)) {
-      fs8.rmSync(workspaceDir, { recursive: true, force: true });
-      log.info("workspace.wiped", { dir: workspaceDir });
-    }
-  }
-  /**
-   * Verify that the PID actually belongs to an openclaw process by checking
-   * the full command line. Requires "openclaw" in the args to avoid matching
-   * unrelated Node processes after PID reuse.
-   */
-  verifyProcessIdentity(pid) {
-    try {
-      if (process.platform === "darwin") {
-        const out = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
-          encoding: "utf-8",
-          timeout: 2e3
-        }).trim();
-        return out.includes("openclaw");
-      }
-      if (process.platform === "linux") {
-        const cmdline = fs8.readFileSync(`/proc/${pid}/cmdline`, "utf-8");
-        return cmdline.includes("openclaw");
-      }
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  readProcessInfo() {
-    if (!fs8.existsSync(this.processJsonPath)) return null;
-    try {
-      return JSON.parse(fs8.readFileSync(this.processJsonPath, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  removeProcessJson() {
-    try {
-      fs8.unlinkSync(this.processJsonPath);
-    } catch {
-    }
-  }
-  /** Parse a simple KEY=value dotenv file from the state dir. */
-  loadDotEnv() {
-    const envFile = path6.join(this.stateDir, ".env");
-    if (!fs8.existsSync(envFile)) return {};
-    const result = {};
-    for (const line of fs8.readFileSync(envFile, "utf-8").split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eq3 = trimmed.indexOf("=");
-      if (eq3 < 1) continue;
-      result[trimmed.slice(0, eq3)] = trimmed.slice(eq3 + 1);
-    }
-    return result;
-  }
-};
-function isProcessAlive2(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function terminateWithEscalation(pid) {
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {
-    return;
-  }
-  const deadline = Date.now() + 800;
-  while (Date.now() < deadline) {
-    if (!isProcessAlive2(pid)) return;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  try {
-    process.kill(pid, "SIGKILL");
-  } catch {
-  }
-}
-
-// src/agent-bootstrap.ts
-import { execFileSync as execFileSync2, execSync } from "child_process";
-import fs9 from "fs";
-import os from "os";
-import path7 from "path";
-import { fileURLToPath } from "url";
-var CACHE_TTL_MS = 5 * 60 * 1e3;
-var cachedResult = null;
-var cachedAt = 0;
-function getAeroStateDir(profile = "aero") {
-  return path7.join(os.homedir(), `.openclaw-${profile}`);
-}
-async function detectOpenClaw(config) {
-  if (cachedResult && Date.now() - cachedAt < CACHE_TTL_MS) {
-    return cachedResult;
-  }
-  let result;
-  if (config?.binary) {
-    const version = probeVersion(config.binary);
-    if (version) {
-      result = { found: true, path: config.binary, version };
-      cachedResult = result;
-      cachedAt = Date.now();
-      return result;
-    }
-  }
-  const binaryPath = findInPath();
-  if (binaryPath) {
-    const version = probeVersion(binaryPath);
-    if (version) {
-      result = { found: true, path: binaryPath, version };
-      cachedResult = result;
-      cachedAt = Date.now();
-      return result;
-    }
-  }
-  result = { found: false };
-  cachedResult = result;
-  cachedAt = Date.now();
-  return result;
-}
-detectOpenClaw.resetCache = () => {
-  cachedResult = null;
-  cachedAt = 0;
-};
-function probeVersion(binaryPath) {
-  try {
-    const output = execFileSync2(binaryPath, ["--version"], {
-      timeout: 5e3,
-      encoding: "utf-8"
-    });
-    const match = output.toString().trim().match(/(\d+\.\d+\.\d+)/);
-    return match ? match[1] : output.toString().trim();
-  } catch {
-    return null;
-  }
-}
-function findInPath() {
-  const cmd = process.platform === "win32" ? "where" : "which";
-  try {
-    const output = execFileSync2(cmd, ["openclaw"], {
-      timeout: 5e3,
-      encoding: "utf-8"
-    });
-    return output.toString().trim().split("\n")[0] || null;
-  } catch {
-    return null;
-  }
-}
-async function installOpenClaw(opts) {
-  try {
-    execSync("npm install -g openclaw", {
-      timeout: 12e4,
-      stdio: opts?.silent ? "pipe" : "inherit"
-    });
-  } catch (err) {
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-  detectOpenClaw.resetCache();
-  const detection = await detectOpenClaw();
-  if (!detection.found) {
-    return {
-      success: false,
-      error: "npm install succeeded but openclaw binary was not found in PATH"
-    };
-  }
-  return { success: true, detection };
-}
-function seedWorkspace(stateDir) {
-  const workspaceDir = path7.join(stateDir, "workspace");
-  fs9.mkdirSync(workspaceDir, { recursive: true });
-  const __dirname = path7.dirname(fileURLToPath(import.meta.url));
-  const assetsDir = path7.join(__dirname, "..", "assets", "agent-workspace");
-  if (!fs9.existsSync(assetsDir)) {
-    return;
-  }
-  copyDirRecursive(assetsDir, workspaceDir);
-}
-function initializeOpenClawProfile(binary, profile, workspaceDir) {
-  try {
-    execFileSync2(binary, [
-      "--profile",
-      profile,
-      "onboard",
-      "--non-interactive",
-      "--accept-risk",
-      "--mode",
-      "local",
-      "--workspace",
-      workspaceDir,
-      "--skip-channels",
-      "--skip-skills",
-      "--skip-health",
-      "--no-install-daemon"
-    ], { timeout: 3e4, stdio: "pipe" });
-  } catch (err) {
-    const stderr = err instanceof Error && "stderr" in err ? String(err.stderr) : "";
-    if (stderr.toLowerCase().includes("already")) return;
-    throw new CliError({
-      code: "AGENT_PROFILE_INIT_FAILED",
-      message: `Failed to initialize OpenClaw profile: ${stderr || (err instanceof Error ? err.message : String(err))}`,
-      displayMessage: `Failed to initialize OpenClaw profile "${profile}".`
-    });
-  }
-}
-function configureOpenClawGateway(binary, profile, gatewayPort) {
-  const entries = [
-    ["gateway.mode", "local", false],
-    ["gateway.port", String(gatewayPort), true]
-  ];
-  for (const [key, value, strict] of entries) {
-    try {
-      const args = ["--profile", profile, "config", "set", key, value];
-      if (strict) args.push("--strict-json");
-      execFileSync2(binary, args, { timeout: 1e4, stdio: "pipe" });
-    } catch (err) {
-      throw new CliError({
-        code: "AGENT_GATEWAY_CONFIG_FAILED",
-        message: `Failed to set ${key}=${value}: ${err instanceof Error ? err.message : String(err)}`,
-        displayMessage: `Failed to configure OpenClaw gateway (${key}).`
-      });
-    }
-  }
-}
-function setOpenClawModel(binary, profile, model) {
-  try {
-    execFileSync2(binary, [
-      "--profile",
-      profile,
-      "models",
-      "set",
-      model
-    ], { timeout: 1e4, stdio: "pipe" });
-  } catch (err) {
-    throw new CliError({
-      code: "AGENT_MODEL_SET_FAILED",
-      message: `Failed to set agent model to ${model}: ${err instanceof Error ? err.message : String(err)}`,
-      displayMessage: `Failed to set agent model to "${model}".`
-    });
-  }
-}
-function providerEnvVar(provider) {
-  const map = {
-    anthropic: "ANTHROPIC_API_KEY",
-    openai: "OPENAI_API_KEY",
-    google: "GOOGLE_API_KEY",
-    "google-vertex": "GOOGLE_API_KEY",
-    groq: "GROQ_API_KEY",
-    mistral: "MISTRAL_API_KEY",
-    xai: "XAI_API_KEY",
-    openrouter: "OPENROUTER_API_KEY",
-    cerebras: "CEREBRAS_API_KEY"
-  };
-  return map[provider] ?? `${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
-}
-function writeAgentEnv(stateDir, key, value) {
-  const envFile = path7.join(stateDir, ".env");
-  let lines = [];
-  if (fs9.existsSync(envFile)) {
-    lines = fs9.readFileSync(envFile, "utf-8").split("\n");
-  }
-  const prefix = `${key}=`;
-  const idx = lines.findIndex((l) => l.startsWith(prefix));
-  const entry = `${key}=${value}`;
-  if (idx >= 0) {
-    lines[idx] = entry;
-  } else {
-    lines.push(entry);
-  }
-  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
-  fs9.writeFileSync(envFile, lines.join("\n") + "\n", "utf-8");
-}
-function resolveAgentCredentials(opts) {
-  const provider = opts.agentProvider ?? "anthropic";
-  if (opts.agentKey) {
-    return { provider, key: opts.agentKey, model: opts.agentModel };
-  }
-  const envVar = providerEnvVar(provider);
-  const envKey = process.env[envVar];
-  if (envKey) {
-    return { provider, key: envKey, model: opts.agentModel };
-  }
-  const genericKey = process.env.CANONRY_AGENT_KEY;
-  if (genericKey) {
-    return { provider, key: genericKey, model: opts.agentModel };
-  }
-  const envFile = path7.join(opts.stateDir, ".env");
-  if (fs9.existsSync(envFile)) {
-    const hasKey = fs9.readFileSync(envFile, "utf-8").split("\n").some((l) => l.includes("_API_KEY="));
-    if (hasKey) {
-      return { provider, key: void 0, model: opts.agentModel };
-    }
-  }
-  return { provider, key: void 0, model: opts.agentModel };
-}
-function copyDirRecursive(src, dest) {
-  fs9.mkdirSync(dest, { recursive: true });
-  for (const entry of fs9.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path7.join(src, entry.name);
-    const destPath = path7.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs9.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-// src/commands/agent.ts
 function resolveStateDir(opts) {
   if (opts?.stateDir) return opts.stateDir;
   try {
@@ -8266,7 +7778,7 @@ async function agentSetup(opts) {
       autoStart: existingConfig.autoStart
     }
   });
-  initializeOpenClawProfile(detection.path, profile, path8.join(stateDir, "workspace"));
+  initializeOpenClawProfile(detection.path, profile, path6.join(stateDir, "workspace"));
   configureOpenClawGateway(detection.path, profile, gatewayPort);
   const creds = agentLLM ?? resolveAgentCredentials({
     agentProvider: opts?.agentProvider,
@@ -8287,6 +7799,7 @@ async function agentSetup(opts) {
     }
   }
   seedWorkspace(stateDir);
+  const attachSummary = await attachAgentWebhookToAllProjects(gatewayPort);
   if (opts?.format === "json") {
     console.log(JSON.stringify({
       state: "configured",
@@ -8294,19 +7807,120 @@ async function agentSetup(opts) {
       version: detection.version,
       profile,
       gatewayPort,
-      stateDir
+      stateDir,
+      attached: attachSummary
     }, null, 2));
   } else {
     console.log(`OpenClaw: ${detection.path} (${detection.version})`);
     console.log(`Profile: ${profile}`);
     console.log(`Gateway port: ${gatewayPort}`);
     console.log(`State dir: ${stateDir}`);
+    if (attachSummary.attached > 0 || attachSummary.alreadyAttached > 0) {
+      console.log(
+        `Agent webhook: ${attachSummary.attached} attached, ${attachSummary.alreadyAttached} already present (via ${attachSummary.path})`
+      );
+    }
     console.log("Agent setup complete.");
   }
 }
+async function attachAgentWebhookToAllProjects(gatewayPort) {
+  let config;
+  try {
+    config = loadConfig();
+  } catch {
+    return { path: "skipped", attached: 0, alreadyAttached: 0 };
+  }
+  try {
+    const client = createApiClient();
+    const projectList = await client.listProjects();
+    const agentUrl = buildAgentWebhookUrl(gatewayPort);
+    let attached2 = 0;
+    let alreadyAttached2 = 0;
+    for (const project of projectList) {
+      const existing = await client.listNotifications(project.name);
+      if (existing.some((n) => n.source === "agent")) {
+        alreadyAttached2++;
+        continue;
+      }
+      await client.createNotification(project.name, {
+        channel: "webhook",
+        url: agentUrl,
+        events: [...AGENT_WEBHOOK_EVENTS],
+        source: "agent"
+      });
+      attached2++;
+    }
+    return { path: "api", attached: attached2, alreadyAttached: alreadyAttached2 };
+  } catch (err) {
+    if (!isConnectionError(err)) throw err;
+  }
+  const db = createClient(config.database);
+  migrate(db);
+  const rows = db.select({ id: projects.id }).from(projects).all();
+  let attached = 0;
+  let alreadyAttached = 0;
+  for (const row of rows) {
+    const result = attachAgentWebhookDirect(db, row.id, gatewayPort);
+    if (result === "attached") attached++;
+    else alreadyAttached++;
+  }
+  return { path: "db", attached, alreadyAttached };
+}
+function isConnectionError(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  const code = err.code ?? "";
+  return code === "CONNECTION_ERROR" || code === "ECONNREFUSED" || code === "ENOTFOUND" || msg.includes("could not connect") || msg.includes("econnrefused") || msg.includes("fetch failed") || msg.includes("connection refused");
+}
+async function agentAttach(opts) {
+  const config = loadConfig();
+  const gatewayPort = config.agent?.gatewayPort ?? 3579;
+  const agentUrl = buildAgentWebhookUrl(gatewayPort);
+  const client = createApiClient();
+  const existing = await client.listNotifications(opts.project);
+  const hasAgent = existing.some((n) => n.source === "agent");
+  if (hasAgent) {
+    if (opts.format === "json") {
+      console.log(JSON.stringify({ status: "already-attached", project: opts.project }));
+    } else {
+      console.log(`Agent webhook already attached to "${opts.project}"`);
+    }
+    return;
+  }
+  const result = await client.createNotification(opts.project, {
+    channel: "webhook",
+    url: agentUrl,
+    events: [...AGENT_WEBHOOK_EVENTS],
+    source: "agent"
+  });
+  if (opts.format === "json") {
+    console.log(JSON.stringify({ status: "attached", project: opts.project, notificationId: result.id }));
+  } else {
+    console.log(`Agent webhook attached to "${opts.project}"`);
+  }
+}
+async function agentDetach(opts) {
+  const client = createApiClient();
+  const existing = await client.listNotifications(opts.project);
+  const agentNotif = existing.find((n) => n.source === "agent");
+  if (!agentNotif) {
+    if (opts.format === "json") {
+      console.log(JSON.stringify({ status: "not-attached", project: opts.project }));
+    } else {
+      console.log(`No agent webhook found on "${opts.project}"`);
+    }
+    return;
+  }
+  await client.deleteNotification(opts.project, agentNotif.id);
+  if (opts.format === "json") {
+    console.log(JSON.stringify({ status: "detached", project: opts.project }));
+  } else {
+    console.log(`Agent webhook detached from "${opts.project}"`);
+  }
+}
 async function autoInstallOrFail(format) {
   if (format !== "json") {
-    console.log("OpenClaw not found, installing via npm...");
+    console.log("OpenClaw not found, installing pinned openclaw@2026.4.14 via npm...");
   }
   const install = await installOpenClaw({ silent: format === "json" });
   if (!install.success) {
@@ -8369,6 +7983,34 @@ var AGENT_CLI_COMMANDS = [
       await agentReset({ format: input.format });
     }
   },
+  {
+    path: ["agent", "attach"],
+    usage: "canonry agent attach <project> [--format json]",
+    options: {},
+    run: async (input) => {
+      const project = input.positionals[0];
+      if (!project) {
+        console.error("Usage: canonry agent attach <project>");
+        process.exitCode = 1;
+        return;
+      }
+      await agentAttach({ project, format: input.format });
+    }
+  },
+  {
+    path: ["agent", "detach"],
+    usage: "canonry agent detach <project> [--format json]",
+    options: {},
+    run: async (input) => {
+      const project = input.positionals[0];
+      if (!project) {
+        console.error("Usage: canonry agent detach <project>");
+        process.exitCode = 1;
+        return;
+      }
+      await agentDetach({ project, format: input.format });
+    }
+  },
   {
     path: ["agent", "setup"],
     usage: "canonry agent setup [--agent-provider <id>] [--agent-key <key>] [--agent-model <model>] [--gateway-port <port>] [--gemini-key <key>] [--openai-key <key>] [--claude-key <key>] [--perplexity-key <key>] [--format json]",