dayloom 0.1.0-beta.0

package/dist/play/event-loop.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPlayLoop = runPlayLoop;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const mcp_gateway_1 = require("../daily/mcp-gateway");
+const mcp_tools_1 = require("../daily/mcp-tools");
+const read_user_input_1 = require("../daily/read-user-input");
+const filtered_stream_output_1 = require("../shared/filtered-stream-output");
+const ai_1 = require("./ai");
+const player_context_1 = require("./player-context");
+const parse_assistant_1 = require("./parse-assistant");
+const state_1 = require("./state");
+const validate_1 = require("./validate");
+const loading_1 = require("../utils/loading");
+async function runPlayLoop(worldRoot, day, options = {}) {
+    if (!process.env.DEEPSEEK_API_KEY?.trim())
+        throw new Error('DEEPSEEK_API_KEY is not set. Play requires an API key.');
+    (0, state_1.initializePlay)(worldRoot, day);
+    const serviceRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-play-service-'));
+    const contextRoot = path_1.default.join(serviceRoot, 'player-context');
+    const toolsFile = path_1.default.join(serviceRoot, 'readonly.tools.toml');
+    let gateway;
+    const maxTools = options.maxToolRounds ?? 8;
+    const maxRounds = options.maxEventRounds ?? 20;
+    try {
+        await (0, loading_1.withLoading)('正在准备游玩上下文...', async (loading) => {
+            (0, player_context_1.buildPlayContext)(worldRoot, day, contextRoot);
+            loading.update('正在启动只读服务...');
+            gateway = await (0, mcp_gateway_1.connectOrStartGateway)(serviceRoot, contextRoot, options.mcpBaseUrl, options.mcpToken);
+            loading.update('正在准备只读工具...');
+            await (0, mcp_tools_1.exportReadonlyTools)(gateway.baseUrl, gateway.token, toolsFile);
+            await (0, mcp_tools_1.assertAllowedPlayerContextRoot)(gateway.baseUrl, gateway.token, contextRoot, serviceRoot);
+        });
+        if (!gateway)
+            throw new Error('Failed to initialize readonly gateway');
+        while (true) {
+            const state = (0, state_1.loadState)(worldRoot, day);
+            const plan = (0, state_1.loadPlan)(worldRoot, day);
+            if (state.step === 'complete' || state.phase === 'settling')
+                return;
+            if (state.step === 'ready') {
+                const beat = (0, state_1.nextExecutableBeat)(plan);
+                if (!beat) {
+                    if (plan.beats.some(b => b.status === 'pending' || b.status === 'active'))
+                        throw new Error('No executable beat; check depends_on references');
+                    (0, state_1.finishPlay)(worldRoot, day, state);
+                    process.stdout.write('All planned events resolved. Day is ready for settlement.\n');
+                    return;
+                }
+                await generate(worldRoot, day, plan, state, beat.id, toolsFile, gateway.baseUrl, gateway.token, maxTools, contextRoot);
+                continue;
+            }
+            if (state.step === 'waiting_user') {
+                const exited = await dialogue(worldRoot, day, state.active_event, toolsFile, gateway.baseUrl, gateway.token, maxTools, maxRounds, contextRoot);
+                if (exited) {
+                    process.stdout.write('Play progress saved.\n');
+                    return;
+                }
+                continue;
+            }
+            if (state.step === 'resolving') {
+                await resolveEvent(worldRoot, day, state.active_event, state.active_beat, toolsFile, gateway.baseUrl, gateway.token, maxTools, contextRoot);
+                continue;
+            }
+            if (state.step === 'replanning') {
+                await replan(worldRoot, day, state.active_event, state.active_beat, toolsFile, gateway.baseUrl, gateway.token, maxTools, contextRoot);
+                continue;
+            }
+            throw new Error('Unsupported play step: ' + state.step);
+        }
+    }
+    finally {
+        if (gateway)
+            await gateway.stop();
+        if (!options.keepSession)
+            fs_1.default.rmSync(serviceRoot, { recursive: true, force: true });
+        else
+            process.stderr.write('Play service session preserved at: ' + serviceRoot + '\n');
+    }
+}
+async function generate(worldRoot, day, plan, state, beatId, tools, base, token, max, context) {
+    const beat = plan.beats.find((b) => b.id === beatId);
+    const id = (0, state_1.eventId)(state.next_event_number);
+    (0, player_context_1.buildPlayContext)(worldRoot, day, context);
+    const reply = await (0, loading_1.withLoading)('正在生成事件...', () => (0, ai_1.callPlayAi)('play-event-generator', '# Event request\n\nEvent ID: ' + id + '\nSource beat: ' + JSON.stringify(beat) + '\nCurrent plan: ' + JSON.stringify(plan, null, 2), tools, base, token, max));
+    const event = (0, parse_assistant_1.parseGeneratedEvent)(reply);
+    (0, validate_1.validateGeneratedEvent)(event, id, beatId);
+    beat.status = 'active';
+    (0, state_1.savePlan)(worldRoot, plan);
+    const dir = (0, state_1.eventRoot)(worldRoot, day, id);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    writeJson(path_1.default.join(dir, 'event.json'), event);
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'transcript.md'), '# ' + event.title + '\n\n' + event.opening + '\n\n' + event.situation + '\n', 'utf8');
+    state.active_event = id;
+    state.active_beat = beatId;
+    state.step = 'waiting_user';
+    (0, state_1.saveState)(worldRoot, state);
+}
+async function dialogue(worldRoot, day, id, tools, base, token, maxTools, maxRounds, context) {
+    const dir = (0, state_1.eventRoot)(worldRoot, day, id);
+    const event = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'event.json'), 'utf8'));
+    let transcript = fs_1.default.readFileSync(path_1.default.join(dir, 'transcript.md'), 'utf8');
+    process.stdout.write('\n--- ' + event.title + ' ---\n\n' + event.opening + '\n\n' + event.situation + '\n');
+    if (event.suggested_actions.length)
+        process.stdout.write(event.suggested_actions.map((x, i) => (i + 1) + '. ' + x).join('\n') + '\n');
+    while (true) {
+        const rounds = (transcript.match(/^## User$/gm) ?? []).length;
+        if (rounds >= maxRounds)
+            throw new Error('Event exceeded max dialogue rounds (' + maxRounds + ')');
+        const input = await (0, read_user_input_1.readDailyUserInput)();
+        if (input === undefined || input === '/exit')
+            return true;
+        if (input === '/status') {
+            process.stdout.write(fs_1.default.readFileSync(path_1.default.join(dir, 'event.json'), 'utf8'));
+            continue;
+        }
+        if (input === '/end-day') {
+            const status = { status: 'resolved', situation: 'The player explicitly ended the day.', needs_user_action: false, resolution_summary: 'The player explicitly ended the current day.', end_day: true };
+            const machine = '```event-status\n' + JSON.stringify(status, null, 2) + '\n```';
+            transcript += '\n## User\n\n/end-day\n\n## Assistant\n\nThe day ends here.\n\n' + machine + '\n';
+            fs_1.default.writeFileSync(path_1.default.join(dir, 'transcript.md'), transcript, 'utf8');
+            writeJson(path_1.default.join(dir, 'status.json'), status);
+            const state = (0, state_1.loadState)(worldRoot, day);
+            state.step = 'resolving';
+            (0, state_1.saveState)(worldRoot, state);
+            return false;
+        }
+        transcript += '\n## User\n\n' + input + '\n';
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'transcript.md'), transcript, 'utf8');
+        (0, player_context_1.buildPlayContext)(worldRoot, day, context);
+        process.stdout.write('\nAI> ');
+        const stream = (0, filtered_stream_output_1.createFilteredStreamOutput)({ hiddenBlocks: ['event-status'] });
+        const reply = await (0, ai_1.callPlayAi)('play-event-dialogue', '# Event\n\n' + JSON.stringify(event, null, 2) + '\n\n# Transcript\n\n' + transcript, tools, base, token, maxTools, text => stream.push(text));
+        stream.flush();
+        process.stdout.write('\n');
+        transcript += '\n## Assistant\n\n' + reply + '\n';
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'transcript.md'), transcript, 'utf8');
+        let status;
+        try {
+            status = (0, parse_assistant_1.parseEventStatus)(reply);
+            (0, validate_1.validateEventStatus)(status);
+        }
+        catch (error) {
+            process.stderr.write('Warning: invalid event-status metadata; continuing the event: ' + (error instanceof Error ? error.message : String(error)) + '\n');
+            continue;
+        }
+        writeJson(path_1.default.join(dir, 'status.json'), status);
+        if (status.status === 'resolved') {
+            const state = (0, state_1.loadState)(worldRoot, day);
+            state.step = 'resolving';
+            (0, state_1.saveState)(worldRoot, state);
+            return false;
+        }
+    }
+}
+async function resolveEvent(worldRoot, day, id, beatId, tools, base, token, max, context) {
+    const dir = (0, state_1.eventRoot)(worldRoot, day, id);
+    const resultFile = path_1.default.join(dir, 'result.json');
+    const plan = (0, state_1.loadPlan)(worldRoot, day);
+    const statusFile = path_1.default.join(dir, 'status.json');
+    const finalStatus = fs_1.default.existsSync(statusFile) ? JSON.parse(fs_1.default.readFileSync(statusFile, 'utf8')) : { status: 'resolved', situation: 'Resolved event', needs_user_action: false, end_day: false, resolution_summary: 'Resolved event' };
+    (0, validate_1.validateEventStatus)(finalStatus);
+    let result;
+    if (fs_1.default.existsSync(resultFile))
+        result = JSON.parse(fs_1.default.readFileSync(resultFile, 'utf8'));
+    else {
+        (0, player_context_1.buildPlayContext)(worldRoot, day, context);
+        const status = JSON.stringify(finalStatus, null, 2);
+        const reply = await (0, loading_1.withLoading)('正在整理事件结果...', () => (0, ai_1.callPlayAi)('play-event-resolver', '# Event\n' + fs_1.default.readFileSync(path_1.default.join(dir, 'event.json'), 'utf8') + '\n# Final event status\n' + status + '\n# Current plan\n' + JSON.stringify(plan, null, 2) + '\n# Transcript\n' + fs_1.default.readFileSync(path_1.default.join(dir, 'transcript.md'), 'utf8'), tools, base, token, max));
+        result = (0, parse_assistant_1.parseEventResult)(reply);
+    }
+    if (finalStatus.end_day)
+        result.end_day = true;
+    (0, validate_1.validateEventResult)(result, id, beatId, plan);
+    writeJson(resultFile, result);
+    const patchFile = path_1.default.join(dir, 'state.patch.json');
+    const appliedFile = path_1.default.join(dir, 'state.patch.applied');
+    if (!fs_1.default.existsSync(patchFile))
+        writeJson(patchFile, result.state_patch);
+    if (!fs_1.default.existsSync(appliedFile)) {
+        (0, state_1.applyEventResult)(worldRoot, day, result);
+        fs_1.default.writeFileSync(appliedFile, new Date().toISOString() + '\n', 'utf8');
+    }
+    const state = (0, state_1.loadState)(worldRoot, day);
+    state.step = 'replanning';
+    (0, state_1.saveState)(worldRoot, state);
+}
+async function replan(worldRoot, day, id, beatId, tools, base, token, max, context) {
+    const dir = (0, state_1.eventRoot)(worldRoot, day, id);
+    const plan = (0, state_1.loadPlan)(worldRoot, day);
+    const result = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, 'result.json'), 'utf8'));
+    (0, validate_1.validateEventResult)(result, id, beatId, plan);
+    const replanFile = path_1.default.join(dir, 'replan.json');
+    let payload;
+    if (result.end_day) {
+        payload = (0, state_1.buildResultReplan)(plan, result);
+    }
+    else {
+        let proposed;
+        if (fs_1.default.existsSync(replanFile))
+            proposed = JSON.parse(fs_1.default.readFileSync(replanFile, 'utf8'));
+        else {
+            (0, player_context_1.buildPlayContext)(worldRoot, day, context);
+            const validBeatIds = plan.beats.map(beat => beat.id);
+            const remainingInsertSlots = Math.max(0, plan.max_events - plan.beats.length);
+            const reply = await (0, loading_1.withLoading)('正在更新后续计划...', () => (0, ai_1.callPlayAi)('play-replanner', '# Replan constraints\nValid existing beat IDs: ' + validBeatIds.join(', ') + '\nRemaining insert slots: ' + remainingInsertSlots + '\ninsert.after may only use a valid existing beat ID. New beat IDs are assigned by the system and cannot be referenced.\n\n# Current plan\n' + JSON.stringify(plan, null, 2) + '\n# Event result\n' + JSON.stringify(result, null, 2), tools, base, token, max));
+            proposed = (0, parse_assistant_1.parseReplan)(reply);
+        }
+        const normalized = (0, validate_1.normalizeReplanPayload)(proposed, plan);
+        for (const warning of normalized.warnings)
+            process.stderr.write('Warning: ' + warning + '\n');
+        payload = (0, state_1.buildResultReplan)(plan, result, normalized.payload);
+    }
+    (0, validate_1.validateReplan)(payload, plan);
+    writeJson(replanFile, payload);
+    const appliedFile = path_1.default.join(dir, 'replan.applied');
+    if (!fs_1.default.existsSync(appliedFile)) {
+        const next = (0, state_1.applyReplan)(plan, payload);
+        for (const beat of next.beats)
+            if (beat.status === 'active')
+                beat.status = 'pending';
+        (0, state_1.savePlan)(worldRoot, next);
+        fs_1.default.writeFileSync(appliedFile, new Date().toISOString() + '\n', 'utf8');
+    }
+    const state = (0, state_1.loadState)(worldRoot, day);
+    if (!state.completed_events.includes(id))
+        state.completed_events.push(id);
+    state.active_event = null;
+    state.active_beat = null;
+    state.next_event_number++;
+    if (result.end_day) {
+        (0, state_1.finishPlay)(worldRoot, day, state);
+        process.stdout.write('Day ended. World is ready for settlement.\n');
+        return;
+    }
+    state.step = 'ready';
+    (0, state_1.saveState)(worldRoot, state);
+}
+function writeJson(file, value) { fs_1.default.writeFileSync(file, JSON.stringify(value, null, 2) + '\n', 'utf8'); }

