@mindstudio-ai/remy 0.1.99 → 0.1.101

package/dist/automatedActions/buildFromInitialSpec.md

@@ -12,7 +12,9 @@ If you are building a web frontend, consult `visualDesignExpert` for guidance an
 
 Then, build everything in one turn: methods, tables, interfaces, manifest updates, and scenarios, using the spec as the master plan. Be sure to delete any unnecessary files from the "Hello World" scaffold that already exist in the project - don't forget to update the page metadata on index.html too.
 
-When code generation is complete, verify your work: 
+When code generation is complete, do a polish pass before verifying. Re-read the spec annotations and the design expert's guidance, then walk through each frontend file looking for design details that got skipped in the initial build: animations, transitions, hover states, micro-interactions, spring physics, entrance reveals, gesture handling, layout issues, and anything else. The initial build prioritizes getting everything connected and functional, but this pass closes the gap between "it works" and "it feels great." In many ways this is the most important part of the initial build, as the user's first experience of the deliverable will set their expectations for every iteration that follows. Don't mess this up.
+
+Then verify: 
 - First, run use `runScenario` to seed test data, then use `runMethod` to confirm a method works 
 - If the app has a web frontend, check the browser logs to make sure there are no errors rendering it.
 - Ask the `visualDesignExpert` to take a screenshot and verity that the visual design looks correct. Fix any issues it flags - we want the user's first time seeing the finished product to truly wow them.

package/dist/headless.js

@@ -1051,6 +1051,18 @@ function unifiedDiff(filePath, oldText, newText) {
   return lines.join("\n");
 }
 
