dayloom 0.1.0-beta.0

package/dist/revise/apply-payload.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.describeChanges = describeChanges;
+exports.applyChanges = applyChanges;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function describeChanges(worldRoot, changes) {
+    return changes.map(change => {
+        const action = fs_1.default.existsSync(path_1.default.join(worldRoot, change.relativePath)) ? 'update' : 'create';
+        return `${action} ${change.relativePath}`;
+    }).join('\n');
+}
+function applyChanges(worldRoot, payload, changes, now = new Date(), artifacts = {}) {
+    const revisionId = `revision_${formatRevisionTimestamp(now)}`;
+    const revisionRoot = path_1.default.join(worldRoot, '.loom', 'revisions', revisionId);
+    const beforeRoot = path_1.default.join(revisionRoot, 'before');
+    const createdFiles = [];
+    fs_1.default.mkdirSync(beforeRoot, { recursive: true });
+    for (const change of changes) {
+        const filePath = path_1.default.join(worldRoot, change.relativePath);
+        if (fs_1.default.existsSync(filePath)) {
+            const beforePath = path_1.default.join(beforeRoot, change.relativePath);
+            fs_1.default.mkdirSync(path_1.default.dirname(beforePath), { recursive: true });
+            fs_1.default.copyFileSync(filePath, beforePath);
+        }
+        else
+            createdFiles.push(change.relativePath);
+    }
+    fs_1.default.writeFileSync(path_1.default.join(revisionRoot, 'payload.json'), `${JSON.stringify({ ...payload, created_files: createdFiles }, null, 2)}\n`, 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(revisionRoot, 'changes.txt'), `${describeChanges(worldRoot, changes)}\n`, 'utf8');
+    if (artifacts.diff !== undefined)
+        fs_1.default.writeFileSync(path_1.default.join(revisionRoot, 'diff.patch'), artifacts.diff, 'utf8');
+    if (artifacts.draft !== undefined)
+        fs_1.default.writeFileSync(path_1.default.join(revisionRoot, 'draft.json'), `${JSON.stringify(artifacts.draft, null, 2)}\n`, 'utf8');
+    if (artifacts.transcript !== undefined) {
+        const transcriptDir = path_1.default.join(revisionRoot, 'transcript');
+        fs_1.default.mkdirSync(transcriptDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(transcriptDir, 'dialogue.md'), artifacts.transcript, 'utf8');
+    }
+    for (const change of changes) {
+        const filePath = path_1.default.join(worldRoot, change.relativePath);
+        fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+        fs_1.default.writeFileSync(filePath, change.content, 'utf8');
+    }
+    appendStateChange(worldRoot, { type: 'world_revision', revision: revisionId, summary: payload.summary, changed_files: changes.map(change => change.relativePath) });
+    return revisionId;
+}
+function appendStateChange(worldRoot, entry) {
+    const logPath = path_1.default.join(worldRoot, 'logs', 'state_changes.jsonl');
+    fs_1.default.mkdirSync(path_1.default.dirname(logPath), { recursive: true });
+    fs_1.default.appendFileSync(logPath, `${JSON.stringify(entry)}\n`, 'utf8');
+}
+function formatRevisionTimestamp(date) {
+    return date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
+}

package/dist/revise/bin-resolve.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPromptpileSpawnConfig = getPromptpileSpawnConfig;
+exports.getPromptpileMcpSpawnConfig = getPromptpileMcpSpawnConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function nodeScript(script) {
+    return { command: process.execPath, argvPrefix: [script], displayName: `node "${script}"` };
+}
+function getPromptpileSpawnConfig() {
+    const override = process.env.PROMPTPILE_BIN?.trim();
+    if (override)
+        return { command: override, argvPrefix: [], displayName: override };
+    try {
+        const pkg = require.resolve('promptpile/package.json');
+        const script = path_1.default.join(path_1.default.dirname(pkg), 'dist', 'index.js');
+        if (fs_1.default.existsSync(script))
+            return nodeScript(script);
+    }
+    catch { /* fall through */ }
+    return { command: 'promptpile', argvPrefix: [], displayName: 'promptpile' };
+}
+function getPromptpileMcpSpawnConfig() {
+    const override = process.env.PROMPTPILE_MCP_BIN?.trim();
+    if (override)
+        return { command: override, argvPrefix: [], displayName: override };
+    try {
+        const pkg = require.resolve('promptpile-mcp/package.json');
+        const script = path_1.default.join(path_1.default.dirname(pkg), 'dist', 'src', 'index.js');
+        if (fs_1.default.existsSync(script))
+            return nodeScript(script);
+    }
+    catch { /* fall through */ }
+    return { command: 'promptpile-mcp', argvPrefix: [], displayName: 'promptpile-mcp' };
+}