package/dist/play/guard.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorldRoot = resolveWorldRoot;
+exports.readCurrent = readCurrent;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function resolveWorldRoot(dir) { return path_1.default.resolve(dir); }
+function readCurrent(worldRoot) { const file = path_1.default.join(worldRoot, 'current.yaml'); if (!fs_1.default.existsSync(path_1.default.join(worldRoot, 'manifest.yaml')))
+    throw new Error('World save is not initialized: ' + worldRoot); const text = fs_1.default.readFileSync(file, 'utf8'); const day = text.match(/^day:\s*(\S+)/m)?.[1]; const phase = text.match(/^phase:\s*(\S+)/m)?.[1]; if (!day || !phase)
+    throw new Error('current.yaml missing day or phase'); if (phase !== 'planned' && phase !== 'playing')
+    throw new Error('Play requires current phase planned or playing, got: ' + phase); return { day, phase }; }

package/dist/play/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playInteractive = playInteractive;
+const guard_1 = require("./guard");
+const event_loop_1 = require("./event-loop");
+async function playInteractive(dir, options = {}) { const worldRoot = (0, guard_1.resolveWorldRoot)(dir); const { day } = (0, guard_1.readCurrent)(worldRoot); await (0, event_loop_1.runPlayLoop)(worldRoot, day, options); }
+__exportStar(require("./types"), exports);

