dayloom 0.1.0-beta.0

package/dist/revise/process-run.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcess = runProcess;
+exports.stopChild = stopChild;
+const child_process_1 = require("child_process");
+function runProcess(command, args, options) {
+    return new Promise(resolve => {
+        const stdio = options.outputPile ? ['ignore', 'pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'];
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            stdio: stdio
+        });
+        let stdout = '';
+        let stderr = '';
+        let spawnError;
+        let outputPileError;
+        let resolved = false;
+        const resolveOnce = (result) => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve(result);
+        };
+        child.stdout?.on('data', chunk => {
+            const text = chunk.toString();
+            stdout += text;
+            if (!options.quiet)
+                process.stdout.write(text);
+        });
+        child.stderr?.on('data', chunk => {
+            const text = chunk.toString();
+            stderr += text;
+            if (!options.quiet)
+                process.stderr.write(text);
+        });
+        if (options.outputPile) {
+            const outputStream = child.stdio[options.outputPile.fd];
+            if (!outputStream || typeof outputStream.on !== 'function') {
+                outputPileError = new Error('promptpile output fd ' + options.outputPile.fd + ' was not created');
+                child.kill();
+            }
+            else {
+                outputStream.setEncoding('utf8');
+                outputStream.on('data', chunk => {
+                    try {
+                        options.outputPile?.onData(String(chunk));
+                    }
+                    catch (e) {
+                        outputPileError = e instanceof Error ? e : new Error(String(e));
+                        child.kill();
+                    }
+                });
+                outputStream.on('error', error => {
+                    outputPileError = new Error('promptpile output fd ' + options.outputPile?.fd + ' error: ' + error.message);
+                    child.kill();
+                });
+            }
+        }
+        child.on('error', error => {
+            spawnError = error;
+        });
+        child.on('close', status => {
+            resolveOnce({ status, stdout, stderr, error: outputPileError ?? spawnError });
+        });
+    });
+}
+function stopChild(child) {
+    return new Promise(resolve => {
+        if (child.exitCode !== null || child.signalCode !== null)
+            return resolve();
+        const timer = setTimeout(() => { if (child.exitCode === null)
+            child.kill('SIGKILL'); }, 3000);
+        child.once('close', () => { clearTimeout(timer); resolve(); });
+        child.kill('SIGTERM');
+    });
+}

