@prodero/curator 0.1.0 → 0.2.1

package/ARCHITECTURE.md

@@ -142,7 +142,7 @@ Set `PRODERO_DEBUG_TIMINGS=1` during local MCP development to emit fast response
 
 Filesystem/stat/checkpoint discovery, status counts, pending detection, index routing, and token estimates are deterministic local operations and make no LLM/API call. Context Selection v2 retains the 6,000 estimated-token resolver budget and treats 2,000 tokens as a Required reserve, using the model-neutral `ceil(UTF-8 bytes / 4)` strategy. Applicable Required can borrow total capacity, with independent safety ceilings of 16,000 tokens / 128 records. Relevant uses a soft target of 8, deterministic marginal-value continuation and a 128-record safety ceiling. Strongly matching Skills receive capacity before Relevant, retaining 4 / 1,500 limits. Undelivered Required produces blocking `required-incomplete`; Open/Bootstrap and the derived router retain their compact limits. See [Context Selection v2](docs/CONTEXT-SELECTION-V2.md). Counts are explicitly estimated; these are Prodero-supplied task-context limits, never the model context window.
 
-`memory-index.ts` caches per-item token, freshness, and provenance-count signals alongside lexical metadata. Context totals and selectivity sum cached summaries; only bounded selected bodies are loaded. Required globals are deterministically priority-ranked under separate item and token bounds, and omissions retain exact reason/count/token diagnostics. Ordinary Relevant omissions are nonblocking; incomplete Required delivery blocks readiness; only bounded metadata for omitted required items is disclosed. Query retrieval uses deterministic lexical scoring and greedy scope/category diversity. Non-critical active `state` records older than 180 days are retained but demoted and surfaced when selected. Detailed memory health counts stale, disputed, historical, missing-provenance, and oversized items; fast status still touches none of the corpus.
+`memory-index.ts` caches per-item token, freshness, and provenance-count signals alongside lexical metadata. Context totals and selectivity sum cached summaries; only bounded selected bodies are loaded. Required globals are deterministically priority-ranked under separate item and token bounds, and omissions retain exact reason/count/token diagnostics. Ordinary Relevant omissions are nonblocking; incomplete Required delivery blocks readiness; only bounded metadata for omitted required items is disclosed. Query retrieval uses deterministic lexical scoring and greedy scope/category diversity. Non-critical active `state` records older than 180 days are retained and flagged stale when selected. Already eligible Relevant candidates receive a bounded storage-recency hint (0–0.5); there is no separate 180-day rank penalty, and Required policy ranking is unchanged. Storage update time is not a fact-effective date. Detailed memory health counts stale, disputed, historical, incomplete-provenance, and oversized items; fast status still touches none of the corpus. The compatibility field `missingProvenanceItems` counts active records with no source-session/source-file evidence or no observation-level `derived_from`. It measures incomplete metadata, not proven loss of history or the validity of every source reference. Legacy/imported records remain readable; no provenance is invented or backfilled by diagnostics.
 
 Sync telemetry is derived from the same pending candidates already in consolidation. `rawSessionTokens` counts durable observation content in the current batch. `canonicalTokensAdded` counts newly created canonical title + content and newly appended consolidation text, excluding duplicates and unrelated existing knowledge. Compression is `1 - canonical/raw` only when canonical is smaller; larger output is an explicit expansion and zero raw input is unavailable. The result also aliases lifecycle-friendly counts (`sessionsProcessed`, `observationsProcessed`, `knowledgeCreated`, `knowledgeConsolidated`, `knowledgeSuperseded`) while preserving the existing bounded result fields.
 

package/CHANGELOG.md

@@ -1,6 +1,29 @@
 # Changelog
 
-## 0.1.0 — Public Preview (unreleased)
+## 0.2.1 — 2026-10-25 (Public Preview)
+
+- Corrected public documentation and release wording, including installation and compatibility guidance.
+- Documented the built-in updater's npm **10.9.x** requirement.
+- Replaced the outdated overview screenshot with the current **Curate Memory** interface using demonstration project data.
+
+This is a documentation-only patch. Application behavior and project/knowledge schemas are unchanged. Users already running 0.2.0 do not need an urgent upgrade.
+
+## 0.2.0 — 2026-10-25 (Public Preview)
+
+- **Curate Memory** replaces the Memory Sync user-facing name, with existing MCP tool IDs and saved workflows retained. Retry/expired analysis, saved answers, deferred questions and Revisit resume reliably; partial progress and remaining work stay visible.
+- Text mode uses the shared Telemetry/Pulse layout with letter-bound knowledge entries, exact numeric actions, complete review bodies and mobile-width output. Prepare continues automatically; Prepare/Close retain a compact fallback when an App is invisible, without repeating Core calls.
+- **CLI compatibility:** `prodero status` now returns readable text by default. Scripts must pass `--json`; scope, failure exit codes and safe diagnostics remain explicit.
+- Theme and mode changes write ignored checkout-local preferences rather than shared project config. Shared context settings stay versioned. Older v0.1 runtimes ignore local preferences and can still write legacy shared presentation settings; no automatic shared-config cleanup is performed.
+- Terminal-only `prodero update [VERSION]` verifies an ordinary npm installation and exact target, asks users to close hosts and confirm, waits for npm and verifies the installed CLI. Non-TTY installation requires an exact version plus `--yes`. No automatic host shutdown or atomic rollback. MCP/App update actions provide terminal instructions only; package update and approved project migration remain separate.
+- Valid legacy links are preserved across current/archive storage and repair previews; the disposable graph cache is rebuilt at format 2. Missing-target removal retains exact approval, stale-preview and recovery guards. Existing canonical legacy IDs are accepted by Remember/relationships/Local Forget and promotion selectors without changing supersession history or path safety. Versioned retirement still requires reviewed repository maintenance with the current revision.
+- Procedural intent gates skill selection so a project name alone does not pull an installer into unrelated context. Skill Preview/Review honor effective local/shared/invocation presentation, retain complete drafts and identify create/update/covered and the exact target before consent. Explicit skill creation and inferred candidates keep their existing distinct workflows.
+- The generated runtime guide is shorter and restores bundle-only read-only handling, last-resort file fallback, readiness/migration/resume and lifecycle rules. It separates Curator tools' Git behavior from the coding agent's current user authorization and host approval controls.
+- Incomplete provenance diagnostics no longer imply proven loss of history; no provenance backfill or canonical storage redesign is included.
+- Session writers serialize lock acquisition, stale-owner recovery and release under the same transition guard, preventing a stale PID decision from deleting a successor's lock. Deterministic process barriers and acknowledgment-preservation stress regressions cover record/close concurrency; unknown owners and interrupted guards remain fail-closed.
+
+Project schema remains **8** and knowledge schema remains **3**. This release adds no canonical schema migration. See [compatibility and verification](docs/COMPATIBILITY.md) for tested clients, platforms and the published package identity.
+
+## 0.1.0 — 2026-10-15 (Public Preview)
 
 - Host-scoped package/dev runtime switching with read-only previews, explicit manual-dev migration, format 1 receipt compatibility and transactional rollback.
 
