@prodero/curator 0.0.0-stage → 0.2.0

package/dist/hosts/wizard.js

@@ -0,0 +1,114 @@
+import { createInterface } from 'node:readline/promises';
+import { PRODERO_VERSION } from '../core/constants.js';
+import { machineIntegrations } from './manager.js';
+const labels = {
+    installed: 'Installed',
+    'externally-configured': 'Already configured (prodero-dev, manual)',
+    'external-incomplete': 'Manual setup needs attention',
+    'not-configured': 'Not configured',
+    'not-detected': 'Agent not found',
+    outdated: 'Update available',
+    conflicted: 'Configuration needs review',
+    'unsupported-configuration': 'Cannot read or update configuration',
+    'recovery-required': 'Recovery required',
+    unsupported: 'Not supported yet',
+};
+const actionable = (host) => host.state === 'outdated' || (host.detected && host.state === 'not-configured');
+const needsAttention = (host) => ['conflicted', 'unsupported-configuration', 'recovery-required', 'external-incomplete'].includes(host.state);
+// Native paths can contain terminal control characters. Never render those as commands.
+const printable = (text) => text.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ');
+export async function runInstallWizard(io, options = {}) {
+    io.write(`\n  Prodero ${PRODERO_VERSION} · Installation\n`);
+    io.write('  Configure Prodero for your coding agents.\n');
+    let result = await machineIntegrations('status', undefined, options);
+    while (true) {
+        io.write('\n  Agent          Prodero status\n  ───────────────────────────────────────────────────────────\n');
+        for (const host of result.hosts) {
+            io.write(`  ${host.name.padEnd(15)}${labels[host.state] ?? host.state}${host.runtimeMode === 'dev' ? ' · dev' : ''}${host.support === 'experimental' ? ' · Experimental' : ''}\n`);
+            if (needsAttention(host) || host.state === 'externally-configured') {
+                io.write(`    ${printable(host.message).replace(/^HOST_[A-Z_]+: /, '')}\n`);
+            }
+        }
+        io.write('\n  Status reflects saved settings; server connectivity is not tested.\n');
+        const available = result.hosts.filter(actionable);
+        if (!io.interactive) {
+            io.write('\n  Open an interactive terminal and run prodero install to choose an agent.\n  No settings were changed.\n');
+            return 1;
+        }
+        if (!available.length) {
+            io.write(needsAttentionIn(result.hosts)
+                ? '\n  Review the settings above, then run prodero install again.\n'
+                : '\n  No agents need installation. Run prodero install again after adding an agent.\n');
+            return needsAttentionIn(result.hosts) ? 1 : 0;
+        }
+        io.write('\n  Choose an action\n');
+        available.forEach((host, index) => io.write(`  ${index + 1}. ${host.state === 'outdated' ? 'Update' : 'Install for'} ${host.name}${host.support === 'experimental' ? ' (experimental)' : ''}\n`));
+        io.write('  0. Finish\n\n');
+        const answer = (await io.question('  Selection [0]: '))?.trim();
+        if (answer === null || answer === undefined || answer === '' || answer === '0') {
+            io.write('\n  Finished.\n');
+            return needsAttentionIn(result.hosts) ? 1 : 0;
+        }
+        if (!/^[1-9]\d*$/.test(answer) || !available[Number(answer) - 1]) {
+            io.write('\n  Enter a number from the menu.\n');
+            continue;
+        }
+        const selected = available[Number(answer) - 1];
+        io.write(`\n  ${selected.state === 'outdated' ? 'Update' : 'Install'} Prodero for ${selected.name}\n`);
+        io.write('  This configures the MCP server and global launch instruction.\n  Existing unrelated settings are preserved; changes are backed up locally.\n');
+        if (selected.support === 'experimental')
+            io.write('  Claude Code support is experimental.\n');
+        const confirmation = (await io.question('  Continue? [y/N]: '))?.trim().toLowerCase();
+        if (confirmation !== 'y' && confirmation !== 'yes') {
+            io.write('\n  Cancelled. No settings were changed for this agent.\n');
+            if (confirmation === undefined)
+                return 0;
+            continue;
+        }
+        io.write(`\n  Configuring ${selected.name}…\n`);
+        const installed = await machineIntegrations('install', selected.id, options);
+        const host = installed.hosts.find(item => item.id === selected.id);
+        if (host.state === 'installed') {
+            io.write(`  ✓ Prodero is installed for ${selected.name}.\n  Restart ${selected.name}, open a repository and type prodero.\n`);
+        }
+        else {
+            io.write(`  ${printable(host.message)}\n`);
+        }
+        // Re-read the settings after each action, including failures and concurrent edits.
+        result = await machineIntegrations('status', undefined, options);
+        if (!installed.ok)
+            return 1;
+    }
+}
+function needsAttentionIn(hosts) { return hosts.some(needsAttention); }
+export async function installWizard() {
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (!interactive)
+        return runInstallWizard({ interactive, write: text => process.stdout.write(text), question: async () => null });
+    const terminal = createInterface({ input: process.stdin, output: process.stdout });
+    const abort = new AbortController();
+    terminal.on('close', () => abort.abort());
+    terminal.on('SIGINT', () => terminal.close());
+    try {
+        return await runInstallWizard({
+            interactive,
+            write: text => process.stdout.write(text),
+            async question(prompt) {
+                if (abort.signal.aborted)
+                    return null;
+                try {
+                    return await terminal.question(prompt, { signal: abort.signal });
+                }
+                catch (error) {
+                    if (abort.signal.aborted)
+                        return null;
+                    throw error;
+                }
+            },
+        });
+    }
+    finally {
+        terminal.close();
+    }
+}
+//# sourceMappingURL=wizard.js.map

