cueclaw 0.1.2 → 0.1.3

package/dist/{chunk-G43R5ASK.js → chunk-JJUF2AJ5.js}

@@ -1,6 +1,6 @@
 import {
   cueclawHome
-} from "./chunk-RSKXBXSJ.js";
+} from "./chunk-25KI643G.js";
 
 // src/db.ts
 import Database from "better-sqlite3";
@@ -113,6 +113,24 @@ function insertWorkflow(db, workflow) {
     workflow.updated_at
   );
 }
+function upsertWorkflow(db, workflow) {
+  db.prepare(`
+    INSERT OR REPLACE INTO workflows (id, name, description, trigger_json, steps_json, failure_policy_json, phase, schema_version, metadata_json, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    workflow.id,
+    workflow.name,
+    workflow.description,
+    JSON.stringify(workflow.trigger),
+    JSON.stringify(workflow.steps),
+    JSON.stringify(workflow.failure_policy),
+    workflow.phase,
+    workflow.schema_version,
+    workflow.metadata ? JSON.stringify(workflow.metadata) : null,
+    workflow.created_at,
+    workflow.updated_at
+  );
+}
 function getWorkflow(db, id) {
   const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
   return row ? rowToWorkflow(row) : void 0;
@@ -171,6 +189,7 @@ function getWorkflowRunsByWorkflowId(db, workflowId) {
 export {
   initDb,
   insertWorkflow,
+  upsertWorkflow,
   getWorkflow,
   listWorkflows,
   updateWorkflowPhase,

package/dist/chunk-KBLMQZ3P.js

@@ -0,0 +1,116 @@
+// src/logger.ts
+import pino from "pino";
+import { PassThrough } from "stream";
+import { createWriteStream, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var listeners = /* @__PURE__ */ new Set();
+var tuiStream = new PassThrough();
+tuiStream.on("data", (chunk) => {
+  for (const raw of chunk.toString().split("\n")) {
+    if (!raw.trim()) continue;
+    try {
+      const obj = JSON.parse(raw);
+      const lvl = (pino.levels.labels[obj.level] ?? "INFO").toUpperCase();
+      const mod = obj.module ? ` [${obj.module}]` : "";
+      const msg = obj.msg ?? "";
+      for (const fn of listeners) fn(`${lvl}${mod} ${msg}`);
+    } catch {
+      for (const fn of listeners) fn(raw);
+    }
+  }
+});
+var fileStream = null;
+var logDir = null;
+var configuredLevel = null;
+function resolveDir(dir) {
+  return dir.startsWith("~") ? join(homedir(), dir.slice(1)) : dir;
+}
+function getLevel() {
+  return configuredLevel ?? process.env["LOG_LEVEL"] ?? "info";
+}
+var logger = pino({
+  level: process.env["LOG_LEVEL"] ?? "info",
+  transport: process.env["NODE_ENV"] === "production" ? void 0 : { target: "pino-pretty", options: { colorize: true } }
+});
+function initLogger(opts) {
+  const level = opts.level ?? process.env["LOG_LEVEL"] ?? "info";
+  configuredLevel = level;
+  if (opts.dir) {
+    const resolved = resolveDir(opts.dir);
+    logDir = resolved;
+    mkdirSync(join(resolved, "executions"), { recursive: true });
+    fileStream = createWriteStream(join(resolved, "daemon.log"), { flags: "a" });
+    logger = pino(
+      { level },
+      pino.multistream([
+        { stream: process.stdout },
+        { stream: fileStream }
+      ])
+    );
+  } else {
+    logger = pino({
+      level,
+      transport: process.env["NODE_ENV"] === "production" ? void 0 : { target: "pino-pretty", options: { colorize: true } }
+    });
+  }
+}
+function enableTuiLogging() {
+  if (fileStream) {
+    logger = pino(
+      { level: getLevel() },
+      pino.multistream([
+        { stream: tuiStream },
+        { stream: fileStream }
+      ])
+    );
+  } else {
+    logger = pino({ level: getLevel() }, tuiStream);
+  }
+}
+function onLogLine(fn) {
+  listeners.add(fn);
+  return () => {
+    listeners.delete(fn);
+  };
+}
+function createChildLogger(bindings) {
+  return logger.child(bindings);
+}
+function createExecutionLogger(workflowId, runId) {
+  if (!logDir) {
+    return logger.child({ workflowId, runId });
+  }
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const filename = `${workflowId}_${date}.log`;
+  const execStream = createWriteStream(join(logDir, "executions", filename), { flags: "a" });
+  return pino(
+    { level: getLevel() },
+    pino.multistream([
+      { stream: execStream },
+      ...fileStream ? [{ stream: fileStream }] : []
+    ])
+  );
+}
+function resetLogger() {
+  if (fileStream) {
+    fileStream.end();
+    fileStream = null;
+  }
+  logDir = null;
+  configuredLevel = null;
+  logger = pino({
+    level: process.env["LOG_LEVEL"] ?? "info",
+    transport: process.env["NODE_ENV"] === "production" ? void 0 : { target: "pino-pretty", options: { colorize: true } }
+  });
+}
+
+export {
+  logger,
+  initLogger,
+  enableTuiLogging,
+  onLogLine,
+  createChildLogger,
+  createExecutionLogger,
+  resetLogger
+};

package/dist/{chunk-SEYPA5M2.js → chunk-X3WNTN5V.js}

@@ -4,18 +4,23 @@ import {
   updateStepRunStatus,
   updateWorkflowPhase,
   updateWorkflowRunStatus
-} from "./chunk-G43R5ASK.js";
+} from "./chunk-JJUF2AJ5.js";
 import {
   cueclawHome,
+  getDefaultImage,
   loadConfig
-} from "./chunk-RSKXBXSJ.js";
+} from "./chunk-25KI643G.js";
 import {
   ConfigError,
   ExecutorError
 } from "./chunk-BVQG3WYO.js";
 import {
+  isDev
+} from "./chunk-ZCK3IFLC.js";
+import {
+  createExecutionLogger,
   logger
-} from "./chunk-QBOYMF4A.js";
+} from "./chunk-KBLMQZ3P.js";
 
 // src/executor.ts
 import { nanoid as nanoid3 } from "nanoid";
@@ -239,7 +244,7 @@ async function runContainerAgent(opts) {
   mkdirSync2(opts.workDir, { recursive: true });
   mkdirSync2(join3(opts.ipcDir, "input"), { recursive: true });
   mkdirSync2(join3(opts.ipcDir, "output"), { recursive: true });
-  const image = config.container?.image ?? "cueclaw-agent:latest";
+  const image = config.container?.image ?? getDefaultImage();
   const network = config.container?.network ?? "none";
   const volumeMounts = buildVolumeMounts(opts);
   const dockerArgs = [
@@ -292,7 +297,8 @@ function buildVolumeMounts(opts) {
   return mounts;
 }
 async function spawnContainer(dockerArgs, opts, config) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
+    logger.info({ containerName: opts.containerName, image: dockerArgs[dockerArgs.length - 1] }, "Starting container");
     const proc = spawn("docker", dockerArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -348,8 +354,9 @@ async function spawnContainer(dockerArgs, opts, config) {
     proc.on("close", (code) => {
       clearTimeout(hardTimer);
       clearInterval(idleCheck);
+      logger.info({ containerName: opts.containerName, exitCode: code }, "Container exited");
       if (truncated) {
-        resolve({ status: "failed", error: "Container output size cap exceeded" });
+        resolve2({ status: "failed", error: "Container output size cap exceeded" });
         return;
       }
       const startIdx = stdout.indexOf(OUTPUT_START_MARKER);
@@ -358,7 +365,7 @@ async function spawnContainer(dockerArgs, opts, config) {
         resultBuffer = stdout.slice(startIdx + OUTPUT_START_MARKER.length + 1, endIdx).trim();
       }
       if (code !== 0 && !resultBuffer) {
-        resolve({
+        resolve2({
           status: "failed",
           error: stderr || `Container exited with code ${code}`
         });
@@ -366,16 +373,16 @@ async function spawnContainer(dockerArgs, opts, config) {
       }
       try {
         const parsed = JSON.parse(resultBuffer);
-        resolve({
+        resolve2({
           status: "succeeded",
           output: parsed.result ?? null,
           sessionId: parsed.sessionId
         });
       } catch {
         if (resultBuffer) {
-          resolve({ status: "succeeded", output: resultBuffer });
+          resolve2({ status: "succeeded", output: resultBuffer });
         } else {
-          resolve({
+          resolve2({
             status: "failed",
             error: stderr || "No output captured from container"
           });
@@ -385,7 +392,8 @@ async function spawnContainer(dockerArgs, opts, config) {
     proc.on("error", (err) => {
       clearTimeout(hardTimer);
       clearInterval(idleCheck);
-      resolve({
+      logger.error({ containerName: opts.containerName, err }, "Docker spawn error");
+      resolve2({
         status: "failed",
         error: `Docker spawn error: ${err.message}`
       });
@@ -393,6 +401,7 @@ async function spawnContainer(dockerArgs, opts, config) {
   });
 }
 function gracefulStop(containerName) {
+  logger.debug({ containerName }, "Gracefully stopping container");
   try {
     spawn("docker", ["stop", containerName]);
   } catch {
@@ -418,35 +427,113 @@ function prepareContainerOpts(workflowId, stepId, runId, prompt, cwd, allowedToo
   };
 }
 
+// src/container-runtime.ts
+import { execFileSync } from "child_process";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync3 } from "fs";
+var cached;
+var imageCache = /* @__PURE__ */ new Map();
+function isDockerAvailable() {
+  if (cached !== void 0) return cached;
+  try {
+    execFileSync("docker", ["info"], { encoding: "utf-8", stdio: "pipe" });
+    cached = true;
+  } catch {
+    cached = false;
+  }
+  return cached;
+}
+function isDockerImageAvailable(image) {
+  const hit = imageCache.get(image);
+  if (hit !== void 0) return hit;
+  try {
+    execFileSync("docker", ["image", "inspect", image], { encoding: "utf-8", stdio: "pipe" });
+    imageCache.set(image, true);
+    return true;
+  } catch {
+    imageCache.set(image, false);
+    return false;
+  }
+}
+function ensureDockerImage(image) {
+  if (isDockerImageAvailable(image)) return true;
+  if (isDev) {
+    return buildDevImage(image);
+  }
+  logger.info({ image }, "Docker image not found locally, attempting pull");
+  try {
+    execFileSync("docker", ["pull", image], { encoding: "utf-8", stdio: "pipe", timeout: 3e5 });
+    imageCache.set(image, true);
+    logger.info({ image }, "Docker image pulled successfully");
+    return true;
+  } catch (err) {
+    logger.warn({ image, err }, "Failed to pull Docker image");
+    return false;
+  }
+}
+function buildDevImage(image) {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const projectRoot = resolve(thisDir, "..");
+  const buildScript = resolve(projectRoot, "container", "build.sh");
+  if (!existsSync3(buildScript)) {
+    logger.warn({ buildScript }, "container/build.sh not found, cannot auto-build");
+    return false;
+  }
+  logger.info({ image }, "Dev mode: auto-building container image via container/build.sh");
+  try {
+    execFileSync("bash", [buildScript], {
+      encoding: "utf-8",
+      stdio: "inherit",
+      cwd: resolve(projectRoot, "container")
+    });
+    imageCache.set(image, true);
+    logger.info({ image }, "Dev mode: container image built successfully");
+    return true;
+  } catch (err) {
+    logger.warn({ image, err }, "Dev mode: container image build failed");
+    return false;
+  }
+}
+
 // src/agent-runner.ts
 function runAgent(opts) {
   const config = loadConfig();
-  if (config.container?.enabled && opts.workflowId && opts.stepId && opts.runId) {
-    const containerOpts = prepareContainerOpts(
-      opts.workflowId,
-      opts.stepId,
-      opts.runId,
-      opts.prompt,
-      opts.cwd,
-      opts.allowedTools
-    );
-    const resultPromise2 = runContainerAgent({
-      ...containerOpts,
-      signal: opts.signal,
-      onProgress: opts.onProgress
-    });
-    return {
-      resultPromise: resultPromise2,
-      abort: () => {
-        try {
-          import("child_process").then(({ spawn: spawn2 }) => {
-            spawn2("docker", ["stop", containerOpts.containerName]);
-          });
-        } catch {
+  const containerEnabled = config.container?.enabled ?? false;
+  if (containerEnabled && opts.workflowId && opts.stepId && opts.runId) {
+    if (!isDockerAvailable()) {
+      logger.warn({ stepId: opts.stepId }, "Docker not available, falling back to local execution");
+    } else if (!ensureDockerImage(config.container?.image ?? getDefaultImage())) {
+      logger.warn({ stepId: opts.stepId, image: config.container?.image ?? getDefaultImage() }, "Docker image not available (pull failed), falling back to local execution");
+    } else {
+      logger.info({ stepId: opts.stepId, mode: "container" }, "Running agent in container mode");
+      const containerOpts = prepareContainerOpts(
+        opts.workflowId,
+        opts.stepId,
+        opts.runId,
+        opts.prompt,
+        opts.cwd,
+        opts.allowedTools
+      );
+      const resultPromise2 = runContainerAgent({
+        ...containerOpts,
+        signal: opts.signal,
+        onProgress: opts.onProgress
+      });
+      return {
+        resultPromise: resultPromise2,
+        abort: () => {
+          try {
+            import("child_process").then(({ spawn: spawn2 }) => {
+              spawn2("docker", ["stop", containerOpts.containerName]);
+            });
+          } catch {
+          }
         }
-      }
-    };
+      };
+    }
   }
+  logger.info({ stepId: opts.stepId, mode: "local" }, "Running agent in local mode");
   let aborted = false;
   const resultPromise = (async () => {
     const authToken = config.claude.executor.api_key ?? config.claude.api_key;
@@ -511,6 +598,7 @@ function runAgent(opts) {
         }
         opts.onProgress?.(message);
       }
+      logger.debug({ stepId: opts.stepId, status: "succeeded" }, "Agent completed");
       return { status: "succeeded", output: result, sessionId };
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
@@ -547,13 +635,16 @@ function createSession(db, stepRunId, sdkSessionId) {
     INSERT INTO sessions (id, step_run_id, sdk_session_id, created_at, last_used_at, is_active)
     VALUES (?, ?, ?, ?, ?, ?)
   `).run(session.id, session.step_run_id, session.sdk_session_id ?? null, session.created_at, session.last_used_at, 1);
+  logger.debug({ sessionId: session.id, stepRunId }, "Session created");
   return session;
 }
 function deactivateSession(db, sessionId) {
   db.prepare("UPDATE sessions SET is_active = 0, last_used_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), sessionId);
+  logger.debug({ sessionId }, "Session deactivated");
 }
 function updateSessionSdkId(db, sessionId, sdkSessionId) {
   db.prepare("UPDATE sessions SET sdk_session_id = ?, last_used_at = ? WHERE id = ?").run(sdkSessionId, (/* @__PURE__ */ new Date()).toISOString(), sessionId);
+  logger.debug({ sessionId, sdkSessionId }, "Session SDK ID updated");
 }
 
 // src/executor.ts
@@ -599,7 +690,7 @@ function hasSkipMarker(inputs) {
   }
   return false;
 }