package/dist/play/parse-assistant.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReplan = exports.parseEventResult = exports.parseGeneratedEvent = void 0;
+exports.parseEventStatus = parseEventStatus;
+function block(text, label) { const m = text.match(new RegExp('```(?:json\\s+)?' + label + '\\s*\\n([\\s\\S]*?)```', 'i')); if (!m)
+    throw new Error('Assistant response missing ' + label + ' JSON block'); return m[1].trim(); }
+function parse(text, label) { try {
+    return JSON.parse(block(text, label));
+}
+catch (e) {
+    throw new Error('Failed to parse ' + label + ': ' + (e instanceof Error ? e.message : String(e)));
+} }
+const parseGeneratedEvent = (text) => parse(text, 'play-event');
+exports.parseGeneratedEvent = parseGeneratedEvent;
+function parseEventStatus(text) {
+    try {
+        return parse(text, 'event-status');
+    }
+    catch (error) {
+        const raw = block(text, 'event-status');
+        const status = raw.match(/"status"\s*:\s*"(ongoing|resolved)"/)?.[1];
+        const situation = raw.match(/"situation"\s*:\s*"([\s\S]*)"\s*,\s*"needs_user_action"\s*:/)?.[1];
+        const needsUserAction = raw.match(/"needs_user_action"\s*:\s*(true|false)/)?.[1];
+        const resolutionSummary = raw.match(/"resolution_summary"\s*:\s*"([\s\S]*)"\s*[,}]?\s*$/)?.[1];
+        if (!status || situation === undefined || !needsUserAction)
+            throw error;
+        return {
+            status: status,
+            situation,
+            needs_user_action: needsUserAction === 'true',
+            ...(resolutionSummary === undefined ? {} : { resolution_summary: resolutionSummary }),
+            end_day: raw.match(/"end_day"\s*:\s*(true|false)/)?.[1] === 'true'
+        };
+    }
+}
+const parseEventResult = (text) => parse(text, 'event-result');
+exports.parseEventResult = parseEventResult;
+const parseReplan = (text) => parse(text, 'play-replan');
+exports.parseReplan = parseReplan;