package/dist/knowledge-table.js

@@ -0,0 +1,38 @@
+const segments = new Intl.Segmenter('en', { granularity: 'grapheme' });
+const width = (s) => {
+    const cp = s.codePointAt(0) ?? 0;
+    return /\p{Extended_Pictographic}/u.test(s) || cp >= 0x1100 && (cp <= 0x115f || cp >= 0x2e80 && cp <= 0xa4cf || cp >= 0xac00 && cp <= 0xd7a3 ||
+        cp >= 0xf900 && cp <= 0xfaff || cp >= 0xfe10 && cp <= 0xfe6f ||
+        cp >= 0xff01 && cp <= 0xff60 || cp >= 0x20000 && cp <= 0x3ffff) ? 2 : 1;
+};
+const cells = (value, limit) => {
+    // Titles are untrusted data: keep terminal controls and Markdown fences out.
+    const text = value.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').replace(/[\p{Cc}\p{Cf}]/gu, ' ').replace(/`/g, "'").replace(/\|/g, '/').replace(/\s+/g, ' ').trim();
+    const lines = [];
+    let line = '', used = 0;
+    for (const { segment } of segments.segment(text)) {
+        const size = width(segment);
+        if (used + size > limit) {
+            lines.push(line + ' '.repeat(limit - used));
+            line = '';
+            used = 0;
+        }
+        line += segment;
+        used += size;
+    }
+    lines.push(line + ' '.repeat(limit - used));
+    return lines;
+};
+export function renderKnowledgeTable(rows) {
+    if (!rows.length)
+        return 'No knowledge matches these filters.';
+    const widths = [5, 44, 11, 10, 9];
+    const border = '+' + widths.map(w => '-'.repeat(w + 2)).join('+') + '+';
+    const row = (values) => {
+        const columns = values.map((v, i) => cells(v, widths[i]));
+        return Array.from({ length: Math.max(...columns.map(c => c.length)) }, (_, i) => '| ' + columns.map((c, j) => c[i] ?? ' '.repeat(widths[j])).join(' | ') + ' |').join('\n');
+    };
+    return ['```text', border, row(['#', 'Knowledge', 'Type', 'Priority', 'Layer']), border,
+        ...rows.flatMap(r => [row([r.key, r.title, r.category, r.priority, r.layer]), border]), '```'].join('\n');
+}
+//# sourceMappingURL=knowledge-table.js.map

package/dist/mcp-development.js

