om-memory-system 5.5.0 → 5.7.0-next.218

package/README.md

@@ -119,7 +119,7 @@ cannot be saved.
 
 ### Memory spaces
 
-Keep separate stores for separate lines of work. The Spaces item in the web app sidebar opens a page with one card for each space. Switching a space applies to every host. See [Memory spaces](docs/memory-spaces.md).
+Keep separate stores for separate lines of work. The Spaces item in the web app sidebar opens a page with one card for each space. Switching a space applies to every host. Memories can be copied or moved between spaces, exported to a shareable file and imported into a new space, and a space can read the spaces it links. See [Memory spaces](docs/memory-spaces.md).
 
 ### Settings
 

package/dist/adapters/pi/extension.js

@@ -350,6 +350,11 @@ export default function ommsPiExtension(pi) {
             allowLinkedSource: Type.Optional(Type.Boolean()),
             spaceAction: Type.Optional(Type.String()),
             spaceName: Type.Optional(Type.String()),
+            spaceTo: Type.Optional(Type.String()),
+            spaceSince: Type.Optional(Type.String()),
+            spaceUntil: Type.Optional(Type.String()),
+            spaceProject: Type.Optional(Type.String()),
+            spaceIn: Type.Optional(Type.String()),
         }),
         async execute(_toolCallId, args, _signal, _onUpdate, ctx) {
             const result = await executeMemoryOperation(args, {

package/dist/cli/space-command.d.ts

@@ -1,14 +1,15 @@
 /**
- * `om-memory-system space <action> [name]`: list, create, switch, archive and unarchive memory
- * spaces from a terminal. Deleting, renaming, backing up and restoring a space exist only in the
- * web app, so those actions are refused here. Parsing stays free of engine imports so `--help`
- * is fast.
+ * `om-memory-system space <action> [name] [options]`: list, create, switch, archive,
+ * unarchive, preview, copy, link, unlink, export and import memory spaces from a
+ * terminal. Deleting, renaming, backing up, restoring and moving exist only in the
+ * web app, so those actions reach the shared operation and are refused there.
+ * Parsing stays free of engine imports so `--help` is fast.
  */
 export interface SpaceCommandIO {
     cwd?: string;
     stdout?: (text: string) => void;
     stderr?: (text: string) => void;
 }
-export declare const spaceCommandUsage = "Usage: om-memory-system space <action> [name]\n\nActions:\n  list                 List spaces and show the active one\n  status               Show the space this project uses now\n  create <name>        Add an empty space (it does not become active)\n  use <name>           Make a space the active one for every host, from the next turn\n  archive <name>       Hide a space from the switcher and keep its data\n  unarchive <name>     Show an archived space again\n\n<name> is a space name or id. Deleting, renaming, backing up and restoring a space\nare only possible in the web app.\n\nExamples:\n  om-memory-system space list\n  om-memory-system space create \"Client work\"\n  om-memory-system space use \"Client work\"";
+export declare const spaceCommandUsage = "Usage: om-memory-system space <action> [name] [options]\n\nActions:\n  list                 List spaces and show the active one\n  status               Show the space this project uses now\n  create <name>        Add an empty space (it does not become active)\n  use <name>           Make a space the active one for every host, from the next turn\n  archive <name>       Hide a space from the switcher and keep its data\n  unarchive <name>     Show an archived space again\n  preview [--from <a>] --to <b> [--since <date>] [--until <date>] [--project <tag>]\n                       Count the memories a copy would carry; writes nothing\n  copy [--from <a>] --to <b> [--since <date>] [--until <date>] [--project <tag>]\n                       Copy memories into another space; the source stays unchanged\n  link <name> [--in <space>]\n                       Make <name> searchable from <space> (the active space by default)\n  unlink <name> [--in <space>]\n                       Remove that link\n  export <name> --out <file> [--since <date>] [--until <date>] [--include-profile]\n                       Write one space to a JSON file that is safe to share\n  import <file> --name <new> [--retag-to-project <folder>]\n                       Create a new space from an export file\n\n<name> is a space name or id. Dates are ISO 8601 and both bounds are inclusive;\n--project takes the project tag a preview's groups show. Moving memories between\nspaces, and deleting, renaming, backing up or restoring a space, are only possible\nin the web app.\n\nExamples:\n  om-memory-system space list\n  om-memory-system space create \"Client work\"\n  om-memory-system space use \"Client work\"\n  om-memory-system space copy --from Experiments --to \"Client work\" --since 2026-10-01\n  om-memory-system space link \"Client work\" --in Experiments\n  om-memory-system space export \"Client work\" --out client.json";
 /** Run `om-memory-system space ...` and return the process exit code. */
 export declare function runSpaceCommand(argv: string[], io?: SpaceCommandIO): Promise<number>;

package/dist/cli/space-command.js

@@ -1,6 +1,7 @@
 import { resolve } from "node:path";
 import { SPACE_ACTIONS, WEB_ONLY_SPACE_ACTIONS } from "../services/spaces/operations.js";
-export const spaceCommandUsage = `Usage: om-memory-system space <action> [name]
+import { runSpaceExport, runSpaceImport } from "./space-transfer-command.js";
+export const spaceCommandUsage = `Usage: om-memory-system space <action> [name] [options]
 
 Actions:
   list                 List spaces and show the active one
@@ -9,36 +10,176 @@ Actions:
   use <name>           Make a space the active one for every host, from the next turn
   archive <name>       Hide a space from the switcher and keep its data
   unarchive <name>     Show an archived space again
+  preview [--from <a>] --to <b> [--since <date>] [--until <date>] [--project <tag>]
+                       Count the memories a copy would carry; writes nothing
+  copy [--from <a>] --to <b> [--since <date>] [--until <date>] [--project <tag>]
+                       Copy memories into another space; the source stays unchanged
+  link <name> [--in <space>]
+                       Make <name> searchable from <space> (the active space by default)
+  unlink <name> [--in <space>]
+                       Remove that link
+  export <name> --out <file> [--since <date>] [--until <date>] [--include-profile]
+                       Write one space to a JSON file that is safe to share
+  import <file> --name <new> [--retag-to-project <folder>]
+                       Create a new space from an export file
 
-<name> is a space name or id. Deleting, renaming, backing up and restoring a space
-are only possible in the web app.
+<name> is a space name or id. Dates are ISO 8601 and both bounds are inclusive;
+--project takes the project tag a preview's groups show. Moving memories between
+spaces, and deleting, renaming, backing up or restoring a space, are only possible
+in the web app.
 
 Examples:
   om-memory-system space list
   om-memory-system space create "Client work"
-  om-memory-system space use "Client work"`;
+  om-memory-system space use "Client work"
+  om-memory-system space copy --from Experiments --to "Client work" --since 2026-10-01
+  om-memory-system space link "Client work" --in Experiments
+  om-memory-system space export "Client work" --out client.json`;
+/** Every action the parser admits; the shared operation refuses the web-only ones. */
+const KNOWN_ACTIONS = new Set([
+    ...SPACE_ACTIONS,
+    ...WEB_ONLY_SPACE_ACTIONS,
+    "move",
+    "export",
+    "import",
+]);
+/** The value flags of the transfer forms. `--directory` is the runner's own flag. */
+const VALUE_FLAGS = new Set([
+    "--from",
+    "--to",
+    "--since",
+    "--until",
+    "--project",
+    "--in",
+    "--out",
+    "--name",
+    "--retag-to-project",
+    "--directory",
+]);
+/** How many positional arguments each action takes and which value flags it allows. */
+const ACTION_FORMS = {
+    list: { positionals: 0, flags: new Set() },
+    status: { positionals: 0, flags: new Set() },
+    create: { positionals: 1, flags: new Set() },
+    use: { positionals: 1, flags: new Set() },
+    archive: { positionals: 1, flags: new Set() },
+    unarchive: { positionals: 1, flags: new Set() },
+    delete: { positionals: 1, flags: new Set() },
+    rename: { positionals: 1, flags: new Set() },
+    backup: { positionals: 1, flags: new Set() },
+    restore: { positionals: 1, flags: new Set() },
+    move: { positionals: 1, flags: new Set(["--from", "--to"]) },
+    preview: {
+        positionals: 1,
+        flags: new Set(["--from", "--to", "--since", "--until", "--project"]),
+    },
+    copy: { positionals: 1, flags: new Set(["--from", "--to", "--since", "--until", "--project"]) },
+    link: { positionals: 1, flags: new Set(["--in"]) },
+    unlink: { positionals: 1, flags: new Set(["--in"]) },
+    export: { positionals: 1, flags: new Set(["--out", "--since", "--until"]) },
+    import: { positionals: 1, flags: new Set(["--name", "--retag-to-project"]) },
+};
+/** One pass over the argument list; every option is `--flag value` or a positional. */
+function parseSpaceArgs(argv) {
+    const parsed = {
+        values: new Map(),
+        includeProfile: false,
+        positionals: [],
+        directory: undefined,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === "--include-profile") {
+            parsed.includeProfile = true;
+            continue;
+        }
+        if (token.startsWith("--")) {
+            if (!VALUE_FLAGS.has(token))
+                return `Unknown option "${token}".`;
+            const value = argv[++i];
+            if (value === undefined)
+                return `Option "${token}" needs a value.`;
+            parsed.values.set(token.slice(2), value);
+            continue;
+        }
+        parsed.positionals.push(token);
+    }
+    parsed.directory = parsed.values.get("directory");
+    return parsed;
+}
 /** Run `om-memory-system space ...` and return the process exit code. */
 export async function runSpaceCommand(argv, io = {}) {
     const stdout = io.stdout ?? ((text) => console.log(text));
     const stderr = io.stderr ?? ((text) => console.error(text));
-    const [action, name, ...extra] = argv;
+    const [action, ...rest] = argv;
     if (action === undefined || action === "--help" || action === "-h") {
         stdout(spaceCommandUsage);
         return 0;
     }
-    const known = [...SPACE_ACTIONS, ...WEB_ONLY_SPACE_ACTIONS];
-    if (!known.includes(action) || extra.length > 0 || (name?.startsWith("--") ?? false)) {
-        const problem = extra.length > 0 ? `Unexpected argument "${extra[0]}"` : `Unknown space action "${action}"`;
+    const fail = (problem) => {
         stderr(`${problem}\n\n${spaceCommandUsage}`);
         return 1;
+    };
+    if (!KNOWN_ACTIONS.has(action))
+        return fail(`Unknown space action "${action}"`);
+    const parsed = parseSpaceArgs(rest);
+    if (typeof parsed === "string")
+        return fail(parsed);
+    const form = ACTION_FORMS[action];
+    const { values, positionals, includeProfile } = parsed;
+    if (positionals.length > form.positionals) {
+        return fail(`Unexpected argument "${positionals[form.positionals]}"`);
+    }
+    for (const flag of values.keys()) {
+        if (flag === "directory")
+            continue;
+        if (!form.flags.has(`--${flag}`))
+            return fail(`The ${action} action does not take --${flag}.`);
+    }
+    if (includeProfile && action !== "export") {
+        return fail(`The ${action} action does not take --include-profile.`);
     }
-    const directory = resolve(io.cwd ?? process.cwd());
+    const directory = resolve(parsed.directory ?? io.cwd ?? process.cwd());
     let result;
     try {
-        const { initConfig } = await import("../config.js");
-        initConfig(directory);
-        const { runSpaceMode } = await import("../core/space-tool.js");
-        result = await runSpaceMode({ mode: "space", spaceAction: action, spaceName: name }, directory);
+        if (action === "export" || action === "import") {
+            // The portability runners own their config bridge; the memory tool has none.
+            result =
+                action === "export"
+                    ? await runSpaceExport({
+                        name: positionals[0] ?? "",
+                        outPath: values.get("out") ?? "",
+                        ...(values.has("since") ? { since: values.get("since") } : {}),
+                        ...(values.has("until") ? { until: values.get("until") } : {}),
+                        ...(includeProfile ? { includeProfile: true } : {}),
+                    }, directory)
+                    : await runSpaceImport({
+                        filePath: positionals[0] ?? "",
+                        name: values.get("name") ?? "",
+                        ...(values.has("retag-to-project")
+                            ? { retagToProject: values.get("retag-to-project") }
+                            : {}),
+                    }, directory);
+        }
+        else {
+            const { initConfig } = await import("../config.js");
+            initConfig(directory);
+            const { runSpaceMode } = await import("../core/space-tool.js");
+            result = await runSpaceMode({
+                mode: "space",
+                spaceAction: action,
+                // The transfer source may be positional or --from; the other actions take a name.
+                spaceName: positionals[0] ??
+                    (action === "preview" || action === "copy" || action === "move"
+                        ? values.get("from")
+                        : undefined),
+                ...(values.has("to") ? { spaceTo: values.get("to") } : {}),
+                ...(values.has("since") ? { spaceSince: values.get("since") } : {}),
+                ...(values.has("until") ? { spaceUntil: values.get("until") } : {}),
+                ...(values.has("project") ? { spaceProject: values.get("project") } : {}),
+                ...(values.has("in") ? { spaceIn: values.get("in") } : {}),
+            }, directory);
+        }
     }
     catch (error) {
         result = { success: false, error: error instanceof Error ? error.message : String(error) };

package/dist/cli/space-transfer-command.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The `space export` and `space import` runners (design D8). Both are CLI-only: the
+ * `memory` tool `space` mode refuses them. This file is the one place that bridges
+ * CONFIG into `exportSpace` and `importSpace`, which themselves never read CONFIG;
+ * the shared space operation runs them only when the CLI hands it this bridge.
+ */
+export interface SpaceExportCliRequest {
+    /** The space to export: a name or id. */
+    name: string;
+    outPath: string;
+    since?: string;
+    until?: string;
+    includeProfile?: boolean;
+}
+export interface SpaceImportCliRequest {
+    /** Path of the export file to read. */
+    filePath: string;
+    /** The name of the new space the file becomes. */
+    name: string;
+    retagToProject?: string;
+}
+/** Runs `space export <name> --out <file>` through the shared space operation. */
+export declare function runSpaceExport(request: SpaceExportCliRequest, directory: string): Promise<Record<string, unknown>>;
+/** Runs `space import <file> --name <new>` through the shared space operation. */
+export declare function runSpaceImport(request: SpaceImportCliRequest, directory: string): Promise<Record<string, unknown>>;

package/dist/cli/space-transfer-command.js

@@ -0,0 +1,79 @@
+import { homedir } from "node:os";
+/** The bridge the CLI hands the shared operation: the export/import capability made real. */
+async function portabilityBridge(files, directory) {
+    const { CONFIG } = await import("../config.js");
+    return {
+        export: async (request) => {
+            const { exportSpace, getOmmsVersion } = await import("../services/spaces/export-space.js");
+            return exportSpace({
+                ...request,
+                embeddingModel: CONFIG.embeddingModel,
+                embeddingDimensions: CONFIG.embeddingDimensions,
+                ommsVersion: getOmmsVersion(),
+                homePath: homedir(),
+            });
+        },
+        import: async (request) => {
+            const { importSpace } = await import("../services/spaces/import-space.js");
+            const { embeddingService } = await import("../services/embedding.js");
+            const { getTags } = await import("../services/tags.js");
+            const user = getTags(directory).user;
+            return importSpace({
+                ...request,
+                files,
+                embedding: { model: CONFIG.embeddingModel, dimensions: CONFIG.embeddingDimensions },
+                embed: (text) => embeddingService.embedWithTimeout(text, { task: "document" }),
+                user: {
+                    userTag: user.tag,
+                    displayName: user.displayName,
+                    ...(user.userName ? { userName: user.userName } : {}),
+                    ...(user.userEmail ? { userEmail: user.userEmail } : {}),
+                },
+            });
+        },
+    };
+}
+/** Runs `space export <name> --out <file>` through the shared space operation. */
+export async function runSpaceExport(request, directory) {
+    const { CONFIG, getActiveSpace, initConfig } = await import("../config.js");
+    initConfig(directory);
+    const { executeSpaceOperation } = await import("../services/spaces/operations.js");
+    const { spaceFiles } = await import("../services/spaces/registry-store.js");
+    const { ommsHomeDir } = await import("../services/spaces/storage-resolution.js");
+    const { spaceOperationSettings } = await import("../core/space-tool.js");
+    const files = spaceFiles(ommsHomeDir());
+    return executeSpaceOperation({
+        action: "export",
+        name: request.name,
+        outPath: request.outPath,
+        ...(request.since === undefined ? {} : { since: request.since }),
+        ...(request.until === undefined ? {} : { until: request.until }),
+        ...(request.includeProfile ? { includeProfile: true } : {}),
+    }, {
+        files,
+        current: getActiveSpace(),
+        settings: spaceOperationSettings(CONFIG, files.spacesRoot),
+        portability: await portabilityBridge(files, directory),
+    });
+}
+/** Runs `space import <file> --name <new>` through the shared space operation. */
+export async function runSpaceImport(request, directory) {
+    const { CONFIG, getActiveSpace, initConfig } = await import("../config.js");
+    initConfig(directory);
+    const { executeSpaceOperation } = await import("../services/spaces/operations.js");
+    const { spaceFiles } = await import("../services/spaces/registry-store.js");
+    const { ommsHomeDir } = await import("../services/spaces/storage-resolution.js");
+    const { spaceOperationSettings } = await import("../core/space-tool.js");
+    const files = spaceFiles(ommsHomeDir());
+    return executeSpaceOperation({
+        action: "import",
+        name: request.name,
+        filePath: request.filePath,
+        ...(request.retagToProject === undefined ? {} : { retagToProject: request.retagToProject }),
+    }, {
+        files,
+        current: getActiveSpace(),
+        settings: spaceOperationSettings(CONFIG, files.spacesRoot),
+        portability: await portabilityBridge(files, directory),
+    });
+}

package/dist/core/memory-operations.d.ts

@@ -17,10 +17,20 @@ export interface MemoryOperationArgs {
     inputPath?: string;
     dryRun?: boolean;
     allowLinkedSource?: boolean;
-    /** `space` mode: list, status, create, archive, unarchive or use. */
+    /** `space` mode: list, status, create, archive, unarchive, use, preview, copy, link or unlink. */
     spaceAction?: string;
-    /** `space` mode: the space name or id. */
+    /** `space` mode: the space name or id; the transfer source or the link target. */
     spaceName?: string;
+    /** `space` mode: the transfer target (preview, copy). */
+    spaceTo?: string;
+    /** `space` mode: inclusive ISO 8601 lower bound on the creation time (preview, copy). */
+    spaceSince?: string;
+    /** `space` mode: inclusive ISO 8601 upper bound on the creation time (preview, copy). */
+    spaceUntil?: string;
+    /** `space` mode: only memories with this project tag (preview, copy). */
+    spaceProject?: string;
+    /** `space` mode: the space that owns a link (link, unlink); the active space when omitted. */
+    spaceIn?: string;
 }
 export interface MemoryOperationContext {
     directory: string;

package/dist/core/memory-operations.js

@@ -14,6 +14,8 @@ function formatSearchResults(query, results, limit) {
             content: result.memory || result.chunk,
             type: result.type,
             similarity: Math.round(result.similarity * 100),
+            // A linked result carries its space so the caller can tell it is read-only.
+            ...(result.spaceName ? { space: result.spaceName } : {}),
         })),
     };
 }
@@ -81,8 +83,16 @@ export async function executeMemoryOperation(args, context) {
                         { command: "list", description: "List recent memories", args: ["limit?"] },
                         {
                             command: "space",
-                            description: "Manage memory spaces: list, status, create, archive, unarchive, use. Deleting a space is only possible in the web app",
-                            args: ["spaceAction?", "spaceName?"],
+                            description: "Manage memory spaces: list, status, create, archive, unarchive, use, preview, copy, link, unlink. Moving, deleting, exporting and importing are not offered here",
+                            args: [
+                                "spaceAction?",
+                                "spaceName?",
+                                "spaceTo?",
+                                "spaceSince?",
+                                "spaceUntil?",
+                                "spaceProject?",
+                                "spaceIn?",
+                            ],
                         },
                         { command: "forget", description: "Remove memory", args: ["memoryId"] },
                         {
@@ -141,7 +151,7 @@ export async function executeMemoryOperation(args, context) {
             case "search": {
                 if (!args.query)
                     return { success: false, error: "query required" };
-                const result = await memoryClient.searchMemories(args.query, tags.project.tag, args.scope ?? CONFIG.memory.defaultScope);
+                const result = await memoryClient.searchMemories(args.query, tags.project.tag, args.scope ?? CONFIG.memory.defaultScope, { includeLinked: true });
                 if (!result.success)
                     return { success: false, error: result.error };
                 return formatSearchResults(args.query, result, args.limit);
@@ -210,7 +220,7 @@ export async function executeMemoryOperation(args, context) {
                 };
             }
             case "list": {
-                const result = await memoryClient.listMemories(tags.project.tag, args.limit || 20, args.scope ?? CONFIG.memory.defaultScope);
+                const result = await memoryClient.listMemories(tags.project.tag, args.limit || 20, args.scope ?? CONFIG.memory.defaultScope, { includeLinked: true });
                 if (!result.success)
                     return { success: false, error: result.error };
                 return {

package/dist/core/recall-summary.js

@@ -7,12 +7,14 @@ export function queryLine(query, max = QUERY_CUT) {
     return line.length > max ? `${line.slice(0, max - 3)}...` : line;
 }
 // Entry shape comes from `formatContextForPrompt`: `<memory id="..." relevance="N%">`, with the
-// id missing when the result had none. A body ends at its own `</memory>` when another entry, a
-// section close or the end of the text follows it. The Claude Code hook can cut a block short and
-// leave tags open, so a body also ends at a section close or at the end of the text. An opening
-// tag inside the text, even at the start of a line, does not end it: a memory can quote the tag.
+// id missing when the result had none. A linked memory carries further attributes after the
+// relevance (`space="..."`), so any number of them may sit before the tag closes. A body ends at
+// its own `</memory>` when another entry, a section close or the end of the text follows it. The
+// Claude Code hook can cut a block short and leave tags open, so a body also ends at a section
+// close or at the end of the text. An opening tag inside the text, even at the start of a line,
+// does not end it: a memory can quote the tag.
 const SECTION_CLOSE = String.raw `<\/project_knowledge>|<\/memory_context>|<\/omms-retrieval>`;
-const MEMORY_ENTRY = new RegExp(String.raw `<memory(?:\s+id="([^"]*)")?\s+relevance="(\d+)%">([\s\S]*?)` +
+const MEMORY_ENTRY = new RegExp(String.raw `<memory(?:\s+id="([^"]*)")?\s+relevance="(\d+)%"(?:\s+[a-z][a-z-]*="[^"]*")*>([\s\S]*?)` +
     String.raw `(?=<\/memory>\s*(?:<memory\s|${SECTION_CLOSE}|$)|${SECTION_CLOSE}|$)`, "g");
 // A restored-session section from `formatMemoriesForCompaction`: `### Memory N (id)`, no relevance.
 // Same rule as the Claude Code parser (`hooks/omms-recall-parse.js`).

package/dist/core/retrieval.js

@@ -17,7 +17,10 @@ export async function searchSectionMemories(query, projectTag, sessionId) {
     // Snapshot before the async search: an excludeCurrentSession edit during
     // the search must not change this operation's filtering.
     const excludeCurrentSession = CONFIG.chatMessage.excludeCurrentSession;
-    const search = await memoryClient.searchMemories(query, projectTag);
+    // Recall reads linked spaces too (D6); capture and profile steps keep the default.
+    const search = await memoryClient.searchMemories(query, projectTag, "project", {
+        includeLinked: true,
+    });
     if (!search.success)
         return null;
     const results = excludeCurrentSession
@@ -57,7 +60,7 @@ export async function buildRetrievalSection(prompt, directory, sessionId, budget
  * Code `SessionStart`). Returns null when no memory qualifies.
  */
 export async function buildRecentMemoriesSection(options) {
-    const listResult = await memoryClient.listMemories(options.projectTag, options.maxMemories);
+    const listResult = await memoryClient.listMemories(options.projectTag, options.maxMemories, "project", { includeLinked: true });
     let memories = listResult.success ? listResult.memories : [];
     if (options.excludeCurrentSession) {
         memories = memories.filter((m) => m.metadata?.sessionID !== options.sessionId);

package/dist/core/space-tool.d.ts

@@ -1,6 +1,11 @@
 import type { MemoryOperationArgs } from "./memory-operations.js";
-/**
- * The `space` mode of the `memory` tool. It loads on demand, so the other modes never import
- * the space code. It needs no embedding model and no open memory store.
- */
+import type { SpaceOperationSettings } from "../services/spaces/operations.js";
+/** Snapshots the settings the space-bound operations need from a CONFIG-shaped object. */
+export declare function spaceOperationSettings(config: {
+    skillStoragePath?: string;
+    storagePath: string;
+    embeddingModel: string;
+    embeddingDimensions: number;
+    maxVectorsPerShard: number;
+}, spacesRoot: string): SpaceOperationSettings;
 export declare function runSpaceMode(args: MemoryOperationArgs, directory: string): Promise<Record<string, unknown>>;

package/dist/core/space-tool.js

@@ -1,13 +1,45 @@
 /**
  * The `space` mode of the `memory` tool. It loads on demand, so the other modes never import
- * the space code. It needs no embedding model and no open memory store.
+ * the space code. `list`, `use` and `create` need no embedding model and no open memory store;
+ * `preview` and `copy` open space stores, so only they carry the settings snapshot.
  */
+/** The actions that read or write a space store, so their settings are loaded only for them. */
+const STORE_ACTIONS = new Set(["preview", "copy"]);
+/** Snapshots the settings the space-bound operations need from a CONFIG-shaped object. */
+export function spaceOperationSettings(config, spacesRoot) {
+    return {
+        paths: {
+            // Default's folder is the global store, even while a space or project folder is in use.
+            globalStoragePath: config.skillStoragePath ?? config.storagePath,
+            spacesRoot,
+        },
+        embedding: { model: config.embeddingModel, dimensions: config.embeddingDimensions },
+        maxVectorsPerShard: config.maxVectorsPerShard,
+    };
+}
 export async function runSpaceMode(args, directory) {
-    const { getActiveSpace, refreshConfigIfChanged } = await import("../config.js");
+    const { CONFIG, getActiveSpace, refreshConfigIfChanged } = await import("../config.js");
     const { executeSpaceOperation } = await import("../services/spaces/operations.js");
     const { spaceFiles } = await import("../services/spaces/registry-store.js");
     const { ommsHomeDir } = await import("../services/spaces/storage-resolution.js");
-    const result = await executeSpaceOperation({ action: args.spaceAction, name: args.spaceName }, { files: spaceFiles(ommsHomeDir()), current: getActiveSpace() });
+    const files = spaceFiles(ommsHomeDir());
+    const action = args.spaceAction?.trim().toLowerCase();
+    const result = await executeSpaceOperation({
+        action: args.spaceAction,
+        name: args.spaceName,
+        ...(args.spaceTo === undefined ? {} : { to: args.spaceTo }),
+        ...(args.spaceSince === undefined ? {} : { since: args.spaceSince }),
+        ...(args.spaceUntil === undefined ? {} : { until: args.spaceUntil }),
+        ...(args.spaceProject === undefined ? {} : { project: args.spaceProject }),
+        ...(args.spaceIn === undefined ? {} : { owner: args.spaceIn }),
+    }, {
+        files,
+        current: getActiveSpace(),
+        // The transfer actions open space stores, so only they get the settings (design D8).
+        ...(STORE_ACTIONS.has(action ?? "")
+            ? { settings: spaceOperationSettings(CONFIG, files.spacesRoot) }
+            : {}),
+    });
     // A switch made here takes effect in this process now, not only on its next config refresh.
     refreshConfigIfChanged(directory);
     return result;

package/dist/services/active-space-access.d.ts

@@ -0,0 +1,6 @@
+import type { LinkedOwner } from "./linked-search.js";
+/**
+ * Reads the active space the way partial test stubs allow: a `config.js` stub may
+ * leave out `getActiveSpace`, and a missing one means the Default space.
+ */
+export declare function activeOwner(): LinkedOwner;

package/dist/services/active-space-access.js

@@ -0,0 +1,8 @@
+import * as configModule from "../config.js";
+/**
+ * Reads the active space the way partial test stubs allow: a `config.js` stub may
+ * leave out `getActiveSpace`, and a missing one means the Default space.
+ */
+export function activeOwner() {
+    return configModule.getActiveSpace?.() ?? { id: "default", customStoragePath: false };
+}

package/dist/services/chat/chat-runtime.js

@@ -89,7 +89,7 @@ export async function chatServiceDeps(config) {
         retrieve: {
             searchMemories: async (query, scopeTag) => {
                 const { memoryClient } = await import("../client.js");
-                const result = await memoryClient.searchMemories(query, scopeTag ?? "", scopeTag ? "project" : "all-projects");
+                const result = await memoryClient.searchMemories(query, scopeTag ?? "", scopeTag ? "project" : "all-projects", { includeLinked: true });
                 return result.success ? result.results : [];
             },
             embed: async (text) => {

package/dist/services/client.d.ts

@@ -1,4 +1,6 @@
+import { type MemoryReadOptions } from "./linked-search.js";
 import type { MemoryType } from "../types/index.js";
+import type { SearchResult } from "./turso/types.js";
 export type MemoryScope = "project" | "all-projects";
 export declare class LocalMemoryClient {
     private initPromise;
@@ -16,10 +18,10 @@ export declare class LocalMemoryClient {
     };
     reset(): void;
     close(): Promise<void>;
-    searchMemories(query: string, containerTag: string, scope?: MemoryScope): Promise<{
+    searchMemories(query: string, containerTag: string, scope?: MemoryScope, options?: MemoryReadOptions): Promise<{
         warnings?: string[] | undefined;
         success: true;
-        results: import("./turso/types.js").SearchResult[];
+        results: SearchResult[];
         total: number;
         timing: number;
         queryVector: Float32Array<ArrayBufferLike>;
@@ -60,21 +62,9 @@ export declare class LocalMemoryClient {
         success: boolean;
         error: string;
     }>;
-    listMemories(containerTag: string, limit?: number, scope?: MemoryScope): Promise<{
+    listMemories(containerTag: string, limit?: number, scope?: MemoryScope, options?: MemoryReadOptions): Promise<{
         success: true;
-        memories: {
-            id: any;
-            summary: any;
-            type: string | undefined;
-            createdAt: string;
-            metadata: any;
-            displayName: any;
-            userName: any;
-            userEmail: any;
-            projectPath: any;
-            projectName: any;
-            gitRepoUrl: any;
-        }[];
+        memories: any[];
         pagination: {
             currentPage: number;
             totalItems: number;