package/dist/revise/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENING_ASSISTANT = exports.READONLY_MCP_TOOL_NAMES = exports.DEFAULT_GATEWAY_TIMEOUT_MS = exports.DEFAULT_MAX_TOOL_ROUNDS = void 0;
+exports.DEFAULT_MAX_TOOL_ROUNDS = 8;
+exports.DEFAULT_GATEWAY_TIMEOUT_MS = 60000;
+exports.READONLY_MCP_TOOL_NAMES = new Set([
+    'mcp__world__list_allowed_directories',
+    'mcp__world__list_directory',
+    'mcp__world__directory_tree',
+    'mcp__world__search_files',
+    'mcp__world__read_text_file',
+    'mcp__world__read_multiple_files',
+    'mcp__world__get_file_info',
+]);
+exports.OPENING_ASSISTANT = `你好，我是 dayloom 的 World 设定维护助手。
+
+你可以询问现有角色、场景和世界设定，也可以告诉我需要怎样修改。每轮可输入多行内容，结束时按 Ctrl+D（macOS/Linux）或 Ctrl+Z 后 Enter（Windows）提交。输入 /pending 查看待修改事项，输入 /apply 生成修改提案，输入 /cancel 放弃退出。`;

package/dist/revise/dialogue-loop.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviseWorldInteractive = reviseWorldInteractive;
+const constants_1 = require("./constants");
+const apply_payload_1 = require("./apply-payload");
+const diff_1 = require("./diff");
+const file_hash_1 = require("./file-hash");
+const finalize_1 = require("./finalize");
+const guard_1 = require("./guard");
+const mcp_gateway_1 = require("./mcp-gateway");
+const mcp_tools_1 = require("./mcp-tools");
+const parse_assistant_1 = require("./parse-assistant");
+const promptpile_loop_1 = require("./promptpile-loop");
+const read_user_input_1 = require("./read-user-input");
+const session_1 = require("./session");
+const project_payload_1 = require("./project-payload");
+const validate_payload_1 = require("./validate-payload");
+const filtered_stream_output_1 = require("../shared/filtered-stream-output");
+const loading_1 = require("../utils/loading");
+async function reviseWorldInteractive(dir, options = {}) {
+    if (!process.env.DEEPSEEK_API_KEY?.trim())
+        throw new Error('DEEPSEEK_API_KEY is not set. Interactive revise requires an API key.');
+    const worldRoot = (0, guard_1.resolveWorldRoot)(dir);
+    (0, guard_1.assertInitializedWorld)(worldRoot);
+    const session = (0, session_1.createReviseSession)();
+    let preserveSession = options.keepSession ?? false;
+    let gateway;
+    const maxToolRounds = options.maxToolRounds ?? constants_1.DEFAULT_MAX_TOOL_ROUNDS;
+    try {
+        await (0, loading_1.withLoading)('正在准备修订会话...', async (loading) => {
+            gateway = await (0, mcp_gateway_1.connectOrStartGateway)(session.root, worldRoot, options.mcpBaseUrl, options.mcpToken);
+            loading.update('正在准备只读工具...');
+            await (0, mcp_tools_1.exportReadonlyTools)(gateway.baseUrl, gateway.token, session.toolsFile);
+            await (0, mcp_tools_1.assertAllowedWorldRoot)(gateway.baseUrl, gateway.token, worldRoot, session.root);
+        });
+        if (!gateway)
+            throw new Error('Failed to initialize readonly gateway');
+        process.stdout.write(`\n--- World revision session ---\n\n${constants_1.OPENING_ASSISTANT}\n`);
+        while (true) {
+            const input = await (0, read_user_input_1.readReviseUserInput)();
+            if (input === undefined) {
+                preserveSession = true;
+                process.stdout.write(`Revision draft saved in session: ${session.root}\n`);
+                return;
+            }
+            if (input === '/help') {
+                process.stdout.write('/pending  /apply  /cancel  /exit\n');
+                continue;
+            }
+            if (input === '/pending') {
+                process.stdout.write(`${JSON.stringify((0, session_1.readDraft)(session), null, 2)}\n`);
+                continue;
+            }
+            if (input === '/cancel') {
+                process.stdout.write('Revision cancelled.\n');
+                return;
+            }
+            if (input === '/exit') {
+                preserveSession = true;
+                process.stdout.write(`Revision draft saved in session: ${session.root}\n`);
+                return;
+            }
+            if (input === '/apply') {
+                const draft = (0, session_1.readDraft)(session);
+                if (!draft.pending_changes.length) {
+                    process.stdout.write('No pending changes.\n');
+                    continue;
+                }
+                const payload = await (0, loading_1.withLoading)('正在生成修订方案...', () => (0, finalize_1.finalizeRevision)((0, session_1.buildTranscript)(session.messagesDir), draft, session.toolsFile, gateway.baseUrl, gateway.token, maxToolRounds, options.keepSession));
+                (0, validate_payload_1.validateRevisePayload)(payload);
+                const changes = (0, project_payload_1.projectRevisePayload)(payload, worldRoot);
+                const diff = (0, diff_1.buildUnifiedDiff)(worldRoot, changes);
+                if (!diff) {
+                    process.stdout.write('No file changes produced.\n');
+                    continue;
+                }
+                process.stdout.write(`\n${diff}\n`);
+                if (options.dryRun) {
+                    process.stdout.write('Dry run only. No files changed.\n');
+                    continue;
+                }
+                const snapshots = (0, file_hash_1.snapshotChanges)(worldRoot, changes);
+                if (!options.yes && !await (0, read_user_input_1.askYesNo)('Apply this revision? (Y/N): ')) {
+                    process.stdout.write('Revision not applied.\n');
+                    continue;
+                }
+                (0, file_hash_1.assertSnapshotsUnchanged)(worldRoot, snapshots);
+                const revisionId = (0, apply_payload_1.applyChanges)(worldRoot, payload, changes, new Date(), { diff, draft, transcript: (0, session_1.buildTranscript)(session.messagesDir) });
+                process.stdout.write(`Applied World revision: ${revisionId}\n`);
+                return;
+            }
+            (0, session_1.appendUserMessage)(session.messagesDir, input);
+            process.stdout.write('\nAI> ');
+            const stream = (0, filtered_stream_output_1.createFilteredStreamOutput)({ hiddenBlocks: ['revise-status'] });
+            const reply = await (0, promptpile_loop_1.runPromptpileUntilText)(session, gateway.baseUrl, gateway.token, maxToolRounds, text => stream.push(text));
+            stream.flush();
+            try {
+                const status = (0, parse_assistant_1.parseReviseStatus)(reply);
+                if (status)
+                    (0, session_1.writeDraft)(session, status);
+            }
+            catch (err) {
+                process.stderr.write(`Warning: ${err instanceof Error ? err.message : err}\n`);
+            }
+            process.stdout.write('\n');
+        }
+    }
+    finally {
+        if (gateway)
+            await gateway.stop();
+        if (preserveSession)
+            process.stderr.write(`Revise session preserved at: ${session.root}\n`);
+        else
+            (0, session_1.cleanupSession)(session);
+    }
+}

