chore(release): prepare Memmy v1.2.2

.github/release-notes/v1.2.2.md

@@ -0,0 +1,22 @@
+# Memmy v1.2.2
+
+## Highlights
+
+- Improved memory initialization and turn capture by moving bounded work off the model path and exposing clearer background-capture diagnostics.
+- Improved bundled Memory runtime upgrades by selecting runtimes by build identity and validating the installed runtime across macOS and Windows.
+- Added long-document reading with bounded chunks and continuation offsets for PDF and Office files.
+- Improved agent-source ingestion, auto-injection, and skill distribution with broader regression coverage and clearer lifecycle handling.
+- Fixed LM Studio and OpenAI-compatible JSON response-format incompatibilities by retrying with text mode when needed.
+
+## Agent and Desktop improvements
+
+- Refreshed installed Claude Code, Codex, and Cursor hooks when their bundled revision or on-disk files are stale, and record the revision only after a successful install.
+- Kept queued memory processing moving after session close and retained end-topic turns that contain feedback or instructions for L1 capture.
+- Improved filesystem and document tools with consistent line numbering, continued long-document reads, and expanded agent-runtime regression coverage.
+- Tightened analytics boundaries by avoiding raw search queries, memory text, and identifiers in CLI command actions while reporting stored-memory and source-layer events consistently.
+
+## Upgrade notes
+
+- Memmy Desktop and Agent are version `1.2.2`.
+- The bundled Memory service, viewer, and CLI remain independently versioned.
+- Memory protocol version remains `1`.

.github/workflows/memory-release.yml

@@ -6,7 +6,7 @@ on:
       version:
         description: Memory version (X.Y.Z)
         required: true
-        default: 2.1.3
+        default: 2.1.4
   push:
     tags:
       - "memory-v*"
@@ -26,7 +26,9 @@ jobs:
       - run: npm ci
       - run: npm run typecheck -w @memmy/memory
       - run: npm test -w @memmy/memory
-      - run: npx vitest run App/shell/desktop/tests/packaged-runtime-boundary.test.ts App/shell/desktop/tests/runtime-services.test.ts
+      - run: npm run build -w @memmy/migrations
+      - run: npm run build -w @memmy/local-api-contracts
+      - run: npx vitest run App/shell/desktop/tests/packaged-runtime-boundary.test.ts App/shell/desktop/tests/runtime-services.test.ts App/shell/desktop/tests/runtime-memory-upgrade.test.ts tests/packaged-runtime-config.test.mjs
 
   runtime:
     needs: verify

.github/workflows/windows-memory-validation.yml

@@ -8,7 +8,11 @@ on:
       - "Memory/**"
       - "AgentSourceCore/**"
       - "App/shell/desktop/build/**"
+      - "App/shell/desktop/src/main/runtime-services.ts"
+      - "App/shell/desktop/tests/runtime-memory-upgrade.test.ts"
       - "App/shell/desktop/tests/windows-standard-upgrade-check.test.ts"
+      - "scripts/internal/shared/memory-runtime-build-identity.mjs"
+      - "scripts/internal/win/create-memory-runtime-manifest.mjs"
       - "package.json"
       - "package-lock.json"
   workflow_dispatch:
@@ -57,11 +61,19 @@ jobs:
         run: npm ci
       - name: Build shared Agent source contracts
         run: npm run build -w @memmy/agent-source-core
+      - name: Build desktop startup dependencies
+        run: |
+          npm run build -w @memmy/migrations
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          npm run build -w @memmy/local-api-contracts
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
       - name: Test Windows Memory contracts and temporary upgrade layouts
         run: >-
           node node_modules/vitest/vitest.mjs run
           tests/windows-memory-workflow.test.ts
           Memory/tests/runtime-installer-windows.test.ts
+          Memory/tests/runtime-installer.test.ts
+          App/shell/desktop/tests/runtime-memory-upgrade.test.ts
           App/shell/desktop/tests/windows-standard-upgrade-check.test.ts
           --reporter=default --reporter=json --outputFile=windows-memory-unit-results.json
       - name: Test the native temporary Memory task

App/backend/src/adapters/inbound/local-api/tests/agent-sources-route.test.ts

