lyra-core 0.1.0

package/README.md

@@ -0,0 +1,24 @@
+# lyra-core
+
+The SDK behind **lyra**, a Sui-native, policy-aware AI treasury assistant:
+the brain (OpenAI-compatible), local file-based memory + index,
+the **permission service + approval floor**, plain-EOA identity + a local
+encrypted keystore, the **lyra::policy (Trustless Agents) identity client**, the
+plugin host, tool registry, and event queue.
+
+## Install
+
+```bash
+bun add lyra-core
+```
+
+Bun / TypeScript-native (ships TS source). Requires [bun](https://bun.sh).
+
+## Use
+
+Install [`lyra-ai-agent`](https://www.npmjs.com/package/lyra-ai-agent) (the
+CLI) for the full agent. This package is for plugin authors and library consumers
+who want to embed the runtime, the deterministic policy/approval spine, or the
+lyra::policy identity client (`registerAgent`, `resolveAgentById`, `buildAgentCard`).
+
+See the [root README](https://github.com/rifkyeasy/lyra#readme) for the full surface.

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "lyra-core",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "The SDK for lyra, a Sui-native policy-aware AI treasury assistant: brain, local memory + storage, the policy/approval engine, and the Sui agent keypair + chain helpers",
+  "license": "MIT",
+  "homepage": "https://github.com/rifkyeasy/lyra",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rifkyeasy/lyra.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/rifkyeasy/lyra/issues"
+  },
+  "keywords": [
+    "lyra",
+    "ai",
+    "agent",
+    "sui",
+    "treasury",
+    "defi",
+    "policy"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": ">=1.1"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "README.md"
+  ],
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./config": "./src/config.ts",
+    "./events": "./src/events/index.ts",
+    "./memory": "./src/memory/index.ts",
+    "./tools": "./src/tools/index.ts",
+    "./brain": "./src/brain/index.ts",
+    "./storage": "./src/storage/index.ts",
+    "./wallet": "./src/wallet/index.ts",
+    "./runtime": "./src/runtime/index.ts",
+    "./paths": "./src/paths.ts"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@mysten/sui": "^1.40.0",
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^2.2.0",
+    "gray-matter": "^4.0.3",
+    "qrcode-terminal": "^0.12.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/qrcode-terminal": "^0.12.2"
+  }
+}

