pi-orchestrator-config 4.3.11 → 4.3.12

package/extensions/orchestrator/async-agents.ts

@@ -13,8 +13,7 @@ import { fileURLToPath } from "node:url";
 const require = createRequire(import.meta.url);
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { AgentConfig } from "./agents.js";
-import { discoverAgents } from "./agents.js";
+import type { AgentConfig, AgentDiscoveryResult } from "./agents.js";
 import { resolveAgentModelProvider } from "./resolve-agent-model.js";
 import { getPiInvocation, getProjectTmpDir, parseProcStartTime, djb2Hash } from "./utils.js";
 import { addReviewerPending, recordReviewerResult, countFindings, readReviewState, markTestsPassed, markTestsFailed } from "./pi-config-review-state.js";
@@ -22,7 +21,8 @@ import {
   getMainBranch,
 } from "./git-helpers.js";
 import { waitForResultFiles } from "./async-wait.js";
-import { openAsyncStatusOverlay } from "./async-status-ui.js";
+import { formatAsyncResultOutput, reviewerOutputArchivePath } from "./async-result-format.js";
+import { cleanupReviewerOutputArchives } from "./reviewer-output-archive.js";
 const log = createLogger("async_agents");
 
 export { autoCompleteTask, autoMarkInProgress } from "./task-lifecycle.js";
