@yagni-app/code-staging 1.2.2-staging.1530.1 → 1.2.2-staging.1555.1

package/dist/extension/pipeline/resilience.d.ts

@@ -37,6 +37,8 @@ export type RunStageFn = (stage: PipelineStage, ctx: {
     lens?: ReviewLens;
     grounded?: boolean;
 }, deps: RunStageDeps) => Promise<StageResult>;
+/** True when at least {@link MODEL_BOUND_SHARE} of a stage's elapsed time was spent outside tools. */
+export declare function isModelBound(elapsedMs: number, toolMs: number): boolean;
 /** One telemetry record per attempt (routed through the orchestrator logger). */
 export interface ResilienceAttemptRecord {
     stageId: string;
@@ -54,6 +56,10 @@ export interface ResilienceAttemptRecord {
     outcome: "ok" | "transient" | "fatal" | "timeout" | "aborted";
     /** Which timer fired, when the attempt timed out. */
     timeoutKind?: "idle" | "wall";
+    /** On a timeout: ms the attempt spent with a tool running (the rest went to the model). */
+    toolMs?: number;
+    /** On a timeout: whether the model, not tools, held most of the attempt's time. */
+    modelBound?: boolean;
     exitCode: number;
     stopReason?: string;
     elapsedMs: number;

package/dist/extension/pipeline/resilience.js

@@ -32,7 +32,34 @@ const WRITE_STAGE_IDS = ["implement", "fix"];
 /** Honest message stamped on a stage we aborted for exceeding its time budget. */
 const TIMEOUT_MESSAGE = "stage exceeded its idle or wall-clock timeout";
 const WALL_TIMEOUT_MESSAGE = "stage exceeded its wall-clock timeout";
+/**
+ * The wall clock fired while most of the stage's time went to waiting on model
+ * responses rather than running tools: a slow model, not a stage too big for one
+ * pass. Keeps {@link WALL_TIMEOUT_MESSAGE} as its prefix so a reader that only
+ * knows the plain sentence still reads it as a wall-clock stop.
+ */
+const WALL_TIMEOUT_MODEL_MESSAGE = `${WALL_TIMEOUT_MESSAGE} while waiting on the model`;
+/**
+ * Share of a timed-out stage's elapsed time outside tools at which the model,
+ * not the work, used the clock. The non-tool time also holds the child's
+ * startup and its teardown after the abort (seconds), which is noise against a
+ * real wall window of many minutes.
+ */
+const MODEL_BOUND_SHARE = 0.6;
 const IDLE_TIMEOUT_MESSAGE = "stage exceeded its idle timeout";
+/** True when at least {@link MODEL_BOUND_SHARE} of a stage's elapsed time was spent outside tools. */
+export function isModelBound(elapsedMs, toolMs) {
+    if (elapsedMs <= 0)
+        return false;
+    return (elapsedMs - toolMs) / elapsedMs >= MODEL_BOUND_SHARE;
+}
+function timeoutMessage(kind, modelBound) {
+    if (kind === "wall")
+        return modelBound ? WALL_TIMEOUT_MODEL_MESSAGE : WALL_TIMEOUT_MESSAGE;
+    if (kind === "idle")
+        return IDLE_TIMEOUT_MESSAGE;
+    return TIMEOUT_MESSAGE;
+}
 /** stderr fingerprints of a transient transport/provider blip worth retrying. */
 const TRANSIENT_STDERR = /\b429\b|\b5\d\d\b|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up/i;
 /**
@@ -117,6 +144,11 @@ export function withResilience(base, policy, opts = {}) {
             // and re-arms instead of aborting; the wall-clock timer stays the
             // backstop for a tool that is genuinely hung.
             let inFlightTools = 0;
+            // Time spent with at least one tool running. The rest of the stage's
+            // elapsed time is the model thinking or streaming, which is what tells a
+            // slow model apart from a stage that had too much work to do.
+            let toolMs = 0;
+            let toolsBusySince;
             let idleTimer;
             const armIdle = () => {
                 if (idleTimer)
@@ -137,10 +169,18 @@ export function withResilience(base, policy, opts = {}) {
             const originalOnEvent = deps.onEvent;
             const onEvent = (ev) => {
                 sawAnyEvent = true;
-                if (ev.type === "tool_execution_start")
+                if (ev.type === "tool_execution_start") {
+                    if (inFlightTools === 0)
+                        toolsBusySince = now();
                     inFlightTools += 1;
-                else if (ev.type === "tool_execution_end")
+                }
+                else if (ev.type === "tool_execution_end") {
                     inFlightTools = Math.max(0, inFlightTools - 1);
+                    if (inFlightTools === 0 && toolsBusySince !== undefined) {
+                        toolMs += now() - toolsBusySince;
+                        toolsBusySince = undefined;
+                    }
+                }
                 armIdle(); // reset the idle window on every live event
                 originalOnEvent?.(ev);
             };
@@ -154,6 +194,10 @@ export function withResilience(base, policy, opts = {}) {
                     clearTimeout(idleTimer);
             }
             const elapsedMs = now() - startedAt;
+            // A tool still running when the stage ended counts up to now.
+            if (toolsBusySince !== undefined)
+                toolMs += now() - toolsBusySince;
+            const modelBound = isModelBound(elapsedMs, toolMs);
             const callerAborted = callerSignal?.aborted === true;
             const record = (outcome, willRetry) => {
                 telemetry?.({
@@ -164,6 +208,7 @@ export function withResilience(base, policy, opts = {}) {
                     attempt,
                     outcome,
                     ...(timedOut && timeoutKind ? { timeoutKind } : {}),
+                    ...(timedOut ? { toolMs, modelBound } : {}),
                     exitCode: last.exitCode,
                     ...(last.stopReason ? { stopReason: last.stopReason } : {}),
                     elapsedMs,
@@ -179,9 +224,8 @@ export function withResilience(base, policy, opts = {}) {
                 record("ok", false);
                 return last;
             }
-            if (timedOut) {
-                last.errorMessage = timeoutKind === "wall" ? WALL_TIMEOUT_MESSAGE : timeoutKind === "idle" ? IDLE_TIMEOUT_MESSAGE : TIMEOUT_MESSAGE;
-            }
+            if (timedOut)
+                last.errorMessage = timeoutMessage(timeoutKind, modelBound);
             const transient = classifyTransient(last, timedOut);
             // A wall-clock exhaustion is a "task too big" signal, not a stall: a
             // lane that opts out (subagents) fails honestly instead of re-burning

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.2-staging.1530.1",
+  "version": "1.2.2-staging.1555.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "cbe4409f1c4a9b1916438a3899957168c5c30ac5"
+  "yagniSourceSha": "8e8cae193cda58ced857dd7c5f832e83d29f3e5b"
 }