package/src/brain/compaction.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  DEFAULT_COMPACTION_OPTS,
+  SUMMARY_SYSTEM_PROMPT,
+  compactHistory,
+  estimateTokens,
+  shouldCompact,
+} from './compaction'
+import type { BrainMessage } from './types'
+
+const u = (content: string): BrainMessage => ({ role: 'user', content })
+const a = (content: string): BrainMessage => ({ role: 'assistant', content })
+
+describe('estimateTokens', () => {
+  it('returns 0 for empty', () => {
+    expect(estimateTokens([])).toBe(0)
+  })
+
+  it('rounds up content length / 3.5', () => {
+    // 7 chars / 3.5 = 2 tokens
+    expect(estimateTokens([u('1234567')])).toBe(2)
+  })
+
+  it('sums across messages', () => {
+    expect(estimateTokens([u('hello'), a('world!')])).toBeGreaterThan(0)
+    expect(estimateTokens([u('hello'), a('world!')])).toBe(Math.ceil(5 / 3.5) + Math.ceil(6 / 3.5))
+  })
+
+  it('counts tool_calls overhead', () => {
+    const withTools: BrainMessage = {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{ id: 'x', name: 'shell.run', args: { command: 'ls' } }],
+    }
+    expect(estimateTokens([withTools])).toBeGreaterThan(0)
+  })
+})
+
+describe('shouldCompact', () => {
+  // Trigger tokens = threshold * contextWindow = 0.5 * 1000 = 500.
+  // Min history length to consider = keepRecent * 2 + 4 = 8 messages.
+  const opts = { threshold: 0.5, contextWindow: 1000, keepRecent: 2 }
+
+  it('returns null when history too short to compact', () => {
+    expect(shouldCompact([], null, opts)).toBeNull()
+    expect(shouldCompact([u('a'), a('b')], null, opts)).toBeNull()
+  })
+
+  it('returns null when token count below threshold', () => {
+    const tiny: BrainMessage[] = []
+    for (let i = 0; i < 20; i++) tiny.push(u('x'))
+    // 20 single-char messages → ~20 tokens, threshold = 500
+    expect(shouldCompact(tiny, null, opts)).toBeNull()
+  })
+
+  it('returns trigger tokens when estimate exceeds threshold', () => {
+    const big: BrainMessage[] = []
+    for (let i = 0; i < 20; i++) big.push(u('x'.repeat(100)))
+    // 20 × ~29 tokens = ~580 tokens; threshold = 500
+    const r = shouldCompact(big, null, opts)
+    expect(r).not.toBeNull()
+    expect(r!).toBeGreaterThan(500)
+  })
+
+  it('uses lastTurnPromptTokens when larger than estimate', () => {
+    const small: BrainMessage[] = []
+    for (let i = 0; i < 20; i++) small.push(u('x'))
+    const r = shouldCompact(small, 999, opts)
+    expect(r).toBe(999)
+  })
+
+  it('uses estimate when larger than lastTurnPromptTokens', () => {
+    const big: BrainMessage[] = []
+    for (let i = 0; i < 20; i++) big.push(u('x'.repeat(100)))
+    const est = estimateTokens(big)
+    const r = shouldCompact(big, 50, opts)
+    expect(r).toBe(est)
+  })
+
+  it('respects keepRecent cutoff', () => {
+    // keepRecent=100 → min 204 messages required
+    const opts2 = { threshold: 0.001, contextWindow: 100, keepRecent: 100 }
+    const ten: BrainMessage[] = []
+    for (let i = 0; i < 50; i++) ten.push(u('x'.repeat(1000)))
+    expect(shouldCompact(ten, null, opts2)).toBeNull()
+  })
+})
+
+describe('compactHistory', () => {
+  it('returns unchanged when history shorter than keepRecent*2', async () => {
+    const opts = { ...DEFAULT_COMPACTION_OPTS, keepRecent: 4 }
+    const h = [u('1'), a('2'), u('3'), a('4')]
+    const result = await compactHistory(h, opts, async () => 'summary')
+    expect(result).toEqual(h)
+  })
+
+  it('folds older into a summary message', async () => {
+    const opts = { ...DEFAULT_COMPACTION_OPTS, keepRecent: 2 }
+    const h: BrainMessage[] = []
+    for (let i = 0; i < 10; i++) h.push(u(`msg ${i}`))
+    const result = await compactHistory(h, opts, async older => {
+      expect(older.length).toBe(6) // 10 - keepRecent*2
+      return 'OLDER SUMMARY'
+    })
+    // Expected: [summary, ...last 4 messages]
+    expect(result.length).toBe(5)
+    expect(result[0]?.role).toBe('user')
+    expect(result[0]?.content).toContain('<previous-context-summary>')
+    expect(result[0]?.content).toContain('OLDER SUMMARY')
+    expect(result[1]?.content).toBe('msg 6')
+    expect(result[4]?.content).toBe('msg 9')
+  })
+
+  it('wraps summary in tag', async () => {
+    const opts = { ...DEFAULT_COMPACTION_OPTS, keepRecent: 2 }
+    const h: BrainMessage[] = []
+    for (let i = 0; i < 10; i++) h.push(u(`msg ${i}`))
+    const result = await compactHistory(h, opts, async () => 'X')
+    expect(result[0]?.content).toMatch(
+      /^<previous-context-summary>\nX\n<\/previous-context-summary>$/,
+    )
+  })
+
+  it('propagates summarize errors', async () => {
+    const opts = { ...DEFAULT_COMPACTION_OPTS, keepRecent: 1 }
+    const h: BrainMessage[] = []
+    for (let i = 0; i < 10; i++) h.push(u(`msg ${i}`))
+    await expect(
+      compactHistory(h, opts, async () => {
+        throw new Error('summarize fail')
+      }),
+    ).rejects.toThrow('summarize fail')
+  })
+})
+
+describe('SUMMARY_SYSTEM_PROMPT', () => {
+  it('mentions key elements to preserve', () => {
+    const lower = SUMMARY_SYSTEM_PROMPT.toLowerCase()
+    expect(lower).toContain('facts')
+    expect(lower).toContain('decisions')
+    expect(lower).toContain('tool outputs')
+  })
+
+  it('forbids preamble', () => {
+    expect(SUMMARY_SYSTEM_PROMPT).toMatch(/preamble/i)
+  })
+})
+
+describe('DEFAULT_COMPACTION_OPTS', () => {
+  it('targets Qwen 1M with conservative threshold', () => {
+    expect(DEFAULT_COMPACTION_OPTS.contextWindow).toBe(1_000_000)
+    expect(DEFAULT_COMPACTION_OPTS.threshold).toBeGreaterThan(0)
+    expect(DEFAULT_COMPACTION_OPTS.threshold).toBeLessThan(1)
+    expect(DEFAULT_COMPACTION_OPTS.keepRecent).toBeGreaterThan(0)
+  })
+})

