@magnusekdahl/parallix 1.0.2 → 1.0.4

package/README.md

@@ -40,7 +40,7 @@ Each capability below is tied to a use case in [`docs/use-cases.md`](docs/use-ca
 - **Publish work to a Forgejo reviewer surface without making Forgejo your branch authority** *(Confirmed mechanic).* When the review provider is enabled, Parallix syncs the local baseline to a dedicated `review` remote and opens or updates the PR there; if Forgejo is disabled, the branch/worktree flow still runs locally.
 - **Use a repo-local Graphify knowledge graph for smaller codebase context pulls** *(Confirmed mechanic, optional, unproven payoff).* In repositories where the operator has already installed the Graphify skill, the workflow keeps `graphify-out/` isolated per worktree and refreshes it during review/integration, while the installed agent guidance steers codebase questions toward `graphify query` / `path` / `explain` before full reports or raw grep. That should reduce context bloat, but this repo does not currently claim a measured token-usage reduction.
 - **Keep your existing verification gate instead of agent self-reporting** *(UC-5 — Confirmed).* The gate is a configured shell command with a no-op default: declare your existing `make` / `npm` / script command in `workflow.config.json` and it runs verbatim; declare nothing and verification is a documented no-op pass, not an invented gate.
-- **See which agent family actually pays off across every repo one runtime drives** *(UC-6 — Partial).* A single operator-owned `stats.csv` accumulates per-agent telemetry across repositories. Token-cost comparison is complete today only for the families with structured telemetry (codex, claude); two families record honest zeros by design.
+- **See which agent family actually pays off across every repo one runtime drives** *(UC-6 — Partial).* A single operator-owned `stats.csv` accumulates per-agent usage telemetry across repositories. Token-cost comparison is complete today only for the families with structured telemetry (codex, claude, opencode/qwen); vibe/mistral record honest zeros by design.
 
 ## The core workflow
 

package/lib/agents/opencode-export.js

@@ -1,6 +1,9 @@
 'use strict';
 
 const childProcess = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
 /**
  * Capture the complete `opencode export <sessionId>` JSON document.
@@ -15,6 +18,10 @@ const childProcess = require('child_process');
  *   - Fails explicitly (resolves null) when output exceeds `maxBytes` rather
  *     than silently truncating into unparseable JSON.
  *
+ * Uses a temp-file fd for stdout to avoid pipe-buffer data loss that occurs
+ * with large (>100 KB) child-process output.  The child writes directly to
+ * the fd; after exit we read the file back as a string.
+ *
  * Never rejects: any error/timeout/oversize resolves to null so telemetry
  * capture stays best-effort and cannot break the launch.
  *
@@ -44,13 +51,21 @@ function captureOpencodeExport(sessionId, opts = {}) {
 
     let settled = false;
     let timer = null;
-    const chunks = [];
     let size = 0;
+    let tmpFd = null;
+    let tmpPath = null;
 
     const finish = (value) => {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
+      // Clean up temp file
+      if (tmpFd !== null) {
+        try { fs.closeSync(tmpFd); } catch (_) { /* already closed */ }
+      }
+      if (tmpPath) {
+        try { fs.unlinkSync(tmpPath); } catch (_) { /* already gone */ }
+      }
       resolve(value);
     };
 
@@ -58,18 +73,33 @@ function captureOpencodeExport(sessionId, opts = {}) {
       try { child.kill('SIGKILL'); } catch (_) { /* already gone */ }
     };
 
+    // Create a temp file for stdout to avoid pipe-buffer truncation
+    let tmpFileError = null;
+    try {
+      tmpPath = path.join(os.tmpdir(), `opencode-export-${process.pid}-${Date.now()}.json`);
+      tmpFd = fs.openSync(tmpPath, 'w');
+    } catch (e) {
+      tmpFileError = e;
+    }
+
     let child;
     try {
       child = spawn('opencode', ['export', sessionId], {
         cwd: worktree,
         env: { ...process.env, ...(env || {}) },
-        stdio: ['ignore', 'pipe', 'ignore'],
+        stdio: ['ignore', tmpFd !== null ? tmpFd : 'pipe', 'pipe'],
       });
     } catch (_) {
       finish(null);
       return;
     }
 
