@isparling/engram-omp 0.1.0

package/LICENSE

@@ -0,0 +1,187 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!) The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.

package/README.md

@@ -0,0 +1,21 @@
+# @isparling/engram-omp
+
+Oh My Pi extension for Engram knowledge capture. It translates Oh My Pi
+lifecycle events into calls to the independently installed `engram` CLI; it
+contains no pack implementation or private knowledge.
+
+```sh
+npm install @isparling/engram-omp @isparling/engram-harness @isparling/engram-cli
+```
+
+```ts
+import engramExtension from "@isparling/engram-omp";
+```
+
+The independently installed `@isparling/engram-cli` is required for normal
+knowledge capture: the extension shells out to it for both turn-end
+extraction and the `engram_capture` tool, and does not perform any
+transaction work itself.
+
+- [INSTALL.md](https://github.com/isparling/engram/blob/main/harness/omp/INSTALL.md) — installing and configuring the extension.
+- [SPEC.md](https://github.com/isparling/engram/blob/main/harness/omp/SPEC.md) — extension behavior and scope.

package/omp-extension.ts

@@ -0,0 +1,409 @@
+/**
+ * Oh My Pi extension for engram knowledge capture.
+ *
+ * Hooks into the agent lifecycle to extract structured knowledge candidates
+ * from settled turns, and registers a voluntary `engram_capture` tool for
+ * mid-turn capture.
+ *
+ * ## Installation
+ *
+ * Install `@isparling/engram-omp` and point Oh My Pi at it via `--extension`
+ * or settings:
+ *
+ *   extensions:
+ *     - @isparling/engram-omp
+ *
+ * ## Configuration
+ *
+ * Environment variables read at session start:
+ *
+ *   ENGRAM_BINDING_REGISTRY  (required)  path to the engram binding registry
+ *   ENGRAM_CLI              (optional)  path to engram CLI binary (default: "engram")
+ *
+ * ## Design
+ *
+ * Two capture paths, both converging on the engram transaction pipeline:
+ *
+ *   Hook (agent_end):  receives raw turn transcript → builds TurnContext →
+ *                      pipes to `engram capture-from-turn` → pack's
+ *                      extractCandidates() → LLM extraction → submit
+ *   Tool (engram_capture): agent provides structured kind/statement/topics →
+ *                         builds KnowledgeEnvelopeInput → writes to temp
+ *                         file → calls `engram knowledge submit` → direct
+ *                         submission, no extraction
+ *
+ * The extension is deliberately thin: it normalizes Oh My Pi events and
+ * shells out to the engram CLI for all pack operations. This avoids
+ * import-resolution issues between Oh My Pi's extension runtime and
+ * engram's separate module layout.
+ *
+ * @module
+ */
+
+import { chmod, mkdtemp, open, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { HostSessionProvenance, TurnContext, TurnToolCall } from "@isparling/engram-harness/knowledge-types";
+
+// ---------------------------------------------------------------------------
+// ExtensionAPI types — mirrors the real omp type from
+// @oh-my-pi/pi-coding-agent/src/extensibility/extensions/types.ts
+// ---------------------------------------------------------------------------
+
+export interface ExtensionAPI {
+  on(event: "agent_end", handler: (event: AgentEndEvent, ctx: ExtensionContext) => void | Promise<void>): void;
+  registerTool(tool: ToolDefinition): void;
+  logger: { info: (message: string) => void; warn: (message: string) => void };
+}
+
+export interface AgentEndEvent {
+  type: "agent_end";
+  messages: unknown[];
+  willContinue?: boolean;
+  sessionId?: string;
+  turnIndex?: number;
+  timestamp?: string;
+}
+
+export interface ExtensionContext {
+  sessionId: string;
+  cwd: string;
+}
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: unknown;
+  handler: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+}
+
+// ---------------------------------------------------------------------------
+// CLI format helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Normalize a candidate envelope to CLI IO format.
+ *
+ * The CLI's `validateKnowledgeEnvelope` expects `submitted_at` (snake_case,
+ * YYYY-MM-DD) and rejects `submittedAt` (camelCase) as an unknown field.
+ * This helper strips the camelCase variant, sets the snake_case variant,
+ * and returns a plain Record suitable for JSON.stringify.
+ */
+function toCliCandidate(input: object): Record<string, unknown> {
+  const raw = input as Record<string, unknown>;
+  const rawDate = raw.submittedAt ?? raw.submitted_at;
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(raw)) {
+    if (key !== "submittedAt") out[key] = raw[key];
+  }
+  out.submitted_at = rawDate !== undefined
+    ? String(rawDate).slice(0, 10)
+    : new Date().toISOString().slice(0, 10);
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Extension factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the engram CLI binary to shell out to.
+ *
+ * Priority: an explicit ENGRAM_CLI, then the sibling @isparling/engram-cli
+ * package when it is installed alongside @isparling/engram-omp, then the
+ * `engram` command on PATH.
+ */
+function resolveCliPath(): string {
+  const explicit = process.env.ENGRAM_CLI;
+  if (explicit !== undefined && explicit.length > 0) return explicit;
+  try {
+    return fileURLToPath(import.meta.resolve("@isparling/engram-cli/bin/engram"));
+  } catch {
+    return "engram";
+  }
+}
+
+export default async function engramExtension(api: ExtensionAPI): Promise<void> {
+  const cliPath = resolveCliPath();
+  const registryPath = process.env.ENGRAM_BINDING_REGISTRY;
+
+  if (registryPath === undefined || registryPath.length === 0) {
+    api.logger.warn("[engram] ENGRAM_BINDING_REGISTRY not set — knowledge capture disabled");
+    return;
+  }
+
+  const bindingRegistryPath = registryPath;
+
+
+  // Session identifier — captured from the first agent_end event's ctx.
+  // Before that, CLI calls will use "pending" which won't resolve a space;
+  // the first agent_end event resolves it.
+  let hostSessionId: string | undefined;
+
+  /** Build env for CLI calls, including the session id resolveActiveSpace requires. */
+  function cliEnv(): Record<string, string> {
+    return {
+      ...(process.env as Record<string, string>),
+      ENGRAM_BINDING_REGISTRY: bindingRegistryPath,
+      ENGRAM_HOST_SESSION_ID: hostSessionId ?? "pending",
+    };
+  }
+
+  // Cached extraction pack id — resolved lazily once a real session id is known.
+  let extractionPackId = "work-pack";
+  let extractionPackVersion = "0.1.0";
+  let extractionSpaceId = "current";
+  let resolvedPackId = false;
+
+  /** Resolve the extraction pack from the active space. Called once on first agent_end. */
+  async function resolveExtractionPack(): Promise<void> {
+    if (hostSessionId === undefined || resolvedPackId) return;
+    try {
+      const proc = Bun.spawn([cliPath, "space", "status"], {
+        stdout: "pipe",
+        stderr: "pipe",
+        env: cliEnv(),
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) return;
+      const stdout = await new Response(proc.stdout).text();
+      const status = JSON.parse(stdout) as Record<string, unknown>;
+      const activeSpaces = status.active_spaces as Record<string, Record<string, unknown>> | undefined;
+      if (activeSpaces === undefined) return;
+      const space = activeSpaces[hostSessionId];
+      if (space === undefined) return;
+      extractionSpaceId = String(space.space_id ?? "current");
+      const packs = space.packs as Array<Record<string, unknown>> | undefined;
+      if (packs === undefined) return;
+      const extractPack = packs.find((p) => p.extract === true);
+      if (extractPack === undefined) return;
+      extractionPackId = String(extractPack.id);
+      extractionPackVersion = String(extractPack.version);
+      resolvedPackId = true;
+    } catch {
+      // Keep defaults
+    }
+  }
+
+
+  // -----------------------------------------------------------------------
+  // Structural capture: agent_end hook
+  // -----------------------------------------------------------------------
+  api.on("agent_end", async (event: AgentEndEvent, ctx: ExtensionContext) => {
+    // Capture the real session id from the first event; resolves the
+    // extraction pack lazily now that we can query the right space.
+    hostSessionId = ctx.sessionId;
+    await resolveExtractionPack();
+
+    // Guard: skip auto-retry/continuation settles
+    if (event.willContinue === true) return;
+    if (!Array.isArray(event.messages) || event.messages.length === 0) return;
+
+    const turn = buildTurnContext(event);
+    if (turn === undefined) return;
+
+
+    // CLI fallback path
+    try {
+      const proc = Bun.spawn([cliPath, "capture-from-turn"], {
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        env: cliEnv(),
+      });
+      await proc.stdin.write(JSON.stringify(turn) + "\n");
+      await proc.stdin.end();
+
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        api.logger.warn(`[engram] capture-from-turn failed (exit ${exitCode}): ${(stdout || stderr).slice(0, 500)}`);
+      }
+    } catch (err) {
+      api.logger.warn(`[engram] failed to invoke engram CLI: ${err}`);
+    }
+  });
+
+  // -----------------------------------------------------------------------
+  // Status tool: report loaded pack and mode
+  // -----------------------------------------------------------------------
+  api.registerTool({
+    name: "engram_status",
+    description: "Report the binding-selected pack identity and CLI mode.",
+    parameters: { type: "object", properties: {} },
+    handler: async () => ({
+      pack_id: resolvedPackId ? extractionPackId : null,
+      pack_version: resolvedPackId ? extractionPackVersion : null,
+      mode: "cli",
+    }),
+  });
+
+  // -----------------------------------------------------------------------
+  // Voluntary capture: engram_capture tool
+  // -----------------------------------------------------------------------
+  api.registerTool({
+    name: "engram_capture",
+    description: `Submit a structured knowledge observation from the current session.
+Use this to record decisions, outcomes, risks, or notable events mid-turn
+rather than waiting for end-of-turn extraction. Bypasses the pack's
+extraction pipeline — the agent provides the classification directly.
+
+Parameters:
+- kind: one of "evidence", "claim", "interpretation", "decision", "recommendation"
+- statement: free-form description of the observation
+- scope_topics: array of topic tags (e.g. ["work:decision", "work:architecture"])
+- subjects: array of subject identifiers (optional)`,
+    parameters: {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: ["evidence", "claim", "interpretation", "decision", "recommendation"] },
+        statement: { type: "string", minLength: 1 },
+        scope_topics: { type: "array", items: { type: "string" }, default: [] },
+        subjects: { type: "array", items: { type: "string" }, default: [] },
+      },
+      required: ["kind", "statement"],
+    },
+    handler: async (params: Record<string, unknown>) => {
+      const id = `capture-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const envelope = {
+        id,
+        kind: String(params.kind ?? "claim"),
+        status: "candidate" as const,
+        disposition: "new" as const,
+        scope: {
+          space: extractionSpaceId,
+          subjects: Array.isArray(params.subjects) ? params.subjects.map(String) : [],
+          topics: Array.isArray(params.scope_topics) ? params.scope_topics.map(String) : [],
+          contexts: [] as string[],
+          dimensions: {} as Record<string, string[]>,
+        },
+        pack: { id: extractionPackId, version: extractionPackVersion },
+        sources: [{ type: "engram-capture-tool" as const, ref: `session:${registryPath}` }],
+        session: { id: hostSessionId ?? "pending", host: "omp" as const },
+        submittedAt: new Date().toISOString(),
+        details: {} as Record<string, unknown>,
+        statement: String(params.statement ?? ""),
+      };
+
+
+      const cliCandidate = toCliCandidate(envelope);
+      let candidateDir: string | undefined;
+      try {
+        candidateDir = await mkdtemp(join(tmpdir(), "engram-candidate-"));
+        await chmod(candidateDir, 0o700);
+        const tmpFile = join(candidateDir, "candidate.json");
+        const file = await open(tmpFile, "wx", 0o600);
+        try {
+          await file.writeFile(JSON.stringify(cliCandidate), "utf8");
+        } finally {
+          await file.close();
+        }
+        const proc = Bun.spawn([cliPath, "knowledge", "submit", "--candidate", tmpFile], {
+          stdout: "pipe",
+          stderr: "pipe",
+          env: cliEnv(),
+        });
+        const exitCode = await proc.exited;
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        if (exitCode === 0) return { status: "submitted", detail: stdout, id };
+        return { status: "error", detail: (stdout || stderr).slice(0, 1000), id };
+      } catch (error) {
+        return { status: "error", detail: String(error).slice(0, 1000), id };
+      } finally {
+        if (candidateDir !== undefined) await rm(candidateDir, { recursive: true, force: true });
+      }
+    },
+  });
+}
+
+// ---------------------------------------------------------------------------
+// TurnContext builder
+// ---------------------------------------------------------------------------
+
+function buildTurnContext(event: AgentEndEvent): TurnContext | undefined {
+  const messages = event.messages;
+  if (!Array.isArray(messages) || messages.length === 0) return undefined;
+
+  const session: HostSessionProvenance = {
+    id: String(event.sessionId ?? "unknown"),
+    host: "omp",
+  };
+
+  const turnIndex = typeof event.turnIndex === "number" ? event.turnIndex : 0;
+  const timestamp = event.timestamp ?? new Date().toISOString();
+
+  const narrativeParts: string[] = [];
+  const toolCalls: TurnToolCall[] = [];
+
+  for (const raw of messages as Array<Record<string, unknown>>) {
+    const role = String(raw.role ?? "");
+    const content = extractTextContent(raw);
+
+    if (role === "user") {
+      narrativeParts.push(`User: ${content}`);
+    } else if (role === "assistant") {
+      narrativeParts.push(`Assistant: ${content}`);
+      const toolCallsData = raw.tool_calls ?? raw.toolCalls;
+      if (Array.isArray(toolCallsData)) {
+        for (const tc of toolCallsData) {
+          const tcr = tc as Record<string, unknown>;
+          const toolName = String(tcr.name ?? (tcr.function as Record<string, unknown>)?.name ?? "unknown");
+          const toolInput = tcr.input ?? (tcr.function as Record<string, unknown>)?.arguments ?? {};
+          toolCalls.push({
+            tool: toolName,
+            input: typeof toolInput === "string" ? { raw: toolInput } : (toolInput as Record<string, unknown>),
+            result: undefined,
+          });
+        }
+      }
+      if (content.length > 0) {
+        toolCalls.push({ tool: "respond", input: { content: content.slice(0, 200) }, result: undefined });
+      }
+    } else if (role === "tool" || role === "tool_result") {
+      const toolName = String(raw.name ?? raw.tool_name ?? "tool");
+      const result = raw.content ?? raw.result;
+      narrativeParts.push(`Tool ${toolName}: returned`);
+      const pending = [...toolCalls].reverse().find((tc) => tc.tool === toolName && tc.result === undefined);
+      if (pending) {
+        pending.result = typeof result === "string" ? result.slice(0, 500) : result;
+      } else {
+        toolCalls.push({
+          tool: toolName,
+          input: {},
+          result: typeof result === "string" ? result.slice(0, 500) : result,
+        });
+      }
+    }
+  }
+
+  return {
+    session,
+    turnIndex,
+    timestamp: String(timestamp ?? new Date().toISOString()),
+    narrative: narrativeParts.join("\n"),
+    toolCalls,
+  };
+}
+
+function extractTextContent(msg: Record<string, unknown>): string {
+  if (typeof msg.content === "string") return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content
+      .map((block: Record<string, unknown>) => {
+        if (block.type === "text" && typeof block.text === "string") return block.text;
+        if (block.type === "text" && typeof block.content === "string") return block.content;
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n");
+  }
+  if (typeof msg.content === "object" && msg.content !== null) {
+    const inner = msg.content as Record<string, unknown>;
+    if (typeof inner.text === "string") return inner.text;
+    if (typeof inner.content === "string") return inner.content;
+  }
+  return "";
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@isparling/engram-omp",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "license": "Apache-2.0",
+  "description": "Oh My Pi extension for Engram knowledge capture.",
+  "exports": {
+    ".": { "import": "./omp-extension.ts" },
+    "./types": { "import": "./omp-extension.ts" }
+  },
+  "files": ["omp-extension.ts", "README.md"],
+  "peerDependencies": {
+    "@isparling/engram-harness": "^0.1.0"
+  },
+  "publishConfig": { "access": "public" }
+}