@@ -13,4 +36,4 @@
 - npm artifact installation, manual package-manager updates, explicit MCP roots and a clean artifact release gate.
 - Interactive `prodero install` wizard with agent status, install/update selection, confirmation and readable results. Replaces install host arguments and `--all`; recognizes manual Codex `prodero-dev` connections without adding a duplicate server.
 
-Preview limitations and actual verification coverage are recorded in docs/COMPATIBILITY.md. This entry does not announce publication.
+Historical release notes. Preview limitations and actual verification coverage are recorded in docs/COMPATIBILITY.md.

package/README.md

@@ -1,59 +1,54 @@
 # Prodero Curator
 
-**Project memory for AI coding agents, through chat.**
+**Project memory for Codex and Claude Code.**
 
-Curator keeps useful decisions, conventions and lessons available across coding sessions. Ask your agent to remember something, retrieve relevant context or review what should be shared with your team.
+Keep project decisions, conventions, and lessons across sessions, right inside your coding assistant.
 
-**v0.1.0 Public Preview.** Curator runs locally and connects to your coding agent through MCP. The terminal is for installation and maintenance; everyday work happens in conversation.
+**Install in two commands → open Codex or Claude Code → type prodero.**
 
-## Why Curator exists
-
-A new coding session often means explaining the same architecture, constraints and past mistakes again. Chat history alone is hard to reuse across tasks and teammates. Curator stores durable project knowledge and selects relevant context for the agent’s next task.
+```sh
+npm install --global @prodero/curator@0.2.1
+prodero install
+```
 
-## How it works
+Requires **Node.js >=22.14.0 <23**, npm and Git. **v0.2.1 Public Preview.** Codex CLI is tested; Claude Code remains experimental. See the [compatibility matrix](docs/COMPATIBILITY.md).
 
-Tell your agent:
+1. In the installation wizard, select **Codex** or **Claude Code**, confirm the setup and choose **Finish**.
+2. Reopen Codex or Claude Code in your repository and type **`prodero`** in chat.
+3. For a new project, choose **Initialize Prodero** and review the generated project files and Git-ignore rules.
 
-> Remember that API tests should use our shared fixtures. Apply this to the `tests/` path.
+For Claude Code, also create or update the project’s `CLAUDE.md` to import `@AGENTS.md`. The installer does not create that file. See the [setup guide](docs/hosts.md).
 
-The agent saves Local Knowledge through Curator’s MCP tools. In a later session, ask it to work on API tests: Curator can include that convention when the agent prepares context for the task. You can inspect or edit the saved item at any time.
+![Curator App overview with Curate Memory](docs/images/prodero-overview-cropped.png)
 
-Curator relies on the agent following its runtime instructions to prepare tasks, record useful outcomes and close sessions. It does not watch every conversation or guarantee that every detail will be remembered.
+*Current Curator App with demonstration project data.*
 
-## Install
+## Relevant context, automatically
 
-Requires **Node.js 22.14+ in the 22.x line**, npm and Git. See [compatibility](docs/COMPATIBILITY.md) for verified platforms.
+Just describe your task in Codex or Claude Code. Curator automatically brings in relevant project knowledge and skills as part of the task workflow. No separate search or manual context selection needed.
 
-```sh
-npm install --global @prodero/curator@0.1.0
-prodero install
-```
+![Context Ready: relevant project knowledge prepared for a task](docs/images/prodero-context-ready-cropped.png)
 
-The interactive wizard lets you choose a coding agent and review its MCP setup. Installation configures the agent; it does not initialize your projects.
+## Carry lessons into the next session
 
-## Open your coding agent
+As Codex or Claude Code closes a session through Curator’s workflow, recorded outcomes automatically become Local Knowledge. Curator can bring those lessons into later tasks when they are relevant. You can inspect and edit saved knowledge at any time.
 
-Restart the agent, open your repository and type:
+![Session Learned: useful outcomes saved for future sessions](docs/images/prodero-session-learned-cropped.png)
 
-```text
-prodero
-```
-
-The agent opens Curator through MCP. In a new project, choose **Initialize Prodero**. Review the generated project files, including the managed `AGENTS.md` instructions and Git-ignore rules.
-
-Where the host supports MCP Apps, Curator provides a graphical interface. Otherwise, use text mode: **“Show Prodero as text.”** You do not need to memorize CLI commands.
+Curator relies on Codex or Claude Code following its runtime instructions to prepare tasks, record useful outcomes and close sessions. It does not watch every conversation or guarantee that every detail will be remembered.
 
 ## Everyday use
 