package/dist/revise/project-payload.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectRevisePayload = projectRevisePayload;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function projectRevisePayload(payload, worldRoot) {
+    const changes = new Map();
+    const characterIds = new Set(readIndexIds(worldRoot, 'characters'));
+    const sceneIds = new Set(readIndexIds(worldRoot, 'scenes'));
+    const put = (relativePath, content) => { changes.set(relativePath, { relativePath, content }); };
+    const putIfMissing = (relativePath, content) => {
+        if (!worldRoot || !fs_1.default.existsSync(path_1.default.join(worldRoot, relativePath)))
+            put(relativePath, content);
+    };
+    for (const operation of payload.operations) {
+        if (operation.op === 'replace_canon') {
+            put(`canon/${operation.section}.md`, operation.content);
+        }
+        else if (operation.op === 'upsert_character') {
+            characterIds.add(operation.id);
+            const dir = `characters/${operation.id}`;
+            put(`${dir}/profile.md`, operation.profileMd);
+            if (operation.relationshipsMd !== undefined)
+                put(`${dir}/relationships.md`, operation.relationshipsMd);
+            else
+                putIfMissing(`${dir}/relationships.md`, '# Relationships\n\n');
+            put(`${dir}/meta.yaml`, entityMetaYaml(operation.id, 'character', operation.meta));
+            putIfMissing(`${dir}/memory.md`, '');
+            putIfMissing(`${dir}/timeline.md`, '');
+        }
+        else if (operation.op === 'upsert_scene') {
+            sceneIds.add(operation.id);
+            const dir = `scenes/${operation.id}`;
+            put(`${dir}/profile.md`, operation.profileMd);
+            put(`${dir}/meta.yaml`, entityMetaYaml(operation.id, 'scene', operation.meta));
+            putIfMissing(`${dir}/memory.md`, '');
+            putIfMissing(`${dir}/triggers.yaml`, 'triggers: []\n');
+            putIfMissing(`${dir}/timeline.md`, '');
+        }
+    }
+    if ([...payload.operations].some(op => op.op === 'upsert_character'))
+        put('characters/index.yaml', yamlIdList('characters', [...characterIds]));
+    if ([...payload.operations].some(op => op.op === 'upsert_scene'))
+        put('scenes/index.yaml', yamlIdList('scenes', [...sceneIds]));
+    return [...changes.values()];
+}
+function readIndexIds(worldRoot, key) {
+    if (!worldRoot)
+        return [];
+    const filePath = path_1.default.join(worldRoot, key, 'index.yaml');
+    if (!fs_1.default.existsSync(filePath))
+        return [];
+    return fs_1.default.readFileSync(filePath, 'utf8').split(/\r?\n/).map(line => line.match(/^\s*-\s+(.+?)\s*$/)?.[1]).filter((id) => Boolean(id)).map(id => id.replace(/^['"]|['"]$/g, ''));
+}
+function yamlIdList(key, ids) { return `${key}:\n${ids.map(id => `  - ${JSON.stringify(id)}`).join('\n')}\n`; }
+function entityMetaYaml(id, type, meta) {
+    const tags = meta?.tags ?? [];
+    return [`id: ${JSON.stringify(id)}`, `type: ${type}`, `status: ${JSON.stringify(meta?.status ?? 'active')}`, tags.length ? `tags:\n${tags.map(tag => `  - ${JSON.stringify(tag)}`).join('\n')}` : 'tags: []', ''].join('\n');
+}

package/dist/revise/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("./bin-resolve");
+const mcp_tools_1 = require("./mcp-tools");
+const session_1 = require("./session");
+const run_promptpile_with_stream_1 = require("../shared/run-promptpile-with-stream");
+async function runPromptpileUntilText(session, baseUrl, token, maxToolRounds, onDelta = () => undefined) {
+    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',
+                '--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/revise/prompts.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRevisePrompt = loadRevisePrompt;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const PROMPTS_DIR = path_1.default.resolve(__dirname, '../../prompts');
+function loadRevisePrompt(name) {
+    const filePath = path_1.default.join(PROMPTS_DIR, `${name}.system.md`);
+    if (!fs_1.default.existsSync(filePath)) {
+        throw new Error(`Prompt not found: ${filePath}`);
+    }
+    return fs_1.default.readFileSync(filePath, 'utf8');
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readReviseUserInput = readReviseUserInput;
+exports.askYesNo = askYesNo;
+const readline_1 = __importDefault(require("readline"));
+async function readReviseUserInput() {
+    while (true) {
+        const text = (await readMultilineInput()).trim();
+        if (text)
+            return text;
+        if (await askYesNo('Empty input. Save draft and exit revise session? (Y/N): '))
+            return undefined;
+    }
+}
+function askYesNo(question) {
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(/^y(es)?$/i.test(answer.trim()));
+        });
+    });
+}
+async function readMultilineInput() {
+    process.stdout.write('\nEnter your message. Finish with Ctrl+Z then Enter (Windows), or Ctrl+D (macOS/Linux).\n');
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    const lines = [];
+    for await (const line of rl)
+        lines.push(line);
+    rl.close();
+    return lines.join('\n');
+}

package/dist/revise/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.createReviseSession = createReviseSession;
+exports.createFinalizeSession = createFinalizeSession;
+exports.scanMessageIndices = scanMessageIndices;
+exports.appendUserMessage = appendUserMessage;
+exports.getLatestAssistantText = getLatestAssistantText;
+exports.getLatestCallsFile = getLatestCallsFile;
+exports.buildTranscript = buildTranscript;
+exports.readDraft = readDraft;
+exports.writeDraft = writeDraft;
+exports.cleanupSession = cleanupSession;
+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 createReviseSession() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-revise-'));
+    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');
+    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.loadRevisePrompt)('revise-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 }, { pending_changes: [] });
+    return { root, messagesDir, toolsFile, promptpileConfig, draftFile };
+}
+function createFinalizeSession(transcript, draft) {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-revise-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');
+    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.loadRevisePrompt)('revise-finalize'), 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[1]user.md'), `# Transcript\n\n${transcript}\n\n# Pending changes\n\n${JSON.stringify(draft, null, 2)}\n`, 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[2]user.md'), '请生成最终 revise-payload。', 'utf8');
+    writeDraft({ root, messagesDir, toolsFile, promptpileConfig, draftFile }, draft);
+    return { root, messagesDir, toolsFile, promptpileConfig, draftFile };
+}
+function scanMessageIndices(messagesDir) {
+    const indices = new Set();
+    for (const name of fs_1.default.readdirSync(messagesDir)) {
+        const m = name.match(MESSAGE_PATTERN);
+        if (m)
+            indices.add(parseInt(m[1], 10));
+    }
+    return [...indices].sort((a, b) => a - b);
+}
+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((a, b) => Number(a.match(/^\[(\d+)\]/)[1]) - Number(b.match(/^\[(\d+)\]/)[1]));
+    if (!files.length)
+        throw new Error('No assistant message found in revise 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((a, b) => Number(a.match(/^\[(\d+)\]/)[1]) - Number(b.match(/^\[(\d+)\]/)[1]));
+    if (!files.length)
+        return undefined;
+    const latest = path_1.default.join(messagesDir, files[files.length - 1]);
+    const result = latest.replace(/\.calls\.jsonl$/i, '.result.jsonl');
+    return fs_1.default.existsSync(result) ? undefined : latest;
+}
+function buildTranscript(messagesDir) {
+    return fs_1.default.readdirSync(messagesDir)
+        .map(name => {
+        const m = name.match(MESSAGE_PATTERN);
+        if (!m)
+            return null;
+        return { idx: Number(m[1]), role: m[2], content: fs_1.default.readFileSync(path_1.default.join(messagesDir, name), 'utf8') };
+    })
+        .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 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 });
+}

