dayloom 0.1.0-beta.0

package/dist/daily/intent-router.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExplicitDailyAction = parseExplicitDailyAction;
+exports.parseDailyIntent = parseDailyIntent;
+exports.validateDailyIntent = validateDailyIntent;
+exports.effectiveDailyAction = effectiveDailyAction;
+exports.routeDailyIntent = routeDailyIntent;
+exports.fallbackDailyIntent = fallbackDailyIntent;
+const promptpile_loop_1 = require("./promptpile-loop");
+const session_1 = require("./session");
+const ACTIONS = new Set(['continue', 'pending', 'start', 'cancel', 'exit']);
+const MIN_CONFIDENCE = 0.8;
+function parseExplicitDailyAction(input) {
+    const actions = {
+        '/pending': 'pending',
+        '/start': 'start',
+        '/cancel': 'cancel',
+        '/exit': 'exit',
+        '/help': 'help',
+    };
+    return actions[input.trim().toLowerCase()];
+}
+function parseDailyIntent(text) {
+    const match = text.match(/```(?:json\s+)?daily-intent\s*\n([\s\S]*?)```/i);
+    if (!match)
+        throw new Error('Assistant response missing daily-intent JSON block');
+    let parsed;
+    try {
+        parsed = JSON.parse(match[1].trim());
+    }
+    catch (error) {
+        throw new Error(`Failed to parse daily-intent JSON: ${error instanceof Error ? error.message : error}`);
+    }
+    validateDailyIntent(parsed);
+    return parsed;
+}
+function validateDailyIntent(intent) {
+    if (!intent || typeof intent !== 'object' || Array.isArray(intent))
+        throw new Error('Daily intent must be an object');
+    if (!ACTIONS.has(intent.action))
+        throw new Error(`Unsupported daily intent action: ${String(intent.action)}`);
+    if (typeof intent.confidence !== 'number' || !Number.isFinite(intent.confidence) || intent.confidence < 0 || intent.confidence > 1) {
+        throw new Error('Daily intent confidence must be between 0 and 1');
+    }
+    if (typeof intent.reason !== 'string' || !intent.reason.trim())
+        throw new Error('Daily intent reason must be non-empty');
+}
+function effectiveDailyAction(intent) {
+    return intent.confidence >= MIN_CONFIDENCE ? intent.action : 'continue';
+}
+async function routeDailyIntent(input, draft, latestAssistantReply, baseUrl, token, maxToolRounds, keepSession = false) {
+    const session = (0, session_1.createIntentSession)({ input, draft, latestAssistantReply });
+    try {
+        return parseDailyIntent(await (0, promptpile_loop_1.runPromptpileUntilText)(session, baseUrl, token, maxToolRounds, () => undefined, true));
+    }
+    finally {
+        if (keepSession)
+            process.stderr.write(`Daily intent session preserved at: ${session.root}\n`);
+        else
+            (0, session_1.cleanupSession)(session);
+    }
+}
+function fallbackDailyIntent(reason) {
+    return { action: 'continue', confidence: 0, reason };
+}

package/dist/daily/mcp-gateway.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectOrStartGateway = void 0;
+var mcp_gateway_1 = require("../revise/mcp-gateway");
+Object.defineProperty(exports, "connectOrStartGateway", { enumerable: true, get: function () { return mcp_gateway_1.connectOrStartGateway; } });

package/dist/daily/mcp-tools.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAndAssertReadonlyCalls = exports.exportReadonlyTools = exports.executeReadonlyCalls = exports.assertAllowedPlayerContextRoot = void 0;
+var mcp_tools_1 = require("../revise/mcp-tools");
+Object.defineProperty(exports, "assertAllowedPlayerContextRoot", { enumerable: true, get: function () { return mcp_tools_1.assertAllowedWorldRoot; } });
+Object.defineProperty(exports, "executeReadonlyCalls", { enumerable: true, get: function () { return mcp_tools_1.executeReadonlyCalls; } });
+Object.defineProperty(exports, "exportReadonlyTools", { enumerable: true, get: function () { return mcp_tools_1.exportReadonlyTools; } });
+Object.defineProperty(exports, "parseAndAssertReadonlyCalls", { enumerable: true, get: function () { return mcp_tools_1.parseAndAssertReadonlyCalls; } });