+// src/tools/_helpers/fileLock.ts
+var locks = /* @__PURE__ */ new Map();
+function acquireFileLock(filePath) {
+  let release;
+  const next = new Promise((res) => {
+    release = res;
+  });
+  const wait = locks.get(filePath) ?? Promise.resolve();
+  locks.set(filePath, next);
+  return wait.then(() => release);
+}
+
 // src/tools/spec/writeSpec.ts
 var writeSpecTool = {
   clearable: true,
@@ -1086,6 +1098,7 @@ ${unifiedDiff(partial.path, oldContent, partial.content)}`;
     } catch (err) {
       return `Error: ${err.message}`;
     }
+    const release = await acquireFileLock(input.path);
     try {
       await fs6.mkdir(path4.dirname(input.path), { recursive: true });
       let oldContent = null;
@@ -1100,6 +1113,8 @@ ${unifiedDiff(partial.path, oldContent, partial.content)}`;
 ${unifiedDiff(input.path, oldContent ?? "", input.content)}`;
     } catch (err) {
       return `Error writing file: ${err.message}`;
+    } finally {
+      release();
     }
   }
 };
@@ -1151,69 +1166,74 @@ var editSpecTool = {
     } catch (err) {
       return `Error: ${err.message}`;
     }
-    let originalContent;
+    const release = await acquireFileLock(input.path);
     try {
-      originalContent = await fs7.readFile(input.path, "utf-8");
-    } catch (err) {
-      return `Error reading file: ${err.message}`;
-    }
-    let content = originalContent;
-    for (const edit of input.edits) {
-      let range;
+      let originalContent;
       try {
-        range = resolveHeadingPath(content, edit.heading);
+        originalContent = await fs7.readFile(input.path, "utf-8");
       } catch (err) {
-        const tree = getHeadingTree(content);
-        return `Error: ${err.message}
+        return `Error reading file: ${err.message}`;
+      }
+      let content = originalContent;
+      for (const edit of input.edits) {
+        let range;
+        try {
+          range = resolveHeadingPath(content, edit.heading);
+        } catch (err) {
+          const tree = getHeadingTree(content);
+          return `Error: ${err.message}
 
 Document structure:
 ${tree}`;
-      }
-      const lines = content.split("\n");
-      switch (edit.operation) {
-        case "replace": {
-          if (edit.content == null) {
-            return 'Error: "content" is required for replace operations.';
-          }
-          const contentLines = edit.content.split("\n");
-          lines.splice(
-            range.contentStart,
-            range.contentEnd - range.contentStart,
-            ...contentLines
-          );
-          break;
         }
-        case "insert_after": {
-          if (edit.content == null) {
-            return 'Error: "content" is required for insert_after operations.';
+        const lines = content.split("\n");
+        switch (edit.operation) {
+          case "replace": {
+            if (edit.content == null) {
+              return 'Error: "content" is required for replace operations.';
+            }
+            const contentLines = edit.content.split("\n");
+            lines.splice(
+              range.contentStart,
+              range.contentEnd - range.contentStart,
+              ...contentLines
+            );
+            break;
           }
-          const contentLines = edit.content.split("\n");
-          lines.splice(range.contentEnd, 0, ...contentLines);
-          break;
-        }
-        case "insert_before": {
-          if (edit.content == null) {
-            return 'Error: "content" is required for insert_before operations.';
+          case "insert_after": {
+            if (edit.content == null) {
+              return 'Error: "content" is required for insert_after operations.';
+            }
+            const contentLines = edit.content.split("\n");
+            lines.splice(range.contentEnd, 0, ...contentLines);
+            break;
           }
-          const contentLines = edit.content.split("\n");
-          lines.splice(range.startLine, 0, ...contentLines);
-          break;
-        }
-        case "delete": {
-          lines.splice(range.startLine, range.contentEnd - range.startLine);
-          break;
+          case "insert_before": {
+            if (edit.content == null) {
+              return 'Error: "content" is required for insert_before operations.';
+            }
+            const contentLines = edit.content.split("\n");
+            lines.splice(range.startLine, 0, ...contentLines);
+            break;
+          }
+          case "delete": {
+            lines.splice(range.startLine, range.contentEnd - range.startLine);
+            break;
+          }
+          default:
+            return `Error: Unknown operation "${edit.operation}". Use replace, insert_after, insert_before, or delete.`;
         }
-        default:
-          return `Error: Unknown operation "${edit.operation}". Use replace, insert_after, insert_before, or delete.`;
+        content = lines.join("\n");
       }
-      content = lines.join("\n");
-    }
-    try {
-      await fs7.writeFile(input.path, content, "utf-8");
-    } catch (err) {
-      return `Error writing file: ${err.message}`;
+      try {
+        await fs7.writeFile(input.path, content, "utf-8");
+      } catch (err) {
+        return `Error writing file: ${err.message}`;
+      }
+      return unifiedDiff(input.path, originalContent, content);
+    } finally {
+      release();
     }
-    return unifiedDiff(input.path, originalContent, content);
   }
 };
 
@@ -1825,6 +1845,7 @@ ${unifiedDiff(partial.path, oldContent, completeContent)}`;
     };
   })(),
   async execute(input) {
+    const release = await acquireFileLock(input.path);
     try {
       await fs10.mkdir(path6.dirname(input.path), { recursive: true });
       let oldContent = null;
@@ -1839,6 +1860,8 @@ ${unifiedDiff(partial.path, oldContent, completeContent)}`;
 ${unifiedDiff(input.path, oldContent ?? "", input.content)}`;
     } catch (err) {
       return `Error writing file: ${err.message}`;
+    } finally {
+      release();
     }
   }
 };
@@ -1955,6 +1978,7 @@ var editFileTool = {
     }
   },
   async execute(input) {
+    const release = await acquireFileLock(input.path);
     try {
       const content = await fs11.readFile(input.path, "utf-8");
       const { old_string, new_string, replace_all } = input;
@@ -2006,6 +2030,8 @@ ${unifiedDiff(input.path, content, updated)}`;
       return `Error: old_string not found in ${input.path}. Make sure you've read the file first and copied the exact text.`;
     } catch (err) {
       return `Error editing file: ${err.message}`;
+    } finally {
+      release();
     }
   }
 };

