@unoverse-platform/studio 0.1.97 → 0.1.99

package/vendor/base/src/agent-mcp/discovery.ts

@@ -5,7 +5,7 @@
  * kinds into one shape, so a model gets one tool per row regardless of which kind it was.
  * Also the etiquette an interactive app carries, and the anchoring a follow-up search needs.
  */
-import type { AgentToolExchange, DiscoveredMCP, AppInvocationContext } from "./types.js";
+import type { AgentToolExchange, DiscoveredMCP, AppInvocationContext, OfferedFunction } from "./types.js";
 
 /** The discovery tools whose results can carry `object_type: "mcp"` rows. */
 export const DISCOVERY_TOOL_NAMES: readonly string[] = ["findIntent", "discoverRelated"];
@@ -25,7 +25,7 @@ import { leanToolResultForModel } from "./lean.js";
  *     calling it fires `workflow@trigger`.
  *   - Path B — bindingless component-app rows (§0.1): an `app` URI but NO workflow. The
  *     app IS the tool; calling it makes the held native `/mcp` call
- *     (`invokeComponentAppNative`) — the SERVER renders the component + elicits, nothing
+ *     (`invokeTaskNative`) — the SERVER renders the component + elicits, nothing
  *     to fire. Carries `component` (the app-tool id) instead of workflow/trigger.
  *
  * Path B also covers CONTENT-TREE rows (object_type "service"/"need") with an app
@@ -34,20 +34,11 @@ import { leanToolResultForModel } from "./lean.js";
  * render (inline card, focus, …). These rows carry no `metadata.name`, so the tool is
  * minted under the component id and deduped across rows pointing at the same app.
  *
- * App descriptions gain the INTERACTIVE-APP etiquette so the model promotes the UI
- * instead of answering alongside it (observed live: a full interview streamed next to
- * the wizard asking the same questions).
+ * App descriptions gain one sentence of etiquette; the schema is the instruction channel.
  */
 export const APP_ETIQUETTE =
