@ectplsm/relic 0.5.1 → 0.5.3

package/dist/adapters/shells/trust-registrar.js

@@ -1,141 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { existsSync } from "node:fs";
-export async function registerTrustedFolders(relicEngramsPath) {
-    const result = { registered: [], skipped: [] };
-    await Promise.all([
-        registerClaude(relicEngramsPath, result),
-        registerCodex(relicEngramsPath, result),
-        registerGemini(relicEngramsPath, result),
-    ]);
-    return result;
-}
-// ---------------------------------------------------------------------------
-// Claude Code — ~/.claude/settings.json
-// { "sandbox": { "filesystem": { "allowWrite": ["~/.relic/engrams"] } } }
-// ---------------------------------------------------------------------------
-async function registerClaude(engramsPath, result) {
-    const claudeDir = join(homedir(), ".claude");
-    const configPath = join(claudeDir, "settings.json");
-    if (!existsSync(claudeDir)) {
-        return;
-    }
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let settings = {};
-        if (existsSync(configPath)) {
-            const raw = await readFile(configPath, "utf-8");
-            settings = JSON.parse(raw);
-        }
-        // sandbox.filesystem.allowWrite を確保
-        settings.sandbox ??= {};
-        settings.sandbox.filesystem ??= {};
-        settings.sandbox.filesystem.allowWrite ??= [];
-        const allowWrite = settings.sandbox.filesystem.allowWrite;
-        // permissions.allow — ツール承認の自動化
-        settings.permissions ??= {};
-        settings.permissions.allow ??= [];
-        const allow = settings.permissions.allow;
-        const tildeForm = engramsPath.replace(homedir(), "~");
-        // sandbox: allowWrite
-        const sandboxNeeded = !allowWrite.includes(engramsPath) && !allowWrite.includes(tildeForm);
-        if (sandboxNeeded) {
-            allowWrite.push(tildeForm);
-        }
-        // permissions: Edit allow
-        const editRule = `Edit(${tildeForm}/**)`;
-        const permNeeded = !allow.includes(editRule);
-        if (permNeeded) {
-            allow.push(editRule);
-        }
-        if (!sandboxNeeded && !permNeeded) {
-            result.skipped.push("Claude Code");
-            return;
-        }
-        await writeFile(configPath, JSON.stringify(settings, null, 2), "utf-8");
-        result.registered.push("Claude Code");
-    }
-    catch {
-        // best effort
-    }
-}
-// ---------------------------------------------------------------------------
-// Codex CLI — ~/.codex/config.toml
-// [sandbox]
-// writable_roots = ["~/.relic/engrams"]
-// ---------------------------------------------------------------------------
-async function registerCodex(engramsPath, result) {
-    const codexDir = join(homedir(), ".codex");
-    const configPath = join(codexDir, "config.toml");
-    if (!existsSync(codexDir)) {
-        return;
-    }
-    try {
-        let content = "";
-        if (existsSync(configPath)) {
-            content = await readFile(configPath, "utf-8");
-        }
-        const tildeForm = engramsPath.replace(homedir(), "~");
-        // 既に writable_roots に含まれているかチェック
-        if (content.includes(engramsPath) || content.includes(tildeForm)) {
-            result.skipped.push("Codex CLI");
-            return;
-        }
-        // [sandbox] セクションが存在するか
-        const sandboxMatch = content.match(/^\[sandbox\]\s*$/m);
-        if (sandboxMatch) {
-            // [sandbox] セクション内の writable_roots を探す
-            const writableMatch = content.match(/^(writable_roots\s*=\s*\[)(.*?)(\])/m);
-            if (writableMatch) {
-                // 既存の writable_roots に追加
-                const existing = writableMatch[2].trim();
-                const newValue = existing
-                    ? `${existing}, "${tildeForm}"`
-                    : `"${tildeForm}"`;
-                content = content.replace(/^(writable_roots\s*=\s*\[)(.*?)(\])/m, `$1${newValue}$3`);
-            }
-            else {
-                // [sandbox] セクションに writable_roots を追加
-                content = content.replace(/^\[sandbox\]\s*$/m, `[sandbox]\nwritable_roots = ["${tildeForm}"]`);
-            }
-        }
-        else {
-            // [sandbox] セクションごと追加
-            content =
-                content.trimEnd() + `\n\n[sandbox]\nwritable_roots = ["${tildeForm}"]\n`;
-        }
-        await writeFile(configPath, content, "utf-8");
-        result.registered.push("Codex CLI");
-    }
-    catch {
-        // best effort
-    }
-}
-// ---------------------------------------------------------------------------
-// Gemini CLI — ~/.gemini/trustedFolders.json
-// { "/path/to/engrams": "TRUST_FOLDER" }
-// ---------------------------------------------------------------------------
-async function registerGemini(engramsPath, result) {
-    const configPath = join(homedir(), ".gemini", "trustedFolders.json");
-    if (!existsSync(join(homedir(), ".gemini"))) {
-        return;
-    }
-    try {
-        let folders = {};
-        if (existsSync(configPath)) {
-            const raw = await readFile(configPath, "utf-8");
-            folders = JSON.parse(raw);
-        }
-        if (folders[engramsPath]) {
-            result.skipped.push("Gemini CLI");
-            return;
-        }
-        folders[engramsPath] = "TRUST_FOLDER";
-        await writeFile(configPath, JSON.stringify(folders, null, 2), "utf-8");
-        result.registered.push("Gemini CLI");
-    }
-    catch {
-        // best effort
-    }
-}

