dayloom 0.1.0-beta.0

package/dist/settle/guard.js

@@ -0,0 +1,71 @@
+"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.assertSettlementCanStart = assertSettlementCanStart;
+exports.assertNextDayAvailable = assertNextDayAvailable;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function resolveWorldRoot(dir) {
+    return path_1.default.resolve(dir);
+}
+function assertSettlementCanStart(worldRoot) {
+    if (!fs_1.default.existsSync(path_1.default.join(worldRoot, 'manifest.yaml')))
+        throw new Error(`World save is not initialized: ${worldRoot}`);
+    const currentPath = path_1.default.join(worldRoot, 'current.yaml');
+    if (!fs_1.default.existsSync(currentPath))
+        throw new Error('World save missing current.yaml');
+    const current = fs_1.default.readFileSync(currentPath, 'utf8');
+    const day = readYamlScalar(current, 'day', 'current.yaml');
+    const phase = readYamlScalar(current, 'phase', 'current.yaml');
+    if (phase !== 'settling')
+        throw new Error(`Settlement requires current phase settling, got: ${phase}`);
+    const dayRoot = path_1.default.join(worldRoot, 'days', day);
+    const metaPath = path_1.default.join(dayRoot, 'meta.yaml');
+    if (!fs_1.default.existsSync(metaPath))
+        throw new Error(`Missing day metadata: days/${day}/meta.yaml`);
+    const metaPhase = readYamlScalar(fs_1.default.readFileSync(metaPath, 'utf8'), 'phase', `days/${day}/meta.yaml`);
+    if (metaPhase !== 'settling')
+        throw new Error(`Settlement requires day phase settling, got: ${metaPhase}`);
+    const plan = readJson(path_1.default.join(dayRoot, 'plan.current.json'), 'current plan');
+    const playState = readJson(path_1.default.join(dayRoot, 'play.state.json'), 'play state');
+    if (plan.day !== day)
+        throw new Error(`Current plan day mismatch: expected ${day}, got ${plan.day}`);
+    if (playState.day !== day)
+        throw new Error(`Play state day mismatch: expected ${day}, got ${playState.day}`);
+    if (playState.phase !== 'settling' || playState.step !== 'complete')
+        throw new Error('Settlement requires completed play state in settling phase');
+    if (playState.active_event !== null || playState.active_beat !== null)
+        throw new Error('Settlement cannot start while an event or beat is active');
+    const unfinished = plan.beats.filter(beat => beat.status !== 'completed' && beat.status !== 'cancelled');
+    if (unfinished.length > 0)
+        throw new Error(`Settlement requires all beats closed: ${unfinished.map(beat => beat.id).join(', ')}`);
+    for (const eventId of playState.completed_events) {
+        if (!fs_1.default.existsSync(path_1.default.join(dayRoot, 'events', eventId, 'result.json')))
+            throw new Error(`Completed event is missing result.json: ${eventId}`);
+    }
+    return { day, dayRoot, plan, playState };
+}
+function assertNextDayAvailable(worldRoot, nextDay) {
+    const nextRoot = path_1.default.join(worldRoot, 'days', nextDay);
+    if (fs_1.default.existsSync(nextRoot) && fs_1.default.readdirSync(nextRoot).length > 0)
+        throw new Error(`Next day directory already exists and is not empty: days/${nextDay}`);
+}
+function readYamlScalar(text, key, label) {
+    const match = text.match(new RegExp(`^${key}:\\s*(\\S+)\\s*$`, 'm'));
+    if (!match)
+        throw new Error(`${label} missing ${key}`);
+    return match[1];
+}
+function readJson(filePath, label) {
+    if (!fs_1.default.existsSync(filePath))
+        throw new Error(`Missing ${label}: ${filePath}`);
+    try {
+        return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        throw new Error(`Invalid JSON in ${label}: ${filePath}`);
+    }
+}

package/dist/settle/index.js