package/dist/daily/parse-assistant.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDailyStatus = parseDailyStatus;
+exports.parseDailyPlan = parseDailyPlan;
+exports.stripDailyStatus = stripDailyStatus;
+function extractBlock(text, label) {
+    const m = text.match(new RegExp('```(?:json\\s+)?' + label + '\\s*\\n([\\s\\S]*?)```', 'i'));
+    return m ? m[1].trim() : null;
+}
+function parseDailyStatus(text) {
+    const raw = extractBlock(text, 'daily-status');
+    if (!raw)
+        return undefined;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object')
+        throw new Error('daily-status must be an object');
+    if (typeof parsed.user_intent !== 'string')
+        throw new Error('daily-status user_intent must be a string');
+    for (const key of ['known_context', 'constraints', 'open_questions']) {
+        if (!Array.isArray(parsed[key]) || parsed[key].some(item => typeof item !== 'string'))
+            throw new Error(`daily-status ${key} must be a string array`);
+    }
+    return parsed;
+}
+function parseDailyPlan(text) {
+    const raw = extractBlock(text, 'daily-plan');
+    if (!raw)
+        throw new Error('Assistant response missing daily-plan JSON block');
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse daily-plan JSON: ${err instanceof Error ? err.message : err}`);
+    }
+}
+function stripDailyStatus(text) {
+    return text.replace(/```(?:json\s+)?daily-status\s*\n[\s\S]*?```/gi, '').trim();
+}

package/dist/daily/parse-payload.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDailyPlan = readDailyPlan;
+const fs_1 = __importDefault(require("fs"));
+function readDailyPlan(filePath) {
+    return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+}

package/dist/daily/player-context.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlayerContext = buildPlayerContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function buildPlayerContext(worldRoot, outputRoot) {
+    fs_1.default.rmSync(outputRoot, { recursive: true, force: true });
+    fs_1.default.mkdirSync(outputRoot, { recursive: true });
+    copyDirFiles(worldRoot, outputRoot, 'canon', ['premise.md', 'rules.md', 'style.md', 'user_role.md']);
+    copyProtagonist(worldRoot, outputRoot);
+    copyKnownCharacters(worldRoot, outputRoot);
+    copyKnownScenes(worldRoot, outputRoot);
+    copyDirFiles(worldRoot, outputRoot, 'memory', ['short_term.md', 'long_term.md', 'facts.yaml']);
+    writeRecentHistory(worldRoot, outputRoot);
+    return { root: outputRoot };
+}
+function copyProtagonist(worldRoot, outputRoot) {
+    const id = findProtagonistId(worldRoot);
+    const base = path_1.default.join(worldRoot, 'characters', id);
+    const chunks = [`# Protagonist\n\nID: ${id}\n`];
+    for (const file of ['profile.md', 'memory.md', 'timeline.md']) {
+        const filePath = path_1.default.join(base, file);
+        if (fs_1.default.existsSync(filePath))
+            chunks.push(`\n## ${file}\n\n${fs_1.default.readFileSync(filePath, 'utf8')}`);
+    }
+    writeFile(path_1.default.join(outputRoot, 'protagonist.md'), chunks.join('\n'));
+}
+function findProtagonistId(worldRoot) {
+    const charactersDir = path_1.default.join(worldRoot, 'characters');
+    const preferred = path_1.default.join(charactersDir, 'char_protagonist');
+    if (fs_1.default.existsSync(preferred))
+        return 'char_protagonist';
+    if (!fs_1.default.existsSync(charactersDir))
+        return 'char_protagonist';
+    const first = fs_1.default.readdirSync(charactersDir, { withFileTypes: true }).find(entry => entry.isDirectory())?.name;
+    return first ?? 'char_protagonist';
+}
+function copyKnownCharacters(worldRoot, outputRoot) {
+    const charactersDir = path_1.default.join(worldRoot, 'characters');
+    if (!fs_1.default.existsSync(charactersDir))
+        return;
+    for (const entry of fs_1.default.readdirSync(charactersDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const src = path_1.default.join(charactersDir, entry.name, 'profile.md');
+        if (fs_1.default.existsSync(src))
+            copyFile(src, path_1.default.join(outputRoot, 'known-characters', entry.name, 'profile.md'));
+    }
+}
+function copyKnownScenes(worldRoot, outputRoot) {
+    const scenesDir = path_1.default.join(worldRoot, 'scenes');
+    if (!fs_1.default.existsSync(scenesDir))
+        return;
+    for (const entry of fs_1.default.readdirSync(scenesDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const src = path_1.default.join(scenesDir, entry.name, 'profile.md');
+        if (fs_1.default.existsSync(src))
+            copyFile(src, path_1.default.join(outputRoot, 'known-scenes', entry.name, 'profile.md'));
+    }
+}
+function copyDirFiles(worldRoot, outputRoot, relDir, files) {
+    for (const file of files) {
+        const src = path_1.default.join(worldRoot, relDir, file);
+        if (fs_1.default.existsSync(src))
+            copyFile(src, path_1.default.join(outputRoot, relDir, file));
+    }
+}
+function writeRecentHistory(worldRoot, outputRoot) {
+    const daysDir = path_1.default.join(worldRoot, 'days');
+    const lines = ['# Recent History', ''];
+    if (fs_1.default.existsSync(daysDir)) {
+        for (const day of fs_1.default.readdirSync(daysDir).sort().slice(-7)) {
+            const diary = path_1.default.join(daysDir, day, 'diary.md');
+            if (fs_1.default.existsSync(diary))
+                lines.push(`## ${day}`, '', fs_1.default.readFileSync(diary, 'utf8').trim(), '');
+        }
+    }
+    writeFile(path_1.default.join(outputRoot, 'recent-history.md'), `${lines.join('\n').trim()}\n`);
+}
+function copyFile(src, dest) { writeFile(dest, fs_1.default.readFileSync(src, 'utf8')); }
+function writeFile(filePath, content) { fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true }); fs_1.default.writeFileSync(filePath, content, 'utf8'); }

