@mindstudio-ai/remy 0.1.139 → 0.1.140

package/dist/headless.js

@@ -2352,7 +2352,30 @@ var listDirTool = {
             const capped = children.slice(0, MAX_CHILDREN);
             for (const child of capped) {
               if (child.isDirectory()) {
-                lines.push(`  ${child.name}/`);
+                const [childDisplay, childFinalPath] = await collapsePath(
+                  finalPath,
+                  child.name
+                );
+                lines.push(`  ${childDisplay}/`);
+                try {
+                  const grandchildren = await readAndSort(childFinalPath);
+                  const gcCapped = grandchildren.slice(0, MAX_CHILDREN);
+                  for (const gc of gcCapped) {
+                    if (gc.isDirectory()) {
+                      lines.push(`    ${gc.name}/`);
+                    } else {
+                      lines.push(
+                        await formatFile(childFinalPath, gc.name, "    ")
+                      );
+                    }
+                  }
+                  if (grandchildren.length > MAX_CHILDREN) {
+                    lines.push(
+                      `    ... and ${grandchildren.length - MAX_CHILDREN} more`
+                    );
+                  }
+                } catch {
+                }
               } else {
                 lines.push(await formatFile(finalPath, child.name, "  "));
               }

package/dist/index.js

@@ -2660,7 +2660,30 @@ var init_listDir = __esm({
                 const capped = children.slice(0, MAX_CHILDREN);
                 for (const child of capped) {
                   if (child.isDirectory()) {
-                    lines.push(`  ${child.name}/`);
+                    const [childDisplay, childFinalPath] = await collapsePath(
+                      finalPath,
+                      child.name
+                    );
+                    lines.push(`  ${childDisplay}/`);
+                    try {
+                      const grandchildren = await readAndSort(childFinalPath);
+                      const gcCapped = grandchildren.slice(0, MAX_CHILDREN);
+                      for (const gc of gcCapped) {
+                        if (gc.isDirectory()) {
+                          lines.push(`    ${gc.name}/`);
+                        } else {
+                          lines.push(
+                            await formatFile(childFinalPath, gc.name, "    ")
+                          );
+                        }
+                      }
+                      if (grandchildren.length > MAX_CHILDREN) {
+                        lines.push(
+                          `    ... and ${grandchildren.length - MAX_CHILDREN} more`
+                        );
+                      }
+                    } catch {
+                    }
                   } else {
                     lines.push(await formatFile(finalPath, child.name, "  "));
                   }

package/dist/prompt/compiled/methods.md

@@ -245,20 +245,54 @@ export function getApprovalState(approvals: Approval[]) {
 
 ## Streaming
 
-Methods can stream token-by-token output (useful for AI-generated content):
+Methods can push real-time updates to the frontend using `stream()`. This is the standard pattern for any method that takes more than a few seconds.
 
 ```typescript
-// Frontend
-const result = await api.generateReport(
-  { month: 'march' },
+import { mindstudio, stream } from '@mindstudio-ai/agent';
+
+export async function enrichProfile(input: { name: string }) {
+  await stream('Researching...');
+
+  const { content } = await mindstudio.generateText(
+    { message: `Find background info on ${input.name}` },
+    { onLog: (event) => stream({ status: event.value }) },
+  );
+
+  await stream({ status: 'generating_image', progress: 0.5 });
+
+  const { imageUrl } = await mindstudio.generateImage(
+    { prompt: `Professional portrait illustration of ${input.name}` },
+    { onLog: (event) => stream({ status: event.value }) },
+  );
+
+  return { bio: content, imageUrl };
+}
+```
+
+Two data types:
+- `stream('text')` sends a text token (like LLM streaming output)
+- `stream({ ... })` sends structured data (progress, status, intermediate results)
+
+Every SDK action accepts an `onLog` callback that emits execution progress. Pipe it through `stream()` so the frontend sees what's happening inside each action in real time. Use `stream()` directly for your own status messages between actions.
+
+When there's no active stream (method not called with `stream: true`, CLI execution, background jobs), `stream()` is a silent no-op. Always safe to include unconditionally.
+
+### Frontend
+
+The frontend calls the method with `stream: true` and receives updates via `onToken`. The `text` value is accumulated (not a delta), so replace your display content each time.
+
+```typescript
+const result = await api.enrichProfile(
+  { name: 'Alice' },
   {
     stream: true,
-    onToken: (text) => setPreview(text),
+    onToken: (text) => setResponseText(text),
   },
 );
+// result is the same final output you'd get without streaming
 ```
 
-The platform handles the SSE transport. The method returns normally — streaming is managed by the SDK and platform, not by your method code.
+Use `onStreamError` for transient error handling. The method's promise still resolves with the final return value once execution completes.
 
 ## Raw Request Context (API Interface)
 

package/dist/prompt/static/coding.md

@@ -30,6 +30,8 @@ For any work involving AI models, external actions (web scraping, email, SMS), o
 
 For multi-step tasks with branching logic (research, enrichment, content pipelines), use `runTask()` instead of manually chaining SDK actions. It runs an autonomous agent loop that composes actions, retries on failure, and returns structured JSON. See the task agents reference for details.
 
+For methods that take more than a few seconds, use `stream()` from `@mindstudio-ai/agent` to push real-time progress to the frontend. Pipe `onLog` from SDK actions through `stream()` so users see what's happening. The frontend calls the method with `stream: true` and gets updates via `onToken`. See the methods reference for the full pattern.
+
 ### Auth
 - Not every app needs auth, and even for apps that do need auth, not every screen needs auth. Think intentionally about places where auth is required. Don't make auth be the first thing a user sees - that's jarring. Only show auth at intuitive and natural moments in the user's journey - be thoughtful about how to implement auth in the UI.
 - Frontend interfaces are always untrusted. Always enforce auth in backend methods. Use frontend auth and role information as a hint to conditionally show/hide UI to make the experience pleasant and seamless for users depending on their state, but remember to always use backend methods for gating data that is conditional on auth.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/remy",
-  "version": "0.1.139",
+  "version": "0.1.140",
   "description": "MindStudio coding agent",
   "repository": {
     "type": "git",