package/dist/revise/diff.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUnifiedDiff = buildUnifiedDiff;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function buildUnifiedDiff(worldRoot, changes) {
+    return changes.map(change => {
+        const filePath = path_1.default.join(worldRoot, change.relativePath);
+        const before = fs_1.default.existsSync(filePath) ? fs_1.default.readFileSync(filePath, 'utf8') : '';
+        if (before === change.content)
+            return '';
+        return [
+            `--- a/${change.relativePath}`,
+            `+++ b/${change.relativePath}`,
+            '@@',
+            ...before.split('\n').filter((_, i, arr) => i < arr.length - 1 || arr[i] !== '').map(line => `-${line}`),
+            ...change.content.split('\n').filter((_, i, arr) => i < arr.length - 1 || arr[i] !== '').map(line => `+${line}`),
+            '',
+        ].join('\n');
+    }).filter(Boolean).join('\n');
+}

package/dist/revise/file-hash.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotChanges = snapshotChanges;
+exports.assertSnapshotsUnchanged = assertSnapshotsUnchanged;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function snapshotChanges(worldRoot, changes) {
+    return changes.map(change => snapshotFile(worldRoot, change.relativePath));
+}
+function assertSnapshotsUnchanged(worldRoot, snapshots) {
+    for (const expected of snapshots) {
+        const current = snapshotFile(worldRoot, expected.relativePath);
+        if (current.exists !== expected.exists || current.sha256 !== expected.sha256) {
+            throw new Error(`Refusing to apply revision: file changed during review: ${expected.relativePath}`);
+        }
+    }
+}
+function snapshotFile(worldRoot, relativePath) {
+    const filePath = path_1.default.join(worldRoot, relativePath);
+    if (!fs_1.default.existsSync(filePath))
+        return { relativePath, exists: false };
+    return { relativePath, exists: true, sha256: crypto_1.default.createHash('sha256').update(fs_1.default.readFileSync(filePath)).digest('hex') };
+}

