@kody-ade/kody-engine 0.4.565 → 0.4.567

package/dist/bin/kody.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@kody-ade/kody-engine",
-      version: "0.4.565",
+      version: "0.4.567",
       description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative implementation profiles.",
       license: "MIT",
       type: "module",
@@ -1143,14 +1143,23 @@ function buildVerifyEnv(source = process.env) {
   env.CI = source.CI ?? "1";
   return env;
 }
-function runCommand(command, cwd) {
+function abortMessage(signal) {
+  const reason = signal.reason;
+  return reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "verification aborted";
+}
+function runCommand(command, cwd, signal) {
   return new Promise((resolve23) => {
     const start = Date.now();
+    if (signal?.aborted) {
+      resolve23({ exitCode: -1, durationMs: 0, tail: abortMessage(signal) });
+      return;
+    }
     const child = spawn(command, {
       cwd,
       shell: true,
       env: buildVerifyEnv(),
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32"
     });
     const buffers = [];
     let totalSize = 0;
@@ -1164,24 +1173,46 @@ function runCommand(command, cwd) {
     };
     child.stdout?.on("data", collect);
     child.stderr?.on("data", collect);
+    let settled = false;
+    const killTree = (killSignal) => {
+      try {
+        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, killSignal);
+        else child.kill(killSignal);
+      } catch {
+        child.kill(killSignal);
+      }
+    };
+    const finish = (exitCode, extraTail = "") => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      const output = Buffer.concat(buffers).toString("utf-8");
+      const tail = [output, extraTail].filter(Boolean).join("\n").slice(-TAIL_CHARS);
+      resolve23({ exitCode, durationMs: Date.now() - start, tail });
+    };
+    const terminate = () => {
+      killTree("SIGTERM");
+      setTimeout(() => killTree("SIGKILL"), 5e3).unref();
+    };
+    const onAbort = () => {
+      terminate();
+      finish(-1, signal ? abortMessage(signal) : "verification aborted");
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
     const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      setTimeout(() => {
-        if (!child.killed) child.kill("SIGKILL");
-      }, 5e3);
+      terminate();
+      finish(-1, "verification command timed out");
     }, COMMAND_TIMEOUT_MS);
     child.on("exit", (code) => {
-      clearTimeout(timer);
-      const tail = Buffer.concat(buffers).toString("utf-8").slice(-TAIL_CHARS);
-      resolve23({ exitCode: code ?? -1, durationMs: Date.now() - start, tail });
+      finish(code ?? -1);
     });
     child.on("error", (err) => {
-      clearTimeout(timer);
-      resolve23({ exitCode: -1, durationMs: Date.now() - start, tail: err.message });
+      finish(-1, err.message);
     });
   });
 }