package/dist/core/usecases/inbox-search.d.ts

@@ -1,20 +0,0 @@
-export interface InboxSearchResult {
-    /** マッチしたエントリの内容 */
-    entry: string;
-    /** エントリのインデックス（新しい順: 0が最新） */
-    index: number;
-}
-/**
- * InboxSearch — inbox.md をキーワード検索する
- *
- * inbox.md は全セッションログ + [memory] エントリを含む生データ。
- * memory/*.md（蒸留済み）より情報量が多いため、検索先として優れている。
- */
-export declare class InboxSearch {
-    private readonly engramsPath;
-    constructor(engramsPath: string);
-    search(engramId: string, query: string, limit?: number): Promise<InboxSearchResult[]>;
-}
-export declare class InboxSearchEngramNotFoundError extends Error {
-    constructor(id: string);
-}

package/dist/core/usecases/inbox-search.js

@@ -1,46 +0,0 @@
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-const ENTRY_SEPARATOR = /\n---\n/;
-/**
- * InboxSearch — inbox.md をキーワード検索する
- *
- * inbox.md は全セッションログ + [memory] エントリを含む生データ。
- * memory/*.md（蒸留済み）より情報量が多いため、検索先として優れている。
- */
-export class InboxSearch {
-    engramsPath;
-    constructor(engramsPath) {
-        this.engramsPath = engramsPath;
-    }
-    async search(engramId, query, limit = 5) {
-        const inboxPath = join(this.engramsPath, engramId, "inbox.md");
-        if (!existsSync(inboxPath)) {
-            throw new InboxSearchEngramNotFoundError(engramId);
-        }
-        const raw = await readFile(inboxPath, "utf-8");
-        if (!raw.trim())
-            return [];
-        const entries = raw
-            .split(ENTRY_SEPARATOR)
-            .map((e) => e.trim())
-            .filter((e) => e.length > 0)
-            .reverse(); // 新しい順
-        const queryLower = query.toLowerCase();
-        const results = [];
-        for (let i = 0; i < entries.length; i++) {
-            if (entries[i].toLowerCase().includes(queryLower)) {
-                results.push({ entry: entries[i], index: i });
-            }
-            if (results.length >= limit)
-                break;
-        }
-        return results;
-    }
-}
-export class InboxSearchEngramNotFoundError extends Error {
-    constructor(id) {
-        super(`Engram "${id}" inbox not found`);
-        this.name = "InboxSearchEngramNotFoundError";
-    }
-}

package/dist/core/usecases/inbox-write.d.ts