package/src/brain/compaction.ts

@@ -0,0 +1,131 @@
+/**
+ * Auto-compaction: pre-flight summarize-fold of older history when the
+ * running token estimate breaches a configurable fraction of the model
+ * context window.
+ *
+ * Cost / quality model:
+ *   - Compaction cost is one extra inference call (the summarize step) per
+ *     fold. Default threshold 0.5 of contextWindow means a Qwen 1M session
+ *     compacts ~once per 500K tokens of accumulated transcript.
+ *   - Frozen prefix (system prompt + identity + persona + skills) is NEVER
+ *     touched by compaction — caller-managed, designed to stay cache-warm.
+ *     This module only operates on the `history` array (user/assistant pairs).
+ *   - The summary is inserted as a single user-role message wrapped in
+ *     `<previous-context-summary>...</previous-context-summary>` so the brain
+ *     can recognize it as historical context, not a fresh request.
+ */
+
+import type { BrainMessage } from './types'
+
+export interface CompactionOpts {
+  /** Fraction of contextWindow (0-1) that triggers compaction. */
+  threshold: number
+  /** Model context window in tokens. */
+  contextWindow: number
+  /**
+   * Number of recent turns to keep verbatim AFTER the summary.
+   * Each "turn" is 2 messages (user + assistant), so keepRecent: 8 retains
+   * the last 16 messages.
+   */
+  keepRecent: number
+}
+
+export const DEFAULT_COMPACTION_OPTS: CompactionOpts = {
+  threshold: 0.5,
+  contextWindow: 1_000_000,
+  keepRecent: 8,
+}
+
+/**
+ * System prompt fed to the summarizer sub-call. Tuned to extract durable
+ * facts and decisions while dropping pleasantries; output is plain text with
+ * no preamble so the wrapper tag is the only structure around it.
+ */
+export const SUMMARY_SYSTEM_PROMPT = `You are summarizing a conversation between an operator and an AI agent so the agent can keep working with context that fits in its budget.
+
+Produce a tight, factual recap (3-8 sentences) preserving:
+- Key facts the operator stated about themselves, their goals, and constraints.
+- Decisions that were made and why.
+- Tool outputs the agent referenced or relied on (URLs visited, balances read, files written).
+- In-progress goals or tasks the agent is mid-flight on.
+
+Drop pleasantries, repeated clarifications, verbose tool args, and redundant agent prose.
+
+Output the summary text only. Do not add a preamble like "Here is the summary:" — start with the first fact.`
+
+/**
+ * Heuristic token estimator: ~3.5 chars per token (slightly conservative for
+ * Qwen-style tokenizers on mixed content). Used as a fallback when the brain
+ * has no `usage.promptTokens` from the prior turn yet.
+ */
+export function estimateTokens(messages: readonly BrainMessage[]): number {
+  let total = 0
+  for (const m of messages) {
+    const text = typeof m.content === 'string' ? m.content : ''
+    total += Math.ceil(text.length / 3.5)
+    // Rough overhead for tool_calls metadata (id, name, args JSON).
+    if (m.toolCalls) {
+      for (const tc of m.toolCalls) {
+        total += Math.ceil((tc.name?.length ?? 0) / 3.5)
+        const argStr = typeof tc.args === 'string' ? tc.args : JSON.stringify(tc.args ?? {})
+        total += Math.ceil(argStr.length / 3.5)
+      }
+    }
+  }
+  return total
+}
+
+/**
+ * Decide whether the next infer() call should compact first.
+ *
+ * Three conditions must hold:
+ *   1. History has more messages than `keepRecent * 2 + 4` (otherwise there's
+ *      nothing meaningful to fold — keep is what we'd already keep).
+ *   2. Either the prior turn's `usage.promptTokens` (canonical) or the
+ *      heuristic estimate exceeds `threshold * contextWindow`.
+ *
+ * Returns the trigger token count (the larger of usage and estimate) for the
+ * caller to log via the compaction event, or null when no compaction needed.
+ */
+export function shouldCompact(
+  history: readonly BrainMessage[],
+  lastTurnPromptTokens: number | null,
+  opts: CompactionOpts,
+): number | null {
+  if (history.length < opts.keepRecent * 2 + 4) return null
+  const estimate = estimateTokens(history)
+  // We take the max of the prior turn's authoritative usage and the heuristic
+  // estimate. Usage alone misses messages appended since the last turn (the
+  // pending user msg), so the estimate is the conservative cap.
+  const tokens = Math.max(lastTurnPromptTokens ?? 0, estimate)
+  const limit = opts.threshold * opts.contextWindow
+  return tokens > limit ? tokens : null
+}
+
+export type SummarizeFn = (older: readonly BrainMessage[]) => Promise<string>
+
+/**
+ * Fold older messages into a single `<previous-context-summary>` user
+ * message and return the new history (summary + last `keepRecent * 2`
+ * messages verbatim).
+ *
+ * If the history is already short enough that there are no "older" messages
+ * to fold, returns the input unchanged.
+ *
+ * Thrown errors from `summarize` propagate — caller decides whether to skip
+ * compaction this turn (best-effort) or fail the turn.
+ */
+export async function compactHistory(
+  history: readonly BrainMessage[],
+  opts: CompactionOpts,
+  summarize: SummarizeFn,
+): Promise<BrainMessage[]> {
+  const recentCount = opts.keepRecent * 2
+  if (history.length <= recentCount) return [...history]
+  const recent = history.slice(-recentCount)
+  const older = history.slice(0, -recentCount)
+  if (older.length === 0) return [...history]
+  const summary = await summarize(older)
+  const wrapped = `<previous-context-summary>\n${summary.trim()}\n</previous-context-summary>`
+  return [{ role: 'user', content: wrapped }, ...recent]
+}

