opencode-codex-memory 0.6.0 → 0.6.2

package/dist/tools/control.js

@@ -13,6 +13,7 @@ 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";
+import { activeProviderCapacityBackoffs } from "../src/ratelimit.js";
 function isSymlinkedRoot() {
     try {
         assertMemoryRootSafe();
@@ -200,7 +201,8 @@ function fmtWatermarkMs(ms) {
 }
 export const memory_inspect = tool({
     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), " +
+        "breakdown, failure classes (backoff / provider_capacity / other_exhausted), 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 " +
@@ -244,9 +246,20 @@ export const memory_inspect = tool({
             const stage1StatusParts = Object.entries(stage1Jobs.by_status)
                 .sort(([a], [b]) => a.localeCompare(b))
                 .map(([s, c]) => `${s}=${c}`);
+            const fc = stage1Jobs.by_failure_class;
+            const failureParts = [
+                fc.backoff > 0 ? `backoff=${fc.backoff}` : "",
+                fc.provider_capacity > 0 ? `provider_capacity=${fc.provider_capacity}` : "",
+                fc.other_exhausted > 0 ? `other_exhausted=${fc.other_exhausted}` : "",
+            ].filter(Boolean);
             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)}` : ""}`),
+                `stage1_failures: ${failureParts.length > 0 ? failureParts.join(" ") : "none"}`,
+                ...stage1Jobs.recent_errors.map((e) => {
+                    const klass = e.failure_class ? `, ${e.failure_class}` : "";
+                    const retry = e.retry_at ? ` retry_at=${fmtUnixSec(e.retry_at)}` : "";
+                    return `  stage1_error ${e.session_id} (${e.status}${klass}): ${e.last_error.slice(0, 200)}${retry}`;
+                }),
             ];
             const discovery = getDiscoveryStatus();
             const discoveryLine = discovery
@@ -260,6 +273,10 @@ export const memory_inspect = tool({
                 `phase2_in_flight: ${isPhase2InFlight()}`,
                 `plugin_shutting_down: ${isPluginShuttingDown()}`,
             ];
+            const capacityBackoffs = activeProviderCapacityBackoffs();
+            const capacityLines = capacityBackoffs.length > 0
+                ? capacityBackoffs.map((b) => `provider_capacity_backoff ${b.scope}: retry_at=${fmtUnixSec(b.retry_at)}`)
+                : ["provider_capacity_backoff: none"];
             const diagnostics = getRecentDiagnostics(12);
             const diagnosticLines = diagnostics.length > 0
                 ? ["recent_events:", ...diagnostics.map((e) => `  ${formatDiagnosticLine(e)}`)]
@@ -271,6 +288,7 @@ export const memory_inspect = tool({
                 discoveryLine,
                 eligibilityHint,
                 ...processLines,
+                ...capacityLines,
                 `memory_summary_chars: ${summaryChars}`,
                 `memory_summary_tokens_est: ${summaryTokens} (on disk; injection caps at ~2500)`,
                 `memories_dir_entries: ${listing.length}`,
@@ -289,6 +307,7 @@ export const memory_inspect = tool({
                 metadata: {
                     stage1_count: outputs.length,
                     stage1_jobs: stage1Jobs.by_status,
+                    stage1_failures: stage1Jobs.by_failure_class,
                     stage1_recent_errors: stage1Jobs.recent_errors,
                     phase2_status: phase2?.status ?? null,
                     phase2_last_error: phase2?.last_error ?? null,
@@ -296,6 +315,7 @@ export const memory_inspect = tool({
                     phase2_last_attempt_finished_at: phase2?.finished_at ?? null,
                     phase2_last_success_watermark: phase2?.last_success_watermark ?? null,
                     phase2_last_success_finished_at: phase2?.success_finished_at ?? null,
+                    provider_capacity_backoffs: capacityBackoffs,
                     // Back-compat aliases used by earlier inspect consumers.
                     phase2_last_finished_at: phase2?.success_finished_at ?? null,
                     discovery,

package/dist/tools/memory.js

@@ -20,7 +20,9 @@ export const memory_read = tool({
             }
             const stat = fs.lstatSync(fullPath);
             if (stat.isDirectory()) {
-                const entries = fs.readdirSync(fullPath);
+                const entries = visibleEntries(fullPath)
+                    .sort((a, b) => comparePathNames(a.name, b.name))
+                    .map((e) => e.name);
                 return {
                     output: `Directory ${args.path}/\n` + entries.map((e) => `- ${e}`).join("\n") + "\n(use memory_list for sorted, typed listings)",
                     metadata: { kind: "directory", entries },
@@ -194,7 +196,7 @@ function parseDateArg(value, endOfDay) {
 function collectSearchFiles(start, prefix) {
     const files = [];
     const walk = (dir, rel) => {
-        const entries = visibleEntries(dir).sort((a, b) => a.name.localeCompare(b.name));
+        const entries = visibleEntries(dir).sort((a, b) => comparePathNames(a.name, b.name));
         for (const { name, isDir } of entries) {
             const abs = path.join(dir, name);
             const relPath = rel ? `${rel}/${name}` : name;
@@ -366,7 +368,21 @@ export const memory_search = tool({
             }
             const rangeLabel = timeFiltered ? ` in ${args.since ?? "..."}..${args.until ?? "..."}` : "";
             if (queries.length === 0) {
-                const listing = files.slice(0, args.max_results).map((f) => {
+                let startIndex = 0;
+                if (args.cursor !== undefined) {
+                    startIndex = Number.parseInt(args.cursor, 10);
+                    if (!Number.isInteger(startIndex) || startIndex < 0 || String(startIndex) !== args.cursor.trim()) {
+                        return { output: `memory_search error: invalid cursor "${args.cursor}" (must be a non-negative integer).` };
+                    }
+                    if (startIndex > files.length) {
+                        return { output: `memory_search error: cursor ${startIndex} exceeds result count ${files.length}.` };
+                    }
+                }
+                const endIndex = Math.min(startIndex + (args.max_results ?? SEARCH_MAX_RESULTS), files.length);
+                const page = files.slice(startIndex, endIndex);
+                const nextCursor = endIndex < files.length ? String(endIndex) : null;
+                const truncated = nextCursor !== null;
+                const listing = page.map((f) => {
                     let content = "";
                     try {
                         content = readRegularFileNoFollow(f.abs).content.toString("utf8");
@@ -375,11 +391,25 @@ export const memory_search = tool({
                     }
                     return `${new Date(f.ts).toISOString()} ${f.rel} — ${firstContentLine(content)}`;
                 });
-                if (listing.length === 0)
+                if (files.length === 0)
                     return { output: `No time-anchored memory files${rangeLabel}.` };
+                if (listing.length === 0) {
+                    return {
+                        output: `No memory files at cursor ${startIndex}${rangeLabel}.`,
+                        metadata: { count: 0, next_cursor: nextCursor, truncated, since: args.since, until: args.until },
+                    };
+                }
                 return {
-                    output: `${listing.length} memory file(s)${rangeLabel}:\n${listing.join("\n")}`,
-                    metadata: { count: listing.length, since: args.since, until: args.until },
+                    output: `${listing.length} of ${files.length} memory file(s)${rangeLabel}` +
+                        `${truncated ? ` (more available; pass cursor=${nextCursor})` : ""}:\n` +
+                        listing.join("\n"),
+                    metadata: {
+                        count: listing.length,
+                        next_cursor: nextCursor,
+                        truncated,
+                        since: args.since,
+                        until: args.until,
+                    },
                 };
             }
             const caseSensitive = args.case_sensitive ?? true;
@@ -402,7 +432,7 @@ export const memory_search = tool({
                     continue; // binary, like codex's InvalidData skip
                 searchFileContent(f, content.split(/\r?\n/), queries, preparedQueries, mode, args.line_count ?? 1, args.context_lines ?? 0, caseSensitive, normalized, all);
             }
-            all.sort((a, b) => a.path.localeCompare(b.path) || a.match_line_number - b.match_line_number);
+            all.sort((a, b) => comparePathNames(a.path, b.path) || a.match_line_number - b.match_line_number);
             let startIndex = 0;
             if (args.cursor !== undefined) {
                 startIndex = Number.parseInt(args.cursor, 10);

package/package.json

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