@vercel/dream 0.2.12 → 0.3.1

package/bin/dream.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+await import("../dist/dream.js");

package/dist/dream.js

@@ -73,16 +73,57 @@ Each iteration follows this cycle:
 
 ## Subagent-First Execution
 
-Treat yourself as the manager agent. Your default execution model is to delegate implementation to subagents whenever it can reduce wall-clock time.
+You are the manager agent. Your default is to delegate implementation to subagents to maximize parallelism and reduce wall-clock time.
 
-1. Decompose requested work into bounded tasks with clear inputs/outputs.
-2. Run independent tasks in parallel using multiple subagents.
-3. Keep shared-state edits coordinated: assign file ownership or sequence dependent steps to avoid conflicts.
-4. Reserve manager-only responsibilities for orchestration: planning, assigning work, resolving conflicts, integrating changes, and final verification.
-5. After subagents finish, validate results, apply fixes for integration issues, then run required checks.
-6. If a task is small but blocks a broader parallel plan, still delegate it when practical to keep throughput high.
+### Decompose into Bounded Tasks
 
-Prefer subagent parallelism over sequential single-agent implementation unless tasks are tightly coupled or delegation overhead is clearly higher than direct execution.
+1. Group work by independent domain \u2014 different routes, subsystems, or data models are natural boundaries.
+2. Each task must have a clear input (what exists), output (what should exist after), and scope (which files to touch).
+3. If two tasks must edit the same file, sequence them \u2014 never dispatch parallel subagents to the same file.
+4. If tasks are tightly coupled or you don't yet understand the problem, investigate sequentially first, then parallelize.
+
+### Subagent Prompt Template
+
+When dispatching a subagent, provide a self-contained prompt with this structure:
+
+\`\`\`
+You are implementing: [task name]
+
+## Task
+[Full text of what to build \u2014 paste requirements inline, never tell subagent to read spec files]
+
+## Context
+[Where this fits: what already exists, dependencies, architectural constraints from specs]
+
+## Scope
+- Files you may create/edit: [explicit list]
+- Files you must NOT touch: [explicit list or "anything not listed above"]
+
+## Constraints
+[Framework requirements, env var rules, forbidden patterns from specs]
+
+## When Done
+Report: what you implemented, files changed, commands to verify, any issues or blockers found.
+\`\`\`
+
+Key rules:
+- Provide all context inline \u2014 subagents start with empty context and cannot read your history.
+- Be specific about file scope to prevent edit conflicts between parallel subagents.
+- Include verification commands so the subagent can self-check before reporting.
+- If a subagent encounters something unclear, it should report a blocker rather than guess.
+
+### After Subagents Return
+
+1. Read each subagent's report. Do not trust claims blindly \u2014 verify against actual files.
+2. Check for conflicts: did any subagent edit files outside its scope or overlap with another?
+3. Run integration verification (build, type check, tests) on the combined changes.
+4. Fix integration issues yourself \u2014 do not re-dispatch for small glue work.
+
+### When NOT to Parallelize
+
+- Tasks share mutable state (same database migration, same config file).
+- You are debugging \u2014 investigate root cause sequentially before dispatching fixes.
+- The overhead of writing a self-contained prompt exceeds the time saved by parallelism (trivial single-file edits).
 
 ## PROGRESS.md Format
 
@@ -122,21 +163,22 @@ Each iteration should complete a coherent unit (not trivial single-file churn),
 
 **If tasks remain:** update \`PROGRESS.md\` and stop. Do NOT output completion signal.
 
-**When all work is done**, output completion signal only after all are true:
-- Every task in \`PROGRESS.md\` is complete
-- All specs in \`specs/\` are implemented
-- Required verification commands pass
-- No active blockers remain
-- Implementation artifacts are source-code-compliant with specs (not forbidden static fallback)
-- Generated deployment output conforms to Build Output API for the target deploy platform
+**When all work is done**, output completion signal. The bar is:
+1. All tasks in \`PROGRESS.md\` are checked off
+2. \`npm run build\` (or equivalent) exits 0
+3. No blockers in \`PROGRESS.md\`
+
+That's it. Do NOT loop on cosmetic verification (curling pages, grepping HTML, re-reading files you just wrote). If it builds clean and tasks are done, you are done.
 
 When complete, output exactly this on its own line:
 
 ${STOP_WORD}
 
-Without this signal, the system keeps launching new iterations.`;
+**You MUST include text in every response.** If you only used tools, still output a one-line status summary. Responses with zero text cause unnecessary continuation.
+
+Without the completion signal, the system keeps launching new iterations.`;
 var DEFAULT_TIMEOUT = 36e5;
-var DEFAULT_MAX_ITERATIONS = 100;
+var DEFAULT_MAX_ITERATIONS = 20;
 var DEFAULT_MODEL = "vercel/anthropic/claude-opus-4.6";
 var DREAM_VERSION = readDreamVersion();
 var DEFAULT_BOOTSTRAP_SKILL_REPOS = [
@@ -321,6 +363,8 @@ ${INDENT_MAIN}${red("\u2717")} Runtime bootstrap failed: ${message}
   }
   printStep("Starting OpenCode...");
   const oidcToken = process.env.VERCEL_OIDC_TOKEN;
+  const gatewayApiKey = process.env.AI_GATEWAY_API_KEY;
+  const providerOptions = oidcToken ? { apiKey: oidcToken, headers: { "ai-gateway-auth-method": "oidc" } } : gatewayApiKey ? { apiKey: gatewayApiKey } : void 0;
   const { client, server } = await createOpencode({
     port: 0,
     config: {
@@ -338,15 +382,8 @@ ${INDENT_MAIN}${red("\u2717")} Runtime bootstrap failed: ${message}
       },
       provider: {
         vercel: {
-          env: ["VERCEL_API_KEY", "VERCEL_OIDC_TOKEN"],
-          ...oidcToken && {
-            options: {
-              apiKey: oidcToken,
-              headers: {
-                "ai-gateway-auth-method": "oidc"
-              }
-            }
-          }
+          env: ["AI_GATEWAY_API_KEY", "VERCEL_API_KEY", "VERCEL_OIDC_TOKEN"],
+          ...providerOptions && { options: providerOptions }
         }
       },
       enabled_providers: ["vercel"]
@@ -385,6 +422,8 @@ ${INDENT_MAIN}Run ${cyan("opencode")} and authenticate the ${bold(providerId)} p
   process.on("SIGTERM", cleanup);
   const startTime = Date.now();
   let iteration = 0;
+  let noEditStreak = 0;
+  const MAX_NO_EDIT_STREAK = 3;
   try {
     while (iteration < maxIterations) {
       const elapsed = Date.now() - startTime;
@@ -425,10 +464,27 @@ ${INDENT_MAIN}${red("\u2717")} Session failed after ${bold(String(iteration))} i
         );
         process.exit(1);
       }
-      printLine(
-        `${INDENT_MAIN}${cyan(`[${iteration}]`)} ${dim(`${formatTime(iterElapsed)} \xB7 continuing...`)}
+      if (result === "stalled") {
+        noEditStreak++;
+        if (noEditStreak >= MAX_NO_EDIT_STREAK) {
+          printLine(
+            `
+${INDENT_MAIN}${red("\u2717")} Stalled: ${MAX_NO_EDIT_STREAK} consecutive iterations with no file edits. Stopping.
 `
-      );
+          );
+          process.exit(1);
+        }
+        printLine(
+          `${INDENT_MAIN}${cyan(`[${iteration}]`)} ${dim(`${formatTime(iterElapsed)} \xB7 no edits (${noEditStreak}/${MAX_NO_EDIT_STREAK}) \xB7 continuing...`)}
+`
+        );
+      } else {
+        noEditStreak = 0;
+        printLine(
+          `${INDENT_MAIN}${cyan(`[${iteration}]`)} ${dim(`${formatTime(iterElapsed)} \xB7 continuing...`)}
+`
+        );
+      }
     }
     printLine(`
 ${INDENT_MAIN}${red("\u2717")} Max iterations reached
@@ -463,6 +519,7 @@ async function runSession(client, title, systemPrompt, verbose) {
   }
   let responseText = "";
   let toolCalls = 0;
+  let fileEdits = 0;
   let totalCost = 0;
   let totalTokensIn = 0;
   let totalTokensOut = 0;
@@ -536,6 +593,7 @@ ${INDENT_SESSION}`);
     if (event.type === "file.edited") {
       const file = event.properties.file;
       if (file) {
+        fileEdits++;
         if (lastOutput === "text") process.stdout.write("\n");
         const relative = file.replace(`${process.cwd()}/`, "");
         printSession(`${green("\u270E")} ${relative}`);
@@ -558,10 +616,15 @@ ${INDENT_SESSION}`);
   const cost = totalCost > 0 ? ` \xB7 $${totalCost.toFixed(2)}` : "";
   printSessionDim(`${toolCalls} tools \xB7 ${tokens}${cost}`);
   if (responseText.length === 0) {
+    if (toolCalls > 0) {
+      printSessionDim("no text response, continuing...");
+      return fileEdits > 0 ? "continue" : "stalled";
+    }
     printSessionError("No response from model");
     return "error";
   }
-  return responseText.includes(STOP_WORD) ? "done" : "continue";
+  if (responseText.includes(STOP_WORD)) return "done";
+  return fileEdits > 0 ? "continue" : "stalled";
 }
 function formatTime(ms) {
   if (ms < 1e3) return `${ms}ms`;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@vercel/dream",
-  "version": "0.2.12",
+  "version": "0.3.1",
   "description": "A CLI that runs OpenCode in a loop until specs are complete",
   "type": "module",
   "bin": {
-    "dream": "./dist/dream.js"
+    "dream": "./bin/dream.mjs"
   },
   "files": [
-    "dist"
+    "dist",
+    "bin/dream.mjs"
   ],
   "dependencies": {
     "@ai-sdk/gateway": "^3.0.39",