@prodero/curator 0.0.0-stage → 0.2.0

package/dist/settings-definition.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { DEFAULT_CONTEXT_BUDGET_TOKENS } from './core/telemetry.js';
+export const THEMES = [
+    { id: 'prodero', label: 'Current / Prodero', swatch: '#c6ff76', base: '#0b0d0c' },
+    { id: 'dark-neon', label: 'Dark Neon', swatch: '#b6efff', base: '#020304' },
+    { id: 'pink-neon', label: 'Pink Neon', swatch: '#ff63c5', base: '#090307' },
+    { id: 'blue-neon', label: 'Blue Neon', swatch: '#55c9ff', base: '#020710' },
+    { id: 'purple-neon', label: 'Purple Neon', swatch: '#b98aff', base: '#07030e' },
+    { id: 'light', label: 'Light', swatch: '#3e6516', base: '#f7f9fc' },
+    { id: 'system', label: 'System', swatch: '#a0adbd', base: '#f7f9fc' },
+];
+export const modeSchema = z.enum(['auto', 'ui', 'text']);
+export const themeSchema = z.enum(['prodero', 'dark-neon', 'pink-neon', 'blue-neon', 'purple-neon', 'light', 'system']);
+export const presentationConfigSchema = z.object({ mode: modeSchema.optional(), theme: themeSchema.optional() }).passthrough();
+export const SETTINGS = [
+    { key: 'presentation.mode', group: 'Presentation', label: 'Display mode', description: 'Choose automatic display, interactive UI, or text on this checkout.', type: 'enum', defaultValue: 'auto', options: [{ id: 'auto', label: 'Automatic', description: 'Use MCP Apps when advertised, otherwise readable text.' }, { id: 'ui', label: 'UI', description: 'Prefer the interactive Prodero application on this checkout.' }, { id: 'text', label: 'Text', description: 'Use readable text on this checkout.' }], validation: modeSchema },
+    { key: 'presentation.theme', group: 'Presentation', label: 'Theme', description: 'Visual theme used by Prodero on this checkout.', type: 'enum', defaultValue: 'prodero', options: THEMES, validation: themeSchema },
+    { key: 'context.max_tokens', group: 'Context', label: 'Task context budget', description: 'Maximum Prodero context budget prepared for a task.', type: 'integer', defaultValue: DEFAULT_CONTEXT_BUDGET_TOKENS, unit: 'tokens', min: 1, max: 1000000, validation: z.number().int().min(1).max(1000000) },
+];
+export const settingKeySchema = z.enum(['presentation.mode', 'presentation.theme', 'context.max_tokens']);
+export const SETTINGS_ROUTING = 'For requests to show Prodero settings, project settings, or Prodero config, call prodero_config_get and show its friendly settings view. For project preference changes use prodero_config_set: text-only/text mode → presentation.mode=text; switch back to UI → presentation.mode=ui; automatic presentation → presentation.mode=auto; blue/purple neon → presentation.theme=blue-neon/purple-neon; context budget 8000 → context.max_tokens=8000. Display mode/theme are ignored checkout-local preferences; context budget remains shared project configuration. Legacy project presentation defaults remain fallback. Use reset:true without value to remove only the requested local presentation override. Never store settings as knowledge. Resolve the current project on each call. Read effective settings when choosing the text gateway; do not rely on a previous project or conversational preference.';
+//# sourceMappingURL=settings-definition.js.map

package/dist/skill-instructions.js

@@ -0,0 +1,2 @@
+export const SKILL_EXECUTION_ROUTING = "For agent skill discovery or procedure retrieval during task execution, use prodero_skills_read without opening UI. Reuse skill procedures already supplied by Prepare. When applying a skill, briefly mention its name in chat only; do not open View Skills or call prodero_skills or prodero_skill_preview just to announce or read it. Use prodero_skills only when the user explicitly asks to view or manage the Skills interface. Candidate review still uses prodero_skill_preview on user intent.";
+//# sourceMappingURL=skill-instructions.js.map

package/dist/status-presentation.js