package/dist/play/player-context.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlayContext = buildPlayContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const player_context_1 = require("../daily/player-context");
+function buildPlayContext(worldRoot, day, outputRoot) { (0, player_context_1.buildPlayerContext)(worldRoot, outputRoot); const today = path_1.default.join(outputRoot, 'today'); fs_1.default.mkdirSync(today, { recursive: true }); for (const name of ['plan.initial.json', 'plan.current.json', 'play.state.json', 'runtime.state.json']) {
+    const src = path_1.default.join(worldRoot, 'days', day, name);
+    if (fs_1.default.existsSync(src))
+        fs_1.default.copyFileSync(src, path_1.default.join(today, name));
+} const events = path_1.default.join(worldRoot, 'days', day, 'events'); const summaries = []; if (fs_1.default.existsSync(events)) {
+    for (const id of fs_1.default.readdirSync(events).sort()) {
+        const result = path_1.default.join(events, id, 'result.json');
+        if (fs_1.default.existsSync(result))
+            summaries.push(fs_1.default.readFileSync(result, 'utf8'));
+    }
+} fs_1.default.writeFileSync(path_1.default.join(today, 'completed-events.jsonl'), summaries.map(s => JSON.stringify(JSON.parse(s))).join('\n') + (summaries.length ? '\n' : ''), 'utf8'); }