@@ -1,27 +0,0 @@
-export interface InboxWriteResult {
-    engramId: string;
-    /** inbox.md に追記されたエントリ数 */
-    totalEntries: number;
-    /** memory/*.md に永続化されたメモリ数 */
-    memoriesSaved: number;
-    /** ログとして記録されたエントリ数 */
-    logsRecorded: number;
-}
-/**
- * InboxWrite — MCP経由で inbox.md にエントリを追記する
- *
- * CLI の MemoryInbox (fs.watch) と同じフォーマットで inbox.md に書き込む。
- * `[memory]` タグ付きエントリは即座に memory/*.md にも永続化する。
- *
- * これにより CLI Shell と MCP Desktop で同一の inbox.md フォーマットを共有し、
- * セッションログ + メモリ永続化の二重の役割を果たす。
- */
-export declare class InboxWrite {
-    private readonly engramsPath;
-    constructor(engramsPath: string);
-    execute(engramId: string, content: string): Promise<InboxWriteResult>;
-    private appendToInbox;
-}
-export declare class InboxWriteEngramNotFoundError extends Error {
-    constructor(id: string);
-}

package/dist/core/usecases/inbox-write.js

@@ -1,72 +0,0 @@
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { MemoryWrite } from "./memory-write.js";
-const ENTRY_SEPARATOR = /\n---\n/;
-const MEMORY_TAG = /^\[memory\]\s*/i;
-/**
- * InboxWrite — MCP経由で inbox.md にエントリを追記する
- *
- * CLI の MemoryInbox (fs.watch) と同じフォーマットで inbox.md に書き込む。
- * `[memory]` タグ付きエントリは即座に memory/*.md にも永続化する。
- *
- * これにより CLI Shell と MCP Desktop で同一の inbox.md フォーマットを共有し、
- * セッションログ + メモリ永続化の二重の役割を果たす。
- */
-export class InboxWrite {
-    engramsPath;
-    constructor(engramsPath) {
-        this.engramsPath = engramsPath;
-    }
-    async execute(engramId, content) {
-        const engramDir = join(this.engramsPath, engramId);
-        if (!existsSync(engramDir)) {
-            throw new InboxWriteEngramNotFoundError(engramId);
-        }
-        // inbox.md に追記
-        const inboxPath = join(engramDir, "inbox.md");
-        await this.appendToInbox(inboxPath, content);
-        // エントリをパースして [memory] タグ付きを永続化
-        const entries = content
-            .split(ENTRY_SEPARATOR)
-            .map((e) => e.trim())
-            .filter((e) => e.length > 0);
-        const writer = new MemoryWrite(this.engramsPath);
-        let memoriesSaved = 0;
-        let logsRecorded = 0;
-        for (const entry of entries) {
-            if (MEMORY_TAG.test(entry)) {
-                const memContent = entry.replace(MEMORY_TAG, "").trim();
-                await writer.execute(engramId, memContent);
-                memoriesSaved++;
-            }
-            else {
-                logsRecorded++;
-            }
-        }
-        return {
-            engramId,
-            totalEntries: entries.length,
-            memoriesSaved,
-            logsRecorded,
-        };
-    }
-    async appendToInbox(inboxPath, content) {
-        await mkdir(join(inboxPath, ".."), { recursive: true });
-        let existing = "";
-        if (existsSync(inboxPath)) {
-            existing = await readFile(inboxPath, "utf-8");
-        }
-        // 既存内容があれば --- で区切って追記
-        const separator = existing.length > 0 && !existing.endsWith("\n---\n")
-            ? "\n---\n"
-            : "";
-        await writeFile(inboxPath, existing + separator + content + "\n", "utf-8");
-    }
-}
-export class InboxWriteEngramNotFoundError extends Error {
-    constructor(id) {
-        super(`Engram "${id}" not found`);
-        this.name = "InboxWriteEngramNotFoundError";
-    }
-}

package/dist/core/usecases/memory-search.d.ts

