@mastra/libsql 0.0.0-knowledge-org-scope-20260902233451 → 0.0.0-knowledge-w1-20261006001735

package/dist/_types/@internal_core/dist/knowledge-compat/index.d.ts

@@ -0,0 +1,533 @@
+//#region src/knowledge-compat/index.d.ts
+declare const KNOWLEDGE_V2_CORE_FEATURE = "knowledge-v2";
+declare const KNOWLEDGE_V2_MINIMUM_CORE_VERSION = "1.65.0-0";
+declare const KNOWLEDGE_STORAGE_CONTRACT_VERSION: 2;
+declare const KNOWLEDGE_STORAGE_SCHEMA_VERSION: 2;
+/** Hard cap on scope nodes returned by one `listScopeNodes` read. */
+declare const MAX_KNOWLEDGE_SCOPE_NODES = 1000;
+/** A reconciled structural scope node with its containing scope nodes. */
+interface KnowledgeScopeNodeSummary {
+  /** UUID of the `isScope` node. */
+  id: string;
+  /** Canonical address the scope node was reconciled from (e.g. `features:memory`). */
+  address: string;
+  name: string;
+  kind?: string;
+  description?: string;
+  /** UUIDs of the scope nodes that contain this scope (membership edges). */
+  parentIds: string[];
+}
+declare const TABLE_KNOWLEDGE_NODE_SCOPES = "mastra_knowledge_node_scopes";
+declare const TABLE_KNOWLEDGE_RECORD_SCOPES = "mastra_knowledge_record_scopes";
+declare const TABLE_KNOWLEDGE_SCOPE_GRANTS = "mastra_knowledge_scope_grants";
+declare const TABLE_KNOWLEDGE_ACCESS_STATE = "mastra_knowledge_access_state";
+declare const TABLE_KNOWLEDGE_SCOPE_ADDRESSES = "mastra_knowledge_scope_addresses";
+declare const TABLE_KNOWLEDGE_NODE_ADDRESSES = "mastra_knowledge_node_addresses";
+declare const TABLE_KNOWLEDGE_IMPORT_STATE = "mastra_knowledge_import_state";
+declare const TABLE_KNOWLEDGE_IMPORT_RUNS = "mastra_knowledge_import_runs";
+declare const TABLE_KNOWLEDGE_PROPOSALS = "mastra_knowledge_proposals";
+declare const KNOWLEDGE_TABLE_NAMES: readonly ["mastra_knowledge_nodes", "mastra_knowledge_records", "mastra_knowledge_mentions", "mastra_knowledge_cursors", "mastra_knowledge_activity", "mastra_knowledge_semantic_outbox", "mastra_knowledge_node_scopes", "mastra_knowledge_record_scopes", "mastra_knowledge_scope_grants", "mastra_knowledge_access_state", "mastra_knowledge_scope_addresses", "mastra_knowledge_node_addresses", "mastra_knowledge_import_state", "mastra_knowledge_import_runs", "mastra_knowledge_proposals"];
+declare const KNOWLEDGE_V2_NODES_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly name: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly kind: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly isScope: {
+    readonly type: 'boolean';
+    readonly nullable: false;
+  };
+  readonly metadata: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly deletedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly deletedBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly type: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly canonicalName: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly content: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly description: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly mergedInto: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_RECORDS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly nodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly text: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly metadata: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly source: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly deletedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly deletedBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly node: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly capturedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly when: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly maxScope: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_MENTIONS_SCHEMA: {
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_records";
+      readonly column: 'id';
+    };
+  };
+  readonly targetNodeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly sourceType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_NODE_SCOPES_SCHEMA: {
+  readonly nodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly addedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_RECORD_SCOPES_SCHEMA: {
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_records";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly addedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_SCOPE_GRANTS_SCHEMA: {
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeRefId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly role: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly canSuggest: {
+    readonly type: 'boolean';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_ACCESS_STATE_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly epoch: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly schemaVersion: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA: {
+  readonly address: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+};
+declare const KNOWLEDGE_NODE_ADDRESSES_SCHEMA: {
+  readonly source: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly address: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly nodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+};
+declare const KNOWLEDGE_IMPORT_STATE_SCHEMA: {
+  readonly importerId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly binding: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly key: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly value: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_IMPORT_RUNS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly importerId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly binding: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly importKind: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly triggerKind: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly status: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly error: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly transcriptThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly traceId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly queuedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly startedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly completedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_ACTIVITY_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly action: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly targetType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly targetId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly contextScopeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly importRunId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_import_runs";
+      readonly column: 'id';
+    };
+  };
+  readonly details: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly recordType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_PROPOSALS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly targetType: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly targetId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly action: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly changes: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly reason: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly proposerContextScopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly expectedVersion: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly status: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly reviewerContextScopeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly reviewedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+type KnowledgeSchemaInspection = {
+  status: 'compatible';
+  schemaVersion: typeof KNOWLEDGE_STORAGE_SCHEMA_VERSION;
+} | {
+  status: 'uninitialized';
+  schemaVersion: null;
+} | {
+  status: 'incompatible-reset-required';
+  schemaVersion: number | null;
+  reason: string;
+} | {
+  status: 'unavailable';
+  schemaVersion: null;
+  reason: string;
+};
+interface KnowledgeSchemaSnapshot {
+  available: boolean;
+  tableNames: readonly string[];
+  schemaVersion?: number;
+  reason?: string;
+}
+interface KnowledgeV2Core {
+  assertKnowledgeDescriptionWithinBound(description: string | undefined): void;
+  assertKnowledgeSchemaCompatible(inspection: KnowledgeSchemaInspection): void;
+  inspectKnowledgeSchema(snapshot: KnowledgeSchemaSnapshot): KnowledgeSchemaInspection;
+}
+declare function assertKnowledgeV2CoreSupport(features: ReadonlySet<string>): void;
+declare function createKnowledgeV2CoreLoader(features: ReadonlySet<string>, loadStorageModule: () => Promise<unknown>): () => Promise<KnowledgeV2Core>;
+//#endregion
+export { KNOWLEDGE_ACCESS_STATE_SCHEMA, KNOWLEDGE_IMPORT_RUNS_SCHEMA, KNOWLEDGE_IMPORT_STATE_SCHEMA, KNOWLEDGE_NODE_ADDRESSES_SCHEMA, KNOWLEDGE_NODE_SCOPES_SCHEMA, KNOWLEDGE_PROPOSALS_SCHEMA, KNOWLEDGE_RECORD_SCOPES_SCHEMA, KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA, KNOWLEDGE_SCOPE_GRANTS_SCHEMA, KNOWLEDGE_STORAGE_CONTRACT_VERSION, KNOWLEDGE_STORAGE_SCHEMA_VERSION, KNOWLEDGE_TABLE_NAMES, KNOWLEDGE_V2_ACTIVITY_SCHEMA, KNOWLEDGE_V2_CORE_FEATURE, KNOWLEDGE_V2_MENTIONS_SCHEMA, KNOWLEDGE_V2_MINIMUM_CORE_VERSION, KNOWLEDGE_V2_NODES_SCHEMA, KNOWLEDGE_V2_RECORDS_SCHEMA, KnowledgeSchemaInspection, KnowledgeSchemaSnapshot, KnowledgeScopeNodeSummary, MAX_KNOWLEDGE_SCOPE_NODES, TABLE_KNOWLEDGE_ACCESS_STATE, TABLE_KNOWLEDGE_IMPORT_RUNS, TABLE_KNOWLEDGE_IMPORT_STATE, TABLE_KNOWLEDGE_NODE_ADDRESSES, TABLE_KNOWLEDGE_NODE_SCOPES, TABLE_KNOWLEDGE_PROPOSALS, TABLE_KNOWLEDGE_RECORD_SCOPES, TABLE_KNOWLEDGE_SCOPE_ADDRESSES, TABLE_KNOWLEDGE_SCOPE_GRANTS, assertKnowledgeV2CoreSupport, createKnowledgeV2CoreLoader };
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/@internal_core/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-libsql
 description: Documentation for @mastra/libsql. Use when working with @mastra/libsql APIs, configuration, or implementation.
 metadata:
   package: "@mastra/libsql"
-  version: "0.0.0-knowledge-org-scope-20260902233451"
+  version: "0.0.0-knowledge-w1-20261006001735"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.0-knowledge-org-scope-20260902233451",
+  "version": "0.0.0-knowledge-w1-20261006001735",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-agents-human-in-the-loop.md

@@ -116,7 +116,44 @@ const stream = await agent.stream('Clean up old records', {
 })
 ```
 
-A tool's own `requireApproval` setting takes precedence over the function above. Its rule decides whether that tool needs approval. If the function throws, the call requires approval as a fail-safe.
+The function can be asynchronous. For decisions that depend on the tool name and arguments, use a [classifier](https://mastra.ai/reference/classifier/classifier) to estimate whether the call needs human review:
+
+```typescript
+import { Classifier } from '@mastra/core/classifier'
+import { typeSafeAi } from '@ai-sdk/typesafe-ai'
+import { agent } from './agent'
+
+const approvalClassifier = new Classifier({
+  id: 'tool-approval-classifier',
+  model: typeSafeAi.evaluationModel('jev-latest'),
+  questions: {
+    requiresApproval: {
+      type: 'boolean',
+      instructions:
+        'Does this tool call need human approval because it is destructive, irreversible, expensive, or handles sensitive data?',
+    },
+  },
+})
+
+const stream = await agent.stream('Clean up old records', {
+  requireToolApproval: async ({ toolName, args }) => {
+    const result = await approvalClassifier.evaluate({
+      state: {
+        toolName,
+        argumentNames: Object.keys(args),
+      },
+    })
+
+    return result.answers.requiresApproval.probability >= 0.7
+  },
+})
+```
+
+The example sends argument names rather than values because the classifier forwards its state to the configured evaluation model. If the decision requires argument values, redact sensitive data first or use an evaluation model and provider that meet the protected tool's data-handling requirements.
+
+Returning `true` pauses the tool call for human approval. It doesn't approve or decline the call automatically. Choose a threshold that matches the risk of the tools available to the agent. If this `requireToolApproval` function throws, it defaults to requiring approval.
+
+The runtime then combines that result with the tool's `requireApproval` setting. A boolean `true` requires approval, while `false` doesn't disable approval required by `requireToolApproval`. A tool-level `requireApproval` function is authoritative and replaces the combined result for that tool.
 
 > **Note:** Function-based `requireToolApproval` is only available on regular `stream()` / `generate()` calls. Durable agents and stored agents persist their options, and a function can't be serialized, so they accept only a boolean. If you pass a function in those contexts it falls back to requiring approval for every tool call.
 
@@ -370,6 +407,10 @@ const handleResume = async () => {
 }
 ```
 
+When a suspended or approval-gated tool call resumes, the stream emits a `tool-call-resumed` chunk with the same `toolCallId` before the call's `tool-result`. Its `payload.kind` is `'suspension'` or `'approval'`, and the payload repeats the original `args`, `suspendPayload`, and `resumeSchema`. The chunk is only emitted when a real suspension or approval request is cleared.
+
+With `@mastra/ai-sdk`, it arrives as a `data-tool-call-suspended` part (or `data-tool-call-approval` part for approvals) with `resumed: true`, which replaces the original part and keeps its payload. Use this signal to mark a question as answered. Don't infer it from the shape of the tool output: when the suspension came from a sub-agent, the output of the delegation call is the sub-agent's result, not your answer.
+
 ## Automatic tool resumption
 
 When using tools that call `suspend()`, you can enable automatic resumption so the agent resumes suspended tools based on the user's next message. Set `autoResumeSuspendedTools` to `true` in the agent's default options or per-request:

package/dist/docs/references/docs-deployment-workers.md

@@ -35,7 +35,10 @@ The orchestration worker requires a PubSub backend that supports pull mode (e.g.
 
 ### Scheduler worker
 
-Polls storage for due cron schedules and publishes `workflow.start` events. It's a producer only, meaning it creates work for the orchestration worker to pick up.
+Polls storage for due cron schedules and publishes a `workflow.start` event for each fire. It's a producer only, meaning it creates work for the orchestration worker to pick up:
+
+- **Split processes**: Scheduled workflows run on the evented engine, and the orchestration worker runs each fire step by step.
+- **In-process mode**: Scheduled workflows run on the default engine. The orchestration worker in the same process runs each fire in-process, the same way a direct `run.start()` does.
 
 The scheduler reads declarative `schedule` fields from your workflow definitions automatically. See [Scheduled workflows](https://mastra.ai/docs/workflows/scheduled-workflows) for how to declare schedules.
 
@@ -57,7 +60,7 @@ The background task worker manages concurrency limits, task lifecycle, and resul
 
 ### In-process mode (default)
 
-With no configuration, Mastra creates and starts workers inside the API process. Events flow through an in-memory PubSub, and everything shares a single Node.js runtime.
+With no configuration, Mastra runs workers inside the API process. Events flow through an in-memory PubSub, and everything shares a single Node.js runtime.
 
 ```typescript
 import { Mastra } from '@mastra/core/mastra'
@@ -68,6 +71,8 @@ export const mastra = new Mastra({
 })
 ```
 
+The server generated by `mastra build` starts these workers automatically. If you use a [server adapter](https://mastra.ai/docs/server/server-adapters) instead, add a call to `mastra.startWorkers()` after your server starts listening. See [Start background workers](https://mastra.ai/docs/server/server-adapters).
+
 This setup needs no external infrastructure beyond your storage adapter. It doesn't survive process crashes, and you can't scale individual components.
 
 ### Split processes
@@ -132,6 +137,8 @@ You can also pass a worker name to the CLI. The command sets `MASTRA_WORKERS` in
 mastra worker start orchestration
 ```
 
+Set `MASTRA_WORKERS` on every process in a split deployment, including `false` on the API process. Any value switches workflows that declare `schedule` to the evented engine, and every process must run those workflows on the same engine. See [Scheduled workflows](https://mastra.ai/docs/workflows/scheduled-workflows). `mastra worker start` without a worker name doesn't set `MASTRA_WORKERS`, so pass a name or set the variable in the process environment.
+
 ## Network architecture
 
 Workers are internal infrastructure. They're not exposed to end users and don't need their own subdomain or public URL, including an inbound HTTP route.
@@ -142,7 +149,7 @@ In a split deployment:
 - **Workers connect outbound only**: They pull events from the distributed PubSub backend and read/write to the shared storage database. They don't accept inbound traffic from clients.
 - **The orchestration worker calls the API internally**: It sends step execution requests to the API over the container network using `MASTRA_STEP_EXECUTION_URL`. This is internal service-to-service communication, not a public endpoint.
 
-All three worker types (orchestration, scheduler, background task) sit behind the API on a private network. They share access to the PubSub backend and storage database but never receive traffic directly from clients. HTTP routes for worker-related features run on the API server rather than the worker process. One example is token minting for a voice integration.
+All three worker types (orchestration, scheduler, background task) sit behind the API on a private network. They share access to the PubSub backend and storage database but never receive traffic directly from clients. HTTP routes for worker-related features run on the API server rather than the worker process. One example is creating a token for a voice integration.
 
 ## Deploy split workers
 
@@ -285,6 +292,8 @@ curl http://localhost:4111/api/agents
 
 ### Kubernetes
 
+> **Helm:** On Kubernetes, the [`mastra-projects` Helm chart](https://mastra.ai/integrations/deploy/kubernetes-helm) renders these deployments for you, with the workers on the same image and environment as the server. It also refuses to install combinations that would run every worker twice. The manifests below are for writing them by hand.
+
 Create separate Deployments for the API, orchestration worker, scheduler worker, and background task worker. Use the same image and Secret for each Deployment. Set only the role-specific environment variables directly on each container.
 
 The orchestration worker Deployment has the following shape:
@@ -391,4 +400,5 @@ If the API crashes while a step is executing, that work can be lost and the work
 - [Workers reference](https://mastra.ai/reference/workers/overview): Details about worker environment variables and types, with a list of supported storage backends
 - [CLI reference](https://mastra.ai/reference/cli/mastra): `mastra worker build` and `mastra worker start`
 - [PubSub](https://mastra.ai/docs/server/pubsub): Event delivery backends
+- [Kubernetes (Helm)](https://mastra.ai/integrations/deploy/kubernetes-helm): Deploy worker roles with the official chart
 - [Scheduled workflows](https://mastra.ai/docs/workflows/scheduled-workflows): Declare cron schedules on workflows

package/dist/docs/references/docs-memory-memory-processors.md

@@ -14,6 +14,12 @@ Memory processors are [processors](https://mastra.ai/docs/agents/processors) tha
 
 Mastra automatically adds these processors when memory is enabled:
 
+### `MemoryInputFilter`
+
+Trims client-echoed history before memory loaders run. For an existing thread, it keeps only the current user turn or new tool results. For an empty thread, it keeps the full initial input and removes provider item metadata from assistant parts that could refer to items that don't exist in storage.
+
+This processor runs first so `MessageHistory`, `SemanticRecall`, and Observational Memory receive only the new input they need.
+
 ### `MessageHistory`
 
 Retrieves message history and persists new messages.
@@ -206,7 +212,7 @@ Understanding the execution order is important when combining guardrails with me
 [Memory Processors] → [Your inputProcessors]
 ```
 
-1. **Memory processors run FIRST**: `WorkingMemory`, `MessageHistory`, `SemanticRecall`
+1. **Memory processors run FIRST**: `MemoryInputFilter`, then `WorkingMemory`, `MessageHistory`, and `SemanticRecall`
 2. **Your input processors run AFTER**: guardrails, filters, validators
 
 As a result, memory loads message history before your processors can validate or filter the input.