package/dist/play/prompts.js

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

package/dist/play/session.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlayAiSession = createPlayAiSession;
+exports.cleanupPlayAiSession = cleanupPlayAiSession;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const prompts_1 = require("./prompts");
+function config() { return '[[llm_api]]\nname = "deepseek"\nmodel = "deepseek-chat"\nbase_url = "https://api.deepseek.com/v1"\napi_key_env = "DEEPSEEK_API_KEY"\n\n[promptpile]\nllm_api = "deepseek"\ndir = "./messages"\ntools_file = "./readonly.tools.toml"\nquiet = true\n'; }
+function createPlayAiSession(prompt, userContent, toolsSource) { const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-play-')); const messagesDir = path_1.default.join(root, 'messages'); fs_1.default.mkdirSync(messagesDir, { recursive: true }); const session = { root, messagesDir, toolsFile: path_1.default.join(root, 'readonly.tools.toml'), promptpileConfig: path_1.default.join(root, 'promptpile.toml'), draftFile: path_1.default.join(root, 'unused.json'), playerContextRoot: path_1.default.join(root, 'unused-context') }; fs_1.default.writeFileSync(session.promptpileConfig, config(), 'utf8'); fs_1.default.copyFileSync(toolsSource, session.toolsFile); fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[0]system.md'), (0, prompts_1.loadPlayPrompt)(prompt), 'utf8'); fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[1]user.md'), userContent, 'utf8'); return session; }
+function cleanupPlayAiSession(session) { fs_1.default.rmSync(session.root, { recursive: true, force: true }); }