+    if (tmpFileError) {
+      killChild(child);
+      finish(null);
+      return;
+    }
+
     timer = setTimeout(() => {
       // Hung or slow export: kill it and degrade to null. Do not block.
       killChild(child);
@@ -80,29 +110,42 @@ function captureOpencodeExport(sessionId, opts = {}) {
     // ref'd keeps the timeout deterministic under Node's test runner (an unref'd
     // timer can be skipped when the loop is otherwise idle, cancelling the test).
 
-    if (!child || !child.stdout) {
-      finish(null);
-      return;
+    // Consume stderr to prevent pipe-buffer issues with the opencode binary
+    if (child.stderr) {
+      child.stderr.on('data', () => { /* drain stderr */ });
     }
 
-    child.stdout.on('data', (chunk) => {
+    child.on('error', () => finish(null));
+
+    child.on('close', (code) => {
       if (settled) return;
-      size += chunk.length;
+      if (tmpFd === null) {
+        finish(null);
+        return;
+      }
+
+      try {
+        fs.closeSync(tmpFd);
+      } catch (_) { /* already closed */ }
+      tmpFd = null;
+
+      let content;
+      try {
+        content = fs.readFileSync(tmpPath, 'utf8');
+      } catch (_) {
+        finish(null);
+        return;
+      }
+
+      size = Buffer.byteLength(content);
       if (size > maxBytes) {
         // Explicit failure rather than silent truncation: a partial JSON
         // document would parse to null/garbage and fabricate zero telemetry.
-        killChild(child);
         finish(null);
         return;
       }
-      chunks.push(chunk);
-    });
 
-    child.on('error', () => finish(null));
-
-    child.on('close', () => {
-      if (settled) return;
-      finish(Buffer.concat(chunks).toString('utf8'));
+      finish(content);
     });
   });
 }

package/lib/core/verification.js

@@ -1,4 +1,4 @@
-const { run } = require('./git');
+const { git, run } = require('./git');
 const { loadAdapterConfig } = require('./product-config');
 const fs = require('fs');
 
@@ -49,7 +49,7 @@ function runVerificationGate(area, options = {}) {
   return runFn('bash', ['-lc', command.replaceAll('{{area}}', effectiveArea)], { cwd: rootDir, stdio });
 }
 
-function readPublishedTreeState(rootDir = process.cwd(), { gitRunner = run } = {}) {
+function readPublishedTreeState(rootDir = process.cwd(), { gitRunner = git } = {}) {
   const resolvedRoot = fs.realpathSync(rootDir);
   const commitResult = gitRunner(['-C', resolvedRoot, 'rev-parse', 'HEAD']);
   const treeResult = gitRunner(['-C', resolvedRoot, 'rev-parse', 'HEAD^{tree}']);
@@ -68,7 +68,7 @@ function readPublishedTreeState(rootDir = process.cwd(), { gitRunner = run } = {
 
 function captureVerifiedTreeProof(area, rootDir = process.cwd(), options = {}) {
   const {
-    gitRunner = run,
+    gitRunner = git,
     runFn = run,
     stdio = 'inherit'
   } = options;
@@ -113,7 +113,7 @@ function captureVerifiedTreeProof(area, rootDir = process.cwd(), options = {}) {
   };
 }
 
-function assertVerifiedTreeProof(proof, rootDir = process.cwd(), { gitRunner = run } = {}) {
+function assertVerifiedTreeProof(proof, rootDir = process.cwd(), { gitRunner = git } = {}) {
   if (!proof || typeof proof !== 'object') {
     return { ok: false, error: 'missing verification proof' };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magnusekdahl/parallix",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "AI mission workflow toolkit with a px CLI — local-first, human-in-the-loop multi-agent development",
   "license": "AGPL-3.0-or-later",
   "private": false,