package/dist/revise/finalize.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.finalizeRevision = finalizeRevision;
+const fs_1 = __importDefault(require("fs"));
+const parse_assistant_1 = require("./parse-assistant");
+const promptpile_loop_1 = require("./promptpile-loop");
+const session_1 = require("./session");
+async function finalizeRevision(transcript, draft, toolsFile, baseUrl, token, maxToolRounds, keepSession = false) {
+    const session = (0, session_1.createFinalizeSession)(transcript, draft);
+    fs_1.default.copyFileSync(toolsFile, session.toolsFile);
+    try {
+        return (0, parse_assistant_1.parseRevisePayload)(await (0, promptpile_loop_1.runPromptpileUntilText)(session, baseUrl, token, maxToolRounds));
+    }
+    finally {
+        if (keepSession)
+            process.stderr.write(`Finalize session preserved at: ${session.root}\n`);
+        else
+            (0, session_1.cleanupSession)(session);
+    }
+}

package/dist/revise/guard.js

@@ -0,0 +1,17 @@
+"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.assertInitializedWorld = assertInitializedWorld;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function resolveWorldRoot(dir) {
+    return path_1.default.resolve(dir);
+}
+function assertInitializedWorld(worldRoot) {
+    if (!fs_1.default.existsSync(path_1.default.join(worldRoot, 'manifest.yaml'))) {
+        throw new Error(`World save is not initialized: ${worldRoot}`);
+    }
+}

package/dist/revise/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviseWorldInteractive = void 0;
+exports.reviseWorldFromProposal = reviseWorldFromProposal;
+const apply_payload_1 = require("./apply-payload");
+const dialogue_loop_1 = require("./dialogue-loop");
+Object.defineProperty(exports, "reviseWorldInteractive", { enumerable: true, get: function () { return dialogue_loop_1.reviseWorldInteractive; } });
+const guard_1 = require("./guard");
+const parse_payload_1 = require("./parse-payload");
+const project_payload_1 = require("./project-payload");
+const validate_payload_1 = require("./validate-payload");
+function reviseWorldFromProposal(dir, proposalPath, options = {}) {
+    const worldRoot = (0, guard_1.resolveWorldRoot)(dir);
+    (0, guard_1.assertInitializedWorld)(worldRoot);
+    const payload = (0, parse_payload_1.readRevisePayload)(proposalPath);
+    (0, validate_payload_1.validateRevisePayload)(payload);
+    const changes = (0, project_payload_1.projectRevisePayload)(payload, worldRoot);
+    const description = (0, apply_payload_1.describeChanges)(worldRoot, changes);
+    if (options.dryRun)
+        return { worldRoot, description };
+    if (!options.yes)
+        throw new Error('Applying a revision requires --yes. Use --dry-run to inspect changes.');
+    return { worldRoot, description, revisionId: (0, apply_payload_1.applyChanges)(worldRoot, payload, changes) };
+}