package/dist/daily/project-plan.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectDailyPlan = projectDailyPlan;
+function projectDailyPlan(plan, transcript, lastCommittedDay = 'null') {
+    const dayDir = `days/${plan.day}`;
+    const files = [
+        { relativePath: `${dayDir}/meta.yaml`, content: [`day: ${plan.day}`, 'phase: planned', `created_at: ${new Date().toISOString()}`, ''].join('\n') },
+        { relativePath: `${dayDir}/plan.user.md`, content: `${plan.user_intent.trim()}\n` },
+        { relativePath: `${dayDir}/plan.initial.json`, content: `${JSON.stringify(plan, null, 2)}\n` },
+        { relativePath: 'current.yaml', content: [`day: ${plan.day}`, 'phase: planned', `last_committed_day: ${lastCommittedDay}`, ''].join('\n') },
+    ];
+    if (transcript !== undefined)
+        files.push({ relativePath: `${dayDir}/dialogue/plan-transcript.md`, content: transcript });
+    return files;
+}

package/dist/daily/promptpile-loop.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPromptpileUntilText = runPromptpileUntilText;
+const path_1 = __importDefault(require("path"));
+const bin_resolve_1 = require("../revise/bin-resolve");
+const run_promptpile_with_stream_1 = require("../shared/run-promptpile-with-stream");
+const mcp_tools_1 = require("./mcp-tools");
+const session_1 = require("./session");
+async function runPromptpileUntilText(session, baseUrl, token, maxToolRounds, onDelta = () => undefined, disableTools = false) {
+    for (let round = 0; round <= maxToolRounds; round += 1) {
+        const spawnConfig = (0, bin_resolve_1.getPromptpileSpawnConfig)();
+        const result = await (0, run_promptpile_with_stream_1.runPromptpileWithStream)({
+            command: spawnConfig.command,
+            args: [
+                ...spawnConfig.argvPrefix,
+                '--config', path_1.default.basename(session.promptpileConfig),
+                '-d', 'messages',
+                ...(disableTools ? ['--disable-tool'] : ['--tools-file', path_1.default.basename(session.toolsFile)]),
+                '--continue',
+                '--quiet'
+            ],
+            cwd: session.root,
+            quiet: true,
+            onDelta
+        });
+        if (result.error)
+            throw new Error('Failed to run ' + spawnConfig.displayName + ': ' + result.error.message);
+        if (result.status !== 0)
+            throw new Error('promptpile exited with code ' + result.status + ': ' + result.stderr.trim().slice(-500));
+        const callsFile = (0, session_1.getLatestCallsFile)(session.messagesDir);
+        if (!callsFile)
+            return (0, session_1.getLatestAssistantText)(session.messagesDir);
+        if (round === maxToolRounds)
+            throw new Error('AI exceeded the tool-call limit (' + maxToolRounds + ') for this turn');
+        await (0, mcp_tools_1.executeReadonlyCalls)(baseUrl, token, callsFile);
+    }
+    throw new Error('Unexpected promptpile loop exit');
+}