@@ -0,0 +1,105 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settleFromProposal = settleFromProposal;
+exports.settleWithAi = settleWithAi;
+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 ai_1 = require("./ai");
+const apply_1 = require("./apply");
+const context_1 = require("./context");
+const derive_1 = require("./derive");
+const guard_1 = require("./guard");
+const parse_assistant_1 = require("./parse-assistant");
+const parse_payload_1 = require("./parse-payload");
+const project_1 = require("./project");
+const validate_1 = require("./validate");
+const loading_1 = require("../utils/loading");
+function settleFromProposal(dir, proposalPath, options = {}) {
+    const worldRoot = (0, guard_1.resolveWorldRoot)(dir);
+    const { day } = (0, guard_1.assertSettlementCanStart)(worldRoot);
+    const nextDay = (0, validate_1.nextDayId)(day);
+    (0, guard_1.assertNextDayAvailable)(worldRoot, nextDay);
+    const proposal = (0, parse_payload_1.readSettlementProposal)(proposalPath);
+    (0, validate_1.validateSettlementProposal)(proposal, day, worldRoot);
+    const changes = (0, project_1.projectSettlement)(worldRoot, proposal, nextDay, new Date().toISOString());
+    const description = (0, project_1.describeSettlementChanges)(worldRoot, changes);
+    if (options.dryRun)
+        return { worldRoot, day, nextDay, description, applied: false };
+    if (!options.yes)
+        throw new Error('Applying a settlement requires --yes. Use --dry-run to inspect changes.');
+    (0, apply_1.applySettlement)(worldRoot, proposal, changes, nextDay);
+    return { worldRoot, day, nextDay, description, applied: true };
+}
+async function settleWithAi(dir, options = {}) {
+    if (!process.env.DEEPSEEK_API_KEY?.trim())
+        throw new Error('DEEPSEEK_API_KEY is not set. AI settlement requires an API key.');
+    const worldRoot = (0, guard_1.resolveWorldRoot)(dir);
+    const { day } = (0, guard_1.assertSettlementCanStart)(worldRoot);
+    const nextDay = (0, validate_1.nextDayId)(day);
+    (0, guard_1.assertNextDayAvailable)(worldRoot, nextDay);
+    const serviceRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-settle-service-'));
+    const contextRoot = path_1.default.join(serviceRoot, 'player-context');
+    const toolsFile = path_1.default.join(serviceRoot, 'readonly.tools.toml');
+    let gateway;
+    try {
+        await (0, loading_1.withLoading)('正在准备结算上下文...', async (loading) => {
+            (0, context_1.buildSettlementPlayerContext)(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);
+        });
+        const reply = await (0, loading_1.withLoading)('正在生成结算提案...', () => (0, ai_1.callSettlementAi)((0, context_1.buildSettlementPromptInput)(worldRoot, day), toolsFile, gateway.baseUrl, gateway.token, options.maxToolRounds ?? 8, options.keepSession));
+        const narrative = (0, parse_assistant_1.parseSettlementNarrative)(reply);
+        (0, validate_1.validateSettlementNarrative)(narrative);
+        const proposal = (0, derive_1.buildProgramSettlementProposal)(worldRoot, day, narrative);
+        (0, validate_1.validateSettlementProposal)(proposal, day, worldRoot);
+        const changes = (0, project_1.projectSettlement)(worldRoot, proposal, nextDay, new Date().toISOString());
+        const description = (0, project_1.describeSettlementChanges)(worldRoot, changes);
+        if (options.dryRun)
+            return { worldRoot, day, nextDay, description, applied: false };
+        if (!options.yes) {
+            const proposalPath = path_1.default.join(worldRoot, 'days', day, 'ending', 'settlement.proposal.json');
+            writeJsonAtomic(proposalPath, proposal);
+            return { worldRoot, day, nextDay, description, applied: false, proposalPath };
+        }
+        (0, apply_1.applySettlement)(worldRoot, proposal, changes, nextDay);
+        return { worldRoot, day, nextDay, description, applied: true };
+    }
+    finally {
+        if (gateway)
+            await gateway.stop();
+        if (options.keepSession)
+            process.stderr.write(`Settlement service session preserved at: ${serviceRoot}\n`);
+        else
+            fs_1.default.rmSync(serviceRoot, { recursive: true, force: true });
+    }
+}
+function writeJsonAtomic(filePath, value) {
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.tmp`;
+    fs_1.default.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    fs_1.default.renameSync(temporary, filePath);
+}
+__exportStar(require("./types"), exports);

package/dist/settle/parse-assistant.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSettlementNarrative = parseSettlementNarrative;
+function parseSettlementNarrative(text) {
+    const match = text.match(/```(?:json\s+)?settlement-narrative\s*\n([\s\S]*?)```/i);
+    if (!match)
+        throw new Error('Assistant response missing settlement-narrative JSON block');
+    try {
+        return JSON.parse(match[1].trim());
+    }
+    catch (error) {
+        throw new Error(`Failed to parse settlement-narrative JSON: ${error instanceof Error ? error.message : error}`);
+    }
+}

package/dist/settle/parse-payload.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSettlementProposal = readSettlementProposal;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function readSettlementProposal(proposalPath) {
+    const resolved = path_1.default.resolve(proposalPath);
+    if (!fs_1.default.existsSync(resolved))
+        throw new Error(`Settlement proposal not found: ${resolved}`);
+    try {
+        return JSON.parse(fs_1.default.readFileSync(resolved, 'utf8'));
+    }
+    catch {
+        throw new Error(`Settlement proposal is not valid JSON: ${resolved}`);
+    }
+}

package/dist/settle/project.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.projectSettlement = projectSettlement;
+exports.describeSettlementChanges = describeSettlementChanges;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function projectSettlement(worldRoot, proposal, nextDay, committedAt) {
+    const dayDir = `days/${proposal.day}`;
+    const changes = [
+        { relativePath: `${dayDir}/summary.md`, content: ensureNewline(proposal.summary) },
+        { relativePath: `${dayDir}/ending/objective_summary.md`, content: ensureNewline(proposal.summary) },
+        { relativePath: `${dayDir}/ending/diary.md`, content: ensureNewline(proposal.diary) },
+        { relativePath: `${dayDir}/ending/state_patch.json`, content: json(proposal.state_patch) },
+        { relativePath: `${dayDir}/ending/next_day_seed.json`, content: json(proposal.next_day_seed) },
+        { relativePath: `${dayDir}/ending/settlement.json`, content: json(proposal) },
+    ];
+    for (const patch of proposal.state_patch) {
+        const existing = fs_1.default.readFileSync(path_1.default.join(worldRoot, patch.path), 'utf8');
+        changes.push({
+            relativePath: patch.path,
+            content: patch.op === 'replace' ? ensureNewline(patch.content) : appendContent(existing, patch.content),
+        });
+    }
+    const logPath = path_1.default.join(worldRoot, 'logs', 'state_changes.jsonl');
+    const existingLog = fs_1.default.existsSync(logPath) ? fs_1.default.readFileSync(logPath, 'utf8') : '';
+    changes.push({
+        relativePath: 'logs/state_changes.jsonl',
+        content: `${existingLog}${JSON.stringify({ type: 'day_settled', day: proposal.day, next_day: nextDay, summary: proposal.summary })}\n`,
+    });
+    changes.push({
+        relativePath: `${dayDir}/meta.yaml`,
+        content: updateDayMeta(fs_1.default.readFileSync(path_1.default.join(worldRoot, dayDir, 'meta.yaml'), 'utf8'), committedAt),
+    });
+    changes.push({
+        relativePath: `${dayDir}/ending/settle.state.json`,
+        content: json({ version: 1, day: proposal.day, status: 'committed', next_day: nextDay, committed_at: committedAt }),
+    });
+    changes.push({ relativePath: 'current.yaml', content: [`day: ${nextDay}`, 'phase: idle', `last_committed_day: ${proposal.day}`, ''].join('\n') });
+    return changes;
+}
+function describeSettlementChanges(worldRoot, changes) {
+    return changes.map(change => `${fs_1.default.existsSync(path_1.default.join(worldRoot, change.relativePath)) ? 'update' : 'create'} ${change.relativePath}`).join('\n');
+}
+function appendContent(existing, addition) {
+    const base = existing.replace(/\s+$/, '');
+    const next = addition.trim();
+    return base ? `${base}\n\n${next}\n` : `${next}\n`;
+}
+function updateDayMeta(text, committedAt) {
+    let next = /^phase:/m.test(text) ? text.replace(/^phase:.*$/m, 'phase: settled') : `${text.replace(/\s*$/, '')}\nphase: settled\n`;
+    next = /^settled_at:/m.test(next) ? next.replace(/^settled_at:.*$/m, `settled_at: ${committedAt}`) : `${next.replace(/\s*$/, '')}\nsettled_at: ${committedAt}\n`;
+    return next;
+}
+function ensureNewline(value) { return `${value.trim()}\n`; }
+function json(value) { return `${JSON.stringify(value, null, 2)}\n`; }

package/dist/settle/session.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSettlementSession = createSettlementSession;
+exports.cleanupSettlementSession = cleanupSettlementSession;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+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 createSettlementSession(systemPrompt, userContent, toolsSource) {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-settle-'));
+    const messagesDir = path_1.default.join(root, 'messages');
+    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.mkdirSync(messagesDir, { recursive: true });
+    fs_1.default.writeFileSync(session.promptpileConfig, promptpileToml(), 'utf8');
+    fs_1.default.copyFileSync(toolsSource, session.toolsFile);
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[0]system.md'), systemPrompt, 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[1]user.md'), userContent, 'utf8');
+    return session;
+}
+function cleanupSettlementSession(session) {
+    fs_1.default.rmSync(session.root, { recursive: true, force: true });
+}

package/dist/settle/types.js

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

package/dist/settle/validate.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSettlementProposal = validateSettlementProposal;
+exports.nextDayId = nextDayId;
+exports.validateSettlementNarrative = validateSettlementNarrative;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DAY_ID = /^day_(\d{4})$/;
+const REPLACE_PATHS = new Set([
+    'state/world.yaml', 'state/calendar.yaml', 'state/progress.yaml', 'state/variables.yaml',
+    'memory/facts.yaml', 'memory/important_events.yaml', 'memory/unresolved_threads.yaml',
+]);
+const APPEND_PATHS = [
+    /^memory\/(?:short_term|long_term)\.md$/,
+    /^characters\/[a-z][a-z0-9_]*\/(?:memory|timeline|relationships)\.md$/,
+    /^scenes\/[a-z][a-z0-9_]*\/(?:memory|timeline)\.md$/,
+    /^arcs\/[a-z][a-z0-9_]*\/timeline\.md$/,
+];
+function validateSettlementProposal(proposal, expectedDay, worldRoot) {
+    if (!proposal || typeof proposal !== 'object' || Array.isArray(proposal))
+        throw new Error('Settlement proposal must be an object');
+    if (proposal.version !== 1)
+        throw new Error('Settlement proposal version must be 1');
+    if (typeof proposal.day !== 'string' || !DAY_ID.test(proposal.day))
+        throw new Error('Settlement proposal day must be day_NNNN');
+    if (proposal.day !== expectedDay)
+        throw new Error(`Settlement proposal day mismatch: expected ${expectedDay}, got ${proposal.day}`);
+    assertNonEmpty(proposal.summary, 'Settlement proposal summary');
+    assertNonEmpty(proposal.diary, 'Settlement proposal diary');
+    if (!Array.isArray(proposal.state_patch))
+        throw new Error('Settlement proposal state_patch must be an array');
+    const patchedPaths = new Set();
+    proposal.state_patch.forEach((patch, index) => {
+        validatePatch(patch, index, worldRoot);
+        if (patchedPaths.has(patch.path))
+            throw new Error(`Settlement patch path is duplicated: ${patch.path}`);
+        patchedPaths.add(patch.path);
+    });
+    const seed = proposal.next_day_seed;
+    if (!seed || typeof seed !== 'object' || Array.isArray(seed))
+        throw new Error('Settlement proposal next_day_seed must be an object');
+    assertNonEmpty(seed.summary, 'Settlement proposal next_day_seed.summary');
+    assertStringArray(seed.suggested_intents, 'Settlement proposal next_day_seed.suggested_intents');
+    assertStringArray(seed.unresolved_threads, 'Settlement proposal next_day_seed.unresolved_threads');
+}
+function nextDayId(day) {
+    const match = day.match(DAY_ID);
+    if (!match)
+        throw new Error(`Invalid day id: ${day}`);
+    const next = Number(match[1]) + 1;
+    if (next > 9999)
+        throw new Error(`Cannot advance beyond ${day}`);
+    return `day_${String(next).padStart(4, '0')}`;
+}
+function validatePatch(patch, index, worldRoot) {
+    if (!patch || typeof patch !== 'object' || Array.isArray(patch))
+        throw new Error(`Settlement patch ${index} must be an object`);
+    if (patch.op !== 'replace' && patch.op !== 'append')
+        throw new Error(`Settlement patch ${index} has unsupported op`);
+    if (typeof patch.path !== 'string' || !patch.path)
+        throw new Error(`Settlement patch ${index} path must be non-empty`);
+    if (path_1.default.isAbsolute(patch.path) || patch.path.includes('\\') || patch.path.split('/').includes('..'))
+        throw new Error(`Settlement patch ${index} path is unsafe: ${patch.path}`);
+    assertNonEmpty(patch.content, `Settlement patch ${index} content`);
+    if (patch.op === 'replace') {
+        if (!REPLACE_PATHS.has(patch.path))
+            throw new Error(`Settlement patch ${index} replace path is not allowed: ${patch.path}`);
+        if (!fs_1.default.existsSync(path_1.default.join(worldRoot, patch.path)))
+            throw new Error(`Settlement patch ${index} cannot replace missing file: ${patch.path}`);
+        return;
+    }
+    if (!APPEND_PATHS.some(pattern => pattern.test(patch.path)))
+        throw new Error(`Settlement patch ${index} append path is not allowed: ${patch.path}`);
+    if (!fs_1.default.existsSync(path_1.default.join(worldRoot, patch.path)))
+        throw new Error(`Settlement patch ${index} cannot append to missing file: ${patch.path}`);
+}
+function assertNonEmpty(value, label) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`${label} must be a non-empty string`);
+}
+function assertStringArray(value, label) {
+    if (!Array.isArray(value) || value.some(item => typeof item !== 'string' || !item.trim()))
+        throw new Error(`${label} must be an array of non-empty strings`);
+}
+function validateSettlementNarrative(narrative) {
+    if (!narrative || typeof narrative !== 'object' || Array.isArray(narrative))
+        throw new Error('Settlement narrative must be an object');
+    assertNonEmpty(narrative.summary, 'Settlement narrative summary');
+    assertNonEmpty(narrative.diary, 'Settlement narrative diary');
+    const seed = narrative.next_day_seed;
+    if (!seed || typeof seed !== 'object' || Array.isArray(seed))
+        throw new Error('Settlement narrative next_day_seed must be an object');
+    assertNonEmpty(seed.summary, 'Settlement narrative next_day_seed.summary');
+    assertStringArray(seed.suggested_intents, 'Settlement narrative next_day_seed.suggested_intents');
+    if (seed.suggested_intents.length < 1 || seed.suggested_intents.length > 5)
+        throw new Error('Settlement narrative suggested_intents must contain 1 to 5 items');
+}

package/dist/shared/filtered-stream-output.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFilteredStreamOutput = createFilteredStreamOutput;
+function createFilteredStreamOutput(options) {
+    const write = options.write ?? (text => process.stdout.write(text));
+    const hidden = new Set(options.hiddenBlocks.map(label => label.toLowerCase()));
+    let buffer = '';
+    let suppressing = false;
+    const handleLine = (line, newline) => {
+        const trimmed = line.trim();
+        if (suppressing) {
+            if (trimmed.startsWith('```'))
+                suppressing = false;
+            return;
+        }
+        const match = trimmed.match(/^```(?:json\s+)?([a-z0-9_-]+)/i);
+        if (match && hidden.has(match[1].toLowerCase())) {
+            suppressing = true;
+            return;
+        }
+        write(line);
+        if (newline)
+            write('\n');
+    };
+    return {
+        push(chunk) {
+            buffer += chunk;
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines)
+                handleLine(line, true);
+        },
+        flush() {
+            if (buffer !== '') {
+                const line = buffer;
+                buffer = '';
+                handleLine(line, false);
+            }
+        }
+    };
+}

package/dist/shared/promptpile-stream.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromptpileStreamConsumer = createPromptpileStreamConsumer;
+function createPromptpileStreamConsumer(options) {
+    let buffer = '';
+    const handleLine = (rawLine) => {
+        const line = rawLine.trim();
+        if (!line) {
+            return;
+        }
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch (e) {
+            const detail = e instanceof Error ? e.message : String(e);
+            throw new Error('Invalid promptpile stream JSON: ' + detail + ': ' + line);
+        }
+        if (!event || typeof event !== 'object') {
+            throw new Error('Invalid promptpile stream event: ' + line);
+        }
+        const payload = event;
+        const type = payload.type;
+        if (type === 'assistant_delta') {
+            if (typeof payload.content !== 'string') {
+                throw new Error('Invalid promptpile assistant_delta event: ' + line);
+            }
+            options.onDelta(payload.content);
+            return;
+        }
+        if (type === 'assistant_done') {
+            options.onDone?.();
+            return;
+        }
+        if (type === 'error') {
+            const message = typeof payload.message === 'string' ? payload.message : line;
+            options.onError?.(message);
+            return;
+        }
+        throw new Error('Unknown promptpile stream event type: ' + String(type));
+    };
+    return {
+        push(chunk) {
+            buffer += chunk;
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                handleLine(line);
+            }
+        },
+        flush() {
+            if (buffer.trim() !== '') {
+                const line = buffer;
+                buffer = '';
+                handleLine(line);
+            }
+        }
+    };
+}

package/dist/shared/run-promptpile-with-stream.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPromptpileWithStream = runPromptpileWithStream;
+const process_run_1 = require("../revise/process-run");
+const promptpile_stream_1 = require("./promptpile-stream");
+async function runPromptpileWithStream(options) {
+    const consumer = (0, promptpile_stream_1.createPromptpileStreamConsumer)({
+        onDelta: options.onDelta,
+        onError: message => {
+            throw new Error('promptpile stream error: ' + message);
+        }
+    });
+    const result = await (0, process_run_1.runProcess)(options.command, [
+        ...options.args,
+        '--output-pile-fd',
+        '3',
+        '--output-pile-format',
+        'json'
+    ], {
+        cwd: options.cwd,
+        quiet: options.quiet,
+        outputPile: {
+            fd: 3,
+            onData: chunk => consumer.push(chunk)
+        }
+    });
+    try {
+        consumer.flush();
+    }
+    catch (e) {
+        return { ...result, error: e instanceof Error ? e : new Error(String(e)) };
+    }
+    return result;
+}

package/dist/utils/loading.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLoading = startLoading;
+exports.withLoading = withLoading;
+const FRAMES = ['|', '/', '-', '\\'];
+function startLoading(label, options = {}) {
+    const stream = options.stream ?? process.stdout;
+    if (!stream.isTTY)
+        return { update: () => undefined, stop: () => undefined };
+    const delayMs = options.delayMs ?? 300;
+    const intervalMs = options.intervalMs ?? 100;
+    let currentLabel = label;
+    let frameIndex = 0;
+    let visible = false;
+    let stopped = false;
+    let interval;
+    const render = () => {
+        if (stopped)
+            return;
+        visible = true;
+        const text = `${currentLabel} ${FRAMES[frameIndex++ % FRAMES.length]}`;
+        stream.write(`\r\u001b[2K${text}`);
+    };
+    const delay = setTimeout(() => {
+        render();
+        interval = setInterval(render, intervalMs);
+    }, delayMs);
+    return {
+        update(nextLabel) {
+            currentLabel = nextLabel;
+            if (visible)
+                render();
+        },
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            clearTimeout(delay);
+            if (interval)
+                clearInterval(interval);
+            if (visible)
+                stream.write('\r\u001b[2K');
+        },
+    };
+}
+async function withLoading(label, task, options = {}) {
+    const loading = startLoading(label, options);
+    try {
+        return await task(loading);
+    }
+    finally {
+        loading.stop();
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "dayloom",
+  "version": "0.1.0-beta.0",
+  "description": "File-based AI life simulation and diary engine.",
+  "main": "dist/index.js",
+  "bin": {
+    "dayloom": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "test": "npm run build && node --test test/init/*.test.js test/revise/*.test.js test/daily/*.test.js test/play/*.test.js test/settle/*.test.js test/next/*.test.js test/i18n/*.test.js"
+  },
+  "keywords": [
+    "dayloom",
+    "command-line"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "files": [
+    "dist",
+    "prompts",
+    "README.md",
+    "package.json"
+  ],
+  "dependencies": {
+    "commander": "^14.0.3",
+    "promptpile": "^0.1.0-beta.0",
+    "promptpile-mcp": "^0.1.0-beta.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "ts-node": "^10.9.2",
+    "typescript": "~5.9.3"
+  }
+}