@@ -117,6 +117,10 @@ export function formatDuration(ms: number): string {
 export function registerAsyncAgents(
   pi: ExtensionAPI,
   terminalNotify: (title: string, body: string) => void,
+  runtime: {
+    spawnProcess?: typeof spawn;
+    discoverAgents?: (cwd: string, scope: "both") => Pick<AgentDiscoveryResult, "agents">;
+  } = {},
 ): {
   spawnAsyncAgent: (agentName: string, task: string, cwd: string, agents: AgentConfig[], options?: { fireAndForget?: boolean; name?: string; parentModelId?: string; parentProvider?: string; groupId?: string; taskId?: string; onComplete?: () => void; persistSession?: boolean; explicit?: { model?: string; provider?: string } }) => { id: string; error?: string; model?: string };
   killAsyncAgent: (target: string) => { killed: string[]; errors: string[] };
@@ -125,6 +129,28 @@ export function registerAsyncAgents(
   let PROJECT_TMP_DIR = path.join(process.cwd(), ".pi", "tmp"); // Computed only; created on session_start
   let ASYNC_RESULTS_DIR = ""; // Set on session_start to project-scoped dir
 
+  function resultOutputPath(job: Pick<AsyncJob, "agent" | "id" | "workerDir">): string {
+    const workerOutputPath = path.join(job.workerDir, "output.log");
+    const outputPath = job.agent.startsWith("code-reviewer-")
+      ? reviewerOutputArchivePath(PROJECT_TMP_DIR, job.id)
+      : workerOutputPath;
+    log.debug("async_result_output_path", { agent: job.agent, archived: outputPath !== workerOutputPath });
+    return outputPath;
+  }
+
+  function preserveReviewerOutput(job: Pick<AsyncJob, "agent" | "id">, output: string): void {
+    if (!job.agent.startsWith("code-reviewer-")) return;
+    const outputPath = reviewerOutputArchivePath(PROJECT_TMP_DIR, job.id);
+    try {
+      fs.mkdirSync(path.dirname(outputPath), { recursive: true, mode: 0o700 });
+      fs.writeFileSync(outputPath, output, { mode: 0o600 });
+      fs.chmodSync(outputPath, 0o600);
+      cleanupReviewerOutputArchives(path.dirname(outputPath));
+      log.info("preserved_reviewer_output", { agent: job.agent, bytes: Buffer.byteLength(output, "utf8") });
+    } catch (e: any) {
+      log.error(`preserve reviewer output failed for ${job.id}: ${e?.message}`);
+    }
+  }
 
   const asyncState: AsyncState = {
     jobs: new Map(),
@@ -392,9 +418,14 @@ export function registerAsyncAgents(
                 log.error(`reconcile: auto-complete failed for task #${safeTaskId}: ${e?.message}`);
               }
             }
-            // Enforce same output-length budget as processResultFile
-            const maxOutput = 3000 - autoCompleteError.length;
-            const output = (job.output || "").slice(0, Math.max(maxOutput, 500));
+            // Enforce same output-length budget as processResultFile.
+            const maxOutput = Math.max(3000 - autoCompleteError.length, 500);
+            const output = formatAsyncResultOutput(
+              job.agent,
+              job.output || "",
+              resultOutputPath(job),
+              maxOutput,
+            );
             // Emit lifecycle events
             if (job.status === "complete") {
               pi.events.emit("subagents:completed", { id: job.id, result: job.output || "" });
@@ -481,6 +512,7 @@ export function registerAsyncAgents(
       try {
         const data = JSON.parse(fs.readFileSync(rp, "utf-8"));
         j.output = data.output;
+        preserveReviewerOutput(j, typeof data.output === "string" ? data.output : JSON.stringify(data.output ?? ""));
         j.exitCode = data.exitCode;
         j.durationMs = data.durationMs;
         if (data.success !== undefined) j.status = data.success ? "complete" : "failed";
@@ -549,7 +581,11 @@ export function registerAsyncAgents(
       if (j.fireAndForget) { j.delivered = true; continue; }
       const resultStatus = j.status === "complete" ? "✅ completed" : "❌ failed";
       const displayName = j.name || j.agent;
-      const output = (j.output || "").slice(0, 3000);
+      const output = formatAsyncResultOutput(
+        j.agent,
+        j.output || "",
+        resultOutputPath(j),
+      );
       let autoCompleteError = "";
       // Auto-complete linked task directly in the store file (no AI involvement)
       if (j.taskId && j.taskId !== "-1" && j.status === "complete" && j.cwd) {
@@ -639,6 +675,7 @@ export function registerAsyncAgents(
       job.exitCode = data.exitCode;
       job.durationMs = data.durationMs;
       job.updatedAt = Date.now();
+      preserveReviewerOutput(job, typeof data.output === "string" ? data.output : JSON.stringify(data.output ?? ""));
 
       // Notify terminal per-agent (lightweight, non-conversational)
       const displayName = job.name || data.agent;
@@ -703,7 +740,11 @@ export function registerAsyncAgents(
       try {
         const statusPath = path.join(job.workerDir, "status.json");
         const existing = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
-        existing.output = (data.output || "").slice(0, 3000);
+        existing.output = formatAsyncResultOutput(
+          job.agent,
+          data.output || "",
+          resultOutputPath(job),
+        );
         existing.state = job.status;
         existing.exitCode = job.exitCode;
         existing.durationMs = job.durationMs;
@@ -748,8 +789,13 @@ export function registerAsyncAgents(
             log.error(`auto-complete failed for task #${job.taskId}: ${e?.message}`);
           }
         }
-        const maxOutput = 3000 - autoCompleteError.length;
-        const output = (data.output || "").slice(0, Math.max(maxOutput, 500));
+        const maxOutput = Math.max(3000 - autoCompleteError.length, 500);
+        const output = formatAsyncResultOutput(
+          job.agent,
+          data.output || "",
+          resultOutputPath(job),
+          maxOutput,
+        );
         const pContent = `## Async Agent Result: ${displayName} ${resultStatus}\n\nTask: ${data.task}\nDuration: ${formatDuration(data.durationMs)}\n\n${output}${autoCompleteError}`;
         if (wasAlreadyDelivered(job.id)) {
           // Already delivered in previous lifecycle — skip send AND onComplete
@@ -815,7 +861,7 @@ export function registerAsyncAgents(
         setTimeout(() => processResultFile(resultPath), 100);
       });
       if (asyncState.watcher.unref) asyncState.watcher.unref();
-    } catch (e: any) { console.debug("[async-agents] watcher setup failed:", e?.message || e); }
+    } catch (e: any) { log.error(`watcher setup failed: ${e?.message || e}`); }
   }
 
   function spawnAsyncAgent(
@@ -844,7 +890,7 @@ export function registerAsyncAgents(
       } catch { /* retry */ }
     }
     if (!parentStartTime) {
-      console.debug("[async-agents] WARNING: could not read /proc/self/stat starttime after 3 attempts");
+      log.warn("async-spawn: could not read /proc/self/stat starttime after 3 attempts");
     }
     const { model: effectiveModel, provider: effectiveProvider } = resolveAgentModelProvider(agentName, agent, options?.parentModelId, options?.parentProvider, cwd, options?.explicit);
     fs.writeFileSync(path.join(workerDir, "session.json"), JSON.stringify({
@@ -912,6 +958,9 @@ export function registerAsyncAgents(
       model: effectiveModel,
       contextWindow: asyncState.lastCtx?.model?.contextWindow || 0,
       resultPath,
+      reviewerOutputPath: agentName.startsWith("code-reviewer-")
+        ? reviewerOutputArchivePath(PROJECT_TMP_DIR, id)
+        : undefined,
       workerDir,
       sessionId: `${process.pid}:${process.cwd()}`,
       piCommand: inv.command,
@@ -982,7 +1031,7 @@ export function registerAsyncAgents(
 
     // Fail fast with a self-explanatory error instead of spawning a child that
     // cannot load TypeScript (bare node dies on ".js"→".ts" specifiers).
-    if (!jitiCliPath) {
+    if (!jitiCliPath && !runtime.spawnProcess) {
       log.error(`async-spawn: ${id} — no jiti-cli.mjs found. Probes:\n  ${(jitiProbes.slice(-14)).join("\n  ")}`);
       // Clean up the artifacts we already created — nothing will consume them.
       try { fs.rmSync(configPath, { force: true }); } catch {}
@@ -1056,7 +1105,7 @@ export function registerAsyncAgents(
     stderrLog.on("error", () => {}); // never let a log write failure crash the session
     log.debug(`async-spawn: ${job.id} stderr → ${stderrLogPath}`);
 
-    const proc = spawn(process.execPath, spawnArgs, {
+    const proc = (runtime.spawnProcess ?? spawn)(process.execPath, spawnArgs, {
       cwd,
       stdio: ["ignore", "ignore", "pipe"],
       windowsHide: true,
@@ -1153,6 +1202,8 @@ export function registerAsyncAgents(
     // Export as env var so prompts/CLI commands can reference it
     process.env.PROJECT_TMP_DIR = PROJECT_TMP_DIR;
 
+    cleanupReviewerOutputArchives(path.join(PROJECT_TMP_DIR, "reviewer-results"));
+
     // Scan worker directories for jobs with delivered=true in status.json
     // This is more reliable than content hashing — uses job IDs directly
     try {
@@ -1205,7 +1256,7 @@ export function registerAsyncAgents(
           try { fs.rmSync(jobDir, { recursive: true, force: true }); } catch {}
         } catch {} // skip unreadable dirs
       }
-    } catch (e: any) { console.debug("[async-agents] zombie cleanup failed:", e?.message?.slice(0, 100)); }
+    } catch (e: any) { log.error(`zombie cleanup failed: ${e?.message?.slice(0, 100)}`); }
 
     // Clean up stale result directories from dead sessions
     try {
@@ -1296,13 +1347,13 @@ export function registerAsyncAgents(
           log.info(`restored job: ${id} state=${job.status}`);
         }
       }
-    } catch (e: any) { console.debug("[async-agents] job restore failed:", e?.message || e); }
+    } catch (e: any) { log.error(`job restore failed: ${e?.message || e}`); }
 
     // Start poller if we have jobs or unprocessed result files
     let hasResultFiles = false;
     try {
       hasResultFiles = fs.existsSync(ASYNC_RESULTS_DIR) && fs.readdirSync(ASYNC_RESULTS_DIR).some(f => f.endsWith(".json"));
-    } catch (e: any) { console.debug("[async-agents] result files check failed:", e?.message || e); }
+    } catch (e: any) { log.error(`result files check failed: ${e?.message || e}`); }
     if (asyncState.jobs.size > 0 || hasResultFiles) {
       ensureAsyncPoller();
     }
@@ -1321,6 +1372,8 @@ export function registerAsyncAgents(
   // /async-status — fullscreen overlay list → live output detail
   async function handleAsyncStatus(ctx: any): Promise<void> {
     if (!ctx.hasUI) return;
+    log.debug("opening_async_status_overlay", { jobs: asyncState.jobs.size });
+    const { openAsyncStatusOverlay } = await import("./async-status-ui.js");
     await openAsyncStatusOverlay(ctx, {
       listJobs: () => Array.from(asyncState.jobs.values()),
       killJob: (id) => {
@@ -1413,7 +1466,11 @@ export function registerAsyncAgents(
         const displayName = job.name || job.agent;
         const duration = job.durationMs || (Date.now() - job.startedAt);
         const rawOutput = typeof job.output === "string" ? job.output : "Killed by user";
-        const output = rawOutput.slice(0, 3000);
+        const output = formatAsyncResultOutput(
+          job.agent,
+          rawOutput,
+          resultOutputPath(job),
+        );
         const killContent = `## Async Agent Result: ${displayName} ❌ failed\n\nTask: ${job.task}\nDuration: ${formatDuration(duration)}\n\n${output}`;
         if (wasAlreadyDelivered(job.id)) {
           job.delivered = true;
@@ -1524,13 +1581,15 @@ export function registerAsyncAgents(
 
   // Spawn — create an async agent from pitasks' TaskExecute
   handleRpc<{ requestId: string; type: string; prompt: string; options?: any }>(
-    "subagents:rpc:spawn", ({ type, prompt, options }) => {
+    "subagents:rpc:spawn", async ({ type, prompt, options }) => {
       const ctx = asyncState.lastCtx;
       if (!ctx) throw new Error("No active session");
       if (!type || typeof type !== "string") throw new Error("Missing or invalid 'type' parameter");
       if (!prompt || typeof prompt !== "string") throw new Error("Missing or invalid 'prompt' parameter");
 
       const cwd = options?.cwd || ctx.cwd;
+      log.debug("rpc_spawn_requested", { type, customCwd: Boolean(options?.cwd) });
+      const discoverAgents = runtime.discoverAgents ?? (await import("./agents.js")).discoverAgents;
       const discovery = discoverAgents(cwd, "both");
       const agents = discovery.agents;
 

package/extensions/orchestrator/async-result-format.ts

@@ -0,0 +1,58 @@
+/** Format async-agent output for bounded delivery and status persistence. */
+
+import { createHash } from "node:crypto";
+import * as path from "node:path";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("async_agents");
+const MAX_OUTPUT_CHARS = 3000;
+
+/** Return the completed-result archive path, outside cleanup-prone worker directories. */
+export function reviewerOutputArchivePath(projectTmpDir: string, jobId: string): string {
+  const archiveDir = path.resolve(projectTmpDir, "reviewer-results");
+  const filename = `${createHash("sha256").update(jobId).digest("hex")}.json`;
+  const archivePath = path.resolve(archiveDir, filename);
+  if (path.dirname(archivePath) !== archiveDir) {
+    throw new Error("Reviewer archive destination escapes its archive root");
+  }
+  log.debug("reviewer_output_archive_path", { jobId, archivePath });
+  return archivePath;
+}
+
+/**
+ * Preserve valid reviewer JSON unless it exceeds the delivery budget.
+ * Oversized reviewer output is available only in its worker output.log.
+ */
+export function formatAsyncResultOutput(
+  agent: string,
+  output: string,
+  outputPath: string,
+  maxChars = MAX_OUTPUT_CHARS,
+): string {
+  log.debug("format_async_result_output", { agent, outputChars: output.length, maxChars });
+  if (agent.startsWith("code-reviewer-") && output.length > maxChars) {
+    try {
+      const parsed = JSON.parse(output);
+      if (parsed && typeof parsed === "object" && Array.isArray(parsed.findings)) {
+        const metadata = {
+          truncated: true,
+          format: "json",
+          outputBytes: Buffer.byteLength(output, "utf8"),
+          outputPath,
+        };
+        const serialized = JSON.stringify(metadata);
+        if (serialized.length <= maxChars) return serialized;
+        log.warn("reviewer_metadata_path_exceeds_budget", { agent, maxChars });
+        return JSON.stringify({
+          truncated: true,
+          format: "json",
+          outputBytes: metadata.outputBytes,
+          outputPathOmitted: true,
+        });
+      }
+    } catch {
+      // Invalid reviewer output retains ordinary bounded-text behavior.
+    }
+  }
+  return output.slice(0, maxChars);
+}

package/extensions/orchestrator/async-runner.ts

@@ -9,6 +9,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { createRequire } from "node:module";
 import { getSetting } from "./project-settings.js";
+import { createLogger } from "../shared/logger.js";
+import { archiveReviewerOutput } from "./reviewer-output-archive.js";
+
+const log = createLogger("async_agents");
 
 interface RunConfig {
   id: string;
@@ -20,6 +24,7 @@ interface RunConfig {
   tools?: string[];
   systemPrompt?: string;
   resultPath: string;
+  reviewerOutputPath?: string;
   workerDir: string;
   sessionId?: string;
   piCommand: string;
@@ -72,7 +77,7 @@ async function run(config: RunConfig): Promise<void> {
   writeJson(statusPath, status);
   let lastUsage: any = null;
 
-  const outputStream = fs.createWriteStream(outputPath, { flags: "w" });
+  const outputStream = fs.createWriteStream(outputPath, { flags: "w", mode: 0o600 });
 
   // Connect to pidash server to stream events
   const pidashPort = getSetting(config.cwd, "pidash_port");
@@ -157,7 +162,7 @@ async function run(config: RunConfig): Promise<void> {
           if (pidashWs?.readyState === 1) {
             pidashWs.send(JSON.stringify({ type: "async_event", id: config.id, event: ev }));
           }
-        } catch (e: any) { console.debug("[async-runner] event processing failed:", e?.message || e); }
+        } catch (e: any) { log.warn(`event processing skipped: ${e?.message || e}`); }
       }
 
       // Update status periodically (every ~10 lines)
@@ -193,7 +198,7 @@ async function run(config: RunConfig): Promise<void> {
           if (p.type === "text") finalOutput = p.text;
         }
       }
-    } catch (e: any) { console.debug("[async-runner] final line parse failed:", e?.message || e); }
+    } catch (e: any) { log.error(`final line parse failed: ${e?.message || e}`); }
   }
 
   // Write final status
@@ -283,7 +288,18 @@ async function run(config: RunConfig): Promise<void> {
   }
 
   // End the output stream after all retries are done
-  outputStream.end();
+  await new Promise<void>((resolve, reject) => {
+    outputStream.once("error", reject);
+    outputStream.end(resolve);
+  });
+  if (config.reviewerOutputPath && config.agent.startsWith("code-reviewer-")) {
+    try {
+      archiveReviewerOutput(outputPath, config.reviewerOutputPath);
+      log.info("archived_reviewer_output", { agent: config.agent, outputPath: config.reviewerOutputPath });
+    } catch (err) {
+      log.error("archive_reviewer_output_failed", err);
+    }
+  }
 
   // Write result for the watcher to pick up
   writeJson(config.resultPath, {

package/extensions/orchestrator/reviewer-output-archive.ts

@@ -0,0 +1,69 @@
+/** Durable reviewer-output archival and bounded retention. */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("async_agents");
+
+export const REVIEWER_ARCHIVE_RETENTION = {
+  maxAgeMs: 7 * 24 * 60 * 60 * 1000,
+  maxFiles: 100,
+  maxBytes: 50 * 1024 * 1024,
+};
+
+type Retention = typeof REVIEWER_ARCHIVE_RETENTION;
+
+/** Copy reviewer output into a durable owner-only archive. */
+export function archiveReviewerOutput(outputPath: string, archivePath: string): void {
+  fs.chmodSync(outputPath, 0o600);
+  fs.mkdirSync(path.dirname(archivePath), { recursive: true, mode: 0o700 });
+  fs.copyFileSync(outputPath, archivePath);
+  fs.chmodSync(archivePath, 0o600);
+  cleanupReviewerOutputArchives(path.dirname(archivePath));
+  log.info("archived_reviewer_output", { outputPath: archivePath });
+}
+
+/** Remove expired and oldest regular-file archives while preserving bounded storage. */
+export function cleanupReviewerOutputArchives(
+  archiveDir: string,
+  retention: Retention = REVIEWER_ARCHIVE_RETENTION,
+): void {
+  let archives: Array<{ path: string; mtimeMs: number; size: number }>;
+  try {
+    archives = fs.readdirSync(archiveDir).flatMap((entry) => {
+      const archivePath = path.join(archiveDir, entry);
+      try {
+        const stat = fs.lstatSync(archivePath);
+        return stat.isFile() ? [{ path: archivePath, mtimeMs: stat.mtimeMs, size: stat.size }] : [];
+      } catch {
+        return [];
+      }
+    });
+  } catch (error: any) {
+    if (error?.code !== "ENOENT") log.warn("reviewer_archive_cleanup_scan_failed", { archiveDir, error: error?.message });
+    return;
+  }
+
+  const now = Date.now();
+  const retained = archives
+    .filter((archive) => {
+      if (now - archive.mtimeMs <= retention.maxAgeMs) return true;
+      try { fs.unlinkSync(archive.path); } catch (error: any) { log.warn("reviewer_archive_expiry_delete_failed", { archivePath: archive.path, error: error?.message }); return true; }
+      return false;
+    })
+    .sort((left, right) => right.mtimeMs - left.mtimeMs);
+
+  let totalBytes = retained.reduce((total, archive) => total + archive.size, 0);
+  for (let index = retained.length - 1; index >= 0; index--) {
+    const archive = retained[index];
+    if (index < retention.maxFiles && totalBytes <= retention.maxBytes) continue;
+    try {
+      fs.unlinkSync(archive.path);
+      totalBytes -= archive.size;
+    } catch (error: any) {
+      log.warn("reviewer_archive_retention_delete_failed", { archivePath: archive.path, error: error?.message });
+    }
+  }
+  log.debug("reviewer_archive_cleanup_complete", { archiveDir, retainedFiles: retained.length, totalBytes });
+}

package/extensions/pidiff/pidiff-ui/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pidiff-ui",
   "private": true,
-  "version": "4.3.11",
+  "version": "4.3.12",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/extensions/pitasks/task-tools.ts

@@ -61,7 +61,7 @@ All tasks are created with status \`pending\`.
 - Include enough detail in the description for another agent to understand and complete the task
 - After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
 - Check TaskList first to avoid creating duplicate tasks
-- Include \`agentType\` (e.g., "general-purpose", "Explore") to mark tasks for subagent execution via TaskExecute`,
+- Use \`agentType\` only as optional descriptive metadata; it does not dispatch or execute an agent`,
 		promptGuidelines: [
 			"When working on complex multi-step tasks, use TaskCreate to track progress and TaskUpdate to update status.",
 			"Mark tasks as in_progress before starting work and completed when done.",
@@ -71,7 +71,7 @@ All tasks are created with status \`pending\`.
 			subject: Type.String({ description: "A brief title for the task" }),
 			description: Type.String({ description: "A detailed description of what needs to be done" }),
 			activeForm: Type.Optional(Type.String({ description: "Present continuous form shown in spinner when in_progress (e.g., 'Running tests')" })),
-			agentType: Type.Optional(Type.String({ description: "Agent type for subagent execution (e.g., 'general-purpose', 'Explore'). Tasks with agentType can be started via TaskExecute." })),
+			agentType: Type.Optional(Type.String({ description: "Optional descriptive metadata for the task. It does not dispatch or execute an agent." })),
 			metadata: Type.Optional(Type.Record(Type.String(), Type.Any(), { description: "Arbitrary metadata to attach to the task" })),
 		}),
 		execute(_toolCallId: string, params: any) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-orchestrator-config",
-  "version": "4.3.11",
+  "version": "4.3.12",
   "description": "Orchestrator pattern for pi: specialist subagents, enforcement, code review loop, workflow commands",
   "keywords": [
     "pi-package"

package/scripts/build-extension-uis.sh

@@ -7,17 +7,17 @@ REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)"
 
 build_ui() {
   local ui_dir="$1"
-  echo "Building ${ui_dir}..."
+  echo "Building ${ui_dir}..." >&2
   cd "${REPO_DIR}/${ui_dir}"
   if [ ! -d node_modules ]; then
-    npm install --production=false
+    npm install --production=false >&2
   fi
-  npm run build
+  npm run build >&2
 }
 
 build_ui extensions/pidash/pidash-ui
 build_ui extensions/pidiff/pidiff-ui
 
-echo "UI builds complete."
-echo "  ${REPO_DIR}/extensions/pidash/pidash-ui/dist/index.html"
-echo "  ${REPO_DIR}/extensions/pidiff/pidiff-ui/dist/index.html"
+echo "UI builds complete." >&2
+echo "  ${REPO_DIR}/extensions/pidash/pidash-ui/dist/index.html" >&2
+echo "  ${REPO_DIR}/extensions/pidiff/pidiff-ui/dist/index.html" >&2