@agentmemory/agentmemory 0.9.28 → 0.9.30

package/docker-compose.yml

@@ -8,34 +8,60 @@ services:
   iii-init:
     image: busybox:1.36
     user: "0:0"
+    environment:
+      AGENTMEMORY_DOCKER_UID: "${AGENTMEMORY_DOCKER_UID:-65532}"
+      AGENTMEMORY_DOCKER_GID: "${AGENTMEMORY_DOCKER_GID:-65532}"
+      AGENTMEMORY_DOCKER_SKIP_CHOWN: "${AGENTMEMORY_DOCKER_SKIP_CHOWN:-0}"
     volumes:
-      - iii-data:/data
-    entrypoint: ["sh", "-c", "chown -R 65532:65532 /data && chmod 755 /data"]
+      - "${AGENTMEMORY_DATA_DIR:-iii-data}:/data"
+    entrypoint: ["sh", "-c", "if [ \"$${AGENTMEMORY_DOCKER_SKIP_CHOWN}\" = \"1\" ]; then exit 0; fi; chown -R $${AGENTMEMORY_DOCKER_UID}:$${AGENTMEMORY_DOCKER_GID} /data && chmod 755 /data"]
     restart: "no"
 
   iii-engine:
-    # Pinned to v0.11.2 — the last engine that runs agentmemory's current
-    # worker model cleanly. v0.11.6 introduces a new sandbox-everything-
-    # via-`iii worker add` model that agentmemory hasn't been refactored
-    # for yet; the architectural mismatch surfaces as EPIPE reconnect
-    # loops and empty search after save. Bump only after agentmemory is
-    # refactored to register as a sandboxed worker.
+    # Pinned to the same release as agentmemory's iii-sdk dependency
+    # (package.json). The worker speaks this engine's wire protocol, so
+    # bump the image tag and the SDK together, never one of them alone.
+    # 0.22.x is the last line before 0.23 removes the config.yaml worker
+    # lifecycle; it keeps HTTP routes owned by the reconnecting worker.
     #
     # Override per-shell or via .env file:
-    #   AGENTMEMORY_III_VERSION=0.11.7 docker compose up
-    image: iiidev/iii:${AGENTMEMORY_III_VERSION:-0.11.2}
-    user: "65532:65532"
+    #   AGENTMEMORY_III_VERSION=0.22.1 docker compose up
+    image: iiidev/iii:${AGENTMEMORY_III_VERSION:-0.22.1}
+    user: "${AGENTMEMORY_DOCKER_UID:-65532}:${AGENTMEMORY_DOCKER_GID:-65532}"
     depends_on:
       iii-init:
         condition: service_completed_successfully
+    command: ["--config", "/app/config.yaml", "--no-update-check"]
+    environment:
+      III_TELEMETRY_ENABLED: "${III_TELEMETRY_ENABLED:-false}"
+      III_REST_PORT: "${III_REST_PORT:-3111}"
+      III_STREAM_PORT: "${III_STREAM_PORT:-3112}"
+      III_VIEWER_PORT: "${III_VIEWER_PORT:-3113}"
+      III_ENGINE_PORT: "${III_ENGINE_PORT:-49134}"
+      AGENTMEMORY_REDIS_URL: "${AGENTMEMORY_REDIS_URL:-}"
+      AGENTMEMORY_STATE_SAVE_INTERVAL_MS: "${AGENTMEMORY_STATE_SAVE_INTERVAL_MS:-2000}"
+      MALLOC_ARENA_MAX: "${MALLOC_ARENA_MAX:-2}"
+    ulimits:
+      nofile:
+        soft: 10240
+        hard: 10240
     ports:
-      - "127.0.0.1:49134:49134"
-      - "127.0.0.1:3111:3111"
-      - "127.0.0.1:3112:3112"
-      - "127.0.0.1:9464:9464"
+      - "127.0.0.1:${III_ENGINE_PORT:-49134}:${III_ENGINE_PORT:-49134}"
+      - "127.0.0.1:${III_REST_PORT:-3111}:${III_REST_PORT:-3111}"
+      - "127.0.0.1:${III_STREAM_PORT:-3112}:${III_STREAM_PORT:-3112}"
+      - "127.0.0.1:${AGENTMEMORY_METRICS_PORT:-9464}:9464"
     volumes:
-      - iii-data:/data
+      - "${AGENTMEMORY_DATA_DIR:-iii-data}:/data"
       - ./iii-config.docker.yaml:/app/config.yaml:ro
+      # The engine persists each builtin worker's seeded config block under
+      # config/ next to its config file (/app/config in the image) on first
+      # boot and treats that copy as the source of truth afterwards. Keeping
+      # it on a tmpfs means every container start re-seeds from config.yaml
+      # and the III_* env vars, the same behavior the native CLI path has.
+      - type: tmpfs
+        target: /app/config
+        tmpfs:
+          mode: 01777
     restart: unless-stopped
     logging:
       driver: json-file

package/iii-config.docker.yaml

@@ -1,18 +1,23 @@
 workers:
   - name: iii-http
     config:
-      port: 3111
+      port: ${III_REST_PORT:3111}
       host: 0.0.0.0
       default_timeout: 180000
       cors:
-        allowed_origins: ["http://localhost:3111", "http://localhost:3113", "http://127.0.0.1:3111", "http://127.0.0.1:3113"]
+        allowed_origins: ["http://localhost:${III_REST_PORT:3111}", "http://localhost:${III_VIEWER_PORT:3113}", "http://127.0.0.1:${III_REST_PORT:3111}", "http://127.0.0.1:${III_VIEWER_PORT:3113}"]
         allowed_methods: [GET, POST, PUT, DELETE, OPTIONS]
+  - name: iii-worker-manager
+    config:
+      port: ${III_ENGINE_PORT:49134}
+      host: 0.0.0.0
   - name: iii-state
     config:
       adapter:
         name: kv
         config:
           store_method: file_based
+          save_interval_ms: ${AGENTMEMORY_STATE_SAVE_INTERVAL_MS:2000}
           file_path: /data/state_store.db
   - name: iii-queue
     config:
@@ -28,26 +33,21 @@ workers:
         name: kv
   - name: iii-stream
     config:
-      port: 3112
+      port: ${III_STREAM_PORT:3112}
       host: 0.0.0.0
       adapter:
         name: kv
         config:
           store_method: file_based
+          save_interval_ms: ${AGENTMEMORY_STATE_SAVE_INTERVAL_MS:2000}
           file_path: /data/stream_store
   - name: iii-observability
     config:
       enabled: true
       service_name: agentmemory
       exporter: memory
-      # See iii-config.yaml for the rationale on 0.1 / console-off (#519).
+      # See iii-config.yaml for the rationale on 0.1 / console-off.
       sampling_ratio: 0.1
       metrics_enabled: true
       logs_enabled: true
       logs_console_output: false
-  - name: iii-exec
-    config:
-      watch:
-        - src/**/*.ts
-      exec:
-        - node dist/index.mjs

package/iii-config.yaml

@@ -13,6 +13,7 @@ workers:
         name: kv
         config:
           store_method: file_based
+          save_interval_ms: 2000
           file_path: ./data/state_store.db
   - name: iii-queue
     config:
@@ -34,6 +35,7 @@ workers:
         name: kv
         config:
           store_method: file_based
+          save_interval_ms: 2000
           file_path: ./data/stream_store
   - name: iii-observability
     config:
@@ -45,7 +47,7 @@ workers:
       # subscriber lagged" WARN, and that WARN re-enters the same
       # stream the subscriber is failing to drain — a positive
       # feedback loop that wrote 137 GB to daemon.log.new on one user
-      # in a few days (#519).
+      # in a few days.
       sampling_ratio: 0.1
       metrics_enabled: true
       logs_enabled: true

package/integrations/pi/README.md