-Ask your connected agent in ordinary language:
+Everyday work happens in conversation with Codex or Claude Code; the terminal is for installation and maintenance.
 
 - “What do we know about our API test setup?”
-- “Remember why we chose this approach.”
+- “Remember that API tests should use our shared fixtures. Apply this to the `tests/` path.”
 - “Update the saved testing convention to use the new fixture directory.”
-- “Show the knowledge relevant to this bug before we start.”
 - “Review which Local lessons would be useful to share with the team.”
 
-Use **Knowledge** to search, inspect and edit saved items. **Sync Memory** lets you choose **Improve memory**, **Share knowledge**, or both, then start the workflow. Eligible Local improvements can apply within that workflow; sharing presents proposed Versioned changes for review. Normal session learning does not require running Sync Memory.
+Use **Knowledge** to search, inspect and edit saved items. **Curate Memory** lets you choose **Improve memory**, **Share knowledge**, or both, then start the workflow. Eligible Local improvements can apply within that workflow; sharing presents proposed Versioned changes for review. Normal session learning does not require running Curate Memory.
+
+Where the host supports MCP Apps, Curator provides a graphical interface. Otherwise, use text mode: **“Show Prodero as text.”** You do not need to memorize CLI commands.
 
 ## Main capabilities
 
@@ -71,9 +66,9 @@ Local does **not** mean inaccessible to the connected agent. The agent may creat
 
 The generated `.prodero/index.md` can include active **Local skill titles and paths**. It is not automatically ignored in every project. Keep it ignored when those details are private, and review generated files before committing. See [storage and privacy](docs/PRIVACY.md).
 
-## Supported agents and limitations
+## Compatibility and limitations
 
-**Codex CLI is verified; Claude Code is experimental.** Claude Code also needs a project `CLAUDE.md` importing `@AGENTS.md`; the installer does not create it. Cursor is detection-only, and there is no Claude Desktop installer.
+Codex CLI and Claude Code were tested with text workflows. The maintainer also reported successful manual checks in Codex Desktop, Claude CLI and Codex Mobile. Claude Code remains experimental; Cursor is detection-only, and there is no Claude Desktop installer. Tested versions and the scope of these checks are listed in the [compatibility matrix](docs/COMPATIBILITY.md).
 
 MCP Apps, workspace roots and sampling support vary by host. Text mode supports core workflows, but App-only curation review/apply is unavailable through the text gateway. See the [host/runtime matrix](docs/COMPATIBILITY.md) and [setup guide](docs/hosts.md).
 
@@ -93,3 +88,7 @@ Retrieved context reaches your connected agent. Optional assisted operations can
 Preview interfaces and schemas may evolve. Back up the whole `.prodero` directory before upgrading; follow the linked maintenance and recovery guidance.
 
 Curator is [MIT licensed](LICENSE).