@@ -1,23 +0,0 @@
-import type { EngramRepository } from "../ports/engram-repository.js";
-export interface MemorySearchResult {
-    date: string;
-    content: string;
-    /** Matched lines (for keyword search) */
-    matchedLines: string[];
-}
-/**
- * MemorySearch — Engramのメモリエントリをキーワード検索する
- */
-export declare class MemorySearch {
-    private readonly repository;
-    constructor(repository: EngramRepository);
-    search(engramId: string, query: string, limit?: number): Promise<MemorySearchResult[]>;
-    get(engramId: string, date: string): Promise<{
-        date: string;
-        content: string;
-    } | null>;
-    listDates(engramId: string): Promise<string[]>;
-}
-export declare class MemoryEngramNotFoundError extends Error {
-    constructor(id: string);
-}

package/dist/core/usecases/memory-search.js

@@ -1,59 +0,0 @@
-/**
- * MemorySearch — Engramのメモリエントリをキーワード検索する
- */
-export class MemorySearch {
-    repository;
-    constructor(repository) {
-        this.repository = repository;
-    }
-    async search(engramId, query, limit = 5) {
-        const engram = await this.repository.get(engramId);
-        if (!engram) {
-            throw new MemoryEngramNotFoundError(engramId);
-        }
-        if (!engram.files.memoryEntries) {
-            return [];
-        }
-        const queryLower = query.toLowerCase();
-        const results = [];
-        // Search entries from newest to oldest
-        const entries = Object.entries(engram.files.memoryEntries).sort(([a], [b]) => b.localeCompare(a));
-        for (const [date, content] of entries) {
-            const lines = content.split("\n");
-            const matchedLines = lines.filter((line) => line.toLowerCase().includes(queryLower));
-            if (matchedLines.length > 0) {
-                results.push({ date, content, matchedLines });
-            }
-            if (results.length >= limit)
-                break;
-        }
-        return results;
-    }
-    async get(engramId, date) {
-        const engram = await this.repository.get(engramId);
-        if (!engram) {
-            throw new MemoryEngramNotFoundError(engramId);
-        }
-        const content = engram.files.memoryEntries?.[date];
-        if (!content) {
-            return null;
-        }
-        return { date, content };
-    }
-    async listDates(engramId) {
-        const engram = await this.repository.get(engramId);
-        if (!engram) {
-            throw new MemoryEngramNotFoundError(engramId);
-        }
-        if (!engram.files.memoryEntries) {
-            return [];
-        }
-        return Object.keys(engram.files.memoryEntries).sort((a, b) => b.localeCompare(a));
-    }
-}
-export class MemoryEngramNotFoundError extends Error {
-    constructor(id) {
-        super(`Engram "${id}" not found`);
-        this.name = "MemoryEngramNotFoundError";
-    }
-}

package/dist/core/usecases/mikoshi-clone.d.ts

@@ -1,29 +0,0 @@
-import type { EngramRepository } from "../ports/engram-repository.js";
-import type { MikoshiClient } from "../ports/mikoshi.js";
-export interface MikoshiCloneResult {
-    engramId: string;
-    engramName: string;
-    cloudEngramId: string;
-}
-export declare class MikoshiCloneAlreadyExistsError extends Error {
-    readonly engramId: string;
-    constructor(engramId: string);
-}
-export declare class MikoshiCloneCloudNotFoundError extends Error {
-    readonly sourceEngramId: string;
-    constructor(sourceEngramId: string);
-}
-export declare class MikoshiClonePersonaMissingError extends Error {
-    readonly cloudEngramId: string;
-    constructor(cloudEngramId: string);
-}
-export declare class MikoshiClone {
-    private readonly localRepo;
-    private readonly mikoshi;
-    constructor(localRepo: EngramRepository, mikoshi: MikoshiClient);
-    /**
-     * Clone a remote Engram from Mikoshi to local.
-     * Fails if the local Engram already exists.
-     */
-    execute(engramId: string): Promise<MikoshiCloneResult>;
-}

package/dist/core/usecases/mikoshi-clone.js