package/dist/revise/types.js

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

package/dist/revise/validate-payload.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRevisePayload = validateRevisePayload;
+const CANON_SECTIONS = new Set(['premise', 'rules', 'style', 'user_role']);
+const SNAKE_CASE = /^[a-z][a-z0-9_]*$/;
+function validateRevisePayload(payload) {
+    if (!payload || typeof payload !== 'object')
+        throw new Error('Revise payload must be an object');
+    if (typeof payload.summary !== 'string' || !payload.summary.trim())
+        throw new Error('Revise payload summary must be a non-empty string');
+    if (!Array.isArray(payload.operations) || payload.operations.length === 0)
+        throw new Error('Revise payload operations must be a non-empty array');
+    payload.operations.forEach((operation, index) => {
+        if (!operation || typeof operation !== 'object')
+            throw new Error(`Revise operation ${index} must be an object`);
+        if (operation.op === 'replace_canon') {
+            if (!CANON_SECTIONS.has(operation.section))
+                throw new Error(`Unsupported canon section in operation ${index}: ${String(operation.section)}`);
+            assertNonEmpty(operation.content, `Revise operation ${index} content`);
+            return;
+        }
+        if (operation.op === 'upsert_character' || operation.op === 'upsert_scene') {
+            if (!SNAKE_CASE.test(operation.id))
+                throw new Error(`Invalid entity id in operation ${index}: ${String(operation.id)}`);
+            assertNonEmpty(operation.profileMd, `Revise operation ${index} profileMd`);
+            if (operation.op === 'upsert_character' && operation.relationshipsMd !== undefined)
+                assertNonEmpty(operation.relationshipsMd, `Revise operation ${index} relationshipsMd`);
+            validateMeta(operation.meta, index);
+            return;
+        }
+        throw new Error(`Unsupported revise operation ${index}: ${String(operation.op)}`);
+    });
+}
+function assertNonEmpty(value, label) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`${label} must be non-empty`);
+}
+function validateMeta(meta, index) {
+    if (meta === undefined)
+        return;
+    if (!meta || typeof meta !== 'object' || Array.isArray(meta))
+        throw new Error(`Revise operation ${index} meta must be an object`);
+    if (meta.status !== undefined)
+        assertNonEmpty(meta.status, `Revise operation ${index} meta.status`);
+    if (meta.tags !== undefined && (!Array.isArray(meta.tags) || meta.tags.some(tag => typeof tag !== 'string')))
+        throw new Error(`Revise operation ${index} meta.tags must be strings`);
+}