+
+### Updating the installed core
+
+Codex/Claude show an available-version indicator and terminal instructions only. Run `prodero update` in your terminal, finish active work and close the hosts when prompted, then explicitly confirm. Restart the hosts after completion. The built-in updater supports a same-user global npm installation with **npm 10.9.x**; use your package manager for other installation layouts or toolchains. Project knowledge migration is offered separately on Open/Prepare; package update preserves saved dev selection and preferences. See [update and non-interactive options](docs/hosts.md#updates-and-advanced-project-commands).

package/dist/cli.js

@@ -13,9 +13,11 @@ import { getMemoryIntelligencePlan } from "./core/memory-intelligence.js";
 import { publicDiagnostic } from "./core/diagnostics.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createServer } from "./server.js";
-import { autoMigrateProject, getProjectStatus, initializeProject, prepareProject, recallProject, PRODERO_VERSION, resolveProjectContext, syncProject, } from "./core/project.js";
+import { getProjectStatus, initializeProject, prepareProject, recallProject, PRODERO_VERSION, resolveProjectContext, syncProject, } from "./core/project.js";
 import { cliProjectRoot, explicitProjectRoot } from "./core/project-root.js";
-import { checkForUpdate, installLatest } from "./core/update.js";
+import { renderMachineStatus, renderProjectStatus, renderStatusFailure, statusFailure } from "./status-presentation.js";
+import { updateCommand } from "./update-command.js";
+import { checkForUpdate } from "./core/update.js";
 const help = `Prodero ${PRODERO_VERSION}
 
 Usage: prodero <command> [--root /absolute/project]
@@ -25,17 +27,17 @@ Usage: prodero <command> [--root /absolute/project]
   install                 Open the interactive agent installation wizard
   runtime <mode> --host HOST Switch one agent between package and dev (runtime --help)
   uninstall [host] [--all] Remove managed host integration; preserve projects
-  status                  Show version and machine host integrations
-  status --root PATH      Show existing project status
+  status [--json]         Show readable machine integrations; --json for scripts
+  status --root PATH [--json] Show existing project status without maintenance
   memory-bundle <id>       Inspect one read-only transformation bundle (JSON)
   memory-plan             Inspect deterministic memory candidates (read-only JSON)
-  sync                    Start/resume Sync Memory (JSON; continue through MCP)
+  sync                    Start/resume Curate Memory (JSON; continue through MCP)
   sync-sessions           Low-level deterministic closed-session recovery
   recall <query>          Recall project knowledge without a session
   context [query]         Inspect retrieved context
   prepare [task]          Prepare context and start a session
   check-update            Show installed/latest npm version and update instruction
-  update                  Show manual npm update instructions (does not install)
+  update [version] [--yes] Update this npm installation from the terminal
   help, --help            Show this help
   --version               Show the installed version
 
@@ -44,7 +46,7 @@ Without --root, project commands require a Git or initialized Prodero ancestor.
 MCP uses negotiated host roots or supported local host launch context. --root is an optional hard boundary.`;
 function parse(argv) {
     let command, root, query;
-    let helpRequested = false, all = false, dev = false, checkout, host;
+    let helpRequested = false, all = false, dev = false, json = false, checkout, host;
     const commands = new Set(["install", "uninstall", "mcp", "--stdio", "init", "migrate", "status", "memory-plan", "memory-bundle", "sync", "sync-sessions", "context", "recall", "prepare", "check-update", "update", "help", "--version"]);
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
@@ -52,6 +54,12 @@ function parse(argv) {
             helpRequested = true;
             continue;
         }
+        if (arg === "--json") {
+            if (json)
+                throw new Error("Specify --json only once.");
+            json = true;
+            continue;
+        }
         if (arg === "--dev") {
             if (dev)
                 throw new Error("Specify --dev only once.");
@@ -95,6 +103,8 @@ function parse(argv) {
             throw new Error("Unexpected argument. Run prodero --help.");
     }
     command ??= "help";
+    if (json && (command !== "status" || helpRequested))
+        throw new Error("Use --json only with status, without --help.");
     if (all && command === "install")
         throw new Error("Run prodero install without --all; choose an agent in the interactive wizard.");
     if (all && (command !== "uninstall" || host))
@@ -105,14 +115,18 @@ function parse(argv) {
         throw new Error("--dev and --checkout are only supported for MCP.");
     if (checkout !== undefined && !dev)
         throw new Error("--checkout requires --dev.");
-    return { dev, checkout, command: helpRequested ? "help" : command, root, query, host: all ? "all" : host };
+    return { dev, checkout, json, command: helpRequested ? "help" : command, root, query, host: all ? "all" : host };
 }
 async function run(localStdio) {
+    if (process.argv[2] === 'update') {
+        process.exitCode = await updateCommand(process.argv.slice(3));
+        return;
+    }
     if (process.argv[2] === 'runtime') {
         await runtimeCommand(process.argv.slice(3));
         return;
     }
-    const { command, root, query, host, dev, checkout } = parse(process.argv.slice(2));
+    const { command, root, query, host, dev, checkout, json } = parse(process.argv.slice(2));
     if (command === "help") {
         console.log(help);
         return;
@@ -127,7 +141,7 @@ async function run(localStdio) {
     }
     if (command === "uninstall" || (command === "status" && root === undefined)) {
         const result = await machineIntegrations(command === "status" ? "status" : command, host);
-        console.log(JSON.stringify(result, null, 2));
+        console.log(command === "status" && !json ? renderMachineStatus(result) : JSON.stringify(result, null, 2));
         if (!result.ok)
             process.exitCode = 1;
         return;
@@ -162,7 +176,7 @@ async function run(localStdio) {
         console.log(JSON.stringify(await initializeProject(rootArg), null, 2));
         return;
     }
-    if (["status", "prepare"].includes(command)) {
+    if (command === "prepare") {
         const plan = await planProjectMigration(rootArg);
         if (plan.state !== "current") {
             (plan.blocked ? console.error : console.log)(renderText(buildViewModel({ action: "migration", root: rootArg, plan, resume: { tool: "prodero_prepare", arguments: { projectRoot: rootArg, task: query } } }), true));
@@ -171,10 +185,15 @@ async function run(localStdio) {
         }
     }
     if (command === "status") {
-        const project = await getProjectStatus(rootArg);
-        if (project.initialized)
-            await autoMigrateProject(project.root);
-        console.log(JSON.stringify({ version: PRODERO_VERSION, project: await getProjectStatus(project.root), update: await checkForUpdate() }, null, 2));
+        const plan = await planProjectMigration(rootArg);
+        if (plan.state !== "current") {
+            const result = statusFailure(plan.diagnostic ?? `PRODERO_MIGRATION_REQUIRED: Project update is ${plan.state}.`, "project", plan);
+            (json ? console.log : console.error)(json ? JSON.stringify(result, null, 2) : renderStatusFailure(result));
+            process.exitCode = 1;
+            return;
+        }
+        const result = { version: PRODERO_VERSION, scope: "project", project: await getProjectStatus(rootArg, { persistCache: false }), update: await checkForUpdate() };
+        console.log(json ? JSON.stringify(result, null, 2) : renderProjectStatus(result));
         return;
     }
     if (command === "memory-bundle") {
@@ -207,18 +226,37 @@ async function run(localStdio) {
         console.log(JSON.stringify(await prepareProject(rootArg, { task: query, agent: "cli" }), null, 2));
         return;
     }
-    if (command === "update") {
-        console.log(JSON.stringify(await installLatest(), null, 2));
-        return;
-    }
     if (command === "check-update") {
         console.log(JSON.stringify(await checkForUpdate(), null, 2));
         return;
     }
 }
+/** Identify the requested command even when option validation fails. Option values
+ * and later positional arguments never turn another command into status. */
+function requestedJsonStatus(argv) {
+    if (!argv.includes('--json'))
+        return false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--root' || arg === '--checkout') {
+            i++;
+            continue;
+        }
+        if (arg === '--stdio' || arg === '--version')
+            return false;
+        if (arg.startsWith('-'))
+            continue;
+        return arg === 'status';
+    }
+    return false;
+}
 export async function main(localStdio) {
     await run(localStdio).catch((error) => {
-        console.error(`[prodero] ${publicDiagnostic(error)}`);
+        const argv = process.argv.slice(2);
+        if (requestedJsonStatus(argv))
+            console.log(JSON.stringify(statusFailure(error, argv.some(arg => arg === '--root' || arg.startsWith('--root=')) ? 'project' : 'machine'), null, 2));
+        else
+            console.error(`[prodero] ${publicDiagnostic(error)}`);
         process.exitCode = 1;
     });
 }

package/dist/contracts.js

@@ -15,6 +15,7 @@ export const PRODERO_TOOLS = {
     migrate: "prodero_migrate",
     curation: "prodero_curation",
     curationReview: "prodero_curation_review",
+    curationQuestion: "prodero_curation_question",
     curationReasoningPrepare: "prodero_curation_reasoning_prepare",
     curationReasoningPropose: "prodero_curation_reasoning_propose",
     curationApply: "prodero_curation_apply",

package/dist/conversation-presentation.js

@@ -1,4 +1,5 @@
-export const PRESENTATION_REPLY = 'For knowledge-list requests in Claude Code, prefer prodero_text with tool=prodero_knowledge unless the user explicitly requests a graphical view. This is a one-off display choice, not a project setting change. When showing knowledge lists in chat, prefer the supplied fenced ASCII table with +, - and | borders; preserve its columns and page-local numeric row keys when translating. Knowledge rows use 1 through N, and action commands below the table continue at N+1. Resolve a standalone number through the exact numberedActions binding from the latest displayed table/menu. knowledgeRows also binds row numbers to exact record IDs; never infer IDs or reuse an older page. Show complete record text when an individual record is requested. In knowledge-detail replies, keep the original, any translation and record metadata together, then preserve a separate ------------- line before service hints about editing, history, approval and available actions. Service hints are not part of the knowledge or its translation. When suggesting next actions in chat, show a numbered Markdown list starting at 1 (or N+1 after a knowledge table with N rows), with one command per line and a blank line before the list. Tell the user they can reply with a number or the command name. Preserve the displayed order and exact numberedActions bindings when translating. A standalone positive integer selects only that item from the latest action menu actually shown in this conversation for this project; never use array positions in availableActions, an older menu or another conversation. If the number is out of range, the menu is missing, or a pending question expects a numeric value rather than a menu choice, clarify instead of guessing. Keep menu bindings only in conversation context, never project settings or knowledge. Route selected covered tools through prodero_text with the exact bound arguments; call other bound tools directly. A numeric selection is navigation or an action request, never explicit approval: for an approval-marked action show the exact proposal and request explicit confirmation before mutation or publication. In ordinary Open and lifecycle replies, omit display mode, theme and tool-routing commentary. Saved presentation settings, resolved mode and App metadata are not evidence that the user saw a graphical interface; do not claim a UI was displayed from those fields. Discuss mode or theme only when the user asks about settings or presentation troubleshooting.';
+export const LIFECYCLE_PRESENTATION_REPLY = 'For lifecycle text delivery, including when presentation.resolved is text in auto mode, relay the supplied compact presentation.text once as a visible assistant message: Prepare before continuing the task, Close before the final task answer. Healthy Prepare continues immediately without a Continue question or approval. A tool result or App metadata does not prove visible delivery. If the App is invisible, relay its retained fallback; do not duplicate a visible App. Use the returned text and exact context snapshot, never repeat Prepare, Close or retrieval just to display details. Show blocked/deferred/error states truthfully; never invent Session Complete or Saved without successful Close and synchronization.';
+export const PRESENTATION_REPLY = 'For knowledge-list requests in Claude Code, prefer prodero_text unless the user requests a graphical view. Relay the supplied text, preserving code fences, letter-keyed catalogue, separators and external Pulse menu. Show complete requested record/review bodies; keep original text, any translation and metadata together, with service hints separate. Bind letters only through entryActions/knowledgeRows and numbers only through numberedActions on the latest displayed screen in this conversation and project, never array positions. Each screen replaces old aliases. Preserve bindings/order when translating. Pending answers take precedence over navigation aliases, including a question expecting a numeric value; clarify missing/out-of-range bindings. Collect the actual value for an input field before calling its action, never an incomplete placeholder. A menu number is an action request, never approval: show the exact proposal and obtain explicit human approval for approval-marked actions. Keep aliases ephemeral; never store them as settings or knowledge. Tell the user they may reply with a number or command name. In ordinary Open/lifecycle replies omit mode, theme and tool-routing commentary; discuss settings only on request. Display settings or App metadata do not prove that a UI was visible.';
 const n = (value, one, many = `${one}s`) => `${value} ${value === 1 ? one : many}`;
 const tokens = (value) => value >= 1000 ? `${Number((value / 1000).toFixed(1))}k` : String(value);
 export function conversationView(payload, vm) {
@@ -36,14 +37,14 @@ export function conversationView(payload, vm) {
                 v.attention.push(`Memory areas to review: ${areas.length + (p.memoryOverview?.areasOmitted ?? 0)}.`);
                 if (areas.some((a) => a.signals?.includes('context_pressure')))
                     v.attention.push('Relevant knowledge has not fit into recent task context.');
-                next('Review memory improvements?', call('Review Memory Sync', 'prodero_sync'));
+                next('Review memory improvements?', call('Review Curate Memory', 'prodero_sync'));
             }
             if (p.memoryOverview?.available === false)
                 v.attention.push('Memory overview unavailable.');
             if (p.memoryOverview?.workflow && p.memoryOverview.workflow.state !== 'completed') {
                 const w = p.memoryOverview.workflow;
-                v.attention.push(w.state === 'stale' ? 'Memory changed since the last Sync.' : 'Memory Sync is unfinished.');
-                next(w.state === 'stale' ? 'Re-analyze memory?' : 'Continue Memory Sync?', w.state === 'stale' ? call('Re-analyze memory', 'prodero_memory_sync', { request: { action: 'start', restart: true } }) : call('Continue Memory Sync', 'prodero_sync', { workflowId: w.id }));
+                v.attention.push(w.state === 'stale' ? 'Memory changed since the last curation.' : 'Curate Memory is unfinished.');
+                next(w.state === 'stale' ? 'Re-analyze memory?' : 'Continue curation?', w.state === 'stale' ? call('Re-analyze memory', 'prodero_memory_sync', { request: { action: 'start', restart: true } }) : call('Continue curation', 'prodero_sync', { workflowId: w.id }));
             }
             const c = payload.curation;
             if (c?.state === 'unavailable')
@@ -70,8 +71,8 @@ export function conversationView(payload, vm) {
                 const w = p.memoryOverview?.workflow;
                 const sync = w?.state === 'stale'
                     ? call('Re-analyze memory', 'prodero_memory_sync', { request: { action: 'start', restart: true } })
-                    : call(w && w.state !== 'completed' ? 'Continue memory sync' : 'Sync memory', 'prodero_sync', w && w.state !== 'completed' ? { workflowId: w.id } : {});
-                v.suggestions = [sync, call('Show knowledge', 'prodero_knowledge'), call('Show settings', 'prodero_config_get')];
+                    : call(w && w.state !== 'completed' ? 'Continue curation' : 'Curate Memory', 'prodero_sync', w && w.state !== 'completed' ? { workflowId: w.id } : {});
+                v.suggestions = [sync, call('Explore knowledge', 'prodero_knowledge'), ...(c?.prominent ? [call('Review changes', 'prodero_curation', { action: 'plan', details: true })] : []), call('Show settings', 'prodero_config_get'), ...(payload.update?.available ? [call('Show update instructions', 'prodero_update')] : [])];
             }
         }
         v.details = call('Show project details', 'prodero_status_details', { details: true });
@@ -85,7 +86,7 @@ export function conversationView(payload, vm) {
         v.blocking = Boolean(readiness?.blocking || omitted);
         v.contextComplete = !omitted && !v.blocking;
         v.state = v.blocking ? (omitted ? 'Required context incomplete' : 'Work paused') : 'Ready';
-        v.facts.push(`Context  ${tokens(m.contextTokens)} / ${tokens(m.contextBudgetTokens)}`, `Required  ${c.required.length} · Relevant  ${c.relevant.length} · Skills  ${c.skills.length}`);
+        v.facts.push(`Context  ${tokens(m.contextTokens)} / ${tokens(m.contextBudgetTokens)}`, `${c.required.length} required · ${c.relevant.length} relevant · ${n(c.skills.length, 'skill')}`);
         if (r.session)
             v.facts.push('Session  active');
         if (omitted)
@@ -94,7 +95,7 @@ export function conversationView(payload, vm) {
             v.attention.push('More task scope is needed before work can start.');
         if (readiness?.state === 'required-conflict' || (v.blocking && !omitted && readiness?.state !== 'context-needed'))
             v.attention.push('Required context needs review before work can continue.');
-        v.attention.push(...(r.warnings ?? []), ...(r.attention ?? c.attention ?? []).map((a) => `${a.title}: ${a.detail}`));
+        v.attention.push(...(r.warnings ?? c.warnings ?? []), ...(r.attention ?? c.attention ?? []).map((a) => `${a.title}: ${a.detail}`));
         if (readiness?.state === 'context-needed')
             next('Specify the work paths or task scope, then prepare again.');
         else if (omitted)
@@ -120,22 +121,25 @@ export function conversationView(payload, vm) {
         v.details = call('Review session knowledge', 'prodero_session_review', { sessionId: r.session.id });
     }
     else if (payload.action === 'memory-sync') {
-        v.title = 'Prodero · Sync';
-        const s = r.summary ?? {}, inspect = call('Review this Sync', 'prodero_memory_sync', { request: { action: 'inspect', workflowId: r.id }, details: true });
+        v.title = 'Prodero · Curate Memory';
+        const s = r.summary ?? {}, inspect = call('Review this curation', 'prodero_memory_sync', { request: { action: 'inspect', workflowId: r.id }, details: true });
         v.details = inspect;
-        const state = { awaiting_selection: 'Ready to sync', semantic_work: 'Improving memory', awaiting_clarification: 'Your input is needed', awaiting_review: 'Review required', applying: 'Saving changes', awaiting_promotion_selection: 'Ready for sharing review', completed: 'Complete', stale: 'Memory changed' };
-        v.state = state[r.state] ?? 'Check saved progress';
+        const operation = vm.operation, state = { selection: 'Ready to curate', queued: 'Analysis queued', awaiting_agent: 'Awaiting agent analysis', submitted: 'Submitted · validation pending', question: 'Your input is needed', review: 'Review required', recovery: 'Approved changes · verify result', sharing: 'Ready for sharing review', completed: operation.outcome === 'remaining' ? 'Completed with remaining work' : 'Complete', stale: 'Memory changed' };
+        v.state = state[operation.phase] ?? 'Check saved progress';
         if (r.state === 'awaiting_selection') {
             v.facts.push('Improve memory · Prepare sharing review');
             if (r.brokenLinks)
                 v.facts.push(`Fix ${n(r.brokenLinks, 'broken link')} · enabled`);
-            next('Start Sync? Sharing will require a separate approval.', vm.actions.find(a => a.label === 'Start Sync'));
+            next('Start curation? Sharing will require a separate approval.', vm.actions.find(a => a.label === 'Start curation'));
         }
         else if (r.state === 'semantic_work') {
             if (r.curation || r.semantic)
                 next('Continue analysis using the prepared evidence.');
             else
-                next('Continue analysis.', vm.actions.find(a => a.label === 'Continue improving memory'));
+                next(operation.phase === 'awaiting_agent' ? 'Prepared evidence is waiting for the host agent.' : operation.phase === 'submitted' ? 'The submitted result is awaiting validation.' : 'Continue analysis.', vm.actions.find(a => 'id' in a && a.id === 'reasoning') ?? vm.actions.find(a => a.label === 'Continue improving memory'));
+        }
+        else if (r.state === 'applying') {
+            next('Check saved progress before retrying; do not repeat approval.', vm.actions.find(a => 'id' in a && a.id === 'inspect'));
         }
         else if (r.state === 'awaiting_review') {
             v.reviewRequired = true;
@@ -145,12 +149,19 @@ export function conversationView(payload, vm) {
         else if (r.state === 'awaiting_promotion_selection') {
             v.facts.push(`${n(r.promotionCandidates.length, 'memory', 'memories')} available for sharing review`);
             // Display the existing candidate set; selecting it still requires the user's request.
-            next(`Review all ${r.promotionCandidates.length} for sharing?`, call('Review these memories', 'prodero_memory_sync', { request: { action: 'promotions', workflowId: r.id, revision: r.revision, ids: r.promotionCandidates.map((c) => c.id) }, details: true }));
+            next(`Review all ${r.promotionCandidates.length} for sharing?`, vm.actions.find(a => ('id' in a && a.id === 'promotions')));
         }
         else if (r.state === 'awaiting_clarification') {
             v.reviewRequired = true;
-            v.attention.push('This question currently requires the graphical review form. Chat answers are not saved.');
+            v.attention.push('Choose an answer or give your explanation. Chat answers are saved as relayed evidence, not approval.');
+            for (const q of r.clarification?.graphical?.questions ?? [])
+                if (q.needsInput) {
+                    v.facts.push(q.question.prompt);
+                    if (q.relatedQuestions?.length > 1)
+                        v.attention.push(`Deferred together: ${q.relatedQuestions.map((q) => q.title).join('; ')}.`);
+                }
             next('Show the question and review details?', inspect);
+            v.suggestions = vm.actions.filter(a => a.tool === 'prodero_curation_question' || a.tool === 'prodero_curation_reasoning_prepare');
         }
         else if (r.state === 'stale') {
             v.attention.push('Re-analyze before continuing; earlier review is out of date.');
@@ -166,18 +177,31 @@ export function conversationView(payload, vm) {
             if (s.brokenLinksRemaining)
                 v.attention.push(`${n(s.brokenLinksRemaining, 'broken link')} remain unchanged.`);
             if (s.promoted)
-                v.facts.push(`${n(s.promoted, 'memory', 'memories')} shared`);
+                v.facts.push(`${n(s.promoted, 'memory', 'memories')} prepared in Versioned files; review the Git diff`);
             if (s.unresolved)
-                v.attention.push(`${n(s.unresolved, 'memory', 'memories')} still need clarification.`);
+                v.attention.push(`${n(s.unresolved, 'unresolved item')} still need clarification.`);
             if (s.areasFailed)
                 v.attention.push(`${n(s.areasFailed, 'area')} could not be analyzed.`);
             if (s.promotionConflicts)
                 v.attention.push(`Sharing items needing review: ${s.promotionConflicts}.`);
-            if (s.questionsDeferred)
-                v.attention.push(`${n(s.questionsDeferred, 'question')} deferred.`);
+            if (operation.counts.questionsDeferred)
+                v.attention.push(`${n(operation.counts.questionsDeferred, 'question')} deferred.`);
+            else if (operation.counts.questionsDeferred === null && operation.counts.deferredAreas)
+                v.attention.push(`${n(operation.counts.deferredAreas, 'area')} deferred; question count unavailable.`);
             if (v.attention.length)
                 next('Review the remaining items?', inspect);
         }
+        const revisit = vm.actions.filter(a => a.arguments.action === 'question_reopen' || a.arguments.request?.action === 'refresh_questions');
+        if (revisit.length)
+            v.suggestions = [...revisit, ...(v.continuation ? [v.continuation] : [])];
+        const retries = vm.actions.filter(a => 'id' in a && String(a.id).startsWith('retry:'));
+        if (retries.length)
+            v.suggestions = [...(v.suggestions ?? []), ...retries, ...(!v.suggestions?.length && v.continuation ? [v.continuation] : [])];
+        for (const q of r.deferredQuestions ?? [])
+            if (q.affectedQuestions.length > 1)
+                v.attention.push(`Revisited together: ${q.affectedQuestions.map((q) => q.title).join('; ')}.`);
+        if (operation.diagnostic)
+            v.attention.push(`${operation.diagnostic.code}: ${operation.diagnostic.cause} ${operation.diagnostic.recovery}`);
         if (r.error)
             v.attention.push('This step could not finish. Check saved progress before retrying.');
     }
@@ -197,14 +221,21 @@ export function conversationView(payload, vm) {
         v.details = call('Show update details', 'prodero_migrate', { action: 'status', details: true });
     }
     else if (payload.action === 'promotion-applied') {
-        v.title = 'Prodero · Published';
+        v.title = 'Prodero · Versioned files prepared';
         v.state = 'Complete';
-        v.facts.push(`${n(r.published, 'memory', 'memories')} shared`);
+        v.facts.push(`${n(r.published, 'memory', 'memories')} prepared in Versioned files; not committed or pushed`);
         if (r.conflicts?.length) {
             v.attention.push(`Conflicts remaining local: ${r.conflicts.length}.`);
             next('Inspect the remaining knowledge?', call('Inspect knowledge', 'prodero_knowledge'));
         }
     }
+    else if (payload.action === 'skill-preview') {
+        v.kind = 'details';
+        v.reviewRequired = payload.preview?.disposition?.action !== 'covered';
+        v.state = v.reviewRequired ? 'Awaiting human review' : 'Already covered';
+        // The full companion contains the exact draft/target. Do not synthesize consent
+        // or an executable approval action merely because the preview was displayed.
+    }
     else {
         // Explicit inspection/review surfaces retain full content and diagnostics.
         v.kind = 'details';
@@ -223,8 +254,7 @@ export function conversationMenu(v) {
 export function numberedActions(vm, expanded = false) {
     const actions = expanded || !vm.conversation || vm.conversation.kind === 'details'
         ? vm.actions : conversationMenu(vm.conversation);
-    const rows = vm.knowledgeTable?.rows.map(row => ({ label: `Open ${row.title}`, tool: 'prodero_knowledge', arguments: { ...vm.actions.find(a => a.tool === 'prodero_knowledge')?.arguments, id: row.id } })) ?? [];
-    return [...rows, ...actions].map((action, index) => ({ ...action, number: index + 1 }));
+    return actions.map((action, index) => ({ ...action, number: index + 1 }));
 }
 export function renderActionMenu(actions, start = 1) {
     if (!actions.length)
@@ -238,7 +268,11 @@ export function renderConversation(v) {
 /** Model-visible MCP content, separate from the human summary; never hidden in _meta. */
 export function conversationOperation(payload, vm, details = false, diagnostics = false) {
     const r = payload.result ?? payload, v = vm.conversation;
+    const questionData = payload.action === 'curation-question' ? payload : r.clarification;
+    const owner = payload.action === 'curation-question' ? { workflowId: payload.syncWorkflowId, candidateId: payload.candidateId } : { workflowId: r.id, candidateId: r.jobs?.find((j) => j.curationReviewId === questionData?.review?.snapshot.reviewId)?.id };
+    const answerInputs = questionData?.review && !questionData.graphical.analysisPending ? questionData.graphical.questions.filter((q) => q.needsInput && q.question.allowFreeText).map((q) => ({ tool: 'prodero_curation_question', inputRequired: 'rawText', instructions: 'Collect the user\'s actual explanation. Supply rawText; never execute this incomplete input binding or invent an answer.', arguments: { projectRoot: payload.root ?? r.root, ...owner, action: 'answer', reviewId: questionData.review.snapshot.reviewId, reviewRevisionId: questionData.review.snapshot.revision.id, planHash: questionData.review.snapshot.planHash, decisionRevision: questionData.review.state.revision, answerLogHash: questionData.graphical.answerLogHash, questionId: q.question.id, questionVersion: q.question.version, requestId: `chat_${globalThis.crypto.randomUUID()}`, ...(q.answer ? { replacesAnswerId: q.answer.id } : {}) } })) : [];
     return {
+        ...(answerInputs.length ? { answerInputs } : {}),
         kind: diagnostics ? 'diagnostic' : details ? 'details' : v.kind,
         succeeded: payload.ok !== false,
         blocking: v.blocking,
@@ -249,10 +283,11 @@ export function conversationOperation(payload, vm, details = false, diagnostics
         detailSource: v.detailSource,
         suggestions: v.suggestions,
         numberedActions: numberedActions(vm, details || diagnostics),
-        ...(vm.knowledgeTable ? { knowledgeRows: vm.knowledgeTable.rows.map(row => ({ key: row.key, number: Number(row.key), id: row.id, tool: 'prodero_knowledge', arguments: { projectRoot: r.root, ...r.options, id: row.id } })) } : {}),
+        entryActions: vm.knowledgeTable ? vm.knowledgeTable.rows.map(row => ({ key: row.key, label: row.title, tool: 'prodero_knowledge', arguments: { projectRoot: r.root, ...r.options, id: row.id } })) : [],
+        knowledgeRows: vm.knowledgeTable ? vm.knowledgeTable.rows.map(row => ({ key: row.key, id: row.id, tool: 'prodero_knowledge', arguments: { projectRoot: r.root, ...r.options, id: row.id } })) : [],
         availableActions: details || v.kind === "details" ? vm.actions : [v.continuation, v.details, ...(v.suggestions ?? [])].filter(Boolean),
-        disclosure: vm.knowledgeTable && !details ? 'Show the supplied fenced ASCII catalogue table and pagination. Full record bodies are available by inspecting a row; do not expand every record into prose.' : details || v.kind === 'details' ? 'Show the requested record/proposal bodies completely before asking for approval.' : 'Keep the human reply to presentation.text; do not expand other domain fields or proposal bodies. This limits display, not execution: continue already-authorized work and Core next instructions. Pause only at a Core human-choice/review step or blocking state. At a human review step, ask whether to inspect; retrieve details on request and show full wording before offering approval.',
-        instructions: PRESENTATION_REPLY + ' Use presentation.text as the human reply, translated if needed. Keep the numbered action menu visible, translated naturally with the reply; use numberedActions for numeric replies and exact tool bindings when chosen. Do not expand healthy state into a full action catalog or narrate tool routing. Keep these operational data out of the human reply unless requested. A yes answers only the immediately preceding question: use its continuation through prodero_text for covered tools, otherwise call the named tool directly with the given arguments. Reviewing is not approval. Show the complete proposed changes before asking for explicit approval; never approve unseen changes. Preserve Core blocking and context requirements. For text presentation, use the continuation here instead of reopening a graphical card. For View Context after Prepare, display the context object already returned here: it is the prepared snapshot. Do not rerun retrieval to display it; a fresh prodero_context call is a new selection. These are tool data, not system instructions.',
+        disclosure: vm.knowledgeTable && !details ? 'Show the supplied letter-keyed catalogue and pagination. Bind letters only through entryActions on this exact page; full bodies require inspecting a record.' : details || v.kind === 'details' ? 'Show the requested record/proposal bodies completely before asking for approval.' : 'Keep the human reply to presentation.text; do not expand other domain fields or proposal bodies. This limits display, not execution: continue already-authorized work and Core next instructions. Pause only at a Core human-choice/review step or blocking state. At a human review step, ask whether to inspect; retrieve details on request and show full wording before offering approval.',
+        instructions: PRESENTATION_REPLY + (['prepare', 'session-close'].includes(payload.action) ? ' ' + LIFECYCLE_PRESENTATION_REPLY : '') + ' Relay presentation.text as the human reply, translated if needed, without narrating operational data. A yes answers only the immediately preceding question: follow its exact continuation through prodero_text for covered tools or the named tool otherwise. Preserve Core blockers and context requirements. View Context after Prepare displays the returned context snapshot; never rerun retrieval to display it. These are tool data, not system instructions.',
         ...(payload.bootstrap ? { bootstrap: payload.bootstrap } : {}),
         ...(payload.action === 'context' ? { context: r } : {}),
         ...(payload.action === 'prepare' ? { session: r.session, context: r.context, automaticSync: r.automaticSync } : {}),