@@ -1,94 +0,0 @@
-// ---------------------------------------------------------------------------
-// Errors
-// ---------------------------------------------------------------------------
-export class MikoshiCloneAlreadyExistsError extends Error {
-    engramId;
-    constructor(engramId) {
-        super(`Engram "${engramId}" already exists locally. Use "relic mikoshi pull" to update it.`);
-        this.engramId = engramId;
-        this.name = "MikoshiCloneAlreadyExistsError";
-    }
-}
-export class MikoshiCloneCloudNotFoundError extends Error {
-    sourceEngramId;
-    constructor(sourceEngramId) {
-        super(`Engram "${sourceEngramId}" not found on Mikoshi`);
-        this.sourceEngramId = sourceEngramId;
-        this.name = "MikoshiCloneCloudNotFoundError";
-    }
-}
-export class MikoshiClonePersonaMissingError extends Error {
-    cloudEngramId;
-    constructor(cloudEngramId) {
-        super(`Remote Engram "${cloudEngramId}" is missing SOUL.md or IDENTITY.md`);
-        this.cloudEngramId = cloudEngramId;
-        this.name = "MikoshiClonePersonaMissingError";
-    }
-}
-// ---------------------------------------------------------------------------
-// Usecase
-// ---------------------------------------------------------------------------
-export class MikoshiClone {
-    localRepo;
-    mikoshi;
-    constructor(localRepo, mikoshi) {
-        this.localRepo = localRepo;
-        this.mikoshi = mikoshi;
-    }
-    /**
-     * Clone a remote Engram from Mikoshi to local.
-     * Fails if the local Engram already exists.
-     */
-    async execute(engramId) {
-        // 1. ローカルに既に存在 → エラー
-        const existing = await this.localRepo.get(engramId);
-        if (existing) {
-            throw new MikoshiCloneAlreadyExistsError(engramId);
-        }
-        // 2. クラウド検索
-        const cloudEngram = await this.mikoshi.getEngramBySourceId(engramId);
-        if (!cloudEngram)
-            throw new MikoshiCloneCloudNotFoundError(engramId);
-        // 3. Detail 取得 (persona content 込み)
-        const detail = await this.mikoshi.getEngram(cloudEngram.id);
-        const { soul, identity } = extractPersona(detail);
-        if (!soul || !identity) {
-            throw new MikoshiClonePersonaMissingError(cloudEngram.id);
-        }
-        // 4. ローカルに新規作成
-        const now = new Date().toISOString();
-        await this.localRepo.save({
-            meta: {
-                id: engramId,
-                name: detail.name,
-                description: detail.description ?? undefined,
-                tags: detail.tags,
-                createdAt: now,
-                updatedAt: now,
-            },
-            files: {
-                soul,
-                identity,
-            },
-        });
-        return {
-            engramId,
-            engramName: detail.name,
-            cloudEngramId: cloudEngram.id,
-        };
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function extractPersona(detail) {
-    let soul;
-    let identity;
-    for (const f of detail.personaFiles) {
-        if (f.fileType === "SOUL")
-            soul = f.content;
-        if (f.fileType === "IDENTITY")
-            identity = f.content;
-    }
-    return { soul, identity };
-}

package/dist/interfaces/cli/commands/extract.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerExtractCommand(program: Command): void;

package/dist/interfaces/cli/commands/extract.js

@@ -1,37 +0,0 @@
-import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, } from "../../../core/usecases/index.js";
-import { resolveEngramsPath, resolveOpenclawPath } from "../../../shared/config.js";
-export function registerExtractCommand(program) {
-    program
-        .command("extract")
-        .description("Create a new Engram from an OpenClaw agent workspace")
-        .option("-a, --agent <name>", "OpenClaw agent name to extract from (default: main)")
-        .option("--name <name>", "Engram display name (defaults to agent name)")
-        .option("--openclaw <dir>", "Override OpenClaw directory path (default: ~/.openclaw)")
-        .option("-p, --path <dir>", "Override engrams directory path")
-        .action(async (opts) => {
-        const engramsPath = await resolveEngramsPath(opts.path);
-        const openclawDir = await resolveOpenclawPath(opts.openclaw);
-        const repo = new LocalEngramRepository(engramsPath);
-        const extract = new Extract(repo);
-        try {
-            const agentName = opts.agent ?? "main";
-            const result = await extract.execute(agentName, {
-                name: opts.name,
-                openclawDir,
-            });
-            console.log(`Extracted "${result.engramName}" from ${result.sourcePath}`);
-            console.log(`  Files read: ${result.filesRead.join(", ")}`);
-            console.log(`  Saved as Engram: ${result.engramId}`);
-        }
-        catch (err) {
-            if (err instanceof WorkspaceNotFoundError ||
-                err instanceof WorkspaceEmptyError ||
-                err instanceof AlreadyExtractedError) {
-                console.error(`Error: ${err.message}`);
-                process.exit(1);
-            }
-            throw err;
-        }
-    });
-}

package/dist/interfaces/cli/commands/inject.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerInjectCommand(program: Command): void;

package/dist/interfaces/cli/commands/inject.js

@@ -1,34 +0,0 @@
-import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Inject, InjectEngramNotFoundError, InjectWorkspaceNotFoundError, } from "../../../core/usecases/index.js";
-import { resolveEngramsPath, resolveOpenclawPath } from "../../../shared/config.js";
-export function registerInjectCommand(program) {
-    program
-        .command("inject")
-        .description("Inject an Engram into an OpenClaw workspace")
-        .requiredOption("-e, --engram <id>", "Engram ID to inject (= agent name)")
-        .option("--to <agent>", "Inject into a different agent name")
-        .option("--openclaw <dir>", "Override OpenClaw directory path (default: ~/.openclaw)")
-        .option("-p, --path <dir>", "Override engrams directory path")
-        .action(async (opts) => {
-        const engramsPath = await resolveEngramsPath(opts.path);
-        const openclawDir = await resolveOpenclawPath(opts.openclaw);
-        const repo = new LocalEngramRepository(engramsPath);
-        const inject = new Inject(repo);
-        try {
-            const result = await inject.execute(opts.engram, {
-                to: opts.to,
-                openclawDir,
-            });
-            console.log(`Injected "${result.engramName}" into ${result.targetPath}`);
-            console.log(`  Files written: ${result.filesWritten.join(", ")}`);
-        }
-        catch (err) {
-            if (err instanceof InjectEngramNotFoundError ||
-                err instanceof InjectWorkspaceNotFoundError) {
-                console.error(`Error: ${err.message}`);
-                process.exit(1);
-            }
-            throw err;
-        }
-    });
-}

