@kody-ade/kody-engine 0.3.79 → 0.3.81

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.79",
+  version: "0.3.81",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -662,7 +662,7 @@ import * as path5 from "path";
 
 // src/chat/inbox.ts
 import { execFileSync } from "child_process";
-var DEFAULT_POLL_MS = 3e4;
+var DEFAULT_POLL_MS = 3e3;
 async function waitForNextUserMessage(opts) {
   const pollMs = opts.pollIntervalMs ?? DEFAULT_POLL_MS;
   const logger = opts.logger ?? {
@@ -724,7 +724,7 @@ function currentBranch(cwd) {
 // src/chat/modes/interactive.ts
 var DEFAULT_IDLE_EXIT_MS = 5 * 6e4;
 var DEFAULT_HARD_CAP_MS = 30 * 6e4;
-var DEFAULT_POLL_MS2 = 3e4;
+var DEFAULT_POLL_MS2 = 3e3;
 async function runInteractiveMode(opts) {
   const sessionFile = sessionFilePath(opts.cwd, opts.sessionId);
   const idleExitMs = opts.meta.idleExitMs ?? DEFAULT_IDLE_EXIT_MS;
@@ -1209,7 +1209,7 @@ function coerceBare(spec, value) {
 }
 
 // src/executor.ts
-import { execFileSync as execFileSync27, spawn as spawn3 } from "child_process";
+import { execFileSync as execFileSync27, spawn as spawn4 } from "child_process";
 import * as fs26 from "fs";
 import * as path23 from "path";
 
@@ -5640,6 +5640,71 @@ function escapeRegex2(s) {
   return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
 
+// src/scripts/parseReproOutput.ts
+var parseReproOutput = async (ctx, _profile, agentResult) => {
+  if (!agentResult || ctx.data.agentDone === false) return;
+  const text = agentResult.finalText ?? "";
+  const testPath = extractTestPath(text);
+  const signatureRaw = extractFailureSignatureBlock(text);
+  if (!testPath) {
+    downgrade(ctx, "reproduce missing TEST_PATH line in final message");
+    return;
+  }
+  let signature = null;
+  if (signatureRaw) {
+    try {
+      const parsed = JSON.parse(signatureRaw);
+      if (typeof parsed.errorType === "string" && typeof parsed.messageContains === "string") {
+        signature = {
+          errorType: parsed.errorType,
+          messageContains: parsed.messageContains,
+          stackContains: typeof parsed.stackContains === "string" ? parsed.stackContains : ""
+        };
+      }
+    } catch {
+    }
+  }
+  if (!signature) {
+    downgrade(
+      ctx,
+      "reproduce missing or malformed FAILURE_SIGNATURE JSON (must contain errorType + messageContains)"
+    );
+    return;
+  }
+  ctx.data.reproTestPath = testPath;
+  ctx.data.reproFailureSignature = JSON.stringify(signature);
+};
+function extractTestPath(text) {
+  const m = text.match(/^[\s>*_#`~-]*TEST_PATH[\s>*_#`~-]*\s*:\s*(.+?)\s*$/im);
+  if (!m) return "";
+  return stripMarkdownEmphasis2(m[1] ?? "");
+}
+function extractFailureSignatureBlock(text) {
+  const startIdx = text.search(/(?:^|\n)[ \t]*FAILURE_SIGNATURE\s*:[ \t]*/i);
+  if (startIdx === -1) return "";
+  const afterMarker = text.slice(startIdx).replace(/^[\s\S]*?FAILURE_SIGNATURE\s*:[ \t]*\n?/i, "");
+  const stopRe = /(?:^|\n)[ \t]*(?:COMMIT_MSG|PR_SUMMARY|TEST_PATH)\s*:/i;
+  const stopIdx = afterMarker.search(stopRe);
+  let block = stopIdx === -1 ? afterMarker : afterMarker.slice(0, stopIdx);
+  block = block.trim();
+  block = block.replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/i, "");
+  return block.trim();
+}
+function stripMarkdownEmphasis2(s) {
+  return s.trim().replace(/^[*_`~]+|[*_`~]+$/g, "").trim();
+}
+function downgrade(ctx, reason) {
+  const action = ctx.data.action;
+  if (action && action.type.endsWith("_COMPLETED")) {
+    ctx.data.action = {
+      type: action.type.replace(/_COMPLETED$/, "_FAILED"),
+      payload: { reason, downgradedFrom: action.type },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  ctx.data.agentDone = false;
+}
+
 // src/scripts/persistArtifacts.ts
 var persistArtifacts = async (ctx, profile) => {
   if (profile.outputArtifacts.length === 0) return;
@@ -6749,6 +6814,122 @@ var verify = async (ctx) => {
   }
 };
 
+// src/scripts/verifyReproFails.ts
+import { spawn as spawn3 } from "child_process";
+var TEST_TIMEOUT_MS = 10 * 60 * 1e3;
+var TAIL_CHARS2 = 8e3;
+var ANSI_RE2 = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+var verifyReproFails = async (ctx) => {
+  if (ctx.data.agentDone === false) return;
+  const testPath = ctx.data.reproTestPath ?? "";
+  const signatureRaw = ctx.data.reproFailureSignature ?? "";
+  if (!testPath || !signatureRaw) {
+    downgrade2(ctx, "verifyReproFails: missing testPath or signature in ctx.data");
+    return;
+  }
+  let signature;
+  try {
+    signature = JSON.parse(signatureRaw);
+  } catch {
+    downgrade2(ctx, "verifyReproFails: failure signature is not valid JSON");
+    return;
+  }
+  const baseCmd = ctx.config.quality.testUnit;
+  if (!baseCmd) {
+    downgrade2(ctx, "verifyReproFails: kody.config.json quality.testUnit is empty \u2014 cannot run repro test");
+    return;
+  }
+  const cmd = composeTestCommand(baseCmd, testPath);
+  const result = await runCommand2(cmd, ctx.cwd);
+  const output = stripAnsi2(result.output);
+  ctx.data.reproVerifyExitCode = result.exitCode;
+  ctx.data.reproVerifyTail = output.slice(-TAIL_CHARS2);
+  if (result.exitCode === 0) {
+    downgrade2(
+      ctx,
+      `verifyReproFails: repro test at \`${testPath}\` exited 0 \u2014 the test should be failing because the bug is unfixed`
+    );
+    return;
+  }
+  const haystack = output.toLowerCase();
+  const messageOk = signature.messageContains.length === 0 || haystack.includes(signature.messageContains.toLowerCase());
+  const errorTypeOk = signature.errorType.length === 0 || haystack.includes(signature.errorType.toLowerCase());
+  if (!messageOk || !errorTypeOk) {
+    const missing = [];
+    if (!messageOk) missing.push(`messageContains="${signature.messageContains}"`);
+    if (!errorTypeOk) missing.push(`errorType="${signature.errorType}"`);
+    downgrade2(
+      ctx,
+      `verifyReproFails: repro test failed but the failure signature did not match (missing ${missing.join(", ")}) \u2014 the test may be failing for the wrong reason (e.g. import or syntax error)`
+    );
+    return;
+  }
+  ctx.data.reproVerified = true;
+};
+function composeTestCommand(baseCmd, testPath) {
+  const trimmed = baseCmd.trim();
+  const lower = trimmed.toLowerCase();
+  const positionalRunners = ["vitest", "jest", "pytest", "mocha", "ava", "deno test", "bun test"];
+  if (positionalRunners.some((r) => lower.includes(r))) {
+    return `${trimmed} ${shellQuote(testPath)}`;
+  }
+  return trimmed;
+}
+function shellQuote(s) {
+  if (/^[A-Za-z0-9_./-]+$/.test(s)) return s;
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function stripAnsi2(s) {
+  return s.replace(ANSI_RE2, "");
+}
+function runCommand2(command, cwd) {
+  return new Promise((resolve4) => {
+    const child = spawn3(command, {
+      cwd,
+      shell: true,
+      env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const buffers = [];
+    let totalSize = 0;
+    const collect = (chunk) => {
+      buffers.push(chunk);
+      totalSize += chunk.length;
+      while (totalSize > TAIL_CHARS2 * 4 && buffers.length > 1) {
+        totalSize -= buffers[0].length;
+        buffers.shift();
+      }
+    };
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, 5e3);
+    }, TEST_TIMEOUT_MS);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve4({ exitCode: code ?? -1, output: Buffer.concat(buffers).toString("utf-8") });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve4({ exitCode: -1, output: err.message });
+    });
+  });
+}
+function downgrade2(ctx, reason) {
+  const action = ctx.data.action;
+  if (action && action.type.endsWith("_COMPLETED")) {
+    ctx.data.action = {
+      type: action.type.replace(/_COMPLETED$/, "_FAILED"),
+      payload: { reason, downgradedFrom: action.type },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  ctx.data.agentDone = false;
+}
+
 // src/scripts/waitForCi.ts
 import { execFileSync as execFileSync25 } from "child_process";
 var API_TIMEOUT_MS10 = 3e4;
@@ -7066,11 +7247,13 @@ var postflightScripts = {
   parseAgentResult: parseAgentResult2,
   parseIssueStateFromAgentResult,
   parseMissionStateFromAgentResult,
+  parseReproOutput,
   writeIssueStateComment,
   writeMissionStateFile,
   requireFeedbackActions,
   requirePlanDeviations,
   verify,
+  verifyReproFails,
   checkCoverageWithRetry,
   abortUnfinishedGitOps: abortUnfinishedGitOps2,
   stageMergeConflicts,
@@ -7434,7 +7617,7 @@ async function runShellEntry(entry, ctx, profile) {
     env[`KODY_CFG_${k}`] = v;
   }
   const timeoutMs = resolveShellTimeoutMs(entry);
-  const child = spawn3("bash", [shellPath, ...positional], {
+  const child = spawn4("bash", [shellPath, ...positional], {
     cwd: ctx.cwd,
     env,
     stdio: ["pipe", "pipe", "pipe"],

package/dist/executables/bug-container/profile.json

@@ -68,6 +68,15 @@
     ]
   },
   "children": [
+    {
+      "exec": "reproduce",
+      "target": "issue",
+      "next": {
+        "REPRODUCE_COMPLETED": "plan",
+        "REPRODUCE_FAILED": "plan",
+        "*": "abort"
+      }
+    },
     {
       "exec": "plan",
       "target": "issue",

package/dist/executables/reproduce/profile.json

@@ -0,0 +1,78 @@
+{
+  "name": "reproduce",
+  "role": "primitive",
+  "describe": "Write a failing test that reproduces a bug. Do NOT fix the bug — leave the test failing and capture the failure signature so subsequent fix verification can confirm the same failure mode.",
+  "inputs": [
+    {
+      "name": "issue",
+      "flag": "--issue",
+      "type": "int",
+      "required": true,
+      "describe": "GitHub issue number to reproduce."
+    }
+  ],
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "acceptEdits",
+    "maxTurns": null,
+    "systemPromptAppend": null,
+    "tools": [
+      "Read",
+      "Write",
+      "Edit",
+      "Bash",
+      "Grep",
+      "Glob"
+    ],
+    "hooks": ["block-git"],
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [],
+  "scripts": {
+    "preflight": [
+      {
+        "script": "setLifecycleLabel",
+        "with": {
+          "label": "kody:reproducing",
+          "color": "fef2c0",
+          "description": "kody: writing a failing test that reproduces the bug"
+        }
+      },
+      { "script": "runFlow" },
+      { "script": "loadTaskState" },
+      { "script": "loadConventions" },
+      { "script": "loadCoverageRules" },
+      { "script": "composePrompt" }
+    ],
+    "postflight": [
+      { "script": "parseAgentResult" },
+      { "script": "parseReproOutput" },
+      { "script": "verifyReproFails" },
+      { "script": "abortUnfinishedGitOps" },
+      { "script": "commitAndPush" },
+      { "script": "ensurePr" },
+      { "script": "postIssueComment" },
+      { "script": "persistArtifacts" },
+      { "script": "writeRunSummary" },
+      { "script": "saveTaskState" },
+      { "script": "mirrorStateToPr" },
+      { "script": "advanceFlow" }
+    ]
+  },
+  "output": {
+    "actionTypes": [
+      "REPRODUCE_COMPLETED",
+      "REPRODUCE_FAILED",
+      "AGENT_NOT_RUN"
+    ],
+    "artifacts": [
+      { "name": "repro", "format": "markdown", "from": "prSummary" },
+      { "name": "repro.testPath", "format": "text", "from": "reproTestPath" },
+      { "name": "repro.failureSignature", "format": "text", "from": "reproFailureSignature" }
+    ]
+  }
+}

package/dist/executables/reproduce/prompt.md

@@ -0,0 +1,67 @@
+You are Kody, an autonomous engineer. Your job for this turn is **NOT** to fix the bug — it is to write a failing test that reproduces the bug, then confirm the test fails for the right reason. The wrapper handles git/gh — you do not.
+
+Subsequent steps (`plan`, `run`) will design and implement the fix. The test you write here is the canonical proof the bug exists, and is the success criterion for the fix.
+
+# Repo
+- {{repoOwner}}/{{repoName}}, default branch: {{defaultBranch}}
+- current branch (already checked out): {{branch}}
+
+{{conventionsBlock}}{{coverageBlock}}{{toolsUsage}}# Issue #{{issue.number}}: {{issue.title}}
+{{issue.body}}
+
+# Required steps (all in this one session)
+
+1. **Understand the bug.** Read the issue carefully. Identify:
+   - The expected behavior (what *should* happen).
+   - The actual behavior (what *does* happen, the bug).
+   - The smallest piece of code that exhibits this gap.
+
+2. **Locate the right test home.** Read the existing test directory structure (`tests/`, `__tests__/`, `*.test.*` siblings — whatever this repo uses). Open the newest existing test file in the most fitting directory and copy its imports, setup, and assertion idioms **verbatim**. Do NOT introduce a new test framework or pattern when one already works in this repo.
+
+3. **Write a failing test.** Create or extend a single test file that asserts the **expected** (correct) behavior. The test must currently fail because the bug is unfixed. Keep it minimal — one test case is enough. Name it after the issue (e.g. `repro-issue-{{issue.number}}.test.ts`) when creating a new file, or add a clearly-labeled test case to an existing file.
+
+   - Do NOT change any production code.
+   - Do NOT mark the test as `skip`, `todo`, or `expect.fail` — it must run and assert.
+   - The assertion must fail because the bug exists, not because of an import error, missing fixture, or syntax error.
+
+4. **Run the test ONCE** with the project's test command (read from conventions / package.json). Capture:
+   - Exit code (must be non-zero).
+   - The error type (`AssertionError`, `TypeError`, the name of the failing matcher, etc.).
+   - A distinctive substring of the error message (something the fix is expected to flip).
+   - One stack-frame anchor pointing at the buggy production code, if visible.
+
+5. **If the test passes** (exit 0), the test isn't actually catching the bug — refine it and re-run. If after two refinement attempts you still cannot get a meaningful failure, output `FAILED: <reason>` instead.
+
+6. **If the test fails for the wrong reason** (import error, syntax error, missing module), fix that and re-run. Only when the failure is a real assertion against the buggy behavior do you proceed.
+
+# Required output
+
+Your FINAL message must use this exact format (or a single `FAILED: <reason>` line):
+
+```
+DONE
+TEST_PATH: <path/to/test/file relative to repo root>
+FAILURE_SIGNATURE:
+```
+{
+  "errorType": "<error class name, e.g. AssertionError>",
+  "messageContains": "<distinctive substring of the failure message>",
+  "stackContains": "<optional: substring of a stack frame in production code, or empty>"
+}
+```
+COMMIT_MSG: test: add failing repro for #{{issue.number}}
+PR_SUMMARY:
+- Test file: <path>
+- What it asserts: <one sentence>
+- Why it fails today: <one sentence pointing at the buggy production code>
+- How to verify locally: <test command + filter>
+```
+
+# Rules
+- Do NOT fix the bug. Do NOT modify production code.
+- Do NOT run `git` or `gh` commands. The wrapper handles all git/gh operations.
+- Stay on the current branch (`{{branch}}`).
+- Do NOT modify files under `.kody/`, `.kody-engine/`, `node_modules/`, `dist/`, `build/`, `.env`, or any `*.log`.
+- Do NOT post issue comments — the wrapper handles that.
+- The test you commit will stay red until the fix lands. That is correct.
+{{systemPromptAppend}}

package/dist/executables/run/profile.json

@@ -68,7 +68,10 @@
   },
   "input": {
     "artifacts": [
-      { "name": "plan", "required": false }
+      { "name": "plan", "required": false },
+      { "name": "repro", "required": false },
+      { "name": "repro.testPath", "required": false },
+      { "name": "repro.failureSignature", "required": false }
     ]
   },
   "output": {

package/dist/executables/run/prompt.md

@@ -7,6 +7,14 @@ You are Kody, an autonomous engineer. Take a GitHub issue from spec to a tested
 {{conventionsBlock}}{{coverageBlock}}{{toolsUsage}}# Issue #{{issue.number}}: {{issue.title}}
 {{issue.body}}
 
+# Failing repro test (success criterion, if present)
+{{artifacts.repro}}
+
+If the section above is non-empty, an earlier `reproduce` step has already committed a failing test on this branch. **The success criterion of your work is to make that test pass** without weakening it (do not delete the assertion, change the expected value to match the buggy output, or skip the test). Test path: `{{artifacts.repro.testPath}}`. The fix is only complete when:
+1. That specific test passes.
+2. The full quality gates (typecheck, lint, full test suite) pass — your fix has not regressed anything else.
+If the repro section is empty, no failing test was pre-committed; proceed normally.
+
 # Existing plan (produced by `@kody plan`, if present)
 {{artifacts.plan}}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.3.79",
+  "version": "0.3.81",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",