package/dist/settle/ai.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callSettlementAi = callSettlementAi;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const promptpile_loop_1 = require("../daily/promptpile-loop");
+const session_1 = require("./session");
+async function callSettlementAi(userContent, toolsFile, baseUrl, token, maxToolRounds, keepSession = false) {
+    const prompt = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '..', '..', 'prompts', 'settle.system.md'), 'utf8');
+    const session = (0, session_1.createSettlementSession)(prompt, userContent, toolsFile);
+    try {
+        return await (0, promptpile_loop_1.runPromptpileUntilText)(session, baseUrl, token, maxToolRounds);
+    }
+    finally {
+        if (keepSession)
+            process.stderr.write(`Settlement AI session preserved at: ${session.root}\n`);
+        else
+            (0, session_1.cleanupSettlementSession)(session);
+    }
+}

package/dist/settle/apply.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySettlement = applySettlement;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function applySettlement(worldRoot, proposal, changes, nextDay) {
+    const workRoot = path_1.default.join(worldRoot, '.loom', 'settle-transaction', proposal.day);
+    const stagingRoot = path_1.default.join(workRoot, 'staged');
+    const backupRoot = path_1.default.join(workRoot, 'before');
+    const createdFiles = [];
+    const committedFiles = [];
+    fs_1.default.rmSync(workRoot, { recursive: true, force: true });
+    try {
+        for (const change of changes) {
+            const target = path_1.default.join(worldRoot, change.relativePath);
+            const staged = path_1.default.join(stagingRoot, change.relativePath);
+            fs_1.default.mkdirSync(path_1.default.dirname(staged), { recursive: true });
+            fs_1.default.writeFileSync(staged, change.content, 'utf8');
+            if (fs_1.default.existsSync(target)) {
+                const backup = path_1.default.join(backupRoot, change.relativePath);
+                fs_1.default.mkdirSync(path_1.default.dirname(backup), { recursive: true });
+                fs_1.default.copyFileSync(target, backup);
+            }
+            else
+                createdFiles.push(change.relativePath);
+        }
+        const ordered = [...changes.filter(change => change.relativePath !== 'current.yaml'), ...changes.filter(change => change.relativePath === 'current.yaml')];
+        for (const change of ordered) {
+            commitFile(stagingRoot, worldRoot, change.relativePath);
+            committedFiles.push(change.relativePath);
+        }
+    }
+    catch (error) {
+        rollback(worldRoot, backupRoot, committedFiles, new Set(createdFiles));
+        throw error;
+    }
+    finally {
+        fs_1.default.rmSync(workRoot, { recursive: true, force: true });
+    }
+}
+function commitFile(stagingRoot, worldRoot, relativePath) {
+    const staged = path_1.default.join(stagingRoot, relativePath);
+    const target = path_1.default.join(worldRoot, relativePath);
+    fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
+    fs_1.default.renameSync(staged, target);
+}
+function rollback(worldRoot, backupRoot, committedFiles, createdFiles) {
+    for (const relativePath of committedFiles.reverse()) {
+        const target = path_1.default.join(worldRoot, relativePath);
+        if (createdFiles.has(relativePath))
+            fs_1.default.rmSync(target, { force: true });
+        else
+            fs_1.default.copyFileSync(path_1.default.join(backupRoot, relativePath), target);
+    }
+}