package/dist/daily/prompts.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDailyPrompt = loadDailyPrompt;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function loadDailyPrompt(name) {
+    return fs_1.default.readFileSync(path_1.default.resolve(__dirname, '..', '..', 'prompts', `${name}.system.md`), 'utf8');
+}

package/dist/daily/read-user-input.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDailyUserInput = exports.askYesNo = void 0;
+var read_user_input_1 = require("../revise/read-user-input");
+Object.defineProperty(exports, "askYesNo", { enumerable: true, get: function () { return read_user_input_1.askYesNo; } });
+Object.defineProperty(exports, "readDailyUserInput", { enumerable: true, get: function () { return read_user_input_1.readReviseUserInput; } });

package/dist/daily/session.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDailySession = createDailySession;
+exports.createFinalizeSession = createFinalizeSession;
+exports.createIntentSession = createIntentSession;
+exports.emptyDraft = emptyDraft;
+exports.readDraft = readDraft;
+exports.writeDraft = writeDraft;
+exports.cleanupSession = cleanupSession;
+exports.appendUserMessage = appendUserMessage;
+exports.getLatestAssistantText = getLatestAssistantText;
+exports.getLatestCallsFile = getLatestCallsFile;
+exports.buildTranscript = buildTranscript;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+const prompts_1 = require("./prompts");
+const MESSAGE_PATTERN = /^\[(\d+)\](.+)\.(md|json)$/i;
+function promptpileToml() {
+    return `[[llm_api]]
+name = "deepseek"
+model = "deepseek-chat"
+base_url = "https://api.deepseek.com/v1"
+api_key_env = "DEEPSEEK_API_KEY"
+
+[promptpile]
+llm_api = "deepseek"
+dir = "./messages"
+tools_file = "./readonly.tools.toml"
+quiet = true
+`;
+}
+function createDailySession() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-daily-'));
+    const messagesDir = path_1.default.join(root, 'messages');
+    const toolsFile = path_1.default.join(root, 'readonly.tools.toml');
+    const promptpileConfig = path_1.default.join(root, 'promptpile.toml');
+    const draftFile = path_1.default.join(root, 'draft.json');
+    const playerContextRoot = path_1.default.join(root, 'player-context');
+    fs_1.default.mkdirSync(messagesDir, { recursive: true });
+    fs_1.default.writeFileSync(promptpileConfig, promptpileToml(), 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[0]system.md'), (0, prompts_1.loadDailyPrompt)('daily-dialogue'), 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[1]assistant.md'), constants_1.OPENING_ASSISTANT, 'utf8');
+    writeDraft({ root, messagesDir, toolsFile, promptpileConfig, draftFile, playerContextRoot }, emptyDraft());
+    return { root, messagesDir, toolsFile, promptpileConfig, draftFile, playerContextRoot };
+}
+function createFinalizeSession(transcript, draft, day) {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-daily-finalize-'));
+    const messagesDir = path_1.default.join(root, 'messages');
+    const toolsFile = path_1.default.join(root, 'readonly.tools.toml');
+    const promptpileConfig = path_1.default.join(root, 'promptpile.toml');
+    const draftFile = path_1.default.join(root, 'draft.json');
+    const playerContextRoot = path_1.default.join(root, 'player-context');
+    fs_1.default.mkdirSync(messagesDir, { recursive: true });
+    fs_1.default.writeFileSync(promptpileConfig, promptpileToml(), 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[0]system.md'), (0, prompts_1.loadDailyPrompt)('daily-finalize-plan'), 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[1]user.md'), `# Current day\n\n${day}\n\n# Transcript\n\n${transcript}\n\n# Draft\n\n${JSON.stringify(draft, null, 2)}\n`, 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[2]user.md'), '请生成最终 daily-plan。', 'utf8');
+    writeDraft({ root, messagesDir, toolsFile, promptpileConfig, draftFile, playerContextRoot }, draft);
+    return { root, messagesDir, toolsFile, promptpileConfig, draftFile, playerContextRoot };
+}
+function createIntentSession(input) {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-daily-intent-'));
+    const messagesDir = path_1.default.join(root, 'messages');
+    const toolsFile = path_1.default.join(root, 'readonly.tools.toml');
+    const promptpileConfig = path_1.default.join(root, 'promptpile.toml');
+    const draftFile = path_1.default.join(root, 'draft.json');
+    const playerContextRoot = path_1.default.join(root, 'unused-context');
+    fs_1.default.mkdirSync(messagesDir, { recursive: true });
+    fs_1.default.writeFileSync(promptpileConfig, promptpileToml(), 'utf8');
+    fs_1.default.writeFileSync(toolsFile, '', 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[0]system.md'), (0, prompts_1.loadDailyPrompt)('daily-intent-router'), 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[1]user.md'), JSON.stringify({
+        latest_user_input: input.input,
+        current_draft: input.draft,
+        latest_assistant_reply: input.latestAssistantReply,
+    }, null, 2), 'utf8');
+    writeDraft({ root, messagesDir, toolsFile, promptpileConfig, draftFile, playerContextRoot }, input.draft);
+    return { root, messagesDir, toolsFile, promptpileConfig, draftFile, playerContextRoot };
+}
+function emptyDraft() { return { user_intent: '', known_context: [], constraints: [], open_questions: [] }; }
+function readDraft(session) { return JSON.parse(fs_1.default.readFileSync(session.draftFile, 'utf8')); }
+function writeDraft(session, draft) { fs_1.default.writeFileSync(session.draftFile, `${JSON.stringify(draft, null, 2)}\n`, 'utf8'); }
+function cleanupSession(session) { if (fs_1.default.existsSync(session.root))
+    fs_1.default.rmSync(session.root, { recursive: true, force: true }); }
+function appendUserMessage(messagesDir, content) {
+    const indices = scanMessageIndices(messagesDir);
+    const next = indices.length ? Math.max(...indices) + 1 : 0;
+    const filePath = path_1.default.join(messagesDir, `[${next}]user.md`);
+    fs_1.default.writeFileSync(filePath, content, 'utf8');
+    return filePath;
+}
+function getLatestAssistantText(messagesDir) {
+    const files = fs_1.default.readdirSync(messagesDir).filter(name => /^\[\d+\]assistant\.md$/i.test(name)).sort(byMessageIndex);
+    if (!files.length)
+        throw new Error('No assistant message found in daily session');
+    return fs_1.default.readFileSync(path_1.default.join(messagesDir, files[files.length - 1]), 'utf8');
+}
+function getLatestCallsFile(messagesDir) {
+    const files = fs_1.default.readdirSync(messagesDir).filter(name => /^\[\d+\]assistant\.calls\.jsonl$/i.test(name)).sort(byMessageIndex);
+    if (!files.length)
+        return undefined;
+    const latest = path_1.default.join(messagesDir, files[files.length - 1]);
+    return fs_1.default.existsSync(latest.replace(/\.calls\.jsonl$/i, '.result.jsonl')) ? undefined : latest;
+}
+function buildTranscript(messagesDir) {
+    return fs_1.default.readdirSync(messagesDir)
+        .map(name => { const m = name.match(MESSAGE_PATTERN); return m ? { idx: Number(m[1]), role: m[2], content: fs_1.default.readFileSync(path_1.default.join(messagesDir, name), 'utf8') } : null; })
+        .filter((x) => x !== null)
+        .sort((a, b) => a.idx - b.idx || a.role.localeCompare(b.role))
+        .map(x => `## [${x.idx}] ${x.role}\n\n${x.content}`)
+        .join('\n\n');
+}
+function scanMessageIndices(messagesDir) { return fs_1.default.readdirSync(messagesDir).map(name => name.match(/^\[(\d+)\]/)?.[1]).filter((x) => Boolean(x)).map(Number); }
+function byMessageIndex(a, b) { return Number(a.match(/^\[(\d+)\]/)[1]) - Number(b.match(/^\[(\d+)\]/)[1]); }