package/src/brain/demo-endpoint.ts

@@ -0,0 +1,13 @@
+/**
+ * Hackathon demo fallback for the brain's LLM endpoint.
+ *
+ * So lyra runs out of the box with **no personal API key**: when neither
+ * `OPENAI_API_KEY` nor `LYRA_LLM_API_KEY` is set, the CLI and gateway route
+ * through this hosted, key-capped, rate-limited proxy (it holds the real key
+ * server-side). Users who set their own key bypass this entirely.
+ *
+ * NOTE: this is a public demo endpoint for the Sui Turing Test 2026. Remove
+ * or rotate it after the event (it gates a shared, spend-capped OpenAI key).
+ */
+export const DEMO_LLM_BASE_URL = 'https://lyraai.space/api/llm/v1'
+export const DEMO_LLM_TOKEN = 'lyra-demo-c3ce165b62c9c8a2f8a61324'

package/src/brain/frozen-prefix.test.ts

@@ -0,0 +1,235 @@
+import { expect, test } from 'bun:test'
+import { buildFrozenPrefix, renderFrozenPrefix, renderUserContext } from './frozen-prefix'
+
+test('buildFrozenPrefix without memory index returns system prompt + session', () => {
+  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
+  expect(p.memoryIndexText).toBeNull()
+  expect(p.systemPrompt.length).toBeGreaterThan(0)
+  expect(renderFrozenPrefix(p)).toBe(`${p.systemPrompt}\n`)
+})
+
+test('buildFrozenPrefix with memory index puts it in renderUserContext, NOT system prompt', () => {
+  const memoryIndex = {
+    lines: ['# agent-id — Memory Index', '', '## Memories', '', '- [foo](agent/foo.md) — hello'],
+    entries: new Map(),
+  }
+  const p = buildFrozenPrefix({ memoryIndex, timestamp: null })
+  const sys = renderFrozenPrefix(p)
+  expect(sys).not.toContain('MEMORY.md (index)')
+  const ctx = renderUserContext(p)
+  expect(ctx).not.toBeNull()
+  expect(ctx!).toContain('MEMORY.md (index)')
+  expect(ctx!).toContain('foo')
+  expect(ctx!).toContain('<system-reminder>')
+})
+
+test('buildFrozenPrefix accepts custom system prompt', () => {
+  const p = buildFrozenPrefix({ systemPrompt: 'custom.', memoryIndex: null, timestamp: null })
+  expect(renderFrozenPrefix(p)).toBe('custom.\n')
+})
+
+test('buildFrozenPrefix loads identity + persona content into prefix', () => {
+  const p = buildFrozenPrefix({
+    memoryIndex: null,
+    identity: '# I am agent #42',
+    persona: '# I am terse',
+    timestamp: null,
+  })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('Identity (canonical')
+  expect(rendered).toContain('I am agent #42')
+  expect(rendered).toContain('Persona (voice')
+  expect(rendered).toContain('I am terse')
+})
+
+test('buildFrozenPrefix appends per-tool guidance for loaded tools only', () => {
+  const p = buildFrozenPrefix({
+    memoryIndex: null,
+    loadedToolNames: ['memory.save', 'memory.read'],
+    timestamp: null,
+  })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('Save durable facts using `memory.save` proactively')
+  expect(rendered).toContain('call `memory.read`')
+  // No guidance for unknown tools
+  const p2 = buildFrozenPrefix({
+    memoryIndex: null,
+    loadedToolNames: ['unknown.tool'],
+    timestamp: null,
+  })
+  expect(p2.toolGuidance).toEqual([])
+})
+
+test('buildFrozenPrefix includes session timestamp by default', () => {
+  const p = buildFrozenPrefix({ memoryIndex: null })
+  expect(p.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/)
+  expect(renderFrozenPrefix(p)).toContain('Session started:')
+})
+
+test('renderUserContext returns null when nothing to inject', () => {
+  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
+  expect(renderUserContext(p)).toBeNull()
+})
+
+test('buildFrozenPrefix filters claude-code agent-browser skill out of the index', () => {
+  const skills = [
+    {
+      id: 'claude-code:agent-browser',
+      name: 'agent-browser',
+      description: 'Automates browser interactions',
+      path: '/x/SKILL.md',
+      source: 'claude-code' as const,
+      frontmatter: { name: 'agent-browser', description: 'Automates browser interactions' },
+    },
+    {
+      id: 'claude-code:hakr',
+      name: 'hakr',
+      description: 'Hacker News CLI',
+      path: '/y/SKILL.md',
+      source: 'claude-code' as const,
+      frontmatter: { name: 'hakr', description: 'Hacker News CLI' },
+    },
+  ]
+  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null, skills })
+  expect(p.skillIndexText).toContain('hakr')
+  expect(p.skillIndexText).not.toContain('agent-browser')
+  expect(p.skillIndexText).not.toContain('claude-code:agent-browser')
+})
+
+test('default system prompt includes browser guidance always-on (not conditional)', () => {
+  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('browser.navigate')
+  expect(rendered).toContain('headless Chromium')
+  expect(rendered).toContain('agent-browser')
+})
+
+test('default system prompt forbids pre-flight environment probes for browser', () => {
+  // v0.19.18 regression guard: brain was hitting `shell.run "which chromium ..."`
+  // before browser.navigate, blocking forever on the resulting approval and
+  // then hallucinating "browser tools aren't available in this sandbox" when
+  // the probe was denied. The guidance must explicitly forbid those probes.
+  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('Do NOT pre-probe the environment')
+  expect(rendered).toContain('which chromium')
+  expect(rendered).toContain('self-contained')
+})
+
+test('default system prompt includes tool-use enforcement', () => {
+  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('You MUST use your tools')
+  expect(rendered).toContain('NEVER answer these from memory')
+})
+
+test('buildFrozenPrefix appends operator promptAppend under # Operator instructions', () => {
+  const p = buildFrozenPrefix({
+    memoryIndex: null,
+    timestamp: null,
+    promptAppend: 'Always reply in Indonesian.',
+  })
+  expect(p.appendText).toBe('Always reply in Indonesian.')
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('# Operator instructions')
+  expect(rendered).toContain('Always reply in Indonesian.')
+})
+
+test('buildFrozenPrefix renders envInfo cwd + platform', () => {
+  const p = buildFrozenPrefix({
+    memoryIndex: null,
+    timestamp: null,
+    envInfo: { cwd: '/tmp/x', platform: 'darwin' },
+  })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('# Environment')
+  expect(rendered).toContain('cwd: /tmp/x')
+  expect(rendered).toContain('platform: darwin')
+})
+
+test('envInfo with sandbox=docker surfaces inner OS + workspace mount + scope', () => {
+  const p = buildFrozenPrefix({
+    memoryIndex: null,
+    timestamp: null,
+    envInfo: {
+      cwd: '/tmp/x',
+      platform: 'darwin',
+      sandbox: {
+        mode: 'docker',
+        label: 'podman:nikolaik/python-nodejs:python3.11-nodejs20+workspace',
+        innerOs: 'linux',
+        workspaceMount: '/workspace',
+        scope: 'shell.run, code.execute, shell.process_start run inside the container',
+      },
+    },
+  })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('sandbox: docker (podman:')
+  expect(rendered).toContain('inner os: linux')
+  expect(rendered).toContain('workspace mount: host cwd is bind-mounted at /workspace')
+  expect(rendered).toContain('scope: shell.run, code.execute')
+})
+
+test('envInfo with sandbox.mode=none does NOT add the sandbox section', () => {
+  const p = buildFrozenPrefix({
+    memoryIndex: null,
+    timestamp: null,
+    envInfo: {
+      cwd: '/tmp/x',
+      platform: 'darwin',
+      sandbox: { mode: 'none', label: 'none' },
+    },
+  })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('cwd: /tmp/x')
+  expect(rendered).not.toContain('sandbox:')
+})
+
+test('envInfo with sandbox=os surfaces label + scope under # Environment', () => {
+  const p = buildFrozenPrefix({
+    memoryIndex: null,
+    timestamp: null,
+    envInfo: {
+      cwd: '/tmp/x',
+      platform: 'darwin',
+      sandbox: {
+        mode: 'os',
+        label: 'os:darwin',
+        innerOs: 'darwin',
+        workspaceMount: null,
+        scope: 'spawns wrapped in sandbox-exec; writes outside agentDir + cwd denied',
+      },
+    },
+  })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toContain('sandbox: os (os:darwin)')
+  expect(rendered).toContain('scope: spawns wrapped in sandbox-exec')
+  expect(rendered).not.toContain('workspace mount:')
+})
+
+test('skill-shadow filter keeps lyra-source skills with the same name', () => {
+  const skills = [
+    {
+      id: 'lyra:browser',
+      name: 'browser',
+      description: 'Lyra native browser playbook',
+      path: '/z/SKILL.md',
+      source: 'lyra' as const,
+      frontmatter: { name: 'browser', description: 'Lyra native browser playbook' },
+    },
+  ]
+  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null, skills })
+  expect(p.skillIndexText).toContain('lyra:browser')
+})
+
+// v0.22.0: brain emitted em-dashes in prose + table separators, violating the
+// project hard rule (global CLAUDE.md). The system prompt now carries an
+// explicit ASCII-hyphen rule in the Tone and style section.
+test('system prompt instructs brain to use ASCII hyphens, not em-dashes', () => {
+  const p = buildFrozenPrefix({ memoryIndex: null, timestamp: null })
+  const rendered = renderFrozenPrefix(p)
+  expect(rendered).toMatch(/ASCII hyphens/)
+  expect(rendered).toMatch(/em-dashes/)
+  // Reference U+2014 explicitly so the brain knows the exact codepoint
+  expect(rendered).toMatch(/U\+2014/)
+})