@@ -1039,6 +1039,9 @@ function createFakeAgentSourceService(): AgentSourceService {
     async uninstallPlugin() {
       return undefined;
     },
+    async isInstalledHookCurrent() {
+      return true;
+    },
     async detectMemoryPluginConflicts() {
       return [];
     }

App/backend/src/adapters/outbound/skill-writer/claude-code/target.ts

@@ -3,6 +3,7 @@ import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { createNodeHookCommand } from "../hook-command.js";
+import { isInstalledMemmyHookCurrent, memmyHookRevisionField } from "../hook-revision.js";
 import { readMemmyMemoryServiceConfig } from "../memmy-runtime-config.js";
 import { removeMemmySkillDirectory, replaceMemmySkillDirectory } from "../skill-directory.js";
 import { renderMemmyPluginSkillManifest } from "../templates/memmy-plugin.js";
@@ -85,6 +86,19 @@ export function createClaudeCodeSkillTarget(deps: CreateClaudeCodeSkillTargetDep
       return (await readTextFile(join(root, TARGET_FILE_NAME))).includes(START_MARKER);
     },
 
+    async isInstalledHookCurrent() {
+      const root = await this.resolveRootDirectory();
+      if (!root) return false;
+      const hookDirectory = join(root, HOOK_DIRECTORY_NAME);
+      return isInstalledMemmyHookCurrent({
+        source: CLAUDE_CODE_TARGET_ID,
+        mode: "claude-code",
+        hookScriptPath: join(hookDirectory, HOOK_SCRIPT_FILE_NAME),
+        bridgePath: join(hookDirectory, WORKSPACE_BRIDGE_FILE_NAME),
+        configPath: join(hookDirectory, HOOK_CONFIG_FILE_NAME)
+      });
+    },
+
     async installPlugin(_targetId) {
       const root = await this.resolveRootDirectory();
       if (!root) {
@@ -93,11 +107,13 @@ export function createClaudeCodeSkillTarget(deps: CreateClaudeCodeSkillTargetDep
 
       const hookDirectory = join(root, HOOK_DIRECTORY_NAME);
       const hookScriptPath = join(hookDirectory, HOOK_SCRIPT_FILE_NAME);
+      const hookConfigPath = join(hookDirectory, HOOK_CONFIG_FILE_NAME);
+      const hookConfig = {
+        memmy_config_path: memmyConfigPath,
+        ...(await readMemmyMemoryServiceConfig(memmyConfigPath))
+      };
       await mkdir(hookDirectory, { recursive: true });
-      await writeFileAtomically(
-        join(hookDirectory, HOOK_CONFIG_FILE_NAME),
-        `${JSON.stringify({ memmy_config_path: memmyConfigPath, ...(await readMemmyMemoryServiceConfig(memmyConfigPath)) }, null, 2)}\n`
-      );
+      await writeFileAtomically(hookConfigPath, `${JSON.stringify(hookConfig, null, 2)}\n`);
       await writeFileAtomically(
         hookScriptPath,
         renderMemmyResumeHookScript({ source: CLAUDE_CODE_TARGET_ID, mode: "claude-code" })
@@ -118,6 +134,10 @@ export function createClaudeCodeSkillTarget(deps: CreateClaudeCodeSkillTargetDep
         upsertMarkerBlock(await readTextFile(filePath), renderMemmySkillBootstrapManifest(manifest))
       );
       await replaceMemmySkillDirectory(root, manifest);
+      await writeFileAtomically(
+        hookConfigPath,
+        `${JSON.stringify({ ...hookConfig, ...(await memmyHookRevisionField(CLAUDE_CODE_TARGET_ID, "claude-code")) }, null, 2)}\n`
+      );
     },
 
     async uninstallPlugin(_targetId) {

App/backend/src/adapters/outbound/skill-writer/claude-code/tests/target.test.ts

@@ -119,6 +119,30 @@ describe("claude code skill target", () => {
     }
   });
 
+  it("marks a hook without a stored revision as outdated and refreshes it in place", async () => {
+    const { rootDirectory, memmyConfigPath } = createFixture();
+    const target = createClaudeCodeSkillTarget({ rootDirectory, memmyConfigPath });
+    const configPath = join(rootDirectory, "hooks", "memmy-memory-config.json");
+
+    await target.installPlugin?.("claude_code");
+    const installed = JSON.parse(readFileSync(configPath, "utf8")) as { hook_revision?: string };
+    expect(installed.hook_revision).toEqual(expect.stringMatching(/^[a-f0-9]{64}$/));
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(true);
+
+    writeFileSync(configPath, `${JSON.stringify({ ...installed, hook_revision: "stale" }, null, 2)}\n`, "utf8");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(false);
+
+    writeFileSync(join(rootDirectory, "hooks", "memmy-resume-hook.mjs"), "old hook\n", "utf8");
+    writeFileSync(configPath, `${JSON.stringify(installed, null, 2)}\n`, "utf8");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(false);
+    rmSync(join(rootDirectory, "hooks", "memmy-resume-hook.mjs"));
+    writeFileSync(configPath, `${JSON.stringify(installed, null, 2)}\n`, "utf8");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(false);
+
+    await target.installPlugin?.("claude_code");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(true);
+  });
+
   it("installs a UserPromptSubmit hook that blocks resume commands with top L1 candidates", async () => {
     const { rootDirectory, memmyConfigPath } = createFixture();
     let requestBody: Record<string, unknown> | undefined;

App/backend/src/adapters/outbound/skill-writer/codex/target.ts

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { resolveCodexHomeDirectory } from "../../agent-paths.js";
 import { createNodeHookCommand } from "../hook-command.js";
+import { isInstalledMemmyHookCurrent, memmyHookRevisionField } from "../hook-revision.js";
 import { readMemmyMemoryServiceConfig } from "../memmy-runtime-config.js";
 import {
   removeMemmyResumeSkillDirectory,
@@ -91,6 +92,19 @@ export function createCodexSkillTarget(deps: CreateCodexSkillTargetDeps = {}): S
       return (await readTextFile(join(root, TARGET_FILE_NAME))).includes(START_MARKER);
     },
 
+    async isInstalledHookCurrent() {
+      const root = await this.resolveRootDirectory();
+      if (!root) return false;
+      const hookDirectory = join(root, HOOK_DIRECTORY_NAME);
+      return isInstalledMemmyHookCurrent({
+        source: CODEX_TARGET_ID,
+        mode: "codex",
+        hookScriptPath: join(hookDirectory, HOOK_SCRIPT_FILE_NAME),
+        bridgePath: join(hookDirectory, WORKSPACE_BRIDGE_FILE_NAME),
+        configPath: join(hookDirectory, HOOK_CONFIG_FILE_NAME)
+      });
+    },
+
     async installPlugin(_targetId) {
       const root = await this.resolveRootDirectory();
       if (!root) {
@@ -99,11 +113,13 @@ export function createCodexSkillTarget(deps: CreateCodexSkillTargetDeps = {}): S
 
       const hookDirectory = join(root, HOOK_DIRECTORY_NAME);
       const hookScriptPath = join(hookDirectory, HOOK_SCRIPT_FILE_NAME);
+      const hookConfigPath = join(hookDirectory, HOOK_CONFIG_FILE_NAME);
+      const hookConfig = {
+        memmy_config_path: memmyConfigPath,
+        ...(await readMemmyMemoryServiceConfig(memmyConfigPath))
+      };
       await mkdir(hookDirectory, { recursive: true });
-      await writeFileAtomically(
-        join(hookDirectory, HOOK_CONFIG_FILE_NAME),
-        `${JSON.stringify({ memmy_config_path: memmyConfigPath, ...(await readMemmyMemoryServiceConfig(memmyConfigPath)) }, null, 2)}\n`
-      );
+      await writeFileAtomically(hookConfigPath, `${JSON.stringify(hookConfig, null, 2)}\n`);
       await writeFileAtomically(hookScriptPath, renderMemmyResumeHookScript({ source: CODEX_TARGET_ID, mode: "codex" }));
       await writeFileAtomically(
         join(hookDirectory, WORKSPACE_BRIDGE_FILE_NAME),
@@ -127,6 +143,10 @@ export function createCodexSkillTarget(deps: CreateCodexSkillTargetDeps = {}): S
         hooksFilePath,
         hookCommand
       });
+      await writeFileAtomically(
+        hookConfigPath,
+        `${JSON.stringify({ ...hookConfig, ...(await memmyHookRevisionField(CODEX_TARGET_ID, "codex")) }, null, 2)}\n`
+      );
     },
 
     async uninstallPlugin(_targetId) {

App/backend/src/adapters/outbound/skill-writer/codex/tests/target.test.ts

@@ -127,6 +127,27 @@ describe("codex skill target", () => {
     }
   });
 
+  it("marks a hook without a stored revision as outdated and refreshes it in place", async () => {
+    const { rootDirectory, memmyConfigPath } = createFixture();
+    const target = createCodexSkillTarget({ rootDirectory, memmyConfigPath, trustHooks: noOpTrustHooks });
+    const configPath = join(rootDirectory, "hooks", "memmy-memory-config.json");
+
+    await target.installPlugin?.("codex");
+    const installed = JSON.parse(readFileSync(configPath, "utf8")) as { hook_revision?: string };
+    expect(installed.hook_revision).toEqual(expect.stringMatching(/^[a-f0-9]{64}$/));
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(true);
+
+    writeFileSync(configPath, `${JSON.stringify({ ...installed, hook_revision: "stale" }, null, 2)}\n`, "utf8");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(false);
+
+    writeFileSync(join(rootDirectory, "hooks", "memmy-resume-hook.mjs"), "old hook\n", "utf8");
+    writeFileSync(configPath, `${JSON.stringify(installed, null, 2)}\n`, "utf8");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(false);
+
+    await target.installPlugin?.("codex");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(true);
+  });
+
   it("persists trust for the installed user-level hooks before installation completes", async () => {
     const { rootDirectory, memmyConfigPath } = createFixture();
     let trustOptions: TrustMemmyCodexHooksOptions | undefined;

App/backend/src/adapters/outbound/skill-writer/cursor/target.ts

@@ -3,6 +3,7 @@ import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { createNodeHookCommand } from "../hook-command.js";
+import { isInstalledMemmyHookCurrent, memmyHookRevisionField } from "../hook-revision.js";
 import { readMemmyMemoryServiceConfig } from "../memmy-runtime-config.js";
 import {
   removeMemmyResumeSkillDirectory,
@@ -59,16 +60,29 @@ export function createCursorSkillTarget(deps: CreateCursorSkillTargetDeps = {}):
       return (await readTextFile(join(cursorRootDirectory, "skills", "memmy-memory", "SKILL.md"))).includes("name: memmy-memory");
     },
 
+    async isInstalledHookCurrent() {
+      const hookDirectory = join(cursorRootDirectory, HOOK_DIRECTORY_NAME);
+      return isInstalledMemmyHookCurrent({
+        source: CURSOR_TARGET_ID,
+        mode: "cursor",
+        hookScriptPath: join(hookDirectory, HOOK_SCRIPT_FILE_NAME),
+        bridgePath: join(hookDirectory, WORKSPACE_BRIDGE_FILE_NAME),
+        configPath: join(hookDirectory, HOOK_CONFIG_FILE_NAME)
+      });
+    },
+
     async installPlugin(_targetId) {
       await mkdir(cursorRootDirectory, { recursive: true });
 
       const hookDirectory = join(cursorRootDirectory, HOOK_DIRECTORY_NAME);
       const hookScriptPath = join(hookDirectory, HOOK_SCRIPT_FILE_NAME);
+      const hookConfigPath = join(hookDirectory, HOOK_CONFIG_FILE_NAME);
+      const hookConfig = {
+        memmy_config_path: memmyConfigPath,
+        ...(await readMemmyMemoryServiceConfig(memmyConfigPath))
+      };
       await mkdir(hookDirectory, { recursive: true });
-      await writeFileAtomically(
-        join(hookDirectory, HOOK_CONFIG_FILE_NAME),
-        `${JSON.stringify({ memmy_config_path: memmyConfigPath, ...(await readMemmyMemoryServiceConfig(memmyConfigPath)) }, null, 2)}\n`
-      );
+      await writeFileAtomically(hookConfigPath, `${JSON.stringify(hookConfig, null, 2)}\n`);
       await writeFileAtomically(
         hookScriptPath,
         renderMemmyResumeHookScript({ source: CURSOR_TARGET_ID, mode: "cursor" })
@@ -83,6 +97,10 @@ export function createCursorSkillTarget(deps: CreateCursorSkillTargetDeps = {}):
       const manifest = renderMemmyPluginSkillManifest(_targetId);
       await replaceMemmySkillDirectory(cursorRootDirectory, manifest);
       await replaceMemmyResumeSkillDirectory(cursorRootDirectory, CURSOR_TARGET_ID);
+      await writeFileAtomically(
+        hookConfigPath,
+        `${JSON.stringify({ ...hookConfig, ...(await memmyHookRevisionField(CURSOR_TARGET_ID, "cursor")) }, null, 2)}\n`
+      );
     },
 
     async uninstallPlugin(_targetId) {

App/backend/src/adapters/outbound/skill-writer/cursor/tests/target.test.ts

@@ -103,6 +103,31 @@ describe("cursor skill target", () => {
     }
   });
 
+  it("marks a hook without a stored revision as outdated and refreshes it in place", async () => {
+    const { rootDirectory, memmyConfigPath } = createFixture();
+    const target = createCursorSkillTarget({ rootDirectory, memmyConfigPath });
+    const configPath = join(rootDirectory, "hooks", "memmy-memory-config.json");
+
+    await target.installPlugin?.("cursor");
+    const installed = JSON.parse(readFileSync(configPath, "utf8")) as { hook_revision?: string };
+    expect(installed.hook_revision).toEqual(expect.stringMatching(/^[a-f0-9]{64}$/));
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(true);
+
+    writeFileSync(configPath, `${JSON.stringify({ ...installed, hook_revision: "stale" }, null, 2)}\n`, "utf8");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(false);
+
+    writeFileSync(join(rootDirectory, "hooks", "memmy-resume-hook.mjs"), "old hook\n", "utf8");
+    writeFileSync(configPath, `${JSON.stringify(installed, null, 2)}\n`, "utf8");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(false);
+
+    delete installed.hook_revision;
+    writeFileSync(configPath, `${JSON.stringify(installed, null, 2)}\n`, "utf8");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(false);
+
+    await target.installPlugin?.("cursor");
+    await expect(target.isInstalledHookCurrent?.()).resolves.toBe(true);
+  });
+
   it("installs a resume Skill and reads the current memmyMemory storage instead of legacy storage", async () => {
     const { rootDirectory, memmyConfigPath } = createFixture();
     let requestBody: Record<string, unknown> | undefined;

App/backend/src/adapters/outbound/skill-writer/hook-revision.test.ts

@@ -0,0 +1,44 @@
+/** Hook revision tests. */
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { currentMemmyHookRevision, hookRevision, isInstalledMemmyHookCurrent } from "./hook-revision.js";
+
+let tempDir: string | undefined;
+
+afterEach(() => {
+  if (tempDir) {
+    rmSync(tempDir, { recursive: true, force: true });
+    tempDir = undefined;
+  }
+});
+
+describe("hook revision", () => {
+  it("changes when the hook script or workspace bridge changes", () => {
+    const current = hookRevision("hook script", "workspace bridge");
+
+    expect(hookRevision("hook script", "workspace bridge")).toBe(current);
+    expect(hookRevision("updated hook script", "workspace bridge")).not.toBe(current);
+    expect(hookRevision("hook script", "updated workspace bridge")).not.toBe(current);
+  });
+
+  it("treats a current fingerprint with leftover hook files as outdated", async () => {
+    tempDir = mkdtempSync(join(tmpdir(), "memmy-hook-revision-"));
+    const revision = await currentMemmyHookRevision("cursor", "cursor");
+    const hookScriptPath = join(tempDir, "memmy-resume-hook.mjs");
+    const bridgePath = join(tempDir, "memmy-workspace-bridge.mjs");
+    const configPath = join(tempDir, "memmy-memory-config.json");
+    writeFileSync(hookScriptPath, "old hook\n", "utf8");
+    writeFileSync(bridgePath, "old bridge\n", "utf8");
+    writeFileSync(configPath, `${JSON.stringify({ hook_revision: revision }, null, 2)}\n`, "utf8");
+
+    await expect(isInstalledMemmyHookCurrent({
+      source: "cursor",
+      mode: "cursor",
+      hookScriptPath,
+      bridgePath,
+      configPath
+    })).resolves.toBe(false);
+  });
+});