@prodero/curator 0.1.0 → 0.2.1

package/dist/presentation.js

@@ -1,13 +1,17 @@
-import { renderKnowledgeTable } from './knowledge-table.js';
-import { conversationView, renderConversation, renderActionMenu, PRESENTATION_REPLY } from './conversation-presentation.js';
+import { renderProductText, entryKey } from './text-layout.js';
+import { conversationView, PRESENTATION_REPLY, LIFECYCLE_PRESENTATION_REPLY } from './conversation-presentation.js';
 import { renderReviewProjection } from './core/curation-review-presentation.js';
-export { PRESENTATION_REPLY } from './conversation-presentation.js';
+export { PRESENTATION_REPLY, LIFECYCLE_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';
+import { memoryOpenPresentation, memorySyncPresentation, MEMORY_COPY } from './memory-presentation.js';
+import { memorySyncOperation } from './memory-sync-operation.js';
+import { MANUAL_UPDATE_COMMAND } from './update-instructions.js';
+export { memorySyncOperation, syncClientFailure, syncClientNotice } from './memory-sync-operation.js';
 export { memoryOpenPresentation, memorySyncPresentation, MEMORY_COPY } from './memory-presentation.js';
+export { UPDATE_INSTRUCTIONS } from './update-instructions.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.';
+export const PRESENTATION_ROUTING = PRESENTATION_REPLY + ' ' + LIFECYCLE_PRESENTATION_REPLY + ' Read effective settings with prodero_config_get for the current project before choosing each presentation route. Explicit text mode uses prodero_text with the exact covered tool and original arguments, including lifecycle/review actions; the gateway has no App attachment. Do not call an App-attached original with presentation=text. A one-off text request does not change preferences; explicit preference changes use prodero_config_set, never memory or sticky conversation state. Auto uses advertised MCP Apps capability, never inferred devices. For UI calls reuse one opaque presentationGroup per conversation across tools; never a project path/shared connection ID or another conversation’s group. Preserve each operation’s existing review/approval requirements.';
 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, " ");
