@gevezex/gdt 0.4.0 → 0.5.0

package/dist/workflow.js

@@ -3,14 +3,15 @@ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node
 import { relative } from "node:path";
 import { headless } from "./backends/headless.js";
 import { backendFor } from "./backends/index.js";
-import { loadConfig, ROLES, userConfigPath } from "./config.js";
+import { DEFAULT_TURN_MAX_MINUTES, DEFAULT_TURN_TIMEOUT_MINUTES, loadConfig, ROLES, userConfigPath, } from "./config.js";
 import { validateContract } from "./contract.js";
 import { findRepository, herdrPreflight, unsupportedAgentFindings } from "./doctor.js";
 import { changedFiles } from "./git.js";
 import { issueBody, repository } from "./github.js";
 import { loadLocale } from "./locale.js";
-import { alive, lockHolder, paths, readOverrides, readState, writeState } from "./state.js";
-import { cliPath } from "./supervisor.js";
+import { isInvalidRecordReason } from "./protocol.js";
+import { alive, lockHolder, paths, readJson, readOverrides, readState, writeJsonAtomic, writeState, } from "./state.js";
+import { activeReason, cliPath, isHardLimitReason, isTimeoutReason, turnDeadline, turnHardLimit, turnLastActivity, } from "./supervisor.js";
 export const ok = (stdout) => ({ code: 0, stdout, stderr: "" });
 export const fail = (stderr) => ({ code: 1, stdout: "", stderr });
 /** Statuses that need a person or end the workflow: `gdt wait` returns when it reaches one. */
