sequant 2.8.0 → 2.10.0

package/dist/src/lib/workflow/run-log-schema.js

@@ -79,13 +79,19 @@ export const ErrorContextSchema = z.object({
     stdoutTail: z.array(z.string()),
     /** Process exit code */
     exitCode: z.number().int().optional(),
-    /** Classified error category (legacy, kept for backwards compatibility) */
+    /**
+     * Classified error category (legacy, kept for backwards compatibility).
+     * Keep in sync with `ERROR_CATEGORIES` in `error-classifier.ts` —
+     * `rate_limit` / `billing` added by #761 AC-6.
+     */
     category: z.enum([
         "context_overflow",
         "api_error",
         "hook_failure",
         "build_error",
         "timeout",
+        "rate_limit",
+        "billing",
         "unknown",
     ]),
     /** Typed error class name (AC-8), e.g. "ApiError", "BuildError" */
@@ -174,6 +180,20 @@ export const IssueLogSchema = z.object({
     phases: z.array(PhaseLogSchema),
     /** Total execution time in seconds */
     totalDurationSeconds: z.number().nonnegative(),
+    /**
+     * Set when this issue never finished because the run was terminated from
+     * outside (#856). Reuses the `"failure"` status — additive boolean rather
+     * than a new `IssueStatus` enum value, matching the `capped` precedent
+     * above, so the persisted-log schema stays stable at `version: 1`.
+     *
+     * Without this, a run killed mid-flight persisted as `success`: `startIssue`
+     * seeds `status: "success"` and only `logPhase` ever revises it, so an issue
+     * whose first phase never completed was written out as a pass with an empty
+     * `phases[]`.
+     */
+    aborted: z.boolean().optional(),
+    /** Human-readable cause of the abort (e.g. `terminated by SIGTERM`). */
+    abortReason: z.string().optional(),
     /** PR number if created after successful QA */
     prNumber: z.number().int().positive().optional(),
     /** PR URL if created after successful QA */
@@ -206,6 +226,21 @@ export const RunSummarySchema = z.object({
     passed: z.number().int().nonnegative(),
     /** Number of issues that failed */
     failed: z.number().int().nonnegative(),
+    /**
+     * Number of issues that ended `partial` — timed out with no genuine failure
+     * and no recovery (#766). Given its own bucket so an all-partial run no longer
+     * vanishes from both `passed` and `failed` (the `0 passed · 0 failed` bug).
+     * `.default(0)` keeps logs written before this field parseable.
+     */
+    partial: z.number().int().nonnegative().default(0),
+    /**
+     * Number of issues cut short by an external signal (#856). A sub-count of
+     * `failed`, not a fourth disjoint bucket — aborted issues carry
+     * `status: "failure"` so existing consumers keep working, and this field
+     * says whether the failure was the run's own or something killing it.
+     * `.default(0)` keeps logs written before this field parseable.
+     */
+    aborted: z.number().int().nonnegative().default(0),
     /** Total execution time in seconds */
     totalDurationSeconds: z.number().nonnegative(),
 });
@@ -233,6 +268,11 @@ export const RunLogSchema = z.object({
     startCommit: z.string().optional(),
     /** Git commit SHA at run end (AC-2) */
     endCommit: z.string().optional(),
+    /**
+     * Signal that terminated the run, when it ended by external signal rather
+     * than by finishing (#856). Present iff at least one issue is `aborted`.
+     */
+    abortedBy: z.string().optional(),
 });
 /**
  * Default log directory paths
@@ -263,7 +303,9 @@ export function generateLogFilename(runId, startTime) {
  */
 export function createEmptyRunLog(config, options) {
     const runId = randomUUID();
-    const startTime = new Date().toISOString();
+    // #867: use the caller-supplied run origin when provided so the log's wall
+    // clock shares the orchestrator's start; fall back to now for standalone use.
+    const startTime = (options?.startTime ?? new Date()).toISOString();
     return {
         version: 1,
         runId,
@@ -274,6 +316,8 @@ export function createEmptyRunLog(config, options) {
             totalIssues: 0,
             passed: 0,
             failed: 0,
+            partial: 0,
+            aborted: 0,
             totalDurationSeconds: 0,
         },
         startCommit: options?.startCommit,
@@ -326,6 +370,14 @@ export function finalizeRunLog(runLog, options) {
     const totalDurationSeconds = (endTime.getTime() - startTime.getTime()) / 1000;
     const passed = runLog.issues.filter((i) => i.status === "success").length;
     const failed = runLog.issues.filter((i) => i.status === "failure").length;
+    // #766: `partial` gets its own bucket so an all-partial run isn't counted as
+    // `0 passed · 0 failed` — it landed in neither before.
+    const partial = runLog.issues.filter((i) => i.status === "partial").length;
+    // #856: aborted issues are also counted in `failed` (they carry
+    // `status: "failure"`); this is the sub-count that says *why* they failed,
+    // so a run killed from outside is distinguishable from one whose phases
+    // genuinely failed.
+    const aborted = runLog.issues.filter((i) => i.aborted).length;
     return {
         ...runLog,
         endTime: endTime.toISOString(),
@@ -333,8 +385,46 @@ export function finalizeRunLog(runLog, options) {
             totalIssues: runLog.issues.length,
             passed,
             failed,
+            partial,
+            aborted,
             totalDurationSeconds,
         },
         endCommit: options?.endCommit ?? runLog.endCommit,
+        ...((options?.abortedBy ?? runLog.abortedBy) && {
+            abortedBy: options?.abortedBy ?? runLog.abortedBy,
+        }),
     };
 }
+/**
+ * Derive an issue's overall log status from its phase log entries (#766).
+ *
+ * Phases are appended in execution order, so the last entry for a given phase
+ * name is its latest attempt — that attempt wins. This lets a `timeout`/
+ * `failure` that a later quality-loop iteration recovers from de-escalate to
+ * `success`, keeping the JSON log consistent with the live card and summary
+ * table (AC-3/AC-5). `loop` is auxiliary recovery and never determines the
+ * verdict (mirrors the live-card rule); an unrecovered failure still leaves a
+ * non-loop phase failed. Priority among latest attempts: failure > timeout >
+ * success.
+ *
+ * An issue with no phase entries is a `failure`, not a `success` (#856). The
+ * only way to reach that state is for `startIssue` to have run while no phase
+ * ever completed — i.e. the run was cut short. Returning `success` there is
+ * what let a SIGTERM'd run persist as a pass with an empty `phases[]`.
+ */
+export function deriveIssueLogStatus(phases) {
+    const latest = new Map();
+    for (const p of phases) {
+        if (p.phase === "loop")
+            continue;
+        latest.set(p.phase, p.status);
+    }
+    const statuses = [...latest.values()];
+    if (statuses.length === 0)
+        return "failure";
+    if (statuses.some((s) => s === "failure"))
+        return "failure";
+    if (statuses.some((s) => s === "timeout"))
+        return "partial";
+    return "success";
+}

package/dist/src/lib/workflow/run-orchestrator.d.ts

@@ -13,6 +13,7 @@ import { LogWriter } from "./log-writer.js";
 import { StateManager } from "./state-manager.js";
 import { ShutdownManager } from "../shutdown.js";
 import type { LockFile } from "../locks/index.js";
+import { type ChainResumePlan } from "./chain-resume.js";
 import { WorkflowEventEmitter } from "./event-emitter.js";
 import type { SequantSettings } from "../settings.js";
 /**
@@ -55,6 +56,12 @@ export interface OrchestratorConfig {
     packageManager?: string;
     /** Base branch for rebase/PR targets */
     baseBranch?: string;
+    /**
+     * Chain resume plan (#760). Present only when re-running a `--chain` batch
+     * whose completed prefix is being skipped. Drives the first active link's
+     * rebase onto the last completed link's committed tip in `executeSequential`.
+     */
+    chainResume?: ChainResumePlan;
     /** Per-phase progress callback (parallel mode) */
     onProgress?: ProgressCallback;
     /** #672 AC-2: phase-plan callback forwarded into per-issue contexts. */
@@ -112,6 +119,13 @@ export interface ResolvedRun {
     config: ExecutionConfig;
     /** Parsed + dep-sorted issue numbers (pre-state-guard) */
     issueNumbers: number[];
+    /**
+     * Raw CLI issue order BEFORE `sortByDependencies` reorders it (#762).
+     * The chain content pre-flight must compare against this order — comparing
+     * against the dep-sorted `issueNumbers` would make the dependency-order and
+     * file-overlap-order checks dead code, since the sorter already fixed them.
+     */
+    rawIssueOrder: number[];
     /** Resolved batches if --batch specified, else null */
     batches: number[][] | null;
     /** Resolved base branch (CLI → settings → auto-detect → "main") */
@@ -150,6 +164,13 @@ export interface RunResult {
     mergedOptions: RunOptions;
     /** Log writer (for reflection access) */
     logWriter: LogWriter | null;
+    /**
+     * Run wall-clock duration in seconds, computed once by the orchestrator from
+     * the run's start and end (#867). The post-run summary reads THIS value rather
+     * than re-summing per-issue durations — under `--parallel` that sum
+     * double-counts overlapping issues and over-reports by ~the concurrency factor.
+     */
+    wallClockDurationSeconds: number;
 }
 /**
  * CLI-free workflow execution engine.
@@ -174,6 +195,18 @@ export declare class RunOrchestrator {
      * listening (#504, AC-3).
      */
     getEmitter(): WorkflowEventEmitter;
+    /**
+     * The wrapped progress sink handed to the batch executor — every phase
+     * lifecycle event enters the orchestrator through here.
+     *
+     * @internal Exported for testing only. `applyProgressEvent` is private and
+     * depends on `issueStates`/`phaseStartTimes`/`emitter`, so there is no way
+     * to exercise its branches short of a full `run()`. Without this seam the
+     * #804 `waiting` branch would be untestable — and an untested `waiting`
+     * branch is not cosmetic: falling through to the complete/failed handler
+     * marks a merely-paused phase `failed` and emits `phase_failed`.
+     */
+    getProgressCallback(): ProgressCallback;
     /**
      * Point-in-time view of the entire run.
      *