package/dist/settle/context.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSettlementPlayerContext = buildSettlementPlayerContext;
+exports.buildSettlementPromptInput = buildSettlementPromptInput;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const player_context_1 = require("../daily/player-context");
+const TRANSCRIPT_TAIL = 6000;
+function buildSettlementPlayerContext(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.user.md', 'plan.initial.json', 'plan.current.json', 'play.state.json', 'runtime.state.json']) {
+        copyIfExists(path_1.default.join(worldRoot, 'days', day, name), path_1.default.join(today, name));
+    }
+    const eventsSource = path_1.default.join(worldRoot, 'days', day, 'events');
+    const eventsTarget = path_1.default.join(today, 'events');
+    if (!fs_1.default.existsSync(eventsSource))
+        return;
+    for (const eventId of fs_1.default.readdirSync(eventsSource).sort()) {
+        for (const name of ['event.json', 'status.json', 'result.json']) {
+            copyIfExists(path_1.default.join(eventsSource, eventId, name), path_1.default.join(eventsTarget, eventId, name));
+        }
+    }
+}
+function buildSettlementPromptInput(worldRoot, day) {
+    const dayRoot = path_1.default.join(worldRoot, 'days', day);
+    const sections = [
+        section('Current day', day),
+        fileSection('User plan', path_1.default.join(dayRoot, 'plan.user.md')),
+        fileSection('Final plan state', path_1.default.join(dayRoot, 'plan.current.json')),
+        fileSection('Runtime state', path_1.default.join(dayRoot, 'runtime.state.json')),
+        fileSection('Existing short-term memory', path_1.default.join(worldRoot, 'memory', 'short_term.md')),
+        fileSection('Existing unresolved threads', path_1.default.join(worldRoot, 'memory', 'unresolved_threads.yaml')),
+    ];
+    const eventsRoot = path_1.default.join(dayRoot, 'events');
+    if (fs_1.default.existsSync(eventsRoot)) {
+        for (const eventId of fs_1.default.readdirSync(eventsRoot).sort()) {
+            const eventRoot = path_1.default.join(eventsRoot, eventId);
+            const eventParts = [
+                fileSection('Event definition', path_1.default.join(eventRoot, 'event.json')),
+                fileSection('Final status', path_1.default.join(eventRoot, 'status.json')),
+                fileSection('Event result', path_1.default.join(eventRoot, 'result.json')),
+            ];
+            const transcriptPath = path_1.default.join(eventRoot, 'transcript.md');
+            if (fs_1.default.existsSync(transcriptPath)) {
+                const transcript = fs_1.default.readFileSync(transcriptPath, 'utf8');
+                eventParts.push(section('Transcript tail', transcript.slice(-TRANSCRIPT_TAIL)));
+            }
+            sections.push(section(`Event ${eventId}`, eventParts.filter(Boolean).join('\n\n')));
+        }
+    }
+    return sections.filter(Boolean).join('\n\n');
+}
+function copyIfExists(source, target) {
+    if (!fs_1.default.existsSync(source))
+        return;
+    fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
+    fs_1.default.copyFileSync(source, target);
+}
+function fileSection(title, filePath) {
+    return fs_1.default.existsSync(filePath) ? section(title, fs_1.default.readFileSync(filePath, 'utf8')) : '';
+}
+function section(title, content) {
+    return `# ${title}\n\n${content.trim()}`;
+}

package/dist/settle/derive.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProgramSettlementProposal = buildProgramSettlementProposal;
+exports.deriveStatePatch = deriveStatePatch;
+exports.readUnresolvedThreads = readUnresolvedThreads;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function buildProgramSettlementProposal(worldRoot, day, narrative) {
+    return {
+        version: 1,
+        day,
+        summary: narrative.summary.trim(),
+        diary: narrative.diary.trim(),
+        state_patch: deriveStatePatch(worldRoot, day, narrative.summary),
+        next_day_seed: {
+            summary: narrative.next_day_seed.summary.trim(),
+            suggested_intents: narrative.next_day_seed.suggested_intents.map(value => value.trim()),
+            unresolved_threads: readUnresolvedThreads(worldRoot),
+        },
+    };
+}
+function deriveStatePatch(worldRoot, day, summary) {
+    const shortTerm = path_1.default.join(worldRoot, 'memory', 'short_term.md');
+    if (!fs_1.default.existsSync(shortTerm))
+        return [];
+    return [{ op: 'append', path: 'memory/short_term.md', content: `## ${day}\n\n${summary.trim()}` }];
+}
+function readUnresolvedThreads(worldRoot) {
+    const filePath = path_1.default.join(worldRoot, 'memory', 'unresolved_threads.yaml');
+    if (!fs_1.default.existsSync(filePath))
+        return [];
+    const text = fs_1.default.readFileSync(filePath, 'utf8');
+    if (/^threads:\s*\[\s*\]\s*$/m.test(text))
+        return [];
+    const lines = text.split(/\r?\n/);
+    const values = [];
+    for (const line of lines) {
+        const id = line.match(/^\s*-\s+id:\s*(.+?)\s*$/)?.[1]?.trim();
+        if (id) {
+            values.push(unquote(id));
+            continue;
+        }
+        const scalar = line.match(/^\s*-\s+([^:#][^:#]*)\s*$/)?.[1]?.trim();
+        if (scalar)
+            values.push(unquote(scalar));
+    }
+    return [...new Set(values)];
+}
+function unquote(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+        return value.slice(1, -1);
+    return value;
+}