@mindstudio-ai/remy 0.1.331 → 0.1.332

package/README.md

@@ -279,12 +279,11 @@ Send a user message to the agent.
 
 Fields:
 - `requestId` — caller-provided correlation ID (echoed on all response events)
-- `text` — the user message (required unless `runCommand` is set)
+- `text` — the user message
 - `onboardingState` — the project's onboarding phase, reflected in the system prompt's dynamic tail and plan-status behavior. One of: `intake`, `building`, `buildComplete`, `onboardingFinished` (default: `onboardingFinished`)
 - `attachments` — array of `{ url, extractedTextUrl? }` for file attachments
-- `runCommand` — triggers a built-in action prompt (`"sync"`, `"publish"`, `"buildFromInitialSpec"`)
 
-When `runCommand` is set, the message text is replaced with a built-in prompt and the user message is marked as `hidden` in conversation history (sent to the LLM but not shown in the UI).
+Built-in actions are triggered by sending their sentinel as the `text` — `@@automated::<name>@@` — which resolves to the action's prompt. See `src/automatedActions/`.
 
 #### `tool_result`
 
@@ -302,7 +301,7 @@ Return the full conversation history.
 {"action": "get_history", "requestId": "r2"}
 ```
 
-Messages with `hidden: true` were generated by `runCommand` actions and should not be displayed in the UI.
+Messages with `hidden: true` are internal plumbing and must not be displayed: the platform's passive sweeps (background sub-agent results, the workspace-behind note) and the loop guard's nudges to the model. They are sent to the LLM and are not anything a person said, whatever role they carry. Automated actions are *not* hidden — clients render those from their `@@automated::` prefix.
 
 The response also includes `queuedMessages` — the current pending-queue snapshot (possibly empty) — so a client can render the queue immediately on connect/reconnect. Live changes after that arrive via `queue_changed`.
 

package/dist/headless.d.ts

@@ -93,6 +93,15 @@ declare class HeadlessSession {
      * Persisted to .remy-stats.json alongside the queue.
      */
     private passivePen;
+    /**
+     * The workspace-behind note, and the upstream tip it was raised for.
+     *
+     * Rides the same sweep as the passive pen and for the same reason: a
+     * workspace that is behind is worth knowing about before the next piece of
+     * work, and worth nothing at all if nobody is working — so it must never
+     * initiate a turn of its own.
+     */
+    private workspaceNotice;
     private pendingTools;
     private earlyResults;
     private pendingBlockUpdates;
@@ -119,6 +128,19 @@ declare class HeadlessSession {
     private dispatchSimple;
     /** Persist sessionStats + queue snapshot + passive pen to .remy-stats.json. */
     private persistStats;
+    /**
+     * Park a note if this workspace is missing work that is already in production.
+     *
+     * Once per upstream tip rather than once per boot. Remy restarts for reasons
+     * that have nothing to do with the repo — a pod recycle, a crash, a new
+     * session — and re-raising the same note on each of those turns a useful
+     * signal into nagging. A colleague publishing again moves the tip, which
+     * re-arms it; bringing the workspace current means there is nothing to raise.
+     *
+     * Never throws: this is called unawaited from the boot path, so an unhandled
+     * rejection here would be a crash at the least recoverable moment.
+     */
+    private checkUpstream;
     /** Apply queued tool block updates to state.messages. Safe to call any time. */
     private applyPendingBlockUpdates;
     /**

package/dist/headless.js

@@ -183,6 +183,10 @@ var RepetitionDetector = class {
 
 // src/api.ts
 var log2 = createLogger("api");
+function sandboxSessionHeader() {
+  const sessionId = process.env.MINDSTUDIO_SESSION_ID;
+  return sessionId ? { "x-sandbox-session": sessionId } : {};
+}
 async function* streamChat(params) {
   const { baseUrl: baseUrl2, apiKey, signal, requestId, model, ...rest } = params;
   const url = `${baseUrl2}/_internal/v2/agent/remy/chat`;
@@ -202,7 +206,8 @@ async function* streamChat(params) {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+        Authorization: `Bearer ${apiKey}`,
+        ...sandboxSessionHeader()
       },
       body: JSON.stringify(requestBody),
       signal
@@ -466,7 +471,8 @@ async function generateBackgroundAck(params) {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${params.apiConfig.apiKey}`
+        Authorization: `Bearer ${params.apiConfig.apiKey}`,
+        ...sandboxSessionHeader()
       },
       body: JSON.stringify({
         appId: params.apiConfig.appId,
@@ -1141,6 +1147,33 @@ ${xml}
 </background_results>`;
   return automatedMessage("background_results", body);
 }
+function buildWorkspaceStatusMessage(status) {
+  const lines = [
+    `Default branch tip: ${status.upstream}`,
+    `Checked at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `Behind by: ${status.behind === null ? "unknown (could not count \u2014 treat the list below as what is missing)" : `${status.behind} commit(s)`}`,
+    `Unpushed commits here: ${status.ahead === null ? "unknown" : status.ahead}`,
+    `Uncommitted changes here: ${status.dirty === "unknown" ? "could not tell \u2014 check with `git status` before relying on it" : status.dirty ? "yes" : "no"}`
+  ];
+  if (status.incoming.length > 0) {
+    lines.push(
+      "",
+      status.incomingTruncated ? `Landed on the default branch since, newest first (first ${status.incoming.length}; there are more):` : "Landed on the default branch since, newest first:",
+      ...status.incoming.map((line) => `- ${escapeForEnvelope(line)}`)
+    );
+  }
+  const body = `<workspace_status>
+Automated note about this workspace, checked when Remy started \u2014 the timestamp below says when, and it may have been a while. This block is not from the user; anything outside it is. Nobody has seen it, and nobody can see it; it is context for you.
+
+This copy of the app does not have everything on the branch production builds from.
+
+${lines.join("\n")}
+</workspace_status>`;
+  return automatedMessage("workspace_status", body);
+}
+function escapeForEnvelope(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/@@automated/g, "@ @automated");
+}
 function mergeBackgroundResultsMessages(messages) {
   const results = [];
   const toolRe = /<tool_result id="([^"]+)" name="([^"]+)">\n([\s\S]*?)\n<\/tool_result>/g;
@@ -3760,6 +3793,7 @@ var INTERNAL_PAYLOAD_MARKERS = [
   "[INTERRUPTED]",
   "[INTERRUPTED - PARTIAL OUTPUT RETRIEVED]",
   "<background_results>",
+  "<workspace_status>",
   "<tool_result"
 ];
 function sanitizeStatusText(text) {
@@ -3814,7 +3848,11 @@ function startStatusWatcher(config) {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${apiConfig.apiKey}`
+          Authorization: `Bearer ${apiConfig.apiKey}`,
+          // Also a liveness signal for this box, and the most frequent one there is — this ticks
+          // every few seconds for as long as the agent is working, which is exactly the window in
+          // which the user may have backgrounded the tab and stopped its own keepalive.
+          ...sandboxSessionHeader()
         },
         body: JSON.stringify({ appId: apiConfig.appId, context }),
         signal
@@ -4831,7 +4869,7 @@ TypeScript running in a sandboxed environment. Any npm package can be installed.
 - Managed SQLite database with typed schemas and automatic migrations. Define a TypeScript interface, push, and the platform handles diffing and migrating.
 - Built-in app-managed auth. Opt-in via manifest \u2014 developer builds login UI, platform handles verification codes (email-code, sms-code) and cookie sessions. API key auth for programmatic access. No OAuth, no social login (no Apple, Google, Facebook, or GitHub sign-in). Backend methods use auth.requireRole() for access control.
 - Encrypted secrets with separate dev/prod values, injected as process.env. For third-party service credentials not covered by the SDK.
-- Git-native deployment. Push to default branch to deploy.
+- Git-native deployment. Each person with edit access works in their own copy of the app, and everyone publishes to the same default branch, which is what deploys. Pushing any other branch builds a private preview instead. Rollback is a git revert.
 
 ## MindStudio SDK
 
@@ -7867,6 +7905,9 @@ function serializeForSummary(messages) {
       }
       continue;
     }
+    if (msg.role === "user" && (msg.hidden || typeof msg.content === "string" && isAutomatedMessage(msg.content))) {
+      continue;
+    }
     if (typeof msg.content === "string") {
       if (msg.content.trim()) {
         lines.push(`[${msg.role}]: ${msg.content}`);
@@ -9026,7 +9067,10 @@ function parsePartialJson(jsonString) {
 }
 
 // src/automatedActions/resolve.ts
-var NON_ACTION_SENTINELS = /* @__PURE__ */ new Set(["background_results"]);
+var NON_ACTION_SENTINELS = /* @__PURE__ */ new Set([
+  "background_results",
+  "workspace_status"
+]);
 function resolveAction(text) {
   const parsed = parseSentinel(text);
   if (!parsed) {
@@ -9402,7 +9446,9 @@ async function runTurn(params) {
   for (const entry of keptEntries) {
     appendEntry(entry);
   }
-  const isFirstMessage = state.messages.filter((m) => m.role === "user").length === 1;
+  const isFirstMessage = state.messages.filter(
+    (m) => m.role === "user" && !m.hidden && !(typeof m.content === "string" && isAutomatedMessage(m.content))
+  ).length === 1;
   const STATUS_EXCLUDED_TOOLS = /* @__PURE__ */ new Set([
     "markBuildComplete",
     "setProjectMetadata",
@@ -10296,7 +10342,24 @@ function loadPassiveResults() {
   }
   return [];
 }
-function writeStats(stats, queue, passiveResults, suggestCompactAt) {
+function emptyWorkspaceNotice() {
+  return { pendingNote: null, lastNotedUpstream: null };
+}
+function loadWorkspaceNotice() {
+  try {
+    const stats = JSON.parse(readFileSync2(STATS_FILE, "utf-8"));
+    const notice = stats.workspaceNotice;
+    if (notice && typeof notice === "object") {
+      return {
+        pendingNote: typeof notice.pendingNote === "string" ? notice.pendingNote : null,
+        lastNotedUpstream: typeof notice.lastNotedUpstream === "string" ? notice.lastNotedUpstream : null
+      };
+    }
+  } catch {
+  }
+  return emptyWorkspaceNotice();
+}
+function writeStats(stats, queue, passiveResults, suggestCompactAt, workspaceNotice) {
   try {
     writeFileAtomicSync(
       STATS_FILE,
@@ -10304,13 +10367,134 @@ function writeStats(stats, queue, passiveResults, suggestCompactAt) {
         ...stats,
         suggestCompactAt,
         queue,
-        passiveResults
+        passiveResults,
+        workspaceNotice
       })
     );
   } catch {
   }
 }
 
+// src/git/upstreamStatus.ts
+import { execFile as execFile2 } from "child_process";
+var log17 = createLogger("upstream");
+var DEFAULT_BRANCH = "main";
+var MAX_INCOMING = 20;
+var FETCH_TIMEOUT_MS = 3e4;
+var GIT_TIMEOUT_MS = 1e4;
+var MAX_BUFFER_BYTES = 32 * 1024 * 1024;
+function git(args, timeout = GIT_TIMEOUT_MS) {
+  return new Promise((resolve4) => {
+    const child = execFile2(
+      "git",
+      args,
+      {
+        cwd: PROJECT_ROOT,
+        encoding: "utf-8",
+        timeout,
+        maxBuffer: MAX_BUFFER_BYTES,
+        // No controlling tty in a box, but an inherited one anywhere else would
+        // let a credential prompt hold the whole timeout open.
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+        // execFile's `timeout` sends SIGTERM, which a wedged `git-remote-https`
+        // can ignore. Escalate so the boot path cannot be held by one.
+        killSignal: "SIGKILL"
+      },
+      (err, stdout, stderr) => {
+        resolve4({
+          ok: !err,
+          stdout: (stdout ?? "").trim(),
+          // Kept so a failure can say WHY. For a probe whose entire failure
+          // model is silence, this is the only line that makes it debuggable.
+          error: err ? (stderr || "").trim() || err.message : null
+        });
+      }
+    );
+    child.on("error", () => {
+    });
+  });
+}
+async function readUpstreamStatus() {
+  const inRepo = await git(["rev-parse", "--git-dir"]);
+  if (!inRepo.ok) {
+    return null;
+  }
+  const fetched = await git(
+    ["fetch", "origin", DEFAULT_BRANCH],
+    FETCH_TIMEOUT_MS
+  );
+  if (!fetched.ok) {
+    log17.info(
+      `fetch failed, falling back to the origin/${DEFAULT_BRANCH} on disk: ${fetched.error}`
+    );
+  }
+  const [upstreamRef, headRef] = await Promise.all([
+    git(["rev-parse", `origin/${DEFAULT_BRANCH}`]),
+    git(["rev-parse", "HEAD"])
+  ]);
+  if (!upstreamRef.ok || !headRef.ok) {
+    return null;
+  }
+  const upstream = upstreamRef.stdout;
+  if (upstream === headRef.stdout) {
+    return null;
+  }
+  const incomingResult = await git([
+    "log",
+    `--max-count=${MAX_INCOMING + 1}`,
+    "--format=%an: %s",
+    `HEAD..origin/${DEFAULT_BRANCH}`
+  ]);
+  const incomingLines = incomingResult.ok ? incomingResult.stdout.split("\n").filter((line) => line.length > 0) : [];
+  if (incomingResult.ok && incomingLines.length === 0) {
+    return null;
+  }
+  let behind = null;
+  let ahead = null;
+  const counts = await git([
+    "rev-list",
+    "--left-right",
+    "--count",
+    `origin/${DEFAULT_BRANCH}...HEAD`
+  ]);
+  if (counts.ok) {
+    const [left, right] = counts.stdout.split(/\s+/);
+    behind = Number(left);
+    ahead = Number(right);
+    if (!Number.isFinite(behind) || behind <= 0) {
+      return null;
+    }
+    if (!Number.isFinite(ahead)) {
+      ahead = null;
+    }
+  } else if (!incomingResult.ok) {
+    const contained = await git([
+      "merge-base",
+      "--is-ancestor",
+      `origin/${DEFAULT_BRANCH}`,
+      "HEAD"
+    ]);
+    if (contained.ok) {
+      return null;
+    }
+    log17.info(
+      `behind by an unknown amount: rev-list and log both failed (${counts.error})`
+    );
+  }
+  const status = await git(["status", "--porcelain"]);
+  if (!status.ok) {
+    log17.info(`could not read the working tree state: ${status.error}`);
+  }
+  return {
+    upstream,
+    behind,
+    ahead,
+    dirty: status.ok ? status.stdout.length > 0 : "unknown",
+    incoming: incomingLines.slice(0, MAX_INCOMING),
+    incomingTruncated: incomingLines.length > MAX_INCOMING
+  };
+}
+
 // src/headless/messageQueue.ts
 function holdRestoredUserItems(items) {
   return items.map(
@@ -10517,7 +10701,7 @@ var MessageQueue = class {
 };
 
 // src/headless/index.ts
-var log17 = createLogger("headless");
+var log18 = createLogger("headless");
 var EXTERNAL_TOOL_TIMEOUT_MS = 3e5;
 var LONG_RUNNING_TOOLS = /* @__PURE__ */ new Set(["runMethod", "testJewel"]);
 var LONG_RUNNING_TOOL_TIMEOUT_MS = 18e5;
@@ -10581,6 +10765,15 @@ var HeadlessSession = class {
    * Persisted to .remy-stats.json alongside the queue.
    */
   passivePen = [];
+  /**
+   * The workspace-behind note, and the upstream tip it was raised for.
+   *
+   * Rides the same sweep as the passive pen and for the same reason: a
+   * workspace that is behind is worth knowing about before the next piece of
+   * work, and worth nothing at all if nobody is working — so it must never
+   * initiate a turn of its own.
+   */
+  workspaceNotice = emptyWorkspaceNotice();
   // External tool bridge
   pendingTools = /* @__PURE__ */ new Map();
   earlyResults = /* @__PURE__ */ new Map();
@@ -10627,6 +10820,8 @@ var HeadlessSession = class {
       }
     );
     this.passivePen = loadPassiveResults();
+    this.workspaceNotice = loadWorkspaceNotice();
+    void this.checkUpstream();
     this.persistStats();
     if (resumed) {
       this.emit("session_restored", {
@@ -10750,7 +10945,7 @@ var HeadlessSession = class {
     try {
       this.handleCancel("shutdown");
     } catch (err) {
-      log17.warn("Shutdown cancel failed", { error: err?.message });
+      log18.warn("Shutdown cancel failed", { error: err?.message });
     }
     this.emit("stopping");
     this.emit("stopped");
@@ -10766,7 +10961,7 @@ var HeadlessSession = class {
     }
     const line = JSON.stringify(payload) + "\n";
     if (event === "history") {
-      log17.info("Wrote history event to stdout", {
+      log18.info("Wrote history event to stdout", {
         requestId,
         bytes: line.length
       });
@@ -10813,9 +11008,45 @@ var HeadlessSession = class {
       this.sessionStats,
       this.queue.snapshot(),
       this.passivePen,
-      suggestCompactAt
+      suggestCompactAt,
+      this.workspaceNotice
     );
   }
+  /**
+   * Park a note if this workspace is missing work that is already in production.
+   *
+   * Once per upstream tip rather than once per boot. Remy restarts for reasons
+   * that have nothing to do with the repo — a pod recycle, a crash, a new
+   * session — and re-raising the same note on each of those turns a useful
+   * signal into nagging. A colleague publishing again moves the tip, which
+   * re-arms it; bringing the workspace current means there is nothing to raise.
+   *
+   * Never throws: this is called unawaited from the boot path, so an unhandled
+   * rejection here would be a crash at the least recoverable moment.
+   */
+  async checkUpstream() {
+    try {
+      const status = await readUpstreamStatus();
+      if (!status || status.upstream === this.workspaceNotice.lastNotedUpstream) {
+        return;
+      }
+      this.workspaceNotice = {
+        pendingNote: buildWorkspaceStatusMessage(status),
+        lastNotedUpstream: status.upstream
+      };
+      this.persistStats();
+      log18.info("workspace behind upstream; note parked for the next turn", {
+        // The upstream sha is the dedupe key, so it is what makes "why did I
+        // not get a note" answerable from the log alone.
+        upstream: status.upstream,
+        behind: status.behind,
+        ahead: status.ahead,
+        dirty: status.dirty
+      });
+    } catch (err) {
+      log18.info(`upstream check failed: ${String(err)}`);
+    }
+  }
   //////////////////////////////////////////////////////////////////////////////
   // Background completions (tool-block mutation; message delivery via queue)
   //////////////////////////////////////////////////////////////////////////////
@@ -10862,7 +11093,7 @@ var HeadlessSession = class {
     if (this.sessionStats.lastContextSize <= threshold) {
       return;
     }
-    log17.info("Forced compaction gate triggered", {
+    log18.info("Forced compaction gate triggered", {
       contextSize: this.sessionStats.lastContextSize,
       threshold,
       model: parentModel,
@@ -10882,7 +11113,7 @@ var HeadlessSession = class {
   onBackgroundComplete = (toolCallId, name, result, subAgentMessages) => {
     const notify = getToolByName(name)?.backgroundNotify ?? "wake";
     this.pendingBlockUpdates.push({ toolCallId, result, subAgentMessages });
-    log17.info("Background complete", {
+    log18.info("Background complete", {
       toolCallId,
       name,
       notify,
@@ -11164,7 +11395,7 @@ var HeadlessSession = class {
       const { documents, images } = await persistAttachments(attachments);
       return buildUploadHeader(documents, images) || void 0;
     } catch (err) {
-      log17.warn("Attachment persistence failed", { error: err.message });
+      log18.warn("Attachment persistence failed", { error: err.message });
       return void 0;
     }
   }
@@ -11224,7 +11455,7 @@ var HeadlessSession = class {
     }
     if (batch.length === 0) {
       if (landings > 0) {
-        log17.info("promptUser store landings passed through", { landings });
+        log18.info("promptUser store landings passed through", { landings });
       }
       return raw;
     }
@@ -11232,7 +11463,7 @@ var HeadlessSession = class {
     try {
       results = await persistAttachmentList(batch);
     } catch (err) {
-      log17.warn("promptUser upload persistence failed", {
+      log18.warn("promptUser upload persistence failed", {
         error: err.message
       });
       results = batch.map(() => null);
@@ -11244,7 +11475,7 @@ var HeadlessSession = class {
           return r.localPath;
         }
         const att = batch[cursor + i];
-        log17.warn("promptUser upload not persisted; falling back to url", {
+        log18.warn("promptUser upload not persisted; falling back to url", {
           filename: att.filename
         });
         return att.url;
@@ -11252,7 +11483,7 @@ var HeadlessSession = class {
       cursor += slot.count;
       answers[slot.id] = slot.isArray ? paths : paths[0];
     }
-    log17.info("promptUser uploads persisted", { count: batch.length });
+    log18.info("promptUser uploads persisted", { count: batch.length });
     return JSON.stringify(answers);
   }
   /**
@@ -11275,7 +11506,7 @@ var HeadlessSession = class {
   async runSingleTurn(parsed, requestId, fromChain = false, queued = false) {
     const attachments = parsed.attachments;
     if (attachments?.length) {
-      log17.info("Message has attachments", {
+      log18.info("Message has attachments", {
         count: attachments.length,
         urls: attachments.map((a) => a.url)
       });
@@ -11423,6 +11654,18 @@ var HeadlessSession = class {
         hidden: true
       });
     }
+    const hasUserWords = entries.some(
+      (entry) => !entry.hidden && !isAutomatedMessage(entry.text)
+    );
+    if (this.workspaceNotice.pendingNote && hasUserWords) {
+      const note = this.workspaceNotice.pendingNote;
+      this.workspaceNotice = {
+        ...this.workspaceNotice,
+        pendingNote: null
+      };
+      this.persistStats();
+      entries.unshift({ text: note, hidden: true });
+    }
     const consumedRids = [];
     const takeSteering = async () => {
       const items = this.queue.removeWhere(
@@ -11475,7 +11718,7 @@ var HeadlessSession = class {
           error: "Turn ended unexpectedly"
         });
       }
-      log17.info("Turn complete", {
+      log18.info("Turn complete", {
         requestId,
         durationMs: Date.now() - this.turnStart
       });
@@ -11487,7 +11730,7 @@ var HeadlessSession = class {
           error: err.message
         });
       }
-      log17.warn("Command failed", {
+      log18.warn("Command failed", {
         action: "message",
         requestId,
         error: err.message
@@ -11794,7 +12037,7 @@ var HeadlessSession = class {
     try {
       parsed = JSON.parse(line);
     } catch (err) {
-      log17.warn("Invalid JSON on stdin", {
+      log18.warn("Invalid JSON on stdin", {
         error: err.message,
         lineLength: line.length,
         preview: line.slice(0, 200)
@@ -11803,7 +12046,7 @@ var HeadlessSession = class {
       return;
     }
     const { action, requestId } = parsed;
-    log17.info("Command received", { action, requestId });
+    log18.info("Command received", { action, requestId });
     if (action === "tool_result" && parsed.id) {
       const id = parsed.id;
       const result = parsed.result ?? "";
@@ -11812,7 +12055,7 @@ var HeadlessSession = class {
         this.pendingTools.delete(id);
         pending2.resolve(result);
       } else if (!this.running) {
-        log17.info("Late tool_result while idle, dismissing", { id });
+        log18.info("Late tool_result while idle, dismissing", { id });
         this.emit("completed", { success: true }, requestId);
       } else {
         this.earlyResults.set(id, result);
@@ -11825,7 +12068,7 @@ var HeadlessSession = class {
         ...typeof parsed.before === "number" ? { before: parsed.before } : {},
         ...typeof parsed.limit === "number" ? { limit: parsed.limit } : {}
       });
-      log17.info("History response", {
+      log18.info("History response", {
         requestId,
         startIndex: page.startIndex,
         endIndex: page.endIndex,