-async function executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress) {
+async function executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress, execLogger) {
   const stepRunId = `sr_${nanoid3()}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const stepRun = {
@@ -610,6 +701,7 @@ async function executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress)
     started_at: now
   };
   insertStepRun(db, stepRun);
+  execLogger?.info({ stepId: step.id, stepRunId, attempt: "start" }, `Step started: ${step.id}`);
   const inputContext = Object.keys(resolvedInputs).length > 0 ? `
 
 Inputs:
@@ -628,15 +720,21 @@ ${JSON.stringify(resolvedInputs, null, 2)}` : "";
     const session = createSession(db, stepRunId, result.sessionId);
     updateSessionSdkId(db, session.id, result.sessionId);
     deactivateSession(db, session.id);
+    execLogger?.debug({ stepId: step.id, sessionId: session.id }, "Session stored");
   }
   updateStepRunStatus(db, stepRunId, result.status, result.output ?? void 0, result.error);
+  if (result.status === "failed") {
+    execLogger?.error({ stepId: step.id, stepRunId, error: result.error }, `Step failed: ${step.id}`);
+  } else {
+    execLogger?.info({ stepId: step.id, stepRunId, status: result.status }, `Step completed: ${step.id}`);
+  }
   return result;
 }
-async function executeStepWithRetry(step, resolvedInputs, runId, db, cwd, policy, onProgress) {
+async function executeStepWithRetry(step, resolvedInputs, runId, db, cwd, policy, onProgress, execLogger) {
   const maxRetries = policy.max_retries ?? 0;
   let delay = policy.retry_delay_ms ?? 5e3;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const result = await executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress);
+    const result = await executeStepOnce(step, resolvedInputs, runId, db, cwd, onProgress, execLogger);
     if (result.status !== "failed" || attempt === maxRetries) return result;
     logger.info({ stepId: step.id, attempt, delay }, "Retrying step");
     await new Promise((r) => setTimeout(r, delay));
@@ -656,6 +754,8 @@ async function executeWorkflow(opts) {
   };
   insertWorkflowRun(db, run);
   updateWorkflowPhase(db, workflow.id, "executing");
+  const execLogger = createExecutionLogger(workflow.id, runId);
+  execLogger.info({ workflowId: workflow.id, runId, steps: workflow.steps.length }, "Workflow execution started");
   const completed = /* @__PURE__ */ new Map();
   const remaining = new Set(workflow.steps.map((s) => s.id));
   const stepMap = new Map(workflow.steps.map((s) => [s.id, s]));
@@ -663,6 +763,7 @@ async function executeWorkflow(opts) {
   try {
     while (remaining.size > 0) {
       if (signal?.aborted) {
+        execLogger.warn({ workflowId: workflow.id, runId, remainingSteps: remaining.size }, "Execution aborted via signal");
         for (const id of remaining) {
           completed.set(id, { status: "skipped", error: "Aborted" });
           onProgress?.(id, { status: "skipped" });
@@ -676,6 +777,7 @@ async function executeWorkflow(opts) {
         return step.depends_on.every((dep) => completed.has(dep));
       });
       if (ready.length === 0) {
+        execLogger.error({ workflowId: workflow.id, runId, remaining: [...remaining] }, "Deadlock detected");
         throw new ExecutorError("Deadlock: no ready steps but remaining steps exist");
       }
       const executable = [];
@@ -685,6 +787,7 @@ async function executeWorkflow(opts) {
           (dep) => completed.get(dep)?.status === "failed" || completed.get(dep)?.status === "skipped"
         );
         if (depsFailed && workflow.failure_policy.on_step_failure !== "ask_user") {
+          execLogger.debug({ stepId: id, reason: "dependency_failed" }, "Step skipped");
           remaining.delete(id);
           completed.set(id, { status: "skipped" });
           const skipRunId = `sr_${nanoid3()}`;
@@ -693,6 +796,7 @@ async function executeWorkflow(opts) {
         }
         const resolvedInputs = resolveInputs(step.inputs, completed, triggerData);
         if (hasSkipMarker(resolvedInputs)) {
+          execLogger.debug({ stepId: id, reason: "skip_marker" }, "Step skipped");
           remaining.delete(id);
           completed.set(id, { status: "skipped" });
           const skipRunId = `sr_${nanoid3()}`;
@@ -713,7 +817,8 @@ async function executeWorkflow(opts) {
             db,
             cwd,
             workflow.failure_policy,
-            onProgress
+            onProgress,
+            execLogger
           );
           return { stepId: step.id, result };
         })
@@ -723,6 +828,7 @@ async function executeWorkflow(opts) {
         if (result.status === "failed") {
           const policy = workflow.failure_policy.on_step_failure;
           if (policy === "stop") {
+            execLogger.warn({ stepId, policy: "stop" }, "Stop policy triggered, skipping remaining steps");
             for (const remainingId of remaining) {
               completed.set(remainingId, { status: "skipped" });
               const skipRunId = `sr_${nanoid3()}`;
@@ -734,6 +840,7 @@ async function executeWorkflow(opts) {
           }
           if (policy === "ask_user" && onStepFailure) {
             const decision = await onStepFailure(stepMap.get(stepId), result.error ?? "Unknown error");
+            execLogger.info({ stepId, decision }, "ask_user decision received");
             if (decision === "stop") {
               for (const remainingId of remaining) {
                 completed.set(remainingId, { status: "skipped" });
@@ -759,6 +866,7 @@ async function executeWorkflow(opts) {
   } else {
     updateWorkflowPhase(db, workflow.id, "active");
   }
+  execLogger.info({ workflowId: workflow.id, runId, status: finalStatus }, "Workflow execution finished");
   return { runId, status: finalStatus, results: completed };
 }
 

package/dist/{chunk-WE5J7GMR.js → chunk-ZOFGQYXX.js}

@@ -1,15 +1,15 @@
 import {
   createAnthropicClient
 } from "./chunk-DVQFSFIZ.js";
-import {
-  getConfiguredSecretKeys
-} from "./chunk-ZCK3IFLC.js";
 import {
   PlannerError
 } from "./chunk-BVQG3WYO.js";
+import {
+  getConfiguredSecretKeys
+} from "./chunk-ZCK3IFLC.js";
 import {
   logger
-} from "./chunk-QBOYMF4A.js";
+} from "./chunk-KBLMQZ3P.js";
 
 // src/planner.ts
 import { z } from "zod/v4";
@@ -236,9 +236,26 @@ function parsePlannerToolResponse(response) {
   }
   return { type: "error", error: "Unexpected planner response format" };
 }
-function buildPlannerSystemPrompt(config) {
+function buildPlannerSystemPrompt(config, channelContext) {
   const identity = config.identity?.name ? `
 User identity: ${config.identity.name}` : "";
+  let channelSection;
+  if (channelContext && channelContext.channel !== "tui") {
+    channelSection = `
+## Channel Context
+
+The user is requesting this workflow via **${channelContext.channel}**.
+- Chat ID: ${channelContext.chatJid}
+- Sender: ${channelContext.sender}
+
+When the workflow needs to send notifications or messages back to the user, use the chat ID and channel above as the recipient. Do not ask the user for recipient information \u2014 you already have it.`;
+  } else {
+    channelSection = `
+## Channel Context
+
+The user is using the TUI (terminal interface). No chat recipient is available.
+If the workflow needs to send notifications or messages to someone, the step description must require explicit recipient input (e.g., email address, phone number, chat ID) \u2014 do not assume any default recipient.`;
+  }
   return `You are CueClaw Planner. Convert user's natural language into a structured Workflow.
 
 ## Execution Environment
@@ -276,9 +293,9 @@ You can reference these in workflow steps \u2014 they are available as environme
 If a workflow needs credentials not listed above, use the set_secret tool to store them after the user provides the value. Never invent or guess secret values.
 
 ## User Identity
-${identity}`;
+${identity}${channelSection}`;
 }
