@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

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

@@ -0,0 +1,241 @@
+import { afterEach, describe, test, expect } from "bun:test";
+import { EventEmitter } from "node:events";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { withConsoleCapture, withTaskTelemetry } from "../task-telemetry";
+
+const COMPLETE = "llm:request:complete";
+const ERROR = "llm:request:error";
+
+function makeHandlers() {
+  return {
+    onComplete: (_m: Record<string, unknown>) => {},
+    onError: (_m: Record<string, unknown>) => {},
+  };
+}
+
+describe("withTaskTelemetry", () => {
+  test("normal return removes both listeners and awaits flush", async () => {
+    const events = new EventEmitter();
+    const handlers = makeHandlers();
+    let flushed = 0;
+    const flush = async () => {
+      flushed += 1;
+    };
+
+    const result = await withTaskTelemetry(events, handlers, flush, async () => {
+      expect(events.listenerCount(COMPLETE)).toBe(1);
+      expect(events.listenerCount(ERROR)).toBe(1);
+      return "value";
+    });
+
+    expect(result).toBe("value");
+    expect(events.listenerCount(COMPLETE)).toBe(0);
+    expect(events.listenerCount(ERROR)).toBe(0);
+    expect(flushed).toBe(1);
+  });
+
+  test("throwing body removes both listeners, flushes, then re-throws the original error", async () => {
+    const events = new EventEmitter();
+    const handlers = makeHandlers();
+    const original = new Error("boom");
+    let flushed = 0;
+    const flush = async () => {
+      flushed += 1;
+    };
+
+    await expect(
+      withTaskTelemetry(events, handlers, flush, async () => {
+        throw original;
+      }),
+    ).rejects.toBe(original);
+
+    expect(events.listenerCount(COMPLETE)).toBe(0);
+    expect(events.listenerCount(ERROR)).toBe(0);
+    expect(flushed).toBe(1);
+  });
+
+  test("a rejecting flush does not replace the body error", async () => {
+    const events = new EventEmitter();
+    const handlers = makeHandlers();
+    const original = new Error("body error");
+    const flush = async () => {
+      throw new Error("flush error");
+    };
+
+    await expect(
+      withTaskTelemetry(events, handlers, flush, async () => {
+        throw original;
+      }),
+    ).rejects.toBe(original);
+
+    expect(events.listenerCount(COMPLETE)).toBe(0);
+    expect(events.listenerCount(ERROR)).toBe(0);
+  });
+
+  test("a rejecting flush does not turn a normal return into a rejection", async () => {
+    const events = new EventEmitter();
+    const handlers = makeHandlers();
+    const flush = async () => {
+      throw new Error("flush error");
+    };
+
+    const result = await withTaskTelemetry(events, handlers, flush, async () => "ok");
+
+    expect(result).toBe("ok");
+    expect(events.listenerCount(COMPLETE)).toBe(0);
+    expect(events.listenerCount(ERROR)).toBe(0);
+  });
+
+  test("cleanup is exactly-once: listener count returns to baseline with no double-remove error", async () => {
+    const events = new EventEmitter();
+    const handlers = makeHandlers();
+
+    // Establish a baseline of pre-existing, unrelated listeners.
+    const otherComplete = () => {};
+    const otherError = () => {};
+    events.on(COMPLETE, otherComplete);
+    events.on(ERROR, otherError);
+    const baselineComplete = events.listenerCount(COMPLETE);
+    const baselineError = events.listenerCount(ERROR);
+
+    await withTaskTelemetry(events, handlers, async () => {}, async () => {
+      // Remove our own listeners mid-body so finally's removeListener is a no-op
+      // on an absent listener — must not throw, must not touch the baseline.
+      events.removeListener(COMPLETE, handlers.onComplete);
+      events.removeListener(ERROR, handlers.onError);
+      return undefined;
+    });
+
+    expect(events.listenerCount(COMPLETE)).toBe(baselineComplete);
+    expect(events.listenerCount(ERROR)).toBe(baselineError);
+  });
+
+  test("flush is thunked: it awaits the current queue, not a value captured at attach", async () => {
+    const events = new EventEmitter();
+    const handlers = makeHandlers();
+    const order: string[] = [];
+
+    // Simulates task-runner's reassigned tokenWriteQueue. Distinct promises so
+    // we can prove which one the thunk awaits.
+    const staleQueue = Promise.resolve().then(() => {
+      order.push("stale-queue");
+    });
+    let queue: Promise<void> = staleQueue;
+
+    const result = await withTaskTelemetry(
+      events,
+      handlers,
+      () => queue,
+      async () => {
+        // Reassign the queue after attach but before finally.
+        queue = staleQueue.then(() => {
+          order.push("latest-queue");
+        });
+        order.push("body");
+        return 42;
+      },
+    );
+
+    expect(result).toBe(42);
+    // The thunk awaited the reassigned queue: "latest-queue" (chained after the
+    // stale one) is the last recorded entry, proving finally-time evaluation.
+    expect(order).toEqual(["body", "stale-queue", "latest-queue"]);
+  });
+});
+
+describe("withConsoleCapture", () => {
+  // Console is process-global state: snapshot the five methods and restore the
+  // exact originals after every test so a leak in one test can't taint another.
+  const originals = {
+    log: console.log,
+    error: console.error,
+    warn: console.warn,
+    info: console.info,
+    debug: console.debug,
+  };
+
+  const tmpFiles: string[] = [];
+  const logPathFor = (name: string) => {
+    const p = join(tmpdir(), `task-telemetry-${name}-${Date.now()}-${Math.random()}.log`);
+    tmpFiles.push(p);
+    return p;
+  };
+
+  afterEach(async () => {
+    console.log = originals.log;
+    console.error = originals.error;
+    console.warn = originals.warn;
+    console.info = originals.info;
+    console.debug = originals.debug;
+    await Promise.all(tmpFiles.splice(0).map((p) => rm(p, { force: true })));
+  });
+
+  test("restores all five console methods to the exact originals on normal return", async () => {
+    await withConsoleCapture(logPathFor("ok"), async () => {
+      // Inside the body the methods are the capture functions, not the originals.
+      expect(console.log).not.toBe(originals.log);
+      return undefined;
+    });
+
+    expect(console.log).toBe(originals.log);
+    expect(console.error).toBe(originals.error);
+    expect(console.warn).toBe(originals.warn);
+    expect(console.info).toBe(originals.info);
+    expect(console.debug).toBe(originals.debug);
+  });
+
+  test("restores all five console methods to the exact originals on body throw", async () => {
+    const boom = new Error("boom");
+
+    await expect(
+      withConsoleCapture(logPathFor("throw"), async () => {
+        throw boom;
+      }),
+    ).rejects.toBe(boom);
+
+    expect(console.log).toBe(originals.log);
+    expect(console.error).toBe(originals.error);
+    expect(console.warn).toBe(originals.warn);
+    expect(console.info).toBe(originals.info);
+    expect(console.debug).toBe(originals.debug);
+  });
+
+  test("a direct double restore is a no-op and cannot reinstate stale originals", async () => {
+    const { captureConsoleOutput } = await import("../task-telemetry");
+    const logPath = logPathFor("double");
+
+    const restore = captureConsoleOutput(logPath);
+    await restore();
+
+    // After the first restore, console.log is the original again.
+    expect(console.log).toBe(originals.log);
+
+    // Simulate a later, unrelated reassignment of console.log by other code.
+    const replacement = () => {};
+    console.log = replacement;
+
+    // A second restore must be a no-op: it must not overwrite the replacement
+    // with the stale captured original.
+    await restore();
+    expect(console.log).toBe(replacement);
+  });
+
+  test("the stage log file receives the captured output", async () => {
+    const logPath = logPathFor("output");
+
+    await withConsoleCapture(logPath, async () => {
+      console.log("plain line");
+      console.error("err line");
+      console.warn("warn line");
+      console.info("info line");
+      console.debug("debug line");
+    });
+
+    const contents = await Bun.file(logPath).text();
+    expect(contents).toBe(
+      "plain line\n[ERROR] err line\n[WARN] warn line\n[INFO] info line\n[DEBUG] debug line\n",
+    );
+  });
+});

