@kody-ade/kody-engine-lite 0.1.7 → 0.1.9

package/README.md

@@ -112,7 +112,7 @@ git push
 Then comment on any issue:
 
 ```
-@kody full my-task-id
+@kody
 ```
 
 ## CLI Usage
@@ -121,19 +121,25 @@ Then comment on any issue:
 
 ```bash
 # Run against current directory
-kody-engine-lite run --task-id my-task --task "Add a sum function to src/math.ts with tests"
+kody-engine-lite run --task "Add a sum function to src/math.ts with tests"
 
 # Run against a different project
-kody-engine-lite run --task-id my-task --task "Add feature X" --cwd /path/to/project
+kody-engine-lite run --task "Add feature X" --cwd /path/to/project
 
 # Run from a GitHub issue (fetches issue body as task)
-kody-engine-lite run --task-id my-task --issue-number 1 --cwd /path/to/project
+kody-engine-lite run --issue-number 1 --cwd /path/to/project
 
 # Dry run (no agent calls)
-kody-engine-lite run --task-id my-task --task "Test" --dry-run
+kody-engine-lite run --task "Test" --dry-run
 
-# Resume from a failed stage
-kody-engine-lite rerun --task-id my-task --from review
+# Resume from a failed/paused stage (auto-detects which stage)
+kody-engine-lite rerun --issue-number 1
+
+# Fix — rerun from build stage (skip taskify/plan)
+kody-engine-lite fix --issue-number 1
+
+# Fix with feedback
+kody-engine-lite fix --issue-number 1 --feedback "Use middleware pattern instead"
 
 # Check pipeline status
 kody-engine-lite status --task-id my-task
@@ -154,9 +160,11 @@ Comment on any issue:
 ```
 @kody                                     # Run full pipeline (auto-generates task-id)
 @kody full <task-id>                      # Run with specific task-id
-@kody rerun --from <stage>                # Resume latest task from stage
-@kody rerun <task-id> --from <stage>      # Resume specific task
-@kody approve                             # Approve + provide answers to Kody's questions
+@kody rerun                               # Resume latest task (auto-detects stage)
+@kody rerun --from <stage>                # Resume from specific stage
+@kody fix                                 # Re-build from build stage (skip taskify/plan)
+@kody fix --feedback "Use X instead of Y" # Fix with specific guidance
+@kody approve                             # Approve + provide answers to questions
 @kody status <task-id>                    # Check status
 ```
 
@@ -195,6 +203,15 @@ Kody resumes automatically from where it paused, with your answers injected as c
 | review-fix | sonnet | Applies known fixes from review findings |
 | ship | — | Pushes branch + creates PR + comments on issue |
 
+### Branch Syncing
+
+On every run/rerun/fix, Kody automatically:
+1. Checks out (or creates) the feature branch
+2. Pulls latest from the default branch and merges into the feature branch
+3. If there's a merge conflict, skips the sync and warns
+
+This ensures the feature branch is always up-to-date before building.
+
 ### Automatic Loops
 
 - **Verify + autofix**: If verify fails, runs lint-fix + format-fix + autofix agent, retries up to 2 times

package/dist/bin/cli.js

@@ -109,11 +109,17 @@ function createClaudeCodeRunner() {
 }
 function createOpenCodeRunner() {
   return {
-    async run(stageName, prompt, _model, timeout, _taskDir, options) {
+    async run(stageName, prompt, model, timeout, _taskDir, options) {
+      const args2 = ["run"];
+      if (model) {
+        args2.push("--model", model);
+      }
+      args2.push(prompt);
       return runSubprocess(
         "opencode",
-        ["github", "run", "--agent", stageName],
-        prompt,
+        args2,
+        "",
+        // opencode takes message as positional, not stdin
         timeout,
         options
       );
@@ -582,6 +588,27 @@ function ensureFeatureBranch(issueNumber, title, cwd) {
   logger.info(`  Created new branch: ${branchName}`);
   return branchName;
 }
+function syncWithDefault(cwd) {
+  const defaultBranch = getDefaultBranch(cwd);
+  const current = getCurrentBranch(cwd);
+  if (current === defaultBranch) return;
+  try {
+    git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
+  } catch {
+    logger.warn("  Failed to fetch latest from origin");
+    return;
+  }
+  try {
+    git(["merge", `origin/${defaultBranch}`, "--no-edit"], { cwd, timeout: 3e4 });
+    logger.info(`  Synced with origin/${defaultBranch}`);
+  } catch {
+    try {
+      git(["merge", "--abort"], { cwd });
+    } catch {
+    }
+    logger.warn(`  Merge conflict with origin/${defaultBranch} \u2014 skipping sync`);
+  }
+}
 function commitAll(message, cwd) {
   const status = git(["status", "--porcelain"], { cwd });
   if (!status) {
@@ -892,8 +919,9 @@ async function executeAgentStage(ctx, def) {
   }
   const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
   const model = resolveModel(def.modelTier, def.name);
-  logger.info(`  model=${model} timeout=${def.timeout / 1e3}s`);
   const config = getProjectConfig();
+  const runnerName = config.agent.stageRunners?.[def.name] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
+  logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1e3}s`);
   const extraEnv = {};
   if (config.agent.litellmUrl) {
     extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
@@ -1190,8 +1218,9 @@ async function runPipeline(ctx) {
       const taskMdPath = path4.join(ctx.taskDir, "task.md");
       const title = fs4.existsSync(taskMdPath) ? fs4.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
       ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
+      syncWithDefault(ctx.projectDir);
     } catch (err) {
-      logger.warn(`  Failed to create feature branch: ${err}`);
+      logger.warn(`  Failed to create/sync feature branch: ${err}`);
     }
   }
   let complexity = ctx.input.complexity ?? "high";
