@pellux/goodvibes-sdk 0.33.24 → 0.33.26

package/dist/platform/tools/agent/wrfc-batch-policy.js

@@ -184,6 +184,34 @@ function buildCollapsedContext(input, tasks, roleTaskIndexes, authoritativeTask,
         ...tasks.map(formatTask),
     ].filter((line) => Boolean(line)).join('\n');
 }
+function buildCompoundContext(input, tasks, authoritativeTask) {
+    const existing = input.context?.trim();
+    return [
+        existing ? `Caller context:\n${existing}` : null,
+        'SDK compound WRFC topology enforcement collapsed this batch into one durable owner chain because multiple implementation deliverables share one higher-level reviewed outcome.',
+        `Authoritative original ask for this WRFC chain:\n${authoritativeTask}`,
+        'The WRFC owner must track every sub-deliverable. Engineer children may run concurrently. Reviewer/fixer phases must run only after the corresponding engineer has output. The integrator phase runs only after all sub-deliverables pass.',
+        'Compound deliverables:',
+        ...tasks.map(formatTask),
+    ].filter((line) => Boolean(line)).join('\n');
+}
+function normalizeCompoundSubtask(task, authoritativeTask) {
+    const normalizedTask = looksLikeScopeNarrowing(task.task, authoritativeTask)
+        ? normalizeNarrowedTask(task.task)
+        : task.task;
+    const toolContract = resolveImplementationToolContract({
+        tools: task.tools,
+        restrictTools: task.restrictTools,
+        authoritativeTask,
+        proposedTask: task.task,
+    });
+    return {
+        ...task,
+        task: normalizedTask,
+        tools: toolContract.tools,
+        restrictTools: toolContract.restrictTools,
+    };
+}
 export function evaluateWrfcBatchPolicy(input) {
     const tasks = input.tasks ?? [];
     if (input.mode !== 'batch-spawn' || tasks.length <= 1) {
@@ -193,7 +221,73 @@ export function evaluateWrfcBatchPolicy(input) {
         .map((task, index) => isRootReviewRoleTask(task) ? index : -1)
         .filter((index) => index >= 0);
     if (roleTaskIndexes.length === 0) {
-        return { kind: 'independent' };
+        const implementationTaskIndexes = tasks
+            .map((task, index) => isImplementationLikeTask(task) ? index : -1)
+            .filter((index) => index >= 0);
+        const implementationTasksDisableWrfc = implementationTaskIndexes.length > 0
+            && implementationTaskIndexes.every((index) => {
+                const task = tasks[index];
+                return task.dangerously_disable_wrfc === true || task.reviewMode === 'none';
+            });
+        const wantsWrfc = input.reviewMode === 'wrfc'
+            || tasks.some((task) => task.reviewMode === 'wrfc')
+            || (!implementationTasksDisableWrfc
+                && input.dangerously_disable_wrfc !== true
+                && input.reviewMode !== 'none'
+                && implementationTaskIndexes.length > 0);
+        if (!wantsWrfc || implementationTaskIndexes.length <= 1) {
+            return { kind: 'independent' };
+        }
+        const authoritativeTask = normalizeTaskText(input.authoritativeTask)
+            ?? normalizeTaskText(input.task)
+            ?? `Complete and integrate ${implementationTaskIndexes.length} reviewed deliverables.`;
+        const ownerInput = {
+            mode: 'spawn',
+            task: authoritativeTask,
+            authoritativeTask,
+            template: input.template ?? 'orchestrator',
+            model: input.model,
+            provider: input.provider,
+            fallbackModels: input.fallbackModels,
+            routing: input.routing,
+            executionIntent: input.executionIntent,
+            reasoningEffort: input.reasoningEffort,
+            tools: input.tools,
+            restrictTools: input.restrictTools,
+            context: buildCompoundContext(input, tasks, authoritativeTask),
+            successCriteria: uniqueStrings([
+                input.successCriteria,
+                ...tasks.map((task) => task.successCriteria),
+                [`Satisfy the authoritative compound WRFC ask exactly: ${authoritativeTask}`],
+                ['Keep every implementation deliverable under one owner chain; do not create sibling reviewer/tester/fixer roots.'],
+                ['Run reviewer/fixer loops only after each corresponding engineer child has output, then integrate the passed deliverables before final full-scope review.'],
+            ]),
+            requiredEvidence: uniqueStrings([
+                input.requiredEvidence,
+                ...tasks.map((task) => task.requiredEvidence),
+            ]),
+            writeScope: uniqueStrings([
+                input.writeScope,
+                ...tasks.map((task) => task.writeScope),
+            ]),
+            executionProtocol: input.executionProtocol,
+            reviewMode: 'wrfc',
+            communicationLane: input.communicationLane,
+            parentAgentId: input.parentAgentId,
+            orchestrationGraphId: input.orchestrationGraphId,
+            orchestrationNodeId: input.orchestrationNodeId,
+            parentNodeId: input.parentNodeId,
+            dangerously_disable_wrfc: false,
+            cohort: input.cohort,
+            wrfcSubtasks: implementationTaskIndexes.map((index) => normalizeCompoundSubtask(tasks[index], authoritativeTask)),
+        };
+        return {
+            kind: 'collapse-to-wrfc',
+            reason: 'batch-spawn contained multiple implementation deliverables that require one compound WRFC owner chain',
+            ownerInput,
+            roleTaskIndexes: [],
+            compoundTaskIndexes: implementationTaskIndexes,
+        };
     }
     const primaryIndex = tasks.findIndex((task, index) => !roleTaskIndexes.includes(index) && isImplementationLikeTask(task));
     const ownerTask = tasks[primaryIndex >= 0 ? primaryIndex : 0];

package/dist/platform/version.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-let version = '0.33.24';
+let version = '0.33.26';
 try {
     const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf-8'));
     version = pkg.version ?? version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-sdk",
-  "version": "0.33.24",
+  "version": "0.33.26",
   "description": "TypeScript SDK for building GoodVibes operator, peer, web, mobile, and daemon-connected apps with typed contracts, auth, realtime events, and transport layers.",
   "keywords": [
     "goodvibes",
@@ -449,14 +449,14 @@
   "sideEffects": false,
   "type": "module",
   "dependencies": {
-    "@pellux/goodvibes-contracts": "0.33.24",
-    "@pellux/goodvibes-daemon-sdk": "0.33.24",
-    "@pellux/goodvibes-errors": "0.33.24",
-    "@pellux/goodvibes-operator-sdk": "0.33.24",
-    "@pellux/goodvibes-peer-sdk": "0.33.24",
-    "@pellux/goodvibes-transport-core": "0.33.24",
-    "@pellux/goodvibes-transport-http": "0.33.24",
-    "@pellux/goodvibes-transport-realtime": "0.33.24"
+    "@pellux/goodvibes-contracts": "0.33.26",
+    "@pellux/goodvibes-daemon-sdk": "0.33.26",
+    "@pellux/goodvibes-errors": "0.33.26",
+    "@pellux/goodvibes-operator-sdk": "0.33.26",
+    "@pellux/goodvibes-peer-sdk": "0.33.26",
+    "@pellux/goodvibes-transport-core": "0.33.26",
+    "@pellux/goodvibes-transport-http": "0.33.26",
+    "@pellux/goodvibes-transport-realtime": "0.33.26"
   },
   "optionalDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",