@@ -0,0 +1,69 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { environment, receiptSchema } from './hosts/manager.js';
+import { resolveNpmCli } from './hosts/public-entry.js';
+import { read, fail } from './hosts/files.js';
+/** Read installation state only to choose runtime CODE, never workspace authority. */
+export async function developmentRoot(explicit) {
+    if (explicit !== undefined) {
+        if (!path.isAbsolute(explicit))
+            fail('HOST_UNSUPPORTED_PATH', '--checkout must be absolute.');
+        return fs.realpath(explicit);
+    }
+    const { home, state } = environment({});
+    const executable = await fs.realpath(fileURLToPath(new URL('../bin/prodero', import.meta.url)));
+    const roots = new Set();
+    for (const host of ['codex', 'claude']) {
+        const dir = path.join(state, host);
+        const saved = await read(home, path.join(dir, 'receipt.json'));
+        if (saved === null)
+            continue;
+        let receipt;
+        try {
+            receipt = receiptSchema.parse(JSON.parse(saved));
+        }
+        catch {
+            fail('HOST_UNSUPPORTED_CONFIG', 'Invalid integration receipt. Repair the managed integration before using --dev.');
+        }
+        if (receipt.host !== host)
+            fail('HOST_UNSUPPORTED_CONFIG', 'Integration receipt host mismatch.');
+        if (receipt.format !== 2 || !receipt.runtime.devRoot || !receipt.runtime.devEntry)
+            continue;
+        const dev = receipt.runtime.devEntry;
+        // An explicit multi-checkout entry does not compete with an ordinary --dev entry.
+        if (JSON.stringify(dev.args) !== JSON.stringify(['mcp', '--dev']) || await fs.realpath(dev.command).catch(() => null) !== executable)
+            continue;
+        if (await read(home, path.join(dir, 'pending.json')) !== null || await fs.lstat(path.join(dir, 'lock')).catch(() => null))
+            fail('HOST_RECOVERY_REQUIRED', 'Integration update is incomplete. Reconnect after recovery.');
+        const { runtime } = receipt;
+        const stable = (value) => JSON.stringify(value, (_k, v) => v && typeof v === 'object' && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b))) : v);
+        if (stable(receipt.entry) !== stable(runtime.mode === 'dev' ? runtime.devEntry : runtime.packageEntry))
+            fail('HOST_UNSUPPORTED_CONFIG', 'Inconsistent runtime receipt.');
+        const root = runtime.devRoot;
+        if (!path.isAbsolute(root) || await fs.realpath(root).catch(() => null) !== root)
+            fail('HOST_RUNTIME_MISSING', 'Saved development checkout was moved or replaced. Select it again with prodero runtime dev.');
+        roots.add(root);
+    }
+    if (roots.size !== 1)
+        fail('HOST_RUNTIME_MISSING', roots.size ? 'Multiple development checkouts are configured. Use an explicit --checkout or switch the host runtime again.' : 'No managed development checkout for this executable. Run prodero runtime dev --host HOST --checkout PATH.');
+    return [...roots][0];
+}
+export async function startDevelopmentRuntime(localStdio, options) {
+    const root = await developmentRoot(options.checkout);
+    let metadata;
+    try {
+        metadata = JSON.parse(await fs.readFile(path.join(root, 'package.json'), 'utf8'));
+    }
+    catch {
+        fail('HOST_RUNTIME_MISSING', 'Cannot read development runtime metadata.');
+    }
+    if (!['@prodero/curator', '@prodero/cli'].includes(metadata.name ?? ''))
+        fail('HOST_RUNTIME_MISSING', 'Development runtime must be a Prodero checkout.');
+    const npmCli = await resolveNpmCli(process.env);
+    const entry = path.join(root, 'scripts/mcp-dev-launcher.mjs');
+    const { startDevelopmentServer } = await import(pathToFileURL(entry).href);
+    // In-process transfer of the captured object: never serialize authority into env or tool metadata.
+    await startDevelopmentServer(localStdio, options.projectRoot, npmCli);
+}
+//# sourceMappingURL=mcp-development.js.map

package/dist/mcp-workspace.js