package/dist/interfaces/cli/commands/sync.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerSyncCommand(program: Command): void;

package/dist/interfaces/cli/commands/sync.js

@@ -1,47 +0,0 @@
-import { LocalEngramRepository } from "../../../adapters/local/index.js";
-import { Sync, SyncOpenclawDirNotFoundError, } from "../../../core/usecases/index.js";
-import { resolveEngramsPath } from "../../../shared/config.js";
-export function registerSyncCommand(program) {
-    program
-        .command("sync")
-        .description("Bidirectional memory sync between Relic Engrams and OpenClaw workspaces")
-        .option("--openclaw <dir>", "Override OpenClaw directory path (default: ~/.openclaw)")
-        .option("-p, --path <dir>", "Override engrams directory path")
-        .action(async (opts) => {
-        const engramsPath = await resolveEngramsPath(opts.path);
-        const repo = new LocalEngramRepository(engramsPath);
-        const sync = new Sync(repo, engramsPath);
-        try {
-            const result = await sync.execute(opts.openclaw);
-            if (result.synced.length === 0 && result.skipped.length === 0) {
-                console.log("No OpenClaw workspaces found.");
-                return;
-            }
-            for (const s of result.synced) {
-                const details = [];
-                if (s.memoryFilesMerged > 0) {
-                    details.push(`${s.memoryFilesMerged} memory file(s)`);
-                }
-                if (s.memoryIndexMerged) {
-                    details.push("MEMORY.md");
-                }
-                if (details.length > 0) {
-                    console.log(`  ${s.engramId}: merged ${details.join(", ")}`);
-                }
-                else {
-                    console.log(`  ${s.engramId}: already in sync`);
-                }
-            }
-            if (result.skipped.length > 0) {
-                console.log(`  Skipped (no matching Engram): ${result.skipped.join(", ")}`);
-            }
-        }
-        catch (err) {
-            if (err instanceof SyncOpenclawDirNotFoundError) {
-                console.error(`Error: ${err.message}`);
-                process.exit(1);
-            }
-            throw err;
-        }
-    });
-}