@rohirik/openltm-core 2.8.0

package/assets/opencode/skills/CommandPathSafety/PathTraversalAndInstallerSafety.md

@@ -0,0 +1,106 @@
+# Path Traversal And Installer Safety
+
+## Boundary Model
+
+Every write, extract, copy, replace, or delete operation needs an explicit allowed root. Normalize the candidate path, resolve it against the root, and verify the final destination remains inside that root before touching the filesystem.
+
+## Traversal And Zip-Slip Risks
+
+Untrusted paths may contain `..`, absolute prefixes, mixed separators, symlinks, or archive metadata that escapes the intended directory. Zip-slip attacks use crafted archive entries such as `../../outside.txt` to overwrite files outside the extraction root.
+
+## Installer Hardening Principles
+
+Operate on a fixed list of managed targets. Avoid wildcard writes. Keep overwrite behavior intentional. Refuse to follow symlinks into unexpected locations. Validate both the source artifact and the final destination before moving files into place.
+
+## TypeScript Examples
+
+### Safe
+
+```ts
+import path from "node:path";
+
+export function resolveWithinRoot(root: string, candidate: string): string {
+  const resolved = path.resolve(root, candidate);
+
+  if (!resolved.startsWith(`${root}${path.sep}`) && resolved !== root) {
+    throw new Error("Path escapes allowed root");
+  }
+
+  return resolved;
+}
+```
+
+### Unsafe
+
+```ts
+import path from "node:path";
+
+export function installFile(root: string, candidate: string): string {
+  return path.join(root, candidate);
+}
+```
+
+`path.join` alone does not prove the final path stays inside the root.
+
+## Python Examples
+
+### Safe
+
+```python
+from pathlib import Path
+
+
+def resolve_within_root(root: Path, candidate: str) -> Path:
+    resolved = (root / candidate).resolve()
+    if root.resolve() not in [resolved, *resolved.parents]:
+        raise ValueError("Path escapes allowed root")
+    return resolved
+```
+
+### Unsafe
+
+```python
+from pathlib import Path
+
+
+def write_target(root: Path, candidate: str) -> Path:
+    return root / candidate
+```
+
+## Bash Examples
+
+### Safe
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+root_dir="$1"
+candidate="$2"
+target="$(python3 -c 'from pathlib import Path; import sys; root = Path(sys.argv[1]).resolve(); target = (root / sys.argv[2]).resolve(); print(target if root in [target, *target.parents] else "")' "$root_dir" "$candidate")"
+
+[[ -n "$target" ]] || { printf 'Path escapes root\n' >&2; exit 1; }
+```
+
+### Unsafe
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+cp "$2" "$1/$3"
+```
+
+String concatenation does not enforce destination boundaries.
+
+## Archive Extraction Checks
+
+Validate every entry name before extraction. Reject absolute paths, parent traversal, device names, and symlink targets that resolve outside the root. Treat archive metadata as attacker-controlled input, not as trustworthy filesystem intent.
+
+## Review Checklist
+
+- [ ] Every filesystem operation resolves against an explicit allowed root.
+- [ ] Final destinations are checked after normalization and resolution.
+- [ ] Installer flows avoid wildcard writes and unexpected symlink traversal.
+- [ ] Archive extraction defends against zip-slip and absolute-path escapes.
+- [ ] TypeScript, Python, and Bash examples all validate final path boundaries.