@@ -25,6 +29,19 @@ 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);
+    const r = normalized.result ?? normalized, p = normalized.project ?? r.project;
+    const c = normalized.action === 'context' ? r : r.context;
+    const b = normalized.bootstrap;
+    const projection = normalized.curation?.projection;
+    vm.textScene = {
+        action: normalized.action,
+        project: p?.name ?? String(r.root ?? c?.projectRoot ?? normalized.root ?? normalized.projectSettings?.root ?? '').split(/[\\/]/).filter(Boolean).at(-1),
+        task: c?.query,
+        ...(c?.metrics ? { budget: { used: c.metrics.contextTokens, total: c.metrics.contextBudgetTokens, source: 'Task', estimated: true } } : b?.loaded && b.metrics && b.limits ? { budget: { used: b.metrics.estimatedTokens, total: b.limits.budgetTokens, source: 'Bootstrap', estimated: true } } : {}),
+        ...(['open', 'status', 'initialized'].includes(normalized.action) ? { home: { initialized: p?.initialized, records: p?.knowledgeCount, local: p?.localKnowledgeCount, versioned: p?.versionedKnowledgeCount, deferred: projection?.deferredQuestions, pending: projection?.readyChangeGroups } } : {}),
+    };
+    if (['open', 'status', 'status-details'].includes(normalized.action) && normalized.update?.available)
+        vm.conversation.attention.push(`Finish work and close hosts, then run ${MANUAL_UPDATE_COMMAND} in a terminal. Restart/reconnect afterwards; review project migrations separately.`);
     return vm;
 }
 function buildDetailedViewModel(payload) {
@@ -37,7 +54,51 @@ function buildDetailedViewModel(payload) {
     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 questionActions = (data, workflowId, candidateId) => {
+        const review = data.review, g = data.graphical;
+        if (!review || !g)
+            return;
+        const binding = { workflowId, candidateId, reviewId: review.snapshot.reviewId, reviewRevisionId: review.snapshot.revision.id, planHash: review.snapshot.planHash, decisionRevision: review.state.revision, answerLogHash: g.answerLogHash };
+        for (const q of g.questions.filter((q) => q.needsInput || q.state === 'answered_pending_analysis')) {
+            if (q.needsInput && !g.analysisPending)
+                for (const choice of q.question.choices)
+                    action(choice.label, 'prodero_curation_question', { ...binding, action: 'answer', questionId: q.question.id, questionVersion: q.question.version, choiceId: choice.id, requestId: `chat_${globalThis.crypto.randomUUID()}`, ...(q.answer ? { replacesAnswerId: q.answer.id } : {}) });
+            action(q.relatedQuestions?.length > 1 ? `Defer ${q.relatedQuestions.length} related questions` : 'Answer later', 'prodero_curation_question', { ...binding, action: 'question_later', questionId: q.question.id, questionVersion: q.question.version });
+        }
+        if (g.canRetryAnalysis)
+            action('Retry saved answer analysis', 'prodero_curation_question', { ...binding, action: 'retry_analysis' });
+        else if (g.needsPreparation)
+            action('Analyze saved answer', 'prodero_curation_question', { ...binding, action: 'analyze' });
+        if (g.continuationJobId)
+            action('Continue bounded analysis', 'prodero_curation_reasoning_prepare', { jobId: g.continuationJobId });
+    };
+    if (payload.action === 'config-get') {
+        vm.title = 'Prodero · Project Settings';
+        const settings = payload.projectSettings;
+        vm.sections = settings.settings.map((s) => ({ title: s.label, items: [{ title: s.displayValue, body: s.description, notes: [`Source: ${s.source}`] }] }));
+        vm.notices.push('Display mode and theme are saved on this checkout. Context budget is shared project configuration.');
+        for (const d of settings.diagnostics ?? [])
+            vm.notices.push(`${d.code}: ${d.cause} ${d.recovery}`);
+        if (!settings.initialized)
+            vm.notices.push('Project is not initialized. Defaults are shown; initialize Prodero before saving settings.');
+    }
+    else if (payload.action === 'update-instructions') {
+        vm.title = 'Prodero · Update instructions';
+        vm.notices.push(r.message);
+    }
+    else if (payload.action === 'curation-question') {
+        vm.title = 'Saved curation question';
+        vm.simpleActions = true;
+        if (payload.answerAcknowledgement)
+            vm.notices.push(payload.answerAcknowledgement.message);
+        if (payload.analysisNotice)
+            vm.notices.push(payload.analysisNotice);
+        vm.notices.push('Chat answers are relayed evidence, not approval. Unresolved facts may still need clarification.');
+        vm.sections.push({ title: 'Project questions', items: payload.graphical.questions.map((q) => ({ title: q.question.title, body: q.question.prompt, notes: [q.state, ...q.question.choices.map((c) => c.label)] })) });
+        questionActions(payload, payload.syncWorkflowId, payload.candidateId);
+        action('Check saved curation progress', 'prodero_memory_sync', { request: { action: 'inspect', workflowId: payload.syncWorkflowId } });
+    }
+    else if (payload.action === "curation") {
         const p = payload.plan, projection = payload.projection;
         vm.title = "Knowledge cleanup";
         if (!projection) {
@@ -160,7 +221,7 @@ function buildDetailedViewModel(payload) {
                 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: [] }] }];
+            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: p.memoryHealth?.missingProvenanceItems ? [`${p.memoryHealth.missingProvenanceItems} current records have incomplete provenance metadata. ${MEMORY_COPY.incompleteProvenance}`] : [] }] }];
             if (payload.phase === "initial") {
                 vm.notices.push("Lightweight status only; detailed statistics were not requested.");
                 action("Load detailed status", "prodero_status_details");
@@ -169,6 +230,8 @@ function buildDetailedViewModel(payload) {
             action("Show project skills", "prodero_skills");
             action(memory.button, "prodero_sync");
             action("Check for updates", "prodero_check_update");
+            if (payload.update?.available)
+                action("Show update instructions", "prodero_update");
         }
         const b = payload.bootstrap;
         if (b) {
@@ -193,36 +256,25 @@ function buildDetailedViewModel(payload) {
     }
     else if (payload.action === "memory-sync") {
         const memory = memorySyncPresentation(r);
-        vm.title = `Sync Memory · ${memory.headline}`;
+        vm.title = memory.headline === 'Curate Memory' ? 'Prodero · Curate Memory' : `Curate 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: [] }] });
+            vm.sections.unshift({ title: 'Curation 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 });
+        const operation = r.operation ?? memorySyncOperation(r);
+        vm.operation = operation;
+        for (const q of list(r.deferredQuestions)) {
+            const { title, expired, affectedQuestions } = q;
+            vm.sections.push({ title: expired ? 'Expired question review' : 'Deferred questions', items: [{ title: affectedQuestions.length > 1 ? `${affectedQuestions.length} related questions` : title, body: affectedQuestions.map((a) => a.title).join('\n'), notes: [...(affectedQuestions.length > 1 ? ['These related questions reopen together.'] : []), ...(expired ? ['Refresh this expired review before choosing Revisit. Refresh preserves deferral.'] : [])] }] });
+        }
+        vm.actions.push(...operation.actions);
     }
     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";
@@ -287,20 +339,26 @@ function buildDetailedViewModel(payload) {
         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 })) };
+            vm.knowledgeTable = { offset: r.options?.offset ?? 0, total: r.total, rows: r.matches.map((i, index) => ({ key: entryKey(index), 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);
+            vm.actions.at(-1).input = { field: 'action', prompt: 'Collect edit/retire and required fields. Show the complete proposal before asking for approval.' };
         }
         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);
+            const search = { label: 'Search knowledge', tool: 'prodero_knowledge', arguments: { ...(root ? { projectRoot: root } : {}), ...r.options, offset: 0 }, input: { field: 'query', prompt: 'What should I search for?' } };
+            vm.actions.push(search);
+            action('Show Local knowledge', 'prodero_knowledge', { ...r.options, layer: 'local', offset: 0 });
+            action('Show Versioned knowledge', 'prodero_knowledge', { ...r.options, layer: 'versioned', offset: 0 });
+            if (r.options?.offset)
+                action('Previous page', 'prodero_knowledge', { ...r.options, offset: Math.max(0, r.options.offset - (r.options.limit ?? 12)) });
         }
         if (!r.detail && r.nextOffset != null)
             action("Next page", "prodero_knowledge", { ...r.options, offset: r.nextOffset });
-        action("Sync Memory · improve and share", "prodero_sync");
+        action("Curate Memory", "prodero_sync");
+        action("Back to Prodero", "prodero_open");
     }
     else if (payload.action === "instruction-review") {
         vm.title = "Prodero · Required Instruction Review";
@@ -348,7 +406,7 @@ function buildDetailedViewModel(payload) {
         action("Publish the exact reviewed preview", "prodero_promote", { approved: true }, true);
     }
     else if (payload.action === "promotion-applied") {
-        vm.title = "Prodero · Publication Complete";
+        vm.title = "Prodero · Versioned Files Prepared";
         metric("Written to Versioned", r.published);
         metric("Already covered", r.covered?.length);
         metric("Conflicts remain local", r.conflicts?.length);
@@ -374,35 +432,8 @@ function buildDetailedViewModel(payload) {
     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");
+export function renderText(vm, includeDiagnostics = false, expanded = includeDiagnostics, plain = false) {
+    return renderProductText(vm, includeDiagnostics, expanded, plain);
 }
 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. */

package/dist/server.js

@@ -1,6 +1,8 @@
 import { AGENT_INSTRUCTIONS_PATH } from "./core/templates.js";
+import { MCP_INITIALIZATION_INSTRUCTIONS } from "./core/agent-instructions.js";
 import { SKILL_EXECUTION_ROUTING } from "./skill-instructions.js";
 import { graphicalActionSchema, graphicalReviewAction, graphicalReviewPayload } from './core/curation-graphical.js';
+import { curationQuestionToolSchema, runCurationQuestion } from './core/curation-question.js';
 import { prepareSemanticCuration, inspectSemanticCuration, submitSemanticCuration, semanticPrepareSchema } from './core/curation-semantic-jobs.js';
 import { executeCurationReview } from "./curation-review-adapter.js";
 import { createCurationReview, curationReviewView, controlCurationReview, latestCurationReview, resumeCurationReview, stageCurationDecisions, CurationReviewError } from "./core/curation-review.js";
@@ -10,10 +12,9 @@ import { matchesCurrentUserRule, rememberCurrentUserRule, rememberChatRule } fro
 import { planProjectMigration, applyProjectMigration, requireCurrentProject } from "./core/migrations.js";
 import { runMemorySync, syncWorkflowForCuration, getMemorySyncOverview, memorySyncActionSchema } from './core/memory-sync.js';
 import { prepareMemoryTransformation, validateMemoryTransformationProposal, memoryTransformationProposalSchema } from './core/memory-transformation-proposal.js';
-import { CONTEXT_ROUTING } from "./context-instructions.js";
-import { projectSettings, setProjectSetting, renderSettings } from "./core/settings.js";
+import { projectSettings, setProjectSetting } from "./core/settings.js";
 import { SETTINGS_ROUTING, settingKeySchema } from "./settings-definition.js";
-import { PRESENTATION_LAUNCHER, PRESENTATION_ROUTING } from "./presentation.js";
+import { buildViewModel, renderText } from "./presentation.js";
 import { presentationTools } from "./presentation-server.js";
 import { installPresentationTrace } from "./presentation-trace.js";
 import { installDiagnosticBoundary } from "./diagnostic-boundary.js";
@@ -25,20 +26,21 @@ import { knowledgeView, mutateKnowledge, knowledgeQuerySchema, knowledgeMutation
 import { mcpSamplingProvider } from "./providers/mcp-sampling.js";
 import { PluginRegistry } from "./plugins/registry.js";
 import { registerPluginTools } from "./plugins/mcp.js";
-import { readConfig } from "./core/storage.js";
+import { readConfig, CANONICAL_ID_PATTERN } from "./core/storage.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { registerAppResource, getUiCapability, RESOURCE_MIME_TYPE, } from "@modelcontextprotocol/ext-apps/server";
 import { z } from "zod";
-import { autoMigrateProject, applyPendingProjectIntegrationRefresh, findProjectRoot, closeProjectSession, emptyBootstrapContext, getDetailedProjectStatus, getFastProjectStatus, initializeProject, rememberProjectKnowledge, searchProjectMemory, forgetProjectKnowledge, previewProjectKnowledgePromotion, promoteProjectKnowledge, prepareProject, recallProject, PRODERO_SCHEMA_VERSION, PRODERO_VERSION, resolveProjectContext, resolveProjectBootstrapContext, refreshProjectIntegration, recordProjectSession, scheduleProjectIntegrationRefresh, } from "./core/project.js";
+import { autoMigrateProject, applyPendingProjectIntegrationRefresh, findProjectRoot, closeProjectSession, emptyBootstrapContext, getDetailedProjectStatus, getFastProjectStatus, initializeProject, rememberProjectKnowledge, searchProjectMemory, forgetProjectKnowledge, previewProjectKnowledgePromotion, promoteProjectKnowledge, prepareProject, recallProject, PRODERO_SCHEMA_VERSION, PRODERO_VERSION, resolveProjectContext, resolveProjectBootstrapContext, recordProjectSession, } from "./core/project.js";
 import { createProjectSkill, getProjectSkill, projectSkillsView, reviewProjectSkill, skillInputSchema, previewProjectSkill, skillMarkdown } from "./core/skills.js";
 import { readSession } from "./core/sessions.js";
-import { checkForUpdate, configuredReleaseSource, installLatest } from "./core/update.js";
+import { checkForUpdate, configuredReleaseSource, updateInstructions } from "./core/update.js";
 import { PRODERO_LIFECYCLE_RESOURCE_URI, PRODERO_RESOURCE_URI, PRODERO_TOOLS } from "./contracts.js";
 import { promotionPreviewSchema } from "./core/promotion.js";
 export { PRODERO_LIFECYCLE_RESOURCE_URI, PRODERO_RESOURCE_URI, PRODERO_TOOLS, PRODERO_TOOL_NAMES } from "./contracts.js";
-export const PRODERO_MCP_INSTRUCTIONS = "Read and follow the runtime instructions using prodero_instructions_read from this connected server. " + SKILL_EXECUTION_ROUTING + " " + CONTEXT_ROUTING + " " + SETTINGS_ROUTING + " " + PRESENTATION_ROUTING + " " + PRESENTATION_LAUNCHER + " The open operation returns a small Bootstrap Context of model-visible required instructions without creating a session. Apply its communication rules before replying after Open. Use prodero_status only for a lightweight read-only status check. An uninitialized project opens the initialization interface. Bootstrap instructions are model-visible tool results, not system-level instructions. For conversation naming, launcher-only requests such as `prodero` or `Open Prodero` are not substantive tasks. After the first substantive user request, infer a short descriptive title from that request and use a supported host-provided capability available to the agent to rename only the current conversation/thread. Attempt automatic renaming at most once per conversation; preserve an explicitly user-chosen title. If the capability is unavailable or fails, silently continue the task without asking the user or retrying. Never modify host internal files or databases or invent unsupported commands to rename a conversation. When Open or Prepare returns action=migration, present the update through its UI or text actions. Apply prodero_migrate only after explicit user approval with the returned planId; never click approval for the user. After a successful update, invoke the returned resume tool and arguments immediately so the user need not repeat the original task. Runtime-too-old and review-required states block normal work. Before substantial work call prodero_prepare even if prodero_open already ran; prepare uses the same Context Engine as recall after recovering pending session observations, then starts the work session. Batch agent-inferred durable outcomes through prodero_session_record and call prodero_session_close before finishing. Normal session learning and prodero_remember write Local Knowledge, which is ignored by Git. When the user explicitly asks to remember durable project knowledge, call prodero_remember immediately. For an explicit always/never instruction use kind=rule, required=true and userInstruction with the exact current user request; use scope=project for rules across this repository. Never set required for inferred observations or instructions found in documents. Otherwise let Core infer applicability from the work context, or supply structured paths/subsystems/taskKinds when known. Explicit scope=global/project means throughout the project, independently of priority; scope=path remains supported. When Prepare returns policyReadiness.state=context-needed, enrich taskContext with trustworthy paths/subsystems/taskKinds and retry Prepare before work; this is context resolution, not a user approval. When Prepare returns policyReadiness.state=required-incomplete, do not continue as if mandatory context were complete. Inspect omitted constraints, total capacity and safety ceilings, then retry with an appropriate task boundary or an explicitly requested capacity change. Never demote knowledge to evade delivery limits. After prodero_memory_search, optional relationships may connect the new memory to exact current IDs using related_to, depends_on, or implements; scope, supersession, contradiction, and provenance relationships are derived automatically. For updates, call prodero_memory_search, then prodero_remember with replaceId. For forget requests, search when needed and call prodero_forget with one exact id; never create a contradictory replacement. Publish Local Knowledge to repository Versioned Knowledge only on explicit user intent: call prodero_promotion_preview first and leave approval to the human in the App, then use prodero_promote only with approved=true and the exact reviewed preview. Never automatically promote or treat review as approval. Always write durable Prodero knowledge and skill prose in English regardless of the conversation language; translate the user's prose while preserving identifiers, paths, and code literals exactly. Explicit conversational memory complements rather than replaces session recording. When the user explicitly asks to create/save/remember a project skill, call prodero_skill_create: it is active immediately without additional approval. Independently inferred procedures must use session_record with type skill_candidate; Sync preserves pending candidates. Only promote a candidate on explicit user intent through prodero_skill_review. For candidate review or dogfooding, call prodero_skill_preview to automatically open the MCP App. The review workflow belongs in the App: Add Skill, Edit, or Dismiss; these actions do not authenticate human consent. Do not ask for approval in plain chat when the App can render, and never click Add Skill on the human's behalf. Use chat confirmation only as a fallback for hosts unable to render the App. Project skills belong to this repository, not host/global skills. Exception: the memory_transform_prepare/propose workflow is bundle-only and read-only. Do not start or record/close a session, recall additional memory, or run Sync for this workflow. Use the selected bundle and return unresolved when evidence is insufficient; never apply a proposal. The separate user-initiated Sync Memory workflow uses prodero_sync and prodero_memory_sync. Do not start it from session close or Prodero Open. Start Sync selects Improve memory and Share knowledge (both enabled by default); users may disable either. When broken links exist, Sync also offers Fix broken links, enabled by default and independently selectable. Link removal always requires approval of its exact review, including Local links. Improve automatically investigates planner candidates using existing Curator reasoning and questions, one bounded bundle at a time; Core may apply eligible Local proposals. Deferred questions do not block independent work. Sharing review follows in the same workflow and always requires explicit publication approval. Stop for human review of any Versioned changes, promotion or semantic limitations. No separate session prepare/record/close is needed for Sync Memory.";
+export const PRODERO_MCP_INSTRUCTIONS = MCP_INITIALIZATION_INSTRUCTIONS;
+const memoryIdSchema = z.string().regex(CANONICAL_ID_PATTERN);
 const observationSchema = z.object({
     applicability: applicabilitySchema.optional(), taskContext: taskContextInputSchema.optional(),
     type: z.enum(["decision", "lesson", "discovery", "state_change", "global_instruction_candidate", "skill_candidate"]),
@@ -51,7 +53,7 @@ const observationSchema = z.object({
     proposedReason: z.string().trim().min(1).max(1_000).optional(),
     importanceHint: z.enum(["critical", "important", "normal", "contextual"]).optional(),
     categoryHint: z.enum(["principle", "invariant", "decision", "constraint", "lesson", "state", "instruction"]).optional(),
-    supersedes: z.array(z.string().regex(/^mem_[a-zA-Z0-9_]+$/)).max(20).optional(),
+    supersedes: z.array(memoryIdSchema).max(20).optional(),
 });
 function text(data, companion) {
     return {
@@ -112,16 +114,17 @@ export function createServer(options = {}) {
         inputSchema: { projectRoot: projectRootSchema }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
     }, async ({ projectRoot }) => {
         const view = await projectSettings(await workspaceRoot(projectRoot));
-        return text({ ok: true, action: "config-get", projectSettings: view }, renderSettings(view));
+        const payload = { ok: true, action: "config-get", projectSettings: view };
+        return text(payload, renderText(buildViewModel(payload)));
     });
     server.registerTool(PRODERO_TOOLS.configSet, {
-        title: "Change Prodero Project Settings", description: SETTINGS_ROUTING + " Change one known setting. Value must be an allowed enum ID or an integer context budget between 1 and 1,000,000. Preserves unrelated config fields; never stores settings as knowledge.",
-        inputSchema: { projectRoot: projectRootSchema, key: settingKeySchema, value: z.union([z.string(), z.number()]) },
+        title: "Change Prodero Project Settings", description: SETTINGS_ROUTING + " Change one known setting. Value must be an allowed enum ID or an integer context budget between 1 and 1,000,000. Use reset:true without value to remove one local presentation override. Preserves unrelated fields; never stores settings as knowledge.",
+        inputSchema: { projectRoot: projectRootSchema, key: settingKeySchema, value: z.union([z.string(), z.number()]).optional(), reset: z.boolean().optional() },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    }, async ({ projectRoot, key, value }) => {
-        const view = await setProjectSetting(await workspaceRoot(projectRoot), key, value);
+    }, async ({ projectRoot, key, value, reset }) => {
+        const view = await setProjectSetting(await workspaceRoot(projectRoot), key, value, { reset });
         const updated = view.settings.find(s => s.key === key);
-        return text({ ok: true, action: "config-set", updated, projectSettings: view }, `${updated.label} saved: ${updated.displayValue}.`);
+        return text({ ok: true, action: "config-set", updated, projectSettings: view }, reset ? `${updated.label} local override removed: ${updated.displayValue} (${updated.source}).` : `${updated.label} saved: ${updated.displayValue}.${key.startsWith('presentation.') ? ' Saved on this checkout.' : ''}`);
     });
     const workSessions = new Map();
     const instructionSelections = new Map();
@@ -178,7 +181,12 @@ export function createServer(options = {}) {
         ...['defer_issue', 'defer_change'].map(action => z.object({ action: z.literal(action), ...reviewIdentity, decisionRevision: z.number().int().nonnegative(), unitId: z.string() }).strict()),
         z.object({ action: z.literal('decide'), ...reviewIdentity, decisionRevision: z.number().int().nonnegative(), decisions: z.record(z.enum(['current', 'suggested', 'deferred'])) }).strict(),
     ]);
-    // Deliberately outside the text gateway; visibility is enforced by the MCP App host.
+    registerAppTool(server, PRODERO_TOOLS.curationQuestion, {
+        title: 'Answer a saved Sync question', description: 'Inspect, answer, defer or deliberately revisit an exactly bound question in the current Sync workflow. Analyze/retry prepares bounded reasoning only. Chat answers are server-stamped agent_relay evidence, not authenticated human intent, policy authority or approval. Save the user\'s actual answer with a unique requestId; never invent an answer. Inspect saved state after unknown outcomes before replay. No create, selection, summary, pause/unpause, protected Apply or promotion.',
+        inputSchema: curationQuestionToolSchema.extend({ projectRoot: projectRootSchema }).shape,
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
+    }, async ({ projectRoot, ...input }) => reviewResult(async () => runCurationQuestion(await workspaceRoot(projectRoot), input)));
+    // Protected review selection remains outside the text gateway and App-only.
     server.registerTool(PRODERO_TOOLS.curationReview, {
         title: "Review knowledge decisions", description: "Stage review choices, defer an issue or change, or pause/resume the whole review. Does not apply knowledge changes.",
         // MCP tool schemas use an object root; enforce action-specific fields below.
@@ -307,7 +315,7 @@ export function createServer(options = {}) {
     });
     registerAppTool(server, PRODERO_TOOLS.prepare, {
         title: "Prepare Prodero Session",
-        description: "Prepare substantial agent work: recover pending session observations, open a unique session memory file, and return compact task context.",
+        description: "Prepare substantial agent work: recover pending session observations, open a unique session memory file, and return compact task context. For lifecycle text delivery use prodero_text with tool=prodero_prepare and show its compact confirmation before continuing; healthy Prepare needs no additional approval or Continue step.",
         inputSchema: { projectRoot: projectRootSchema, task: z.string().optional(), taskContext: taskContextInputSchema.optional(), purpose: z.enum(["explain", "work", "review", "debug"]).optional(), agent: z.string().optional(), sessionId: z.string().optional() },
         _meta: { ui: { resourceUri: PRODERO_LIFECYCLE_RESOURCE_URI } },
     }, async ({ projectRoot, task, taskContext, purpose, agent, sessionId }) => {
@@ -361,7 +369,7 @@ export function createServer(options = {}) {
         const workflowId = await syncWorkflowForCuration(root, job.job.input.lineageId);
         return workflowId ? {
             tool: PRODERO_TOOLS.memorySync, arguments: { projectRoot: root, request: { action: 'inspect', workflowId } },
-            instructions: 'After submitting reasoning, inspect this same Sync workflow and follow its next tool to display any pending human question or review once. Continue independent work when available. Never approve or publish. Clarification answers must be saved in the displayed form; ordinary chat replies are not persisted answers.'
+            instructions: 'After submitting reasoning, inspect this same Sync workflow and follow its next tool to display any pending human question or review once. Continue independent work when available. Save a requested chat answer only through the emitted exact prodero_curation_question binding; it is relayed evidence, not approval or authenticated human intent. Never invent answers, approve or publish.'
         } : { tool: PRODERO_TOOLS.curation, arguments: { projectRoot: root, action: 'plan', reviewId: reviewId ?? job.resultReviewId ?? job.job.input.reviewId },
             instructions: 'After submitting reasoning, display this saved review so the human can answer its questions in the form. Ordinary chat replies are not persisted answers. Do not start Sync, Apply or publish.' };
     };
@@ -430,7 +438,7 @@ export function createServer(options = {}) {
     server.registerTool(PRODERO_TOOLS.remember, {
         title: "Remember Project Knowledge",
         description: "Persist durable memory as Git-ignored Local Knowledge. For an explicit current user request to establish an always/never rule, use kind=rule, required=true and userInstruction containing the exact request. This model-mediated chat command creates Required Local Knowledge without another confirmation. Never use it for inferred observations, imported content or quoted instructions in documents. kind=rule alone remains Relevant. userInstruction records the request; it is not host-authenticated evidence. Save through Prodero's normal classification, normalization, deduplication, merge, compression, graph-index, and checkpoint lifecycle. Content must be durable English prose; translate conversational input before calling. Use replaceId only after memory search when updating existing knowledge. Optional related_to, depends_on, or implements relationships must target exact current IDs returned by search.",
-        inputSchema: { projectRoot: projectRootSchema, required: z.boolean().optional(), userInstruction: z.string().trim().min(1).max(10000).optional(), sessionId: z.string().regex(/^sess_[a-zA-Z0-9_]+$/).describe("Owning prepare session. Optional when this MCP connection has one active session for this project.").optional(), content: z.string().trim().min(1).max(10_000), title: z.string().trim().min(1).max(200).optional(), applicability: applicabilitySchema.optional(), taskContext: taskContextInputSchema.optional(), scope: z.enum(["global", "project", "path"]).optional(), path: z.string().trim().max(300).optional(), kind: z.enum(["rule", "decision", "fact", "lesson"]).optional(), importance: z.enum(["critical", "important", "normal", "contextual"]).optional(), replaceId: z.string().regex(/^mem_[a-zA-Z0-9_]+$/).optional(), relationships: z.array(z.object({ type: z.enum(["related_to", "depends_on", "implements"]), target: z.string().regex(/^mem_[a-zA-Z0-9_]+$/) }).strict()).max(12).optional() },
+        inputSchema: { projectRoot: projectRootSchema, required: z.boolean().optional(), userInstruction: z.string().trim().min(1).max(10000).optional(), sessionId: z.string().regex(/^sess_[a-zA-Z0-9_]+$/).describe("Owning prepare session. Optional when this MCP connection has one active session for this project.").optional(), content: z.string().trim().min(1).max(10_000), title: z.string().trim().min(1).max(200).optional(), applicability: applicabilitySchema.optional(), taskContext: taskContextInputSchema.optional(), scope: z.enum(["global", "project", "path"]).optional(), path: z.string().trim().max(300).optional(), kind: z.enum(["rule", "decision", "fact", "lesson"]).optional(), importance: z.enum(["critical", "important", "normal", "contextual"]).optional(), replaceId: memoryIdSchema.optional(), relationships: z.array(z.object({ type: z.enum(["related_to", "depends_on", "implements"]), target: memoryIdSchema }).strict()).max(12).optional() },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     }, async ({ projectRoot, required, userInstruction, ...input }) => {
         if (required && (input.kind !== "rule" || !userInstruction))
@@ -455,8 +463,8 @@ export function createServer(options = {}) {
     });
     server.registerTool(PRODERO_TOOLS.forget, {
         title: "Forget Project Knowledge",
-        description: "Safely retire one exact durable knowledge item after explicit user intent. Prefer an id returned by prodero_memory_search. The canonical record is preserved as historical and excluded from normal context; no file is destructively deleted.",
-        inputSchema: { projectRoot: projectRootSchema, id: z.string().regex(/^mem_[a-zA-Z0-9_]+$/).optional(), query: z.string().trim().min(1).max(1_000).optional(), reason: z.string().trim().min(1).max(1_000).optional() },
+        description: "Retire one exact Local Knowledge item after explicit user intent; use the id and layer returned by prodero_memory_search. Versioned Knowledge requires the existing reviewed prodero_knowledge_mutate repository-maintenance retire operation with its current revision. Never silently switch layers or operations. The canonical record is preserved as historical; no file is destructively deleted.",
+        inputSchema: { projectRoot: projectRootSchema, id: memoryIdSchema.optional(), query: z.string().trim().min(1).max(1_000).optional(), reason: z.string().trim().min(1).max(1_000).optional() },
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
     }, async ({ projectRoot, id, query, reason }) => {
         if (!id && !query)
@@ -467,7 +475,7 @@ export function createServer(options = {}) {
     registerAppTool(server, PRODERO_TOOLS.promotionPreview, {
         title: "Review Local Knowledge Promotion",
         description: "Build a read-only semantic consolidation proposal from Local Knowledge into Versioned Knowledge. The proposal distinguishes new, merge, supersede, covered, and conflict outcomes. It never publishes knowledge or implies approval; leave the decision to the human in the attached App.",
-        inputSchema: { projectRoot: projectRootSchema, ids: z.array(z.string().regex(/^mem_[a-zA-Z0-9_]+$/)).max(50).optional(), includeAll: z.boolean().optional() },
+        inputSchema: { projectRoot: projectRootSchema, ids: z.array(memoryIdSchema).max(50).optional(), includeAll: z.boolean().optional() },
         annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
         _meta: { ui: { resourceUri: PRODERO_RESOURCE_URI } },
     }, async ({ projectRoot, ids, includeAll }) => {
@@ -496,7 +504,7 @@ export function createServer(options = {}) {
     });
     registerAppTool(server, PRODERO_TOOLS.sessionClose, {
         title: "Close Prodero Session",
-        description: "Finalize the current Prodero session, optionally with a final batch. Synchronizes session observations into Local Knowledge deterministically before returning success; prepare recovers pending work.",
+        description: "Finalize the current Prodero session, optionally with a final batch. Synchronizes session observations into Local Knowledge deterministically before returning success; prepare recovers pending work. Call before the final task answer. For lifecycle text delivery use prodero_text with tool=prodero_session_close and show its returned compact saved/deferred state; never claim Session Complete without a successful Close result.",
         inputSchema: { projectRoot: projectRootSchema, sessionId: z.string(), finalEntries: z.array(observationSchema).max(100).optional(), sync: z.boolean().optional().describe("Defaults to true. Set false only to defer synchronization for legacy workflows; prepare recovers it.") },
         _meta: { ui: { resourceUri: PRODERO_LIFECYCLE_RESOURCE_URI } },
     }, async ({ projectRoot, sessionId, finalEntries, sync }) => {
@@ -532,22 +540,22 @@ export function createServer(options = {}) {
         return text({ ok: true, action: "initialized", project, status: await detailedStatus(project.root, instrument) });
     });
     registerAppTool(server, PRODERO_TOOLS.sync, {
-        title: 'Sync Memory',
-        description: 'Open Sync Memory or present a pending human step. With workflowId, reopen only that saved workflow; do not restart analysis. Recover pending deterministic observations, analyze transformation and promotion candidates, then await selection. Opening does not authorize semantic transformation or publication. This replaces the old manual session-flush action.',
+        title: 'Curate Memory',
+        description: 'Open Curate Memory or present a pending human step. With workflowId, reopen only that saved workflow; do not restart analysis. Recover pending deterministic observations, analyze transformation and promotion candidates, then await selection. Opening does not authorize semantic transformation or publication. This replaces the old manual session-flush action.',
         inputSchema: { projectRoot: projectRootSchema, workflowId: z.string().uuid().optional().describe("Reopen this exact saved workflow without starting a new analysis.") }, annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
         _meta: { ui: { resourceUri: PRODERO_RESOURCE_URI } },
     }, async ({ projectRoot, workflowId }) => {
         const result = await runMemorySync(await workspaceRoot(projectRoot), workflowId ? { action: 'inspect', workflowId } : { action: 'start' });
-        return text({ ok: true, action: 'memory-sync', result, uiState: { view: 'memory-sync' } }, `Sync Memory: ${result.state}. The current saved step is displayed in the App.`);
+        return text({ ok: true, action: 'memory-sync', result, uiState: { view: 'memory-sync' } }, `Curate Memory: ${result.state}. The current saved step is displayed in the App.`);
     });
     registerAppTool(server, PRODERO_TOOLS.memorySync, {
-        title: 'Continue Sync Memory',
-        description: 'Continue the existing Sync Memory UI in place without opening another App. Use prodero_sync to open the UI and once when next.tool requests a human handoff; pass next.arguments exactly before ending the turn. Do not reopen during intermediate analysis. Orchestrate one persisted Sync Memory workflow. start opens options; select with improve/share starts the same workflow (both default true; both false is invalid). Core chooses all improvement candidates. prepare returns the next bounded Curator job; use curation_reasoning_prepare/propose then inspect this same workflow and continue. Questions reuse Curator; after an answer or deferral inspect Sync to continue. Legacy candidateIds/prepare/propose remains supported for saved workflows. Clean Local plans apply only within this selected workflow. Continue candidates sequentially. awaiting_review requires explicit human approval of the exact reviewId: NEVER infer approval or click approval for the human. Mixed plans stay atomic. Promotion selection follows transformations; the UI initially checks all displayed candidates and lets the human select or deselect them before review. Preselection is not publication approval. approve is allowed only after human review; text hosts must show the full review and obtain explicit approval. retry handles failed candidates; skip/complete leave unresolved work untouched. No sampling, session lifecycle or extra memory scan by the agent.',
+        title: 'Continue Curate Memory',
+        description: 'Continue the existing Curate Memory UI in place without opening another App. Use prodero_sync to open the UI and once when next.tool requests a human handoff; pass next.arguments exactly before ending the turn. Do not reopen during intermediate analysis. Orchestrate one persisted Curate Memory workflow. start opens options; select with improve/share starts the same workflow (both default true; both false is invalid). Core chooses all improvement candidates. prepare returns the next bounded Curator job; use curation_reasoning_prepare/propose then inspect this same workflow and continue. Questions reuse Curator; after an answer or deferral inspect Sync to continue. Legacy candidateIds/prepare/propose remains supported for saved workflows. Clean Local plans apply only within this selected workflow. Continue candidates sequentially. awaiting_review requires explicit human approval of the exact reviewId: NEVER infer approval or click approval for the human. Mixed plans stay atomic. Promotion selection follows transformations; the UI initially checks all displayed candidates and lets the human select or deselect them before review. Preselection is not publication approval. approve is allowed only after human review; text hosts must show the full review and obtain explicit approval. retry handles failed candidates; skip/complete leave unresolved work untouched. No sampling, session lifecycle or extra memory scan by the agent.',
         inputSchema: { projectRoot: projectRootSchema, request: memorySyncActionSchema },
         annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
     }, async ({ projectRoot, request }) => {
         const result = await runMemorySync(await workspaceRoot(projectRoot), request);
-        return text({ ok: true, action: 'memory-sync', result, uiState: { view: 'memory-sync' } }, `Sync Memory: ${result.state}. ${result.next.action}. Workflow ${result.id}, revision ${result.revision}.`);
+        return text({ ok: true, action: 'memory-sync', result, uiState: { view: 'memory-sync' } }, `Curate Memory: ${result.state}. ${result.next.action}. Workflow ${result.id}, revision ${result.revision}.`);
     });
     server.registerTool(PRODERO_TOOLS.skillCreate, {
         title: "Create Project Skill",
@@ -585,23 +593,30 @@ export function createServer(options = {}) {
     });
     registerAppTool(server, PRODERO_TOOLS.skillPreview, {
         title: "Preview Project Skill",
-        description: "Preview a candidate as a reusable Project Skill before human approval. Optional draft revisions are previewed, never activated. Optional Skill Curator uses bounded source observations, related knowledge and active skill evidence; failures fall back to a deterministic draft. Set recurate=true only on explicit re-curation intent, including proposed updates of active skills. Edited drafts bypass the model; pass previousPreview to retain the update target and stale-version protection. Automatically opens the review MCP App with Add Skill, Edit, and Dismiss. Leave approval to the human in that App; do not ask a chat confirmation when it can render. Only hosts unable to render the App use the full text preview and explicit chat approval fallback.",
+        description: "Preview a candidate as a reusable Project Skill before human approval. Optional draft revisions are previewed, never activated. Optional Skill Curator uses bounded source observations, related knowledge and active skill evidence; failures fall back to a deterministic draft. Set recurate=true only on explicit re-curation intent, including proposed updates of active skills. Edited drafts bypass the model; pass previousPreview to retain the update target and stale-version protection. Use the effective presentation: text mode or auto without Apps returns the full preview for explicit chat approval; UI uses the attached review App with Add Skill, Edit, and Dismiss. If the App cannot render, show the full preview in chat instead. Leave approval to the human; never infer it. Use prodero_text to guarantee no App attachment.",
         inputSchema: { projectRoot: projectRootSchema, id: z.string(), draft: skillInputSchema.optional(), recurate: z.boolean().optional(), previousPreview: skillPreviewSchema.optional() },
         _meta: { ui: { resourceUri: PRODERO_RESOURCE_URI } },
-    }, async ({ projectRoot, id, draft, recurate, previousPreview }) => {
+    }, async ({ projectRoot, id, draft, recurate, previousPreview }, _extra, presentation) => {
+        if (!presentation)
+            throw new Error("Skill preview requires its presentation context.");
         const root = await findProjectRoot(await workspaceRoot(projectRoot));
         const config = await readConfig(root);
         const preview = await previewProjectSkill(root, id, { draft, recurate, previousPreview, provider: config?.knowledgeEngine?.mode === "assisted" ? mcpSamplingProvider(server) : undefined });
         const skill = await getProjectSkill(root, id);
         const appSupportAdvertised = Boolean(getUiCapability(server.server.getClientCapabilities())?.mimeTypes?.includes(RESOURCE_MIME_TYPE));
-        const guidance = config?.presentation?.mode === "text" ? "Show the complete preview in chat and obtain explicit human approval before calling prodero_skill_review with approved=true and this exact preview." : "Review this skill in the attached MCP App using Add Skill, Edit, or Dismiss. Do not ask for approval in chat when the App can render. Never approve on the human's behalf.";
-        const fallback = "Only if this host cannot render the MCP App: show the complete text preview below and obtain explicit human approval before calling prodero_skill_review with approved=true and this exact preview.";
-        // Keep the resource attached even when older hosts omit the capability advertisement.
-        return text({ ok: true, action: "skill-preview", preview, skill, result: await projectSkillsView(root), approval: { surface: config?.presentation?.mode === "text" ? "chat" : "mcp-app", appSupportAdvertised, chatFallback: "only-if-app-cannot-render" }, uiState: { view: "skills" } }, `${guidance}${appSupportAdvertised && config?.presentation?.mode !== "text" ? "" : `\n\n${config?.presentation?.mode === "text" ? "" : fallback}\n\n${skillMarkdown({ ...skill, ...preview.draft, candidateTitle: skill.title })}`}`);
+        const chat = presentation.resolved === "text" || !appSupportAdvertised;
+        const operation = preview.disposition?.action ?? "create";
+        const covered = operation === "covered";
+        const operationLabel = { create: "Create Project Skill", update: "Update existing Project Skill", covered: "Already covered; no changes to apply", "keep-separate": "Create separate Project Skill" }[operation];
+        const summary = [`Operation: ${operationLabel}`, ...(preview.target ? [`Target: ${preview.target.title} (${preview.target.id})`] : []), ...(preview.notice ? [`Notice: ${preview.notice}`] : [])].join("\n");
+        const coveredGuidance = "Inspect the existing skill or dismiss this candidate. Promotion is unavailable; do not request approval to apply this preview.";
+        const guidance = covered ? coveredGuidance : chat ? "Show the complete preview in chat and obtain explicit human approval before calling prodero_skill_review with approved=true and this exact preview." : "Review this skill in the attached MCP App using Add Skill, Edit, or Dismiss. Do not ask for approval in chat when the App can render. Never approve on the human's behalf.";
+        const fallback = "Only if this host cannot render the MCP App: show the complete text preview below. " + (covered ? coveredGuidance : "Obtain explicit human approval before calling prodero_skill_review with approved=true and this exact preview.");
+        return text({ ok: true, action: "skill-preview", preview, skill, result: await projectSkillsView(root), approval: { required: !covered, surface: chat ? "chat" : "mcp-app", appSupportAdvertised, ...(!chat ? { chatFallback: "only-if-app-cannot-render" } : {}) }, uiState: { view: "skills" } }, `${summary}\n\n${guidance}\n\n${chat ? "" : fallback + "\n\n"}${skillMarkdown({ ...skill, ...preview.draft, candidateTitle: skill.title })}`);
     });
     registerAppTool(server, PRODERO_TOOLS.skillReview, {
         title: "Review Project Skill Candidate",
-        description: "Promote only the exact preview the human approved: first call prodero_skill_preview to open the MCP App. Add Skill submits approved=true and the exact preview as a workflow safeguard, not proof of human consent. Chat approval is only a fallback when the host cannot render the App. Never automatically promote inferred candidates. Dismiss retains procedure and provenance.",
+        description: "Promote only the exact preview the human approved: first call prodero_skill_preview using the effective presentation, or prodero_text for a complete text preview. The review App or explicit chat approval submits approved=true and the exact preview as a workflow safeguard, not proof of human consent. Text mode and auto without Apps use chat; UI uses the App with chat fallback only when it cannot render. Never automatically promote inferred candidates. Dismiss retains procedure and provenance.",
         inputSchema: { projectRoot: projectRootSchema, id: z.string(), action: z.enum(["promote", "dismiss"]), reason: z.string().trim().max(1_000).optional(), approved: z.boolean().optional(), preview: skillPreviewSchema.optional() },
         _meta: { ui: { resourceUri: PRODERO_RESOURCE_URI } },
     }, async ({ projectRoot, id, action, reason, approved, preview }) => {
@@ -620,24 +635,17 @@ export function createServer(options = {}) {
         return text({ ok: true, update });
     });
     server.registerTool(PRODERO_TOOLS.update, {
-        title: "Update Prodero",
-        description: "Show the exact manual npm update instruction. Production updates are performed by the package manager, never by this tool. Local staging is an explicitly enabled development-only adapter.",
+        title: "Show Prodero Update Instructions",
+        description: "Read-only instructions for updating Prodero in a terminal with prodero update. Finish work and close hosts first, then restart/reconnect after terminal completion and review project migrations separately. This tool never installs, builds, stages, switches runtimes or refreshes project integration, including development sources. Do not execute installation through chat tools.",
         inputSchema: { projectRoot: projectRootSchema },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     }, async ({ projectRoot }) => {
-        if (releaseSource.id === "npm" || releaseSource.id === "unconfigured")
-            return text(await installLatest(releaseSource));
-        const resolved = projectRoot !== undefined || (options.projectRoot !== undefined || options.localStdio !== undefined) ? await workspaceRoot(projectRoot) : undefined;
-        const root = resolved ? await findProjectRoot(resolved) : undefined;
-        const update = await installLatest(releaseSource);
-        let projectMaintenance = null;
-        if (root && (await readConfig(root))) {
-            if (update.restartRequired)
-                await scheduleProjectIntegrationRefresh(root, { version: update.availableVersion, source: update.source });
-            else
-                projectMaintenance = await refreshProjectIntegration(root);
-        }
-        const maintenanceMessage = projectMaintenance?.changedFiles.length ? ` Refreshed ${projectMaintenance.changedFiles.join(", ")}.` : projectMaintenance ? " Project integration is current." : update.restartRequired && root ? " Project integration will refresh automatically after restart." : "";
-        return text({ ...update, projectMaintenance, message: `${update.message}${maintenanceMessage}` });
+        // Preserve the selector contract without reading project state or invoking
+        // a release adapter. Instructions cannot stage even an injected dev source.
+        if (projectRoot !== undefined)
+            await workspaceRoot(projectRoot);
+        const result = updateInstructions(releaseSource);
+        return text(result, renderText(buildViewModel(result)));
     });
     registerAppResource(server, PRODERO_RESOURCE_URI, PRODERO_RESOURCE_URI, { mimeType: RESOURCE_MIME_TYPE }, async () => {
         const htmlPath = path.resolve(import.meta.dirname, "../dist-ui/index.html");

package/dist/settings-definition.js

@@ -13,10 +13,10 @@ 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 for this project.', 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 for this project.' }, { id: 'text', label: 'Text', description: 'Use readable text for this project.' }], validation: modeSchema },
-    { key: 'presentation.theme', group: 'Presentation', label: 'Theme', description: 'Visual theme used by Prodero for this project.', type: 'enum', defaultValue: 'prodero', options: THEMES, validation: themeSchema },
+    { 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. These are canonical project settings, never knowledge entries. 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.';
+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