@@ -0,0 +1,77 @@
+<p align="center">
+  <img src="../../assets/banner.png" alt="agentmemory" width="640" />
+</p>
+
+<h1 align="center">
+  &nbsp;agentmemory for pi
+</h1>
+
+<p align="center">
+  <strong>Your pi sessions remember everything. No more re-explaining.</strong><br/>
+  <sub>Persistent cross-session memory via <a href="https://github.com/rohitg00/agentmemory">agentmemory</a> — shared with Claude Code, Codex CLI, Gemini CLI, Hermes, OpenClaw, and more.</sub>
+</p>
+
+---
+
+## Quick setup
+
+Start the agentmemory server in a separate terminal:
+
+```bash
+npx @agentmemory/agentmemory
+```
+
+Copy this folder into pi's global extensions directory:
+
+```bash
+mkdir -p ~/.pi/agent/extensions/agentmemory
+cp integrations/pi/index.ts ~/.pi/agent/extensions/agentmemory/index.ts
+```
+
+Then enable it in `~/.pi/agent/settings.json` if you prefer explicit loading:
+
+```json
+{
+  "extensions": ["~/.pi/agent/extensions/agentmemory"]
+}
+```
+
+If you place it under `~/.pi/agent/extensions/agentmemory/`, pi will also auto-discover it and `/reload` can hot-reload it.
+
+## What it adds
+
+- `memory_health` — confirm the shared memory server is reachable
+- `memory_search` — search prior decisions, bugs, workflows, and preferences
+- `memory_save` — write durable facts back to long-term memory
+- `/agentmemory-status` — check health from inside pi
+- `before_agent_start` recall — injects relevant memories into the prompt
+- `agent_end` capture — saves completed conversation turns back to agentmemory
+
+## Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `AGENTMEMORY_URL` | `http://localhost:3111` | agentmemory server URL |
+| `AGENTMEMORY_SECRET` | (none) | Bearer token for protected instances |
+| `AGENTMEMORY_REQUIRE_HTTPS` | (off) | When set to `1`, refuse to send a bearer token over plaintext HTTP to a non-loopback host. Sends the token only when `AGENTMEMORY_URL` is `https://...` or points at `localhost`/`127.0.0.1`/`::1`. With this off, the plugin warns once but still sends. |
+
+## Smoke test
+
+Run pi and ask it to use the `memory_health` tool, or call the command directly:
+
+```text
+/agentmemory-status
+```
+
+You should see `agentmemory healthy` and a footer status like `🧠 agentmemory`.
+
+## Notes
+
+- This extension uses pi's extension API, not MCP, so it can hook directly into the agent lifecycle.
+- One local agentmemory server can be shared across pi, pi2, Hermes, OpenClaw, Claude Code, Codex CLI, and Gemini CLI.
+
+## See also
+
+- [agentmemory main README](../../README.md)
+- [Hermes integration](../hermes/README.md)
+- [OpenClaw integration](../openclaw/README.md)

package/integrations/pi/index.ts