@@ -0,0 +1,20 @@
+import { publicDiagnostic } from './core/diagnostics.js';
+import { PRODERO_VERSION } from './core/constants.js';
+import { MEMORY_COPY } from './memory-presentation.js';
+const plain = (value) => value.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ').trim();
+export function statusFailure(error, scope, migration) {
+    const message = plain(publicDiagnostic(error)), code = /^(PRODERO_[A-Z0-9_]+):/.exec(message)?.[1] ?? 'PRODERO_STATUS_FAILED';
+    return { ok: false, version: PRODERO_VERSION, scope, error: { code, message, recovery: migration ? plain(publicDiagnostic(migration.recovery ?? (migration.state === 'runtime-too-old' ? 'Update Curator before reading this project.' : 'Run prodero migrate status with this project root to review the required update.'))) : 'Check the command arguments, selected root, and preserved configuration before retrying.' }, ...(migration ? { migration: { ...migration, ...(migration.diagnostic ? { diagnostic: plain(publicDiagnostic(migration.diagnostic)) } : {}), ...(migration.recovery ? { recovery: plain(publicDiagnostic(migration.recovery)) } : {}) } } : {}) };
+}
+export function renderStatusFailure(result) {
+    return [`Prodero ${result.version} · ${result.scope} status unavailable`, `${result.error.code}: ${result.error.message}`, result.error.recovery, ...(result.migration ? [`Project update: ${result.migration.state}`] : [])].join('\n');
+}
+const yes = (value) => value === null ? 'unknown' : value ? 'yes' : 'no';
+export function renderMachineStatus(result) {
+    return [`Prodero ${result.version}`, `Machine integrations${result.ok ? '' : ' · attention required'}`, ...result.hosts.flatMap(h => [`${h.name}: ${h.state.replaceAll('-', ' ')}`, `  Detected: ${yes(h.detected)} · MCP configured: ${yes(h.mcpConfigured)} · Launcher installed: ${yes(h.launcherInstalled)}${h.runtimeMode ? ` · Runtime: ${h.runtimeMode}` : ''}`, `  ${plain(publicDiagnostic(h.message))}`])].join('\n');
+}
+export function renderProjectStatus(result) {
+    const p = result.project, u = result.update;
+    return [`Prodero ${result.version}`, `Project: ${plain(p.name)} (${plain(p.root)})`, `Initialized: ${yes(p.initialized)} · Git repository: ${yes(p.git)} · Project instructions: ${yes(p.agentsFile)}`, ...(p.initialized ? [`Project schema: ${p.schemaVersion}`, `Knowledge: ${p.knowledgeCount} current · ${p.localKnowledgeCount} Local · ${p.versionedKnowledgeCount} Versioned`, `Sessions: ${p.sessionCount} total · ${p.activeSessionCount} active · ${p.pendingSessionCount} pending`, `Skills: ${p.skillCount} active · ${p.skillCandidateCount} candidates`, `Checkpoints: ${p.checkpointCount} · Last sync: ${p.lastSyncAt ?? 'never'}`, `Needs attention: ${p.conflictCount} conflicts · ${p.knowledgeGraph.brokenReferences} broken references · ${p.promotionRecommendedCount} sharing suggestions`].concat(p.memoryHealth?.missingProvenanceItems ? [`Provenance: ${p.memoryHealth.missingProvenanceItems} current records with incomplete metadata. ${MEMORY_COPY.incompleteProvenance}`] : []) : ['Project is not initialized. Run prodero init with --root set to this directory.']), u.status === 'current' ? `Update: current (${u.current})` : u.status === 'update-available' ? `Update available: ${u.current} → ${u.latest}` : `Update check ${u.status}: ${plain(publicDiagnostic(u.error ?? 'No release information is available.'))}`, ...(u.status === 'update-available' && u.manualUpdateCommand ? [u.manualUpdateCommand] : [])].join('\n');
+}
+//# sourceMappingURL=status-presentation.js.map

package/dist/text-layout.js