package/dist/revise/mcp-gateway.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectOrStartGateway = connectOrStartGateway;
+const child_process_1 = require("child_process");
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const net_1 = __importDefault(require("net"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+const bin_resolve_1 = require("./bin-resolve");
+const process_run_1 = require("./process-run");
+async function connectOrStartGateway(sessionRoot, worldRoot, externalBaseUrl, externalToken) {
+    if (externalBaseUrl)
+        return { baseUrl: externalBaseUrl.replace(/\/$/, ''), token: externalToken, async stop() { } };
+    const port = await pickFreePort();
+    const token = crypto_1.default.randomBytes(24).toString('hex');
+    const config = path_1.default.join(sessionRoot, 'mcp.toml');
+    const filesystemServer = getFilesystemServerSpawnConfig(worldRoot);
+    fs_1.default.writeFileSync(config, `version = 1\n\n[gateway]\nport = ${port}\ntoken = "${token}"\n\n[behavior]\nfailure_policy = "strict"\nflat_names = false\n\n[servers.world]\ncommand = ${JSON.stringify(filesystemServer.command)}\nargs = ${JSON.stringify(filesystemServer.args)}\n`, 'utf8');
+    const spawnConfig = (0, bin_resolve_1.getPromptpileMcpSpawnConfig)();
+    const child = (0, child_process_1.spawn)(spawnConfig.command, [...spawnConfig.argvPrefix, 'launch', '--config', config], { cwd: sessionRoot, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stderr = '';
+    let spawnError;
+    child.stderr?.on('data', chunk => { stderr += chunk.toString(); });
+    child.on('error', error => { spawnError = error; });
+    const baseUrl = `http://127.0.0.1:${port}`;
+    try {
+        await waitForHealth(baseUrl, token, child, () => stderr, () => spawnError);
+    }
+    catch (err) {
+        await (0, process_run_1.stopChild)(child);
+        throw err;
+    }
+    return { baseUrl, token, stop: () => (0, process_run_1.stopChild)(child) };
+}
+async function pickFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net_1.default.createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (!address || typeof address === 'string')
+                return reject(new Error('Failed to choose MCP gateway port'));
+            server.close(err => err ? reject(err) : resolve(address.port));
+        });
+    });
+}
+async function waitForHealth(baseUrl, token, child, getStderr, getSpawnError) {
+    const deadline = Date.now() + constants_1.DEFAULT_GATEWAY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const spawnError = getSpawnError();
+        if (spawnError)
+            throw new Error(`Failed to start promptpile-mcp: ${spawnError.message}`);
+        if (child.exitCode !== null)
+            throw new Error(`promptpile-mcp exited before health check: ${getStderr().trim().slice(-500)}`);
+        try {
+            const res = await fetch(`${baseUrl}/health`, { headers: { Authorization: `Bearer ${token}` } });
+            if (res.ok)
+                return;
+        }
+        catch { /* retry */ }
+        await new Promise(resolve => setTimeout(resolve, 250));
+    }
+    throw new Error(`Timed out waiting for promptpile-mcp gateway. ${getStderr().trim().slice(-500)}`);
+}
+function getFilesystemServerSpawnConfig(worldRoot) {
+    const override = process.env.DAY_LOOM_FILESYSTEM_MCP_BIN?.trim();
+    if (override)
+        return { command: process.execPath, args: [override, worldRoot] };
+    return { command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', worldRoot] };
+}

package/dist/revise/mcp-tools.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportReadonlyTools = exportReadonlyTools;
+exports.parseAndAssertReadonlyCalls = parseAndAssertReadonlyCalls;
+exports.executeReadonlyCalls = executeReadonlyCalls;
+exports.assertAllowedWorldRoot = assertAllowedWorldRoot;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+function headers(token) {
+    return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function exportReadonlyTools(baseUrl, token, outputFile) {
+    const res = await fetch(`${baseUrl}/v1/tools/export`, { headers: { Accept: 'application/json', ...headers(token) } });
+    if (!res.ok)
+        throw new Error(`MCP export-tools failed: HTTP ${res.status}`);
+    const body = await res.json();
+    if (!Array.isArray(body.tools))
+        throw new Error('MCP export-tools response missing tools array');
+    const tools = body.tools.filter(tool => constants_1.READONLY_MCP_TOOL_NAMES.has(tool.function.name));
+    for (const required of constants_1.READONLY_MCP_TOOL_NAMES) {
+        if (!tools.some(tool => tool.function.name === required))
+            throw new Error(`MCP readonly tool missing: ${required}`);
+    }
+    fs_1.default.writeFileSync(outputFile, toolsToml(tools), 'utf8');
+}
+function toolsToml(tools) {
+    return tools.map(tool => [
+        '[[tools]]',
+        `name = ${JSON.stringify(tool.function.name)}`,
+        ...(tool.function.description ? [`description = ${JSON.stringify(tool.function.description)}`] : []),
+        `parameters = ${JSON.stringify(JSON.stringify(tool.function.parameters ?? { type: 'object', properties: {} }))}`,
+        '',
+    ].join('\n')).join('\n');
+}
+function parseAndAssertReadonlyCalls(callFile) {
+    const calls = [];
+    for (const [index, line] of fs_1.default.readFileSync(callFile, 'utf8').split(/\r?\n/).entries()) {
+        if (!line.trim())
+            continue;
+        const call = JSON.parse(line);
+        if (!call || call.type !== 'function' || typeof call.id !== 'string' || typeof call.function?.name !== 'string' || typeof call.function.arguments !== 'string') {
+            throw new Error(`Invalid tool call on line ${index + 1}: ${path_1.default.basename(callFile)}`);
+        }
+        if (!constants_1.READONLY_MCP_TOOL_NAMES.has(call.function.name))
+            throw new Error(`Refusing non-readonly MCP tool call: ${call.function.name}`);
+        calls.push(call);
+    }
+    return calls;
+}
+async function executeReadonlyCalls(baseUrl, token, callFile) {
+    const calls = parseAndAssertReadonlyCalls(callFile);
+    if (!calls.length)
+        throw new Error(`No MCP calls found in ${callFile}`);
+    const res = await fetch(`${baseUrl}/v1/calls/exec`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json', ...headers(token) }, body: JSON.stringify({ calls }),
+    });
+    if (!res.ok)
+        throw new Error(`MCP exec-calls failed: HTTP ${res.status}`);
+    const body = await res.json();
+    if (!Array.isArray(body.results))
+        throw new Error('MCP exec-calls response missing results array');
+    const byId = new Map(body.results.map(result => [result.toolCallId, result]));
+    const resultFile = callFile.replace(/\.calls\.jsonl$/i, '.result.jsonl');
+    const lines = calls.map(call => {
+        const result = byId.get(call.id);
+        const content = result?.ok ? (typeof result.content === 'string' ? result.content : JSON.stringify(result.content ?? '')) : result?.error ?? 'MCP tool failed';
+        return JSON.stringify({ tool_call_id: call.id, name: call.function.name, content });
+    });
+    fs_1.default.writeFileSync(resultFile, `${lines.join('\n')}\n`, 'utf8');
+    return resultFile;
+}
+async function assertAllowedWorldRoot(baseUrl, token, worldRoot, scratchDir) {
+    const callFile = path_1.default.join(scratchDir, `.dayloom-allowed-${process.pid}.calls.jsonl`);
+    const id = `allowed-${process.pid}`;
+    fs_1.default.writeFileSync(callFile, `${JSON.stringify({ id, type: 'function', function: { name: 'mcp__world__list_allowed_directories', arguments: '{}' } })}\n`, 'utf8');
+    try {
+        const resultFile = await executeReadonlyCalls(baseUrl, token, callFile);
+        const row = JSON.parse(fs_1.default.readFileSync(resultFile, 'utf8').trim());
+        const allowedText = row.content;
+        if (!allowedText.includes(worldRoot))
+            throw new Error(`MCP allowed directories do not include World root: ${worldRoot}`);
+        fs_1.default.rmSync(resultFile, { force: true });
+    }
+    finally {
+        fs_1.default.rmSync(callFile, { force: true });
+    }
+}

package/dist/revise/parse-assistant.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReviseStatus = parseReviseStatus;
+exports.parseRevisePayload = parseRevisePayload;
+exports.stripReviseStatus = stripReviseStatus;
+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 parseReviseStatus(text) {
+    const raw = extractBlock(text, 'revise-status');
+    if (!raw)
+        return undefined;
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.pending_changes)) {
+        throw new Error('revise-status pending_changes must be an array');
+    }
+    for (const [index, item] of parsed.pending_changes.entries()) {
+        if (!item || typeof item !== 'object' || typeof item.instruction !== 'string' || !item.instruction.trim()) {
+            throw new Error(`revise-status pending_changes[${index}] is invalid`);
+        }
+        if (!item.target || typeof item.target !== 'object' || Array.isArray(item.target)) {
+            throw new Error(`revise-status pending_changes[${index}].target is invalid`);
+        }
+    }
+    return parsed;
+}
+function parseRevisePayload(text) {
+    const raw = extractBlock(text, 'revise-payload');
+    if (!raw)
+        throw new Error('Assistant response missing revise-payload JSON block');
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse revise-payload JSON: ${err instanceof Error ? err.message : err}`);
+    }
+}
+function stripReviseStatus(text) {
+    return text.replace(/```(?:json\s+)?revise-status\s*\n[\s\S]*?```/gi, '').trim();
+}

package/dist/revise/parse-payload.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRevisePayload = readRevisePayload;
+const fs_1 = __importDefault(require("fs"));
+function readRevisePayload(filePath) {
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(filePath, 'utf8');
+    }
+    catch (err) {
+        throw new Error(`Failed to read revise proposal: ${err instanceof Error ? err.message : err}`);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse revise proposal JSON: ${err instanceof Error ? err.message : err}`);
+    }
+}