package/dist/daily/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/daily/validate-plan.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDailyPlan = validateDailyPlan;
+const DAY_ID = /^day_\d{4}$/;
+const BEAT_ID = /^beat_\d{2}$/;
+const FORBIDDEN_KEYS = new Set(['outcome', 'result', 'results', 'reward', 'rewards', 'success', 'failure']);
+function validateDailyPlan(plan, expectedDay) {
+    if (!plan || typeof plan !== 'object')
+        throw new Error('Daily plan must be an object');
+    if (typeof plan.day !== 'string' || !DAY_ID.test(plan.day))
+        throw new Error('Daily plan day must be day_NNNN');
+    if (expectedDay && plan.day !== expectedDay)
+        throw new Error(`Daily plan day mismatch: expected ${expectedDay}, got ${plan.day}`);
+    assertNonEmpty(plan.user_intent, 'Daily plan user_intent');
+    assertStringArray(plan.known_context, 'Daily plan known_context');
+    assertStringArray(plan.constraints, 'Daily plan constraints');
+    assertStringArray(plan.open_questions, 'Daily plan open_questions');
+    if (!Number.isInteger(plan.max_events) || plan.max_events < 1 || plan.max_events > 5)
+        throw new Error('Daily plan max_events must be between 1 and 5');
+    if (!Array.isArray(plan.planned_beats) || plan.planned_beats.length < 1 || plan.planned_beats.length > 5)
+        throw new Error('Daily plan planned_beats must contain 1 to 5 beats');
+    for (const [index, beat] of plan.planned_beats.entries()) {
+        if (!beat || typeof beat !== 'object')
+            throw new Error(`Daily beat ${index} must be an object`);
+        for (const key of Object.keys(beat))
+            if (FORBIDDEN_KEYS.has(key))
+                throw new Error(`Daily beat ${index} contains forbidden result field: ${key}`);
+        if (typeof beat.id !== 'string' || !BEAT_ID.test(beat.id))
+            throw new Error(`Daily beat ${index} id must be beat_NN`);
+        assertNonEmpty(beat.intent, `Daily beat ${index} intent`);
+        if (beat.priority !== 'required' && beat.priority !== 'optional')
+            throw new Error(`Daily beat ${index} priority is invalid`);
+        if (beat.status !== 'tentative')
+            throw new Error(`Daily beat ${index} status must be tentative`);
+        if (beat.depends_on !== undefined)
+            assertStringArray(beat.depends_on, `Daily beat ${index} depends_on`);
+    }
+}
+function assertNonEmpty(value, label) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`${label} must be a non-empty string`);
+}
+function assertStringArray(value, label) {
+    if (!Array.isArray(value) || value.some(item => typeof item !== 'string'))
+        throw new Error(`${label} must be a string array`);
+}