package/dist/play/state.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventRoot = exports.dayRoot = void 0;
+exports.initializePlay = initializePlay;
+exports.loadPlan = loadPlan;
+exports.savePlan = savePlan;
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.nextExecutableBeat = nextExecutableBeat;
+exports.eventId = eventId;
+exports.applyEventResult = applyEventResult;
+exports.buildResultReplan = buildResultReplan;
+exports.applyReplan = applyReplan;
+exports.finishPlay = finishPlay;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dayRoot = (worldRoot, day) => path_1.default.join(worldRoot, 'days', day);
+exports.dayRoot = dayRoot;
+const eventRoot = (worldRoot, day, eventId) => path_1.default.join((0, exports.dayRoot)(worldRoot, day), 'events', eventId);
+exports.eventRoot = eventRoot;
+const planPath = (worldRoot, day) => path_1.default.join((0, exports.dayRoot)(worldRoot, day), 'plan.current.json');
+const statePath = (worldRoot, day) => path_1.default.join((0, exports.dayRoot)(worldRoot, day), 'play.state.json');
+const runtimePath = (worldRoot, day) => path_1.default.join((0, exports.dayRoot)(worldRoot, day), 'runtime.state.json');
+function initializePlay(worldRoot, day) {
+    const initialFile = path_1.default.join((0, exports.dayRoot)(worldRoot, day), 'plan.initial.json');
+    if (!fs_1.default.existsSync(initialFile))
+        throw new Error('Missing daily plan: days/' + day + '/plan.initial.json');
+    if (!fs_1.default.existsSync(planPath(worldRoot, day))) {
+        const initial = JSON.parse(fs_1.default.readFileSync(initialFile, 'utf8'));
+        const plan = { day: initial.day, user_intent: initial.user_intent, revision: 0, max_events: initial.max_events, beats: initial.planned_beats.map(b => ({ ...b, status: 'pending' })) };
+        writeJson(planPath(worldRoot, day), plan);
+    }
+    if (!fs_1.default.existsSync(statePath(worldRoot, day))) {
+        const state = { version: 1, day, phase: 'playing', next_event_number: 1, active_event: null, active_beat: null, step: 'ready', completed_events: [] };
+        writeJson(statePath(worldRoot, day), state);
+    }
+    if (!fs_1.default.existsSync(runtimePath(worldRoot, day)))
+        writeJson(runtimePath(worldRoot, day), {});
+    const phase = loadState(worldRoot, day).phase;
+    setYamlPhase(path_1.default.join(worldRoot, 'current.yaml'), phase);
+    setYamlPhase(path_1.default.join((0, exports.dayRoot)(worldRoot, day), 'meta.yaml'), phase);
+    return { plan: loadPlan(worldRoot, day), state: loadState(worldRoot, day) };
+}
+function loadPlan(worldRoot, day) { return JSON.parse(fs_1.default.readFileSync(planPath(worldRoot, day), 'utf8')); }
+function savePlan(worldRoot, plan) { writeJson(planPath(worldRoot, plan.day), plan); }
+function loadState(worldRoot, day) { return JSON.parse(fs_1.default.readFileSync(statePath(worldRoot, day), 'utf8')); }
+function saveState(worldRoot, state) { writeJson(statePath(worldRoot, state.day), state); }
+function nextExecutableBeat(plan) { const completed = new Set(plan.beats.filter(b => b.status === 'completed').map(b => b.id)); return plan.beats.find(b => b.status === 'pending' && (b.depends_on ?? []).every(id => completed.has(id))); }
+function eventId(number) { return 'event_' + String(number).padStart(3, '0'); }
+function durationMinutes(value) { const hours = value.match(/^(\d+)h$/)?.[1]; if (hours)
+    return Number(hours) * 60; const minutes = value.match(/^(\d+)m$/)?.[1]; return Number(minutes ?? 0); }
+function applyEventResult(worldRoot, day, result) {
+    const runtime = JSON.parse(fs_1.default.readFileSync(runtimePath(worldRoot, day), 'utf8'));
+    for (const p of result.state_patch)
+        runtime[p.key] = p.value;
+    const elapsed = (typeof runtime.day_elapsed_minutes === 'number' ? runtime.day_elapsed_minutes : 0) + durationMinutes(result.time_advanced);
+    runtime.day_elapsed_minutes = elapsed;
+    writeJson(runtimePath(worldRoot, day), runtime);
+    const log = path_1.default.join(worldRoot, 'logs', 'state_changes.jsonl');
+    fs_1.default.appendFileSync(log, JSON.stringify({ type: 'event_resolved', day, event: result.event_id, beat: result.source_beat, summary: result.summary, time_advanced: result.time_advanced, end_day: result.end_day ?? false, completed_beats: result.completed_beats ?? [], cancelled_beats: result.cancelled_beats ?? [], state_patch: result.state_patch }) + '\n', 'utf8');
+}
+function buildResultReplan(plan, result, payload = { operations: [] }) {
+    const completed = new Set(result.completed_beats ?? (result.completed_source_beat === false ? [] : [result.source_beat]));
+    const cancelled = new Set(result.cancelled_beats ?? []);
+    const operations = [];
+    const handled = new Set();
+    for (const beat of plan.beats) {
+        if (beat.status === 'completed' || beat.status === 'cancelled')
+            continue;
+        if (completed.has(beat.id)) {
+            operations.push({ op: 'complete', beat_id: beat.id, reason: 'Completed by event result' });
+            handled.add(beat.id);
+        }
+        else if (cancelled.has(beat.id)) {
+            operations.push({ op: 'cancel', beat_id: beat.id, reason: 'Cancelled by event result' });
+            handled.add(beat.id);
+        }
+        else if (result.end_day) {
+            operations.push({ op: 'cancel', beat_id: beat.id, reason: 'Day ended before this beat was completed' });
+            handled.add(beat.id);
+        }
+    }
+    if (!result.end_day) {
+        for (const op of payload.operations) {
+            if (op.op !== 'insert' && handled.has(op.beat_id))
+                continue;
+            if (op.op !== 'insert')
+                handled.add(op.beat_id);
+            operations.push(op);
+        }
+    }
+    return { operations };
+}
+function applyReplan(plan, payload) { const next = JSON.parse(JSON.stringify(plan)); let counter = Math.max(0, ...next.beats.map(b => Number(b.id.match(/\d+/)?.[0] ?? 0))); for (const op of payload.operations) {
+    if (op.op === 'insert') {
+        counter++;
+        const beat = { id: 'beat_' + String(counter).padStart(2, '0'), intent: op.intent, priority: op.priority, status: 'pending' };
+        const index = op.after ? next.beats.findIndex(b => b.id === op.after) : -1;
+        next.beats.splice(index >= 0 ? index + 1 : next.beats.length, 0, beat);
+        continue;
+    }
+    const beat = next.beats.find(b => b.id === op.beat_id);
+    if (!beat)
+        continue;
+    if (op.op === 'complete')
+        beat.status = 'completed';
+    else if (op.op === 'cancel')
+        beat.status = 'cancelled';
+    else if (op.op === 'modify')
+        beat.intent = op.intent;
+} next.revision++; return next; }
+function finishPlay(worldRoot, day, state) { state.phase = 'settling'; state.step = 'complete'; state.active_event = null; state.active_beat = null; saveState(worldRoot, state); setYamlPhase(path_1.default.join(worldRoot, 'current.yaml'), 'settling'); setYamlPhase(path_1.default.join((0, exports.dayRoot)(worldRoot, day), 'meta.yaml'), 'settling'); }
+function setYamlPhase(file, phase) { let text = fs_1.default.readFileSync(file, 'utf8'); text = /^phase:/m.test(text) ? text.replace(/^phase:.*$/m, 'phase: ' + phase) : text + '\nphase: ' + phase + '\n'; fs_1.default.writeFileSync(file, text, 'utf8'); }
+function writeJson(file, value) { fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true }); const tmp = file + '.tmp'; fs_1.default.writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', 'utf8'); fs_1.default.renameSync(tmp, file); }

