opencode-codex-memory 0.4.11 → 0.6.0

package/dist/src/options.d.ts

@@ -1,4 +1,5 @@
 import type { CodexInteropOptions } from "./codex-interop.js";
+import type { ClaudeImportOptions } from "./claude-import.js";
 /**
  * Effective plugin options + configuration diagnostics, owned by a leaf
  * module so both the plugin entry (writes) and the control tools (read for
@@ -6,8 +7,9 @@ import type { CodexInteropOptions } from "./codex-interop.js";
  *
  * Option names and defaults mirror codex's MemoriesToml/MemoriesConfig
  * (codex-rs/config/src/types.rs). Keep them 1:1 so the drift script and
- * manual syncing stay trivial; do not rename for taste. codex_interop is the
- * one opencode-specific addition (no codex equivalent).
+ * manual syncing stay trivial; do not rename for taste. codex_interop and
+ * claude_import are opencode-facing knobs for external-agent exchange
+ * (codex's Claude importer is migration-UI gated / default-off).
  */
 export interface PluginOptionsState {
     generate_memories: boolean;
@@ -22,6 +24,7 @@ export interface PluginOptionsState {
     max_rollouts_per_startup: number;
     min_rollout_idle_hours: number;
     codex_interop: CodexInteropOptions;
+    claude_import: ClaudeImportOptions;
 }
 export declare const pluginOptions: PluginOptionsState;
 export declare function resetPluginOptions(): void;

package/dist/src/options.js

@@ -9,16 +9,19 @@ const DEFAULT_PLUGIN_OPTIONS = {
     max_rollouts_per_startup: 2,
     min_rollout_idle_hours: 6,
     codex_interop: { import: false, export: false },
+    claude_import: { enabled: false },
 };
 export const pluginOptions = {
     ...DEFAULT_PLUGIN_OPTIONS,
     codex_interop: { ...DEFAULT_PLUGIN_OPTIONS.codex_interop },
+    claude_import: { ...DEFAULT_PLUGIN_OPTIONS.claude_import },
 };
 export function resetPluginOptions() {
     delete pluginOptions.extract_model;
     delete pluginOptions.consolidation_model;
     Object.assign(pluginOptions, DEFAULT_PLUGIN_OPTIONS, {
         codex_interop: { ...DEFAULT_PLUGIN_OPTIONS.codex_interop },
+        claude_import: { ...DEFAULT_PLUGIN_OPTIONS.claude_import },
     });
 }
 /**

package/dist/src/phase2.d.ts

@@ -1,11 +1,13 @@
 import { MemoryStore } from "./store.js";
 import { type CodexInteropOptions } from "./codex-interop.js";
+import { type ClaudeImportOptions } from "./claude-import.js";
 export interface Phase2Options {
     maxRaw: number;
     maxUnusedDays: number;
     extensionRetentionDays: number;
     consolidationModel?: string;
     codexInterop?: CodexInteropOptions;
+    claudeImport?: ClaudeImportOptions;
     /** Override the 90s heartbeat interval (tests / advanced). */
     heartbeatIntervalMs?: number;
 }

package/dist/src/phase2.js

@@ -5,6 +5,7 @@ import { invalidateCache } from "./source.js";
 import { memoryRoot } from "./paths.js";
 import { abortPhase2Consolidation, beginPhase2AbortScope, endPhase2AbortScope, isPluginShuttingDown, } from "./lifecycle.js";
 import { resolveCodexInterop, syncCodexImport, exportToCodexMemory } from "./codex-interop.js";
+import { syncClaudeImport } from "./claude-import.js";
 export const DEFAULT_PHASE2_OPTIONS = {
     maxRaw: 256,
     maxUnusedDays: 30,
@@ -76,7 +77,8 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
             rebuildRawMemories(outputs);
             writeRolloutSummaries(outputs);
             pruneExtensionResources(opts.extensionRetentionDays);
-            // Codex-interop import: inside the claimed job (workspace mutations are
+            // External-agent imports (Codex consolidated memory + Claude project
+            // memories): inside the claimed job (workspace mutations are
             // lease-protected — pre-claim writes could race a running consolidator),
             // after the baseline (copies must show up as diff, not be swallowed by a
             // first-run baseline init; codex memory_import.rs orders prepare-then-
@@ -92,6 +94,17 @@ export async function runPhase2(store, opts = DEFAULT_PHASE2_OPTIONS) {
                     console.warn("[opencode-codex-memory] codex import sync failed:", err);
                 }
             }
