soulbridge 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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.
+
+   Copyright 2023 The Sigstore Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,35 @@
+soulbridge
+Copyright 2026 soulbridge contributors
+
+This product is licensed under the Apache License, Version 2.0 (see LICENSE).
+
+--------------------------------------------------------------------------------
+Third-party notices
+--------------------------------------------------------------------------------
+
+Source code bundled in this repository: none.
+
+The repository contains only original code and documentation. Runtime behavior
+relies on Node.js built-in modules (notably `node:sqlite`), which are distributed
+under the Node.js license and are not covered by this repository's license.
+
+Design references (ideas, not code)
+-----------------------------------
+- The four-verb protocol shape (context / observe / recall / reflect) is an
+  original design informed by common agent lifecycle conventions, including the
+  Model Context Protocol's tool conventions.
+- The emotion taxonomy *structure* used by the future affect layer (7 categories,
+  intensity 1–9, polarity) follows the publicly documented structure of the
+  Dalian University of Technology affective lexicon (DUTIR).
+
+  No word list from DUTIR — or from any third-party lexicon — is bundled here.
+  Any lexicon a user supplies remains subject to that user's own licensing
+  obligations. See docs/adr/0006-licensing.md.
+
+--------------------------------------------------------------------------------
+Trademarks
+--------------------------------------------------------------------------------
+
+"Claude", "Cursor", "Codex", "Pi" and other product names are trademarks of their
+respective owners. References to them describe interoperability targets only and
+imply no affiliation or endorsement.

package/README.md

@@ -1,3 +1,99 @@
-# Temporary Holding Version
+# soulbridge
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> **给任何 agent 装上一个人格层。**
+> A personality layer for any agent — continuity, forgetting, and growth across tools.
+
+**状态：v0.0.1 骨架 · 未发布 · 接口随时会变**
+
+---
+
+## 它解决什么
+
+Claude Code 记得你在 Claude Code 里说过的话，Cursor 不记得，Pi 不记得。
+你的偏好、你的判断、你被纠正过的错——换一个工具，全部归零。
+
+soulbridge 是它们之间那层**不属于任何一家**的记忆与人格：
+
+> 一个 soul，多个宿主；一个人格，持续成长。
+
+## 它不做什么
+
+| 不做 | 为什么 |
+|---|---|
+| agent runtime | 宿主已经免费提供了，再写一遍是重复劳动 |
+| 向量数据库 / RAG 引擎 | 内容是商品，检索可以接现成的 |
+| 云端服务 | 默认全本地，数据不出机器 |
+| “更像人”的叙事营销 | 只承诺可观测的事 |
+
+## 四个动词
+
+宿主只需要在四个时机调用，就完成了接入：
+
+| 动词 | 时机 | 作用 |
+|---|---|---|
+| `context()` | 会话开始 | 注入：身份 + 画像 + 相关记忆 + 表达风格 |
+| `observe(turn)` | 每轮结束 | 观察：写入经历、更新情绪 |
+| `recall(q)` | 需要时 | 召回：按相关性/新旧/重要度/唤醒次数排序 |
+| `reflect(session)` | 会话结束 | 反思：把经历固化成策略与认知 |
+
+详见 [docs/protocol.md](docs/protocol.md)。
+
+## 30 秒跑起来
+
+零依赖，只需要 Node ≥ 22（原生跑 TypeScript + `node:sqlite`）：
+
+```bash
+node packages/cli/src/cli.ts init
+node packages/cli/src/cli.ts remember --type strategy "提交前先跑 make check，能省一轮 CI"
+node packages/cli/src/cli.ts context --query "要不要先跑测试"
+node packages/cli/src/cli.ts demo          # 起一个 soul，跑完整 context→observe→reflect→context
+```
+
+不需要模型、不需要网络、不需要数据库服务。
+
+## 架构
+
+```
+宿主（Claude Code / Pi / DSH / Cursor / Codex）
+        │ hooks + MCP
+        ▼
+packages/core   人格状态 · 评分 · 注入 · 反思   （约 800 行，零依赖）
+        │
+        ▼
+SQLite（默认） / Postgres（可选）
+```
+
+- **人格状态**（身份 / 情绪 / 策略 / 关系 / 特质）：结构化、量小，SQL 就够
+- **内容记忆**（对话片段 / 文档）：v0 用关键词检索，之后可换成向量或外部服务
+
+详见 [docs/architecture.md](docs/architecture.md)。
+
+## 设计文档
+
+| 文档 | 内容 |
+|---|---|
+| [thesis](docs/thesis.md) | 核心命题、三条可证伪预测、四臂实验、放弃条件 |
+| [RFC 0001](docs/rfcs/0001-foundations.md) | 定位、用户、非目标、成功指标、四个动词、接入阶梯 |
+| [ADR 索引](docs/rfcs/README.md) | 11 条已生效的架构决定（定位/语言/存储/依赖/协议/许可/接入/范围/评估/质量） |
+| [protocol.v0](docs/spec/protocol.v0.md) | 四个动词的完整契约：字段、错误码、降级、测试映射 |
+| [quality](docs/quality.md) | 质量模型、九条门禁、五条评审清单 |
+| [references](docs/references.md) | 外部资料的去留与过期判断 |
+
+**规则**：架构级改动必须先有 RFC 或 ADR；聊天里达成的不算决定。
+
+## 为什么值得做
+
+见 [docs/thesis.md](docs/thesis.md)：核心命题、三条可证伪预测、四臂实验设计。
+如果实验否定它，这个项目就该停——**先定好什么情况下放弃，再开始写代码。**
+
+## 隐私
+
+- 默认 SQLite，落在 `~/.soulbridge/soul.db`
+- 零遥测、零上报
+- 记忆可导出、可删除、可迁移
+
+## License
+
+[Apache-2.0](LICENSE) —— 含明确专利授权，便于企业采用。第三方声明见 [NOTICE](NOTICE)。
+
+本项目不捆绑任何第三方源码。未来若引入词库等外部资产，必须单独核查许可（[ADR 0006](docs/adr/0006-licensing.md)）。

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "soulbridge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "A personality layer for any agent: continuity, forgetting, and growth across tools.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "soulbridge": "packages/cli/src/cli.ts"
+  },
+  "files": [
+    "packages/core/src",
+    "packages/cli/src",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "workspaces": [
+    "packages/*"
+  ],
+  "engines": {
+    "node": ">=22.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jason0826/soulbridge.git"
+  },
+  "homepage": "https://github.com/Jason0826/soulbridge#readme",
+  "bugs": {
+    "url": "https://github.com/Jason0826/soulbridge/issues"
+  },
+  "keywords": [
+    "ai-agent",
+    "memory",
+    "personality",
+    "continuity",
+    "mcp",
+    "claude-code"
+  ],
+  "scripts": {
+    "test": "node --test \"packages/core/test/*.test.ts\"",
+    "demo": "node packages/cli/src/cli.ts demo",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm test"
+  }
+}