@@ -0,0 +1,402 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import path from "node:path";
+import crypto from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { createPlaintextBearerAuthGuard, resolveSecret } from "./security.js";
+
+type TextBlock = { type?: string; text?: string };
+type AssistantMessage = { role?: string; content?: unknown };
+type SmartSearchResult = {
+  title?: string;
+  narrative?: string;
+  type?: string;
+  combinedScore?: number;
+  score?: number;
+  observation?: {
+    title?: string;
+    narrative?: string;
+    type?: string;
+  };
+};
+
+type HealthResponse = {
+  status?: string;
+  service?: string;
+  version?: string;
+  health?: {
+    status?: string;
+    notes?: string[];
+  };
+};
+
+const DEFAULT_URL = process.env.AGENTMEMORY_URL || "http://localhost:3111";
+const guardPlaintextBearerAuth = createPlaintextBearerAuthGuard();
+const TOOL_GUIDANCE = [
+  "agentmemory is available for cross-session memory.",
+  "Use memory_search to recall prior decisions, preferences, bugs, and workflows.",
+  "Use memory_save when you discover durable facts worth remembering beyond this session.",
+].join(" ");
+
+function normalizeBaseUrl(url: string): string {
+  return url.replace(/\/+$/, "");
+}
+
+function getText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .flatMap((part) => {
+      if (!part || typeof part !== "object") return [] as string[];
+      const block = part as TextBlock;
+      if (block.type === "text" && typeof block.text === "string") return [block.text];
+      return [] as string[];
+    })
+    .join("\n")
+    .trim();
+}
+
+function getLastAssistantText(messages: unknown[]): string {
+  for (const msg of [...messages].reverse()) {
+    if (!msg || typeof msg !== "object") continue;
+    const assistant = msg as AssistantMessage;
+    if (assistant.role !== "assistant") continue;
+    const text = getText(assistant.content);
+    if (text) return text;
+  }
+  return "";
+}
+
+function formatSearchResults(results: SmartSearchResult[]): string {
+  if (!results.length) return "No relevant memories found.";
+  return results
+    .slice(0, 5)
+    .map((result, index) => {
+      const obs = result.observation ?? result;
+      const title = obs.title?.trim() || `Memory ${index + 1}`;
+      const narrative = obs.narrative?.trim() || "";
+      const type = obs.type?.trim() || "memory";
+      const score = result.combinedScore ?? result.score;
+      const scoreText = typeof score === "number" ? ` [score=${score.toFixed(3)}]` : "";
+      return `- ${title} (${type})${scoreText}${narrative ? `: ${narrative}` : ""}`;
+    })
+    .join("\n");
+}
+
+async function callAgentMemory<T>(
+  pathname: string,
+  options?: {
+    method?: "GET" | "POST";
+    body?: unknown;
+    baseUrl?: string;
+    timeoutMs?: number;
+  },
+): Promise<T | null> {
+  const baseUrl = normalizeBaseUrl(options?.baseUrl || process.env.AGENTMEMORY_URL || DEFAULT_URL);
+  const method = options?.method || "POST";
+  const url = `${baseUrl}/agentmemory/${pathname.replace(/^\/+/, "")}`;
+  const headers: Record<string, string> = {};
+  const secret = resolveSecret(baseUrl, process.env.AGENTMEMORY_SECRET);
+  guardPlaintextBearerAuth(baseUrl, secret);
+  if (options?.body !== undefined) headers["Content-Type"] = "application/json";
+  if (secret) headers.Authorization = `Bearer ${secret}`;
+
+  try {
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+      signal: options?.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : undefined,
+    });
+    if (!response.ok) return null;
+    return (await response.json()) as T;
+  } catch {
+    return null;
+  }
+}
+
+export default function agentmemoryExtension(pi: ExtensionAPI) {
+  if (process.env.AGENTMEMORY_REQUIRE_HTTPS === "1") {
+    guardPlaintextBearerAuth(
+      normalizeBaseUrl(process.env.AGENTMEMORY_URL || DEFAULT_URL),
+      process.env.AGENTMEMORY_SECRET,
+    );
+  }
+  let sessionId = `ephemeral-${crypto.randomUUID().slice(0, 8)}`;
+  // Canonical project scope, matching the hooks' resolveProject order (env
+  // override, git toplevel basename, cwd basename) so Pi sessions share a
+  // project bucket with every other agent instead of scoping on a raw path.
+  const projectCache = new Map<string, string>();
+  function resolveProjectName(dir: string): string {
+    const explicit = process.env["AGENTMEMORY_PROJECT_NAME"]?.trim();
+    if (explicit) return explicit;
+    const cached = projectCache.get(dir);
+    if (cached) return cached;
+    let name = path.basename(dir) || dir;
+    try {
+      const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8",
+      }).trim();
+      if (top) name = path.basename(top);
+    } catch {
+      // not a git repo
+    }
+    projectCache.set(dir, name);
+    return name;
+  }
+  let currentCwd = process.cwd();
+  let currentProject = resolveProjectName(currentCwd);
+  let lastPrompt = "";
+  let lastHealthOk = false;
+
+  const toolObserveEnabled = process.env.AGENTMEMORY_TOOL_OBSERVE !== "0";
+
+  // Skips the round-trip when an auto-retry re-submits an identical prompt.
+  const DEDUP_WINDOW_MS = 5 * 60 * 1000;
+  const recentHashes = new Map<string, number>();
+  function isDuplicate(data: string): boolean {
+    const hash = crypto.createHash("sha256").update(data).digest("hex");
+    const now = Date.now();
+    const prev = recentHashes.get(hash);
+    if (prev !== undefined && now - prev < DEDUP_WINDOW_MS) return true;
+    if (recentHashes.size > 500) {
+      for (const [key, ts] of recentHashes) {
+        if (now - ts >= DEDUP_WINDOW_MS) recentHashes.delete(key);
+      }
+    }
+    recentHashes.set(hash, now);
+    return false;
+  }
+
+  async function getHealth() {
+    return await callAgentMemory<HealthResponse>("health", { method: "GET" });
+  }
+
+  async function refreshStatus(ctx: { ui: { setStatus: (key: string, text: string) => void } }) {
+    // Bind before the await: ctx goes stale if the session is replaced.
+    let setStatus: (key: string, text: string) => void;
+    try {
+      const ui = ctx.ui;
+      setStatus = ui.setStatus.bind(ui);
+    } catch {
+      return;
+    }
+    const health = await getHealth();
+    lastHealthOk =
+      !!health &&
+      (health.status === "ok" ||
+        health.status === "healthy" ||
+        health.health?.status === "healthy");
+    try {
+      setStatus("agentmemory", lastHealthOk ? "🧠 agentmemory" : "🧠 agentmemory off");
+    } catch {
+      // status is best-effort
+    }
+  }
+
+  pi.registerCommand("agentmemory-status", {
+    description: "Check local agentmemory server health",
+    handler: async (_args, ctx) => {
+      const health = await getHealth();
+      if (!health) {
+        ctx.ui.notify("agentmemory is unreachable at http://localhost:3111", "warning");
+        return;
+      }
+      ctx.ui.notify(
+        `agentmemory ${health.status || health.health?.status || "unknown"}${health.version ? ` v${health.version}` : ""}`,
+        "info",
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "memory_health",
+    label: "Memory Health",
+    description: "Check whether the local agentmemory server is reachable and healthy",
+    parameters: Type.Object({}),
+    async execute() {
+      const health = await getHealth();
+      if (!health) {
+        return {
+          content: [{ type: "text", text: "agentmemory is unreachable at http://localhost:3111" }],
+          details: { ok: false },
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `agentmemory status: ${health.status || health.health?.status || "unknown"}${health.version ? ` (v${health.version})` : ""}`,
+          },
+        ],
+        details: health,
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "memory_search",
+    label: "Memory Search",
+    description: "Search agentmemory for cross-session project memory, prior decisions, bugs, and user preferences",
+    parameters: Type.Object({
+      query: Type.String({ description: "What to search for in memory" }),
+      limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 10, default: 5, description: "Maximum results" })),
+    }),
+    async execute(_toolCallId, params) {
+      const result = await callAgentMemory<{ results?: SmartSearchResult[] }>("smart-search", {
+        body: { query: params.query, limit: params.limit ?? 5, project: currentProject },
+      });
+      const results = result?.results || [];
+      return {
+        content: [{ type: "text", text: formatSearchResults(results) }],
+        details: { query: params.query, results },
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "memory_save",
+    label: "Memory Save",
+    description: "Save a durable fact, convention, workflow, preference, or bug fix into agentmemory",
+    parameters: Type.Object({
+      content: Type.String({ description: "What should be remembered" }),
+      type: Type.Optional(
+        Type.String({
+          description: "Memory type",
+          default: "fact",
+        }),
+      ),
+    }),
+    async execute(_toolCallId, params) {
+      const result = await callAgentMemory<Record<string, unknown>>("remember", {
+        body: { content: params.content, type: params.type || "fact", project: currentProject },
+      });
+      if (!result) {
+        return {
+          content: [{ type: "text", text: "Failed to save memory to agentmemory." }],
+          details: { ok: false },
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Saved memory (${params.type || "fact"}): ${params.content}` }],
+        details: result,
+      };
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    sessionId = sessionFile ? path.basename(sessionFile).replace(/\.[^.]+$/, "") : `ephemeral-${crypto.randomUUID().slice(0, 8)}`;
+    currentCwd = process.cwd();
+    currentProject = resolveProjectName(currentCwd);
+    await refreshStatus(ctx);
+    // After refreshStatus: that is where lastHealthOk is first populated.
+    if (lastHealthOk) {
+      await callAgentMemory("session/start", {
+        body: { sessionId, project: currentProject, cwd: currentCwd },
+      });
+    }
+  });
+
+  pi.on("before_agent_start", async (event, ctx) => {
+    currentCwd = event.systemPromptOptions.cwd || process.cwd();
+    currentProject = resolveProjectName(currentCwd);
+    lastPrompt = event.prompt?.trim() || "";
+    if (!lastPrompt) return;
+
+    if (lastHealthOk && !isDuplicate(`prompt_submit:${sessionId}:${lastPrompt}`)) {
+      void callAgentMemory("observe", {
+        body: {
+          hookType: "prompt_submit",
+          sessionId,
+          project: currentProject,
+          cwd: currentCwd,
+          timestamp: new Date().toISOString(),
+          data: { prompt: lastPrompt },
+        },
+      });
+    }
+
+    const result = await callAgentMemory<{ results?: SmartSearchResult[] }>("smart-search", {
+      body: { query: lastPrompt, limit: 5, project: currentProject },
+    });
+    const results = result?.results || [];
+    const recallBlock = results.length
+      ? [
+          "Relevant long-term memory from agentmemory:",
+          formatSearchResults(results),
+        ].join("\n")
+      : "";
+
+    await refreshStatus(ctx);
+    return {
+      systemPrompt: [event.systemPrompt, TOOL_GUIDANCE, recallBlock].filter(Boolean).join("\n\n"),
+    };
+  });
+
+  pi.on("tool_result", (event) => {
+    if (!toolObserveEnabled || !lastHealthOk || !sessionId) return;
+    const toolName = event.toolName;
+    if (!toolName) return;
+    let input = "";
+    try {
+      input = typeof event.input === "string" ? event.input : JSON.stringify(event.input ?? {});
+    } catch {
+      // non-serializable
+    }
+    let output = "";
+    try {
+      output = typeof event.content === "string" ? event.content : JSON.stringify(event.content ?? "");
+    } catch {
+      // non-serializable
+    }
+    void callAgentMemory("observe", {
+      body: {
+        hookType: "post_tool_use",
+        sessionId,
+        project: currentProject,
+        cwd: currentCwd,
+        timestamp: new Date().toISOString(),
+        data: {
+          tool_name: toolName,
+          tool_input: input.slice(0, 8000),
+          tool_output: output.slice(0, 8000),
+          ...(event.isError ? { tool_error: true } : {}),
+        },
+      },
+    });
+  });
+
+  pi.on("agent_end", async (event) => {
+    if (!lastHealthOk || !lastPrompt) return;
+    const assistantText = getLastAssistantText(event.messages as unknown[]);
+    if (!assistantText) return;
+    void callAgentMemory("observe", {
+      body: {
+        hookType: "post_tool_use",
+        sessionId,
+        project: currentProject,
+        cwd: currentCwd,
+        timestamp: new Date().toISOString(),
+        data: {
+          tool_name: "conversation",
+          tool_input: lastPrompt.slice(0, 8000),
+          tool_output: assistantText.slice(0, 8000),
+        },
+      },
+    });
+  });
+
+  pi.on("session_shutdown", async (event) => {
+    // /new, /resume, /fork and reloads fire this too; only quit ends the session.
+    if (event.reason !== "quit") return;
+    if (!lastHealthOk || !sessionId) return;
+    await callAgentMemory("session/end", {
+      body: { sessionId },
+      timeoutMs: 5_000,
+    });
+    void callAgentMemory("consolidate", { body: {} });
+  });
+}

package/integrations/pi/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "agentmemory-pi-extension",
+  "version": "0.1.0",
+  "private": true,
+  "description": "agentmemory extension for the pi coding agent: memory recall on agent start, capture on agent end, memory_search / memory_save / memory_health tools, /agentmemory-status command",
+  "type": "module",
+  "license": "Apache-2.0",
+  "keywords": [
+    "pi-package",
+    "agentmemory",
+    "memory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rohitg00/agentmemory.git",
+    "directory": "integrations/pi"
+  },
+  "files": [
+    "index.ts",
+    "security.ts",
+    "README.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  }
+}