package/src/core/__tests__/workspace-root-resolution-guard.test.ts

@@ -0,0 +1,62 @@
+import { describe, test, expect } from "bun:test";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+
+// Source scan modeled on the #327 deleted-config-symbols scan
+// (src/core/__tests__/config.test.ts "source deletion scan" block).
+// Matches the wrong-pattern root-resolution expression:
+//   process.env["PO_ROOT"] ?? process.cwd()   (or single-quote variant)
+// Does NOT match bare process.env["PO_ROOT"] or bare process.cwd() — see AC-8.
+const WRONG_PATTERN = /process\.env\[["']PO_ROOT["']\]\s*\?\?\s*process\.cwd\(\)/;
+
+// AC-8 allowlist: legitimate entry-point consumers of PO_ROOT, relative to src/.
+const ALLOWLIST: ReadonlySet<string> = new Set([
+  "config/paths.ts",
+  "core/config.ts",
+  "cli/index.ts",
+  "core/orchestrator.ts",
+  "core/pipeline-runner.ts",
+  "ui/server/index.ts",
+]);
+
+const SRC_ROOT = join(import.meta.dir, "..", "..");
+
+function walkTs(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      out.push(...walkTs(full));
+      continue;
+    }
+    if (/\.tsx?$/.test(entry)) out.push(full);
+  }
+  return out;
+}
+
+describe("workspace-root resolution guard scan (AC-8)", () => {
+  test("no non-allowlisted src/ file contains the PO_ROOT ?? process.cwd() fallback pattern", () => {
+    const files = walkTs(SRC_ROOT).filter((f) => !f.includes("/__tests__/"));
+    const offending: Array<{ file: string; relPath: string }> = [];
+    for (const file of files) {
+      const content = readFileSync(file, "utf8");
+      if (!WRONG_PATTERN.test(content)) continue;
+      const relPath = relative(SRC_ROOT, file).split("\\").join("/");
+      if (ALLOWLIST.has(relPath)) continue;
+      offending.push({ file, relPath });
+    }
+    if (offending.length > 0) {
+      const lines = offending.map((o) => `  ${o.relPath}: ${WRONG_PATTERN.source}`).join("\n");
+      throw new Error(`Workspace-root fallback expression outside allowlist under src/:\n${lines}`);
+    }
+    expect(offending).toHaveLength(0);
+  });
+
+  test("router.ts distDir cwd use does not trip the pattern", () => {
+    // router.ts uses process.cwd() only for `distDir = options.distDir ?? path.join(process.cwd(), "dist")`
+    // (no process.env["PO_ROOT"]), so it must not match the wrong-pattern expression.
+    const routerTs = join(SRC_ROOT, "ui", "server", "router.ts");
+    const content = readFileSync(routerTs, "utf8");
+    expect(WRONG_PATTERN.test(content)).toBe(false);
+  });
+});