package/assets/opencode/skills/CommandPathSafety/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: command-path-safety
+description: "USE WHEN hardening command execution, path handling, or installer boundaries."
+---
+
+# Command Path Safety
+
+Treat commands and paths as structured, validated inputs.
+
+## Workflow Routing
+
+| Workflow | Trigger | File |
+|---------|---------|------|
+| **HardenCommandExecution** | "command injection", "shell safety", "exec hardening", "safe subprocess" | `Workflows/HardenCommandExecution.md` |
+| **EnforcePathBoundaries** | "path traversal", "zip slip", "installer safety", "path boundaries" | `Workflows/EnforcePathBoundaries.md` |
+
+## SkillSearch
+
+- Command injection guidance: `SkillSearch('command path safety command injection patterns')` → loads `CommandInjectionPatterns.md`
+- Path and installer guidance: `SkillSearch('command path safety path traversal installer safety')` → loads `PathTraversalAndInstallerSafety.md`
+
+## Use This Skill To
+
+- Replace shell interpolation with validated structured execution.
+- Enforce path roots for writes, extraction, and installer operations.
+- Review archive and installer behavior for traversal and boundary escapes.
+
+## Not This Skill
+
+- Not for exploit scanning, malware analysis, or final security verdicts.
+- Hand off to @aegis for deep audits, exploitability assessment, or repo-wide review.

package/assets/opencode/skills/CommandPathSafety/Workflows/EnforcePathBoundaries.md

@@ -0,0 +1,27 @@
+# EnforcePathBoundaries
+
+## Use When
+
+Use when code writes files, extracts archives, installs assets, or accepts filenames that could escape an intended root.
+
+## Procedure
+
+1. Define the exact allowed root for the operation and list every candidate source of path input.
+2. Normalize and resolve each candidate path against the allowed root before any filesystem action.
+3. Reject traversal markers, absolute escapes, unexpected symlink targets, and archive entries that resolve outside the root.
+4. Replace wildcard or implicit installer writes with an explicit managed target list.
+5. Re-check the final destination after resolution and before overwrite, extraction, or replacement occurs.
+6. Review TypeScript, Python, and Bash implementations for equivalent boundary gaps, then add adversarial tests.
+
+## Done When
+
+- [ ] Every destination is proven to remain inside an allowed root.
+- [ ] Traversal, zip-slip, and symlink escapes are rejected.
+- [ ] Installer operations act only on explicit managed targets.
+- [ ] Cross-language path handling follows the same boundary rules.
+
+## Escalate To @aegis When
+
+- You suspect an active path traversal exploit or malicious archive.
+- The boundary crosses user directories, system paths, or deployment artifacts.
+- You need a wider audit of installer or extraction behavior.

package/assets/opencode/skills/CommandPathSafety/Workflows/HardenCommandExecution.md

@@ -0,0 +1,27 @@
+# HardenCommandExecution
+
+## Use When
+
+Use when code builds shell commands, launches subprocesses, or passes untrusted values into command execution paths.
+
+## Procedure
+
+1. Identify the executable, every argument source, and every place untrusted data could influence parsing.
+2. Replace shell-built command strings with structured argv invocation wherever the runtime allows it.
+3. Validate attacker-controlled fields for separators, substitutions, globs, newlines, and leading-dash option injection.
+4. Insert `--` before positional untrusted values when the target command supports it.
+5. Remove `eval`, `exec` string templates, `os.system`, and comparable dynamic shell patterns from the flow.
+6. Review TypeScript, Python, and Bash entry points for equivalent weaknesses, then add adversarial tests.
+
+## Done When
+
+- [ ] Commands use explicit executable plus arguments.
+- [ ] Metacharacter and option-injection risks are addressed.
+- [ ] Dynamic shell construction paths are removed or tightly constrained.
+- [ ] Cross-language command execution patterns are consistently hardened.
+
+## Escalate To @aegis When
+
+- You need exploitability assessment for an existing injection path.
+- The flow executes downloaded or attacker-supplied programs.
+- Repo-wide command execution review is required.

package/assets/opencode/skills/SecretSafeHandling/CloudCredentialPatterns.md