package/dist/play/types.js

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

package/dist/play/validate.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGeneratedEvent = validateGeneratedEvent;
+exports.validateEventStatus = validateEventStatus;
+exports.normalizeTimeAdvanced = normalizeTimeAdvanced;
+exports.validateEventResult = validateEventResult;
+exports.normalizeReplanPayload = normalizeReplanPayload;
+exports.validateReplan = validateReplan;
+const ID = /^[a-z][a-z0-9_]*$/;
+const EVENT_ID = /^event_\d{3}$/;
+const TIME = /^\d+(?:m|h)$/;
+function nonEmpty(v, label) { if (typeof v !== 'string' || !v.trim())
+    throw new Error(label + ' must be non-empty'); }
+function strings(v, label) { if (!Array.isArray(v) || v.some(x => typeof x !== 'string'))
+    throw new Error(label + ' must be a string array'); }
+function validateGeneratedEvent(v, expectedEvent, beat) { if (v.id !== expectedEvent || !EVENT_ID.test(v.id))
+    throw new Error('Invalid event id'); if (v.source_beat !== beat)
+    throw new Error('Event source beat mismatch'); nonEmpty(v.title, 'Event title'); nonEmpty(v.opening, 'Event opening'); nonEmpty(v.situation, 'Event situation'); strings(v.suggested_actions, 'Event suggested_actions'); if (v.suggested_actions.length > 5)
+    throw new Error('Event suggested_actions exceeds 5'); for (const key of ['outcome', 'result', 'success', 'failure', 'reward'])
+    if (key in v)
+        throw new Error('Generated event contains forbidden result field: ' + key); }
+function validateEventStatus(v) {
+    if (v.status !== 'ongoing' && v.status !== 'resolved')
+        throw new Error('Invalid event status');
+    nonEmpty(v.situation, 'Event status situation');
+    if (typeof v.needs_user_action !== 'boolean')
+        throw new Error('needs_user_action must be boolean');
+    if (v.end_day === undefined)
+        v.end_day = false;
+    if (typeof v.end_day !== 'boolean')
+        throw new Error('end_day must be boolean');
+    if (v.status === 'resolved')
+        nonEmpty(v.resolution_summary, 'resolution_summary');
+    if (v.end_day && (v.status !== 'resolved' || v.needs_user_action))
+        throw new Error('end_day requires a resolved event without further user action');
+}
+function normalizeTimeAdvanced(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0)
+        return Math.round(value) + 'm';
+    if (typeof value !== 'string')
+        throw new Error('time_advanced must be a duration string or minute count');
+    const compact = value.trim().toLowerCase().replace(/[约大概左右\s]/g, '');
+    if (TIME.test(compact))
+        return compact;
+    const compound = compact.match(/^(?:(\d+(?:\.\d+)?)h(?:ours?)?)?(?:(\d+)m(?:in(?:ute)?s?)?)?$/);
+    if (compound && (compound[1] || compound[2])) {
+        const minutes = Math.round(Number(compound[1] ?? 0) * 60 + Number(compound[2] ?? 0));
+        if (minutes > 0)
+            return minutes + 'm';
+    }
+    const chinese = compact.match(/^(?:(\d+(?:\.\d+)?)小时)?(?:(\d+)分钟)?$/);
+    if (chinese && (chinese[1] || chinese[2])) {
+        const minutes = Math.round(Number(chinese[1] ?? 0) * 60 + Number(chinese[2] ?? 0));
+        if (minutes > 0)
+            return minutes + 'm';
+    }
+    throw new Error('time_advanced must describe a positive duration, such as 30m, 1h30m, or 1小时30分钟');
+}
+function validateEventResult(v, eventId, beatId, plan) {
+    if (v.event_id !== eventId || v.source_beat !== beatId)
+        throw new Error('Event result identity mismatch');
+    nonEmpty(v.summary, 'Event result summary');
+    strings(v.protagonist_learned, 'protagonist_learned');
+    v.time_advanced = normalizeTimeAdvanced(v.time_advanced);
+    if (v.completed_source_beat !== undefined && typeof v.completed_source_beat !== 'boolean')
+        throw new Error('completed_source_beat must be boolean');
+    if (v.completed_beats === undefined)
+        v.completed_beats = v.completed_source_beat === false ? [] : [beatId];
+    if (v.cancelled_beats === undefined)
+        v.cancelled_beats = [];
+    if (v.end_day === undefined)
+        v.end_day = false;
+    strings(v.completed_beats, 'completed_beats');
+    strings(v.cancelled_beats, 'cancelled_beats');
+    if (typeof v.end_day !== 'boolean')
+        throw new Error('end_day must be boolean');
+    v.completed_source_beat = v.completed_beats.includes(beatId);
+    const completed = new Set(v.completed_beats);
+    if (v.cancelled_beats.some(id => completed.has(id)))
+        throw new Error('completed_beats and cancelled_beats overlap');
+    if (plan) {
+        const valid = new Set(plan.beats.map(beat => beat.id));
+        for (const id of [...v.completed_beats, ...v.cancelled_beats])
+            if (!valid.has(id))
+                throw new Error('Unknown beat in event result: ' + id);
+    }
+    if (!Array.isArray(v.state_patch) || v.state_patch.length > 20)
+        throw new Error('Invalid state_patch');
+    for (const patch of v.state_patch) {
+        if (patch.op !== 'set' || !ID.test(patch.key))
+            throw new Error('Invalid runtime patch');
+        if (!['string', 'number', 'boolean'].includes(typeof patch.value) && patch.value !== null)
+            throw new Error('Invalid runtime patch value');
+    }
+}
+function normalizeReplanPayload(v, plan) {
+    if (!Array.isArray(v.operations))
+        return { payload: v, warnings: [] };
+    const validIds = new Set(plan.beats.map(beat => beat.id));
+    let insertSlots = Math.max(0, plan.max_events - plan.beats.length);
+    const warnings = [];
+    const operations = [];
+    for (const original of v.operations) {
+        const op = JSON.parse(JSON.stringify(original));
+        if (op.op !== 'insert') {
+            operations.push(op);
+            continue;
+        }
+        if (insertSlots === 0) {
+            warnings.push('Dropped insert because max_events has no remaining slots');
+            continue;
+        }
+        if (op.after && !validIds.has(op.after)) {
+            warnings.push('Removed unknown insertion anchor ' + op.after + '; appending the beat instead');
+            delete op.after;
+        }
+        operations.push(op);
+        insertSlots--;
+    }
+    return { payload: { operations }, warnings };
+}
+function validateReplan(v, plan) {
+    if (!Array.isArray(v.operations) || v.operations.length > 10)
+        throw new Error('Invalid replan operations');
+    const byId = new Map(plan.beats.map(beat => [beat.id, beat]));
+    const touched = new Set();
+    let inserts = 0;
+    for (const op of v.operations) {
+        if (op.op === 'insert') {
+            nonEmpty(op.intent, 'Inserted beat intent');
+            nonEmpty(op.reason, 'Inserted beat reason');
+            if (op.after && !byId.has(op.after))
+                throw new Error('Unknown insertion anchor: ' + op.after);
+            if (op.priority !== 'required' && op.priority !== 'optional')
+                throw new Error('Invalid inserted beat priority');
+            inserts++;
+            continue;
+        }
+        if (touched.has(op.beat_id))
+            throw new Error('Multiple replan operations for beat: ' + op.beat_id);
+        touched.add(op.beat_id);
+        const beat = byId.get(op.beat_id);
+        if (!beat)
+            throw new Error('Unknown beat in replan: ' + op.beat_id);
+        if (beat.status === 'completed' || beat.status === 'cancelled')
+            throw new Error('Cannot change finished beat: ' + op.beat_id);
+        if (op.op === 'modify') {
+            nonEmpty(op.intent, 'Modified beat intent');
+            nonEmpty(op.reason, 'Modified beat reason');
+        }
+        if (op.op === 'cancel')
+            nonEmpty(op.reason, 'Cancelled beat reason');
+    }
+    if (plan.beats.length + inserts > plan.max_events)
+        throw new Error('Replan exceeds max_events');
+}