@elevasis/sdk 1.44.1 → 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
@@ -44117,17 +44125,17 @@ function getLeadGenCrmHandoffResourceIds(model) {
     (resource) => resource.systemPath === LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath && resource.ontology?.usesCatalogs?.includes(CRM_PIPELINE_CATALOG_ONTOLOGY_ID) === true
   ).map((resource) => resource.id);
 }
-function getSystemInterfaceReadinessMarker(model, request) {
-  const system = getSystem(model, request.systemPath);
+function getSystemInterfaceReadinessMarker(model, request2) {
+  const system = getSystem(model, request2.systemPath);
   if (system === void 0) return void 0;
-  if (request.systemPath === LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath && request.interfaceKey === LEAD_GEN_CRM_HANDOFF_INTERFACE.interfaceKey) {
+  if (request2.systemPath === LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath && request2.interfaceKey === LEAD_GEN_CRM_HANDOFF_INTERFACE.interfaceKey) {
     return {
       lifecycle: "active",
       readinessProfile: LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile,
       resourceIds: getLeadGenCrmHandoffResourceIds(model)
     };
   }
-  if (request.interfaceKey === "api" && system.apiInterface !== void 0) {
+  if (request2.interfaceKey === "api" && system.apiInterface !== void 0) {
     return system.apiInterface;
   }
   return void 0;
@@ -44186,24 +44194,24 @@ function requireContractReadiness(issues, index, resources, contract, context) {
     requireScopedBinding(issues, catalogs, "usesCatalogs", catalogId, context);
   }
 }
-function computeInterfaceReadiness(model, request) {
+function computeInterfaceReadiness(model, request2) {
   const issues = [];
-  const system = getSystem(model, request.systemPath);
-  const systemInterface = getSystemInterfaceReadinessMarker(model, request);
-  const readinessProfile = systemInterface === void 0 ? void 0 : profileForInterface(request.systemPath, request.interfaceKey, systemInterface.readinessProfile);
+  const system = getSystem(model, request2.systemPath);
+  const systemInterface = getSystemInterfaceReadinessMarker(model, request2);
+  const readinessProfile = systemInterface === void 0 ? void 0 : profileForInterface(request2.systemPath, request2.interfaceKey, systemInterface.readinessProfile);
   const scopedResourceIds = systemInterface?.resourceIds ?? [];
   if (system === void 0) {
     addReadinessIssue(
       issues,
       "SYSTEM_INTERFACE_MISSING",
       "missing-system",
-      `System "${request.systemPath}" is missing.`,
-      { ref: request.systemPath }
+      `System "${request2.systemPath}" is missing.`,
+      { ref: request2.systemPath }
     );
     return {
       ready: false,
-      systemPath: request.systemPath,
-      interfaceKey: request.interfaceKey,
+      systemPath: request2.systemPath,
+      interfaceKey: request2.interfaceKey,
       scopedResourceIds,
       issues
     };
@@ -44213,13 +44221,13 @@ function computeInterfaceReadiness(model, request) {
       issues,
       "SYSTEM_INTERFACE_MISSING",
       "missing-interface",
-      `System "${request.systemPath}" does not declare interface "${request.interfaceKey}".`,
-      { path: readinessMarkerPath(request) }
+      `System "${request2.systemPath}" does not declare interface "${request2.interfaceKey}".`,
+      { path: readinessMarkerPath(request2) }
     );
     return {
       ready: false,
-      systemPath: request.systemPath,
-      interfaceKey: request.interfaceKey,
+      systemPath: request2.systemPath,
+      interfaceKey: request2.interfaceKey,
       scopedResourceIds,
       issues
     };
@@ -44229,11 +44237,11 @@ function computeInterfaceReadiness(model, request) {
       issues,
       "SYSTEM_INTERFACE_DISABLED",
       "inactive-interface",
-      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" lifecycle is "${systemInterface.lifecycle}".`,
-      { path: `${readinessMarkerPath(request)}.lifecycle` }
+      `System Interface "${formatInterfaceIdentity(request2.systemPath, request2.interfaceKey)}" lifecycle is "${systemInterface.lifecycle}".`,
+      { path: `${readinessMarkerPath(request2)}.lifecycle` }
     );
   }
-  const checkedReadinessProfile = readinessProfile ?? profileForInterface(request.systemPath, request.interfaceKey);
+  const checkedReadinessProfile = readinessProfile ?? profileForInterface(request2.systemPath, request2.interfaceKey);
   const isBuiltIn = isBuiltInReadinessProfile(checkedReadinessProfile);
   const readinessContract = systemInterface.readinessContract;
   if (!isBuiltIn && readinessContract === void 0) {
@@ -44241,13 +44249,13 @@ function computeInterfaceReadiness(model, request) {
       issues,
       "SYSTEM_INTERFACE_INVALID",
       "missing-readiness-contract",
-      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" uses custom readiness profile "${checkedReadinessProfile}" but declares no readinessContract. Built-in profiles: ${formatSupportedReadinessProfiles()}.`,
-      { path: `${readinessMarkerPath(request)}.readinessContract`, ref: checkedReadinessProfile }
+      `System Interface "${formatInterfaceIdentity(request2.systemPath, request2.interfaceKey)}" uses custom readiness profile "${checkedReadinessProfile}" but declares no readinessContract. Built-in profiles: ${formatSupportedReadinessProfiles()}.`,
+      { path: `${readinessMarkerPath(request2)}.readinessContract`, ref: checkedReadinessProfile }
     );
     return {
       ready: false,
-      systemPath: request.systemPath,
-      interfaceKey: request.interfaceKey,
+      systemPath: request2.systemPath,
+      interfaceKey: request2.interfaceKey,
       readinessProfile: checkedReadinessProfile,
       scopedResourceIds,
       issues
@@ -44258,29 +44266,29 @@ function computeInterfaceReadiness(model, request) {
       issues,
       "SYSTEM_INTERFACE_NOT_READY",
       "missing-scoped-resources",
-      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" must scope at least one active resource.`,
-      { path: `${readinessMarkerPath(request)}.resourceIds` }
+      `System Interface "${formatInterfaceIdentity(request2.systemPath, request2.interfaceKey)}" must scope at least one active resource.`,
+      { path: `${readinessMarkerPath(request2)}.resourceIds` }
     );
   }
-  const resources = getActiveScopedResources(model, scopedResourceIds, issues, request);
+  const resources = getActiveScopedResources(model, scopedResourceIds, issues, request2);
   const index = tryCompileBusinessOntology(model, checkedReadinessProfile, issues);
   if (index !== void 0) {
     if (checkedReadinessProfile === LEAD_GEN_API_INTERFACE.readinessProfile) {
-      requireLeadGenInterfaceReadiness(issues, index, resources, request);
+      requireLeadGenInterfaceReadiness(issues, index, resources, request2);
     } else if (checkedReadinessProfile === CRM_API_INTERFACE.readinessProfile) {
-      requireCrmInterfaceReadiness(issues, index, resources, request);
+      requireCrmInterfaceReadiness(issues, index, resources, request2);
     } else if (checkedReadinessProfile === LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile) {
-      requireLeadGenInterfaceReadiness(issues, index, resources, request);
-      requireCrmInterfaceReadiness(issues, index, resources, { ...request, allowForeignOwner: true });
-      requireHandoffBridgeReadiness(issues, model, request);
+      requireLeadGenInterfaceReadiness(issues, index, resources, request2);
+      requireCrmInterfaceReadiness(issues, index, resources, { ...request2, allowForeignOwner: true });
+      requireHandoffBridgeReadiness(issues, model, request2);
     } else if (readinessContract !== void 0) {
-      requireContractReadiness(issues, index, resources, readinessContract, request);
+      requireContractReadiness(issues, index, resources, readinessContract, request2);
     }
   }
   return {
     ready: issues.length === 0,
-    systemPath: request.systemPath,
-    interfaceKey: request.interfaceKey,
+    systemPath: request2.systemPath,
+    interfaceKey: request2.interfaceKey,
     readinessProfile: checkedReadinessProfile,
     scopedResourceIds,
     issues
@@ -46160,22 +46168,72 @@ function getApiKey(apiUrl) {
   const key = resolveApiKey(isProd);
   if (!key) {
     const varName = isProd ? "ELEVASIS_PLATFORM_KEY" : "ELEVASIS_PLATFORM_KEY_DEV";
-    throw new Error(
-      `${varName} environment variable is required.
-Set it in your .env file: ${varName}=sk_...`
-    );
+    throw new Error(`${varName} environment variable is required.
+Set it in your .env file: ${varName}=sk_...`);
   }
   return key;
 }
-async function apiGet(endpoint, apiUrl = resolveApiUrl()) {
-  const response = await fetch(`${apiUrl}${endpoint}`, {
-    headers: { Authorization: `Bearer ${getApiKey(apiUrl)}` }
-  });
+var DEFAULT_TIMEOUT_MS = 2 * 60 * 60 * 1e3;
+function resolveTimeoutMs() {
+  const raw = process.env.ELEVASIS_CLI_TIMEOUT_MS;
+  if (!raw) return DEFAULT_TIMEOUT_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS;
+}
+function formatElapsed(ms) {
+  return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
+var GATEWAY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+function describeGatewayFailure(status, endpoint, elapsedMs) {
+  return `API request failed (${status}) after ${formatElapsed(elapsedMs)}: a gateway between this CLI and the API ended the connection.
+This is NOT the API rejecting the request, and the work may still be running server-side -- a status code from a proxy says nothing about whether the handler completed.
+  Endpoint: ${endpoint}
+  Check for a result before re-running, or the same work may execute twice:
+    executions -> 'elevasis execution <workflow> <id>'
+    session turns -> 'elevasis-sdk session:messages <session-id> --all'
+  Workflow executions can avoid this entirely with 'exec --async', which returns immediately
+  and polls. Session turns have no async variant, so a long turn is exposed to this cutoff.`;
+}
+async function request(method, endpoint, apiUrl, body) {
+  const timeoutMs = resolveTimeoutMs();
+  const startedAt = Date.now();
+  const headers = { Authorization: `Bearer ${getApiKey(apiUrl)}` };
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  let response;
+  try {
+    response = await fetch(`${apiUrl}${endpoint}`, {
+      method,
+      headers,
+      ...body !== void 0 && { body: JSON.stringify(body) },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error46) {
+    const elapsedMs = Date.now() - startedAt;
+    if (error46 instanceof Error && error46.name === "TimeoutError") {
+      throw new Error(
+        `Request timed out after ${formatElapsed(elapsedMs)} (limit ${formatElapsed(timeoutMs)}).
+  Endpoint: ${endpoint}
+  The server may still be working -- check for a result before re-running.
+  Raise the limit with ELEVASIS_CLI_TIMEOUT_MS, or, for a workflow execution, submit it
+  with 'exec --async'. Session turns have no async variant.`
+      );
+    }
+    const detail = error46 instanceof Error ? error46.message : String(error46);
+    throw new Error(
+      `Could not reach the API after ${formatElapsed(elapsedMs)}: ${detail}
+  Endpoint: ${apiUrl}${endpoint}
+  No HTTP status was returned, so the request may never have been received.`
+    );
+  }
   if (!response.ok) {
+    const elapsedMs = Date.now() - startedAt;
     const errorText = await response.text();
     if (response.status === 401) {
       throw new Error(`401 Unauthorized: Invalid or missing ELEVASIS_PLATFORM_KEY. Check your .env file.`);
     }
+    if (GATEWAY_STATUSES.has(response.status)) {
+      throw new Error(describeGatewayFailure(response.status, endpoint, elapsedMs));
+    }
     throw new Error(`API request failed (${response.status}): ${errorText}`);
   }
   if (response.status === 204) {
@@ -46183,55 +46241,17 @@ async function apiGet(endpoint, apiUrl = resolveApiUrl()) {
   }
   return response.json();
 }
+async function apiGet(endpoint, apiUrl = resolveApiUrl()) {
+  return request("GET", endpoint, apiUrl);
+}
 async function apiPost(endpoint, body, apiUrl = resolveApiUrl()) {
-  const response = await fetch(`${apiUrl}${endpoint}`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${getApiKey(apiUrl)}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`API request failed (${response.status}): ${errorText}`);
-  }
-  if (response.status === 204) {
-    return {};
-  }
-  return response.json();
+  return request("POST", endpoint, apiUrl, body);
 }
 async function apiPatch(endpoint, body, apiUrl = resolveApiUrl()) {
-  const response = await fetch(`${apiUrl}${endpoint}`, {
-    method: "PATCH",
-    headers: {
-      Authorization: `Bearer ${getApiKey(apiUrl)}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`API request failed (${response.status}): ${errorText}`);
-  }
-  if (response.status === 204) {
-    return {};
-  }
-  return response.json();
+  return request("PATCH", endpoint, apiUrl, body);
 }
 async function apiDelete(endpoint, apiUrl = resolveApiUrl()) {
-  const response = await fetch(`${apiUrl}${endpoint}`, {
-    method: "DELETE",
-    headers: { Authorization: `Bearer ${getApiKey(apiUrl)}` }
-  });
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`API request failed (${response.status}): ${errorText}`);
-  }
-  if (response.status === 204) {
-    return {};
-  }
-  return response.json();
+  return request("DELETE", endpoint, apiUrl);
 }
 
 // src/cli/wrap-action.ts
@@ -46253,7 +46273,7 @@ function wrapAction(commandName, fn) {
 // package.json
 var package_default = {
   name: "@elevasis/sdk",
-  version: "1.44.1",
+  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) {
@@ -5295,6 +5381,10 @@ var MEMORY_DOMAINS = {
    *
    * Tools manage complex structured data (caches, indexes, etc.)
    * that would be error-prone for LLM to update via JSON strings.
+   *
+   * No tool currently writes these three keys, so in practice the guard reserves the names
+   * against the LLM rather than arbitrating a live conflict. That is still enforcement --
+   * see `validateMemoryKeyOwnership` in `./utils` -- not dead code.
    */
   TOOL_OWNED: [
     "notion-pages-cache",
@@ -5303,20 +5393,10 @@ var MEMORY_DOMAINS = {
     // GitHub tools manage repository structure
     "slack-channel-cache"
     // Slack tools manage channel data
-  ],
-  /**
-   * Action-owned keys
-   * Updated by framework actions
-   * LLM cannot modify these via memoryOps
-   *
-   * Actions manage framework state that controls execution flow. Empty today -- the one
-   * action that ever wrote here was retired. Kept as its own domain because a future
-   * action-managed key belongs here, not folded into TOOL_OWNED.
-   */
-  ACTION_OWNED: []
+  ]
   /**
    * LLM-owned keys
-   * All keys NOT in TOOL_OWNED or ACTION_OWNED
+   * All keys NOT in TOOL_OWNED
    * Managed via memoryOps by agent reasoning
    *
    * LLM manages semantic memory (business context, decisions, etc.)
@@ -5326,12 +5406,8 @@ var MEMORY_DOMAINS = {
 function isToolOwnedKey(key) {
   return MEMORY_DOMAINS.TOOL_OWNED.includes(key);
 }
-function isActionOwnedKey(key) {
-  return MEMORY_DOMAINS.ACTION_OWNED.includes(key);
-}
 function getKeyOwner(key) {
   if (isToolOwnedKey(key)) return "tool";
-  if (isActionOwnedKey(key)) return "action";
   return "llm";
 }
 
@@ -5358,7 +5434,7 @@ function addToolError(memoryManager, action, errorMessage, iteration, turnNumber
   });
 }
 function validateMemoryKeyOwnership(key, logger, iteration) {
-  if (isToolOwnedKey(key) || isActionOwnedKey(key)) {
+  if (isToolOwnedKey(key)) {
     const owner = getKeyOwner(key);
     logger.action(
       "memory-set-rejected",

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) {
@@ -3387,6 +3473,10 @@ var MEMORY_DOMAINS = {
    *
    * Tools manage complex structured data (caches, indexes, etc.)
    * that would be error-prone for LLM to update via JSON strings.
+   *
+   * No tool currently writes these three keys, so in practice the guard reserves the names
+   * against the LLM rather than arbitrating a live conflict. That is still enforcement --
+   * see `validateMemoryKeyOwnership` in `./utils` -- not dead code.
    */
   TOOL_OWNED: [
     "notion-pages-cache",
@@ -3395,20 +3485,10 @@ var MEMORY_DOMAINS = {
     // GitHub tools manage repository structure
     "slack-channel-cache"
     // Slack tools manage channel data
-  ],
-  /**
-   * Action-owned keys
-   * Updated by framework actions
-   * LLM cannot modify these via memoryOps
-   *
-   * Actions manage framework state that controls execution flow. Empty today -- the one
-   * action that ever wrote here was retired. Kept as its own domain because a future
-   * action-managed key belongs here, not folded into TOOL_OWNED.
-   */
-  ACTION_OWNED: []
+  ]
   /**
    * LLM-owned keys
-   * All keys NOT in TOOL_OWNED or ACTION_OWNED
+   * All keys NOT in TOOL_OWNED
    * Managed via memoryOps by agent reasoning
    *
    * LLM manages semantic memory (business context, decisions, etc.)
@@ -3418,12 +3498,8 @@ var MEMORY_DOMAINS = {
 function isToolOwnedKey(key) {
   return MEMORY_DOMAINS.TOOL_OWNED.includes(key);
 }
-function isActionOwnedKey(key) {
-  return MEMORY_DOMAINS.ACTION_OWNED.includes(key);
-}
 function getKeyOwner(key) {
   if (isToolOwnedKey(key)) return "tool";
-  if (isActionOwnedKey(key)) return "action";
   return "llm";
 }
 
@@ -3450,7 +3526,7 @@ function addToolError(memoryManager, action, errorMessage, iteration, turnNumber
   });
 }
 function validateMemoryKeyOwnership(key, logger, iteration) {
-  if (isToolOwnedKey(key) || isActionOwnedKey(key)) {
+  if (isToolOwnedKey(key)) {
     const owner = getKeyOwner(key);
     logger.action(
       "memory-set-rejected",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/sdk",
-  "version": "1.44.1",
+  "version": "1.44.3",
   "description": "SDK for building Elevasis organization resources",
   "type": "module",
   "bin": {
@@ -59,8 +59,8 @@
     "typescript": "5.9.2",
     "zod": "^4.1.0",
     "@repo/core": "0.59.0",
-    "@repo/eslint-config": "0.0.0",
-    "@repo/typescript-config": "0.0.0"
+    "@repo/typescript-config": "0.0.0",
+    "@repo/eslint-config": "0.0.0"
   },
   "scripts": {
     "lint": "eslint src --max-warnings 0",

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/claude-config/sync-notes/2026-08-03-cli-gateway-errors-and-request-timeout.md

@@ -0,0 +1,120 @@
+# Your CLI now explains a 502 instead of just reporting one, and no request hangs forever
+
+## Why this note exists
+
+This train publishes one package — `@elevasis/sdk` — and every change in it is in the CLI you type
+commands into. Nothing about your workflows, organization model, or UI moves. But the CLI's failure
+messages change, and one of them changes in a way that is meant to stop you doing something harmful.
+
+**1. A gateway failure now tells you the work may still be running, and how to check.** Until now
+every non-2xx response produced the same shape: `API request failed (502)`. That message is
+technically accurate and practically dangerous, because the most natural reaction to it is to run the
+command again.
+
+A 502, 503, or 504 does not come from the platform API. It comes from a hop in front of it that ended
+your connection while the API was still working. The request you sent may have completed in full. We
+found this the hard way: a session turn returned 502 to the CLI after 300 seconds, and a later
+database query showed the turn had **completed successfully server-side in 319.8 seconds** with a
+model reply written and no error of any kind. The only thing that failed was the connection carrying
+the answer back. It was turn 14 of a 14-turn run — re-running blind would have executed that turn a
+second time.
+
+The new message says the proxy ended the connection, that this is not the API rejecting your request,
+that the work may still be running, and which command to use to look for a result before re-running.
+
+**2. Every CLI request is now bounded by a timeout, defaulting to 2 hours.** Before, the CLI used a
+bare `fetch()` with no signal, so a connection that stalled would sit there indefinitely with no
+output. The limit is deliberately set high — it matches the server's own socket budget on long routes.
+The goal is to bound an indefinite hang, not to police how long your work may take. Anything shorter
+would make the CLI give up on executions the API is still legitimately serving, turning a working long
+run into a reported failure. Override it with `ELEVASIS_CLI_TIMEOUT_MS` if you have a reason to.
+
+**3. "Timed out" and "never reached the API" are now different messages.** A bare `fetch()` rejection
+carries no status, so a dead port, a wrong API URL, and a stalled connection were indistinguishable.
+They now read differently.
+
+**4. The friendly authentication message now applies to every verb.** A 401 on `GET` printed a clear
+"check your platform key" message; a 401 on `POST`, `PATCH`, or `DELETE` printed the raw response
+body. All four now share the same message.
+
+**5. Three dead exports were removed from the agent memory surface.** `MEMORY_DOMAINS.ACTION_OWNED`
+was an empty array, `isActionOwnedKey` returned `false` for every input, and the `ActionOwnedKey` type
+resolved to `never`. They are gone. The live half of that layer is unchanged and still enforced: an
+agent still cannot write to a tool-owned memory key. If your project imports any of the three removed
+names, it was importing something that could never do anything — but the import will now fail, so it
+is worth a grep.
+
+## Applies to
+
+- **Every project that uses the `elevasis-sdk` CLI**, which is every template-family project. Items 1
+  through 4 arrive with the baseline bump and need no source edit from you.
+- **Any script or CI job that parses CLI stderr.** The gateway, timeout, and transport messages are
+  new text. If something greps for `API request failed`, check it.
+- **Any project importing `ACTION_OWNED`, `isActionOwnedKey`, or `ActionOwnedKey`** from the SDK, for
+  item 5. We found no such import in any template-family project, but only you can see out-of-tree
+  code.
+- **Not applicable to your organization model, knowledge nodes, workflows, or UI.** Nothing in this
+  train touches authored content or any rendered surface.
+
+## Required actions
+
+1. **Take the `@elevasis/sdk` baseline bump** this train propagates, then reinstall in `operations/`:
+
+   ```bash
+   pnpm -C operations install
+   ```
+
+2. **Grep for the three removed memory exports** before you deploy. This is the only change in the
+   train that can break a build, and it is cheap to rule out:
+
+   ```bash
+   grep -rn "ACTION_OWNED\|isActionOwnedKey\|ActionOwnedKey" operations/src core/config
+   ```
+
+   No output means item 5 does not affect you.
+
+3. **Redeploy `operations/`.** The baseline bump changes what your next bundle contains; it does not
+   change what is already deployed:
+
+   ```bash
+   pnpm -C operations exec elevasis-sdk deploy
+   ```
+
+4. **Check any script that matches on CLI error text.** If you have automation that branches on
+   `API request failed`, it will no longer match a gateway failure.
+
+## Verification
+
+- **Read the installed bundle, not the version number.** A bumped pin and a green sync report are
+  claims about intent; the installed file is the only ground truth:
+
+  ```bash
+  grep -c "GATEWAY_STATUSES" operations/node_modules/@elevasis/sdk/dist/cli.cjs
+  grep -c "ACTION_OWNED" operations/node_modules/@elevasis/sdk/dist/worker/index.js
+  ```
+
+  The first must be non-zero and the second must be `0`. Either result the other way means the
+  install did not land, regardless of what `package.json` says.
+
+- **Provoke a transport failure and read the message.** The cheapest honest check that the new
+  branches are live, because it needs no broken server:
+
+  ```bash
+  ELEVASIS_API_URL=http://localhost:9 pnpm -C operations exec elevasis-sdk list
+  ```
+
+  You should get a message naming the endpoint and saying the request never reached the API — not a
+  bare `fetch failed`.
+
+- **Confirm the timeout is configurable.** Setting `ELEVASIS_CLI_TIMEOUT_MS=1` on any command should
+  produce a timeout message that quotes the limit back to you.
+
+## Not handled by /git-sync
+
+- **The `operations/` reinstall.** `/git-sync` propagates and commits the dependency baseline. The
+  `node_modules` copy your CLI actually executes is not updated until you run `pnpm install` yourself,
+  and the CLI will keep printing the old messages until you do.
+- **The `operations/` redeploy.** Bumping the `@elevasis/sdk` pin changes what your next bundle
+  contains. Your currently deployed workers keep running the old bundle until you deploy.
+- **The grep for the removed memory exports.** Nothing can detect an out-of-tree import for you.
+- **Updating scripts that match on CLI error text.** The sync cannot see your automation.

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