@@ -0,0 +1,106 @@
+# Cloud Credential Patterns
+
+## Recognition Principles
+
+Recognize provider credential formats so you can redact, quarantine, or avoid reproducing them. Do not copy live-looking values into code, docs, or tests. Use obviously fake placeholders that communicate format without resembling deployable credentials.
+
+## AWS Patterns
+
+Common AWS access key identifiers begin with prefixes such as `AKIA` or `ASIA`, followed by additional uppercase alphanumeric characters. Session tokens and secret access keys are separate values and should never be shown in full.
+
+Use placeholders like `AKIA_FAKE_EXAMPLE_ONLY` or `ASIA_FAKE_SESSION_ONLY`. Keep them visibly synthetic with separators or words.
+
+## GCP Patterns
+
+Google API keys often begin with `AIza`. Service account credentials are usually JSON documents containing keys such as `type`, `project_id`, `client_email`, and `private_key`. Never reproduce a realistic private key block or full JSON blob from a live account.
+
+Use placeholders like `AIza_FAKE_EXAMPLE_ONLY` and `"private_key": "<REDACTED-FAKE-KEY>"`.
+
+## Azure Patterns
+
+Azure leaks often appear inside connection strings or signed URLs. Watch for fields like `AccountKey=` in storage connection strings and query parameters such as `sig=` in SAS URLs. Redact the value while preserving enough shape to identify the credential class.
+
+Use placeholders like `AccountKey=FAKE_EXAMPLE_ONLY` and `sig=FAKE_SIGNATURE_ONLY`.
+
+## TypeScript Examples
+
+### Safe
+
+```ts
+export function redactCloudSecret(value: string): string {
+  if (value.startsWith("AKIA") || value.startsWith("ASIA")) {
+    return "<AWS-KEY-REDACTED>";
+  }
+
+  if (value.startsWith("AIza")) {
+    return "<GCP-API-KEY-REDACTED>";
+  }
+
+  return value.replace(/AccountKey=[^;]+/, "AccountKey=<REDACTED>");
+}
+```
+
+### Unsafe
+
+```ts
+export const exampleConfig = {
+  accessKeyId: "AKIAFAKEBUTTOOREAL1234",
+  apiKey: "AIzaFakeButLooksReal1234567890",
+};
+```
+
+Even fake examples must be obviously fake, not merely invalid.
+
+## Python Examples
+
+### Safe
+
+```python
+def mask_connection_string(text: str) -> str:
+    return text.replace("AccountKey=FAKE_EXAMPLE_ONLY", "AccountKey=<REDACTED>")
+```
+
+### Unsafe
+
+```python
+SERVICE_ACCOUNT = {
+    "type": "service_account",
+    "private_key": "-----BEGIN PRIVATE KEY-----\npretend\n-----END PRIVATE KEY-----",
+}
+```
+
+Avoid private-key shaped fixtures, even when they are fake.
+
+## Bash Examples
+
+### Safe
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+printf 'Using %s\n' 'AWS_ACCESS_KEY_ID=<REDACTED>'
+```
+
+### Unsafe
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+export AZURE_STORAGE_CONNECTION_STRING='DefaultEndpointsProtocol=https;AccountName=demo;AccountKey=FAKE_EXAMPLE_ONLY'
+```
+
+Avoid shell examples that normalize inline secret storage, even with placeholders.
+
+## Redaction Guidance
+
+Preserve provider clues while removing the secret value. Examples: keep `AKIA...` as `AKIA<REDACTED>`, keep `sig=` as `sig=<REDACTED>`, and keep service account field names while replacing values. The goal is reviewability without leakage.
+
+## Review Checklist
+
+- [ ] AWS, GCP, and Azure credential shapes are recognized without reproducing realistic values.
+- [ ] Examples use obviously fake placeholders, not plausible credentials.
+- [ ] TypeScript, Python, and Bash examples all prefer redaction over inline storage.
+- [ ] Service account JSON and signed URLs are described safely.
+- [ ] Documentation preserves provider context while removing secret material.