-  "INTERACTIVE APP: calling this renders a UI the user " +
-  "completes on screen. When you call it, reply with at most ONE short sentence inviting the user to it — " +
-  "never answer the request in text alongside it, never list options, never ask questions the app will " +
-  "collect. If the result includes `output`, those are the user's complete answers — continue the task " +
-  "with them (search if the request needs a lookup) and only then answer. " +
-  "If your instructions include background about this user, every text field you compose here is written " +
-  "FOR that person — use their name and what you know about them in headlines, intros, and copy; " +
-  "generic audience-neutral brochure copy is wrong when you know who is reading.";
-
+  "INTERACTIVE APP: calling this puts a UI on screen that the user completes there; reply with one short sentence inviting them to it, and when the result carries `output` those are their answers, so continue with them. " +
+  "Text you compose here is written for this person when you know who they are.";
 
 export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[] {
   const discovered: DiscoveredMCP[] = [];
@@ -60,11 +51,52 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
     const results = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.results) ? parsed.results : null;
     if (!results) continue;
     for (const item of results) {
-      if (item?.object_type !== "mcp") continue;
-      if (item.metadata?.schema?.methods) {
+      // Two row types mint tools: the registry family (stored "mcp": components, apps,
+      // node-MCPs) and TASKS (an outcome with a door, docs/unoverse/data/objects/elements/task.md).
+      if (item?.object_type !== "mcp" && item?.object_type !== "task") continue;
+      // WHAT KIND OF STEP a call to it will be on the timeline: a task is an outcome the
+      // person can get done, and the viewer draws it as one rather than as a bare tool.
+      const isTask = item.object_type === "task";
+      if (item.object_type === "task" && item.metadata?.workflow && item.metadata?.trigger && item.metadata?.output) {
+        // A WORKFLOW TASK: a task-augmented native tool on the platform's own /mcp
+        // (server mcp/server/taskTools.ts). Calling it fires the Agent and HOLDS until the
+        // run completes; the terminal node's output is the result. `taskTool` is the tool's
+        // identity (`<org>/<name>`), which the wire call spells dotted.
+        const methodName = item.metadata.name;
+        if (!methodName) continue;
+        const input = item.metadata.inputSchema || { type: "object", properties: { message: { type: "string" } } };
+        // What to do rides the tool description: the only channel that reaches a model for a
+        // tool minted mid-conversation. The skills it names are loaded through readSkill as usual.
+        const skills = Array.isArray(item.metadata?.skills) && item.metadata.skills.length ? ` Skills required: ${item.metadata.skills.join(", ")} (read them with readSkill first).` : "";
+        // A TASK IS A TOOL, DESCRIBED LIKE ONE (owner ruling 2026-09-08). This used to close
+        // with TASK_ETIQUETTE — "calling this runs an Agent and holds until it completes while
+        // the person watches its progress on screen; say in one short sentence what you are
+        // doing" — and the only thing it told the model to DO was speak. Measured on SAB
+        // (2026-09-08): across four runs of one question the model called once and, three
+        // times, emitted exactly one sentence of intent and ended the turn, with no
+        // function-call events in the stream at all.
+        //
+        // Nothing replaces it. Tool calling is native to these models, and the etiquette was
+        // us describing a heavyweight thing with consequences — holds, progress, watch — where
+        // a tool description should say what the tool does and what it returns. What the
+        // AUTHOR wrote stands on its own; add words back only if a measurement asks for them.
+        const taskDescription = `${item.description || item.title || methodName}${item.metadata?.instructions ? ` ${item.metadata.instructions}` : ""}${skills}`;
+        discovered.push({
+          ...(isTask ? { task: true as const } : {}),
+          id: item.id || item.universal_id,
+          title: item.title || "",
+          description: taskDescription,
+          workflowId: item.metadata.workflow || item.workflow_id,
+          nodeId: item.metadata.trigger,
+          methodName,
+          taskTool: String(methodName),
+          schema: { methods: { [methodName]: { description: taskDescription, input } } },
+        });
+      } else if (item.metadata?.schema?.methods) {
         const methodName = Object.keys(item.metadata.schema.methods)[0];
         if (!methodName) continue;
         discovered.push({
+          ...(isTask ? { task: true as const } : {}),
           id: item.id || item.universal_id,
           title: item.title || "",
           description: item.description || "",
@@ -80,6 +112,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
         const input = item.metadata.inputSchema || { type: "object", properties: { message: { type: "string" } } };
         const appDescription = `${item.description || item.title || methodName} ${APP_ETIQUETTE}`;
         discovered.push({
+          ...(isTask ? { task: true as const } : {}),
           id: item.id || item.universal_id,
           title: item.title || "",
           description: appDescription,
@@ -90,7 +123,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
         });
       } else if (item.metadata?.app && !item.metadata?.workflow) {
         // PATH B — bindingless component app: no workflow. Minted like an app tool; the
-        // adapter passes `component` to `invokeComponentAppNative` (held native `/mcp`
+        // adapter passes `component` to `invokeTaskNative` (held native `/mcp`
         // call → the SERVER renders + elicits) instead of firing. The row carries NO
         // schema — the input schema is pulled LIVE from `<appUri>/schema` at mint time
         // (`resolveToolDefNative`); this default is the un-briefed fallback only.
@@ -99,6 +132,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
         const input = { type: "object", properties: {} };
         const appDescription = `${item.description || item.title || methodName} ${APP_ETIQUETTE}`;
         discovered.push({
+          ...(isTask ? { task: true as const } : {}),
           id: item.id || item.universal_id,
           title: item.title || "",
           description: appDescription,
@@ -130,7 +164,7 @@ export function parseDiscoveredMCPs(calls: AgentToolExchange[]): DiscoveredMCP[]
  * DISCOVERY NEVER CALLS THE APP. Finding a component in search results is not someone
  * asking for it; only the model's own tool call is. Two fire-and-forget calls lived here
  * (a shell-open on unlock, a draft top-up when a later search carried images) to paint a
- * composed page's frame early. Both were `invokeComponentAppNative`, so on an app whose
+ * composed page's frame early. Both were `invokeTaskNative`, so on an app whose
  * component declares `outputs` each one rendered the component AND opened its own
  * elicitation: observed live 2026-08-10, three renders and three concurrent forms in ONE
  * turn, of which the channel can hold only one (connection.tsx keeps a single pending
@@ -162,6 +196,30 @@ export async function handleDiscoveryResult(
   return leanToolResultForModel(resultContent);
 }
 
+/**
+ * THE FUNCTIONS THE RESULT'S ROWS OFFER, lifted off the search envelope before the lean drops the
+ * key. The engine wrote them once per name (`functions: { getDetail: { description, input,
+ * objects } }`); each becomes a tool the moment the row that offers it is found, and the model
+ * never reads the key as data. Not a discovery tool's reply, or a reply without the key: nothing.
+ */
+export function parseOfferedFunctions(toolName: string, resultContent: string): OfferedFunction[] {
+  if (!DISCOVERY_TOOL_NAMES.includes(toolName)) return [];
+  const parsed = parseToolResult(resultContent);
+  const fns = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as { functions?: unknown }).functions : null;
+  if (!fns || typeof fns !== "object" || Array.isArray(fns)) return [];
+  const out: OfferedFunction[] = [];
+  for (const [name, raw] of Object.entries(fns as Record<string, any>)) {
+    if (!name || !raw || typeof raw !== "object") continue;
+    out.push({
+      name,
+      description: typeof raw.description === "string" ? raw.description : "",
+      ...(raw.input && typeof raw.input === "object" && !Array.isArray(raw.input) ? { input: raw.input as Record<string, unknown> } : {}),
+      objects: Array.isArray(raw.objects) ? raw.objects.filter((o: unknown) => typeof o === "string") : [],
+    });
+  }
+  return out;
+}
+
 /**
  * THE SKILLS THE SEARCH SAID ARE IN FORCE where this query landed.
  *

package/vendor/base/src/agent-mcp/handoff.ts

@@ -1,9 +1,9 @@
 /**
  * DOES THIS TOOL CALL END THE TURN?
  *
- * Decided by PROVENANCE and RESULT SHAPE, never by a hardcoded list of tool names. A tool
- * wired in up front keeps the conversation going; one spatial surfaced mid-loop is a handoff
- * candidate, and whether it actually ends the turn depends on what came back.
+ * Decided by PROVENANCE and RESULT SHAPE, never by a hardcoded list of tool names. The
+ * bridge knows which minted tools are workflow handoffs; whether one actually ends the
+ * turn depends on what came back.
  */
 import type { AgentToolExchange } from "./types.js";
 
@@ -16,39 +16,19 @@ export function parseToolResult(content: string): any {
   }
 }
 
-/**
- * Whether any tool call is a dynamically-discovered workflow handoff.
- *
- * Provenance, not a hardcoded name list: a tool keeps the conversation going if it
- * was wired in up front (`coreToolNames`, the getSchema set — SpatialSearch, memory,
- * connector MCPs). Only tools spatial surfaced mid-loop are handoff candidates.
- * With no wired-tool info we can't identify a handoff, so we keep going.
- */
-export function hasDynamicHandoff(toolNames: string[], coreToolNames?: Set<string>): boolean {
-  if (!coreToolNames || coreToolNames.size === 0) return false;
-  return toolNames.some((name) => !coreToolNames.has(name));
-}
-
 /**
  * Whether this batch of tool calls ENDS the agent's turn.
  *
- * Refined by RESULT shape: a dynamically-discovered tool whose result carries
- * `output` (or an explicit completed/error status) is an interactive app's SLOW
- * CALL — the user completed it and the answers ARE the result; the conversation
- * CONTINUES with them. Only the fire-and-forget handoff signature
- * ({ status: "started" } / unparseable) ends the turn.
+ * Only a tool in `handoffTools` can — a workflow-bound app fired through the service lane,
+ * whose result is the fire-and-forget signature ({ status: "started" } / unparseable). A
+ * result carrying `output` (or an explicit completed/error status) is a held call that
+ * came back with the answers, and the conversation continues with them. A component app, a
+ * workflow task or a platform tool is never a handoff, whatever it returns.
  */
-export function isTurnEndingHandoff(calls: AgentToolExchange[], coreToolNames?: Set<string>): boolean {
-  if (
-    !hasDynamicHandoff(
-      calls.map((c) => c.name),
-      coreToolNames,
-    )
-  ) {
-    return false;
-  }
+export function isTurnEndingHandoff(calls: AgentToolExchange[], handoffTools?: Set<string>): boolean {
+  if (!handoffTools?.size) return false;
   return calls.some((c) => {
-    if (coreToolNames?.has(c.name)) return false;
+    if (!handoffTools.has(c.name)) return false;
     const res = parseToolResult(c.resultContent);
     if (res && typeof res === "object" && (res.output || res.status === "completed" || res.status === "error")) return false;
     return true;

package/vendor/base/src/agent-mcp/index.ts

@@ -33,12 +33,12 @@ export type {
   AppInvocationContext,
 } from "./types.js";
 
-export { DISCOVERY_TOOL_NAMES, APP_ETIQUETTE, parseDiscoveredMCPs, handleDiscoveryResult, parseRegionSkills, type LoadedRegionSkill } from "./discovery.js";
-export { parseToolResult, hasDynamicHandoff, isTurnEndingHandoff } from "./handoff.js";
-export { rowComponentsFromResults, renderRowComponents, rankedRowIds, componentTypeFromAppUri, onEmptyRowDelivery } from "./rowComponents.js";
+export { DISCOVERY_TOOL_NAMES, APP_ETIQUETTE, parseDiscoveredMCPs, handleDiscoveryResult, parseRegionSkills, parseOfferedFunctions, type LoadedRegionSkill } from "./discovery.js";
+export { parseToolResult, isTurnEndingHandoff } from "./handoff.js";
+export { rowComponentsFromResults, renderRowComponents, rankedRowIds, componentTypeFromAppUri, onScreenRead, onScreenPlaces, placesOn, placesLine, rememberRows, rowsById, cardIdOf, screenOf, openedOn, type ScreenItem, openTasksOn, onScreenLine, ABOUT_THE_PAGE, ABOUT_THE_OPENED } from "./rowComponents.js";
 export { leanToolResultForModel } from "./lean.js";
-export { toolDefFromDiscoveredMCP, resolveToolDefNative, isBindinglessComponentApp, componentAppInvoker, modelToolName } from "./tools.js";
-export { invokeComponentAppNative, connectPlatformMcp } from "./invoke.js";
+export { toolDefFromDiscoveredMCP, resolveToolDefNative, isBindinglessComponentApp, componentAppInvoker, isWorkflowTask, workflowTaskInvoker, workflowAppInvoker, modelToolName, objectFunctionToolDef, objectFunctionInvoker } from "./tools.js";
+export { invokeTaskNative, connectPlatformMcp } from "./invoke.js";
 
 export { ingestConversationTurn, type ConversationTurn } from "./memoryIngest.js";
 export { fetchUserMemoryContext, hydratePromptWithUserMemory } from "./memoryContext.js";

package/vendor/base/src/agent-mcp/invoke.ts

@@ -2,12 +2,14 @@
  * THE ONE WIRE CALL. Where our code ends and native MCP begins.
  *
  * Everything else in this folder is interpretation and routing that never touches the MCP
- * wire. This is the exception: `invokeComponentAppNative` opens a client and makes a real
- * `tools/call`. From there the server renders, elicits, and its answers resolve the call.
+ * wire. This is the exception: `invokeTaskNative` opens a client and makes a real
+ * `tools/call`. From there the server renders, elicits, runs, and its answers resolve the call.
  *
- * Node-MCP rows and path-A workflow apps do NOT come through here — they route in-process
- * via the caller's `api.callService`, because they have a node or a workflow to run. Only a
- * path-B component app, with nothing local to call, rides the wire.
+ * TWO KINDS OF TASK ride it (2026-09-06, "every task is a native MCP tool"): a component
+ * app (path B: the server renders and elicits) and a WORKFLOW TASK (the server fires the
+ * Agent and holds the call until the run completes; the terminal output is the result).
+ * Node-MCP rows still route in-process via the caller's `api.callService`: they have a
+ * node to run. Renamed from `invokeComponentAppNative` when workflow tasks joined it.
  */
 import type { AppInvocationContext, DiscoveredMCP } from "./types.js";
 
@@ -68,7 +70,7 @@ export async function connectPlatformMcp(
   };
 }
 
-export async function invokeComponentAppNative(
+export async function invokeTaskNative(
   toolId: string,
   ctx: AppInvocationContext,
 ): Promise<{ status: "completed"; output?: Record<string, unknown>; conversationId?: string; action?: string; message?: string }> {
@@ -87,24 +89,44 @@ export async function invokeComponentAppNative(
           ...(ctx.instanceId ? { instanceId: ctx.instanceId } : {}),
           ...(ctx.fromRow ? { fromRow: true } : {}),
           ...(ctx.shell ? { shell: true } : {}),
+          ...(typeof ctx.rank === "number" ? { rank: ctx.rank } : {}),
           ...(ctx.batch ? { batch: ctx.batch } : {}),
+          // A workflow task's own arguments, as the model wrote them against the task's schema.
+          ...(ctx.args ?? {}),
         },
       },
       undefined,
-      // A human is completing the wizard — lift the SDK's 60s default to 24h.
+      // A human is completing the wizard, or an Agent is working — lift the SDK's 60s default to 24h.
       { timeout: 24 * 60 * 60 * 1000 },
     )) as {
       isError?: boolean;
       content?: Array<{ type: string; text?: string }>;
-      structuredContent?: { output?: Record<string, unknown>; conversationId?: string; action?: string };
+      structuredContent?: { output?: Record<string, unknown>; conversationId?: string; action?: string; result?: string; executionId?: string; status?: string };
     };
     // A handler exception arrives as an isError RESULT, not a rejection — surface it, or a
     // broken run masquerades as "completed with no output".
     if (result.isError) {
       throw new Error(result.content?.find((c) => c.type === "text")?.text || `${toolId} app tool call failed`);
     }
-    const output = result.structuredContent?.output;
+    // THE ANSWER IS THE RESULT (2026-09-15): a component that asks returns `structuredContent`
+    // conforming to its `outputSchema`, with no envelope. Older shapes keep `output` inside one.
+    const sc = result.structuredContent as Record<string, unknown> | undefined;
+    const bare = !!sc && sc.output === undefined && sc.app === undefined && sc.result === undefined && sc.rendered === undefined;
+    const output = bare ? sc : result.structuredContent?.output;
     const resultText = result.content?.find((c) => c.type === "text")?.text;
+    // A WORKFLOW TASK resolved: the Agent's run completed and `result` is its terminal
+    // output (server mcp/server/taskRun.ts). Handed to the model as `output.result` with
+    // the instruction that this IS the answer to use, not a profile to search with.
+    if (typeof result.structuredContent?.result === "string") {
+      return {
+        status: "completed",
+        output: { result: result.structuredContent.result },
+        conversationId: result.structuredContent?.conversationId,
+        message:
+          "The Agent completed. `output.result` is what it found, already shown to the person on screen. " +
+          "Continue the task with it: answer from it, and do not repeat it verbatim unless asked.",
+      };
+    }
     // BRIEFED component result (output carries `rendered`): the TEXT is the instruction
     // channel — the referee's "NOT RENDERED — <violations>" correction or the mirror's
     // "Rendered. The guest now sees this page…" reflection. Pass it through VERBATIM so
@@ -128,18 +150,14 @@ export async function invokeComponentAppNative(
       // live: card streamed in, then no follow-up text, twice).
       status: "completed",
       output,
-      conversationId: result.structuredContent?.conversationId,
+      conversationId: result.structuredContent?.conversationId ?? ctx.conversationId,
       action: result.structuredContent?.action,
-      // Tell the calling model what the output MEANS and that the task is NOT done yet.
-      // Without this the model summarises the answers and stops instead of using them —
-      // observed live: it returned a generic reply and never re-searched (iteration with
-      // toolCalls:0). The legacy MCPInvoker returned this same guidance; dropping it in the
-      // de-fork is why "the model does nothing with the answers". Restores the behaviour.
+      // THE ANSWER IS THE RESULT (2026-09-15, native elicitation): what each field means was
+      // declared on the tool's `outputSchema` and read before the call. Nothing is said here.
+      // A fixed "search now with this profile" sentence lived in this spot; it turned a
+      // chosen card into a search query.
       ...(output && Object.keys(output).length
-        ? {
-            message:
-              "`output` is the user's complete profile collected by the app — do NOT ask for any of these values again. The user's request is NOT yet fulfilled: any earlier search predates these answers. Search NOW with a query built from this profile and recommend the specific matches you find.",
-          }
+        ? {}
         : {
             message:
               "The component is now displayed on the user's screen. Continue your answer for the user now — the render is a visual aid, not your reply.",

package/vendor/base/src/agent-mcp/lean.ts

@@ -36,6 +36,11 @@ const MODEL_METADATA_FIELDS = [
   "category",
   "whenToUse",
   "section",
+  // A TASK row (object_type task): its identity URI and what its face says while it runs.
+  // The door fields (workflow, trigger, output) are read from the RAW row by the harness
+  // at mint time, never by the model.
+  "task",
+  "message",
 ] as const;
 
 /**
@@ -54,6 +59,14 @@ export function leanToolResultForModel(resultContent: string): string {
       // THE SEARCH'S MIRROR (MCP_APP_PROTOCOL §0.1): what the delivery put on screen. The
       // one key the model must read before the rows; kept verbatim.
       ...(typeof parsed.screen === "string" && parsed.screen ? { screen: parsed.screen } : {}),
+      // THE TOOLS THESE ROWS BROUGHT (objects-in-spatial.md, "Found objects' functions as tools").
+      // The harness minted them a moment ago; a tool minted mid-conversation reaches the model
+      // through its description alone, and observed 2026-09-16 that was not enough on a long
+      // conversation: the model answered from the rows with the tool on offer. Named here, in
+      // the reply it is reading, before the rows.
+      ...(parsed.functions && typeof parsed.functions === "object" && !Array.isArray(parsed.functions) && Object.keys(parsed.functions).length
+        ? { tools: Object.entries(parsed.functions as Record<string, any>).map(([tool, f]) => ({ tool, offeredBy: Array.isArray(f?.objects) ? f.objects : [], does: typeof f?.description === "string" ? f.description : "", call: "with a result's universal_id" })) }
+        : {}),
       results: parsed.results.map((r: Record<string, any>) => {
         const m = (r.metadata ?? {}) as Record<string, unknown>;
         const meta: Record<string, unknown> = {};
@@ -74,6 +87,9 @@ export function leanToolResultForModel(resultContent: string): string {
           description: r.description,
           ...(r.key_need ? { key_need: r.key_need } : {}),
           object_type: r.object_type,
+          // WHICH OF THE TWELVE IT IS (objects README 4a): the search route stamps it, the
+          // node keeps it, and this projection runs last, so it must keep it too.
+          ...(r.element ? { element: r.element } : {}),
           // One relevance number per mode: similarity (intent) or distance (discovery).
           ...(typeof r.similarity === "number" ? { similarity: r.similarity } : {}),
           ...(typeof r.distance === "number" ? { distance: r.distance } : {}),
@@ -83,6 +99,9 @@ export function leanToolResultForModel(resultContent: string): string {
           // 12 chars: cheaper than the URL it complements.
           ...(r.source_id ? { source_id: r.source_id } : {}),
           hasImage,
+          // ITS LINES, by name (migration 051): a need's `of` is what it was read from, a part's
+          // `partOf` its whole. They let rows be joined without a read.
+          ...(r.links && typeof r.links === "object" && Object.keys(r.links).length ? { links: r.links } : {}),
           ...(Object.keys(meta).length ? { metadata: meta } : {}),
         };
       }),

package/vendor/base/src/agent-mcp/memoryContext.ts

@@ -6,7 +6,7 @@
  * memory block (identity + current state, non-intrusion framing included)
  * from the memory server's GET /context at LOOP START and inlines it into the
  * agent's system context — memory arrives with the agent, never as a
- * model-visible tool call (MEMORY_SPEC.md v3 § Serving: zero-call standing lane).
+ * model-visible tool call (docs/architecture/signal/memory/MEMORY.md § Serving: the zero-call injected lane).
  *
  * Every agent family calls this once when building its instructions. Soft-fail
  * by design: memory server down / cold / no identity → returns "" and the agent
@@ -14,7 +14,11 @@
  */
 
 const MEMORY_SERVICE_URL = process.env.MEMORY_SERVICE_URL || "http://localhost:4114";
-const CONTEXT_FETCH_TIMEOUT_MS = 3_000;
+// SIX SECONDS, NOT THREE (2026-09-18). The memory service now keeps the block ready, so a
+// read is milliseconds; this only matters for the one cold build after a day's silence, and
+// three seconds lost that race against a database in another region. A call opened without
+// the block told a known caller "I don't have your name yet".
+const CONTEXT_FETCH_TIMEOUT_MS = 6_000;
 
 /**
  * Fetch the user's standing memory block, ready to append to the agent's
@@ -31,16 +35,18 @@ export async function fetchUserMemoryContext(
 
   const pubCtx = executionContext?.publishingContext;
   const userId = pubCtx?.userId;
-  const workflowId = executionContext?.workflow?.id;
-  if (!userId || !workflowId) {
+  // The org the run works as is the scope of a person's memory (MEMORY.md § 2.10); named by
+  // the run, else the canvas's default. Same precedence as memoryIngest.ts.
+  const org = pubCtx?.org ?? executionContext?.workflow?.org;
+  if (!userId || !org) {
     logger?.debug?.("[MemoryContext] Skipped — incomplete identity", {
       hasUserId: !!userId,
-      hasWorkflowId: !!workflowId,
+      hasOrg: !!org,
     });
     return "";
   }
 
-  return fetchUserMemoryBlock(userId, workflowId, executionContext?.auth?.accessToken, logger);
+  return fetchUserMemoryBlock(userId, org, executionContext?.auth?.accessToken, logger);
 }
 
 /**
@@ -48,13 +54,13 @@ export async function fetchUserMemoryContext(
  * director's verdict lane reads it this way — no node config, no execution
  * context). Same endpoint, same soft-fail: any problem returns "".
  */
-export async function fetchUserMemoryBlock(userId: string, workflowId: string, accessToken?: string, logger?: any): Promise<string> {
-  if (!userId || !workflowId) return "";
+export async function fetchUserMemoryBlock(userId: string, org: string, accessToken?: string, logger?: any): Promise<string> {
+  if (!userId || !org) return "";
   const headers: Record<string, string> = { "Content-Type": "application/json" };
   if (accessToken) headers["Authorization"] = `Bearer ${accessToken}`;
 
   try {
-    const params = new URLSearchParams({ userId, workflowId });
+    const params = new URLSearchParams({ userId, org });
     const res = await fetch(`${MEMORY_SERVICE_URL}/context?${params}`, {
       headers,
       signal: AbortSignal.timeout(CONTEXT_FETCH_TIMEOUT_MS),

package/vendor/base/src/agent-mcp/memoryIngest.ts

@@ -5,7 +5,7 @@
  * (config.enableUserMemory) is ON, each completed turn (original user input +
  * final agent answer — never intermediate iterations or tool chatter) is
  * POSTed to the memory server's /memory/ingest, which feeds the L1→L4
- * cascade (see docs/architecture/memory/MEMORY_SPEC.md). Replaces the retired
+ * consolidation pipeline (see docs/architecture/signal/memory/MEMORY.md). Replaces the retired
  * GravityMemoryStore canvas node.
  *
  * Every agent family calls this at turn completion with its own node type;
@@ -38,12 +38,16 @@ export function ingestConversationTurn(
 
   const pubCtx = executionContext?.publishingContext;
   const userId = pubCtx?.userId;
+  // THE ORG IS THE SCOPE (MEMORY.md § 2.10): a person's memory belongs to the organisation the
+  // run works as, never to one canvas. Named by the run, else the canvas's default — the same
+  // precedence every manifest gets (manifests/executor/context.ts). The canvas rides as a stamp.
+  const org = pubCtx?.org ?? executionContext?.workflow?.org;
   const workflowId = executionContext?.workflow?.id;
   const conversationId = pubCtx?.conversationId;
-  if (!userId || !workflowId || !conversationId) {
+  if (!userId || !org || !conversationId) {
     logger?.debug?.("[MemoryIngest] Skipped — incomplete identity", {
       hasUserId: !!userId,
-      hasWorkflowId: !!workflowId,
+      hasOrg: !!org,
       hasConversationId: !!conversationId,
     });
     return;
@@ -51,6 +55,7 @@ export function ingestConversationTurn(
 
   const payload: Record<string, any> = {
     userId,
+    org,
     workflowId,
     conversationId,
     executionId: executionContext?.executionId || "",