@@ -0,0 +1,141 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import fs from 'node:fs/promises';
+import { realpathSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { explicitProjectRoot } from './core/project-root.js';
+function pin(value) {
+    if (!value.trim() || !path.isAbsolute(value))
+        throw new Error('Project root must be an absolute existing directory.');
+    try {
+        const canonical = realpathSync(value);
+        if (!statSync(canonical).isDirectory())
+            throw new Error();
+        return Object.freeze({ path: path.resolve(value), canonical });
+    }
+    catch {
+        throw new Error('Project root is not an existing directory.');
+    }
+}
+/** Capture before build/npm can change the workspace. PWD and INIT_CWD are never read. */
+export function captureLocalStdioContext() {
+    let claudeProject, invalidClaudeProject = false;
+    if (process.env.CLAUDE_PROJECT_DIR !== undefined) {
+        try {
+            claudeProject = pin(process.env.CLAUDE_PROJECT_DIR);
+        }
+        catch {
+            invalidClaudeProject = true;
+        }
+    }
+    return Object.freeze({ cwd: pin(process.cwd()), claudeProject, invalidClaudeProject,
+        // npm scripts execute in their package, not necessarily in the host workspace.
+        // This flag only disables launch authority; environment data never grant it.
+        indirectLaunch: Boolean(process.env.npm_lifecycle_event) });
+}
+async function canonical(value) {
+    if (!value.trim() || !path.isAbsolute(value))
+        throw new Error('Project root must be an absolute existing directory.');
+    const root = await fs.realpath(value).catch(() => null);
+    if (!root || !(await fs.stat(root).catch(() => null))?.isDirectory())
+        throw new Error('Project root is not an existing directory.');
+    return root;
+}
+async function recheck(root) {
+    if (await canonical(root.path) !== root.canonical)
+        throw new Error('PRODERO_ROOT_UNAUTHORIZED: Workspace boundary changed. Reconnect from the intended workspace.');
+    return root;
+}
+/** One lazy authority snapshot and selected root per tools/call, including Apps/plugins/text. */
+export function installWorkspaceBoundary(server, options) {
+    const fixed = options.projectRoot === undefined ? undefined : pin(options.projectRoot);
+    const launch = options.localStdio;
+    // Remember identities only to detect replacement; this map never grants access.
+    const hostIdentities = new Map();
+    const operations = new AsyncLocalStorage();
+    const register = server.server.setRequestHandler.bind(server.server);
+    server.server.setRequestHandler = (schema, handler) => register(schema, (request, extra) => request.method === 'tools/call' ? operations.run({}, () => handler(request, extra)) : handler(request, extra));
+    async function authority() {
+        if (fixed)
+            return { roots: [await recheck(fixed)], primary: fixed };
+        const client = server.server.getClientVersion()?.name;
+        const claude = client === 'claude-code';
+        if (server.server.getClientCapabilities()?.roots) {
+            let roots;
+            try {
+                roots = (await server.server.listRoots()).roots;
+            }
+            catch {
+                throw new Error('PRODERO_WORKSPACE_UNAVAILABLE: Cannot read MCP workspace roots. Reconnect the host.');
+            }
+            const unique = new Map();
+            try {
+                for (const { uri } of roots) {
+                    const url = new URL(uri);
+                    if (url.protocol !== 'file:')
+                        throw new Error();
+                    const value = path.resolve(fileURLToPath(url));
+                    const real = await canonical(value);
+                    const prior = hostIdentities.get(value);
+                    if (prior && prior.canonical !== real)
+                        throw new Error('Host root was replaced.');
+                    const root = prior ?? Object.freeze({ path: value, canonical: real });
+                    hostIdentities.set(value, root);
+                    if (!unique.has(real))
+                        unique.set(real, root);
+                }
+            }
+            catch {
+                throw new Error('PRODERO_WORKSPACE_UNAVAILABLE: MCP workspace roots must be file URIs for existing directories.');
+            }
+            // Empty/revoked/invalid negotiated roots never fall back to launch context.
+            if (!unique.size)
+                throw new Error('PRODERO_WORKSPACE_UNAVAILABLE: No MCP workspace roots are authorized by the host.');
+            let primary;
+            if (claude && launch?.invalidClaudeProject)
+                throw new Error('PRODERO_WORKSPACE_UNAVAILABLE: Invalid host project context. Reconnect the host.');
+            if (claude && launch?.claudeProject) {
+                await recheck(launch.claudeProject);
+                primary = unique.get(launch.claudeProject.canonical);
+                // Primary removal is legitimate revocation; never restore it through env.
+            }
+            return { roots: [...unique.values()], primary };
+        }
+        if (claude && launch?.claudeProject && !launch.invalidClaudeProject) {
+            const root = await recheck(launch.claudeProject);
+            return { roots: [root], primary: root };
+        }
+        if (client === 'codex-mcp-client' && launch && !launch.indirectLaunch) {
+            const root = await recheck(launch.cwd);
+            return { roots: [root], primary: root };
+        }
+        throw new Error('PRODERO_WORKSPACE_UNAVAILABLE: No trusted MCP workspace context. Use a supported local host and the direct Prodero launcher; reconnect after updating the integration.');
+    }
+    return async function workspaceRoot(explicit) {
+        const operation = operations.getStore();
+        if (!operation)
+            throw new Error('PRODERO_WORKSPACE_UNAVAILABLE: Project access requires an MCP operation context.');
+        const allowed = await (operation.authority ??= authority());
+        const selectedCanonical = explicit === undefined ? undefined : await canonical(explicit);
+        if (!operation.selected) {
+            operation.selected = (async () => {
+                const selected = selectedCanonical === undefined
+                    ? allowed.primary ?? (allowed.roots.length === 1 ? allowed.roots[0] : undefined)
+                    : allowed.roots.find(root => root.canonical === selectedCanonical);
+                if (!selected)
+                    throw new Error(selectedCanonical === undefined
+                        ? 'Missing or ambiguous MCP workspace roots. Select an authorized root with projectRoot.'
+                        : 'PRODERO_ROOT_UNAUTHORIZED: projectRoot is outside the host-authorized workspace boundary.');
+                await recheck(selected);
+                await explicitProjectRoot(selected.path);
+                return selected;
+            })();
+        }
+        const selected = await operation.selected;
+        if (selectedCanonical !== undefined && selectedCanonical !== selected.canonical)
+            throw new Error('PRODERO_ROOT_UNAUTHORIZED: An operation cannot switch workspace boundaries.');
+        await recheck(selected);
+        return selected.path;
+    };
+}
+//# sourceMappingURL=mcp-workspace.js.map

package/dist/memory-presentation.js

@@ -0,0 +1,182 @@
+/** Pure product copy shared by Open, Curate Memory and text clients. Core owns decisions. */
+import { memorySyncOperation } from './memory-sync-operation.js';
+const count = (n, one, many = one + 's') => `${n} ${n === 1 ? one : many}`;
+const tokens = (n) => n >= 1000 ? `${(n / 1000).toFixed(2)}K` : String(n);
+export const MEMORY_COPY = {
+    automatic: 'Prodero remembers automatically. Sessions save useful knowledge into Local Knowledge when they close.',
+    purpose: 'Curate Memory keeps that memory useful and shareable.',
+    noHistory: 'Not enough usage history yet to evaluate memory optimization.',
+    stale: 'Project memory changed since this curation started. Re-analyze before continuing.',
+    incompleteProvenance: 'Some provenance fields are incomplete; this is not proof of lost history. Existing records are preserved. Verify actual sources before proposing repairs; diagnostics do not infer or backfill provenance.',
+    shared: 'Versioned Knowledge is Git-shareable project state that your agent can change. Curator does not commit or push; review the repository diff before doing so.',
+};
+/** Display only: never infer a topic from a knowledge title. Full labels remain in text/details. */
+export function memoryAreaLabel(j) {
+    const refs = [...new Set((j.records ?? []).map((r) => r.scopeRef).filter(Boolean))];
+    const path = refs.length === 1 ? String(refs[0]) : String(j.label ?? '');
+    const reliablePath = /^(?:[\w.@-]+\/)+[\w.@-]+\/?$/.test(path);
+    if (reliablePath)
+        return path.length <= 48 ? path : `${path.slice(0, 20)}…${path.slice(-27)}`;
+    return `Area ${String(j.id ?? j.candidateId ?? '').replace(/^area_/, '').slice(0, 8) || 'overview'}`;
+}
+export function memoryArea(j) {
+    const signals = j.signals ?? [], c = j.counts ?? {};
+    const reasons = [];
+    if (signals.includes('context_pressure'))
+        reasons.push(c.budgetOmissionSessions ? `Some relevant knowledge did not fit into ${count(c.budgetOmissionSessions, 'recent session')}.` : 'Some relevant knowledge repeatedly did not fit into recent task context.');
+    if (signals.includes('fragmentation'))
+        reasons.push('Related memories are spread across several records used together.');
+    if (signals.includes('recent_evolution'))
+        reasons.push('Knowledge has evolved through related updates.');
+    if (signals.includes('redundancy'))
+        reasons.push('Repeated information may be easier to use together.');
+    if (signals.includes('unresolved'))
+        reasons.push('Some related information still needs clarification.');
+    const conflict = signals.includes('potential_conflict');
+    if (conflict)
+        reasons.push('Prodero found incompatible current knowledge and could not determine which state is correct.');
+    const statuses = { unselected: '', pending: 'Waiting', semantic_work: 'Improving…', awaiting_review: 'Ready for your review', applied: 'Processed', skipped: 'Skipped', failed: 'Could not finish this area' };
+    return { id: j.id, title: j.label, displayLabel: memoryAreaLabel(j), body: `${count(j.recordCount, 'related memory', 'related memories')} · ${j.layers?.local ?? 0} Local / ${j.layers?.versioned ?? 0} Shared`, reasons, conflict, status: statuses[j.status] ?? '', error: j.error ? 'This area could not be completed. Retry it or continue with other areas.' : null };
+}
+export function memoryOpenPresentation(p) {
+    const o = p.memoryOverview, areas = (o?.areas ?? []).map(memoryArea), conflicts = areas.filter((a) => a.conflict).length;
+    const hasHistory = o?.available && o.sessions > 0;
+    const headline = !o?.available ? 'Memory overview unavailable' : areas.length ? `${count(areas.length, 'area')} can be improved` : hasHistory ? 'No improvements suggested by recent usage' : 'Memory is ready to learn';
+    const notes = [MEMORY_COPY.automatic, MEMORY_COPY.purpose];
+    if (!o?.available)
+        notes.push('Memory analysis is temporarily unavailable. Try Curate Memory again when current work has finished.');
+    else if (!hasHistory)
+        notes.push(MEMORY_COPY.noHistory);
+    else if (!areas.length)
+        notes.push('No transformation is suggested by the available recent usage.');
+    if (p.knowledgeCount === 0)
+        notes.push('No current memories yet. Normal work will build Local Knowledge.');
+    if (p.promotionRecommendedCount)
+        notes.push(`${count(p.promotionRecommendedCount, 'Local memory', 'Local memories')} can be reviewed for team sharing.`);
+    if (areas.some((a) => a.reasons.some((r) => r.includes('did not fit'))))
+        notes.push('Some relevant knowledge has not fit into recent task context.');
+    if (o?.areasOmitted)
+        notes.push(`${count(o.areasOmitted, 'additional area')} can be inspected in a later Curate Memory run.`);
+    const workflow = o?.workflow;
+    if (workflow)
+        notes.push(workflow.state === 'stale' ? MEMORY_COPY.stale : 'Curate Memory is in progress. Continue when you are ready.');
+    const signal = areas.some((a) => a.reasons.some((r) => r.includes('did not fit'))) ? 'Relevant knowledge has not fit into recent task context.'
+        : areas.length ? areas[0].reasons.find((r) => !r.includes('incompatible')) ?? 'Related knowledge is ready for review.'
+            : !o?.available ? 'Memory analysis is temporarily unavailable.' : !hasHistory ? 'Not enough usage history yet to evaluate improvements.' : 'No improvements suggested by recent usage.';
+    const total = areas.length + (o?.areasOmitted ?? 0);
+    const dashboard = { headline: areas.length ? 'Memory can be improved' : headline, areasLabel: total ? `${count(total, 'area')} identified` : null, signal,
+        sharing: typeof p.localKnowledgeCount === 'number' ? p.localKnowledgeCount ? `${count(p.localKnowledgeCount, 'Local memory', 'Local memories')} available for sharing review.` : 'No Local memories to share.' : null,
+        established: p.knowledgeCount > 0, workflowNotice: workflow ? workflow.state === 'stale' ? MEMORY_COPY.stale : 'Curate Memory is in progress.' : null };
+    return { headline, notes, areas, conflicts, workflow, dashboard, button: workflow ? (workflow.state === 'stale' ? 'Re-analyze memory' : 'Continue curation') : 'Curate Memory' };
+}
+export function memorySyncPresentation(w) {
+    const areas = (w.jobs ?? []).map(memoryArea), s = w.summary ?? {}, p = w.review?.preview;
+    const operation = w.operation ?? memorySyncOperation(w);
+    const headlines = { awaiting_selection: 'Curate Memory', semantic_work: 'Improving memory…', awaiting_clarification: 'A question about your project', awaiting_review: w.review?.kind === 'promotion' ? 'Review knowledge for team sharing' : p?.requiresVersionedReview ? 'Review shared-memory changes' : 'Review memory changes', applying: 'Approved changes pending verification', awaiting_promotion_selection: 'Review Local knowledge for sharing', completed: 'Memory curated', stale: 'Re-analyze memory' };
+    const notes = [], warnings = [], metrics = [], sections = [];
+    const section = (title, body) => sections.push({ title, items: [{ title: '', body, notes: [] }] });
+    if (w.state === 'awaiting_selection') {
+        // Operation choices are the entry surface; planner data is diagnostic.
+    }
+    if (['semantic_work', 'awaiting_clarification'].includes(w.state) && operation.phase !== 'question')
+        notes.push(operation.phase === 'submitted' ? 'The result was submitted and is awaiting validation.' : operation.phase === 'awaiting_agent' ? 'Prepared evidence is waiting for host-agent analysis. No background worker is confirmed.' : 'Analysis is queued. Continue with the prepared evidence; you may be asked about missing project facts.');
+    if (w.state === 'applying')
+        notes.push('The approved intention is saved. Check progress to verify the result or resume recovery; no active writer is assumed.');
+    if (w.state === 'stale')
+        notes.push(MEMORY_COPY.stale);
+    if (w.state === 'awaiting_promotion_selection')
+        notes.push('Select Local knowledge to move to Versioned Knowledge.');
+    if (w.state !== 'stale' && w.review?.kind === 'transformation') {
+        const r = p.summary, before = r.consolidated.length + r.superseded.length + r.kept.length + r.unresolved.length, after = r.created.length + r.kept.length + r.unresolved.length;
+        metrics.push({ label: 'Before · current memories', value: before }, { label: 'After · current memories', value: after }, { label: 'Estimated tokens · before → after', value: `${tokens(r.estimatedTokens.before)} → ${tokens(r.estimatedTokens.after)}` });
+        section(r.label, `${count(r.consolidated.length, 'memory', 'memories')} consolidated; ${count(r.superseded.length, 'memory', 'memories')} replaced by newer project state; ${count(r.kept.length + r.unresolved.length, 'previous memory', 'previous memories')} remain current.\n${count(r.archives.length, 'previous memory', 'previous memories')} will be preserved in history.`);
+        for (const category of ['instruction', 'principle', 'invariant', 'constraint', 'decision']) {
+            const n = r.protectedSources.filter((x) => x.category === category && x.action === 'keep').length;
+            if (n)
+                notes.push(`${count(n, `project ${category}`)} ${n === 1 ? 'was' : 'were'} preserved unchanged.`);
+        }
+        if (r.unresolved.length)
+            notes.push(`Prodero could not safely determine how ${count(r.unresolved.length, 'memory', 'memories')} should be handled. It will remain current.`);
+        const l = p.limitations;
+        notes.push(...(l.warnings ?? []), ...(l.additionalEvidenceRequired ?? []));
+        if (l.omittedAsRedundant?.length)
+            section('Information proposed as repetition', l.omittedAsRedundant.flatMap((x) => x.information).join('\n'));
+        if (l.unresolved?.length)
+            section('Information still unresolved', l.unresolved.flatMap((x) => x.information).join('\n'));
+        if (p.requiresVersionedReview) {
+            notes.push(MEMORY_COPY.shared, 'Local and shared changes will be saved together after approval.');
+            const v = p.versionedEffects;
+            const sharedIds = new Set(r.created.filter((x) => x.layer === 'versioned').map((x) => x.id));
+            const localIds = new Set(r.archives.filter((x) => x.layer === 'local').map((x) => x.id));
+            const sharedLocal = new Set(r.provenance.filter((x) => sharedIds.has(x.from) && localIds.has(x.to)).map((x) => x.to));
+            if (sharedLocal.size)
+                notes.push(`${count(sharedLocal.size, 'Local memory', 'Local memories')} will be represented in the new shared knowledge; the originals stay in history.`);
+            section('Shared-memory changes', `${count(v.filter((x) => x.action === 'create').length, 'new current memory', 'new current memories')}; ${count(v.filter((x) => x.action === 'consolidate').length, 'memory', 'memories')} consolidated; ${count(v.filter((x) => x.action === 'supersede').length, 'memory', 'memories')} replaced by newer project state.\n${count(r.archives.filter((x) => x.layer === 'versioned').length, 'previous shared memory', 'previous shared memories')} preserved in Versioned archive files.`);
+        }
+        notes.push('Please review the proposed wording. Prodero checks data integrity but cannot guarantee that every meaning was preserved.');
+        sections.push({ title: 'Proposed current knowledge', items: p.proposal.records.map((x) => ({ title: x.title, body: x.body, notes: [`${x.category} · ${x.scope}${x.path ? ' · ' + x.path : ''} · ${r.created.find((c) => c.key === x.key)?.layer === 'versioned' ? 'Shared / Versioned' : 'Local'}`] })) });
+    }
+    if (w.state !== 'stale' && w.review?.kind === 'link-repair') {
+        notes.push(`Remove ${count(p.count, 'broken link')} to missing memories. No replacement memory is inferred.`, 'Memory text and valid links stay unchanged. Original records, including removed links, are saved in a checkpoint.');
+        if (p.requiresVersionedReview)
+            notes.push(MEMORY_COPY.shared);
+        if (p.remaining)
+            notes.push(`${count(p.remaining, 'additional broken link')} will remain for a later curation run.`);
+        sections.push({ title: 'Broken links to remove', items: p.changes.map((c) => ({ title: c.title, body: c.links.map((l) => `${l.type} → ${l.target}`).join('\n'), notes: [`${c.layer === 'versioned' ? 'Shared / Versioned' : 'Local'} · ${c.id}`] })) });
+    }
+    if (w.state !== 'stale' && w.review?.kind === 'promotion') {
+        notes.push(MEMORY_COPY.shared, 'This operation applies the knowledge shown here to Versioned files; it does not share it through Git.');
+        const labels = { new: 'New shared memory', merge: 'Update existing shared memory', supersede: 'Replace older shared state', covered: 'Already represented in shared knowledge', conflict: 'Needs review · remains Local' };
+        sections.push({ title: 'Sharing review', items: p.actions.flatMap((a) => [
+                ...(a.before ? [{ title: `Current · ${a.before.title}`, body: a.before.content, notes: [] }] : []),
+                { title: a.draft?.title ?? a.before?.title ?? 'Local knowledge', body: a.draft?.content ?? a.reason, notes: [labels[a.disposition], a.reason] },
+            ]) });
+        if (p.actions.some((a) => a.disposition === 'conflict'))
+            notes.push('Some selected knowledge cannot be shared safely and will remain Local. Review the reasons below.');
+    }
+    if (w.state === 'completed') {
+        if (s.areasProcessed && s.archived)
+            notes.push(`${s.sourcesBefore} previous memories → ${s.currentAfter} current memories.`, `${count(s.archived, 'previous memory', 'previous memories')} preserved in history.`);
+        else if (s.areasProcessed)
+            notes.push('Memory reviewed. No previous memories needed to be replaced.');
+        else if (w.jobs?.some((j) => j.selected) || s.areasSkipped || s.areasFailed)
+            notes.push('No memory improvements were applied.');
+        else if (w.improveEnabled === false)
+            notes.push('Memory improvement was not selected.');
+        else if (w.jobs?.length)
+            notes.push('No memory improvements were selected.');
+        else
+            notes.push(w.usage?.available && w.usage?.sessions ? 'No transformation was needed based on recent usage.' : MEMORY_COPY.noHistory);
+        if (s.brokenLinksFixed)
+            notes.push(`${count(s.brokenLinksFixed, 'broken link')} fixed.`);
+        if (s.brokenLinksRemaining)
+            notes.push(`${count(s.brokenLinksRemaining, 'broken link')} remain unchanged.`);
+        if (s.promoted)
+            notes.push(`${count(s.promoted, 'Local memory', 'Local memories')} prepared in Versioned files. Review the Git diff before sharing; Curator did not commit or push.`);
+        if (s.areasProcessed)
+            notes.push(`Estimated context for reviewed knowledge: ${tokens(s.estimatedTokens.before)} → ${tokens(s.estimatedTokens.after)} tokens.`);
+        if (s.unresolved)
+            notes.push(`${count(s.unresolved, 'unresolved item')} still need clarification and remain current.`);
+        if (s.areasSkipped)
+            notes.push('Some knowledge was retained because a safe improvement could not be established.');
+        if (s.areasFailed)
+            notes.push('Some analysis could not be completed. Saved knowledge is unchanged for those items.');
+        if (s.questionsDeferred)
+            notes.push('Deferred questions are saved for later. Independent work continued.');
+        if (s.promotionConflicts)
+            notes.push(`${count(s.promotionConflicts, 'sharing item')} still need review and remain Local.`);
+        notes.push('Previous knowledge remains available through history.');
+    }
+    notes.push('Your place and saved answers are retained. Leave and return with Continue curation.');
+    if (['semantic_work', 'awaiting_clarification', 'awaiting_review'].includes(w.state))
+        notes.push('Skip or Answer later retains original knowledge and saved answers, then continues other selected work.');
+    if (w.state === 'stale' || w.state === 'completed')
+        notes.push('Re-analyze starts a fresh workflow from current project data. Changes already saved remain in place.');
+    if (w.error && w.state !== 'stale')
+        notes.push('This step could not finish. Continue to check saved progress before retrying.');
+    if (w.state === 'awaiting_promotion_selection' && w.coverage?.promotionCandidatesOmitted)
+        notes.push(`${count(w.coverage.promotionCandidatesOmitted, 'additional Local memory', 'additional Local memories')} can be reviewed in a later Curate Memory run.`);
+    const headline = w.state === 'completed' && operation.outcome === 'remaining' ? 'Completed with remaining work' : operation.phase === 'awaiting_agent' ? 'Awaiting agent analysis' : operation.phase === 'submitted' ? 'Submitted · validation pending' : w.state === 'semantic_work' ? 'Analysis queued' : headlines[w.state] ?? 'Curate Memory';
+    return { headline, graphicalHeadline: headline, operation, reviewAreaLabel: 'Memory changes', notes, warnings, metrics, sections, areas };
+}
+//# sourceMappingURL=memory-presentation.js.map