package/packages/cli/src/cli.ts

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * Minimal CLI. No framework, no dependencies.
+ *
+ *   soulbridge init
+ *   soulbridge remember "以后提交前先跑 make check" --type strategy --importance 8
+ *   soulbridge context --query "提交前要做什么"
+ *   soulbridge recall "测试"
+ *   soulbridge reflect --text "..."      (or --file transcript.txt)
+ *   soulbridge stats
+ *   soulbridge demo
+ */
+import { mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import type { MemoryType, Turn } from '../../core/src/index.ts';
+import type { Soul as SoulType } from '../../core/src/index.ts';
+
+// node:sqlite prints an ExperimentalWarning the moment it loads. Replace the default
+// printer with a filter: the CLI's own output stays clean, other warnings still show.
+// Must run before the dynamic import below, which is why that import is dynamic.
+process.removeAllListeners('warning');
+process.on('warning', (warning) => {
+  if (warning.message.includes('SQLite is an experimental feature')) return;
+  process.stderr.write(`${warning.name}: ${warning.message}\n`);
+});
+
+const { openSqlite, Soul } = await import('../../core/src/index.ts');
+
+interface Parsed {
+  cmd: string;
+  positional: string[];
+  flags: Record<string, string>;
+}
+
+function parse(argv: string[]): Parsed {
+  const [cmd = 'help', ...rest] = argv;
+  const positional: string[] = [];
+  const flags: Record<string, string> = {};
+
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (!arg.startsWith('--')) {
+      positional.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    const next = rest[i + 1];
+    if (next !== undefined && !next.startsWith('--')) {
+      flags[key] = next;
+      i += 1;
+    } else {
+      flags[key] = 'true';
+    }
+  }
+
+  return { cmd, positional, flags };
+}
+
+function dbFile(): string {
+  const file = process.env.SOULBRIDGE_DB ?? resolve(process.cwd(), '.soulbridge', 'soul.db');
+  mkdirSync(dirname(file), { recursive: true });
+  return file;
+}
+
+function open(file?: string, createdAt?: number): { soul: SoulType; file: string } {
+  const target = file ?? dbFile();
+  const store = openSqlite(target);
+  const soul = new Soul({
+    store,
+    soulId: process.env.SOULBRIDGE_SOUL ?? 'xiaoling',
+    userId: process.env.SOULBRIDGE_USER ?? 'local',
+    name: process.env.SOULBRIDGE_NAME ?? '小灵',
+    createdAt,
+  });
+  return { soul, file: target };
+}
+
+function out(value: unknown): void {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+async function demo(): Promise<void> {
+  const dir = resolve(process.cwd(), '.soulbridge');
+  mkdirSync(dir, { recursive: true });
+  const file = resolve(dir, 'demo.db');
+  for (const suffix of ['', '-wal', '-shm']) rmSync(`${file}${suffix}`, { force: true });
+
+  // Backdate the birthday so the demo shows a relationship that has time in it.
+  const seed = openSqlite(file);
+  seed.ensureSoul({ soulId: 'xiaoling', name: '小灵', createdAt: Date.now() - 3 * 86_400_000 });
+  seed.close();
+
+  const soul = new Soul({ store: openSqlite(file), soulId: 'xiaoling', userId: 'demo', name: '小灵' });
+
+  process.stdout.write('=== 第 1 次会话（刚认识，还没有记忆）===\n');
+  process.stdout.write(`${soul.context().text}\n\n`);
+
+  process.stdout.write('=== 会话结束，反思 ===\n');
+  const result = await soul.reflect([
+    { role: 'user', content: '以后提交前先跑 make check，别等 CI 挂了再修' },
+    { role: 'assistant', content: '好，记住了。' },
+    { role: 'user', content: '我喜欢简洁的回答，不要铺垫' },
+    { role: 'user', content: '不对，这个方案是错的' },
+  ]);
+  process.stdout.write(`写入 ${result.memories} 条记忆，情绪 ${JSON.stringify(result.emotion)}\n\n`);
+
+  process.stdout.write('=== 第 2 次会话：开场（无查询，按重要度注入全部）===\n');
+  process.stdout.write(`${soul.context().text}\n\n`);
+
+  process.stdout.write('=== 同一会话中，用户问「提交前要做什么」（有查询，只注入相关的）===\n');
+  process.stdout.write(`${soul.context({ query: '提交前要做什么' }).text}\n\n`);
+
+  process.stdout.write('=== stats ===\n');
+  out(soul.stats());
+  process.stdout.write(`\n数据库：${file}\n`);
+}
+
+async function main(): Promise<void> {
+  const { cmd, positional, flags } = parse(process.argv.slice(2));
+
+  switch (cmd) {
+    case 'init': {
+      const { soul, file } = open();
+      out({ ok: true, db: file, ...soul.stats() });
+      return;
+    }
+
+    case 'remember': {
+      const content = positional.join(' ').trim();
+      if (!content) throw new Error('usage: soulbridge remember "内容" [--type T] [--importance N]');
+      const { soul } = open();
+      const id = soul.remember(content, {
+        type: (flags.type as MemoryType | undefined) ?? 'fact',
+        importance: flags.importance ? Number(flags.importance) : undefined,
+      });
+      out({ ok: true, id });
+      return;
+    }
+
+    case 'context': {
+      const { soul } = open();
+      const result = soul.context({
+        query: flags.query,
+        maxChars: flags.max ? Number(flags.max) : undefined,
+      });
+      out(result);
+      return;
+    }
+
+    case 'recall': {
+      const query = positional.join(' ').trim();
+      if (!query) throw new Error('usage: soulbridge recall "查询" [--limit N]');
+      const { soul } = open();
+      const hits = soul.recall(query, flags.limit ? Number(flags.limit) : 5);
+      out(hits.map((h) => ({ id: h.memory.id, type: h.memory.type, content: h.memory.content, score: Number(h.score.toFixed(3)) })));
+      return;
+    }
+
+    case 'observe': {
+      const content = positional.join(' ').trim();
+      if (!content) throw new Error('usage: soulbridge observe "一句话"');
+      const { soul } = open();
+      out(soul.observe({ role: 'user', content }));
+      return;
+    }
+
+    case 'reflect': {
+      const text = flags.file ? readFileSync(flags.file, 'utf8') : (flags.text ?? '');
+      if (!text.trim()) throw new Error('usage: soulbridge reflect --text "..." | --file transcript.txt');
+      const turns: Turn[] = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+          const match = line.match(/^(user|assistant|助手|用户)\s*[:：]\s*(.*)$/i);
+          if (!match) return { role: 'user', content: line } as Turn;
+          const role = /^(assistant|助手)$/i.test(match[1]) ? 'assistant' : 'user';
+          return { role, content: match[2] } as Turn;
+        });
+      const { soul } = open();
+      out(await soul.reflect(turns));
+      return;
+    }
+
+    case 'stats': {
+      const { soul, file } = open();
+      out({ db: file, ...soul.stats() });
+      return;
+    }
+
+    case 'demo':
+      await demo();
+      return;
+
+    default:
+      process.stdout.write(
+        [
+          'soulbridge — 给任何 agent 装上一个人格层',
+          '',
+          'commands:',
+          '  init                            初始化数据库',
+          '  remember <text> [--type T]      显式记住一条',
+          '  context [--query Q] [--max N]   生成注入文本',
+          '  recall <q> [--limit N]          召回',
+          '  observe <text>                  观察一轮',
+          '  reflect --text|--file           会话反思',
+          '  stats                           看状态',
+          '  demo                            端到端演示（无需模型）',
+          '',
+          'env: SOULBRIDGE_DB, SOULBRIDGE_SOUL, SOULBRIDGE_USER, SOULBRIDGE_NAME',
+          '',
+        ].join('\n'),
+      );
+  }
+}
+
+main().catch((error: unknown) => {
+  process.stderr.write(`soulbridge: ${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+});