package/dist/i18n/detect.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLocale = detectLocale;
+exports.normalizeLocale = normalizeLocale;
+function detectLocale(argv = process.argv, env = process.env) {
+    return normalizeLocale(readArgLocale(argv) ?? env.DAYLOOM_LANG ?? env.LC_ALL ?? env.LC_MESSAGES ?? env.LANG);
+}
+function normalizeLocale(value) {
+    const normalized = (value ?? '').trim().toLowerCase().replace('_', '-');
+    if (normalized === 'zh' || normalized.startsWith('zh-') || normalized.includes('chinese'))
+        return 'zh';
+    return 'en';
+}
+function readArgLocale(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--lang')
+            return argv[index + 1];
+        if (arg.startsWith('--lang='))
+            return arg.slice('--lang='.length);
+    }
+    return undefined;
+}

package/dist/i18n/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLocale = exports.detectLocale = void 0;
+exports.createTranslator = createTranslator;
+exports.addLangOption = addLangOption;
+const detect_1 = require("./detect");
+const messages_1 = require("./messages");
+function createTranslator(locale = (0, detect_1.detectLocale)()) {
+    return (key, vars) => interpolate(messages_1.messages[locale][key] ?? messages_1.messages.en[key] ?? key, vars);
+}
+function addLangOption(command, t) {
+    return command.option('--lang <locale>', t('cli.lang'));
+}
+var detect_2 = require("./detect");
+Object.defineProperty(exports, "detectLocale", { enumerable: true, get: function () { return detect_2.detectLocale; } });
+Object.defineProperty(exports, "normalizeLocale", { enumerable: true, get: function () { return detect_2.normalizeLocale; } });
+function interpolate(template, vars = {}) {
+    return template.replace(/\{([A-Za-z0-9_]+)\}/g, (match, key) => {
+        const value = vars[key];
+        return value === undefined || value === null ? match : String(value);
+    });
+}