-async function generatePlan(userDescription, config) {
+async function generatePlan(userDescription, config, channelContext) {
   const anthropic = createAnthropicClient(config);
   const MAX_RETRIES = 2;
   let retryContext = "";
@@ -292,13 +309,14 @@ ${retryContext}` : userDescription;
       response = await anthropic.messages.create({
         model: config.claude.planner.model,
         max_tokens: 4096,
-        system: buildPlannerSystemPrompt(config),
+        system: buildPlannerSystemPrompt(config, channelContext),
         messages: [{ role: "user", content: prompt }],
         tools: [plannerTool],
         tool_choice: { type: "tool", name: "create_workflow" }
       });
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
+      logger.error({ err, attempt }, "Planner API request failed");
       throw new PlannerError(
         `API request failed: ${detail}. Check your API key and base_url in ~/.cueclaw/config.yaml`
       );
@@ -322,6 +340,7 @@ ${retryContext}` : userDescription;
     if (!parseResult.success) {
       const errMsg = parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
       if (attempt < MAX_RETRIES) {
+        logger.warn({ attempt, errors: errMsg }, "Planner output validation failed, retrying");
         retryContext = `[System] Previous plan had validation issues:
 ${errMsg}
 Please fix and try again.`;
@@ -332,6 +351,7 @@ Please fix and try again.`;
     const dagErrors = validateDAG(parseResult.data.steps);
     if (dagErrors.length > 0) {
       if (attempt < MAX_RETRIES) {
+        logger.warn({ attempt, dagErrors }, "DAG validation failed, retrying");
         retryContext = `[System] DAG dependency issues:
 ${dagErrors.join("\n")}
 Please fix the step dependencies.`;
@@ -340,7 +360,7 @@ Please fix the step dependencies.`;
       throw new PlannerError(`DAG validation failed after ${MAX_RETRIES + 1} attempts: ${dagErrors.join(", ")}`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    return {
+    const workflow = {
       ...parseResult.data,
       schema_version: "1.0",
       id: `wf_${nanoid()}`,
@@ -348,10 +368,12 @@ Please fix the step dependencies.`;
       created_at: now,
       updated_at: now
     };
+    logger.info({ name: workflow.name, stepCount: workflow.steps.length, workflowId: workflow.id }, "Plan generated successfully");
+    return workflow;
   }
   throw new PlannerError("Failed to generate valid plan after retries");
 }
-async function modifyPlan(originalWorkflow, modificationDescription, config) {
+async function modifyPlan(originalWorkflow, modificationDescription, config, channelContext) {
   const plannerOutput = {
     name: originalWorkflow.name,
     description: originalWorkflow.description,
@@ -369,7 +391,8 @@ ${modificationDescription}
 
 Preserve unmodified steps' IDs, descriptions, and dependencies \u2014 only change what the user specified.
 Return the complete modified workflow using the create_workflow tool.`;
-  const result = await generatePlan(combinedPrompt, config);
+  const result = await generatePlan(combinedPrompt, config, channelContext);
+  logger.info({ workflowId: originalWorkflow.id }, "Plan modified");
   return {
     ...result,
     id: originalWorkflow.id,
@@ -381,6 +404,7 @@ function confirmPlan(workflow) {
     throw new PlannerError(`Cannot confirm workflow in phase "${workflow.phase}"`);
   }
   const nextPhase = workflow.trigger.type === "manual" ? "executing" : "active";
+  logger.info({ workflowId: workflow.id, nextPhase }, "Plan confirmed");
   return {
     ...workflow,
     phase: nextPhase,
@@ -388,6 +412,7 @@ function confirmPlan(workflow) {
   };
 }
 function rejectPlan(workflow) {
+  logger.info({ workflowId: workflow.id }, "Plan rejected");
   return {
     ...workflow,
     phase: "planning",