@kody-ade/kody-engine 0.4.137 → 0.4.139

package/dist/bin/kody.js

@@ -312,6 +312,52 @@ var init_verifyMcp = __esm({
   }
 });
 
+// src/submitMcp.ts
+var submitMcp_exports = {};
+__export(submitMcp_exports, {
+  buildSubmitMcpServer: () => buildSubmitMcpServer
+});
+import { createSdkMcpServer as createSdkMcpServer2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
+function buildSubmitMcpServer() {
+  let submitted;
+  const submitTool = tool2(
+    "submit_state",
+    "Persist this tick's next state. Call this EXACTLY ONCE, at the very end, when you've finished your work \u2014 it is the ONLY way your decision is saved. Pass your next `cursor` (string), your next `data` (object \u2014 carry prior data forward and mutate what you acted on), and `done` (boolean). After calling it you are finished; do not take further actions.",
+    {
+      cursor: z2.string().describe('The next cursor value (e.g. "idle"). Must be a non-empty string.'),
+      data: z2.record(z2.string(), z2.unknown()).describe("The next `data` object. Carry forward prior data and mutate only what you acted on this tick."),
+      done: z2.boolean().describe("true only if this duty is permanently finished; evergreen duties stay false.")
+    },
+    async (args) => {
+      submitted = {
+        cursor: String(args.cursor ?? ""),
+        data: args.data ?? {},
+        done: Boolean(args.done)
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: "State recorded. You are done for this tick \u2014 no further action needed."
+          }
+        ]
+      };
+    }
+  );
+  const server = createSdkMcpServer2({
+    name: "kody-submit",
+    version: "0.1.0",
+    tools: [submitTool]
+  });
+  return { server, getSubmitted: () => submitted };
+}
+var init_submitMcp = __esm({
+  "src/submitMcp.ts"() {
+    "use strict";
+  }
+});
+
 // src/issue.ts
 import { execFileSync } from "child_process";
 function ghToken() {
@@ -880,7 +926,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.137",
+  version: "0.4.139",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -1514,6 +1560,7 @@ async function runAgent(opts) {
   const turnTimeoutMs = resolveTurnTimeoutMs(opts);
   let ndjsonWriteFailed = false;
   let ndjsonWriteError;
+  let getSubmitted;
   try {
     const queryOptions = {
       model: opts.model.model,
@@ -1541,6 +1588,12 @@ async function runAgent(opts) {
       });
       mcpEntries.push(["kody-verify", verifyServer]);
     }
+    if (opts.enableSubmitTool) {
+      const { buildSubmitMcpServer: buildSubmitMcpServer2 } = await Promise.resolve().then(() => (init_submitMcp(), submitMcp_exports));
+      const submitHandle = buildSubmitMcpServer2();
+      getSubmitted = submitHandle.getSubmitted;
+      mcpEntries.push(["kody-submit", submitHandle.server]);
+    }
     if (mcpEntries.length > 0) {
       queryOptions.mcpServers = Object.fromEntries(mcpEntries);
     }
@@ -1706,10 +1759,12 @@ async function runAgent(opts) {
 `);
   }
   const finalText = resultTexts.join("\n\n---\n\n");
+  const submittedState = getSubmitted?.();
   return {
     outcome,
     outcomeKind,
     finalText,
+    ...submittedState ? { submittedState } : {},
     error: errorMessage,
     ndjsonPath,
     durationMs: Date.now() - startedAt,
@@ -3186,6 +3241,7 @@ function parseClaudeCode(p, raw) {
     systemPromptAppend: typeof r.systemPromptAppend === "string" ? r.systemPromptAppend : null,
     cacheable: r.cacheable === true,
     enableVerifyTool: r.enableVerifyTool === true,
+    enableSubmitTool: r.enableSubmitTool === true,
     verifyAttempts: typeof r.verifyAttempts === "number" && r.verifyAttempts > 0 ? r.verifyAttempts : null,
     tools,
     hooks: Array.isArray(r.hooks) ? r.hooks : [],
@@ -7879,7 +7935,7 @@ function getRecentFailedRunsForPr(prNumber, limit, cwd) {
   } catch {
     return [];
   }
-  if (!headBranch || !headSha) return [];
+  if (!headBranch) return [];
   try {
     const out = gh3(
       [
@@ -7898,7 +7954,7 @@ function getRecentFailedRunsForPr(prNumber, limit, cwd) {
     );
     const parsed = JSON.parse(out);
     if (!Array.isArray(parsed)) return [];
-    return parsed.map((r) => ({
+    const runs = parsed.map((r) => ({
       id: String(r.databaseId ?? ""),
       workflowName: r.workflowName ?? "",
       headBranch: r.headBranch ?? headBranch,
@@ -7906,7 +7962,8 @@ function getRecentFailedRunsForPr(prNumber, limit, cwd) {
       conclusion: r.conclusion ?? "failure",
       url: r.url ?? "",
       createdAt: r.createdAt ?? ""
-    })).filter((r) => r.headSha === headSha);
+    }));
+    return runs.sort((a, b) => (a.headSha === headSha ? 0 : 1) - (b.headSha === headSha ? 0 : 1));
   } catch {
     return [];
   }
@@ -7970,7 +8027,7 @@ var fixCiFlow = async (ctx) => {
       bail(
         ctx,
         prNumber,
-        `no actionable failed workflow run found for PR #${prNumber}'s current commit (scanned up to ${RUN_LOOKBACK} failed runs on the head SHA \u2014 none were actionable CI failures with fetchable logs; pass --run-id to target a specific run)`
+        `no actionable failed workflow run found for PR #${prNumber} (scanned up to ${RUN_LOOKBACK} recent failed runs on the branch, head commit first \u2014 none were actionable CI failures with fetchable logs; pass --run-id to target a specific run)`
       );
       return;
     }
@@ -9312,6 +9369,17 @@ var parseJobStateFromAgentResult = async (ctx, _profile, agentResult, args) => {
   }
   const loaded = ctx.data.jobState;
   const prevRev = loaded?.state.rev ?? 0;
+  const submitted = agentResult.submittedState;
+  if (submitted && typeof submitted.cursor === "string" && submitted.cursor.length > 0) {
+    ctx.data.nextJobState = {
+      version: 1,
+      rev: prevRev + 1,
+      cursor: submitted.cursor,
+      data: submitted.data ?? {},
+      done: Boolean(submitted.done)
+    };
+    return;
+  }
   const result = extractNextStateFromText(agentResult.finalText, fenceLabel, prevRev);
   if (result.error) {
     ctx.data.nextStateParseError = result.error.startsWith("missing `") ? `agent did not emit a \`${fenceLabel}\` fenced block` : result.error;
@@ -12511,21 +12579,21 @@ function firstRequiredFailure(results, tools) {
   }
   return null;
 }
-function verifyOne(tool2, cwd) {
-  const result = { name: tool2.name, present: false, verified: false };
-  let present = runShell(tool2.install.checkCommand, cwd);
-  if (!present && tool2.install.installCommand) {
-    runShell(tool2.install.installCommand, cwd, 12e4);
-    present = runShell(tool2.install.checkCommand, cwd);
+function verifyOne(tool3, cwd) {
+  const result = { name: tool3.name, present: false, verified: false };
+  let present = runShell(tool3.install.checkCommand, cwd);
+  if (!present && tool3.install.installCommand) {
+    runShell(tool3.install.installCommand, cwd, 12e4);
+    present = runShell(tool3.install.checkCommand, cwd);
   }
   result.present = present;
   if (!present) {
-    result.error = `tool "${tool2.name}" not on PATH (check: ${tool2.install.checkCommand})`;
+    result.error = `tool "${tool3.name}" not on PATH (check: ${tool3.install.checkCommand})`;
     return result;
   }
-  const verified = runShell(tool2.verify, cwd);
+  const verified = runShell(tool3.verify, cwd);
   result.verified = verified;
-  if (!verified) result.error = `tool "${tool2.name}" failed verify: ${tool2.verify}`;
+  if (!verified) result.error = `tool "${tool3.name}" failed verify: ${tool3.verify}`;
   return result;
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
@@ -12665,6 +12733,7 @@ async function runExecutable(profileName, input) {
       systemPromptAppend: [DISCIPLINE, profile.claudeCode.systemPromptAppend, taskArtifacts?.promptAddendum].filter((s) => typeof s === "string" && s.length > 0).join("\n\n") || void 0,
       cacheable: profile.claudeCode.cacheable,
       enableVerifyTool: profile.claudeCode.enableVerifyTool,
+      enableSubmitTool: profile.claudeCode.enableSubmitTool,
       verifyToolMaxAttempts: profile.claudeCode.verifyAttempts ?? null,
       verifyConfig: profile.claudeCode.enableVerifyTool ? config : void 0,
       executableName: profileName,

package/dist/executables/job-tick/profile.json

@@ -24,7 +24,8 @@
     "maxTurns": 20,
     "maxThinkingTokens": null,
     "systemPromptAppend": null,
-    "tools": ["Bash", "Read"],
+    "enableSubmitTool": true,
+    "tools": ["Bash", "Read", "mcp__kody-submit"],
     "hooks": [],
     "skills": [],
     "commands": [],

package/dist/executables/job-tick/prompt.md

@@ -32,23 +32,25 @@ This is the state you wrote at the end of the previous tick (or `null` if this i
 2. **Re-read the job body.** It may have changed since the last tick.
 3. **Execute exactly the work the body's `## Job` section describes**, subject to its `## Allowed Commands` and `## Restrictions`. Use the `## State` section to interpret and update `data`.
 4. **Optionally post a short narration** wherever the job tells you to (typically a PR comment alongside the action). Keep it terse.
-5. **Emit the new state** at the very end of your response using the fenced block below. Do not include `version` or `rev` — the postflight script manages those.
+5. **Submit the new state** by calling the `submit_state` tool (see contract below). Do not include `version` or `rev` — the postflight script manages those.
 
 ## Output contract (MANDATORY, exactly once, at the end)
 
-End your response with a single fenced block using the `kody-job-next-state` language tag:
+Call the **`submit_state`** tool exactly once, as the final step, with your next state:
 
-````
-```kody-job-next-state
-{
-  "cursor": "<your-next-cursor>",
-  "data": { ... },
-  "done": <true|false>
-}
-```
-````
+- `cursor` — your next cursor (string, e.g. `"idle"`).
+- `data` — your next `data` object. Carry forward prior `data` and mutate only what you acted on this tick.
+- `done` — `true` only if the duty is permanently finished; evergreen duties stay `false`.
+
+This is the ONLY way your decision is saved. If you don't call it, the tick fails and the state is NOT updated — on the next wake you'll see the same prior state and can retry.
 
-If you fail to emit this block, or the JSON is invalid, the tick fails and the gist state is NOT updated. On the next wake you'll see the same prior state and can retry.
+> Backstop (legacy): if the `submit_state` tool is unavailable, end your reply with the same JSON in a single fenced block tagged `kody-job-next-state` instead:
+>
+> ````
+> ```kody-job-next-state
+> { "cursor": "<next>", "data": { ... }, "done": <true|false> }
+> ```
+> ````
 
 ## Rules
 

package/dist/executables/types.ts

@@ -228,6 +228,13 @@ export interface ClaudeCodeSpec {
    * Default false.
    */
   enableVerifyTool?: boolean
+  /**
+   * Opt-in: expose an in-process `submit_state` tool the agent calls to
+   * persist its next state, instead of relying on a trailing fenced
+   * `kody-job-next-state` block it must remember to emit. Used by job-tick.
+   * The fenced block stays supported as a fallback. Default false.
+   */
+  enableSubmitTool?: boolean
   /**
    * Hard cap on verify-tool invocations per agent session when
    * `enableVerifyTool` is true. Default 4 (≈3 fix iterations after the

package/package.json

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