opencode-codex-memory 0.4.7 → 0.4.9

package/dist/tools/control.js

@@ -8,7 +8,9 @@ import { estimateTokens } from "../src/token.js";
 import { assertMemoryRootSafe, readRegularFileNoFollow } from "../src/path-guard.js";
 import { isPhase2InFlight } from "../src/phase2.js";
 import { pluginOptions, getConfigWarnings } from "../src/options.js";
-import { resolveCodexInterop } from "../src/codex-interop.js";
+import { codexInteropMtimes, resolveCodexInterop } from "../src/codex-interop.js";
+import { formatDiagnosticLine, getDiscoveryStatus, getRecentDiagnostics, } from "../src/diagnostics.js";
+import { isPluginShuttingDown } from "../src/lifecycle.js";
 function isSymlinkedRoot() {
     try {
         assertMemoryRootSafe();
@@ -73,6 +75,11 @@ function renderEffectiveConfig() {
         else {
             const reachable = fs.existsSync(resolved.codexMemoryRoot);
             lines.push(`  codex_interop: import=${ci.import} export=${ci.export}`, `    codex memories: ${resolved.codexMemoryRoot}${reachable ? "" : " (not found yet — nothing is imported/exported until Codex's memory feature creates it)"}`);
+            if (reachable) {
+                const mt = codexInteropMtimes(resolved.codexMemoryRoot);
+                const fmt = (ms) => (ms == null ? "none" : new Date(ms).toISOString());
+                lines.push(`    last import mtimes: MEMORY.md=${fmt(mt.importMemoryMd)} summary=${fmt(mt.importSummary)}`, `    last export mtimes: MEMORY.md=${fmt(mt.exportMemoryMd)} summary=${fmt(mt.exportSummary)}`);
+            }
         }
     }
     const warnings = getConfigWarnings();
@@ -129,9 +136,11 @@ export const memory_reset = tool({
         }
         // A consolidation running in THIS process would recreate files right
         // after the wipe (the sub-agent edits live artifacts and resets the git
-        // baseline). Refuse instead of racing it. Cross-process consolidators
-        // are still ownership-guarded DB-side (the wiped job rows make their
-        // final confirmation a no-op) but may leave stray files; same window
+        // baseline). Refuse instead of racing it. clearMemoryData also leaves a
+        // phase-2 cooldown marker so the next idle/chat hook cannot first-run-claim
+        // phase 2 and re-seed the root via ensureLayout. Cross-process consolidators
+        // already in flight remain ownership-guarded (their final mark becomes a
+        // no-op once the row is replaced) but may leave stray files — same window
         // codex has between CLI clear and a running daemon.
         if (isPhase2InFlight()) {
             return { output: "Reset refused: memory consolidation is currently running. Try again in a few minutes." };
@@ -161,11 +170,12 @@ function fmtWatermarkMs(ms) {
     return new Date(ms).toISOString();
 }
 export const memory_inspect = tool({
-    description: "Inspect the current memory state. Returns: stage1_outputs count, Phase 2 job status " +
-        "(including last error / retry time when failed), last Phase 2 success watermark, " +
-        "memory_summary token estimate (on-disk; injection caps at ~2500), a listing of the " +
-        "memories directory, the effective plugin options, and any configuration warnings " +
-        "(unknown/malformed options). Use it to verify the plugin configuration took effect. Read-only.",
+    description: "Inspect the current memory state. Returns: stage1_outputs count, stage-1 job status " +
+        "breakdown and recent errors, Phase 2 job status (including last error / retry time), " +
+        "last discovery outcome, pipeline diagnostics, memory_summary token estimate " +
+        "(on-disk; injection caps at ~2500), a listing of the memories directory, the " +
+        "effective plugin options, and any configuration warnings. Use it to verify " +
+        "configuration and debug why memory is not building. Read-only.",
     args: {},
     async execute() {
         try {
@@ -173,6 +183,7 @@ export const memory_inspect = tool({
             assertMemoryRootSafe();
             const store = new MemoryStore();
             const outputs = store.stage1Outputs();
+            const stage1Jobs = store.stage1JobSnapshot();
             const summaryPath = memorySummaryPath();
             let summaryChars = 0;
             let summaryTokens = 0;
@@ -201,15 +212,44 @@ export const memory_inspect = tool({
                     "phase2_last_success_watermark: none",
                     "phase2_last_success_finished_at: none",
                 ];
+            const stage1StatusParts = Object.entries(stage1Jobs.by_status)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([s, c]) => `${s}=${c}`);
+            const stage1Lines = [
+                `stage1_jobs: ${stage1StatusParts.length > 0 ? stage1StatusParts.join(" ") : "none"}`,
+                ...stage1Jobs.recent_errors.map((e) => `  stage1_error ${e.session_id} (${e.status}): ${e.last_error.slice(0, 200)}${e.retry_at ? ` retry_at=${fmtUnixSec(e.retry_at)}` : ""}`),
+            ];
+            const discovery = getDiscoveryStatus();
+            const discoveryLine = discovery
+                ? `discovery: ${discovery.ok ? "ok" : "failed"} count=${discovery.count} at=${new Date(discovery.at).toISOString()}${discovery.error ? ` error=${discovery.error}` : ""}`
+                : "discovery: never ran (no phase-1 pass yet this process)";
+            const idleHours = pluginOptions.min_rollout_idle_hours;
+            const eligibilityHint = `eligibility: sessions must be idle ≥ ${idleHours}h and younger than ${pluginOptions.max_rollout_age_days}d ` +
+                `(generate_memories=${pluginOptions.generate_memories}). ` +
+                `For faster local testing, set min_rollout_idle_hours to 1 (clamp floor).`;
+            const processLines = [
+                `phase2_in_flight: ${isPhase2InFlight()}`,
+                `plugin_shutting_down: ${isPluginShuttingDown()}`,
+            ];
+            const diagnostics = getRecentDiagnostics(12);
+            const diagnosticLines = diagnostics.length > 0
+                ? ["recent_events:", ...diagnostics.map((e) => `  ${formatDiagnosticLine(e)}`)]
+                : ["recent_events: none"];
             const out = [
                 `stage1_outputs: ${outputs.length}`,
+                ...stage1Lines,
                 ...phase2Lines,
+                discoveryLine,
+                eligibilityHint,
+                ...processLines,
                 `memory_summary_chars: ${summaryChars}`,
                 `memory_summary_tokens_est: ${summaryTokens} (on disk; injection caps at ~2500)`,
                 `memories_dir_entries: ${listing.length}`,
                 "",
                 ...renderEffectiveConfig(),
                 "",
+                ...diagnosticLines,
+                "",
                 "Files:",
                 listing.length > 0 ? listing.join("\n") : "(empty)",
             ].join("\n");
@@ -217,6 +257,8 @@ export const memory_inspect = tool({
                 output: out,
                 metadata: {
                     stage1_count: outputs.length,
+                    stage1_jobs: stage1Jobs.by_status,
+                    stage1_recent_errors: stage1Jobs.recent_errors,
                     phase2_status: phase2?.status ?? null,
                     phase2_last_error: phase2?.last_error ?? null,
                     phase2_retry_at: phase2?.retry_at ?? null,
@@ -225,11 +267,13 @@ export const memory_inspect = tool({
                     phase2_last_success_finished_at: phase2?.success_finished_at ?? null,
                     // Back-compat aliases used by earlier inspect consumers.
                     phase2_last_finished_at: phase2?.success_finished_at ?? null,
+                    discovery,
                     summary_chars: summaryChars,
                     summary_tokens_est: summaryTokens,
                     files: listing,
                     effective_options: { ...pluginOptions, codex_interop: { ...pluginOptions.codex_interop } },
                     config_warnings: [...getConfigWarnings()],
+                    recent_events: diagnostics,
                 },
             };
         }

package/dist/tools/memory.js

@@ -69,27 +69,25 @@ export const memory_read = tool({
 });
 /** Skip hidden entries and symlinks, mirroring codex local/list.rs + local/search.rs walkers. */
 function visibleEntries(dir) {
-    let names;
+    // Dirent file types (readdir withFileTypes) — codex read_sorted_dir_entries
+    // uses entry.file_type() so listing never follows symlinks.
+    let ents;
     try {
-        names = fs.readdirSync(dir);
+        ents = fs.readdirSync(dir, { withFileTypes: true });
     }
     catch {
         return [];
     }
     const out = [];
-    for (const name of names) {
-        if (name.startsWith("."))
+    for (const ent of ents) {
+        if (ent.name.startsWith("."))
             continue;
-        let st;
-        try {
-            st = fs.lstatSync(path.join(dir, name));
-        }
-        catch {
+        if (ent.isSymbolicLink())
             continue;
-        }
-        if (st.isSymbolicLink())
-            continue;
-        out.push({ name, isDir: st.isDirectory() });
+        if (ent.isDirectory())
+            out.push({ name: ent.name, isDir: true });
+        else if (ent.isFile())
+            out.push({ name: ent.name, isDir: false });
     }
     return out;
 }
@@ -106,7 +104,14 @@ export const memory_list = tool({
             const fullPath = safeResolveMemoryPath(args.path || ".");
             if (!fs.existsSync(fullPath))
                 return { output: `Not found: ${args.path}` };
-            if (!fs.statSync(fullPath).isDirectory())
+            // lstat: do not follow a TOCTOU symlink swap after safeResolve checked.
+            // Symlinked dirs are rejected by design (same as path-guard / codex), not
+            // a regression from the TOCTOU fix — report that explicitly.
+            const st = fs.lstatSync(fullPath);
+            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;

package/opencode.json

@@ -3,7 +3,7 @@
   "agent": {
     "memorize": {
       "mode": "subagent",
-      "prompt": "You are a memory consolidation agent. Read the workspace diff file and update MEMORY.md, memory_summary.md, and skills/ to reflect the latest memories. Keep memory_summary.md under 10000 chars (2500 tokens). Prune stale entries. Do not access the network.",
+      "prompt": "You are a memory consolidation agent. Read the workspace diff file and update MEMORY.md, memory_summary.md, and skills/ under the memory workspace only. Do not read or edit project source files outside that memory root. Keep memory_summary.md under 10000 chars (2500 tokens). Prune stale entries. Do not access the network.",
       "permission": {
         "*": "deny",
         "bash": "deny",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codex-memory",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "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",