@elevasis/sdk 1.44.2 → 1.44.3

package/dist/cli.cjs

@@ -43807,7 +43807,7 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   if (capabilities.message !== "off") {
     properties.message = {
       type: "string",
-      description: "Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet."
+      description: 'Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet. Write real line breaks and real quotation marks -- the two characters \\n are not a line break, and \\" is not a quotation mark. Serialization is handled for you.'
     };
   }
   properties.reasoning = { type: "string", description: "Your reasoning process" };
@@ -43827,7 +43827,15 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
             type: "object",
             properties: {
               key: { type: "string" },
-              value: { type: "string" }
+              value: {
+                type: "string",
+                // `memoryOps` has NO framework prompt section -- a grep across `prompt-sections/`
+                // returns zero memory references -- so this description is the only framework-owned
+                // lever on how a memory value is written. It matters more here than in `message`:
+                // a session-memory value is re-sent on every iteration of every subsequent turn and
+                // never ages out, so one literal escape stored here is one the model re-reads forever.
+                description: "Stored verbatim and replayed to you on every later turn. Write real line breaks and real quotation marks -- the two characters \\n are not a line break."
+              }
             },
             required: ["key", "value"],
             additionalProperties: false
@@ -46265,7 +46273,7 @@ function wrapAction(commandName, fn) {
 // package.json
 var package_default = {
   name: "@elevasis/sdk",
-  version: "1.44.2",
+  version: "1.44.3",
   description: "SDK for building Elevasis organization resources",
   type: "module",
   bin: {

package/dist/index.js

@@ -4021,7 +4021,7 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   if (capabilities.message !== "off") {
     properties.message = {
       type: "string",
-      description: "Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet."
+      description: 'Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet. Write real line breaks and real quotation marks -- the two characters \\n are not a line break, and \\" is not a quotation mark. Serialization is handled for you.'
     };
   }
   properties.reasoning = { type: "string", description: "Your reasoning process" };
@@ -4041,7 +4041,15 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
             type: "object",
             properties: {
               key: { type: "string" },
-              value: { type: "string" }
+              value: {
+                type: "string",
+                // `memoryOps` has NO framework prompt section -- a grep across `prompt-sections/`
+                // returns zero memory references -- so this description is the only framework-owned
+                // lever on how a memory value is written. It matters more here than in `message`:
+                // a session-memory value is re-sent on every iteration of every subsequent turn and
+                // never ages out, so one literal escape stored here is one the model re-reads forever.
+                description: "Stored verbatim and replayed to you on every later turn. Write real line breaks and real quotation marks -- the two characters \\n are not a line break."
+              }
             },
             required: ["key", "value"],
             additionalProperties: false

package/dist/test-utils/index.js

@@ -4479,6 +4479,11 @@ every response:
 and never continue the response envelope in the reasoning text -- nextActions is a separate field
 that you fill separately. A response carrying reasoning alone is discarded and retried.
 
+**Prose fields take real characters, never escape sequences.** A line break in ${includeMessage ? "message or reasoning" : "reasoning"} is
+a real line break -- not the two characters \\n. A quotation mark is the character ", not \\". The
+response is serialized for you; typing the escape yourself puts those literal characters into the
+stored text and in front of the reader.
+
 ## Rules
 
 - Batch independent tool calls in one iteration (faster execution)
@@ -5074,7 +5079,7 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   if (capabilities.message !== "off") {
     properties.message = {
       type: "string",
-      description: "Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet."
+      description: 'Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet. Write real line breaks and real quotation marks -- the two characters \\n are not a line break, and \\" is not a quotation mark. Serialization is handled for you.'
     };
   }
   properties.reasoning = { type: "string", description: "Your reasoning process" };
@@ -5094,7 +5099,15 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
             type: "object",
             properties: {
               key: { type: "string" },
-              value: { type: "string" }
+              value: {
+                type: "string",
+                // `memoryOps` has NO framework prompt section -- a grep across `prompt-sections/`
+                // returns zero memory references -- so this description is the only framework-owned
+                // lever on how a memory value is written. It matters more here than in `message`:
+                // a session-memory value is re-sent on every iteration of every subsequent turn and
+                // never ages out, so one literal escape stored here is one the model re-reads forever.
+                description: "Stored verbatim and replayed to you on every later turn. Write real line breaks and real quotation marks -- the two characters \\n are not a line break."
+              }
             },
             required: ["key", "value"],
             additionalProperties: false
@@ -5113,6 +5126,59 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   };
 }
 
+// ../core/src/execution/engine/agent/reasoning/adapters/prose-escapes.ts
+var BACKSLASH = String.fromCharCode(92);
+function normalizeProseEscapes(text) {
+  if (!text.includes(BACKSLASH)) return text;
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const char = text[i];
+    if (char !== BACKSLASH || i + 1 >= text.length) {
+      out += char;
+      i += 1;
+      continue;
+    }
+    switch (text[i + 1]) {
+      case BACKSLASH:
+        out += BACKSLASH + BACKSLASH;
+        i += 2;
+        break;
+      case "n":
+        out += "\n";
+        i += 2;
+        break;
+      case "r":
+        if (text[i + 2] === BACKSLASH && text[i + 3] === "n") {
+          out += "\n";
+          i += 4;
+        } else {
+          out += "\n";
+          i += 2;
+        }
+        break;
+      case "t":
+        out += "	";
+        i += 2;
+        break;
+      case '"':
+        out += '"';
+        i += 2;
+        break;
+      default:
+        out += char;
+        i += 1;
+    }
+  }
+  return out;
+}
+function normalizeMemoryValue(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return value;
+  return normalizeProseEscapes(value);
+}
+
 // ../core/src/execution/engine/agent/reasoning/adapters/agent-adapter-helpers.ts
 var MemoryKeyValuePairSchema = z.object({ key: z.string(), value: z.any() });
 var MemorySetSchema = z.union([z.record(z.string(), z.any()), z.array(MemoryKeyValuePairSchema)]).transform((value) => {
@@ -5124,13 +5190,33 @@ var MemoryOperationsSchema = z.object({
   // Accept any value type - framework will stringify
   delete: z.array(z.string()).optional()
 });
-var AgentIterationOutputSchema = z.object({
+var AgentIterationOutputObjectSchema = z.object({
   reasoning: z.string(),
   message: z.string().optional(),
   memoryOps: MemoryOperationsSchema.optional(),
   nextActions: z.array(AgentActionSchema)
 });
-var REQUIRED_ITERATION_KEYS = Object.entries(AgentIterationOutputSchema.shape).filter(([, fieldSchema]) => !fieldSchema.isOptional()).map(([key]) => key);
+function normalizeIterationProse(output) {
+  const normalized = { ...output };
+  normalized.reasoning = normalizeProseEscapes(output.reasoning);
+  if (typeof output.message === "string") {
+    normalized.message = normalizeProseEscapes(output.message);
+  }
+  if (output.memoryOps?.set) {
+    normalized.memoryOps = {
+      ...output.memoryOps,
+      set: Object.fromEntries(
+        Object.entries(output.memoryOps.set).map(([key, value]) => [key, normalizeMemoryValue(value)])
+      )
+    };
+  }
+  normalized.nextActions = output.nextActions.map(
+    (action) => action.type === "message" ? { ...action, text: normalizeProseEscapes(action.text) } : action
+  );
+  return normalized;
+}
+var AgentIterationOutputSchema = AgentIterationOutputObjectSchema.transform(normalizeIterationProse);
+var REQUIRED_ITERATION_KEYS = Object.entries(AgentIterationOutputObjectSchema.shape).filter(([, fieldSchema]) => !fieldSchema.isOptional()).map(([key]) => key);
 function withSynthesizedMessage(nextActions, message) {
   const text = message?.trim();
   if (!text) {

package/dist/worker/index.js

@@ -2601,6 +2601,11 @@ every response:
 and never continue the response envelope in the reasoning text -- nextActions is a separate field
 that you fill separately. A response carrying reasoning alone is discarded and retried.
 
+**Prose fields take real characters, never escape sequences.** A line break in ${includeMessage ? "message or reasoning" : "reasoning"} is
+a real line break -- not the two characters \\n. A quotation mark is the character ", not \\". The
+response is serialized for you; typing the escape yourself puts those literal characters into the
+stored text and in front of the reader.
+
 ## Rules
 
 - Batch independent tool calls in one iteration (faster execution)
@@ -3166,7 +3171,7 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   if (capabilities.message !== "off") {
     properties.message = {
       type: "string",
-      description: "Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet."
+      description: 'Your reply to the user, as plain prose. This is the ONLY field the user sees. Use an empty string only when this iteration just calls tools and you have nothing to say yet. Write real line breaks and real quotation marks -- the two characters \\n are not a line break, and \\" is not a quotation mark. Serialization is handled for you.'
     };
   }
   properties.reasoning = { type: "string", description: "Your reasoning process" };
@@ -3186,7 +3191,15 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
             type: "object",
             properties: {
               key: { type: "string" },
-              value: { type: "string" }
+              value: {
+                type: "string",
+                // `memoryOps` has NO framework prompt section -- a grep across `prompt-sections/`
+                // returns zero memory references -- so this description is the only framework-owned
+                // lever on how a memory value is written. It matters more here than in `message`:
+                // a session-memory value is re-sent on every iteration of every subsequent turn and
+                // never ages out, so one literal escape stored here is one the model re-reads forever.
+                description: "Stored verbatim and replayed to you on every later turn. Write real line breaks and real quotation marks -- the two characters \\n are not a line break."
+              }
             },
             required: ["key", "value"],
             additionalProperties: false
@@ -3205,6 +3218,59 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   };
 }
 
+// ../core/src/execution/engine/agent/reasoning/adapters/prose-escapes.ts
+var BACKSLASH = String.fromCharCode(92);
+function normalizeProseEscapes(text) {
+  if (!text.includes(BACKSLASH)) return text;
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const char = text[i];
+    if (char !== BACKSLASH || i + 1 >= text.length) {
+      out += char;
+      i += 1;
+      continue;
+    }
+    switch (text[i + 1]) {
+      case BACKSLASH:
+        out += BACKSLASH + BACKSLASH;
+        i += 2;
+        break;
+      case "n":
+        out += "\n";
+        i += 2;
+        break;
+      case "r":
+        if (text[i + 2] === BACKSLASH && text[i + 3] === "n") {
+          out += "\n";
+          i += 4;
+        } else {
+          out += "\n";
+          i += 2;
+        }
+        break;
+      case "t":
+        out += "	";
+        i += 2;
+        break;
+      case '"':
+        out += '"';
+        i += 2;
+        break;
+      default:
+        out += char;
+        i += 1;
+    }
+  }
+  return out;
+}
+function normalizeMemoryValue(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return value;
+  return normalizeProseEscapes(value);
+}
+
 // ../core/src/execution/engine/agent/reasoning/adapters/agent-adapter-helpers.ts
 var MemoryKeyValuePairSchema = z.object({ key: z.string(), value: z.any() });
 var MemorySetSchema = z.union([z.record(z.string(), z.any()), z.array(MemoryKeyValuePairSchema)]).transform((value) => {
@@ -3216,13 +3282,33 @@ var MemoryOperationsSchema = z.object({
   // Accept any value type - framework will stringify
   delete: z.array(z.string()).optional()
 });
-var AgentIterationOutputSchema = z.object({
+var AgentIterationOutputObjectSchema = z.object({
   reasoning: z.string(),
   message: z.string().optional(),
   memoryOps: MemoryOperationsSchema.optional(),
   nextActions: z.array(AgentActionSchema)
 });
-var REQUIRED_ITERATION_KEYS = Object.entries(AgentIterationOutputSchema.shape).filter(([, fieldSchema]) => !fieldSchema.isOptional()).map(([key]) => key);
+function normalizeIterationProse(output) {
+  const normalized = { ...output };
+  normalized.reasoning = normalizeProseEscapes(output.reasoning);
+  if (typeof output.message === "string") {
+    normalized.message = normalizeProseEscapes(output.message);
+  }
+  if (output.memoryOps?.set) {
+    normalized.memoryOps = {
+      ...output.memoryOps,
+      set: Object.fromEntries(
+        Object.entries(output.memoryOps.set).map(([key, value]) => [key, normalizeMemoryValue(value)])
+      )
+    };
+  }
+  normalized.nextActions = output.nextActions.map(
+    (action) => action.type === "message" ? { ...action, text: normalizeProseEscapes(action.text) } : action
+  );
+  return normalized;
+}
+var AgentIterationOutputSchema = AgentIterationOutputObjectSchema.transform(normalizeIterationProse);
+var REQUIRED_ITERATION_KEYS = Object.entries(AgentIterationOutputObjectSchema.shape).filter(([, fieldSchema]) => !fieldSchema.isOptional()).map(([key]) => key);
 function withSynthesizedMessage(nextActions, message) {
   const text = message?.trim();
   if (!text) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/sdk",
-  "version": "1.44.2",
+  "version": "1.44.3",
   "description": "SDK for building Elevasis organization resources",
   "type": "module",
   "bin": {

package/reference/claude-config/sync-notes/2026-08-03-agent-prose-escape-normalization.md

@@ -0,0 +1,88 @@
+# Agent prose is repaired before it is stored
+
+## Why this note exists
+
+**Your agents have been writing the two characters `\n` into their replies where a line break
+belongs, and `\"` where a quotation mark belongs.** The operator reads `\n\n` in the middle of a
+sentence, and the stored transcript keeps those characters forever.
+
+Measured on 2026-08-03 across four 14-turn production sessions on a live tenant agent — 56 assistant
+replies:
+
+| Surface     | Rows | Rows affected | Literal `\n` | Literal `\"` |
+| ----------- | ---- | ------------- | ------------ | ------------ |
+| `message`   | 56   | 28            | 111          | 146          |
+| `reasoning` | 56   | 1             | 4            | 0            |
+
+Half the replies were affected. This is a different defect from the em-dash corruption in
+`2026-07-28-agent-reply-is-its-own-field.md`, and that fix still holds — em-dashes were clean across
+all 56 replies here. This one is on the field that fix created.
+
+**The model is choosing the wrong characters, not the wrong encoding.** Three replies carried one
+paragraph break written as real newlines and another written as the two characters, inside the
+_same string_. No serialization layer produces that — a layer that escapes, escapes everything. So
+there is nothing to wait for on the provider side: the output is valid JSON, it satisfies the
+response schema, and no parser can tell the difference.
+
+**It also feeds back.** Assistant text is replayed verbatim into the next turn as trusted context,
+so a damaged reply becomes evidence to the model of how this agent writes.
+
+The runtime now repairs it deterministically at the single point where model output is validated —
+upstream of persist, stream, render, and replay. `\n`, `\r\n`, `\t`, and `\"` are converted to the
+characters they denote in `message`, in `reasoning`, and in session-memory values.
+
+## Applies to
+
+- **Every agent, not only session-capable ones.** `reasoning` and `memoryOps` are normalized on all
+  agents; `message` on the ones that have it.
+- **Session memory especially.** A stored memory value is re-sent on every iteration of every
+  later turn and never ages out, so one literal escape stored there is one the model re-reads for
+  the life of the session. This surface had never been measured before this train.
+- **No agent definition changes are required.** You do not edit your agents. The repair lives in the
+  runtime your bundle carries.
+
+## Two behaviors worth knowing
+
+1. **The normalizer is not markdown-aware.** A fenced code block or inline span containing a literal
+   `\n` **is** converted. This was a deliberate trade: a reply whose line breaks are all literal has
+   no line structure for a fence to start on, so the replies most in need of repair are exactly the
+   ones a fence scan would fail to parse. If you run an agent that discusses escape sequences or
+   regexes in its user-facing prose, this is the case to check.
+2. **A doubled backslash is left alone**, and JSON-shaped memory values are skipped entirely — so a
+   stored JSON blob keeps its internal escaping and still parses.
+
+## Required actions
+
+1. **Take the `@elevasis/sdk` baseline bump** this train propagates, then reinstall in `operations/`
+   so the new worker bundle is present.
+2. **Redeploy your operations bundle.** This is the step that closes the defect. The agent loop is
+   inlined into your deployed bundle, so an existing deployment keeps emitting damaged prose until
+   it is redeployed:
+
+   ```bash
+   pnpm -C operations exec elevasis-sdk deploy --prod
+   ```
+
+   A platform-side deploy does not fix this for you, and neither does the reinstall on its own.
+
+3. **Do not treat existing transcripts as clean.** No backfill is performed. Replies and memory
+   snapshots written before your redeploy keep the literal escapes they already have. Memory
+   snapshots in particular are live agent state, and rewriting them mid-session was judged riskier
+   than the damage.
+
+## Verification
+
+- Run a multi-turn session and ask for a reply with paragraph structure — a short summary in two or
+  three paragraphs is enough. Read the reply: the signature failure is a visible `\n\n` between
+  sentences, or a quotation mark rendered as `\"`.
+- **Check a reply containing quoted speech.** Quote escapes were the larger surface (146 of 257
+  measured occurrences), and one measured reply carried six of them with no newline escapes at all —
+  so a reply can be damaged purely on quotes and look fine structurally.
+- If your agent declares `memoryPreferences`, run enough turns for it to write session memory, then
+  confirm a stored value comes back with real line breaks rather than literal ones.
+
+## Not handled by /git-sync
+
+- **The redeploy.** `/git-sync` commits and pushes the propagated dependency baseline. Your deployed
+  agents keep producing damaged prose until you run action 2 above.
+- **Repairing existing transcripts or memory snapshots.** No backfill is performed, by decision.

package/reference/sdk/resources/index.mdx

@@ -328,6 +328,8 @@ const myAgent: AgentDefinition = {
 
 `contract.inputSchema` is required, same as a workflow. `contract.outputSchema` is what a **non-session** (single-shot) agent like the example above returns — there is no conversational reply to read a structured answer from otherwise. A `sessionCapable: true` agent typically omits `outputSchema` and speaks through its conversational `message` instead.
 
+The framework normalizes literal escape sequences out of that conversational `message`, out of `reasoning`, and out of session-memory values before any of them are persisted, streamed, or replayed. A model sometimes writes the two characters backslash-n where a line break belongs; the result is valid JSON that satisfies the response schema, so nothing upstream can catch it, and the operator ends up reading those characters mid-sentence. Nothing is required of you — no agent definition field changes — but two consequences are worth knowing. An agent that legitimately wants to show an escape sequence in prose (explaining a regex, say) will have it converted, because the normalizer is not markdown-aware. And a memory value that is itself JSON is skipped entirely, so a stored JSON blob keeps its internal escaping intact.
+
 ---
 
 ## DeploymentSpec