package/assets/opencode/skills/SecretSafeHandling/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: secret-safe-handling
+description: "USE WHEN handling credentials, env vars, logs, tests, or docs safely."
+---
+
+# Secret Safe Handling
+
+Reference secret interfaces without exposing secret values.
+
+## Workflow Routing
+
+| Workflow | Trigger | File |
+|---------|---------|------|
+| **DesignSecretSafeFlow** | "secret flow", "credential wiring", "env vars", "safe secret access" | `Workflows/DesignSecretSafeFlow.md` |
+| **RemoveSecretExposure** | "secret leak", "redact token", "credential exposure", "cleanup secret" | `Workflows/RemoveSecretExposure.md` |
+
+## SkillSearch
+
+- Cloud credential identification: `SkillSearch('secret safe handling cloud credential patterns')` → loads `CloudCredentialPatterns.md`
+- Safe handling guidance: `SkillSearch('secret safe handling playbook')` → loads `SecretHandlingPlaybook.md`
+
+## Use This Skill To
+
+- Recognize cloud credential shapes without copying live values.
+- Design code, docs, tests, and logs that avoid secret disclosure.
+- Remediate accidental exposure using redaction and rotation-oriented workflows.
+
+## Not This Skill
+
+- Not for secret scanning, incident verdicts, or provider-side breach analysis.
+- Hand off to @aegis for detection runs, deep audits, or formal security judgments.

package/assets/opencode/skills/SecretSafeHandling/SecretHandlingPlaybook.md

@@ -0,0 +1,102 @@
+# Secret Handling Playbook
+
+## Core Practice
+
+Secrets should flow through dedicated interfaces such as environment variables, secret managers, injected files with limited scope, or runtime handles. They should not flow through source code literals, screenshots, snapshots, shell history, or debug logs.
+
+## Safe Wiring Patterns
+
+Use names, paths, and contracts instead of values. Say `process.env.API_TOKEN`, `os.environ["API_TOKEN"]`, or `/run/secrets/api-token` rather than showing any token content.
+
+Prefer the shortest path from secret source to secret consumer. Every extra copy creates another leak surface.
+
+## Logging Patterns
+
+Log secret state, not secret content. Safe logs include presence, source, age, rotation state, or validation outcome. Unsafe logs include full tokens, connection strings, authorization headers, signed URLs, or PEM blocks.
+
+## Test And Documentation Patterns
+
+Tests should use synthetic placeholders such as `<TOKEN_FROM_TEST_FIXTURE>` or `FAKE_EXAMPLE_ONLY`. Documentation should show where a value goes and how to inject it, not what a realistic value looks like.
+
+Snapshots, screenshots, and copy-paste setup guides often become leak vectors. Review them as carefully as source code.
+
+## TypeScript Examples
+
+### Safe
+
+```ts
+export function readApiToken(): string {
+  const token = process.env.API_TOKEN;
+
+  if (!token) {
+    throw new Error("API_TOKEN is required");
+  }
+
+  return token;
+}
+```
+
+### Unsafe
+
+```ts
+export const API_TOKEN = "FAKE_TOKEN_EXAMPLE_ONLY";
+```
+
+Even fake literals teach the wrong integration pattern.
+
+## Python Examples
+
+### Safe
+
+```python
+import os
+
+
+def get_db_password() -> str:
+    password = os.environ["DB_PASSWORD"]
+    return password
+```
+
+### Unsafe
+
+```python
+def debug_secret(password: str) -> None:
+    print(f"db password={password}")
+```
+
+## Bash Examples
+
+### Safe
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ -z "${API_TOKEN:-}" ]]; then
+  printf 'API_TOKEN is missing\n' >&2
+  exit 1
+fi
+```
+
+### Unsafe
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+curl -H "Authorization: Bearer ${API_TOKEN}" "https://example.invalid"
+```
+
+Inline shell expansion can leak into process listings, traces, and logs.
+
+## Cleanup Strategy For Exposed Secrets
+
+When exposure occurs, first contain the artifact, then redact visible copies, then plan rotation with the system owner. Code cleanup alone is not enough if the secret may already have been observed. Preserve evidence for incident response without repeating the secret.
+
+## Review Checklist
+
+- [ ] Secrets enter code through approved interfaces instead of literals.
+- [ ] Logs, tests, docs, and screenshots avoid revealing secret values.
+- [ ] TypeScript, Python, and Bash examples model safe integration patterns.
+- [ ] Redaction preserves context without disclosing the value.
+- [ ] Cleanup guidance includes containment and rotation-oriented follow-up.