-async function verifyAll(config, cwd) {
+async function verifyAll(config, cwd, opts) {
   const commands = [];
   if (config.quality.typecheck) commands.push({ name: "typecheck", cmd: config.quality.typecheck });
   if (config.quality.testUnit) commands.push({ name: "test", cmd: config.quality.testUnit });
@@ -1190,20 +1221,21 @@ async function verifyAll(config, cwd) {
   const failed = [];
   const details = {};
   for (const { name, cmd } of commands) {
-    const result = await runCommand(cmd, cwd);
+    const result = await runCommand(cmd, cwd, opts?.signal);
     details[name] = result;
     if (result.exitCode !== 0) failed.push(name);
   }
   return { ok: failed.length === 0, failed, details };
 }
-async function applyTestRetries(initial, testCommand, cwd, runner, testRetries = DEFAULT_TEST_RETRIES) {
+async function applyTestRetries(initial, testCommand, cwd, runner, testRetries = DEFAULT_TEST_RETRIES, signal) {
   if (initial.ok) return { ...initial, recovered: [] };
   const recovered = [];
   const details = { ...initial.details };
   let failed = [...initial.failed];
   if (failed.includes("test") && testCommand && testRetries > 0) {
     for (let attempt = 1; attempt <= testRetries; attempt++) {
-      const retry = await runner(testCommand, cwd);
+      if (signal?.aborted) break;
+      const retry = await runner(testCommand, cwd, signal);
       details[`test (retry ${attempt})`] = retry;
       if (retry.exitCode === 0) {
         failed = failed.filter((f) => f !== "test");
@@ -1215,8 +1247,8 @@ async function applyTestRetries(initial, testCommand, cwd, runner, testRetries =
   return { ok: failed.length === 0, failed, details, recovered };
 }
 async function verifyAllWithRetry(config, cwd, opts) {
-  const initial = await verifyAll(config, cwd);
-  return applyTestRetries(initial, config.quality.testUnit, cwd, runCommand, opts?.testRetries);
+  const initial = await verifyAll(config, cwd, { signal: opts?.signal });
+  return applyTestRetries(initial, config.quality.testUnit, cwd, runCommand, opts?.testRetries, opts?.signal);
 }
 function stripAnsi(s) {
   return s.replace(ANSI_RE, "");
@@ -2289,6 +2321,7 @@ function parseWorkflowStep(value) {
   const target = stringField(raw.target);
   const delivery = stringField(raw.delivery);
   const targetFact = stringField(raw.targetFact ?? raw.target_fact);
+  const timeoutSeconds = typeof raw.timeoutSeconds === "number" && Number.isInteger(raw.timeoutSeconds) && raw.timeoutSeconds > 0 && raw.timeoutSeconds <= 3600 ? raw.timeoutSeconds : void 0;
   const hasInput = Object.hasOwn(raw, "input");
   const inputs = parseWorkflowInputBindings(raw.inputs);
   const next = parseWorkflowTransitions(raw.next);
@@ -2304,6 +2337,7 @@ function parseWorkflowStep(value) {
     ...delivery === "pull-request" ? { delivery } : {},
     ...targetFact ? { targetFact } : {},
     ...reason ? { reason } : {},
+    ...timeoutSeconds ? { timeoutSeconds } : {},
     ...next ? { next } : {},
     ...isPlainObject(raw.runWhen) ? { runWhen: raw.runWhen } : {},
     ...stringList(raw.continueOn ?? raw.continue_on).length > 0 ? { continueOn: stringList(raw.continueOn ?? raw.continue_on) } : {},
@@ -4722,6 +4756,15 @@ function validateWorkflow(value, options = {}) {
     if (step.input !== void 0 && step.inputs !== void 0) {
       issue(issues, "conflicting_inputs", base, "workflow step cannot declare both input and inputs");
     }
+    const timeoutSeconds = step.timeoutSeconds;
+    if (timeoutSeconds !== void 0 && (typeof timeoutSeconds !== "number" || !Number.isInteger(timeoutSeconds) || timeoutSeconds < 1 || timeoutSeconds > 3600)) {
+      issue(
+        issues,
+        "invalid_step_timeout",
+        `${base}.timeoutSeconds`,
+        "workflow step timeoutSeconds must be an integer from 1 to 3600"
+      );
+    }
     validateInputBindings(
       step.inputs,
       `${base}.inputs`,
@@ -5005,6 +5048,7 @@ var init_workflowValidation = __esm({
       "delivery",
       "targetFact",
       "reason",
+      "timeoutSeconds",
       "next",
       "runWhen",
       "continueOn",
@@ -20877,7 +20921,7 @@ var init_verifyReproFails = __esm({
 // src/scripts/verifyWithRetry.ts
 async function runVerify(ctx) {
   try {
-    const result = await verifyAllWithRetry(ctx.config, ctx.cwd);
+    const result = await verifyAllWithRetry(ctx.config, ctx.cwd, { signal: ctx.abortSignal });
     ctx.data.verifyOk = result.ok;
     ctx.data.verifyReason = result.ok ? "" : summarizeFailure(result);
     ctx.data.verifyRecovered = result.recovered ?? [];
@@ -20922,6 +20966,10 @@ var init_verifyWithRetry = __esm({
     verifyWithRetry = async (ctx) => {
       await runVerify(ctx);
       if (ctx.data.verifyOk !== false) return;
+      if (ctx.abortSignal?.aborted) {
+        downgradeActionOnFailure(ctx);
+        return;
+      }
       if (!ctx.data.agentDone) {
         downgradeActionOnFailure(ctx);
         return;
@@ -20958,6 +21006,10 @@ var init_verifyWithRetry = __esm({
         process.stderr.write(`[kody] verify retry crashed: ${err instanceof Error ? err.message : String(err)}
 `);
       }
+      if (ctx.abortSignal?.aborted) {
+        downgradeActionOnFailure(ctx);
+        return;
+      }
       await runVerify(ctx);
       if (ctx.data.verifyOk === true) {
         upgradeActionOnPass(ctx);
@@ -21961,6 +22013,7 @@ async function runImplementation(profileName, input) {
     config,
     verbose: input.verbose,
     quiet: input.quiet,
+    abortSignal: input.abortController?.signal,
     // Phase 5 foundation: seed ctx.data with any preloaded values handed
     // in by a parent (typically a container loop). Loaders that see
     // their field already populated take the fast path and skip the
@@ -22042,6 +22095,10 @@ async function runImplementation(profileName, input) {
   const jobWhyBlock = typeof ctx.data.jobWhy === "string" ? operatorRequestBlock(ctx.data.jobWhy) : null;
   const jobRefBlock = jobReferenceBlock(profileName, profile, ctx.data);
   const invokeAgent = async (prompt) => {
+    if (input.abortController?.signal.aborted) {
+      const reason = input.abortController.signal.reason;
+      throw reason instanceof Error ? reason : new Error("agent invocation aborted");
+    }
     const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path51.isAbsolute(p) ? p : path51.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
@@ -23574,25 +23631,31 @@ async function runGraphCapabilityWorkflow(parent, workflow, capability, base, ch
 
 `
     );
-    result = await runJob(child, {
-      ...base,
-      preloadedData: {
-        ...chainData,
-        runSubjectType: "capability",
-        runSubjectId: step.capability,
-        runSubjectLabel: step.id,
-        workflowStep: step.id,
-        workflowStepIndex: index + 1,
-        workflowExecutionKey: graphWorkflowExecutionKey(
-          base.preloadedData?.workflowExecutionKey,
-          capability.slug,
-          step.id,
-          state.transitionCounts
-        ),
-        workflowStepReason: step.reason,
-        workflowContinueOn: step.continueOn ?? []
-      }
-    });
+    const stepAbort = workflowStepAbortController(base.abortController, step.timeoutSeconds);
+    try {
+      result = await runJob(child, {
+        ...base,
+        abortController: stepAbort.controller,
+        preloadedData: {
+          ...chainData,
+          runSubjectType: "capability",
+          runSubjectId: step.capability,
+          runSubjectLabel: step.id,
+          workflowStep: step.id,
+          workflowStepIndex: index + 1,
+          workflowExecutionKey: graphWorkflowExecutionKey(
+            base.preloadedData?.workflowExecutionKey,
+            capability.slug,
+            step.id,
+            state.transitionCounts
+          ),
+          workflowStepReason: step.reason,
+          workflowContinueOn: step.continueOn ?? []
+        }
+      });
+    } finally {
+      stepAbort.cleanup();
+    }
     finishWorkflowStep(state, step, result);
     mergeWorkflowResults(state, result.capabilityResults);
     if (result.capabilityOutput && typeof result.capabilityOutput === "object" && !Array.isArray(result.capabilityOutput)) {
@@ -23900,6 +23963,24 @@ function canContinueWorkflow(step, outcome) {
   if (!outcome || !step.continueOn || step.continueOn.length === 0) return false;
   return step.continueOn.includes(outcome.type);
 }
+function workflowStepAbortController(parent, timeoutSeconds) {
+  if (!timeoutSeconds) return { controller: parent, cleanup: () => void 0 };
+  const controller = new AbortController();
+  const forwardParentAbort = () => controller.abort(parent?.signal.reason);
+  if (parent?.signal.aborted) forwardParentAbort();
+  else parent?.signal.addEventListener("abort", forwardParentAbort, { once: true });
+  const timer = setTimeout(() => {
+    controller.abort(new Error(`workflow step timed out after ${timeoutSeconds}s`));
+  }, timeoutSeconds * 1e3);
+  timer.unref?.();
+  return {
+    controller,
+    cleanup: () => {
+      clearTimeout(timer);
+      parent?.signal.removeEventListener("abort", forwardParentAbort);
+    }
+  };
+}
 function workflowOutcome(result) {
   return result.taskState?.core.lastOutcome ?? null;
 }

package/dist/implementations/types.ts

@@ -456,6 +456,8 @@ export interface Context {
   /** Stream-output verbosity. */
   verbose?: boolean
   quiet?: boolean
+  /** Cancellation owned by the enclosing job or workflow step. */
+  abortSignal?: AbortSignal
   /** Opaque bag scripts populate during preflight (issue, pr, diff, logs, …). */
   data: Record<string, unknown>
   /** Final output the executor returns. */

package/package.json

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