package/src/core/agent-step.ts

@@ -4,6 +4,7 @@ import { cp, mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { createTaskFileIO, generateLogName } from "./file-io.ts";
+import { redactSecrets } from "./redact.ts";
 import { LogEvent, LogFileExtension } from "../config/log-events.ts";
 import { run } from "../harness/index.ts";
 import { startMcpIoServer } from "../harness/mcp-io-server.ts";
@@ -341,7 +342,9 @@ export async function executeAgent(
       permissionMode: "bypass",
       onEvent: (event: HarnessEvent) => {
         observedEvents.push(event);
-        void io.writeLog(logName, JSON.stringify(event.raw) + "\n", {
+        const token = mcpHandle?.connection?.token;
+        const redacted = redactSecrets(event.raw, { secrets: token ? [token] : [] });
+        void io.writeLog(logName, JSON.stringify(redacted) + "\n", {
           mode: "append",
         });
       },

package/src/core/agent-types.ts

@@ -1,4 +1,4 @@
-import type { HarnessName, Usage } from "../harness/index.ts";
+import type { HarnessName, ModelPayload, Usage } from "../harness/index.ts";
 
 export interface McpServerConnection {
   url: string;
@@ -7,7 +7,7 @@ export interface McpServerConnection {
 
 export interface AgentEntryConfig {
   harness: HarnessName;
-  model?: string;
+  model?: ModelPayload | string;
   prompt?: string;
   promptFrom?: string;
   cwd?: string;
@@ -38,8 +38,9 @@ export interface TaskAgentOptions {
   harness: HarnessName;
   /** The instruction handed to the agent. */
   prompt: string;
-  /** Optional model id passed through to the harness verbatim. */
-  model?: string;
+  /** Optional model selection passed through to the harness verbatim — a bare
+   *  model id or a resolved {@link ModelPayload} carrying reasoning effort. */
+  model?: ModelPayload | string;
   /** Working directory for the agent. Defaults to the task directory. */
   cwd?: string;
   /**