package/assets/opencode/skills/SecretSafeHandling/Workflows/DesignSecretSafeFlow.md

@@ -0,0 +1,27 @@
+# DesignSecretSafeFlow
+
+## Use When
+
+Use when designing code, docs, tests, or automation that must access credentials without exposing them.
+
+## Procedure
+
+1. Identify the secret producer, the secret consumer, and every place the value could be copied or logged.
+2. Choose a dedicated handoff mechanism such as environment injection, secret manager lookup, or restricted runtime file.
+3. Replace any literal examples with interface-only references, placeholders, or redacted shapes.
+4. Audit logs, error paths, tests, and docs to ensure they reveal state only, not secret content.
+5. Minimize secret lifetime and duplication by passing the value directly to the consumer with the fewest intermediate hops.
+6. Review the design for leak surfaces across TypeScript, Python, and Bash touchpoints, then add adversarial tests.
+
+## Done When
+
+- [ ] No design artifact embeds a secret literal.
+- [ ] Secret flow uses an approved injection or retrieval path.
+- [ ] Logs, docs, and tests show interface shape without value disclosure.
+- [ ] Leak surfaces are identified and reduced.
+
+## Escalate To @aegis When
+
+- You suspect a real credential has already been exposed.
+- You need repo-wide secret detection or incident-oriented review.
+- The flow touches multiple systems and requires a formal security judgment.

package/assets/opencode/skills/SecretSafeHandling/Workflows/RemoveSecretExposure.md

