@prodero/curator 0.0.0-stage → 0.1.0

package/dist/presentation-trace.js

@@ -0,0 +1,174 @@
+/** Temporary, opt-in wire observation. No tool/resource payloads are recorded. */
+import { createHmac, randomBytes, randomUUID } from "node:crypto";
+import { closeSync, constants, fstatSync, openSync, writeSync } from "node:fs";
+import path from "node:path";
+import { getUiCapability, RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server";
+import { PRODERO_RESOURCE_URI, PRODERO_TOOLS } from "./contracts.js";
+const publicKeys = new Set(["experimental", "extensions", "io.modelcontextprotocol/ui", "mimeTypes", "roots", "listChanged", "sampling", "context", "tools", "elicitation", "form", "url", "tasks", "requests", "call", "createMessage", "create", "list", "cancel", "subscribe", "name", "version", "title", "platform", "userAgent", "clientInfo", "hostInfo", "clientId", "sessionId", "progressToken", "io.modelcontextprotocol/related-task", "taskId", "openai/userAgent", "openai/userLocation", "openai/locale", "openai/widgetSessionId", "ui", "protocolVersion"]);
+const publicNames = new Set(["codex", "codex-mcp-client", "Codex", "claude-desktop", "Claude", "Cursor", "cursor", "claude-code"]);
+let processFingerprintSalt;
+const versions = new Set(["2024-10-07", "2024-11-05", "2025-03-26", "2025-06-18", "2025-11-25", "2026-01-26"]);
+export function installPresentationTrace(server) {
+    if (process.env.PRODERO_DEBUG_PRESENTATION !== "1")
+        return;
+    const connect = server.connect.bind(server);
+    // Hashes permit equality checks within this process without storing unknown values.
+    const salt = processFingerprintSalt ??= randomBytes(32);
+    const fingerprint = (value) => createHmac("sha256", salt).update(JSON.stringify(value) ?? "undefined").digest("hex").slice(0, 24);
+    function safe(value, key = "", depth = 0) {
+        if (depth > 6)
+            return { redacted: true, fingerprint: fingerprint(value) };
+        if (value === undefined)
+            return null;
+        if (value === null || typeof value === "boolean")
+            return value;
+        if (typeof value === "string") {
+            if ((key === "mimeTypes" && value === RESOURCE_MIME_TYPE) || (key === "platform" && ["desktop", "mobile", "web"].includes(value)) || (key === "name" && publicNames.has(value)) || (key === "version" && /^\d+\.\d+\.\d+$/.test(value)) || (key === "protocolVersion" && versions.has(value)))
+                return value;
+            return { type: "string", fingerprint: fingerprint(value) };
+        }
+        if (typeof value === "number")
+            return { type: "number", fingerprint: fingerprint(value) };
+        if (Array.isArray(value))
+            return { items: value.slice(0, 32).map(item => safe(item, key, depth + 1)), truncated: value.length > 32, ...(value.length > 32 ? { fingerprint: fingerprint(value) } : {}) };
+        if (typeof value === "object")
+            return { ...Object.fromEntries(Object.entries(value).slice(0, 64).map(([k, v]) => [publicKeys.has(k) ? k : `key#${fingerprint(k)}`, safe(v, k, depth + 1)])), ...(Object.keys(value).length > 64 ? { traceTruncatedKeys: true, fingerprint: fingerprint(value) } : {}) };
+        return { redacted: true };
+    }
+    server.connect = async (transport) => {
+        const connection = randomUUID();
+        let fd;
+        let disabled = false;
+        let sequence = 0;
+        const destination = process.env.PRODERO_DEBUG_PRESENTATION_FILE;
+        try {
+            if (destination) {
+                if (!path.isAbsolute(destination))
+                    throw new Error("absolute path required");
+                fd = openSync(destination, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+                const stat = fstatSync(fd);
+                if (!stat.isFile() || (stat.mode & 0o077) !== 0 || (process.getuid && stat.uid !== process.getuid()))
+                    throw new Error("private regular file required");
+            }
+        }
+        catch {
+            if (fd !== undefined)
+                closeSync(fd);
+            fd = undefined;
+            disabled = true;
+            process.stderr.write("[prodero:presentation] Trace disabled: destination must be an owned private regular file at an absolute path.\n");
+        }
+        const emit = (event, details = {}) => {
+            if (disabled || sequence >= 10000)
+                return;
+            try {
+                let line = JSON.stringify({ trace: "prodero-presentation-v1", time: new Date().toISOString(), pid: process.pid, connection, sequence: ++sequence, event, ...details }) + "\n";
+                if (line.length > 32768)
+                    line = JSON.stringify({ trace: "prodero-presentation-v1", time: new Date().toISOString(), pid: process.pid, connection, sequence, event, truncated: true }) + "\n";
+                if (fd !== undefined)
+                    writeSync(fd, line);
+                else
+                    process.stderr.write(line);
+            }
+            catch {
+                disabled = true;
+            } // Diagnostics never change a protocol result.
+        };
+        const snapshot = () => {
+            const capabilities = server.server.getClientCapabilities();
+            const ui = getUiCapability(capabilities);
+            return { transportSession: safe(transport.sessionId), clientInfo: safe(server.server.getClientVersion()), capabilities: safe(capabilities), uiExtensionPresent: ui !== undefined, declaredMimeTypes: safe(ui?.mimeTypes, "mimeTypes"), supportsMcpAppHtml: Array.isArray(ui?.mimeTypes) && ui.mimeTypes.includes(RESOURCE_MIME_TYPE) };
+        };
+        const pending = new Map();
+        let call = 0;
+        function incoming(message) {
+            if (!("method" in message))
+                return;
+            const params = message.params;
+            let event;
+            if (message.method === "initialize")
+                event = "initialize.request";
+            else if (message.method === "tools/call" && params?.name === PRODERO_TOOLS.open)
+                event = "open.request";
+            else if (message.method === "tools/call" && params?.name === PRODERO_TOOLS.plugins)
+                event = "control.request";
+            else if (["tools/list", "resources/list", "resources/templates/list", "prompts/list", "ping"].includes(message.method))
+                event = "discovery.request";
+            else if (message.method === "tools/call") {
+                emit("other-tool.observed");
+                return;
+            }
+            else if (message.method === "resources/read" && params?.uri === PRODERO_RESOURCE_URI)
+                event = "status-resource.read";
+            else if (message.method === "notifications/initialized") {
+                emit("mcp.initialized", snapshot());
+                return;
+            }
+            else if (message.method.startsWith("ui/")) {
+                emit("ui.message.observed", { method: ["ui/initialize", "ui/notifications/initialized", "ui/notifications/size-changed", "ui/notifications/host-context-changed"].includes(message.method) ? message.method : safe(message.method), meta: safe(params?._meta) });
+                return;
+            }
+            if (!event)
+                return;
+            const number = ++call;
+            if ("id" in message) {
+                if (pending.size >= 256)
+                    pending.delete(pending.keys().next().value);
+                pending.set(message.id, { event, call: number });
+            }
+            emit(event, { call: number, ...(event === "discovery.request" ? { method: message.method } : { meta: safe(params?._meta) }), ...(event === "initialize.request" ? { requestedProtocolVersion: safe(params?.protocolVersion, "protocolVersion"), clientInfo: safe(params?.clientInfo), capabilities: safe(params?.capabilities) } : snapshot()) });
+        }
+        function outgoing(message) {
+            if (!("id" in message) || message.id === undefined || "method" in message)
+                return;
+            const request = pending.get(message.id);
+            if (!request)
+                return;
+            pending.delete(message.id);
+            const result = "result" in message ? message.result : undefined;
+            emit(request.event.replace(/request$|read$/, "response"), { call: request.call, outcome: "error" in message || result?.isError === true ? "error" : "ok", ...(request.event === "initialize.request" ? { negotiatedProtocolVersion: safe(result?.protocolVersion, "protocolVersion"), ...snapshot() } : {}) });
+        }
+        // Observe the public transport boundary, including the SDK-owned initialize handler.
+        const wrapped = {
+            onmessage: transport.onmessage,
+            onerror: transport.onerror,
+            onclose: transport.onclose,
+            get sessionId() { return transport.sessionId; },
+            setProtocolVersion: transport.setProtocolVersion?.bind(transport),
+            async start() {
+                transport.onmessage = (message, extra) => { try {
+                    incoming(message);
+                }
+                catch { /* fail open */ } wrapped.onmessage?.(message, extra); };
+                transport.onerror = error => { emit("transport.error"); wrapped.onerror?.(error); };
+                transport.onclose = () => { emit("connection.closed"); if (fd !== undefined) {
+                    try {
+                        closeSync(fd);
+                    }
+                    catch { }
+                    fd = undefined;
+                } disabled = true; wrapped.onclose?.(); };
+                await transport.start();
+            },
+            async send(message, options) { try {
+                outgoing(message);
+            }
+            catch { /* fail open */ } await transport.send(message, options); },
+            close: () => transport.close(),
+        };
+        emit("connection.started", { handshakeObservation: "passive-server-wire-only; app-host handshake normally does not reach server", fingerprintScope: "process", controlTool: PRODERO_TOOLS.plugins });
+        try {
+            await connect(wrapped);
+        }
+        catch (error) {
+            if (fd !== undefined) {
+                try {
+                    closeSync(fd);
+                }
+                catch { }
+            }
+            throw error;
+        }
+    };
+}
+//# sourceMappingURL=presentation-trace.js.map

package/dist/presentation.js

@@ -0,0 +1,412 @@
+import { renderKnowledgeTable } from './knowledge-table.js';
+import { conversationView, renderConversation, renderActionMenu, PRESENTATION_REPLY } from './conversation-presentation.js';
+import { renderReviewProjection } from './core/curation-review-presentation.js';
+export { PRESENTATION_REPLY } from './conversation-presentation.js';
+export { renderReviewProjection } from './core/curation-review-presentation.js';
+import { applicabilityLabel } from "./core/applicability-label.js";
+import { memoryOpenPresentation, memorySyncPresentation } from './memory-presentation.js';
+export { memoryOpenPresentation, memorySyncPresentation, MEMORY_COPY } from './memory-presentation.js';
+export const PRESENTATION_LAUNCHER = "When the user says `prodero` (ignoring surrounding whitespace and case), `open prodero`, or `show prodero`, immediately call prodero_config_get for the current workspace. If presentation.mode is text, call prodero_text with tool=prodero_open; otherwise call prodero_open. Pass the same projectRoot to config_get and the selected operation (inside arguments for prodero_text). Do not ask what the user wants to do with Prodero.";
+export const PRESENTATION_ROUTING = PRESENTATION_REPLY + ' Use prodero_config_get for the current project before choosing a presentation route. For a project in text mode, call prodero_text (default tool prodero_open); pass original arguments in arguments. Apply this routing to every covered lifecycle and review operation, including prodero_prepare and prodero_session_close, and to available actions. Do not call the App-attached original with presentation=text: it can leave an empty host container. The gateway has no App attachment. Show human-readable content and actions in chat. Natural requests to change display mode update presentation.mode through prodero_config_set; do not retain a sticky conversation-only preference or record settings as knowledge. A one-off request to show a response as text may use prodero_text without changing config. Standard MCP Apps capabilities inform auto mode only; never infer a device from client metadata. Original tools retain static App descriptors even if they return text. For UI calls, generate one opaque presentationGroup per conversation (or use a supported host-provided conversation ID) and reuse it across Prodero UI tools, including open, prepare and session_close, so older cards can collapse. Never use a project path or a shared MCP connection ID as the group; never reuse it in another conversation. Keep it ephemeral, not in project settings or knowledge. Keep the existing review and approval workflow before mutations or promotion. v0.1 trust model: Local Knowledge is Git-ignored working state, not a security boundary against the connected agent. Versioned Knowledge is Git-shareable project state; the agent may create, promote and maintain it. Review/preview/approval steps are workflow safeguards, not authenticated human authorization; approved=true does not prove human consent. Curator does not commit or push. Users must review repository changes before committing or pushing.';
+const list = (v) => Array.isArray(v) ? v : [];
+export const tokenLabel = (n) => n >= 1000 ? `${(n / 1000).toFixed(2)}K` : String(n);
+const human = (s) => s.replace(/[-_]/g, " ");
+function itemView(item) {
+    return { title: item.title ?? item.id ?? "Knowledge", body: item.content ?? item.contentPreview ?? "", notes: [
+            item.applicability && `Applies to: ${applicabilityLabel(item)}`,
+            item.id && `ID: ${item.id}`, item.revision && `Revision: ${item.revision}`,
+            item.createdAt && `Created: ${item.createdAt}`, item.updatedAt && `Updated: ${item.updatedAt}`,
+            [item.layer, item.category ?? item.type, item.priority, item.scopeRef ?? item.scope, item.status].filter(Boolean).join(" · "),
+            ...list(item.signals).map(s => `${s.kind}: ${s.detail}`),
+            item.derivedFrom?.length && `Sources: ${item.derivedFrom.join(", ")}`,
+        ].filter(Boolean) };
+}
+export function buildViewModel(payload) {
+    const normalized = payload.action === "initialized" ? { ...payload, project: payload.status?.project ?? payload.project } : payload;
+    const vm = buildDetailedViewModel(normalized);
+    vm.conversation = conversationView(normalized, vm);
+    return vm;
+}
+function buildDetailedViewModel(payload) {
+    const r = payload.result ?? payload;
+    const root = r.root ?? r.project?.root ?? payload.project?.root ?? payload.root;
+    const vm = { version: 1, title: "Prodero · Project Intelligence", metrics: [], notices: [], sections: [], actions: [] };
+    const metric = (label, value, detail) => { if (value !== undefined && value !== null)
+        vm.metrics.push({ label, value: typeof value === "number" ? value : String(value), ...(detail ? { detail } : {}) }); };
+    const action = (label, tool, args = {}, approval = false) => vm.actions.push({ label, tool, arguments: { ...(root ? { projectRoot: root } : {}), ...args }, ...(approval ? { approval: true } : {}) });
+    const section = (title, items) => { if (items.length)
+        vm.sections.push({ title, items: items.map(itemView) }); };
+    const knowledge = () => action("Show project knowledge", "prodero_knowledge");
+    if (payload.action === "curation") {
+        const p = payload.plan, projection = payload.projection;
+        vm.title = "Knowledge cleanup";
+        if (!projection) {
+            vm.notices.push("Reload this review to obtain its saved state.");
+            action("Reload review", "prodero_curation", { action: "plan" });
+            return vm;
+        }
+        vm.notices.push(renderReviewProjection(projection), "Knowledge stays unchanged until explicit Apply.");
+        metric("Proposed change groups", projection.readyChangeGroups);
+        metric("Needs input", projection.needsInputNow);
+        metric("Deferred questions", projection.deferredQuestions);
+        metric("Deferred changes", projection.deferredChanges);
+        metric("Unchanged", projection.unchanged);
+        const decisions = projection.items.filter((v) => v.needsInput);
+        if (decisions.length)
+            vm.sections.push({ title: "Needs clarification", items: decisions.map((v) => ({ title: p.proposals.find((q) => q.id === v.proposalIds[0]).before.title, body: "Keep current or decide later. No actionable suggestion is available yet.", notes: [] })) });
+        for (const group of [...new Set(p.proposals.map((v) => v.group))])
+            vm.sections.push({ title: String(group), items: p.proposals.filter((v) => v.group === group).map((v) => ({ title: v.before.title, body: `Currently: ${v.before.contextPolicy} · ${applicabilityLabel(v.before)}\nSuggested: ${v.outputs.map((o) => `${o.category} · ${o.contextPolicy} · ${applicabilityLabel(o)}`).join("; ")}`, notes: [...v.attention, ...(v.investigation ? [v.investigation.outcome, v.investigation.explanation] : [])] })) });
+        vm.diagnostics = [{ title: "Record content and traceability", items: p.proposals.map((v) => ({ title: v.before.title, body: `Current: ${v.before.content}\n\nProposed: ${v.outputs.map((o) => o.content).join("\n\n")}`, notes: [`Source revision: ${v.revision}`, `Source: ${v.sourceId}`, ...v.evidence] })) }];
+        if (payload.result && Array.isArray(payload.result))
+            vm.sections.push({ title: "Context impact · safe batch", items: payload.result.map((row) => ({ title: row.task, body: `Required candidate tokens: ${row.before.requiredCandidateTokens} → ${row.after.requiredCandidateTokens}; omissions: ${row.before.requiredOmissions} → ${row.after.requiredOmissions}`, notes: [`Context needed: ${row.after.contextNeeded ? "yes" : "no"}`] })) });
+        if (!payload.trustedReviewAvailable)
+            vm.notices.push("Text review is preview-only. Open the graphical App to review and apply changes.");
+        if (projection.readyChangeGroups && !projection.paused)
+            action("Preview context impact", "prodero_curation", { projectRoot: payload.root, action: "simulate", planId: p.planId });
+        if ((projection.readyChangeGroups || projection.needsInputNow) && !projection.paused)
+            action("Pause review", "prodero_curation", { projectRoot: payload.root, action: "defer", planId: p.planId });
+        if (!projection.paused && (projection.readyChangeGroups || projection.needsInputNow))
+            action("Refresh suggestions", "prodero_curation", { projectRoot: payload.root, action: "plan" });
+        action("Back to Prodero", "prodero_open", { projectRoot: payload.root });
+        return vm;
+    }
+    if (payload.action === "migration") {
+        const p = payload.plan;
+        const titles = { current: "Project knowledge is up to date", available: "Knowledge update available", "review-required": "Knowledge update needs review", "recovery-required": "Knowledge update needs recovery", updating: "Updating project knowledge", "runtime-too-old": "Update Curator to continue", blocked: "Knowledge update unavailable" };
+        vm.title = payload.completed ? "Knowledge update completed" : titles[p.state] ?? "Project knowledge update";
+        if (p.state === "available")
+            vm.notices.push("This project needs a knowledge update. Existing knowledge will be preserved and a recovery backup will be created before changes.");
+        if (p.state === "review-required")
+            vm.notices.push("Some decisions need review. This update cannot be applied automatically; a supported review workflow is required.");
+        if (p.state === "runtime-too-old")
+            vm.notices.push("This project uses a newer knowledge or project format. Update Curator before continuing work.");
+        if (p.state === "recovery-required")
+            vm.notices.push("A previous update was interrupted. Restore the pre-update backup safely, then review the update again.");
+        if (p.state === "updating")
+            vm.notices.push("The project update is running. Check progress shortly.");
+        if (p.state === "blocked")
+            vm.notices.push("The project update cannot proceed safely. Inspect Details for recovery information.");
+        if (payload.completed)
+            vm.notices.push("Knowledge was preserved. The project is ready to continue.");
+        const args = { planId: p.planId, ...(payload.resume ? { resume: payload.resume } : {}) };
+        if (p.safeToApply)
+            action("Update project knowledge", "prodero_migrate", { ...args, action: "apply", approved: true }, true);
+        if (p.state === "recovery-required")
+            action("Restore pre-update backup", "prodero_migrate", { ...args, action: "recover", approved: true }, true);
+        if (p.state === "updating")
+            action("Check update progress", "prodero_migrate", { action: "status", ...(payload.resume ? { resume: payload.resume } : {}) });
+        if (p.state === "current") {
+            const resume = payload.resume ?? { tool: "prodero_open", arguments: { projectRoot: root } };
+            action("Continue", resume.tool, resume.arguments);
+        }
+        const formatVersion = (domain) => p.current?.[domain] == null
+            ? `Current version unavailable · Target v${p.target[domain]}`
+            : p.current[domain] === p.target[domain] ? `v${p.current[domain]} · Up to date`
+                : `v${p.current[domain]} → v${p.target[domain]}`;
+        const stores = { memory: "Shared knowledge", "local/memory": "Local knowledge", archive: "Shared archive", "local/archive": "Local archive", "config.json": "Project settings", "index.md": "Shared index", "local/index.md": "Local index", ".cache": "Derived caches" };
+        const kinds = { structural: "Format update", "compatible-semantic": "Compatible knowledge update", "review-required": "Requires review" };
+        vm.diagnostics = [
+            { title: "Format versions", items: [
+                    { title: "Project format", body: formatVersion("project"), notes: [] },
+                    { title: "Knowledge format", body: formatVersion("knowledge"), notes: [] },
+                ] },
+            ...(p.migrations.length ? [{ title: "Planned changes", items: list(p.migrations).map(step => ({
+                        title: `${step.domain === "project" ? "Project" : "Knowledge"} · v${step.from} → v${step.to}`,
+                        body: step.description,
+                        notes: [kinds[step.kind] ?? human(step.kind), ...(step.affectedStores?.length ? [`Affects: ${step.affectedStores.map((store) => stores[store] ?? store).join(", ")}`] : [])],
+                    })) }] : []),
+            { title: "Backup and recovery", items: [
+                    { title: "Recovery backup", body: p.backupRequired ? "A recovery backup will be created before changes are applied." : "No new backup is required for the current state.", notes: [] },
+                    ...(p.recovery ? [{ title: "Recovery instructions", body: p.recovery, notes: [] }] : []),
+                    ...(p.diagnostic ? [{ title: "Update issue", body: p.diagnostic, notes: [] }] : []),
+                ] },
+        ];
+    }
+    else if (["open", "status", "status-details", "initialized"].includes(payload.action)) {
+        const p = payload.project;
+        if (payload.curation?.state === "unavailable")
+            vm.notices.push(payload.curation.message ?? "Saved review is unavailable.");
+        if (payload.curation?.prominent) {
+            vm.notices.push(renderReviewProjection(payload.curation.projection));
+            action("Review cleanup", "prodero_curation", { action: "plan" });
+            action("Pause review", "prodero_curation", { action: "defer", planId: payload.curation.planId });
+        }
+        if (payload.curation?.projection?.analyzedSourceCount > 0 && !payload.curation.prominent) {
+            vm.notices.push(renderReviewProjection(payload.curation.projection));
+            action("Review saved decisions", "prodero_curation", { action: "plan" });
+        }
+        if (typeof p?.initialized !== "boolean") {
+            vm.notices.push("Project state is not available yet.");
+            return vm;
+        }
+        vm.title = p.initialized ? "Prodero · Project Intelligence" : "Prodero · Initialize Project";
+        metric("Project", p.name);
+        metric("Git", p.git ? "Available" : "Not found");
+        metric("AGENTS.md", p.agentsFile ? "Found" : "Not found");
+        if (!p.initialized) {
+            vm.notices.push("Prodero is not initialized. Initialization creates .prodero/ and managed agent instructions.");
+            action("Initialize Prodero", "prodero_initialize");
+        }
+        else {
+            const memory = memoryOpenPresentation(p);
+            vm.simpleActions = true;
+            metric("Knowledge", p.knowledgeCount);
+            metric("Local Knowledge", p.localKnowledgeCount);
+            metric("Shared / Versioned Knowledge", p.versionedKnowledgeCount);
+            metric("Active skills", p.skillCount, p.skillCandidateCount ? `${p.skillCandidateCount} candidate${p.skillCandidateCount === 1 ? "" : "s"}` : undefined);
+            metric("Sessions", p.sessionCount);
+            vm.notices.push(memory.headline, ...memory.notes);
+            if (memory.conflicts)
+                vm.notices.push(`${memory.conflicts} area${memory.conflicts === 1 ? ' needs' : 's need'} review. Prodero found incompatible current knowledge.`);
+            if (memory.areas.length)
+                vm.sections.push({ title: "Memory", items: memory.areas.map((a) => ({ title: a.title, body: a.body, notes: a.reasons })) });
+            vm.diagnostics = [{ title: "Memory diagnostics", items: [{ title: "Project statistics", body: JSON.stringify({ memoryHealth: p.memoryHealth, graph: p.knowledgeGraph ? { ...p.knowledgeGraph, cacheState: undefined, ...(payload.action === "open" ? { brokenReferences: undefined } : {}) } : undefined, pendingSessions: p.pendingSessionCount, checkpoints: p.checkpointCount, overview: p.memoryOverview }, null, 2), notes: [] }] }];
+            if (payload.phase === "initial") {
+                vm.notices.push("Lightweight status only; detailed statistics were not requested.");
+                action("Load detailed status", "prodero_status_details");
+            }
+            knowledge();
+            action("Show project skills", "prodero_skills");
+            action(memory.button, "prodero_sync");
+            action("Check for updates", "prodero_check_update");
+        }
+        const b = payload.bootstrap;
+        if (b) {
+            metric("Required", b.instructions.length);
+            section("Required instructions · model-visible, not system-level", b.instructions);
+            vm.notices.push(...b.warnings);
+        }
+        if (payload.update?.available)
+            vm.notices.push(`Update available: ${payload.update.current} → ${payload.update.latest}.`);
+    }
+    else if (payload.action === "context") {
+        vm.title = "Prodero · View Context";
+        metric("Context", `${tokenLabel(r.metrics.contextTokens)} / ${tokenLabel(r.metrics.contextBudgetTokens)}`);
+        if (r.policyReadiness?.blocking)
+            vm.notices.push("Required context is incomplete or needs review. Do not continue work.");
+        vm.notices.push(...list(r.attention).map(a => `${a.title}: ${a.detail}`));
+        section("Required instructions not loaded", list(r.selection?.omittedRequired));
+        section("Required instructions", r.required);
+        section("Relevant knowledge", r.relevant);
+        section("Skills", r.skills);
+        vm.diagnostics = [{ title: "Context diagnostics", items: [{ title: "Selection", body: JSON.stringify({ metrics: r.metrics, selection: r.selection, policyReadiness: r.policyReadiness }, null, 2), notes: [] }] }];
+    }
+    else if (payload.action === "memory-sync") {
+        const memory = memorySyncPresentation(r);
+        vm.title = `Sync Memory · ${memory.headline}`;
+        vm.simpleActions = true;
+        vm.metrics = memory.metrics;
+        vm.notices = [...memory.notes, ...memory.warnings];
+        vm.sections = memory.sections;
+        if (r.state === 'awaiting_selection')
+            vm.sections.unshift({ title: 'Sync options', items: [{ title: 'Improve memory · enabled', body: 'Process, compress and organize memory.', notes: [] }, ...(r.brokenLinks ? [{ title: `Fix ${r.brokenLinks} broken ${r.brokenLinks === 1 ? 'link' : 'links'} · enabled`, body: 'Review and remove links to missing memories. Original records are saved in history.', notes: [] }] : []), { title: 'Share knowledge · enabled', body: 'Review Local knowledge for Versioned files. Your agent can also change these files; review the Git diff before commit/push.', notes: [] }] });
+        if (r.clarification?.graphical)
+            vm.sections.push({ title: 'Project questions', items: r.clarification.graphical.questions.filter((q) => q.needsInput).map((q) => ({ title: q.question.title, body: q.question.prompt, notes: q.question.choices.map((c) => c.label) })) });
+        if (r.state === 'awaiting_promotion_selection')
+            section("Local Knowledge available for sharing review", r.promotionCandidates.map((c) => ({ title: c.title })));
+        vm.diagnostics = [{ title: "Memory diagnostics", items: [{ title: "Workflow evidence and exact effects", body: JSON.stringify({ ...r, semantic: undefined }, null, 2), notes: [] }] }];
+        const args = { workflowId: r.id, revision: r.revision };
+        if (r.state === 'awaiting_selection')
+            action("Start Sync", "prodero_memory_sync", { request: { action: 'select', ...args, improve: true, share: true, ...(r.brokenLinks ? { repairLinks: true } : {}) } });
+        if (r.state === 'semantic_work')
+            action("Continue improving memory", "prodero_memory_sync", { request: { action: 'prepare', ...args, candidateId: r.next.candidateId } });
+        if (r.state === 'awaiting_review')
+            action(r.review.kind === 'promotion' ? "Share reviewed knowledge" : "Approve reviewed changes", "prodero_memory_sync", { request: { action: 'approve', ...args, reviewId: r.review.reviewId, approved: true } }, true);
+        if (r.state === 'awaiting_promotion_selection')
+            action("Review selected knowledge for sharing", "prodero_memory_sync", { request: { action: 'promotions', ...args, ids: [] } });
+        if (r.state === 'awaiting_review')
+            action("Skip this review", "prodero_memory_sync", { request: { action: 'skip', ...args, ...(r.review.kind === 'transformation' ? { candidateId: r.jobs.find((j) => j.status === 'awaiting_review')?.id } : {}) } });
+        if (r.state === 'awaiting_promotion_selection')
+            action("Finish without sharing", "prodero_memory_sync", { request: { action: 'complete', ...args } });
+        if (r.state === 'stale' || r.state === 'completed')
+            action("Re-analyze memory", "prodero_memory_sync", { request: { action: 'start', restart: true } });
+        else if (["semantic_work", "applying"].includes(r.state))
+            action("Check progress", "prodero_memory_sync", { request: { action: 'inspect', workflowId: r.id } });
+        action("Show details", "prodero_memory_sync", { request: { action: 'inspect', workflowId: r.id }, details: true });
+    }
+    else if (payload.action === "prepare") {
+        vm.title = r.context.policyReadiness?.state === "required-incomplete" ? "Prodero · Required context incomplete" : r.context.policyReadiness?.state === "context-needed" ? "Prodero · Task context needed" : r.context.policyReadiness?.blocking ? "Prodero · Required policy review" : "Prodero · Context Ready";
+        const c = r.context, m = c.metrics;
+        if (c.applicability)
+            vm.diagnostics = [{ title: "Applicability", items: Object.entries(c.applicability.decisions).map(([id, d]) => ({ title: id, body: d.state, notes: d.reasons })) }];
+        if (c.allocation)
+            (vm.diagnostics ??= []).push({ title: "Context allocation", items: [{ title: "Allocation decisions", body: JSON.stringify(c.allocation, null, 2), notes: [] }] });
+        metric("Required", c.required.length);
+        metric("Relevant", c.relevant.length);
+        metric("Skills", c.skills.length);
+        metric("Synced", r.automaticSync?.sessionsProcessed ?? r.automaticSync?.sessions ?? 0);
+        metric("Task context", `${tokenLabel(m.contextTokens)} / ${tokenLabel(m.contextBudgetTokens)} est. tokens`);
+        metric("Project knowledge", `${tokenLabel(m.projectKnowledgeTokens)} est. tokens`);
+        const omitted = m.requiredGlobalExcludedItems ?? c.selection?.omittedRequired?.length ?? 0;
+        if (omitted)
+            vm.notices.push(`Required context truncated: ${omitted} required instructions were not loaded. Mandatory delivery is incomplete. Inspect total capacity and safety-ceiling omissions before continuing.`);
+        vm.notices.push(...(r.warnings ?? []), ...list(r.attention ?? c.attention).map(a => `${a.title}: ${a.detail}`));
+        section("Required instructions", c.required);
+        section("Relevant knowledge", c.relevant);
+        section("Skills", c.skills);
+        section("Required instructions not loaded", list(c.selection?.omittedRequired).map(i => ({ ...i, content: human(i.reason ?? "not loaded") })));
+        section("Additional matches not loaded", list(c.selection?.omittedRelevant).map(i => ({ ...i, content: human(i.reason ?? "not loaded") })));
+        const additional = (c.selection?.omittedRelevantByBudget ?? 0) + (c.selection?.omittedRelevantByItemLimit ?? 0) + (c.selection?.omittedRelevantByMarginalValue ?? 0);
+        if (additional)
+            vm.notices.push(`${additional} additional relevant matches were not loaded; ${c.selection?.omittedRelevant?.length ?? 0} summaries supplied.`);
+        const reviewId = c.snapshot?.reviewId;
+        if (reviewId) {
+            action("Review truncated required instructions", "prodero_instruction_review", { reviewId });
+            action("Preview instruction consolidation", "prodero_instruction_optimize", { reviewId, action: "preview" });
+        }
+        knowledge();
+    }
+    else if (payload.action === "session-close") {
+        vm.title = "Prodero · Session Learned";
+        metric("Recorded", r.learned.observations);
+        metric("Session memory", `${tokenLabel(r.learned.rawSessionTokens)} est. tokens`);
+        for (const [key, value] of Object.entries(r.learned.byType ?? {}))
+            if (value)
+                metric(human(key), value);
+        metric("Needs review", r.review?.needsReview);
+        metric("Local Knowledge", r.review?.localKnowledge);
+        metric("Versioned Knowledge", r.review?.versionedKnowledge);
+        vm.notices.push(r.alreadyClosed ? "Session was already closed." : "Session closed.");
+        vm.notices.push(r.learned.syncState === "pending-auto-sync" ? "Saving was deferred. Prodero will recover it before the next work session." : "Useful knowledge was saved automatically to Local Knowledge.");
+        const s = r.learned.synchronization;
+        if (s)
+            for (const key of ["knowledgeCreated", "knowledgeConsolidated", "duplicates", "conflicts"])
+                metric(human(key), s[key]);
+        if (r.review?.error)
+            vm.notices.push(`Knowledge review unavailable: ${r.review.error}`);
+        action("Review session knowledge", "prodero_session_review", { sessionId: r.session.id });
+        knowledge();
+    }
+    else if (["knowledge", "knowledge-mutated"].includes(payload.action)) {
+        vm.title = "Prodero · Knowledge";
+        if (payload.action === "knowledge-mutated")
+            vm.notices.push("Knowledge maintenance completed. Identity and history are retained.");
+        metric("Local", r.counts.local);
+        metric("Versioned", r.counts.versioned);
+        metric("Available for sharing review", r.counts.recommended);
+        metric("Matches", r.total);
+        section(r.detail ? "Knowledge detail" : "Knowledge", r.detail ? [r.detail] : r.matches);
+        if (!r.detail)
+            vm.knowledgeTable = { offset: r.options?.offset ?? 0, total: r.total, rows: r.matches.map((i, index) => ({ key: String(index + 1), id: i.id, layer: i.layer === 'versioned' ? 'Versioned' : 'Local', category: i.category ?? i.type ?? '', priority: i.priority ?? '', title: i.title ?? i.id })) };
+        if (r.detail) {
+            const i = r.detail;
+            action("Back to knowledge list", "prodero_knowledge", r.options);
+            vm.notices.push("Edits preserve identity and history. Retirement is not secure erase. Repository maintenance modifies Git-shareable files through the review workflow. Approval arguments do not authenticate human consent; review the Git diff before commit/push.");
+            action("Review an edit or retirement", "prodero_knowledge_mutate", { id: i.id, revision: i.revision, mode: i.layer === "versioned" ? "repository-maintenance" : "local" }, true);
+        }
+        else {
+            vm.notices.push("Pass an item ID to inspect its complete content and current revision.");
+            action("Inspect knowledge by ID", "prodero_knowledge", r.options);
+        }
+        if (!r.detail && r.nextOffset != null)
+            action("Next page", "prodero_knowledge", { ...r.options, offset: r.nextOffset });
+        action("Sync Memory · improve and share", "prodero_sync");
+    }
+    else if (payload.action === "instruction-review") {
+        vm.title = "Prodero · Required Instruction Review";
+        metric("Omitted", r.total);
+        metric("Critical", r.counts.critical);
+        metric("Normal", r.counts.normal);
+        section("Instructions", r.items.map((row) => ({ ...row.item, ...(!row.item ? { title: row.selection.title, id: row.selection.id, content: "No longer available." } : {}), signals: [{ kind: "Omission", detail: human(row.selection.reason) }] })));
+        if (r.nextOffset != null)
+            action("Next page", "prodero_instruction_review", { reviewId: r.reviewId, offset: r.nextOffset, criticalOnly: r.criticalOnly });
+        action("Preview instruction consolidation", "prodero_instruction_optimize", { reviewId: r.reviewId, action: "preview" });
+        knowledge();
+    }
+    else if (payload.action === "instruction-optimize") {
+        vm.title = "Prodero · Instruction Consolidation";
+        metric("Before", r.beforeTokens);
+        metric("After", r.afterTokens);
+        metric("Instructions reduced", r.reducedBy);
+        metric("Inspected", r.inspected);
+        metric("Remaining", r.remaining);
+        if (r.notice)
+            vm.notices.push(r.notice);
+        if (r.repository)
+            vm.notices.push("This proposal changes Git-tracked Versioned Knowledge.");
+        section("Before", list(r.before));
+        section("After", list(r.after));
+        if (!r.applied && r.previewId && r.reducedBy > 0)
+            action("Apply this exact reviewed preview", "prodero_instruction_optimize", { reviewId: r.reviewId, previewId: r.previewId, action: "apply", approved: true }, true);
+        if (r.applied)
+            vm.notices.push("Applied. Prepare again to load the updated instructions.");
+        knowledge();
+    }
+    else if (payload.action === "promotion-preview") {
+        vm.title = "Prodero · Publication Review";
+        const preview = payload.preview;
+        if (preview.notice)
+            vm.notices.push(preview.notice);
+        vm.notices.push("Supply the complete structured preview unchanged when approving publication.");
+        metric("Items", preview.actions.length);
+        vm.notices.push("This preview changes no knowledge. Applying it writes Git-shareable Versioned files; Curator does not commit or push. Review the Git diff before sharing. Conflicts remain local.");
+        for (const a of preview.actions) {
+            vm.notices.push(`${a.disposition}: ${a.localIds.join(", ")} — ${a.reason}`);
+            section(`Before · ${a.targetId ?? "new item"}`, a.before ? [a.before] : []);
+            section("Proposed", a.draft ? [a.draft] : []);
+        }
+        action("Publish the exact reviewed preview", "prodero_promote", { approved: true }, true);
+    }
+    else if (payload.action === "promotion-applied") {
+        vm.title = "Prodero · Publication Complete";
+        metric("Written to Versioned", r.published);
+        metric("Already covered", r.covered?.length);
+        metric("Conflicts remain local", r.conflicts?.length);
+        knowledge();
+    }
+    else if (payload.action === "session-review") {
+        vm.title = "Prodero · Session Knowledge Review";
+        metric("Items", r.summary.total);
+        metric("Needs review", r.summary.needsReview);
+        metric("State", r.consolidated ? "Synchronized" : "Pending synchronization");
+        section("Observations", r.items);
+        section("Produced knowledge", [...r.items.flatMap((i) => i.outputs ?? []), ...r.knowledge]);
+        vm.notices.push(`Session: ${r.sessionId} · Revision: ${r.revision}`);
+        if (r.editable)
+            action("Review an edit or discard", "prodero_session_review_mutate", { sessionId: r.sessionId, revision: r.revision }, true);
+        else
+            vm.notices.push("Session history is not editable; maintain the resulting knowledge instead.");
+        knowledge();
+    }
+    if (payload.presentationWarning)
+        vm.notices.push(payload.presentationWarning);
+    vm.notices = [...new Set(vm.notices.filter(Boolean))];
+    return vm;
+}
+/** Short overview first; selected instruction/knowledge bodies remain available to the agent. */
+export function renderText(vm, includeDiagnostics = false, expanded = includeDiagnostics) {
+    if (vm.conversation && vm.conversation.kind !== "details" && !expanded)
+        return renderConversation(vm.conversation);
+    const knowledgeDetail = vm.sections.find(s => s.title === "Knowledge detail");
+    if (knowledgeDetail) {
+        const record = knowledgeDetail.items.map(i => [i.title, i.body, ...i.notes].filter(Boolean).join("\n")).join("\n\n");
+        const hints = vm.notices.map(n => `• ${n}`).join("\n");
+        const diagnostics = includeDiagnostics ? (vm.diagnostics ?? []).map(s => `${s.title}:\n${s.items.map(i => [i.title, i.body, ...i.notes].filter(Boolean).join("\n")).join("\n\n")}`).join("\n\n") : '';
+        return [vm.title, `Knowledge detail:\n${record}`, "-------------", hints, renderActionMenu(vm.actions), diagnostics].filter(Boolean).join("\n\n");
+    }
+    const blocks = [vm.title, vm.metrics.map(m => `${m.label}  ${m.value}${m.detail ? ` · ${m.detail}` : ""}`).join("\n"), vm.notices.map(n => `• ${n}`).join("\n")];
+    if (vm.knowledgeTable) {
+        const t = vm.knowledgeTable;
+        blocks.push(renderKnowledgeTable(t.rows));
+        if (t.rows.length)
+            blocks.push(`Showing ${t.offset + 1}-${t.offset + t.rows.length} of ${t.total}. Enter a record number (for example 1) to open it; numbers refer only to this displayed page.`);
+    }
+    if (vm.actions.length)
+        blocks.push(renderActionMenu(vm.actions, (vm.knowledgeTable?.rows.length ?? 0) + 1));
+    for (const s of [...vm.sections.filter(s => !vm.knowledgeTable || s.title !== "Knowledge" || expanded), ...(includeDiagnostics ? vm.diagnostics ?? [] : (vm.title === "Knowledge cleanup" || (expanded && vm.conversation?.title === "Prodero · Project update") ? vm.diagnostics ?? [] : []))])
+        blocks.push(`${s.title}:\n` + s.items.map(i => [i.title, i.body, ...i.notes].filter(Boolean).join("\n")).join("\n\n"));
+    if (expanded && vm.conversation?.reviewRequired && vm.actions.some(a => a.approval) && vm.conversation.title === "Prodero · Sync")
+        blocks.push("Approve these exact changes?");
+    if (expanded && vm.conversation?.title === "Prodero · Project update") {
+        const approval = vm.actions.find(a => a.approval);
+        if (approval)
+            blocks.push(`${approval.label}?`);
+    }
+    return blocks.filter(Boolean).join("\n\n");
+}
+const escape = (s) => String(s).replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+/** Shared summary renderer, used by the existing interactive App. Actions keep its handlers. */
+export function renderMetricsHtml(vm) {
+    return vm.metrics.map(m => `<div class="metric"><strong>${escape(m.value)}</strong><span>${escape(m.label)}</span>${m.detail ? `<small>${escape(m.detail)}</small>` : ""}</div>`).join("");
+}
+//# sourceMappingURL=presentation.js.map