@ryanfw/prompt-orchestration-pipeline 1.2.7 → 1.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server/index.ts",

package/src/config/__tests__/models.test.ts

@@ -15,7 +15,7 @@ import {
 } from "../models";
 import type { ModelConfigEntry } from "../models";
 
-const MODEL_COUNT = 48;
+const MODEL_COUNT = 50;
 const PROVIDER_COUNT = 8;
 
 describe("ModelAlias", () => {
@@ -177,6 +177,21 @@ describe("getModelConfig", () => {
     expect(config!.provider).toBe("openai");
   });
 
+  it("returns configs for Alibaba Qwen 3.6 models", () => {
+    expect(getModelConfig("alibaba:qwen3.6-flash")).toMatchObject({
+      provider: "alibaba",
+      model: "qwen3.6-flash",
+    });
+    expect(getModelConfig("alibaba:qwen3.6-plus")).toMatchObject({
+      provider: "alibaba",
+      model: "qwen3.6-plus",
+    });
+    expect(getModelConfig("alibaba:qwen3.6-max-preview")).toMatchObject({
+      provider: "alibaba",
+      model: "qwen3.6-max-preview",
+    });
+  });
+
   it("returns null for unknown aliases", () => {
     expect(getModelConfig("nonexistent:model")).toBeNull();
     expect(getModelConfig("invalid")).toBeNull();
@@ -218,6 +233,14 @@ describe("FUNCTION_NAME_BY_ALIAS", () => {
   it("has correct value for gemini:flash-2.5-lite", () => {
     expect(FUNCTION_NAME_BY_ALIAS["gemini:flash-2.5-lite"]).toBe("flash25Lite");
   });
+
+  it("has correct values for Alibaba Qwen 3.6 models", () => {
+    expect(FUNCTION_NAME_BY_ALIAS["alibaba:qwen3.6-flash"]).toBe("qwen36Flash");
+    expect(FUNCTION_NAME_BY_ALIAS["alibaba:qwen3.6-plus"]).toBe("qwen36Plus");
+    expect(FUNCTION_NAME_BY_ALIAS["alibaba:qwen3.6-max-preview"]).toBe(
+      "qwen36MaxPreview",
+    );
+  });
 });
 
 describe("PROVIDER_FUNCTIONS", () => {
@@ -248,6 +271,13 @@ describe("PROVIDER_FUNCTIONS", () => {
     }
   });
 
+  it("includes callable paths for Alibaba Qwen 3.6 models", () => {
+    const alibabaPaths = PROVIDER_FUNCTIONS.alibaba.map((entry) => entry.fullPath);
+    expect(alibabaPaths).toContain("llm.alibaba.qwen36Flash");
+    expect(alibabaPaths).toContain("llm.alibaba.qwen36Plus");
+    expect(alibabaPaths).toContain("llm.alibaba.qwen36MaxPreview");
+  });
+
   it("is frozen (top-level)", () => {
     expect(Object.isFrozen(PROVIDER_FUNCTIONS)).toBe(true);
   });

package/src/config/models.ts

@@ -27,7 +27,11 @@ function deepFreeze<T>(obj: T): T {
   if (obj === null || typeof obj !== "object") return obj;
   Object.freeze(obj);
   for (const value of Object.values(obj as object)) {
-    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    if (
+      value !== null &&
+      typeof value === "object" &&
+      !Object.isFrozen(value)
+    ) {
       deepFreeze(value);
     }
   }
@@ -84,8 +88,10 @@ export const ModelAlias = Object.freeze({
   ZAI_GLM_4_5_AIR: "zai:glm-4-5-air",
   ZAI_GLM_4_5_AIR_X: "zai:glm-4-5-air-x",
   // Alibaba (Qwen via DashScope, international/Singapore deployment)
-  ALIBABA_QWEN3_MAX: "alibaba:qwen3-max",
+  ALIBABA_QWEN3_6_MAX_PREVIEW: "alibaba:qwen3.6-max-preview",
   ALIBABA_QWEN3_6_PLUS: "alibaba:qwen3.6-plus",
+  ALIBABA_QWEN3_6_FLASH: "alibaba:qwen3.6-flash",
+  ALIBABA_QWEN3_MAX: "alibaba:qwen3-max",
   ALIBABA_QWEN3_5_PLUS: "alibaba:qwen3.5-plus",
   ALIBABA_QWEN3_5_FLASH: "alibaba:qwen3.5-flash",
   ALIBABA_QWEN_PLUS: "alibaba:qwen-plus",
@@ -342,11 +348,11 @@ const MODEL_CONFIG_RAW: Record<ModelAliasKey, ModelConfigEntry> = {
     tokenCostOutPerMillion: 4.5,
   },
   // Alibaba (Qwen via DashScope, international/Singapore deployment, base tier)
-  "alibaba:qwen3-max": {
+  "alibaba:qwen3.6-max-preview": {
     provider: "alibaba",
-    model: "qwen3-max",
-    tokenCostInPerMillion: 1.2,
-    tokenCostOutPerMillion: 6,
+    model: "qwen3.6-max-preview",
+    tokenCostInPerMillion: 1.3,
+    tokenCostOutPerMillion: 7.8,
   },
   "alibaba:qwen3.6-plus": {
     provider: "alibaba",
@@ -354,6 +360,18 @@ const MODEL_CONFIG_RAW: Record<ModelAliasKey, ModelConfigEntry> = {
     tokenCostInPerMillion: 0.276,
     tokenCostOutPerMillion: 1.651,
   },
+  "alibaba:qwen3.6-flash": {
+    provider: "alibaba",
+    model: "qwen3.6-flash",
+    tokenCostInPerMillion: 0.025,
+    tokenCostOutPerMillion: 1.5,
+  },
+  "alibaba:qwen3-max": {
+    provider: "alibaba",
+    model: "qwen3-max",
+    tokenCostInPerMillion: 1.2,
+    tokenCostOutPerMillion: 6,
+  },
   "alibaba:qwen3.5-plus": {
     provider: "alibaba",
     model: "qwen3.5-plus",
@@ -399,7 +417,9 @@ const MODEL_CONFIG_RAW: Record<ModelAliasKey, ModelConfigEntry> = {
 };
 
 export const MODEL_CONFIG: Readonly<Record<ModelAliasKey, ModelConfigEntry>> =
-  deepFreeze(MODEL_CONFIG_RAW) as Readonly<Record<ModelAliasKey, ModelConfigEntry>>;
+  deepFreeze(MODEL_CONFIG_RAW) as Readonly<
+    Record<ModelAliasKey, ModelConfigEntry>
+  >;
 
 export const VALID_MODEL_ALIASES: ReadonlySet<ModelAliasKey> = new Set(
   Object.keys(MODEL_CONFIG) as ModelAliasKey[],
@@ -409,18 +429,24 @@ export const VALID_MODEL_ALIASES: ReadonlySet<ModelAliasKey> = new Set(
 
 export function aliasToFunctionName(alias: string): string {
   if (typeof alias !== "string") {
-    throw new Error(`Invalid model alias: expected string, got ${typeof alias}`);
+    throw new Error(
+      `Invalid model alias: expected string, got ${typeof alias}`,
+    );
   }
   if (!alias.includes(":")) {
     throw new Error(`Invalid model alias: "${alias}" does not contain a colon`);
   }
   const model = alias.split(":").slice(1).join(":");
-  return model.replace(/[-.]([a-z0-9])/gi, (_, char: string) => char.toUpperCase());
+  return model.replace(/[-.]([a-z0-9])/gi, (_, char: string) =>
+    char.toUpperCase(),
+  );
 }
 
 export function getProviderFromAlias(alias: string): ProviderName {
   if (typeof alias !== "string") {
-    throw new Error(`Invalid model alias: expected string, got ${typeof alias}`);
+    throw new Error(
+      `Invalid model alias: expected string, got ${typeof alias}`,
+    );
   }
   if (!alias.includes(":")) {
     throw new Error(`Invalid model alias: "${alias}" does not contain a colon`);
@@ -430,7 +456,9 @@ export function getProviderFromAlias(alias: string): ProviderName {
 
 export function getModelFromAlias(alias: string): string {
   if (typeof alias !== "string") {
-    throw new Error(`Invalid model alias: expected string, got ${typeof alias}`);
+    throw new Error(
+      `Invalid model alias: expected string, got ${typeof alias}`,
+    );
   }
   if (!alias.includes(":")) {
     throw new Error(`Invalid model alias: "${alias}" does not contain a colon`);
@@ -439,33 +467,38 @@ export function getModelFromAlias(alias: string): string {
 }
 
 export function getModelConfig(alias: string): ModelConfigEntry | null {
-  return (MODEL_CONFIG as Record<string, ModelConfigEntry | undefined>)[alias] ?? null;
+  return (
+    (MODEL_CONFIG as Record<string, ModelConfigEntry | undefined>)[alias] ??
+    null
+  );
 }
 
 // ─── Default Model By Provider ───────────────────────────────────────────────
 
-export const DEFAULT_MODEL_BY_PROVIDER: Readonly<Record<ProviderName, ModelAliasKey>> =
-  Object.freeze({
-    openai: "openai:gpt-5.4",
-    anthropic: "anthropic:sonnet-4-6",
-    gemini: "gemini:flash-2.5",
-    deepseek: "deepseek:v4-flash",
-    moonshot: "moonshot:kimi-k2.6",
-    "claude-code": "claude-code:sonnet",
-    zai: "zai:glm-5-1",
-    alibaba: "alibaba:qwen3-max",
-  } as const);
+export const DEFAULT_MODEL_BY_PROVIDER: Readonly<
+  Record<ProviderName, ModelAliasKey>
+> = Object.freeze({
+  openai: "openai:gpt-5.4",
+  anthropic: "anthropic:sonnet-4-6",
+  gemini: "gemini:flash-2.5",
+  deepseek: "deepseek:v4-flash",
+  moonshot: "moonshot:kimi-k2.6",
+  "claude-code": "claude-code:sonnet",
+  zai: "zai:glm-5-1",
+  alibaba: "alibaba:qwen3-max",
+} as const);
 
 // ─── Function Name Derived Index ─────────────────────────────────────────────
 
-export const FUNCTION_NAME_BY_ALIAS: Readonly<Record<ModelAliasKey, string>> = Object.freeze(
-  Object.fromEntries(
-    (Object.keys(MODEL_CONFIG) as ModelAliasKey[]).map((alias) => [
-      alias,
-      aliasToFunctionName(alias),
-    ]),
-  ) as Record<ModelAliasKey, string>,
-);
+export const FUNCTION_NAME_BY_ALIAS: Readonly<Record<ModelAliasKey, string>> =
+  Object.freeze(
+    Object.fromEntries(
+      (Object.keys(MODEL_CONFIG) as ModelAliasKey[]).map((alias) => [
+        alias,
+        aliasToFunctionName(alias),
+      ]),
+    ) as Record<ModelAliasKey, string>,
+  );
 
 // ─── Provider Functions Index ────────────────────────────────────────────────
 
@@ -487,7 +520,13 @@ export function buildProviderFunctionsIndex(): ProviderFunctionsIndex {
       index[provider] = [];
     }
     index[provider]!.push(
-      Object.freeze({ alias, provider, model, functionName, fullPath }) as ProviderFunctionEntry,
+      Object.freeze({
+        alias,
+        provider,
+        model,
+        functionName,
+        fullPath,
+      }) as ProviderFunctionEntry,
     );
   }
 
@@ -499,7 +538,8 @@ export function buildProviderFunctionsIndex(): ProviderFunctionsIndex {
   return Object.freeze(index) as ProviderFunctionsIndex;
 }
 
-export const PROVIDER_FUNCTIONS: ProviderFunctionsIndex = buildProviderFunctionsIndex();
+export const PROVIDER_FUNCTIONS: ProviderFunctionsIndex =
+  buildProviderFunctionsIndex();
 
 // ─── Module-Load Invariant Validation ────────────────────────────────────────
 
@@ -546,13 +586,19 @@ export function validateModelRegistry(
     }
 
     // Check non-negative token costs
-    if (typeof entry.tokenCostInPerMillion !== "number" || entry.tokenCostInPerMillion < 0) {
+    if (
+      typeof entry.tokenCostInPerMillion !== "number" ||
+      entry.tokenCostInPerMillion < 0
+    ) {
       throw new Error(
         `Model config invariant violation: alias "${alias}" has invalid tokenCostInPerMillion: ` +
           `${entry.tokenCostInPerMillion}`,
       );
     }
-    if (typeof entry.tokenCostOutPerMillion !== "number" || entry.tokenCostOutPerMillion < 0) {
+    if (
+      typeof entry.tokenCostOutPerMillion !== "number" ||
+      entry.tokenCostOutPerMillion < 0
+    ) {
       throw new Error(
         `Model config invariant violation: alias "${alias}" has invalid tokenCostOutPerMillion: ` +
           `${entry.tokenCostOutPerMillion}`,

package/src/core/__tests__/config.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect, afterEach } from "bun:test";
 import { defaultConfig, resetConfig, loadConfig, getConfig, getConfigValue, getPipelineConfig } from "../config";
+import type { AppConfig } from "../config";
 import { mkdtemp, writeFile, mkdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -71,6 +72,84 @@ describe("defaultConfig", () => {
     expect(defaultConfig.ui.port).toBe(3000);
     expect(defaultConfig.taskRunner.maxRefinementAttempts).toBeGreaterThan(0);
   });
+
+  test("taskRunner.maxAttempts defaults to 3", () => {
+    expect(defaultConfig.taskRunner.maxAttempts).toBe(3);
+  });
+});
+
+describe("validateConfig (via loadConfig)", () => {
+  afterEach(() => {
+    resetConfig();
+  });
+
+  test("throws when taskRunner.maxAttempts is 0", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "config-test-"));
+    const configDir = join(dir, "pipeline-config", "test");
+    const tasksDir = join(configDir, "tasks");
+    await mkdir(tasksDir, { recursive: true });
+    await writeFile(join(configDir, "pipeline.json"), JSON.stringify({ name: "test", tasks: ["t1"] }));
+    await writeFile(join(dir, "pipeline-config", "registry.json"), JSON.stringify({
+      pipelines: { test: { configDir, tasksDir } }
+    }));
+    const overrideFile = join(dir, "config.json");
+    await writeFile(overrideFile, JSON.stringify({ taskRunner: { maxAttempts: 0 } }));
+    const origRoot = process.env.PO_ROOT;
+    process.env.PO_ROOT = dir;
+    try {
+      await expect(loadConfig({ configPath: overrideFile })).rejects.toThrow("taskRunner.maxAttempts must be an integer >= 1");
+    } finally {
+      if (origRoot) process.env.PO_ROOT = origRoot; else delete process.env.PO_ROOT;
+      await rm(dir, { recursive: true });
+    }
+  });
+
+  test("throws when taskRunner.maxAttempts is non-integer", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "config-test-"));
+    const configDir = join(dir, "pipeline-config", "test");
+    const tasksDir = join(configDir, "tasks");
+    await mkdir(tasksDir, { recursive: true });
+    await writeFile(join(configDir, "pipeline.json"), JSON.stringify({ name: "test", tasks: ["t1"] }));
+    await writeFile(join(dir, "pipeline-config", "registry.json"), JSON.stringify({
+      pipelines: { test: { configDir, tasksDir } }
+    }));
+    const overrideFile = join(dir, "config.json");
+    await writeFile(overrideFile, JSON.stringify({ taskRunner: { maxAttempts: 2.5 } }));
+    const origRoot = process.env.PO_ROOT;
+    process.env.PO_ROOT = dir;
+    try {
+      await expect(loadConfig({ configPath: overrideFile })).rejects.toThrow("taskRunner.maxAttempts must be an integer >= 1");
+    } finally {
+      if (origRoot) process.env.PO_ROOT = origRoot; else delete process.env.PO_ROOT;
+      await rm(dir, { recursive: true });
+    }
+  });
+});
+
+describe("PO_TASK_MAX_ATTEMPTS env override", () => {
+  afterEach(() => {
+    delete process.env.PO_TASK_MAX_ATTEMPTS;
+    resetConfig();
+  });
+
+  test("getConfig reads PO_TASK_MAX_ATTEMPTS into taskRunner.maxAttempts", () => {
+    process.env.PO_TASK_MAX_ATTEMPTS = "5";
+    resetConfig();
+    const config: AppConfig = getConfig();
+    expect(config.taskRunner.maxAttempts).toBe(5);
+  });
+
+  test("getConfig rejects non-numeric PO_TASK_MAX_ATTEMPTS values", () => {
+    process.env.PO_TASK_MAX_ATTEMPTS = "abc";
+    resetConfig();
+    expect(() => getConfig()).toThrow("PO_TASK_MAX_ATTEMPTS must be an integer >= 1");
+  });
+
+  test("getConfig rejects non-integer PO_TASK_MAX_ATTEMPTS values", () => {
+    process.env.PO_TASK_MAX_ATTEMPTS = "2.5";
+    resetConfig();
+    expect(() => getConfig()).toThrow("PO_TASK_MAX_ATTEMPTS must be an integer >= 1");
+  });
 });
 
 describe("getConfig", () => {

package/src/core/__tests__/pipeline-runner.test.ts

@@ -9,12 +9,14 @@ import { join } from "node:path";
 // deterministic no-ops; config/validation/module-loader are replaced so we
 // don't need a real pipelines directory on disk.
 
+const mockGetConfig = mock(() => ({ taskRunner: { maxAttempts: 3 } }));
+
 mock.module("../config", () => ({
   getPipelineConfig: mock((_slug: string) => ({
     pipelineJsonPath: "/mock/pipeline.json",
     tasksDir: "/mock/tasks",
   })),
-  getConfig: mock(() => ({})),
+  getConfig: mockGetConfig,
   loadConfig: mock(async () => ({})),
   resetConfig: mock(() => {}),
 }));
@@ -95,6 +97,7 @@ const PO_ENV_KEYS = [
   "PO_TASK_REGISTRY",
   "PO_START_FROM_TASK",
   "PO_RUN_SINGLE_TASK",
+  "PO_TASK_MAX_ATTEMPTS",
 ] as const;
 
 interface MultiTaskFixture {
@@ -359,3 +362,267 @@ describe("runPipelineJob — outer-catch failure surfacing", () => {
     expect(stderrContainsMessage).toBe(true);
   });
 });
+
+describe("runPipelineJob — bounded retry loop", () => {
+  const savedEnv: Record<string, string | undefined> = {};
+  const cleanupDirs: string[] = [];
+  let originalSleep: typeof Bun.sleep;
+  let sleepDelays: number[];
+
+  beforeEach(() => {
+    for (const key of Object.keys(savedEnv)) delete savedEnv[key];
+    for (const key of PO_ENV_KEYS) {
+      savedEnv[key] = process.env[key];
+      delete process.env[key];
+    }
+
+    mockRunPipeline.mockClear();
+    mockEnsureTaskSymlinkBridge.mockClear();
+    mockValidateTaskSymlinks.mockClear();
+    mockRepairTaskSymlinks.mockClear();
+    mockCleanupTaskSymlinks.mockClear();
+    mockLoadFreshModule.mockClear();
+    mockGetConfig.mockReset();
+    mockGetConfig.mockImplementation(() => ({ taskRunner: { maxAttempts: 3 } }));
+
+    sleepDelays = [];
+    originalSleep = Bun.sleep;
+    (Bun as unknown as { sleep: (ms: number) => Promise<void> }).sleep = async (ms: number) => {
+      sleepDelays.push(ms);
+    };
+  });
+
+  afterEach(async () => {
+    (Bun as unknown as { sleep: typeof Bun.sleep }).sleep = originalSleep;
+
+    for (const key of PO_ENV_KEYS) {
+      if (savedEnv[key] === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = savedEnv[key];
+      }
+    }
+    process.exitCode = 0;
+
+    await Promise.all(cleanupDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+  });
+
+  function makeFailureResult() {
+    return {
+      ok: false as const,
+      failedStage: "generate",
+      error: {
+        name: "TaskFailure",
+        message: "stub failure",
+        stack: "stack",
+        debug: { stage: "generate", logPath: "/tmp/log" },
+      },
+      logs: [{ stage: "generate", ok: false as const, ms: 5, error: "stub" }],
+      context: {} as Record<string, unknown>,
+    };
+  }
+
+  function makeSuccessResult() {
+    return {
+      ok: true as const,
+      logs: [{ stage: "generate", ok: true as const, ms: 5 }],
+      context: {} as Record<string, unknown>,
+      llmMetrics: [],
+    };
+  }
+
+  test("maxAttempts: 1 — failing task runs once and exits non-zero", async () => {
+    mockGetConfig.mockImplementation(() => ({ taskRunner: { maxAttempts: 1 } }));
+    const fixture = await setupMultiTaskFixture(["task-a"]);
+    cleanupDirs.push(fixture.tmpDir);
+
+    mockRunPipeline.mockImplementation(async () => makeFailureResult() as never);
+
+    const exitCalls: Array<number | undefined> = [];
+    const exitSpy = spyOn(process, "exit").mockImplementation(((code?: number) => {
+      exitCalls.push(code);
+      throw new Error(`__test_exit__:${String(code)}`);
+    }) as typeof process.exit);
+
+    try {
+      await runPipelineJob(fixture.jobId);
+    } catch (e) {
+      if (!(e instanceof Error) || !/^__test_exit__:/.test(e.message)) throw e;
+    } finally {
+      exitSpy.mockRestore();
+    }
+
+    expect(mockRunPipeline.mock.calls.length).toBe(1);
+    expect(sleepDelays).toEqual([]);
+    expect(exitCalls).toContain(1);
+
+    const statusText = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
+    const status = JSON.parse(statusText) as {
+      tasks: Record<string, { state?: string; attempts?: number; restartCount?: number }>;
+    };
+    expect(status.tasks["task-a"]?.state).toBe("failed");
+    expect(status.tasks["task-a"]?.restartCount).toBeUndefined();
+    expect(status.tasks["task-a"]?.attempts).toBe(1);
+  });
+
+  test("maxAttempts: 3 — fails twice then succeeds: three calls, restartCount=2, exits zero", async () => {
+    mockGetConfig.mockImplementation(() => ({ taskRunner: { maxAttempts: 3 } }));
+    const fixture = await setupMultiTaskFixture(["task-a"]);
+    cleanupDirs.push(fixture.tmpDir);
+
+    let call = 0;
+    mockRunPipeline.mockImplementation(async () => {
+      call += 1;
+      return (call <= 2 ? makeFailureResult() : makeSuccessResult()) as never;
+    });
+
+    const exitCalls: Array<number | undefined> = [];
+    const exitSpy = spyOn(process, "exit").mockImplementation(((code?: number) => {
+      exitCalls.push(code);
+      throw new Error(`__test_exit__:${String(code)}`);
+    }) as typeof process.exit);
+
+    try {
+      await runPipelineJob(fixture.jobId);
+    } catch (e) {
+      if (!(e instanceof Error) || !/^__test_exit__:/.test(e.message)) throw e;
+    } finally {
+      exitSpy.mockRestore();
+    }
+
+    expect(mockRunPipeline.mock.calls.length).toBe(3);
+    expect(sleepDelays).toEqual([2000, 4000]);
+    expect(exitCalls).toEqual([]);
+
+    const statusText = await readFile(fixture.statusPath, "utf-8");
+    const status = JSON.parse(statusText) as {
+      tasks: Record<string, { state?: string; attempts?: number; restartCount?: number }>;
+    };
+    expect(status.tasks["task-a"]?.state).toBe("done");
+    expect(status.tasks["task-a"]?.attempts).toBe(3);
+    expect(status.tasks["task-a"]?.restartCount).toBe(2);
+  });
+
+  test("maxAttempts: 3 — always fails: three calls, restartCount=2, exits non-zero", async () => {
+    mockGetConfig.mockImplementation(() => ({ taskRunner: { maxAttempts: 3 } }));
+    const fixture = await setupMultiTaskFixture(["task-a"]);
+    cleanupDirs.push(fixture.tmpDir);
+
+    mockRunPipeline.mockImplementation(async () => makeFailureResult() as never);
+
+    const exitCalls: Array<number | undefined> = [];
+    const exitSpy = spyOn(process, "exit").mockImplementation(((code?: number) => {
+      exitCalls.push(code);
+      throw new Error(`__test_exit__:${String(code)}`);
+    }) as typeof process.exit);
+
+    try {
+      await runPipelineJob(fixture.jobId);
+    } catch (e) {
+      if (!(e instanceof Error) || !/^__test_exit__:/.test(e.message)) throw e;
+    } finally {
+      exitSpy.mockRestore();
+    }
+
+    expect(mockRunPipeline.mock.calls.length).toBe(3);
+    expect(sleepDelays).toEqual([2000, 4000]);
+    expect(exitCalls).toContain(1);
+
+    const statusText = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
+    const status = JSON.parse(statusText) as {
+      tasks: Record<string, { state?: string; attempts?: number; restartCount?: number }>;
+    };
+    expect(status.tasks["task-a"]?.state).toBe("failed");
+    expect(status.tasks["task-a"]?.attempts).toBe(3);
+    expect(status.tasks["task-a"]?.restartCount).toBe(2);
+  });
+
+  test("interim status between attempts: state=running, no failedStage/error, restartCount incremented", async () => {
+    mockGetConfig.mockImplementation(() => ({ taskRunner: { maxAttempts: 3 } }));
+    const fixture = await setupMultiTaskFixture(["task-a"]);
+    cleanupDirs.push(fixture.tmpDir);
+
+    let call = 0;
+    let interimSnapshot: { state?: string; attempts?: number; failedStage?: unknown; error?: unknown; restartCount?: number } | undefined;
+
+    // Capture the snapshot from disk *during* the second call (after the first failure
+    // and the interim writeJobStatus). At call #2 we read tasks-status.json, then
+    // return success so the test ends cleanly.
+    mockRunPipeline.mockImplementation(async () => {
+      call += 1;
+      if (call === 2) {
+        const text = await readFile(join(fixture.jobDir, "tasks-status.json"), "utf-8");
+        const parsed = JSON.parse(text) as {
+          tasks: Record<string, { state?: string; attempts?: number; failedStage?: unknown; error?: unknown; restartCount?: number }>;
+        };
+        interimSnapshot = parsed.tasks["task-a"];
+        return makeSuccessResult() as never;
+      }
+      return makeFailureResult() as never;
+    });
+
+    const exitSpy = spyOn(process, "exit").mockImplementation(((code?: number) => {
+      throw new Error(`__test_exit__:${String(code)}`);
+    }) as typeof process.exit);
+
+    try {
+      await runPipelineJob(fixture.jobId);
+    } catch (e) {
+      if (!(e instanceof Error) || !/^__test_exit__:/.test(e.message)) throw e;
+    } finally {
+      exitSpy.mockRestore();
+    }
+
+    expect(interimSnapshot).toBeDefined();
+    expect(interimSnapshot?.state).toBe("running");
+    expect(interimSnapshot?.failedStage).toBeUndefined();
+    expect(interimSnapshot?.error).toBeUndefined();
+    expect(interimSnapshot?.attempts).toBe(2);
+    expect(interimSnapshot?.restartCount).toBe(1);
+  });
+
+  test("missing taskRunner config falls back to the default retry cap", async () => {
+    mockGetConfig.mockImplementation(() => ({} as never));
+    const fixture = await setupMultiTaskFixture(["task-a"]);
+    cleanupDirs.push(fixture.tmpDir);
+
+    let call = 0;
+    mockRunPipeline.mockImplementation(async () => {
+      call += 1;
+      return (call === 1 ? makeFailureResult() : makeSuccessResult()) as never;
+    });
+
+    await runPipelineJob(fixture.jobId);
+
+    expect(mockRunPipeline.mock.calls.length).toBe(2);
+    expect(sleepDelays).toEqual([2000]);
+  });
+
+  test("exceptions from runPipeline bypass result retries and surface through outer failure handling", async () => {
+    mockGetConfig.mockImplementation(() => ({ taskRunner: { maxAttempts: 3 } }));
+    const fixture = await setupMultiTaskFixture(["task-a"]);
+    cleanupDirs.push(fixture.tmpDir);
+
+    mockRunPipeline.mockImplementation(async () => {
+      throw new Error("task module exploded");
+    });
+
+    const exitCalls: Array<number | undefined> = [];
+    const exitSpy = spyOn(process, "exit").mockImplementation(((code?: number) => {
+      exitCalls.push(code);
+      throw new Error(`__test_exit__:${String(code)}`);
+    }) as typeof process.exit);
+
+    try {
+      await runPipelineJob(fixture.jobId);
+    } catch (e) {
+      if (!(e instanceof Error) || !/^__test_exit__:/.test(e.message)) throw e;
+    } finally {
+      exitSpy.mockRestore();
+    }
+
+    expect(mockRunPipeline.mock.calls.length).toBe(1);
+    expect(sleepDelays).toEqual([]);
+    expect(exitCalls).toContain(1);
+  });
+});

package/src/core/__tests__/task-runner.test.ts

@@ -91,11 +91,10 @@ describe("task-runner does not write job-level status fields", () => {
 
     const status = JSON.parse(await readFile(path.join(workDir, "tasks-status.json"), "utf8")) as StatusSnapshot;
 
-    // Job-level lifecycle fields must remain untouched by task-runner.
+    // Lifecycle fields are owned by pipeline-runner; task-runner persists progress only.
     expect(status.state).toBe("pending");
     expect(status.current).toBeNull();
     expect(status.currentStage).toBeNull();
-    expect(status.progress).toBe(100);
   });
 
   it("does not set snapshot.state on task failure", async () => {