package/dist/index.js

@@ -502,6 +502,24 @@ var init_diff = __esm({
   }
 });
 
+// src/tools/_helpers/fileLock.ts
+function acquireFileLock(filePath) {
+  let release;
+  const next = new Promise((res) => {
+    release = res;
+  });
+  const wait = locks.get(filePath) ?? Promise.resolve();
+  locks.set(filePath, next);
+  return wait.then(() => release);
+}
+var locks;
+var init_fileLock = __esm({
+  "src/tools/_helpers/fileLock.ts"() {
+    "use strict";
+    locks = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/tools/spec/writeSpec.ts
 import fs3 from "fs/promises";
 import path from "path";
@@ -511,6 +529,7 @@ var init_writeSpec = __esm({
     "use strict";
     init_helpers();
     init_diff();
+    init_fileLock();
     writeSpecTool = {
       clearable: true,
       definition: {
@@ -545,6 +564,7 @@ ${unifiedDiff(partial.path, oldContent, partial.content)}`;
         } catch (err) {
           return `Error: ${err.message}`;
         }
+        const release = await acquireFileLock(input.path);
         try {
           await fs3.mkdir(path.dirname(input.path), { recursive: true });
           let oldContent = null;
@@ -559,6 +579,8 @@ ${unifiedDiff(partial.path, oldContent, partial.content)}`;
 ${unifiedDiff(input.path, oldContent ?? "", input.content)}`;
         } catch (err) {
           return `Error writing file: ${err.message}`;
+        } finally {
+          release();
         }
       }
     };
@@ -573,6 +595,7 @@ var init_editSpec = __esm({
     "use strict";
     init_helpers();
     init_diff();
+    init_fileLock();
     editSpecTool = {
       clearable: true,
       definition: {
@@ -618,69 +641,74 @@ var init_editSpec = __esm({
         } catch (err) {
           return `Error: ${err.message}`;
         }
-        let originalContent;
+        const release = await acquireFileLock(input.path);
         try {
-          originalContent = await fs4.readFile(input.path, "utf-8");
-        } catch (err) {
-          return `Error reading file: ${err.message}`;
-        }
-        let content = originalContent;
-        for (const edit of input.edits) {
-          let range;
+          let originalContent;
           try {
-            range = resolveHeadingPath(content, edit.heading);
+            originalContent = await fs4.readFile(input.path, "utf-8");
           } catch (err) {
-            const tree = getHeadingTree(content);
-            return `Error: ${err.message}
+            return `Error reading file: ${err.message}`;
+          }
+          let content = originalContent;
+          for (const edit of input.edits) {
+            let range;
+            try {
+              range = resolveHeadingPath(content, edit.heading);
+            } catch (err) {
+              const tree = getHeadingTree(content);
+              return `Error: ${err.message}
 
 Document structure:
 ${tree}`;
-          }
-          const lines = content.split("\n");
-          switch (edit.operation) {
-            case "replace": {
-              if (edit.content == null) {
-                return 'Error: "content" is required for replace operations.';
-              }
-              const contentLines = edit.content.split("\n");
-              lines.splice(
-                range.contentStart,
-                range.contentEnd - range.contentStart,
-                ...contentLines
-              );
-              break;
             }
-            case "insert_after": {
-              if (edit.content == null) {
-                return 'Error: "content" is required for insert_after operations.';
+            const lines = content.split("\n");
+            switch (edit.operation) {
+              case "replace": {
+                if (edit.content == null) {
+                  return 'Error: "content" is required for replace operations.';
+                }
+                const contentLines = edit.content.split("\n");
+                lines.splice(
+                  range.contentStart,
+                  range.contentEnd - range.contentStart,
+                  ...contentLines
+                );
+                break;
               }
-              const contentLines = edit.content.split("\n");
-              lines.splice(range.contentEnd, 0, ...contentLines);
-              break;
-            }
-            case "insert_before": {
-              if (edit.content == null) {
-                return 'Error: "content" is required for insert_before operations.';
+              case "insert_after": {
+                if (edit.content == null) {
+                  return 'Error: "content" is required for insert_after operations.';
+                }
+                const contentLines = edit.content.split("\n");
+                lines.splice(range.contentEnd, 0, ...contentLines);
+                break;
               }
-              const contentLines = edit.content.split("\n");
-              lines.splice(range.startLine, 0, ...contentLines);
-              break;
-            }
-            case "delete": {
-              lines.splice(range.startLine, range.contentEnd - range.startLine);
-              break;
+              case "insert_before": {
+                if (edit.content == null) {
+                  return 'Error: "content" is required for insert_before operations.';
+                }
+                const contentLines = edit.content.split("\n");
+                lines.splice(range.startLine, 0, ...contentLines);
+                break;
+              }
+              case "delete": {
+                lines.splice(range.startLine, range.contentEnd - range.startLine);
+                break;
+              }
+              default:
+                return `Error: Unknown operation "${edit.operation}". Use replace, insert_after, insert_before, or delete.`;
             }
-            default:
-              return `Error: Unknown operation "${edit.operation}". Use replace, insert_after, insert_before, or delete.`;
+            content = lines.join("\n");
           }
-          content = lines.join("\n");
-        }
-        try {
-          await fs4.writeFile(input.path, content, "utf-8");
-        } catch (err) {
-          return `Error writing file: ${err.message}`;
+          try {
+            await fs4.writeFile(input.path, content, "utf-8");
+          } catch (err) {
+            return `Error writing file: ${err.message}`;
+          }
+          return unifiedDiff(input.path, originalContent, content);
+        } finally {
+          release();
         }
-        return unifiedDiff(input.path, originalContent, content);
       }
     };
   }
@@ -1335,6 +1363,7 @@ var init_writeFile = __esm({
   "src/tools/code/writeFile.ts"() {
     "use strict";
     init_diff();
+    init_fileLock();
     writeFileTool = {
       clearable: true,
       definition: {
@@ -1378,6 +1407,7 @@ ${unifiedDiff(partial.path, oldContent, completeContent)}`;
         };
       })(),
       async execute(input) {
+        const release = await acquireFileLock(input.path);
         try {
           await fs7.mkdir(path3.dirname(input.path), { recursive: true });
           let oldContent = null;
@@ -1392,6 +1422,8 @@ ${unifiedDiff(partial.path, oldContent, completeContent)}`;
 ${unifiedDiff(input.path, oldContent ?? "", input.content)}`;
         } catch (err) {
           return `Error writing file: ${err.message}`;
+        } finally {
+          release();
         }
       }
     };
@@ -1489,6 +1521,7 @@ var init_editFile = __esm({
   "src/tools/code/editFile/index.ts"() {
     "use strict";
     init_diff();
+    init_fileLock();
     init_helpers2();
     editFileTool = {
       clearable: true,
@@ -1519,6 +1552,7 @@ var init_editFile = __esm({
         }
       },
       async execute(input) {
+        const release = await acquireFileLock(input.path);
         try {
           const content = await fs8.readFile(input.path, "utf-8");
           const { old_string, new_string, replace_all } = input;
@@ -1570,6 +1604,8 @@ ${unifiedDiff(input.path, content, updated)}`;
           return `Error: old_string not found in ${input.path}. Make sure you've read the file first and copied the exact text.`;
         } catch (err) {
           return `Error editing file: ${err.message}`;
+        } finally {
+          release();
         }
       }
     };

package/dist/prompt/compiled/auth.md

@@ -62,7 +62,7 @@ export const Users = db.defineTable<{
 
 - **`email` / `phone`** — read-only from code. Writing via `update()` or `push()` throws a `MindStudioError`. Use the auth API to change a user's email or phone.
 - **`roles`** — read/write from both code and the dashboard. `Users.update(userId, { roles: ['admin'] })` works and syncs to the platform. Dashboard role changes sync back to the table.
-- All other columns are fully the developer's.
+- All other columns are fully the developer's. When auth creates a user row, only the managed columns (email/phone, roles) are populated. All user-defined columns start as null until the user completes onboarding — type them as optional and guard against null.
 
 ## Frontend Auth (Interface SDK)
 
@@ -129,6 +129,7 @@ await auth.logout();  // clears session
 
 ```typescript
 auth.phone.countries          // ~180 countries with { code, dialCode, name, flag }
+                              // Key selects by country code (US, CA, BB), not dial code — multiple countries share +1
 auth.phone.detectCountry()    // guess from timezone, e.g. 'US'
 auth.phone.toE164('5551234567', 'US')  // '+15551234567'
 auth.phone.format('+15551234567')      // '+1 (555) 123-4567'

package/dist/prompt/static/authoring.md

@@ -25,7 +25,7 @@ Remember: users care about look and feel as much as (and often more than) underl
 
 Write specs in natural, human language. Describe what the app does the way you'd explain it to a colleague. The spec renders with annotations hidden is a human-forward document that anyone can read. The spec with annotations visible is the agent-forward document that drives code generation. Keep the prose clean and readable — the user should never see raw CSS, code, or technical values in the prose. Write "square corners on all cards" not `border-radius: 0`. Write "no shadows" not `box-shadow: none`. Technical specifics belong in annotations.
 
-When the design expert provides specific implementation details — layout structure, CSS values, spacing, font sizes, rotation angles, shadow definitions, animation timings, or things to pay special attention to or watch out for — capture them as annotations on the relevant prose. The design expert's recommendations are precise and intentional; don't summarize them into vague language. The prose describes the intent, the annotations preserve the exact values the coder needs:
+When the design expert provides specific implementation details — layout structure, CSS values, spacing, font sizes, rotation angles, shadow definitions, animation timings, or things to pay special attention to or watch out for — it is critical that you capture them in full within the spec. The design expert's recommendations are precise and intentional; don't summarize them into vague language. The prose describes the intent, the annotations preserve the exact values the coder needs:
 
 ```markdown
 Cards float at varied angles with [rounded corners]{border-radius: 24px} on a pure black background.
@@ -37,6 +37,8 @@ box-shadow: 0 8px 32px rgba(0,0,0,0.3) for floating depth
 
 When you have image URLs (from the design expert), embed them directly in the spec using markdown image syntax. Write descriptive alt text that captures what the image actually depicts (this helps accessibility and helps the coding agent understand the image without loading it). Use the surrounding prose to explain the design intent — what the image is for, how it should be used in the layout, and why it was chosen.
 
+When the design expert provides wireframes, include them directly in the spec for future reference.
+
 ```markdown
 ### Hero Section
 

package/dist/prompt/static/coding.md

@@ -43,7 +43,7 @@ For any work involving AI models, external actions (web scraping, email, SMS), o
 - Use container queries for components that need to adapt to their container rather than the viewport.
 
 ### State Management
-- Calls to methods introduce latency. When building web frontends that load data from methods, consider front-loading as much data as you can in a single API request - e.g., when possible, load a large data object into a central store and use that to render sub-screens in an app, rather than an API call on every screen.
+- Calls to methods introduce latency. When building web frontends that load data from methods, front-load as much data as you can in a single API request - e.g., when possible, load a large data object into a central store and use that to render sub-screens in an app, rather than an API call on every screen. User experience and perceived speed/performance are far more valuable than normalization and good REST API design.
 
 ### Dependencies
 Before installing a package you haven't used in this project, do a quick web search to confirm it's still the best option. The JavaScript ecosystem moves fast — the package you remember from training may have been superseded by something smaller, faster, or better maintained. A 10-second search beats debugging a deprecated library.

package/package.json

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