ui-chan-mcp 0.5.0

package/dist/app/main.js

@@ -0,0 +1,527 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const electron_1 = require("electron");
+const ws_1 = require("ws");
+const paths_1 = require("../shared/paths");
+const set_cue_schema_1 = require("../shared/set-cue-schema");
+const assets_1 = require("./assets");
+const cues_1 = require("./cues");
+const state_1 = require("./state");
+const tts_1 = require("./tts");
+const projectRoot = path.resolve(__dirname, '..', '..');
+// TTS credentials live in .env / env vars (never in the config). The MCP bridge
+// also forwards them on connect; this covers a manually launched `npm run app`.
+(0, paths_1.loadEnvFiles)(projectRoot);
+// Packaged defaults + the user's ~/.ui-chan overrides (see shared/paths.ts).
+const paths = (0, paths_1.resolvePaths)(projectRoot);
+const config = paths.config;
+const port = Number(process.env.UI_CHAN_PORT ?? config.port ?? 8123);
+const cuesDir = paths.cueDirs;
+const cueSchemaPath = paths.cueSchemaFile;
+let cueErrors = [];
+function loadCurrentCues() {
+    const set = (0, cues_1.loadCues)(cuesDir, cueSchemaPath);
+    cueErrors = set.errors;
+    if (config.tts)
+        config.tts.cueVoice = (0, cues_1.extractCueVoice)(set);
+    for (const err of set.errors)
+        console.error(`[ui-chan] cue error: ${err}`);
+    return set.cues;
+}
+let cues = loadCurrentCues();
+let win = null;
+let rendererReady = false;
+let rendererWarnings = [];
+const agents = new Map();
+const pendingCommands = [];
+function findPsd() {
+    return (0, assets_1.findPsd)(paths.assetsDirs);
+}
+function sendToRenderer(cmd) {
+    if (win && rendererReady) {
+        win.webContents.send('ui-chan:command', cmd);
+    }
+    else {
+        pendingCommands.push(cmd);
+    }
+}
+/** The agent ういちゃん last spoke for — "who is she talking to right now",
+ *  which is the question the connections panel exists to answer. */
+let activeAgent = null;
+let nextAgentId = 1;
+/** Is there a newer ui-chan upstream? Checked in a child process because it
+ *  touches the network (git fetch) and must never stall the mascot. Silent on
+ *  every failure — "can't tell" and "up to date" look the same on screen, and
+ *  neither is worth a warning. */
+function checkForUpdate() {
+    const child = (0, node_child_process_1.spawn)(process.execPath, [path.join(projectRoot, 'tools', 'setup', 'update-check.mjs'), projectRoot], { stdio: ['ignore', 'pipe', 'ignore'] });
+    let out = '';
+    child.stdout?.on('data', (d) => {
+        out += d;
+    });
+    child.on('close', () => {
+        try {
+            const st = JSON.parse(out);
+            sendToRenderer({
+                type: 'update',
+                available: Boolean(st.available),
+                behind: st.behind,
+                blocked: st.blocked ?? null,
+            });
+        }
+        catch {
+            /* not a git install, offline, or git missing — say nothing */
+        }
+    });
+    child.on('error', () => {
+        /* no node? impossible here, but never throw from a timer */
+    });
+}
+/** Push the current connection list to the renderer. Called on connect,
+ *  disconnect, and whenever she starts speaking for someone else — the panel
+ *  never polls, so it cannot show a stale session. */
+function sendConnections() {
+    sendToRenderer({ type: 'connections', agents: [...agents.values()], active: activeAgent });
+}
+const tts = config.tts?.enabled ? new tts_1.VoiSonaTalkClient(config.tts) : null;
+/** Voice can be muted from the panel. This silences the *voice* only — the
+ *  bubble still appears, because a mascot that goes completely blank looks
+ *  broken rather than quiet. */
+let muted = false;
+const state = new state_1.UiChanState(config, cues, sendToRenderer, tts
+    ? (text, cue, adlib) => (muted ? Promise.resolve(null) : tts.synthesize(text, cue, adlib))
+    : undefined, 
+// OS-wide "seconds since the user last touched keyboard or mouse" — what lets
+// Idling read the user's presence instead of only its own timers.
+() => electron_1.powerMonitor.getSystemIdleTime());
+/** Setup-level problems the agent can't see from tool results alone (no PSD in
+ *  assets/, TTS on but unusable) surface as warnings so they're diagnosable
+ *  from a single get_state instead of by reading the app's stderr. */
+function setupWarnings(psdFile) {
+    const out = [];
+    if (!psdFile) {
+        out.push(`立ち絵PSDが見つかりません: ${path.join(paths.home, 'assets')} に PSD を置いてください`);
+    }
+    const t = tts?.status();
+    if (t?.enabled && !t.hasCredentials) {
+        out.push(`TTSの資格情報がありません: ${path.join(paths.home, '.env')}（または環境変数）に UI_CHAN_TTS_USERNAME / UI_CHAN_TTS_PASSWORD を設定してください`);
+    }
+    if (t?.enabled && t.hasCredentials && t.engineUnreachable) {
+        out.push(`VoiSona Talk に接続できません (${config.tts?.url}): 起動しているか確認してください`);
+    }
+    return out;
+}
+function buildSnapshot() {
+    const psdFile = findPsd();
+    const { cueWarning, ...rest } = state.snapshot();
+    return {
+        psdLoaded: psdFile !== null && rendererReady,
+        psdFile: psdFile ? path.basename(psdFile) : null,
+        ...rest,
+        connectedAgents: [...agents.values()],
+        availableCues: state.listCues(),
+        tts: tts ? tts.status() : { enabled: false },
+        warnings: [
+            ...setupWarnings(psdFile),
+            ...rendererWarnings,
+            ...cueErrors,
+            ...(cueWarning ? [cueWarning] : []),
+        ],
+        affinity: state.affinitySnapshot(),
+    };
+}
+const toolHandlers = {
+    set_cue: (args, agent) => state.setCue(set_cue_schema_1.setCueArgsSchema.parse(args), agent),
+    get_state: () => buildSnapshot(),
+    clear: () => state.clear(),
+    adjust_affinity: (args) => state.adjustAffinity(String(args.direction), String(args.magnitude)),
+    event_cue: (args) => state.fireEventCue(String(args.event), { force: args.force === true }),
+};
+function handleDebug(_ws, req) {
+    const action = req.debug;
+    if (!action) {
+        return { id: req.id, ok: false, error: 'missing debug action' };
+    }
+    try {
+        switch (action.type) {
+            case 'trigger_idle': {
+                const result = state.triggerIdleAction(action.name);
+                if (!result.ok) {
+                    return { id: req.id, ok: false, error: result.error };
+                }
+                return { id: req.id, ok: true, result };
+            }
+            case 'list_idle': {
+                return { id: req.id, ok: true, result: state.listIdle() };
+            }
+            case 'list_event_cues': {
+                return { id: req.id, ok: true, result: state.listEventCues() };
+            }
+            case 'trigger_event': {
+                // force: the dev asked for this one, so skip cooldown/chance — but the
+                // affinity and time gates still apply, so what you see could really play.
+                const result = state.fireEventCue(action.event, { force: true });
+                if (!result.ok)
+                    return { id: req.id, ok: false, error: result.error };
+                return { id: req.id, ok: true, result };
+            }
+            case 'preview_cue': {
+                return { id: req.id, ok: true, result: state.previewCue(action.cue) };
+            }
+            case 'set_affinity': {
+                const result = state.setAffinity(action.value);
+                if (!result.ok) {
+                    return { id: req.id, ok: false, error: result.error };
+                }
+                return { id: req.id, ok: true, result };
+            }
+            case 'interact': {
+                state.onInteraction(action.kind ?? 'poke');
+                return { id: req.id, ok: true, result: { ok: true } };
+            }
+            default: {
+                return { id: req.id, ok: false, error: `unknown debug action` };
+            }
+        }
+    }
+    catch (e) {
+        return { id: req.id, ok: false, error: String(e) };
+    }
+}
+function handleRequest(ws, req) {
+    const agent = agents.get(ws)?.name ?? req.agent ?? 'unknown';
+    try {
+        switch (req.type) {
+            case 'hello': {
+                agents.set(ws, {
+                    id: nextAgentId++,
+                    name: req.agent ?? 'unknown',
+                    connectedAt: new Date().toISOString(),
+                    ...(req.identity ?? {}),
+                });
+                sendConnections();
+                if (exitTimer) {
+                    clearTimeout(exitTimer);
+                    exitTimer = null;
+                }
+                if (req.tts?.username && tts) {
+                    tts.setCredentials(req.tts.username, req.tts.password);
+                }
+                return { id: req.id, ok: true, result: { server: 'ui-chan-mcp' } };
+            }
+            case 'tool': {
+                const handler = req.tool ? toolHandlers[req.tool] : undefined;
+                if (!handler)
+                    return { id: req.id, ok: false, error: `unknown tool: ${req.tool}` };
+                const caller = agents.get(ws)?.id ?? null;
+                if (caller !== null && caller !== activeAgent) {
+                    activeAgent = caller;
+                    sendConnections();
+                }
+                return { id: req.id, ok: true, result: handler(req.args ?? {}, agent) };
+            }
+            case 'debug': {
+                return handleDebug(ws, req);
+            }
+            default:
+                return { id: req.id, ok: false, error: `unknown request type` };
+        }
+    }
+    catch (e) {
+        return { id: req.id, ok: false, error: String(e) };
+    }
+}
+/** Ask the renderer to paint a backdrop and wait for it to have painted.
+ *  Two frames is enough (one to apply, one to render) and is far more reliable
+ *  than a fixed sleep. */
+async function setBackdrop(style) {
+    if (!win || !rendererReady)
+        return;
+    sendToRenderer({ type: 'backdrop', style });
+    await new Promise((r) => setTimeout(r, 120));
+}
+async function handleScreenshot(req) {
+    try {
+        if (!win)
+            return { id: req.id, ok: false, error: 'no window' };
+        const requested = req.args?.path;
+        // Installed globally the package dir is not a sane place to write, so
+        // screenshots land in the user's home dir whenever there is one.
+        const shotRoot = paths.homeExists ? paths.home : projectRoot;
+        const out = path.resolve(shotRoot, typeof requested === 'string' && requested.length > 0 ? requested : 'ui-chan-shot.png');
+        // The WS server only binds 127.0.0.1, but a caller-supplied path could
+        // still try to escape via `..` — keep screenshot writes inside the project.
+        if (out !== shotRoot && !out.startsWith(shotRoot + path.sep)) {
+            return { id: req.id, ok: false, error: `path must stay within ${shotRoot}` };
+        }
+        // `background` is any CSS background value ('#fff', a gradient, …) or the
+        // named presets in the renderer.透過のままだと、白以外の場所に貼った
+        // 瞬間に破綻するので、撮る間だけ背景を敷く。
+        const background = typeof req.args?.background === 'string' ? req.args.background : null;
+        if (background)
+            await setBackdrop(background);
+        try {
+            const image = await win.webContents.capturePage();
+            fs.writeFileSync(out, image.toPNG());
+        }
+        finally {
+            if (background)
+                await setBackdrop(null);
+        }
+        return { id: req.id, ok: true, result: { path: out } };
+    }
+    catch (e) {
+        return { id: req.id, ok: false, error: String(e) };
+    }
+}
+function startWsServer() {
+    const wss = new ws_1.WebSocketServer({ port, host: '127.0.0.1' });
+    wss.on('connection', (ws) => {
+        ws.on('message', (data) => {
+            let req;
+            try {
+                req = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            if (req.type === 'screenshot') {
+                handleScreenshot(req).then((res) => ws.send(JSON.stringify(res)));
+                return;
+            }
+            ws.send(JSON.stringify(handleRequest(ws, req)));
+        });
+        ws.on('close', () => {
+            agents.delete(ws);
+            sendConnections();
+            scheduleExitIfIdle();
+        });
+    });
+    wss.on('error', (err) => {
+        console.error(`[ui-chan] WebSocket server error: ${err.message}`);
+    });
+}
+/**
+ * Quit once nothing is connected any more.
+ *
+ * The app is launched detached (by the MCP server or the SessionStart hook), so
+ * without this it outlives every client and has to be killed by hand from the
+ * repo. Agents are tracked per WebSocket, which makes "is anyone still there?"
+ * exact across windows, apps and other MCP clients alike — and it needs no
+ * cooperation from the client, so a session that dies without a goodbye still
+ * releases her.
+ *
+ * The delay matters: restarting Claude Code drops the socket and reconnects a
+ * few seconds later, and quitting on the gap would make every restart blink the
+ * mascot out of existence. Any reconnection inside the window cancels it.
+ */
+let exitTimer = null;
+function scheduleExitIfIdle() {
+    if (exitTimer) {
+        clearTimeout(exitTimer);
+        exitTimer = null;
+    }
+    const sec = config.exitAfterLastAgentSec ?? 0;
+    if (sec <= 0 || agents.size > 0)
+        return;
+    exitTimer = setTimeout(() => {
+        exitTimer = null;
+        if (agents.size > 0)
+            return; // someone came back while we waited
+        console.error(`[ui-chan] no agents connected for ${sec}s — quitting`);
+        electron_1.app.quit();
+    }, sec * 1000);
+}
+function createWindow() {
+    const { width, height, margin } = config.window;
+    const wa = electron_1.screen.getPrimaryDisplay().workArea;
+    win = new electron_1.BrowserWindow({
+        width,
+        height,
+        x: wa.x + wa.width - width - margin,
+        y: wa.y + wa.height - height - margin,
+        transparent: true,
+        frame: false,
+        resizable: false,
+        hasShadow: false,
+        alwaysOnTop: true,
+        skipTaskbar: true,
+        webPreferences: {
+            preload: path.join(__dirname, 'preload.js'),
+            contextIsolation: true,
+        },
+    });
+    win.setAlwaysOnTop(true, 'floating');
+    win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+    win.loadFile(path.join(projectRoot, 'dist', 'renderer', 'index.html'));
+    win.on('closed', () => {
+        win = null;
+        rendererReady = false;
+    });
+}
+const gotLock = electron_1.app.requestSingleInstanceLock();
+if (!gotLock) {
+    electron_1.app.quit();
+}
+else {
+    electron_1.app.whenReady().then(() => {
+        startWsServer();
+        createWindow();
+        // Once at startup, then every 6 hours: rare enough to be invisible, often
+        // enough that a long-running mascot notices a release.
+        setTimeout(checkForUpdate, 8_000);
+        setInterval(checkForUpdate, 6 * 60 * 60 * 1000);
+        (0, cues_1.watchCues)(cuesDir, () => {
+            cues = loadCurrentCues();
+            state.setCues(cues);
+            console.error('[ui-chan] cues reloaded');
+        });
+    });
+    electron_1.app.on('window-all-closed', () => electron_1.app.quit());
+    /** The panel's buttons. Deliberately few and all reversible-or-obvious:
+     *  anything destructive belongs in the CLI, not in a window that pops open
+     *  on its own. */
+    electron_1.ipcMain.handle('ui-chan:panel-action', (_ev, kind, value) => {
+        switch (kind) {
+            case 'affinity':
+                // The panel is the only place a human can move affinity directly; the
+                // agent's own adjust_affinity stays direction+magnitude, so this can't
+                // be used to sneak past the asymmetric curve on her behalf.
+                if (typeof value === 'number')
+                    state.setAffinity(value);
+                return state.affinitySnapshot();
+            case 'affinity:get':
+                return state.affinitySnapshot();
+            case 'mute':
+                muted = true;
+                return { muted };
+            case 'unmute':
+                muted = false;
+                return { muted };
+            case 'clear':
+                state.clear();
+                return { ok: true };
+            case 'restart':
+                electron_1.app.relaunch();
+                electron_1.app.quit();
+                return { ok: true };
+            case 'update': {
+                // The update rewrites the very files this process is running from, so
+                // it happens in a detached child that outlives us: pull, npm install,
+                // build, then start the app again on the new build.
+                const child = (0, node_child_process_1.spawn)(path.join(projectRoot, 'bin', 'ui-chan-node'), [path.join(projectRoot, 'bin', 'ui-chan.mjs'), 'update'], { detached: true, stdio: 'ignore' });
+                child.unref();
+                state.setCue({
+                    cue: 'sys_think',
+                    text: '着替えてくる。ちょっと待ってて。',
+                    reading: 'きがえてくる。ちょっとまってて。',
+                }, 'panel');
+                return { ok: true };
+            }
+            case 'quit':
+                // Nothing to coordinate: a bridge only launches the app at its own
+                // startup, so quitting stays quit until a person starts her again.
+                electron_1.app.quit();
+                return { ok: true };
+            default:
+                return { ok: false };
+        }
+    });
+    electron_1.ipcMain.handle('ui-chan:get-init', () => {
+        const psdFile = findPsd();
+        return { config, psdAvailable: psdFile !== null, psdFile };
+    });
+    electron_1.ipcMain.handle('ui-chan:read-psd', () => {
+        const psdFile = findPsd();
+        if (!psdFile)
+            return null;
+        return fs.readFileSync(psdFile);
+    });
+    electron_1.ipcMain.on('ui-chan:ready', () => {
+        rendererReady = true;
+        state.applyVisual();
+        for (const cmd of pendingCommands.splice(0)) {
+            win?.webContents.send('ui-chan:command', cmd);
+        }
+        // The panel is otherwise only fed by *changes*, so a renderer that starts
+        // (or reloads) while nobody is connected would sit there showing neither
+        // rows nor the empty state. Send the current list once it can receive it.
+        sendConnections();
+    });
+    electron_1.ipcMain.on('ui-chan:interaction', (_ev, kind) => {
+        state.onInteraction(kind);
+    });
+    // Manual window drag (we dropped -webkit-app-region:drag so JS can own the
+    // fidget input). While the button is held over her body, the window follows
+    // the cursor at a fixed grab offset.
+    let dragTimer = null;
+    electron_1.ipcMain.on('ui-chan:drag-start', () => {
+        if (!win)
+            return;
+        const start = electron_1.screen.getCursorScreenPoint();
+        const [wx, wy] = win.getPosition();
+        const offX = start.x - wx;
+        const offY = start.y - wy;
+        if (dragTimer)
+            clearInterval(dragTimer);
+        dragTimer = setInterval(() => {
+            if (!win)
+                return;
+            const p = electron_1.screen.getCursorScreenPoint();
+            win.setPosition(p.x - offX, p.y - offY);
+        }, 16);
+    });
+    electron_1.ipcMain.on('ui-chan:drag-end', () => {
+        if (dragTimer) {
+            clearInterval(dragTimer);
+            dragTimer = null;
+        }
+    });
+    electron_1.ipcMain.on('ui-chan:warnings', (_ev, warnings) => {
+        // The renderer reports its full warning set on every applyDirectives()
+        // call (i.e. on every set_cue), which is normally the same set repeated —
+        // only log when it actually changed, or a stuck missing-layer-path
+        // warning would spam stderr on every single tool call.
+        const changed = JSON.stringify(warnings) !== JSON.stringify(rendererWarnings);
+        rendererWarnings = warnings;
+        if (changed && warnings.length > 0) {
+            console.error(`[ui-chan] layer warnings:\n  ${warnings.join('\n  ')}`);
+        }
+    });
+}

package/dist/app/persona.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCueCatalog = buildCueCatalog;
+exports.buildPersonaText = buildPersonaText;
+// The single implementation of "what the character is", as text an AI can read:
+// persona/ui-chan.md + context/*.md + a Cue catalog generated from cues/.
+//
+// It lives here, in compiled code, because three different callers need exactly
+// the same bytes and used to build them separately:
+//   - the MCP server, which ships it as the handshake `instructions` (so any
+//     client — Claude Desktop included — gets the character with the tools) and
+//     as the `persona` prompt (manual reload after editing the files)
+//   - the SessionStart hook, for clients that don't use `instructions`
+//   - anything added later that has to hand the character to a model
+//
+// Keeping one copy is what makes "edit the Markdown, restart, done" true: a
+// second implementation drifts, and the drift is invisible until the mascot
+// behaves differently depending on which door the persona came through.
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const types_1 = require("../shared/types");
+const cues_1 = require("./cues");
+/** Order the taxonomy sections so the catalog reads as layers, not a flat list. */
+const CUE_GROUP_ORDER = ['emo', 'mix', 'self', 'sys', 'pose'];
+const CUE_GROUP_TITLE = {
+    emo: '基本感情 `emo_<系統>_<lo|無印|hi>`（喜/信頼/恐/驚/悲/嫌悪/怒/期待 × 強度）',
+    mix: 'ブレンド `mix_<感情A>_<感情B>`（隣接2感情の混合。名前が構成を表す）',
+    self: '自己意識 `self_<感情>`（照れ/恥/罪悪感/誇り）',
+    sys: 'システム `sys_<機能>`（状態・進行・特殊）',
+    pose: 'ポーズ `pose_<型>`（感情に腕ポーズを重ねた変種）',
+};
+/** The AI-facing Cue catalog, generated fresh from `cues/` on every call — so
+ *  adding a Cue file can never leave a hand-written list out of date. Cues
+ *  marked `internal: true` are excluded: they're IdlingCue building blocks
+ *  (state.ts), not expressions to pick with set_cue. */
+function buildCueCatalog(paths) {
+    const { cues, errors } = (0, cues_1.loadCues)(paths.cueDirs, paths.cueSchemaFile);
+    const groups = new Map();
+    for (const [name, cue] of Object.entries(cues)) {
+        if (cue.internal || name === types_1.DEFAULT_CUE_NAME)
+            continue;
+        const g = name.split('_')[0];
+        const list = groups.get(g) ?? [];
+        list.push([name, cue]);
+        groups.set(g, list);
+    }
+    const keys = [
+        ...CUE_GROUP_ORDER.filter((k) => groups.has(k)),
+        ...[...groups.keys()].filter((k) => !CUE_GROUP_ORDER.includes(k)).sort(),
+    ];
+    const sections = keys.map((k) => {
+        const lines = (groups.get(k) ?? [])
+            .sort(([a], [b]) => a.localeCompare(b)) // by name, not the label-suffixed line
+            .map(([name, cue]) => `- \`${name}\`${cue.label ? `（${cue.label}）` : ''}${cue.description ? ` — ${cue.description}` : ''}`);
+        return `### ${CUE_GROUP_TITLE[k] ?? k}\n${lines.join('\n')}`;
+    });
+    const warning = errors.length > 0 ? `\n\n(cue読み込みエラー: ${errors.join('; ')})` : '';
+    return ('## 利用可能なCue一覧（set_cueのcue引数。cues/から自動生成）\n\n' +
+        'Cue名は構造的：接頭辞が層（emo=基本感情 / mix=ブレンド / self=自己意識 / sys=システム / pose=ポーズ）、' +
+        '強度は `_lo`(弱)/無印/`_hi`(強)。系統から辿って選ぶ。\n\n' +
+        `${sections.join('\n\n')}${warning}`);
+}
+/** persona file + every `context/*.md` in filename order + the Cue catalog.
+ *  Missing pieces degrade to a note rather than throwing: a half-formed persona
+ *  is far better than a mascot that refuses to start. */
+function buildPersonaText(paths) {
+    const parts = [];
+    const personaPath = paths.personaFile;
+    try {
+        parts.push(fs.readFileSync(personaPath, 'utf-8'));
+    }
+    catch {
+        parts.push(`ペルソナファイルが見つかりません: ${personaPath}\nこのパスに人格定義のMarkdownを作成してください。`);
+    }
+    // Filename-keyed across dirs: a `~/.ui-chan/context/SOUL.md` replaces the
+    // packaged one, anything else is appended in filename order.
+    const contextFiles = new Map();
+    for (const dir of paths.contextDirs) {
+        try {
+            for (const file of fs.readdirSync(dir).filter((f) => f.endsWith('.md'))) {
+                contextFiles.set(file, path.join(dir, file));
+            }
+        }
+        catch {
+            /* unreadable context dir — persona file alone still works */
+        }
+    }
+    for (const file of [...contextFiles.keys()].sort()) {
+        try {
+            parts.push(fs.readFileSync(contextFiles.get(file), 'utf-8'));
+        }
+        catch {
+            /* skip a file that vanished mid-build */
+        }
+    }
+    try {
+        parts.push(buildCueCatalog(paths));
+    }
+    catch (e) {
+        parts.push(`Cue一覧の生成に失敗しました: ${e instanceof Error ? e.message : e}`);
+    }
+    return parts.join('\n\n---\n\n');
+}

package/dist/app/preload.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+electron_1.contextBridge.exposeInMainWorld('uiChan', {
+    getInit: () => electron_1.ipcRenderer.invoke('ui-chan:get-init'),
+    readPsd: () => electron_1.ipcRenderer.invoke('ui-chan:read-psd'),
+    ready: () => electron_1.ipcRenderer.send('ui-chan:ready'),
+    reportWarnings: (warnings) => electron_1.ipcRenderer.send('ui-chan:warnings', warnings),
+    onCommand: (cb) => electron_1.ipcRenderer.on('ui-chan:command', (_ev, cmd) => cb(cmd)),
+    interaction: (kind) => electron_1.ipcRenderer.send('ui-chan:interaction', kind),
+    panelAction: (kind, value) => electron_1.ipcRenderer.invoke('ui-chan:panel-action', kind, value),
+    dragStart: () => electron_1.ipcRenderer.send('ui-chan:drag-start'),
+    dragEnd: () => electron_1.ipcRenderer.send('ui-chan:drag-end'),
+});