@@ -0,0 +1,27 @@
+# RemoveSecretExposure
+
+## Use When
+
+Use when code, docs, logs, tests, or examples contain a secret or secret-like value that must be contained and cleaned up.
+
+## Procedure
+
+1. Identify every artifact that contains the exposed value or a derived copy such as logs, snapshots, comments, or transcripts.
+2. Contain further spread by removing the value from active prompts, outputs, and generated artifacts.
+3. Replace the exposed value with a redacted marker that preserves provider or field context.
+4. Update code, docs, tests, and shell snippets so future examples use interface-only references or obviously fake placeholders.
+5. Document whether rotation or owner notification is required without repeating the secret in the note.
+6. Re-review the cleaned artifacts for residual copies and screenshot risk, then add adversarial tests.
+
+## Done When
+
+- [ ] The exposed value is no longer present in maintained artifacts.
+- [ ] Replacement text is clearly redacted and non-usable.
+- [ ] Follow-up notes avoid reintroducing the secret.
+- [ ] Future examples use safe placeholders or secret interfaces.
+
+## Escalate To @aegis When
+
+- The exposure may involve a real cloud credential, token, or private key.
+- You need forensic guidance, scan coverage, or incident severity judgment.
+- The leak spans commit history, artifacts, or multiple repositories.

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@rohirik/openltm-core",
+  "version": "2.8.0",
+  "description": "Shared LTM storage engine — path-agnostic SQLite core used by Claude Code, OpenCode, and Pi adapters",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./cli": "./src/cli/index.ts"
+  },
+  "bin": {
+    "ltm": "src/cli/bin.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RohiRIK/OpenLtm"
+  },
+  "keywords": [
+    "ltm",
+    "long-term-memory",
+    "claude-code",
+    "sqlite",
+    "memory"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.3.0",
+    "@iarna/toml": "^2.2.5",
+    "bun-types": "^1.0.0",
+    "sqlite-vec": "0.1.9"
+  },
+  "optionalDependencies": {
+    "@russellthehippo/honker-bun": "^0.2.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/src/__tests__/cli/claude.test.ts

@@ -0,0 +1,122 @@
+/**
+ * cli/claude.test.ts — Unit tests for the Claude Code installer.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import os from "os";
+
+function makeTmp(): string {
+  const dir = join(
+    os.tmpdir(),
+    `ltm-claude-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function readSettings(tmpDir: string): Record<string, unknown> {
+  const p = join(tmpDir, ".claude", "settings.json");
+  return JSON.parse(readFileSync(p, "utf8")) as Record<string, unknown>;
+}
+
+describe("installClaude", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmp();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("creates settings.json with MCP entry and all 3 hooks", async () => {
+    const { installClaude } = await import("../../cli/claude.js");
+    const result = await installClaude({ homedir: tmpDir });
+    expect(result.status).toBe("installed");
+
+    const s = readSettings(tmpDir);
+    const servers = s["mcpServers"] as Record<string, unknown>;
+    expect(servers).toBeDefined();
+    expect(servers["openltm"]).toBeDefined();
+
+    const hooks = s["hooks"] as Record<string, unknown[]>;
+    expect(hooks).toBeDefined();
+    expect(Array.isArray(hooks["SessionStart"])).toBe(true);
+    expect(Array.isArray(hooks["PreCompact"])).toBe(true);
+    expect(Array.isArray(hooks["PostEditCheck"])).toBe(true);
+  });
+
+  it("second run returns status skipped (idempotent)", async () => {
+    const { installClaude } = await import("../../cli/claude.js");
+    const first = await installClaude({ homedir: tmpDir });
+    expect(first.status).toBe("installed");
+
+    const second = await installClaude({ homedir: tmpDir });
+    expect(second.status).toBe("skipped");
+  });
+
+  it("preserves existing mcpServers entries from other tools", async () => {
+    // Pre-create a settings.json with another MCP server
+    mkdirSync(join(tmpDir, ".claude"), { recursive: true });
+    writeFileSync(
+      join(tmpDir, ".claude", "settings.json"),
+      JSON.stringify({ mcpServers: { existingTool: { command: "npx", args: ["some-tool"] } } }),
+      "utf8",
+    );
+
+    const { installClaude } = await import("../../cli/claude.js");
+    await installClaude({ homedir: tmpDir });
+
+    const s = readSettings(tmpDir);
+    const servers = s["mcpServers"] as Record<string, unknown>;
+    expect(servers["existingTool"]).toBeDefined();
+    expect(servers["openltm"]).toBeDefined();
+  });
+
+  it("dryRun=true does not write any files", async () => {
+    const { installClaude } = await import("../../cli/claude.js");
+    const result = await installClaude({ homedir: tmpDir, dryRun: true });
+    expect(result.status).toBe("installed");
+
+    const settingsFile = join(tmpDir, ".claude", "settings.json");
+    expect(existsSync(settingsFile)).toBe(false);
+  });
+
+  it("creates settings.json when .claude/ directory does not exist", async () => {
+    const { installClaude } = await import("../../cli/claude.js");
+    // tmpDir has no .claude subdirectory
+    const result = await installClaude({ homedir: tmpDir });
+    expect(result.status).toBe("installed");
+    expect(existsSync(join(tmpDir, ".claude", "settings.json"))).toBe(true);
+  });
+
+  it("includes the correct MCP command and args", async () => {
+    const { installClaude } = await import("../../cli/claude.js");
+    await installClaude({ homedir: tmpDir });
+
+    const s = readSettings(tmpDir);
+    const ltm = (s["mcpServers"] as Record<string, unknown>)["openltm"] as {
+      command: string;
+      args: string[];
+    };
+    expect(ltm.command).toBe("bunx");
+    expect(ltm.args).toEqual(["@rohirik/openltm-core", "mcp-serve"]);
+  });
+
+  it("includes all 3 hook events with correct command", async () => {
+    const { installClaude } = await import("../../cli/claude.js");
+    await installClaude({ homedir: tmpDir });
+
+    const s = readSettings(tmpDir);
+    const hooks = s["hooks"] as Record<string, Array<{ command: string; args: string[] }>>;
+
+    for (const event of ["SessionStart", "PreCompact", "PostEditCheck"]) {
+      const entries = hooks[event];
+      expect(entries.length).toBeGreaterThan(0);
+      expect(entries[0]!.command).toBe("bunx");
+      expect(entries[0]!.args[0]).toBe("@rohirik/openltm-core");
+    }
+  });
+});