@@ -200,7 +201,12 @@ export function stop(issue, cwd, env) {
 function retryable(state) {
     if (state.status === "failed")
         return true;
-    return state.status === "blocked" && (state.reason.includes("without a visible handoff") || state.reason.includes("already ran"));
+    return (state.status === "blocked" &&
+        (state.reason.includes("without a visible handoff") ||
+            state.reason.includes("already ran") ||
+            isTimeoutReason(state.reason) ||
+            isHardLimitReason(state.reason) ||
+            isInvalidRecordReason(state.reason)));
 }
 /** `gdt retry <n>`: stops the workflow and clears the interrupted turn so `gdt start` runs it again. */
 export function retry(issue, cwd, env) {
@@ -217,6 +223,7 @@ export function retry(issue, cwd, env) {
     if (key !== undefined) {
         rmSync(p.started(key), { force: true });
         rmSync(p.result(key), { force: true });
+        rmSync(p.agent(key), { force: true });
         state.dispatched = state.dispatched.filter((known) => known !== key);
     }
     Object.assign(state, {
@@ -228,6 +235,7 @@ export function retry(issue, cwd, env) {
         pids: { supervisor: null, workers: {} },
     });
     writeState(p, state);
+    rmSync(p.extend, { force: true });
     // Release the lock only now: `gdt wait` must return on the final status, never on the vanished lock.
     releaseAfterStop(p);
     return ok(`Retry prepared for #${issue}. Next: ${describe(state, false).next}\n`);
@@ -235,8 +243,15 @@ export function retry(issue, cwd, env) {
 function blockedHint(issue, reason) {
     if (reason.startsWith("round budget exhausted"))
         return `gdt allow-round ${issue}`;
-    if (reason.includes("without a visible handoff") || reason.includes("already ran"))
+    // AC-4: a turn still active at its hard limit gets more time or is stopped and run again.
+    if (isHardLimitReason(reason))
+        return `gdt extend ${issue} or gdt retry ${issue}`;
+    if (reason.includes("without a visible handoff") ||
+        reason.includes("already ran") ||
+        isTimeoutReason(reason) ||
+        isInvalidRecordReason(reason)) {
         return `gdt retry ${issue}`;
+    }
     if (reason.includes("without a Changelog update"))
         return `add a Changelog entry to issue #${issue}, or revert the body change`;
     return "resolve the cause; the supervisor checks again on every poll";
@@ -268,10 +283,54 @@ export function describe(state, supervisorAlive) {
             return { line: withReason, next: "wait" };
     }
 }
-/** The state as status and wait see it: the pause file reports `paused` until the workflow ends. */
-function effectiveState(p, state) {
+/** A `gdt extend` request for the state's in-flight turn that the supervisor has not applied yet. */
+function pendingExtension(p, state) {
+    const extension = readJson(p.extend);
+    return extension !== null && extension.key === state.inflight?.key ? extension : null;
+}
+/**
+ * The state as status and wait see it: the pause file reports `paused` until the workflow ends, and
+ * AC-5: a pending `gdt extend` reports the turn `running` with its new hard limit before the
+ * supervisor's next poll applies it.
+ */
+function effectiveState(p, state, turnTimeoutMinutes = DEFAULT_TURN_TIMEOUT_MINUTES) {
     const paused = existsSync(p.pause) && state.status !== "stopped" && state.status !== "failed";
-    return paused ? { ...state, status: "paused", reason: "" } : state;
+    if (paused)
+        return { ...state, status: "paused", reason: "" };
+    const extension = pendingExtension(p, state);
+    if (extension === null || state.inflight === null || state.status !== "blocked" || !isHardLimitReason(state.reason))
+        return state;
+    const inflight = { ...state.inflight, hard_limit: extension.hard_limit, at_hard_limit: false };
+    return { ...state, status: "running", reason: activeReason(inflight.role, turnTimeoutMinutes), inflight };
+}
+/** The workflow's turn limits, or the defaults when the config is unreadable. */
+function turnLimits(report) {
+    return report.valid
+        ? { timeout: report.workflow.turn_timeout_minutes, max: report.workflow.turn_max_minutes }
+        : { timeout: DEFAULT_TURN_TIMEOUT_MINUTES, max: DEFAULT_TURN_MAX_MINUTES };
+}
+/** `gdt extend <n>`: grants a turn blocked at its hard limit `turn_max_minutes` more from now (AC-5). */
+export function extend(issue, cwd, env) {
+    const root = findRepository(cwd) ?? cwd;
+    const p = paths(root, issue, env);
+    const state = readState(p);
+    if (state === null)
+        return fail(`No workflow for #${issue}. Next: gdt start ${issue}\n`);
+    const limits = turnLimits(loadConfig(root, env).report);
+    const effective = effectiveState(p, state, limits.timeout);
+    const inflight = state.inflight;
+    if (effective.status !== "blocked" ||
+        !isHardLimitReason(effective.reason) ||
+        inflight === null ||
+        readJson(p.result(inflight.key)) !== null) {
+        const { line, next } = describe(effective, lockHolder(p) !== null);
+        return fail(`Workflow for #${issue} is not waiting at a turn's hard limit (${line}). Next: ${next}\n`);
+    }
+    const hardLimit = new Date(Date.now() + limits.max * 60_000).toISOString();
+    // The supervisor applies the request on its next poll; status and wait report it at once.
+    writeJsonAtomic(p.extend, { key: inflight.key, hard_limit: hardLimit });
+    const { next } = describe(effectiveState(p, state, limits.timeout), lockHolder(p) !== null);
+    return ok(`Extended the ${inflight.role} turn of #${issue}; new hard limit ${hardLimit}. Next: ${next}\n`);
 }
 /** `gdt status <n>`. The pause file reports `paused` even before the supervisor notices it. */
 export function status(issue, cwd, env, json) {
@@ -279,18 +338,29 @@ export function status(issue, cwd, env, json) {
     const p = paths(root, issue, env);
     const state = readState(p);
     if (state === null) {
-        return json
-            ? { code: 1, stdout: `${JSON.stringify({ issue, status: null, next_step: `gdt start ${issue}` }, null, 2)}\n`, stderr: "" }
-            : fail(`No workflow for #${issue}. Next: gdt start ${issue}\n`);
+        // AC-5: the same keys, null without a dispatched turn.
+        const empty = {
+            issue,
+            status: null,
+            turn_started_at: null,
+            turn_deadline: null,
+            turn_last_activity: null,
+            turn_hard_limit: null,
+            next_step: `gdt start ${issue}`,
+        };
+        return json ? { code: 1, stdout: `${JSON.stringify(empty, null, 2)}\n`, stderr: "" } : fail(`No workflow for #${issue}. Next: gdt start ${issue}\n`);
     }
-    const effective = effectiveState(p, state);
+    const { report } = loadConfig(root, env);
+    const limits = turnLimits(report);
+    const effective = effectiveState(p, state, limits.timeout);
     const { line, next } = describe(effective, lockHolder(p) !== null);
     if (!json)
         return ok(`${line}. Next: ${next}\n`);
-    let maxRounds = null;
-    const { report } = loadConfig(root, env);
-    if (report.valid)
-        maxRounds = report.workflow.max_correction_rounds;
+    const maxRounds = report.valid ? report.workflow.max_correction_rounds : null;
+    // The in-flight turn's start, deadline, last activity and hard limit. A result file ends the turn,
+    // so a turn that has finished but still awaits its handoff check reports null for all four.
+    const inflight = effective.inflight !== null && readJson(p.result(effective.inflight.key)) === null ? effective.inflight : null;
+    const turnStart = inflight?.dispatched_at ?? null;
     const out = {
         issue,
         workflow_id: state.workflow_id,
@@ -302,6 +372,11 @@ export function status(issue, cwd, env, json) {
         exit_code: state.exit_code,
         pr_number: state.pr_number,
         open_findings: state.open_findings ?? [],
+        turn_started_at: turnStart,
+        turn_deadline: turnStart === null ? null : turnDeadline(turnStart, limits.timeout).toISOString(),
+        // AC-8: null without a result-less in-flight turn.
+        turn_last_activity: inflight === null ? null : turnLastActivity(inflight),
+        turn_hard_limit: inflight === null ? null : turnHardLimit(inflight, limits.max).toISOString(),
         overrides: readOverrides(p),
         next_step: next,
     };
@@ -316,12 +391,13 @@ export function wait(issue, cwd, env, options) {
     const root = findRepository(cwd) ?? cwd;
     const p = paths(root, issue, env);
     const deadline = options.timeoutSeconds === null ? null : Date.now() + options.timeoutSeconds * 1000;
+    const turnTimeout = turnLimits(loadConfig(root, env).report).timeout;
     for (;;) {
         const state = readState(p);
         // No workflow is status's error path (AC-6); an action status returns at once (AC-1, AC-2).
         if (state === null)
             return status(issue, cwd, env, options.json);
-        const effective = effectiveState(p, state);
+        const effective = effectiveState(p, state, turnTimeout);
         if (ACTION_STATUSES.includes(effective.status))
             return status(issue, cwd, env, options.json);
         // A dead supervisor ends the wait, except while the operator paused it deliberately (AC-4).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gevezex/gdt",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "GitHub issues to merge-ready pull requests, with a developer, tester and reviewer agent.",
   "keywords": [
     "github",