@@ -1621,12 +1650,13 @@ function parseArgs() {
     console.log(`Usage:
   kody run    --task-id <id> [--task "<desc>"] [--cwd <path>] [--issue-number <n>] [--complexity low|medium|high] [--feedback "<text>"] [--local] [--dry-run]
   kody rerun  --task-id <id> --from <stage> [--cwd <path>] [--issue-number <n>]
+  kody fix    --task-id <id> [--cwd <path>] [--issue-number <n>] [--feedback "<text>"]
   kody status --task-id <id> [--cwd <path>]
   kody --help`);
     process.exit(0);
   }
   const command2 = args2[0];
-  if (!["run", "rerun", "status"].includes(command2)) {
+  if (!["run", "rerun", "fix", "status"].includes(command2)) {
     console.error(`Unknown command: ${command2}`);
     process.exit(1);
   }
@@ -1671,7 +1701,7 @@ async function main() {
   }
   let taskId = input.taskId;
   if (!taskId) {
-    if (input.command === "rerun" && input.issueNumber) {
+    if ((input.command === "rerun" || input.command === "fix") && input.issueNumber) {
       const found = findLatestTaskForIssue(input.issueNumber, projectDir);
       if (!found) {
         console.error(`No previous task found for issue #${input.issueNumber}`);
@@ -1717,6 +1747,9 @@ ${issue.body ?? ""}`;
       process.exit(1);
     }
   }
+  if (input.command === "fix" && !input.fromStage) {
+    input.fromStage = "build";
+  }
   if (input.command === "rerun" && !input.fromStage) {
     const statusPath = path5.join(taskDir, "status.json");
     if (fs6.existsSync(statusPath)) {
@@ -1774,7 +1807,7 @@ ${issue.body ?? ""}`;
     projectDir,
     runners,
     input: {
-      mode: input.command === "rerun" ? "rerun" : "full",
+      mode: input.command === "rerun" || input.command === "fix" ? "rerun" : "full",
       fromStage: input.fromStage,
       dryRun: input.dryRun,
       issueNumber: input.issueNumber,
@@ -2004,6 +2037,270 @@ function detectArchitecture(cwd) {
   if (configs.length > 0) detected.push(`- Config files: ${configs.join(", ")}`);
   return detected;
 }
+function detectBasicConfig(cwd) {
+  let pm = "pnpm";
+  if (fs7.existsSync(path6.join(cwd, "yarn.lock"))) pm = "yarn";
+  else if (fs7.existsSync(path6.join(cwd, "bun.lockb"))) pm = "bun";
+  else if (!fs7.existsSync(path6.join(cwd, "pnpm-lock.yaml")) && fs7.existsSync(path6.join(cwd, "package-lock.json"))) pm = "npm";
+  let defaultBranch = "main";
+  try {
+    const ref = execFileSync7("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    defaultBranch = ref.replace("refs/remotes/origin/", "");
+  } catch {
+    try {
+      execFileSync7("git", ["rev-parse", "--verify", "origin/dev"], {
+        encoding: "utf-8",
+        timeout: 5e3,
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      defaultBranch = "dev";
+    } catch {
+    }
+  }
+  let owner = "";
+  let repo = "";
+  try {
+    const remote = execFileSync7("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = remote.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+    if (match) {
+      owner = match[1];
+      repo = match[2];
+    }
+  } catch {
+  }
+  const hasOpenCode = fs7.existsSync(path6.join(cwd, "opencode.json"));
+  return { defaultBranch, owner, repo, pm, hasOpenCode };
+}
+function smartInit(cwd) {
+  const basic = detectBasicConfig(cwd);
+  let context = "";
+  const readIfExists = (rel, maxChars = 3e3) => {
+    const p = path6.join(cwd, rel);
+    if (fs7.existsSync(p)) {
+      const content = fs7.readFileSync(p, "utf-8");
+      return content.slice(0, maxChars);
+    }
+    return null;
+  };
+  const pkgJson = readIfExists("package.json");
+  if (pkgJson) context += `## package.json
+${pkgJson}
+
+`;
+  const tsconfig = readIfExists("tsconfig.json", 1e3);
+  if (tsconfig) context += `## tsconfig.json
+${tsconfig}
+
+`;
+  const readme = readIfExists("README.md", 2e3);
+  if (readme) context += `## README.md (first 2000 chars)
+${readme}
+
+`;
+  const claudeMd = readIfExists("CLAUDE.md", 3e3);
+  if (claudeMd) context += `## CLAUDE.md
+${claudeMd}
+
+`;
+  try {
+    const topDirs = fs7.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    context += `## Top-level directories
+${topDirs.join(", ")}
+
+`;
+    const srcDir = path6.join(cwd, "src");
+    if (fs7.existsSync(srcDir)) {
+      const srcDirs = fs7.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      context += `## src/ subdirectories
+${srcDirs.join(", ")}
+
+`;
+    }
+  } catch {
+  }
+  const existingFiles = [];
+  for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "opencode.json", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
+    if (fs7.existsSync(path6.join(cwd, f))) existingFiles.push(f);
+  }
+  if (existingFiles.length) context += `## Config files present
+${existingFiles.join(", ")}
+
+`;
+  context += `## Detected: package manager=${basic.pm}, default branch=${basic.defaultBranch}, github=${basic.owner}/${basic.repo}, opencode=${basic.hasOpenCode}
+`;
+  const prompt = `You are analyzing a project to configure Kody (an autonomous SDLC pipeline).
+
+Given this project context, output ONLY a JSON object with EXACTLY this structure:
+
+{
+  "config": {
+    "quality": {
+      "typecheck": "${basic.pm} <script or command>",
+      "lint": "${basic.pm} <script or command>",
+      "lintFix": "${basic.pm} <script or command>",
+      "format": "${basic.pm} <script or command>",
+      "formatFix": "${basic.pm} <script or command>",
+      "testUnit": "${basic.pm} <script or command>"
+    },
+    "git": { "defaultBranch": "${basic.defaultBranch}" },
+    "github": { "owner": "${basic.owner}", "repo": "${basic.repo}" },
+    "paths": { "taskDir": ".tasks" },
+    "agent": {
+      "runner": "${basic.hasOpenCode ? "opencode" : "claude-code"}",
+      "defaultRunner": "${basic.hasOpenCode ? "opencode" : "claude"}",
+      "modelMap": { "cheap": "haiku", "mid": "sonnet", "strong": "opus" }
+    }
+  },
+  "architecture": "# Architecture\\n\\n<markdown content>",
+  "conventions": "# Conventions\\n\\n<markdown content>"
+}
+
+CRITICAL rules for config.quality:
+- Every command MUST start with "${basic.pm}" (e.g., "${basic.pm} typecheck", "${basic.pm} lint")
+- Look at the package.json "scripts" section to find the correct script names
+- testUnit must run ONLY unit tests \u2014 exclude integration and e2e tests. If there's a "test:unit" script use it. Otherwise use "test" but add exclude flags for int/e2e.
+- If a script doesn't exist and can't be inferred, set the value to ""
+- Do NOT invent commands that don't exist in package.json scripts
+
+Rules for architecture (markdown string):
+- Be specific about THIS project
+- Include: framework, language, database, testing, key directories, data flow
+- Reference CLAUDE.md and .ai-docs/ if they exist
+- Keep under 50 lines
+
+Rules for conventions (markdown string):
+- Extract actual patterns from the project
+- If CLAUDE.md exists, reference it
+- If .ai-docs/ exists, reference it
+- Keep under 30 lines
+
+Output ONLY valid JSON. No markdown fences. No explanation before or after.
+
+${context}`;
+  console.log("  \u23F3 Analyzing project with Claude Code...");
+  try {
+    const output = execFileSync7("claude", [
+      "--print",
+      "--model",
+      "haiku",
+      "--dangerously-skip-permissions",
+      prompt
+    ], {
+      encoding: "utf-8",
+      timeout: 12e4,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+    const parsed = JSON.parse(cleaned);
+    const config = parsed.config ?? {};
+    if (!config.git) config.git = {};
+    if (!config.github) config.github = {};
+    if (!config.paths) config.paths = {};
+    if (!config.agent) config.agent = {};
+    config.git.defaultBranch = config.git.defaultBranch || basic.defaultBranch;
+    config.github.owner = config.github.owner || basic.owner;
+    config.github.repo = config.github.repo || basic.repo;
+    config.paths.taskDir = config.paths.taskDir || ".tasks";
+    config.agent.runner = config.agent.runner || (basic.hasOpenCode ? "opencode" : "claude-code");
+    config.agent.defaultRunner = config.agent.defaultRunner || (basic.hasOpenCode ? "opencode" : "claude");
+    if (!config.agent.modelMap) {
+      config.agent.modelMap = { cheap: "haiku", mid: "sonnet", strong: "opus" };
+    }
+    validateQualityCommands(cwd, config, basic.pm);
+    return {
+      config,
+      architecture: parsed.architecture ?? "",
+      conventions: parsed.conventions ?? ""
+    };
+  } catch (err) {
+    console.log("  \u26A0 Smart detection failed, falling back to basic detection");
+    return {
+      config: buildFallbackConfig(cwd, basic),
+      architecture: "",
+      conventions: ""
+    };
+  }
+}
+function validateQualityCommands(cwd, config, pm) {
+  let scripts = {};
+  try {
+    const pkg = JSON.parse(fs7.readFileSync(path6.join(cwd, "package.json"), "utf-8"));
+    scripts = pkg.scripts ?? {};
+  } catch {
+    return;
+  }
+  const quality = config.quality ?? {};
+  const overrides = [
+    { key: "typecheck", preferred: ["typecheck", "type-check"] },
+    { key: "lint", preferred: ["lint"] },
+    { key: "lintFix", preferred: ["lint:fix", "lint-fix"] },
+    { key: "format", preferred: ["format:check", "format-check", "prettier:check"] },
+    { key: "formatFix", preferred: ["format", "format:fix", "format-fix"] },
+    { key: "testUnit", preferred: ["test:unit", "test-unit", "test:ci"] }
+  ];
+  for (const { key, preferred } of overrides) {
+    const match = preferred.find((s) => scripts[s]);
+    if (match) {
+      const correct = `${pm} ${match}`;
+      if (quality[key] !== correct) {
+        quality[key] = correct;
+      }
+    }
+    if (quality[key]) {
+      const scriptName = quality[key].replace(`${pm} `, "");
+      if (scriptName && !scripts[scriptName] && !scriptName.includes(" ")) {
+        quality[key] = "";
+      }
+    }
+  }
+  config.quality = quality;
+}
+function buildFallbackConfig(cwd, basic) {
+  const pkg = (() => {
+    try {
+      return JSON.parse(fs7.readFileSync(path6.join(cwd, "package.json"), "utf-8"));
+    } catch {
+      return {};
+    }
+  })();
+  const scripts = pkg.scripts ?? {};
+  const find = (...c) => {
+    for (const s of c) {
+      if (scripts[s]) return `${basic.pm} ${s}`;
+    }
+    return "";
+  };
+  return {
+    quality: {
+      typecheck: find("typecheck", "type-check") || (pkg.devDependencies?.typescript ? `${basic.pm} tsc --noEmit` : ""),
+      lint: find("lint"),
+      lintFix: find("lint:fix", "lint-fix"),
+      format: find("format:check"),
+      formatFix: find("format", "format:fix"),
+      testUnit: find("test:unit", "test", "test:ci")
+    },
+    git: { defaultBranch: basic.defaultBranch },
+    github: { owner: basic.owner, repo: basic.repo },
+    paths: { taskDir: ".tasks" },
+    agent: {
+      runner: basic.hasOpenCode ? "opencode" : "claude-code",
+      defaultRunner: basic.hasOpenCode ? "opencode" : "claude",
+      modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+    }
+  };
+}
 function initCommand(opts) {
   const cwd = process.cwd();
   console.log(`
@@ -2027,26 +2324,11 @@ function initCommand(opts) {
     console.log("  \u2713 .github/workflows/kody.yml");
   }
   const configDest = path6.join(cwd, "kody.config.json");
-  if (!fs7.existsSync(configDest)) {
-    const defaultConfig = {
-      quality: {
-        typecheck: "pnpm tsc --noEmit",
-        lint: "",
-        lintFix: "",
-        format: "",
-        formatFix: "",
-        testUnit: "pnpm test"
-      },
-      git: { defaultBranch: "main" },
-      github: { owner: "", repo: "" },
-      paths: { taskDir: ".tasks" },
-      agent: {
-        runner: "claude-code",
-        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
-      }
-    };
-    fs7.writeFileSync(configDest, JSON.stringify(defaultConfig, null, 2) + "\n");
-    console.log("  \u2713 kody.config.json (created \u2014 edit github.owner and github.repo)");
+  let smartResult = null;
+  if (!fs7.existsSync(configDest) || opts.force) {
+    smartResult = smartInit(cwd);
+    fs7.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
+    console.log("  \u2713 kody.config.json (auto-configured)");
   } else {
     console.log("  \u25CB kody.config.json (exists)");
   }
@@ -2172,33 +2454,38 @@ function initCommand(opts) {
       console.log("  \u2717 kody.config.json \u2014 invalid JSON");
     }
   }
-  console.log("\n\u2500\u2500 Architecture Detection \u2500\u2500");
+  console.log("\n\u2500\u2500 Project Memory \u2500\u2500");
   const memoryDir = path6.join(cwd, ".kody", "memory");
+  fs7.mkdirSync(memoryDir, { recursive: true });
   const archPath = path6.join(memoryDir, "architecture.md");
-  if (fs7.existsSync(archPath)) {
-    console.log("  \u25CB .kody/memory/architecture.md (exists, not overwriting)");
+  const conventionsPath = path6.join(memoryDir, "conventions.md");
+  if (fs7.existsSync(archPath) && !opts.force) {
+    console.log("  \u25CB .kody/memory/architecture.md (exists, use --force to regenerate)");
+  } else if (smartResult?.architecture) {
+    fs7.writeFileSync(archPath, smartResult.architecture);
+    const lineCount = smartResult.architecture.split("\n").length;
+    console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines, LLM-generated)`);
   } else {
     const archItems = detectArchitecture(cwd);
     if (archItems.length > 0) {
-      fs7.mkdirSync(memoryDir, { recursive: true });
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const content = `# Architecture (auto-detected ${timestamp2})
+      fs7.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${archItems.join("\n")}
-`;
-      fs7.writeFileSync(archPath, content);
-      console.log(`  \u2713 .kody/memory/architecture.md (${archItems.length} items detected)`);
-      for (const item of archItems) {
-        console.log(`    ${item}`);
-      }
+`);
+      console.log(`  \u2713 .kody/memory/architecture.md (${archItems.length} items, basic detection)`);
     } else {
       console.log("  \u25CB No architecture detected");
     }
   }
-  const conventionsPath = path6.join(memoryDir, "conventions.md");
-  if (!fs7.existsSync(conventionsPath)) {
-    fs7.mkdirSync(memoryDir, { recursive: true });
+  if (fs7.existsSync(conventionsPath) && !opts.force) {
+    console.log("  \u25CB .kody/memory/conventions.md (exists, use --force to regenerate)");
+  } else if (smartResult?.conventions) {
+    fs7.writeFileSync(conventionsPath, smartResult.conventions);
+    const lineCount = smartResult.conventions.split("\n").length;
+    console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines, LLM-generated)`);
+  } else {
     fs7.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",

package/templates/kody.yml

@@ -103,7 +103,7 @@ jobs:
 
           # Validate mode
           case "$MODE" in
-            full|rerun|status|approve) ;;
+            full|rerun|fix|status|approve) ;;
             *)
               # If first arg isn't a mode, it might be a task-id or nothing
               if [ -n "$MODE" ] && [ "$MODE" != "" ]; then
@@ -196,7 +196,15 @@ jobs:
           FEEDBACK: ${{ github.event.inputs.feedback || needs.parse.outputs.feedback }}
           DRY_RUN: ${{ github.event.inputs.dry_run || 'false' }}
           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
-        run: kody-engine-lite run --task-id "$TASK_ID" --issue-number "$ISSUE_NUMBER"
+        run: |
+          CMD="run"
+          [ "$MODE" = "rerun" ] && CMD="rerun"
+          [ "$MODE" = "fix" ] && CMD="fix"
+          ARGS="--task-id $TASK_ID --issue-number $ISSUE_NUMBER"
+          [ -n "$FROM_STAGE" ] && ARGS="$ARGS --from $FROM_STAGE"
+          [ -n "$FEEDBACK" ] && ARGS="$ARGS --feedback \"$FEEDBACK\""
+          [ "$DRY_RUN" = "true" ] && ARGS="$ARGS --dry-run"
+          kody-engine-lite $CMD $ARGS
 
       - name: Pipeline summary
         if: always()