+            if (opts.claudeImport?.enabled) {
+                try {
+                    const result = syncClaudeImport(opts.claudeImport);
+                    for (const f of result.failures) {
+                        console.warn(`[opencode-codex-memory] claude import: ${f.message}`);
+                    }
+                }
+                catch (err) {
+                    console.warn("[opencode-codex-memory] claude import sync failed:", err);
+                }
+            }
             const diff = await captureWorkspaceDiff();
             if (releaseIfShuttingDown(store, claim.ownershipToken)) {
                 return { status: "shutting_down" };

package/dist/tools/control.js

@@ -9,8 +9,10 @@ import { assertMemoryRootSafe, readRegularFileNoFollow } from "../src/path-guard
 import { isPhase2InFlight } from "../src/phase2.js";
 import { pluginOptions, getConfigWarnings } from "../src/options.js";
 import { codexInteropMtimes, resolveCodexInterop } from "../src/codex-interop.js";
+import { claudeImportStatus, resolveClaudeHome } from "../src/claude-import.js";
 import { formatDiagnosticLine, getDiscoveryStatus, getRecentDiagnostics, } from "../src/diagnostics.js";
 import { isPluginShuttingDown } from "../src/lifecycle.js";
+import { getAgentHealth } from "../src/agent-health.js";
 function isSymlinkedRoot() {
     try {
         assertMemoryRootSafe();
@@ -82,6 +84,21 @@ function renderEffectiveConfig() {
             }
         }
     }
+    const cl = o.claude_import;
+    if (!cl.enabled) {
+        lines.push("  claude_import: off");
+    }
+    else {
+        const home = resolveClaudeHome(cl);
+        const reachable = fs.existsSync(home);
+        const allow = cl.projects && cl.projects.length > 0 ? ` projects=[${cl.projects.join(", ")}]` : " projects=all";
+        lines.push(`  claude_import: enabled${allow}`, `    claude home: ${home}${reachable ? "" : " (not found — nothing imported until Claude Code creates it)"}`);
+        const st = claudeImportStatus();
+        if (st.extensionPresent) {
+            const fmt = (ms) => (ms == null ? "none" : new Date(ms).toISOString());
+            lines.push(`    imported projects (${st.projects.length}): ${st.projects.length > 0 ? st.projects.join(", ") : "(none)"}`, `    instructions mtime: ${fmt(st.instructionsMtimeMs)}`);
+        }
+    }
     const warnings = getConfigWarnings();
     lines.push(warnings.length > 0 ? `config_warnings (${warnings.length}):` : "config_warnings: none", ...warnings.map((w) => `  - ${w}`));
     return lines;
@@ -121,6 +138,18 @@ function listMemoriesDir() {
     walk(root, "");
     return out;
 }
+function renderAgentHealth() {
+    const health = getAgentHealth();
+    const lines = [
+        `agent_config: ${health.observed ? "observed" : "not observed (config hook has not run)"}`,
+        `agent_generation_enabled: ${health.generationEnabled ?? "unknown"}`,
+    ];
+    for (const name of ["memorize", "memorize-extract"]) {
+        const entry = health.agents[name];
+        lines.push(`  agent_${name}: source=${entry.source} status=${entry.healthy ? "healthy" : "degraded"}`, ...entry.issues.map((issue) => `    issue: ${issue}`));
+    }
+    return lines;
+}
 export const memory_reset = tool({
     description: "Reset all persistent memory. Wipes the plugin's extracted memories and jobs tables and the entire " +
         "contents of the memories directory (including git history). Per-session memory modes are preserved, " +
@@ -248,6 +277,8 @@ export const memory_inspect = tool({
                 "",
                 ...renderEffectiveConfig(),
                 "",
+                ...renderAgentHealth(),
+                "",
                 ...diagnosticLines,
                 "",
                 "Files:",
@@ -271,8 +302,18 @@ export const memory_inspect = tool({
                     summary_chars: summaryChars,
                     summary_tokens_est: summaryTokens,
                     files: listing,
-                    effective_options: { ...pluginOptions, codex_interop: { ...pluginOptions.codex_interop } },
+                    effective_options: {
+                        ...pluginOptions,
+                        codex_interop: { ...pluginOptions.codex_interop },
+                        claude_import: {
+                            ...pluginOptions.claude_import,
+                            ...(pluginOptions.claude_import.projects
+                                ? { projects: [...pluginOptions.claude_import.projects] }
+                                : {}),
+                        },
+                    },
                     config_warnings: [...getConfigWarnings()],
+                    agent_health: getAgentHealth(),
                     recent_events: diagnostics,
                 },
             };

package/dist/tools/memory.d.ts

@@ -15,11 +15,13 @@ export declare const memory_list: {
     description: string;
     args: {
         path: import("zod").ZodDefault<import("zod").ZodString>;
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
         max_results: import("zod").ZodDefault<import("zod").ZodNumber>;
     };
     execute(args: {
         path: string;
         max_results: number;
+        cursor?: string | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
 };
 export declare const memory_search: {

package/dist/tools/memory.js

@@ -92,15 +92,23 @@ function visibleEntries(dir) {
     return out;
 }
 const LIST_MAX_RESULTS = 2000;
+// Codex sorts paths lexically (`Path` ordering), not with locale collation.
+// Keep ordering stable across hosts and match ASCII path ordering.
+function comparePathNames(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
 export const memory_list = tool({
     description: "List the immediate entries of a directory in the persistent memory workspace, sorted by name, " +
-        "with entry types. Hidden files and symlinks are skipped. Use path '' (empty) for the memory root.",
+        "with entry types. Hidden files and symlinks are skipped. Supports cursor pagination and listing " +
+        "a single file. Use path '' (empty) for the memory root.",
     args: {
         path: tool.schema.string().default("").describe("Relative directory path inside the memory workspace ('' for the root)."),
+        cursor: tool.schema.string().optional().describe("Pagination cursor from a previous response's next_cursor."),
         max_results: tool.schema.number().int().min(1).max(LIST_MAX_RESULTS).default(LIST_MAX_RESULTS).describe("Maximum entries to return."),
     },
     async execute(args) {
         try {
+            const root = assertMemoryRootSafe();
             const fullPath = safeResolveMemoryPath(args.path || ".");
             if (!fs.existsSync(fullPath))
                 return { output: `Not found: ${args.path}` };
@@ -111,19 +119,49 @@ export const memory_list = tool({
             if (st.isSymbolicLink()) {
                 return { output: `memory_list error: symlinks are not allowed in the memory workspace: ${args.path}` };
             }
-            if (!st.isDirectory())
-                return { output: `memory_list error: not a directory: ${args.path}` };
-            const entries = visibleEntries(fullPath).sort((a, b) => a.name.localeCompare(b.name));
-            const truncated = entries.length > args.max_results;
-            const shown = entries.slice(0, args.max_results);
-            const prefix = args.path ? `${args.path.replace(/\/+$/, "")}/` : "";
-            const listing = shown.map((e) => ({ path: `${prefix}${e.name}`, entry_type: e.isDir ? "directory" : "file" }));
-            if (listing.length === 0)
-                return { output: `Directory ${args.path || "."} is empty.` };
+            const entries = st.isFile()
+                ? [{ path: path.relative(root, fullPath).split(path.sep).join("/"), entry_type: "file" }]
+                : st.isDirectory()
+                    ? visibleEntries(fullPath)
+                        .sort((a, b) => comparePathNames(a.name, b.name))
+                        .map((e) => ({
+                        path: path.relative(root, path.join(fullPath, e.name)).split(path.sep).join("/"),
+                        entry_type: e.isDir ? "directory" : "file",
+                    }))
+                    : [];
+            let startIndex = 0;
+            if (args.cursor !== undefined) {
+                if (!/^\d+$/.test(args.cursor)) {
+                    return { output: `memory_list error: invalid cursor "${args.cursor}" (must be a non-negative integer).` };
+                }
+                startIndex = Number(args.cursor);
+                if (!Number.isSafeInteger(startIndex)) {
+                    return { output: `memory_list error: invalid cursor "${args.cursor}" (must be a non-negative integer).` };
+                }
+            }
+            if (startIndex > entries.length) {
+                return { output: `memory_list error: cursor ${args.cursor} exceeds result count ${entries.length}.` };
+            }
+            const maxResults = args.max_results ?? LIST_MAX_RESULTS;
+            const endIndex = Math.min(startIndex + maxResults, entries.length);
+            const nextCursor = endIndex < entries.length ? String(endIndex) : null;
+            const truncated = nextCursor !== null;
+            const listing = entries.slice(startIndex, endIndex);
+            if (listing.length === 0) {
+                const output = st.isDirectory()
+                    ? entries.length === 0
+                        ? `Directory ${args.path || "."} is empty.`
+                        : `No entries at cursor ${startIndex} for directory ${args.path || "."}.`
+                    : "";
+                return {
+                    output,
+                    metadata: { path: args.path, entries: [], next_cursor: nextCursor, truncated },
+                };
+            }
             return {
                 output: listing.map((e) => `${e.entry_type === "directory" ? "d" : "f"} ${e.path}`).join("\n") +
-                    (truncated ? `\n[truncated: ${entries.length - args.max_results} more entries]` : ""),
-                metadata: { path: args.path, entries: listing, truncated },
+                    (truncated ? `\n[truncated: ${entries.length - endIndex} more entries; pass cursor=${nextCursor}]` : ""),
+                metadata: { path: args.path, entries: listing, next_cursor: nextCursor, truncated },
             };
         }
         catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codex-memory",
-  "version": "0.4.11",
+  "version": "0.6.0",
   "description": "Persistent memory plugin for opencode — ports codex's two-phase memory system (extraction → consolidation → injection → citation feedback)",
   "type": "module",
   "main": "./dist/src/index.js",