@@ -0,0 +1,278 @@
+import { numberedActions } from './conversation-presentation.js';
+const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+const graphemes = (s) => Array.from(segmenter.segment(s), x => x.segment);
+const glyphWidth = (s) => {
+    const n = s.codePointAt(0) ?? 0;
+    if (/^[\p{Mark}]+$/u.test(s))
+        return 0;
+    return /[\p{Extended_Pictographic}\p{Regional_Indicator}\u20e3]/u.test(s) || n >= 0x1100 && (n <= 0x115f || n >= 0x2e80 && n <= 0xa4cf || n >= 0xac00 && n <= 0xd7a3 || n >= 0xf900 && n <= 0xfaff || n >= 0xfe10 && n <= 0xfe6f || n >= 0xff01 && n <= 0xff60 || n >= 0x20000 && n <= 0x3ffff) ? 2 : 1;
+};
+export const textWidth = (s) => graphemes(s).reduce((n, g) => n + glyphWidth(g), 0);
+// Formatting never permits terminal escapes, bidi controls or injected fence endings.
+// Newlines and literal code/body spacing survive in the verbatim fallback below.
+export const safeText = (s) => String(s ?? '').replace(/\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~])/g, '').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, '');
+export function wrapText(raw, width) {
+    const result = [];
+    for (const paragraph of safeText(raw).replace(/\t/g, '    ').split(/\r?\n/)) {
+        let line = '', used = 0;
+        for (const g of graphemes(paragraph)) {
+            const size = glyphWidth(g);
+            if (used + size > width && line) {
+                const cut = line.lastIndexOf(' ');
+                if (cut > 0) {
+                    result.push(line.slice(0, cut));
+                    line = line.slice(cut + 1);
+                    used = textWidth(line);
+                }
+                else {
+                    result.push(line);
+                    line = '';
+                    used = 0;
+                }
+            }
+            line += g;
+            used += size;
+        }
+        result.push(line);
+    }
+    return result;
+}
+/** Dynamic fences retain complete Markdown/code examples without escaping their wording. */
+export function textFence(content) {
+    const text = safeText(content);
+    let longest = 2;
+    for (const m of text.matchAll(/`+/g))
+        longest = Math.max(longest, m[0].length);
+    const fence = '`'.repeat(longest + 1);
+    return `${fence}text\n${text}\n${fence}`;
+}
+export function entryKey(index) {
+    let n = index + 1, key = '';
+    do {
+        n--;
+        key = String.fromCharCode(65 + n % 26) + key;
+        n = Math.floor(n / 26);
+    } while (n);
+    return key;
+}
+const number = (n) => n.toLocaleString('en-US');
+export function budgetLines(b) {
+    if (!Number.isFinite(b.used) || !Number.isFinite(b.total) || b.used < 0 || b.total <= 0)
+        return ['Budget unavailable.'];
+    const percent = Math.round(b.used / b.total * 100);
+    const filled = Math.max(0, Math.min(25, Math.round(b.used / b.total * 25)));
+    return ['▰'.repeat(filled) + '▱'.repeat(25 - filled) + ` ${percent}%`, `${number(b.used)} / ${number(b.total)} est. tokens`, `${b.source} · Prodero allocation only.`, ...(b.used > b.total ? ['Allocation exceeds its budget.'] : [])];
+}
+export function renderProductText(vm, diagnostics = false, expanded = diagnostics, plain = false) {
+    const scene = vm.textScene, action = scene?.action, v = vm.conversation;
+    const width = 38, prefix = plain ? '| ' : '│ ', rule = plain ? '-' : '─';
+    const screens = { open: '01', status: '01', 'status-details': '01', initialized: '01', knowledge: '02', 'knowledge-mutated': '02', prepare: '03', context: '03', 'memory-sync': '04', 'curation-question': '04', curation: '05', 'instruction-review': '06', 'instruction-optimize': '06', 'promotion-preview': '07', 'promotion-applied': '07', 'session-close': '08', 'session-review': '08', 'config-get': '09', 'update-instructions': '10', migration: '10', error: '00' };
+    const screen = vm.knowledgeTable ? '02' : screens[action ?? ''] ?? '00';
+    const head = `${plain ? '+-' : '╭─'} >_ PRODERO `;
+    const lines = [head + rule.repeat(width - textWidth(head) - 4) + ` /${screen}`];
+    const line = (text = '') => {
+        const indent = (text.match(/^ +/)?.[0] ?? '').slice(0, 12);
+        lines.push(...wrapText(text.slice(indent.length), width - 2 - indent.length).map(s => prefix.trimEnd() + (s.trimEnd() ? ' ' + indent + s.trimEnd() : '')));
+    };
+    const section = (title) => {
+        if (textWidth(safeText(title)) > width - 5) {
+            lines.push((plain ? '+' : '├') + rule.repeat(width - 1));
+            line(title);
+            return;
+        }
+        const parts = wrapText(title, width - 5);
+        const p = `${plain ? '+-' : '├─'} ${parts.shift()} `;
+        lines.push(p + rule.repeat(Math.max(0, width - textWidth(p))));
+        parts.forEach(part => line(part));
+    };
+    const inset = () => { line(); lines.push(prefix + '  ' + rule.repeat(27)); line(); };
+    const title = vm.title.replace(/^Prodero · /, '');
+    line(action === 'update-instructions' ? 'Prodero · terminal update' : scene?.project ? `${scene.project} · project memory` : 'Prodero');
+    line();
+    const prepared = action === 'prepare' || action === 'context';
+    const full = expanded || !v || v.kind === 'details';
+    const compactReady = prepared && !full && !v?.blocking && !v?.attention.length;
+    if (compactReady) {
+        const compact = ['>_ PRODERO /03 · Context Ready'];
+        if (scene?.project)
+            compact.push(...wrapText(scene.project, width));
+        compact.push(...wrapText(v?.facts.find(x => x.includes(' required · ')) ?? '', width));
+        if (scene?.budget)
+            compact.push(...wrapText(`${number(scene.budget.used)} / ${number(scene.budget.total)} est. Prodero tokens`, width));
+        compact.push('Ready · continuing the task');
+        return textFence(compact.join('\n'));
+    }
+    // Exact bodies are deliberately unframed: long code/paths and whitespace are not
+    // truncated or rewritten merely to fit a phone. The panel remains bounded.
+    const bodies = [];
+    const verbatim = (heading, items) => {
+        if (!items.length)
+            return;
+        bodies.push(`${heading}:\n` + items.map(i => [i.title, i.body, ...i.notes].filter(Boolean).join('\n')).join('\n\n   ' + rule.repeat(27) + '\n\n'));
+    };
+    if (scene?.home && !full) {
+        const h = scene.home;
+        if (h.initialized) {
+            if (action === 'initialized') {
+                line('Initialized');
+                line();
+            }
+            section('CONTEXT');
+            if (scene.budget)
+                budgetLines(scene.budget).forEach(x => line(plain ? x.replaceAll('▰', '#').replaceAll('▱', '.') : x));
+            else
+                line('Task allocation not prepared here.');
+            line();
+            section('MEMORY');
+            if (h.records !== undefined)
+                line(`${number(h.records)} records`);
+            if (h.local !== undefined && h.versioned !== undefined)
+                line(`${number(h.local)} local · ${number(h.versioned)} versioned`);
+            line();
+            section('ATTENTION');
+            if (h.deferred !== undefined)
+                line(`? ${h.deferred} deferred questions`);
+            if (h.pending !== undefined)
+                line(`Δ ${h.pending} unapplied change groups`);
+            (v?.attention ?? []).forEach(x => line(x));
+            if (!v?.attention.length && h.deferred === undefined && h.pending === undefined)
+                line(action === 'status' && h.records === undefined ? 'Lightweight status; counts not loaded.' : 'No attention needed.');
+            // Session activity is real data, not evidence of a background agent.
+            v?.facts.filter(x => x.startsWith('Session')).forEach(x => line(x));
+        }
+        else {
+            section(v?.state ?? title);
+            (v?.facts ?? vm.notices).forEach(x => line(x));
+            v?.attention.forEach(x => line(x));
+        }
+    }
+    else if (prepared) {
+        section(v?.blocking ? v.state : v?.attention.length ? 'Attention' : action === 'prepare' ? 'Context Ready' : 'View Context');
+        if (!compactReady && scene?.task)
+            line(`Task: ${scene.task}`);
+        if (!v?.blocking)
+            line(action === 'context' ? 'Read-only context view.' : v?.attention.length ? 'Task is not blocked; see attention.' : 'Ready · continuing the task');
+        const facts = v?.facts.filter(x => !x.startsWith('Context  ')) ?? [];
+        if (!compactReady) {
+            line();
+            section('PROVIDED TO AGENT');
+        }
+        facts.forEach(x => line(x));
+        if (scene?.budget) {
+            if (!compactReady) {
+                line();
+                section('PRODERO CONTEXT');
+                budgetLines(scene.budget).forEach(x => line(plain ? x.replaceAll('▰', '#').replaceAll('▱', '.') : x));
+            }
+            else
+                line(`${number(scene.budget.used)} / ${number(scene.budget.total)} est. Prodero tokens`);
+        }
+        if (v?.attention.length) {
+            line();
+            section('ATTENTION');
+            v.attention.forEach(x => line(x));
+        }
+        if (full)
+            for (const s of vm.sections) {
+                section(s.title);
+                s.items.forEach((i, index) => { if (index)
+                    inset(); line(i.title); });
+                verbatim(s.title, s.items);
+            }
+    }
+    else if (vm.knowledgeTable) {
+        const t = vm.knowledgeTable;
+        section('KNOWLEDGE');
+        line(t.rows.length ? `Showing ${t.offset + 1}-${t.offset + t.rows.length} of ${t.total}` : 'No knowledge matches these filters.');
+        t.rows.forEach((r, index) => {
+            if (index)
+                inset();
+            else
+                line();
+            line(`${r.key} · ${r.title}`);
+            line(`  ${r.layer}`);
+            const preview = vm.sections.find(s => s.title === 'Knowledge')?.items[index]?.body;
+            if (preview) {
+                const flat = safeText(preview).replace(/\s+/g, ' ').trim();
+                const summary = graphemes(flat).slice(0, 90).join('');
+                line('  ' + summary + (summary.length < flat.length ? '…' : ''));
+            }
+        });
+        if (t.rows.length) {
+            line();
+            line('Enter a letter to open its record.');
+        }
+        if (expanded)
+            verbatim('Knowledge', vm.sections.find(s => s.title === 'Knowledge')?.items ?? []);
+    }
+    else {
+        if (action === 'memory-sync') {
+            section('CURATE MEMORY');
+            const state = full ? title.replace(/^Curate Memory · /, '') : v?.state ?? title;
+            if (state !== 'Curate Memory')
+                line(state);
+        }
+        else
+            section(action === 'session-close' ? 'Session closed' : v?.kind !== 'details' && !full ? v?.state ?? title : title);
+        if (action === 'session-close')
+            line(v?.state ?? 'Check saved state');
+        if (full && v?.reviewRequired)
+            line('Review required · not approval.');
+        if (!full && v?.kind !== 'details') {
+            v?.facts.forEach(x => line(x));
+            if (v?.attention.length) {
+                line();
+                section('ATTENTION');
+                v.attention.forEach(x => line(x));
+            }
+        }
+        else {
+            vm.metrics.forEach(m => line(`${m.label}  ${m.value}${m.detail ? ' · ' + m.detail : ''}`));
+            if (!vm.sections.some(s => s.title === 'Knowledge detail'))
+                vm.notices.forEach(x => line(x));
+            for (const s of vm.sections) {
+                section(s.title);
+                s.items.forEach((i, n) => { if (n)
+                    inset(); line(i.title); });
+                verbatim(s.title, s.items);
+            }
+        }
+    }
+    // Exact reviews precede the approval menu; reading and approving remain distinct.
+    if (v?.prompt) {
+        line();
+        wrapText(v.prompt, width - 2).forEach(x => line(x));
+    }
+    lines.push((plain ? '+' : '╰') + rule.repeat(width - 1));
+    const actions = numberedActions(vm, full);
+    const menu = [];
+    if (actions.length) {
+        menu.push('', 'Available actions:', '');
+        for (const a of actions) {
+            const key = `  ${a.number} > `;
+            const parts = wrapText(a.label, width - key.length);
+            menu.push(key + parts[0], ...parts.slice(1).map(x => ' '.repeat(key.length) + x));
+            if (a.approval)
+                menu.push('      Explicit approval required.');
+            if (a.input)
+                menu.push(...wrapText(a.input.prompt, width - 6).map(x => '      ' + x));
+        }
+        menu.push('', 'Reply with a number or the command name.');
+    }
+    // Keep the service separator outside the record and its metadata.
+    if (vm.sections.some(s => s.title === 'Knowledge detail'))
+        bodies.push('-------------\n' + vm.notices.join('\n'));
+    if (diagnostics || action === 'curation' || full && action === 'migration')
+        for (const s of vm.diagnostics ?? [])
+            verbatim(s.title, s.items);
+    const panel = textFence(lines.join('\n'));
+    const exact = bodies.map(textFence);
+    const approval = full && actions.some(a => a.approval) && (action === 'memory-sync' || action === 'migration')
+        ? action === 'memory-sync' ? 'Approve these exact changes?' : `${actions.find(a => a.approval).label}?` : '';
+    return [panel, ...exact, menu.length ? textFence(menu.join('\n').replace(/^\n/, '').trimEnd()) : '', approval].filter(Boolean).join('\n\n');
+}
+/** Public sanitized errors have no executable retry/apply action. */
+export function renderTextError(message, plain = false) {
+    return renderProductText({ version: 1, title: 'Prodero · Error', metrics: [], notices: [message], sections: [], actions: [], textScene: { action: 'error' } }, false, true, plain);
+}
+//# sourceMappingURL=text-layout.js.map

package/dist/update-command.js

@@ -0,0 +1,53 @@
+import { createInterface } from 'node:readline/promises';
+import { runNpmUpdate, NpmUpdateError } from './core/npm-update.js';
+const help = `Usage: prodero update [exact-version] [--yes]
+
+Finish work and close Codex and Claude before updating. The terminal waits for
+npm and verifies the installed CLI; reopen your applications and reconnect afterward.
+Only an ordinary same-user global npm installation with Node 22.14–22.x/npm 10.9.x
+is supported. Install scripts are disabled; project and host settings are untouched.
+
+Without a version, an interactive terminal checks the latest public release.
+Non-interactive use requires an exact stable version and --yes, confirming that
+work has ended and applications are closed. Equal versions are a no-op; downgrades
+are refused. No sudo, automatic application closing or package rollback is used.`;
+/** Closing stdin or Ctrl-C at the maintenance prompt is a refusal. */
+export function terminalConfirmation(question, input = process.stdin, output = process.stdout) {
+    const terminal = createInterface({ input, output });
+    return new Promise(resolve => { let done = false; const finish = (answer) => { if (done)
+        return; done = true; terminal.close(); resolve(answer); }; terminal.once('close', () => finish(false)); terminal.once('SIGINT', () => finish(false)); terminal.question(question).then(answer => finish(/^y(?:es)?$/i.test(answer.trim())), () => finish(false)); });
+}
+export async function updateCommand(args, dependencies = {}) {
+    if (args.length === 1 && ['--help', '-h'].includes(args[0])) {
+        (dependencies.write ?? console.log)(help);
+        return 0;
+    }
+    let yes = false, targetVersion;
+    for (const arg of args) {
+        if (arg === '--yes') {
+            if (yes)
+                throw new NpmUpdateError('NPM_UPDATE_ARGUMENT', 'Specify --yes only once.');
+            yes = true;
+        }
+        else if (arg.startsWith('-') || targetVersion !== undefined)
+            throw new NpmUpdateError('NPM_UPDATE_ARGUMENT', 'Use prodero update [exact-version] [--yes].');
+        else
+            targetVersion = arg;
+    }
+    const write = dependencies.write ?? console.log;
+    const confirm = dependencies.confirm ?? terminalConfirmation;
+    try {
+        const result = await runNpmUpdate({ targetVersion, yes }, { ...dependencies, write, confirm, interactive: dependencies.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY) });
+        write(result.message);
+        return result.exitCode;
+    }
+    catch (error) {
+        if (error instanceof NpmUpdateError) {
+            write(`${error.code}: ${error.message}`);
+            return error.exitCode;
+        }
+        write('NPM_UPDATE_FAILED: Cannot complete or verify this update. Inspect this npm installation before retrying.');
+        return 1;
+    }
+}
+//# sourceMappingURL=update-command.js.map

package/dist/update-instructions.js

@@ -0,0 +1,4 @@
+/** Shared copy only: safe to bundle into the App; no execution or host access. */
+export const MANUAL_UPDATE_COMMAND = 'prodero update';
+export const UPDATE_INSTRUCTIONS = 'Finish the current work and close your MCP hosts. In a terminal, run prodero update and review its plan before approving installation. After the terminal reports completion, restart and reconnect your hosts. Open Prodero again and review any project knowledge migration separately. This chat action only shows instructions; it has not installed or staged a runtime, refreshed project integration, or changed your development runtime selection.';
+//# sourceMappingURL=update-instructions.js.map